Recursion and Induction: Program Development; Variable Ordering - - PowerPoint PPT Presentation

Recursion and Induction: Program Development; Variable Ordering

Greg Plaxton Theory in Programming Practice, Fall 2005 Department of Computer Science University of Texas at Austin

Program Development

• Today we will develop a Haskell program for the satisfiability problem
• As discussed in the previous lecture, we will assume that the input is a

CNF formula – Such a formula is a conjunction of clauses – Each clause is a disjunction of literals – Each literal is either a variable or the negation of a variable

• Our implementation will use the Davis-Putnam procedure outlined last

time

Theory in Programming Practice, Plaxton, Fall 2005

Representation of a Formula

• Each variable will be represented by an arbitrary string
• Each literal will be represented by a string consisting of a ’+’ or ’-’

symbol followed by the associated variable name – The prefix ’+’ indicates a variable that is not negated – The prefix ’-’ indicates a negated variable

• A clause will be represented as a list of literals
• A formula will be represented as a list of clauses

Theory in Programming Practice, Plaxton, Fall 2005

Example of a Formula

• Consider the formula f equal to

(¬p ∨ q ∨ r) ∧ (p ∨ ¬r) ∧ (¬q ∨ r) ∧ (¬p ∨ ¬q ∨ ¬r) ∧ (p ∨ q ∨ r)

• We represent the formula f as follows

[ ["-p", "+q", "+r"], ["+p", "-r"], ["-q", "+r"], ["-p", "-q", "-r"], ["+p", "+q", "+r"] ]

Theory in Programming Practice, Plaxton, Fall 2005

Types

• In our previous examples we have allowed Haskell to deduce the types
• In this example we will show how to define the types explicitly
• We use the following type definitions

type Literal = String type Clause = [Literal] type Formula = [Clause]

Theory in Programming Practice, Plaxton, Fall 2005

Top-Down Design

• Let us define a function that accepts a formula as input and returns a

boolean indicating whether the formula is satisfiable

• If the formula is empty, then the result is True
• If it contains an empty clause, then the result is False
• Otherwise, we choose some literal of the formula, decompose the

formula into two subformulae based on this literal, solve each subformula recursively for satisfiability, and return True if either returns True

Theory in Programming Practice, Plaxton, Fall 2005

The Top-Level Function dp

• We define our top-level function dp as follows

dp :: Formula -> Bool dp xss | xss == [] = True | emptyin xss = False | otherwise = (dp yss) || (dp zss) where v = literal xss yss = reduce v xss zss = reduce (neg v) xss

• We have introduced a number of auxiliary functions that are discussed

in greater detail on the next slide

Theory in Programming Practice, Plaxton, Fall 2005

Functions used in dp

• emptyin xss: returns True if xss has an empty clause
• literal xss: returns a literal from xss, where xss is nonempty and

does not contain an empty clause

• neg v: returns the string corresponding to the negation of v
• reduce v xss, where v is a literal: returns the formula obtained from

xss by dropping any clause containing the literal v and dropping any

• ccurrence of the literal neg v in each remaining clause

Theory in Programming Practice, Plaxton, Fall 2005

The emptyin Function

• The code for emptyin is straightforward:
• - Does the formula contain an empty list?

emptyin :: Formula -> Bool emptyin [] = False emptyin ([]: xss) = True emptyin (xs: xss) = emptyin xss

Theory in Programming Practice, Plaxton, Fall 2005

The literal Function

• Function literal can return any literal from the formula
• It is easy to return the first literal of the first clause of its argument
• Since the formula is not empty and has no empty clause, this procedure

is valid {- Returns a literal from a formula. It returns the first literal of the first list. The list is not empty, and it does not contain an empty list.

• }

literal :: Formula -> Literal literal ((x: xs):xss) = x

Theory in Programming Practice, Plaxton, Fall 2005

The neg Function

• The neg function is easy to code:
• - negate a literal

neg :: Literal -> Literal neg (’+’: var) = ’-’: var neg (’-’: var) = ’+’: var

Theory in Programming Practice, Plaxton, Fall 2005

The reduce Function

• A call to reduce v xss scans through the clauses of xss
• If xss is empty, the result is the empty formula
• Otherwise, for each clause xs,

– If v appears in xs, drop the clause – If the negation of v appears in xs then modify xs by removing the negation of v – If neither of the above conditions hold, retain the clause

Theory in Programming Practice, Plaxton, Fall 2005

The reduce Function

• Here is the code for the reduce function:
• - reduce a literal through a formula

reduce :: Literal -> Formula -> Formula reduce v [] = [] reduce v (xs:xss) | inl v xs = reduce v xss | inl (neg v) xs = (remove (neg v) xs): (reduce v xss) | otherwise = xs : (reduce v xss)

Theory in Programming Practice, Plaxton, Fall 2005

Functions used in reduce

• Function reduce introduces two new functions, which will be developed

next – inl v xs, where v is a literal and xs is a clause: returns True iff v appears in xs – remove u xs, where u is a literal known to be in clause xs: return the clause obtained by removing u from xs.

Theory in Programming Practice, Plaxton, Fall 2005

The inl Function

• Here is the code for the inl function:
• - check if a literal is in a clause

inl :: Literal -> Clause -> Bool inl v [] = False inl v (x:xs) = (v == x) || (inl v xs)

Theory in Programming Practice, Plaxton, Fall 2005

The remove Function

• Here is the code for the remove function:
• - remove a literal u from clause xs. u is in xs.

remove :: Literal -> Clause -> Clause remove u (x:xs) | x == u = xs | otherwise = (x : (remove u xs))

Theory in Programming Practice, Plaxton, Fall 2005

Refining our Implementation

• Currently we scan a clause to find a given literal
• Suppose we impose an order on the variables/literals
• Then we could search more efficiently
• Furthermore, we get to choose which variable to eliminate

– Use the order imposed above to determine the order of elimination – When we eliminate a particular variable, it is guaranteed to be associated with the first literal of any clause in which it appears

Theory in Programming Practice, Plaxton, Fall 2005

The dp2 Function

• Function dp2, given below, does the job of dp, but it needs an

extra argument, like [ "p", "q" ,"r" ], which defines the variable

• rdering

dp2 vlist xss | xss == [] = True | emptyin xss = False | otherwise = (dp2 wlist yss) || (dp2 wlist zss) where v:wlist = vlist yss = reduce2 (’+’: v) xss zss = reduce2 (’-’: v) xss

• We no longer need the functions inl, remove, and literal

Theory in Programming Practice, Plaxton, Fall 2005

The reduce2 Function

• Here is the code for the reduce2 function:
• - reduce a literal through a formula

reduce2 :: Literal -> Formula -> Formula reduce2 w [] = [] reduce2 w ((x:xs):xss) | w == x = reduce2 w xss | (neg w) == x = xs: (reduce2 w xss) | otherwise = (x:xs): (reduce2 w xss)

Theory in Programming Practice, Plaxton, Fall 2005

A Further Improvement

• Note that reduce2 scans its argument list twice, once for w and again

for neg w

• We define reduce3 to scan the given list only once, checking for both

w and neg w simultaneously, and creating two lists reduce3 v [] = ([],[]) reduce3 v ((x:xs):xss) | ’+’: v == x = (yss , xs:zss) | ’-’: v == x = (xs:yss, zss ) | otherwise = ((x:xs):yss, (x:xs):zss) where (yss,zss) = reduce3 v xss

• Note that the interface to reduce3 is slightly different; also, we have

eliminated the use of function neg

Theory in Programming Practice, Plaxton, Fall 2005

The dp3 Function

• Here is the code for the dp3 function:

dp3 vlist xss | xss == [] = True | emptyin xss = False | otherwise = (dp3 wlist yss) || (dp3 wlist zss) where v:wlist = vlist (yss,zss) = reduce3 v xss

Theory in Programming Practice, Plaxton, Fall 2005