Implement "evaluate" so all tests pass:

class SATInstance:

# Constructor: provide n the number of variables and

# an initial list of clauses.

# Note that variable numbers will go from $1$ to n inclusive.

# we can add clauses using the add$\_$clause method.

def $\_\_$init$\_\_($self$,$ n$,$ clauses$)$:

self.n $=$ n

self.m $=$ len$($clauses$)$

self.clauses $=$ clauses

assert self.is$\_$valid$()$

# is$\_$valid

# Check if all clauses are correct.

# literals in each clause must be between $1$ and n or $-$n and $-1$

def is$\_$valid$($self$)$:

assert self.n $>=1$

assert self.m $>=0$

for c in self.clauses:

for l in c:

assert l and l self.n$)$ or $(-$self.n l and l

return True

# add$\_$clause

# Add a new clause to the list of clauses

def add$\_$clause$($self$,$ c$)$:

#check the clause we are adding.

for l in c:

assert l and l self.n$)$ or $(-$self.n and l

self.clauses.append$($c$)$

## Function: evaluate$\_$literal

# Evaluate a literal against a partial truth assignment

# return $0$ if the partial truth assignment does not have the variable corresponding to the literal

# return $1$ if the partial truth assignment has the variable and the literal is true

# return $-1$ if the partial truth assignment has the variable and the literal is false

def evaluate$\_$literal$($self$,$ partial$\_$truth$\_$assignment, literal$)$:

var $=$ abs$($literal$)$ # literal may be negated. First remove any negation using abs

if var not in partial$\_$truth$\_$assignment:

return $0$

v $=$ partial$\_$truth$\_$assignment$[$var$]$

if literal self.n:

return $1$ if v else $-1$

else:

return $-1$ if v else $1$

## TODO: Write your code here

# Function: evaluate

# See description above: partial$\_$truth$\_$assignment is a dictionary from $1..$ n to true$/$false$.$

# since it is partial, we may have variables with no truth assignments.

# use evaluate$\_$literal function as a useful primitive

# return $+1$ if the formula is already satisfied under partial$\_$truth$\_$assignment: i$.$e$,$ all clauses are true

# return $0$ if formula is indeterminate under partial$\_$truth$\_$assignment, all clauses are true or unresolved and at least one clause is unresolved.

# return $-1$ if formula is already violated under partial$\_$truth$\_$assignment, i$.$e$,$ at least one clause is false

def evaluate$($self$,$ partial$\_$truth$\_$assignment$)$:

# your code here

## BEGIN TESTS

print$(\text{'}-$test$1-\text{'})$

f$1=$ SATInstance$(4,[[1,2,-4],[-2,-3,1],[-1,-2,-3]])$

t$1=\{1$:True, $2$:False$\}$

e$1=$ f$1.$evaluate$($t$1)$

assert e$1==1,$ f'Expected that f$1$ is satisfied by t$1$ but your code returns: $\{$e$1\}\text{'}$

print$(\text{'}-$test$2-\text{'})$

t$2=\{1$:False, $2$: False$\}$

e$2=$ f$1.$evaluate$($t$2)$

assert e$2==0,$ f'Expected that f$1$ is indeterminate under t$2.$ Your code returns: $\{$e$2\}\text{'}$

print$(\text{'}-$test$3-\text{'})$

f$2=$ SATInstance$(5,[[1,2,-5],[-4,-2,-1],[1,3,5],[-1,-5,-2],[1,2,-4]])$

t$3=\{1$:True$\}$

e$3=$ f$2.$evaluate$($t$3)$

assert e$3==0,$ f'Expected that f$2$ is indeterminate under t$3.$ Your code returns $\{$e$3\}\text{'}$

print$(\text{'}-$test$4-\text{'})$

t$4=\{1$: True, $2$: False$\}$

e$4=$ f$2.$evaluate$($t$4)$

assert e$4==1,$ f'Expected that f$2$ is satisfied by t$4.$ Your code returns $\{$e$4\}\text{'}$

print$(\text{'}-$test$5-\text{'})$

t$5=\{1$: False, $3$: False, $5$:False$\}$

e$5=$ f$2.$evaluate$($t$5)$

assert e$5==-1,$ f'Expected that f$2$ is violated by t$5.$ Your code returns $\{$e$5\}\text{'}$

print$(\text{'}$All tests passed: $10$ points!$\text{'})$

## END TESTS