Computing Fundamentals 1 Equations and Reduction in CafeOBJ

1. Computing Fundamentals 1Equations and Reduction in CafeOBJ Lecturer: Patrick Browne Lecture Room: K308 Lab Room: A308

2. Why a specification language? • High level programming languages (HLP), like Python or Java, can be considered formal specifications. They specify what the machine should do. • However, HLP are not good at expressing our understanding of a domain. They are too low level and contain too much detail. Using HLP it is difficult to identify design errors, assumptions are not made explicit, they are implementation dependent. HLP focus on howsystem tasks are performed. They don’t allow us to reason aboutthe system or describe what the system does. • Domains of interest include: a theory of sets, a theory of integers, a theory of bank accounts, a theory of a hospital records, a theory of traffic flow.

3. Why a specification language? • CafeOBJ allows us to reason about what a system does rather than about the detailed algorithms . • CafeOBJ is based on rigorous mathematic (equational logic, a lattice of types, functions, equations, axioms, syntactic and semantic domains). This makes CafeOBJ useful for teaching mathematics. • CafeOBJ is executable. Even though it allows us to focus the what a program should do (i.e. specification), CafeOBJ also allows to run ‘specifications’ and produce results. Thus we can check our work (prototype) and get a result (compute). In sort we can: • Specify • Prototype • Reason and study proofs • Compute

4. Why a specification language? • CafeOBJ has conceptual semantics based on the logic of equations. • CafeOBJ has operational semantics based based on term rewriting. • These two interpretations are closely related. Usually we talk about syntactic 'terms' and semantic 'expressions'. • A good specification should be written in such a way that it can be used to predict how the system will behave.

5. Computing < Maths < World • The role of CafeOBJ on this course is to provide a functional and logic based language that can be used to represent the mathematical concepts such as logic, sets, and functions. Which in turn can be used to model real world systems

6. Predefined Modules1

7. CafeOBJ Equational Logic • Equational calculus derives (proves) a term equation from a conditional-equational axiom set. The deduction rules in this calculus are: • Reflexivity: Any term is provably equal to itself (t = t). • Transitivity: If t1is provably equal to t2andt2is provably equal to t3, then t1is provably equal to t3. • Symmetry: If t1is provably equal to t2, then t2is provably equal to t1. • Congruence: If t1is provably equal to t2, then any two terms are provably equal which consist of some context built around t1and t2. e.g. f(t1)=f(t2).

8. Writing equations in CafeOBJ • CafeOBJ statements are equations in which instances of the LHS pattern are replaced by corresponding instances of the RHS if the LHS matches the input expression. The matching process occurs "top-down, left-to-right.“ The first equation that matches is used. • The definition of a function can be broken into several equations, giving us a multi-line definition: e.g. • eq fact(0) = s(0) . • eq fact(s(N)) = s(N) * fact(N) . • Variables in CafeOBJ equations are universally quantified (∀N) equations Variables

9. Variables in CafeOBJ • Variables in CafeOBJ equations are universally quantified (∀N) equations • Terms with variables, are instantiated by substituting the variables with ground terms. • Here is an example from Jose Meseguer’s CC373 lecture notes.

10. Writing equations in CafeOBJ • In CafeOBJ computation is reduction of a well-formed term (or expression) to a normal form. An expression in normal form cannot be reduced any further. • An expression is a ground if it contains no variables. • If a term is normal form and is ground we say it is in ground normal form. • The ground normal form can be considered as a value. • Reduction can be viewed as a sequence of term rewrites, that treat the equation 0 + N = N as a left to right rewrite rule 0 + N -> N. This replaces (0 + N) with N. Reduction rewrites a term into a simpler form.

11. Writing equations in CafeOBJ • In general when writing equations we should follow the following rules: • The RHS should not be a single variable. • All variables in the RHS must appear in the LHS. • The scope of a constant is the module it is declared in (or a proof score or interactive session). • The scope of a variable is only inside of the equation. So, during evaluation a variable, say X, will have the same value in a given equation, but it may have different values in different equations in the same module.

12. Reducing an Expressionin CafeOBJ • An equation LHS=RHS is applicable to a given expression X, if we can substitute the variables occurring in some LHS with the values in expression X. This is also expressed as "LHS matches X“. Then we can replace X by Y, where Y is the expression obtained from RHS by replacing the variables occurring in LHS by their corresponding values. Such a replacement step a is called a reduction. For instance, given the equation and a reduction • eq sqr X = X*X . – A definition • red sqr 2 -- Reduction gives 2*2 = 4 • The expression sqr 2 matches the left-hand side sqr X, with 2 being substituted for the variable X.

13. Reduction • Reduction is a sequence of rewrites. • open BOOL . • red true and (not(false) or (not true)) • The diagram shows 4 rewrites CafeOBJ actually does 6 rewrites. >[1] rule: eq (not A:Bool) = (A xor true) { A:Bool |-> false } <[1] (not false):Bool --> (false xor true):Bool >[2] rule: eq (false xor A:Bool) = A { A:Bool |-> true } <[2] (false xor true):Bool --> (true):Bool >[3] rule: eq (not A:Bool) = (A xor true) { A:Bool |-> true } <[3] (not true):Bool --> (true xor true):Bool >[4] rule: eq (A:Bool xor A) = false { A:Bool |-> true } <[4] (true xor true):Bool --> (false):Bool >[5] rule: eq (false or A:Bool) = A { A:Bool |-> true } <[5] (true or false):Bool --> (true):Bool >[6] rule: eq (true and A:Bool) = A { A:Bool |-> true } <[6] (true and true):Bool --> (true):Bool

14. Reduction • Reduction with variables in term and result. Result is normal form, not ground. Uses rightmost-innermost reduction. • red T:Bool and ((not F:Bool) or (not T)) . • CafeOBJ uses 14 rewrites • We simplify to 4 • =R=> represents rewrite. Term-1 (not F) =R=> (F xor true) Term-2 (not T) =R=> (T xor true) Term-3 (T xor true) or (F xor true) =R=> ((T and F) xor true) Term-4 T and ((T xor true) or (F xor true)) =R=> ((F and T)xor T)

15. Reduction • Reduction with variables in term and ground normal form result. • open BOOL • red (a:Bool or (not a)) . • Gives: true • As an intermediate step: (not a) =R=> (a xor true)

16. Trace of Reduction (a ˅ ~a) • Because we have (a xor true) we can write: • red a:Bool or (a xor true) . • 1>[1] rule: eq (A or B) = ((A and B) xor (A xor B)) { A: |-> (a xor true), B |-> a } • 1<[1] (a or (a xor true)) --> (((a xor true) and a) xor ((a xor true) xor a)) • 1>[2] rule: eq (A and (B xor C)) = ((A and B) xor (A and C)){ A |-> a, B |-> true, C |-> a } • 1<[2] ((a xor true) and a) --> ((a and true) xor (a and a)) • 1>[3] rule: eq (true and A) = A { A |-> a } • 1<[3] (a and true) --> a • 1>[4] rule: eq (A and A) = A {A |-> a } • 1<[4] (a and a) --> a • 1>[5] rule: eq (A xor A) = false { A |-> a } • 1<[5] (a xor a) --> (false) • 1>[6] rule: eq (AC xor (A xor A))= (AC xor false) { AC |-> true, A |-> a } • 1<[6] ((a xor true) xor a)--> (true xor false)

17. Reduction(a ˅ ~a) • 1>[7] rule: eq (false xor A) = A { A |-> true } • 1<[7] (true xor false) --> (true) • 1>[8] rule: eq (false xor A) = A { A |-> true } • 1<[8] (false xor true) --> (true) • (true):Bool • Everywhere you see rule: it means that the reduction found a matching equation in the BOOL module. • The square brackets indicate the rule number in the this particular reduction [1]..[8] • The grater-than sign > indicates starting a rewrite with the curled brackets {} showing a substitution. • The variables in capitals are from the BOOL module. • The less-than sign < indicates ending a rewrite replacing the LHS with the RHS. • Using the commutativity property, the system may changed the order of the arguments. • The commutative rule is applied.

18. Automatic Theorem Proving The CafeOBJ environment includes automatic theorem proving (ATP) software. The ATP will try to show that some statements (often called a conjecture, goal, conclusion) is a logical consequence of a set of statements (often called hypothesis, assumptions or axioms). The ATP in CafeOBJ is based on (Prover9). Most of the logic problems on this course use the ATP. We set up problems such as Portia, Superman, and Family using a different1 logical notation than the normal CafeOBJ equations.

19. Automatic Theorem Proving The basic steps in our examples are: • Declare some predicates (sister). • Define the axioms using the logical notation1 (-> , <->, |, &, ~, ax) • Write the conjecture to be proved (goal). • If the ATP can prove a goal we can examine the proof. We may compare it to other proof methods such as ordinary reduction, truth table, or a manual proof.

20. Half-Adder eq halfAdder(x,y) = pair(x xor y, x and y) . eq sum(pair(x,y)) = x . eq carry(pair(x,y)) = y . red halfAdder(true,true) . red sum(halfAdder(true,true)) . red carry(halfAdder(true,true)) .

21. Full-adder fullAdder(A,B,C-IN) = pair(sum.., carry.. OR carry) http://www.doctronics.co.uk/4008.htm • Will need nested functions e.g. sum(HA(sum(HA(A,B)),C-IN))

22. Checking Signatures

23. Equivalence Class • Let r be an equivalence relation on B. Then [b]r , the equivalence class of b, is the subset of elements of B that are equivalent (under r) to b. The equivalence classes of an equivalence relation R partition the set A into disjoint nonempty subsets whose union is the entire set. CafeOBJ reduction can show [s s 0]. • red s s 0 == s 0 + s 0 .

24. Equivalence Class

25. mod! NATURAL { [Natural] op 0 : -> Natural op _+_ : Natural Natural -> Natural ops (s_) (p_) : Natural -> Natural vars M N : Natural eq s p N = N . eq p s N = N . eq N + 0 = N . eq N + s M = s (N + M) .}