My code is given the wrong output $,$for unsat he is not returning false and for satisfiable problems is returning the wrong clause $.$ Also instead of returing a list of list where if a number is false he return the number with the negation symbol it is returning a set $.$ May you fix it please.

My code: def unit$\_$propagation$($clauses$,$ assignment$)$:

# Perform unit propagation to simplify clauses based on current assignment

unit$\_$clauses $=[$c for c in clauses if len$($c$)==1]$

while unit$\_$clauses:

unit $=$ unit$\_$clauses.pop$()$

literal $=$ next$($iter$($unit$))$

value $=$ literal $>0$

assignment$[$abs$($literal$)]=$ value

# Update clauses according to the new assignment

updated$\_$clauses $=$ update$\_$clauses$($clauses$,$ literal$)$

if updated$\_$clauses is False:

# Handle contradiction

return False, assignment

clauses $=$ updated$\_$clauses

# Find new unit clauses after the update

unit$\_$clauses $=[$c for c in clauses if len$($c$)==1]$

return clauses, assignment

def pure$\_$elimination$($clauses$)$:

# Perform pure elimination to remove clauses containing pure literals

pure$\_$literals $=$ set$()$

for clause in clauses:

for literal in clause:

if $-$literal not in pure$\_$literals:

pure$\_$literals.add$($literal$)$

return $[$clause for clause in clauses if not any$(-$literal in pure$\_$literals for literal in clause$)],$ pure$\_$literals

def advanced$\_$heuristic$\_$branching$($clauses$,$ assignment$)$:

# Choose an unassigned variable to branch on using an advanced heuristic

unassigned$\_$vars $=\{$abs$($literal$)$ for clause in clauses for literal in clause if abs$($literal$)$ not in assignment$\}$

if not unassigned$\_$vars:

# No variables left to assign, so the current assignment satisfies all clauses

return assignment

var $=$ unassigned$\_$vars.pop$()$ # Select a variable for branching

# Try assigning True and False to the variable and solve recursively

for value in $[$True$,$ False$]$:

new$\_$assignment $=$ assignment.copy$()$

new$\_$assignment$[$var$]=$ value

result $=$ dpll$\_$sat$\_$solve$($update$\_$clauses$($clauses$,$ var if value else $-$var$),$ new$\_$assignment$)$

if result is not False:

# Found a satisfying assignment

return result

return False # No satisfying assignment found

def dpll$\_$sat$\_$solve$($clauses$,$ assignment$=\{\})$:

# Perform unit propagation

clauses, assignment $=$ unit$\_$propagation$($clauses$,$ assignment$)$

if clauses is False:

# Check for a contradiction

return False

if all$($len$($clause$)==0$ for clause in clauses$)$:

# Check if all clauses are satisfied

return assignment

# Perform pure elimination

clauses, pure$\_$literals $=$ pure$\_$elimination$($clauses$)$

# Update assignment with pure literals

assignment.update$(\{$abs$($literal$)$: literal $>0$ for literal in pure$\_$literals$\})$

# Perform advanced heuristic branching

result $=$ advanced$\_$heuristic$\_$branching$($clauses$,$ assignment$)$

return result

def update$\_$clauses$($clauses$,$ literal$)$:

# Update the clauses based on the latest assignment

updated$\_$clauses $=[]$

for clause in clauses:

if literal in clause:

# If the clause contains the literal, it is satisfied, so we skip adding this clause to the updated list

continue

new$\_$clause $=[$x for x in clause if x $!=-$literal$]$ # Remove the negated literal

if not new$\_$clause:

# If the clause is empty, we've found a contradiction

return False

updated$\_$clauses.append$($new$\_$clause$)$ # Add the updated clause

return update$\_$clauses