Ciao a tutti, ho una domanda piuttosto difficile per voi, e con difficile intendo che non mi servono risposte banali ma solo cose veramente astute.
Data una formula ben formata della logica proposizionale F, mi servirebbe qualche consiglio per un algoritmo che applichi a F la proprietà distributiva rispetto alla disgiunzione (or).
Ecco degli esempi:
Expr f: (*1 | (*2 & *3))
Applico distr f: ((*1 | *2) & (*1 | *3))
Expr f: ((*4 & !*5) | (*2 & !*3))
Applico distr f: ((*4 | *2) & (*4 | !*3) & (!*5 | *2) & (!*5 | !*3))
Expr f: ((*4 & !*5) | (*2 & !*3) | (*7 & !*8))
Applico distr f: ((*7 | *4 | *2) & (*7 | *4 | !*3) & (*7 | !*5 | *2) & (*7 | !*5 | !*3) & (!*8 | *4 | *2) & (!*8 | *4 | !*3) & (!*8 | !*5 | *2) & (!*8 | !*5 | !*3))
Expr f: (*1 | *4 | (*2 & *3))
Applico distr f: ((*1 | *4 | *2) & (*1 | *4 | *3))
Expr f: (*1 | *4 | (*2 & *3) | (*4 & *5) | (*6 & *7))
Applico distr f: ((*1 | *4 | *2 | *4 | *6) & (*1 | *4 | *2 | *4 | *7) & (*1 | *4 | *2 | *5 | *6) & (*1 | *4 | *2 | *5 | *7) & (*1 | *4 | *3 | *4 | *6) & (*1 | *4 | *3 | *4 | *7) & (*1 | *4 | *3 | *5 | *6) & (*1 | *4 | *3 | *5 | *7))
Expr f: (*1 | (*2 & *3) | (*5 & *6))
Applico distr f: ((*5 | *1 | *2) & (*5 | *1 | *3) & (*6 | *1 | *2) & (*6 | *1 | *3))
Expr f: ((*1 & *2) | (*3 & *4) | (*5 & *6))
Applico distr f: ((*5 | *1 | *3) & (*5 | *1 | *4) & (*5 | *2 | *3) & (*5 | *2 | *4) & (*6 | *1 | *3) & (*6 | *1 | *4) & (*6 | *2 | *3) & (*6 | *2 | *4))
Concludendo, specifico che (come si può notare dagli esempi che appunto sono l'output di un programma) una funzione che implementi l'applicazione della proprietà distributiva l'ho scritta, ma dato l'utilizzo che ne devo fare (su formule decisamente ENORMI), me ne serve una versione in cui l'efficienza sia un requisito fondamentale!!!
un grazie infinito a chi ha la bontà di suggerire qualcosa!
|