Built-in Module BOOL. Lecture Note 01a

Transcription

1 Built-in Module BOOL Lecture Note 01a

2 Topics! Built-in Boolean Algebra module BOOL and the equivalence of two boolean expressions (or SAT problems)! Study important concepts about CafeOBJ system through BOOL built-in module

3 Boolean data type in CafeOBJ! Boolean data type (or Boolean Algebra) is the most fundamental data type of CafeOBJ.! It defines propositional calculus which plays the central role in any logical argument. BOOL is the name of a CafeOBJ built-in module which defines Boolean Algebra. BOOL is set to be imported automatically to any module.

4 Signature of BOOL (ADJ diagram) _and_, _xor_, _or_, _implies_, _iff_ true, false Bool not_

5 Signature of BOOL (integral part) [ Bool ] -- two constants ops true false : -> Bool { constr } -- two implicit constructors for Boolean expressions with variables --- op _ and _ : Bool Bool -> Bool { assoc comm prec: 55 r-assoc } op _ xor _ : Bool Bool -> Bool { assoc comm prec: 57 r-assoc } op _ or _ : Bool Bool -> Bool { assoc comm prec: 59 r-assoc } op not _ : Bool -> Bool { strat: (0 1) prec: 53 } op _ implies _ : Bool Bool -> Bool { strat: (0 1 2) prec: 61 r-assoc } op _ iff _ : Bool Bool -> Bool { strat: (0 1 2) prec: 63 r-assoc } Key words inside braces ({ and }) declare attributes of each operator: constr -> constructor assoc -> associative comm -> commutative prec -> precedence r-assoc -> right associative strat -> strategy

6 Operator Attribute: constr (constructor) ops true false : -> Bool { constr } is same as op true : -> Bool { constr } op false : -> Bool { constr } Any term of a sort S is reduced to a term that is composed only of the constructors of the sort S. In current implementation of CafeOBJ, the constructor attribute does not affect the system behavior in any way; it is just comment.

7 Standard operator declaration -- An operator (a name of operation) is declared as standard or mixfix Standard Operator Declaration op and : Bool Bool -> Bool {assoc comm}. -- no _ symbols in standard operator! BOOL> red and(and(and(b1,b2),and(b3,b4)),b5). and(and(and(b1,b2),and(b3,b4)),b5) : Bool BOOL> red and(and(and(b1,b2),and(b3,b4)),b5) = and(and(b5,b3),and(and(b1,b4),b2)). true : Bool A standard way of writing function applications and terms! Little danger in parsing.

8 Mixfix operator declaration -- An operator (a name of operation) is declared as standard or mixfix Mixfix (infix) Operator Declaration -- op _and_ : Bool Bool -> Bool {assoc comm prec: 55 r-assoc} BOOL> red (((b1 and b2) and (b3 and b4)) and b5). b1 and b2 and b3 and b4 and b5 : Bool BOOL> red (((b1 and b2) and (b3 and b4)) and b5) = ((b5 and b3) and ((b1 and b4) and b2)). true : Bool Flexible in writing expressions. Much danger in parsing. Put parentheses properly; a good practice is put parentheses fully!

9 Operator Attributes: assoc (associative), comm (commutative) (1) op _and_ : Bool Bool -> Bool { assoc comm prec: 55 r-assoc } Attribute assoc declares that the operator _and_ satisfy an equation: vars A B C : Bool. eq (A and B) and C = A and (B and C). Attribute comm declares that the operator _and_ satisfy an equation: vars A B : Bool. eq A and B = B and A. This equation makes an infinite loop if used as a rewriting rule.

10 Operator Attributes: assoc (associative), comm (commutative) (2) Attributes assoc and comm together mean that order of arguments connected by _and_ operators does not affect the equivalence of two expressions. BOOL> open EQL - for using _=_ %EQL> ops b1 b2 b3 b4 b5 : -> Bool reduce in %EQL: (b1 and b2 and b3 and b4 and b5) = (b5 and b2 and b1 and b3 and b4) true : Bool

11 Operator Attributes for Parsing: prec (precedence) and r-assoc (right associative) (1) op _and_ : Bool Bool -> Bool { assoc comm prec: 55 r-assoc } op _xor_ : Bool Bool -> Bool { assoc comm prec: 57 r-assoc }! An operator of a higher precedence (an operator with a lower prec: number) binds tighter: that is, encloses its arguments with parentheses ( ( and ) ) first.! An operator with r-assoc is declared to associate to right.

12 Operator Attributes for Parsing: prec (precedence) and r-assoc (right associative) (2) BOOL> set verbose on BOOL> parse b1 xor b2 and b3 and b4 xor b5. (b1 xor ((b2 and (b3 and b4)) xor b5)) : Bool _xor_:bool / \ b1:bool _xor_:bool / \ _and_:bool b5:bool / \ b2:bool _and_:bool / \ b3:bool b4:bool

13 Default precedence of operators! Standard operators have precedence 0. Hence the term of the form f(a) connects strongest.! When an operator is mixfix, if the operator symbol does not start or end with ``_'', that is, no argument appears outside the term construct, the precedence is zero. An example is a singleton operator ``{_}'';! If it is a prefix unary operator, the precedence is 15. The unary ``-_'' offers an example;! Otherwise, the precedence is 41. (Description from the CafeOBJ Manual )

14 Default precedence of operators: Examples mod! MIXfix { [ Nat ] op 0 : -> Nat. -- 0: constant/standard op s _ : Nat -> Nat :prefix/mixfix op _! : Nat -> Nat :postfix/mixfix op _+_ : Nat Nat -> Nat. - 41:infix/mixfix } -- _! and _+_ have the precedence of s_ has the precedence of confirm this with the CafeOBJ system -- by using a command of describe op (_!) etc. Do not use precedence attribute without understanding well. Design simple and transparent syntax and put parentheses properly. Do not play with the parser of the system too much.

15 Axioms of BOOL (the integral part) vars A B C : Bool -- _and_ eq false and A = false. eq true and A = A. eq A and A = A. eq A and (B xor C) = (A and B) xor (A and C). -- _xor_ eq false xor A = A. eq A xor A = false. -- _or_ eq false or A = A. eq true or A = true. eq A or A = A. eq A or B = (A and B) xor A xor B. -- not_ eq not A = A xor true. -- _implies_ eq A implies B = (A and B) xor A xor true. -- _iff_ eq A iff B = A xor B xor true. Value Tables for Operators implied from the Axioms (true and true) = true (true and false) = false (false and false) = false (true xor true) = false (true xor false) = true (false xor false) = false (true or true) = true (true or false) = true (false or false) = false (not true) = false (not false) = true

16 Axioms for _and_ vars A B C : Bool. eq false and A = false. eq true and A = A. eq A and A = A. eq A and (B xor C) = (A and B) xor (A and C). Value Table for _and_ (true and true) = true (true and false) = false (false and true) = false (false and false) = false

17 Axioms for _xor_ var A : Bool. eq false xor A = A. eq A xor A = false. Value Table for _or_ (true xor true) = alse (true xor false) = true (false xor true) = true (false xor false) = false

18 Axioms for _or_ vars A B : Bool eq false or A = A. eq true or A = true. eq A or A = A. eq A or B = (A and B) xor A xor B. Value Table for _or_ (true or true) = true (true or false) = true (false or true) = true (false or false) = false

19 Axioms for not_ var A : Bool. eq not A = A xor true. Value Table for not_ (not true) = false (not false) = true

20 Axioms for not_implies_ var A B : Bool eq A implies B = (A and B) xor A xor true. Value Table for _implies_ (true implies true) = true (true implies false) = false (false implies true) = true (false implies false) = true

21 Axioms for_iff_ vars A B : Bool eq A iff B = A xor B xor true. Value Table for _or_ (true iff true) = true (true iff false) = false (false iff true) = false (false iff false) = true

22 Operator attribute: strat: (strategy) op not_ : Bool -> Bool { strat: (0 1) prec: 53 } op _implies_ : Bool Bool -> Bool { strat: (0 1 2) prec: 61 r-assoc } op _iff_ : Bool Bool -> Bool { strat: (0 1 2) prec: 63 r-assoc } The integer list after the key word strart: indicates the order in which the system try to reduce the term. 0 indicate the whole term with the specified operator on the top. i {1,2, <the number of argument>} indicates the term at the i-th argument. The number with minus sign indicates to delay the reduction until needed. You can find strategy of an operator by describe op <operator> command.

23 Default strategy of operators vars A B C : Bool. eq false and A = false. eq true and A = A. eq A and A = A. eq A and (B xor C) = (A and B) xor (A and C). The CafeOBJ system calculate the default strategy for each operator based on the equations for the operator. The principle for the calculation is reduce the argument needed to decide whether a term matches to a left hand side of the equations. The above set of equations suggest the strategy of ( ) for operator _and_, because _and_ is commutative, the final strategy is determined to be (1 2 0).

24 xor-and normal form of Boolean expressions (with variables) 1. By using the axioms (equations) of BOOL as rewriting rules, operators other than and and xor (i.e. or, not, implies, iff) are erased from Boolean expressions by keeping equivalence. 2. Any Boolean expression composed only with two operators of xor and and is reduced to (i.e. is equivalent to) the xor-and normal form by the equation: 3. X and (Y xor Z) = (X and Y) xor (X and Z). The module BOOL is designed to adopt exclusive-or (xor) normal forms for Boolean expressions (propositional expressions). That is, any Boolean expression is reduced to an expression containing only two kinds of boolean operators of xor and and.

25 xor-and normal form A Boolean expression is in xor-and normal form if it is expressed as: c 1 xor c 2 xor xor c m (if m=0 then false) without any dupulication of c i (i.e. c j = c k does not hold for any different j,k) and each c l (l=1 m) is expressed as: b l and b 2 and... and b n(l) (if n(l)=0 then true) for Boolean variables b i (i = 1 n(l)) without any duplication (i.e. b j =b k does not hold for any different j,k). Examples of terms in xor-and normal form b1 xor b2 and b3 and b4 xor b5 and b6 = (b1 xor ((b2 and (b3 and b4)) xor (b5 and b6))

26 Uniqueness of xor-and normal form (1) Any two Boolean expression are defined to be equivalent if they are equivalent as Boolean functions, i.e. the two expressions evaluate to the same value (true or false) for any assignment of Boolean values (true or false) to all Boolean variables in the expressions. Equations of BOOL define this equivalence of Boolean expressions.

27 Uniqueness of xor-and normal form (2) [xor-and uniqueness] Any two Boolean expressions in xor-and normal form are equivalent if and only if they are the same expression modulo assoc and comm of _xor_ and _and_.! Proof sketch) If part is trivial. For proving only if part, it is enough to show that for two different Boolean expressions e1 and e2 in xor-and normal form there is an assignment which makes (e1 iff e2) false. (e1 xor e2) can not be false because e1 and e2 are different. Therefore, by the following lemma, there is an assignment which makes (e1 xor e2) true and makes (e1 xor e2 xor true)=(e1 iff e2) false. [qed]

28 Lemma for [xor-and uniqueness] [Lemma] If the Boolean expression e in xor-and normal form is not false, there is an assignment which makes e true. Proof sketch) By induction w.r.t. the number n(e) of variables contained in the expression e. If n(e) is zero, then e should be true, and any assignment works. Let n(e) > 0 and e contain variable b1. (case 1) if e is of the form true xor e1, then make b1= false then the expression (true xor e1) [b1<-false] can not be false and contains smaller number of variables. (case 2) if e does not contain true, make b1=true then the expression e[b1<-true] can not be false and contains smaller number of variables. [qed]

29 BOOL provides a decision procedure for equivalance of boolean expressions Let exp1, exp2, and exp be any boolean expressions exp1:bool is equivalent to exp2:bool if and only if (red exp1 = exp2.) returns true if and only if (red exp1 iff exp2.) returns true BOOL can solve SAT problems exp:bool is satisfiable (there is at least one assignment which make exp true) if and only if (red exp.) does not return false

30 Examples of Equivalence %EQL> -- equivalence of two boolean expressions %EQL> red ((b1 implies b2) and (b2 implies b1)) = (b1 iff b2). -- reduce in %EQL : ((b1 implies b2) and (b2 implies b1)) = (b1 iff b2) true : Bool (0.000 sec for parse, 22 rewrites(0.000 sec), 178 matches) %EQL> red (not (b1 and b2)) = ((not b1) or (not b2)). -- reduce in %EQL : (not (b1 and b2)) = (not b1 or not b2) true : Bool (0.000 sec for parse, 11 rewrites(0.000 sec), 76 matches) %EQL> red (b1 implies b2) = ((not b1) or b2). -- reduce in %EQL : (b1 implies b2) = (not b1 or b2) true : Bool (0.000 sec for parse, 8 rewrites(0.000 sec), 57 matches)

31 Examples of Satisfiability %EQL> -- satisfiable boolean expressions red (b1 implies b2) iff (b1 iff b2). %EQL> -- reduce in %EQL : b1 implies b2 iff (b1 iff b2) b1 and b2 xor true xor b2 : Bool (0.000 sec for parse, 5 rewrites(0.000 sec), 28 matches) %EQL> red not((b1 implies b2) iff (b1 iff b2)). -- reduce in %EQL : not (b1 implies b2 iff (b1 iff b2)) b1 and b2 xor b2 : Bool (0.000 sec for parse, 8 rewrites(0.000 sec), 38 matches)