Working with Logical Formulas

Boolean Logic

Appendix B.1 Normal Forms for Boolean Logic • A literal in a Boolean formula is an atomic proposition or an atomic proposition preceded by a :

P Q P

• A positive literal is a literal with no . • A negative literal is a literal with a .

• A clause is a single literal or the disjunction of two or more literals:

P P  P P  Q  R  S are clauses. (Q  R) P  Q  R are not. Conjunctive Normal Form

A Boolean wff is in conjunctive normal form iff it is: •a single clause, or •the conjunction of two or more clauses.

In conjunctive normal form: •P •P  Q  R  S •(P  Q  R  S)  (P  R)

Not in conjunctive normal form: •P  Q •(P  Q) •(P  Q  R  S)  (P  R) Conjunctive Normal Form Theorem

Theorem: Any Boolean wff can be converted to conjunctive normal form.

Proof: By construction: Conjunctive Normal Form Theorem conjunctiveBoolean(w: wff of Boolean logic) = 1. Eliminate  and  from w, using:  P  Q  P  Q.

2. Reduce the scope of each  to a single term, using:  Double negation: (P) = P.

 deMorgan’s laws: (P  Q)  (P  Q). (P  Q)  (P  Q).

3. Convert w to a conjunction of clauses using:  Both  and  are associative   and  distribute over each other. Example of the Conversion

Let w = P  (R  Q).

• Step 1 produces P  (R  Q).

• Step 2 produces P  (R  Q).

• Step 3 produces (P  R)  (P  Q). But Exponential Growth is Possible

For every Boolean wff w there exists an equivalent CNF wff w. But the maximum length of w grows exponentially in |w|.

Example:

Let w = (X1  Y1)  (X2  Y2)  (X3  Y3)  …  (Xn  Yn).

The output of conjunctiveBoolean on input w will have 2n clauses. 3-CNF

A Boolean wff is in 3-conjunctive normal form (3-CNF) iff it is in CNF and each clause contains exactly three literals.

These wffs are in 3-CNF:

• (Q  R  S). • (Q  R  S)  (P  R  Q).

These are not:

• (Q  R ). • (Q  R  S)  (P  R  Q  S). 3-CNF Theorem: Given a Boolean wff w in CNF, there exists an algorithm that constructs w so that:

• w is in 3-CNF and • w is satisfiable iff w is.

Proof: By construction: 3-CNF 3-conjunctiveBoolean(w: wff of Boolean logic) = 1.If, in w, there are any clauses with n > 3 literals, of the following form:

(l1  l2  l3  …  ln),

then introduce Z1 - Zn-3 that do not otherwise occur in w and replace the clause with:

(l1  l2  Z1)  (Z1  l3  Z2)  …  (Zn-3  ln-1  ln)

2.If there is any clause with only one or two literals, replicate one of those literals once or twice so that there is a total of three literals in the clause. A 3-CNF Example

(P  R)  (P  Q  R  S) Disjunctive Normal Form A Boolean wff is in disjunctive normal form (DNF) iff it is the disjunction of one or more disjuncts, each of which is a single literal or the conjunction of two or more literals.

These wffs are in DNF:

• P • P  Q  R  S • (P  Q  R  S)  (P  R)

This is not:

• (P  Q  R  S)  (P  R)

Disjunctive normal form is the basis for a convenient notation for writing queries against relational databases. Disjunctive Normal Form Theorem

Theorem: Any Boolean wff can be converted to disjunctive normal form.

Proof: By construction: Disjunctive Normal Form Theorem disjunctiveBoolean(w: wff of Boolean logic) = 1. Eliminate  and  from w, using:  P  Q  P  Q.

2. Reduce the scope of each  to a single term, using:  Double negation: (P) = P.

 deMorgan’s laws: (P  Q)  (P  Q). (P  Q)  (P  Q).

3. Convert w to a disjunction of disjuncts using:  both  and  are associative, and   and  distribute over each other. Boolean Resolution

Two of the most important operations on Boolean formulas are:

• Satisfiability checking: given a wff ST, is it satisfiable or not? • Theorem proving: given a set of axioms A and a wff ST, does A entail ST?

A entails ST iff A  ST is unsatisfiable.

So satisfiability is key. Resolution – the Inference Rule

Resolution: From : (P  Q) and (R  Q), Conclude: (P  R).

• If Q is True, R must be True. • If Q is True, P must be True. Examples

Suppose we know:

winter  summer winter summer summer nil

winter  summer winter  cold summer  cold Resolution – the Algorithm

A resolution proof is a proof by contradiction (often called refutation).

To use resolution to prove ST, given a set of axioms A: • Demonstrate that A  ST is unsatisfiable. • If ST cannot be true given A, ST must be. Resolution – Before It Begins

To prove ST from A:

1. Convert the axioms in A to a list of clauses: 1. Convert each formula in A to CNF. 2. Build L, a list of the clauses that are constructed in step 1.2.

2. Consider ST: 1. Construct the formula ST. 2. Convert it to CNF. 3. Add all of the resulting clauses to L. An Example

Given Axioms: Converted to CNF: P P (P  Q)  R P  Q  R (S  T)  Q (S  Q)  (T  Q) T T

Then the list L of clauses constructed in this process is: P P  Q  R S  Q T  Q T Complementary Literals

A pair of complementary literals is a pair of literals that are not mutually satisfiable. So two literals are complementary iff one is positive, one is negative, and they contain the same propositional symbol. Example: Q and Q are complementary literals.

Two clauses C1 and C2 contain a pair of complementary literals iff C1 contains one element of the pair and C2 contains the other. Example: (P  Q  R) and (T  Q) Resolving Two Parent Clauses

Given:C1 = R1  R2  …  Rj  Q, and C2 = S1  S2  …  Sk  Q,

Resolution (the inference rule) allows us to conclude:

R1  R2  …  Rj  S1  S2  …  Sk.

When we apply the resolution rule in this way, we’ll say that we have resolved the parents, C1 and C2, to generate a new clause, which we’ll call the resolvent. Resolution – Generating nil

Consider:

Q Q

nil

The empty clause is unsatisfiable since it contains no literals that can be made True. So, if it is ever generated, the resolution procedure halts and reports that, since adding ST to A has led to a contradiction, ST is a theorem given A. The Resolution Algorithm resolve-Boolean(A, ST) = 1. Construct L, the list of clauses from A. 2. Negate ST, convert the result to conjunctive normal form, and add the resulting clauses to L. 3. Until either the empty clause (nil) is generated or no progress is being made do: 1. Choose a pair of parent clauses from L. 2. Resolve the parent clauses together. If the resolvent is not nil and is not in L, add it to L. 4. If nil was generated, a contradiction has been found. Return success. ST must be true. 5. If nil was not generated and there was nothing left to do, return failure. A Resolution Example

Prove R from:

Given Axioms: Generate the Clauses: P P (P  Q)  R P  Q  R (S  T)  Q S  Q T  Q T T

Negate R. The result is already in conjunctive normal form, so we simply add it to the list of clauses:

R Using Resolution to Prove R P  Q  R  R P P  Q  R S  Q P  Q P T  Q T  R T  Q Q

T T

nil Only Select One Pair to Resolve

P  Q (1) P  Q  R (2)

Prove R:

P  Q  R R

P  Q P  Q

? nil

But is R entailed by the two facts we have been given? Properties of Resolution

Resolution is:

• Sound • Refutation complete • But it cannot get around the fact that SAT is NP-complete. Efficient SAT Solvers

Efficient SAT solvers play an important role in:

• Design and analysis of digital circuits • Model checking to verify properties of programs • Planning algorithms for robots Boolean Formulas

Think of a Boolean formula as a function of its inputs. We can represent a function f as a truth table.

Example: f(x1, x2, x3) = (x1  x2)  x3

x1 x2 x3 f1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 1 1 1 0 0 0 1 0 1 1 1 1 0 0 1 1 1 1 Binary Decision Trees f(x1, x2, x3) = (x1  x2)  x3

Choose the variable ordering (x1 < x2 < x3): The Size of the Representation

Let n be the length of f. Using either technique, the size of the representation of f grows as:

Can we do better? Ordered Binary Decision Diagrams

Key idea 1: No subtree need occur more than once.

The (0, 1) subtree occurs three times. OBDDs OBDDs

Key idea 2: Get rid of irrelevant nodes.

The two circled nodes are irrelevant. OBDDs createOBDD createOBDDfromtree(d: ordered binary decision tree) = 1. Eliminate redundant terminal nodes by creating a single node for each label and redirecting edges as necessary. 2. Until one pass is made during which no reductions occurred do: 1. Eliminate redundant nonterminal nodes. 2. Eliminate redundant tests by erasing any node whose two output edges go to the same place. Redirect edges as necessary. Functions on OBDDs

• Computing validity:

• Computing satisfiability: Functions on OBDDs

• Computing validity:

1

• Computing satisfiability: Functions on OBDDs

• Computing validity:

1

• Computing satisfiability:

0 Using OBDDs

• It is possible to build OBDDs directly, without first building an unreduced tree.

• So model checkers based on OBDDs can be used to prove properties of systems with state descriptions containing 1020 states.

• Variable ordering may matter. One Variable Ordering Another One