Optmize my code please, and if you could implement a fuction to return the answer in list of lis intead of dictionary $.$ Here is my code :

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

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

while unit$\_$clauses:

unit $=$ unit$\_$clauses.pop$()$ # Take one unit clause

literal $=$ next$($iter$($unit$))$ # Get the literal from the unit clause

value $=$ literal $>0$ # Determine the value to satisfy the clause

assignment$[$abs$($literal$)]=$ value # Assign the value

# Update clauses according to the new assignment

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

# Check if clauses is False

if clauses is False:

return False, assignment # Return False and the current assignment

# Find new unit clauses after the update

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

return clauses, assignment

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

updated$\_$clauses $=[]$

for clause in clauses:

if literal in clause: # If the clause contains the literal, it is satisfied

continue # So$,$ we skip adding this clause to the updated list

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 updated$\_$clauses

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

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

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

# Choose an unassigned variable to branch on

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 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