Boolesk algebra. En abstype för booleska uttryck

Transkript

1 Boolesk algebra Boolesk algebra är en algebra där man räknar med sanningsvärden istället för tal, dvs värdena sant (T) och falskt (F). Räknesätten kallas för konnektiv. De konnektiv vi tittar på här är: A, icke-a, är sant om A är falskt och vice versa. Kallas även negation. A B, A och B, är sant om både A och B är sanna, men falskt annars. Kallas även konjunktion. A B, A eller B, är sant om minst en av A och B är sanna, och falsk annars. Kallas även disjunktion. A B, A implicerar B. Sant om antingen: A är falsk A är sann, och B är sann Falsk annars. Kallas även implikation. A B, A är ekvivalent med B. Är sant om både A och B har samma sanningsvärde. Några exempel: T F =T T F = F =T A A =T, där A betecknar ett godtyckligt uttryck. Varför är det alltid sant oavsett A? En abstype för booleska uttryck En abstrakt datatyp boolexp för att representera booleska uttryck enligt ovan i SML följer här nedan. Uppgiften består i att, givet den abstrakta datatypen, skriva en funktion som har följande specifikation: (* truthvalue(e,f) TYPE: boolexp * (string -> bool) -> bool PRE: f är väldefinierad för alla variabelnamn i e POST: Sanningsvärdet av uttrycket e, där f definierar sanningsvärdet av alla variabler i e, så att variabeln v har sanningsvärde f(v). *) Funktionen truthvalue ska ligga utanför den abstrakta datatypen, dvs den har inte direkt tillgång till datarepresentationen utan måste använda sig av gränssnittsfunktionerna. av Johannes Åman Pohjola 1/5 ingen copyright inga licenser allt tillhör alla

2 (* REPRESENTATION CONVENTION: Representerar olika sorters booleska uttryck. TExp representerar uttrycket "sant" FExp representerar uttrycket "falskt" VARExp representerar variabeluttryck NOTExp representerar negationsuttryck ORExp representerar ett disjunktionsuttryck ANDExp representerar ett konjunktionsuttryck IMPExp representerar ett implikationsuttryck IFFExp representerar ett ekvivalensuttryck REPRESENTATION INVARIANT: - *) datatype exptype = TExp FExp VARExp NOTExp ORExp ANDExp IMPExp IFFExp (* REPRESENTATION CONVENTION: Representerar ett booleskt uttryckt. T representerar sant F representerar falskt VAR(s) representerar sanningsvärdet av variabeln s NOT(e) representerar "icke-e" OR(e1,e2) representerar uttrycket "e1 eller e2" AND(e1,e2) representerar uttrycket "e1 och e2" IMP(e1,e2) representerar uttrycket "e1 implicerar e2" IFF(e1,e2) representerar uttrycket "e1 om och endast om e2" REPRESENTATION INVARIANT: - *) abstype boolexp = T F VAR of string NOT of boolexp OR of boolexp*boolexp AND of boolexp*boolexp IMP of boolexp*boolexp IFF of boolexp*boolexp with (* maketrue() TYPE: unit -> boolexp POST: Ett uttryck som alltid är sant *) fun maketrue() = T av Johannes Åman Pohjola 2/5 ingen copyright inga licenser allt tillhör alla

3 (* maketrue() TYPE: unit -> boolexp POST: Ett uttryck som alltid är sant *) fun makefalse() = F (* makevar(s) TYPE: string -> boolexp POST: Ett uttryck för sanningsvärdet av variablen s *) fun makevar(s) = VAR(s) (* makenot(e) Exp POST: icke-e *) fun makenot(e) = NOT(e) (* makeor(e1,e2) POST: Uttrycket "e1 eller e2" *) fun makeor(e1,e2) = OR(e1,e2) (* makeand(e1,e2) POST: Uttrycket "e1 och e2" *) fun makeand(e1,e2) = AND(e1,e2) (* makeimp(e1,e2) POST: Uttrycket "e1 implicerar e2" *) fun makeimp(e1,e2) = IMP(e1,e2) (* makeiff(e1,e2) POST: Uttrycket "e1 om och endast om e2" *) fun makeiff(e1,e2) = IFF(e1,e2) (* makeiff(e1,e2) POST: Uttrycket "e1 om och endast om e2" *) fun makeiff(e1,e2) = IFF(e1,e2) (* istrue(e) POST: true omm e är uttrycket "sant" *) fun istrue(e) = e = T (* isfalse(e) POST: true omm e är uttrycket "falskt" *) fun isfalse(e) = e = F av Johannes Åman Pohjola 3/5 ingen copyright inga licenser allt tillhör alla

4 (* isvar(e) POST: true omm e är ett variabeluttryck *) fun isvar(var _) = true isvar _ = false (* isor(e) POST: true omm e är en disjunktion *) fun isor(or _) = true isor _ = false (* isand(e) POST: true omm e är en konjunktion *) fun isand(and _) = true isand _ = false (* isnot(e) POST: true omm e är en negation *) fun isnot(not _) = true isnot _ = false (* isimp(e) POST: true omm e är ett implikationsuttryck *) fun isimp(imp _) = true isimp _ = false (* isiff(e) POST: true omm e är ett ekvivalensuttryck *) fun isiff(iff _) = true isiff _ = false (* gettype(e) TYPE: boolexp -> exptype POST: Den sorts uttryck som e är *) fun gettype T = TExp gettype F = FExp gettype(var _) = VARExp gettype(or _) = ORExp gettype(and _) = ANDExp gettype(imp _) = IMPExp gettype(iff _) = IFFExp gettype(not _) = NOTExp (* getvar(e) TYPE: boolexp -> string option POST: Variabelns namn, om e är ett variabeluttryck. av Johannes Åman Pohjola 4/5 ingen copyright inga licenser allt tillhör alla

5 end NONE annars. *) fun getvar(var s) = SOME s getvar _ = NONE (* getnot(e) Exp option POST: Negationen av e, om e är ett negationsuttryck. NONE annars. *) fun getnot(not e) = SOME e getnot _ = NONE (* getleft(e) Exp option POST: e:s vänsterled om e är ett konnektiv, NONE annars. *) fun getleft(or(l,_)) = SOME l getleft(and(l,_)) = SOME l getleft(imp(l,_)) = SOME l getleft(iff(l,_)) = SOME l getleft _ = NONE (* getright(e) Exp option POST: e:s högerled om e är ett konnektiv, NONE annars. *) fun getright(or(_,r)) = SOME r getright(and(_,r)) = SOME r getright(imp(_,r)) = SOME r getright(iff(_,r)) = SOME r getright _ = NONE (* compare(e1,e2) TYPE: boolexp * boolexp -> bool POST: true omm e1 och e2 är exakt samma uttryck *) fun compare(e1:boolexp,e2) = e1 = e2 av Johannes Åman Pohjola 5/5 ingen copyright inga licenser allt tillhör alla