Write a effective recursive Python function dpll sat solve that takes two arguments clause setand partial assignment as input and solves the satisfiability of the clause set under the partial assignment by applying unit propagation before branching on the two truth assignmentsfor a given variable $($this is the famous DPLL algorithm but without pure literal elimination$).$In case the clause set is satisfiable under the partial assignment it should output a full satisfyingassignment; if it is not satisfiable the function should return False. When the function is run with an empty partial assignment it should act as a SAT$-$solver.

this is my code, can you optimze it further? Some optimization you may consider are : Clause learning $($conflict analysis$)$ but needs to be recursive

More advanced variable selection heuristics

Data structures optimized for frequent clause operations $($e$.$g$.,$ watched literals$)$

def dpll$\_$sat$\_$solve$($clause$\_$set, partial$\_$assignment$=$None$)$:

if partial$\_$assignment is None:

partial$\_$assignment $=\{\}$

# Unit propagation

clause$\_$set $=\_$unit$\_$propagate$($clause$\_$set, partial$\_$assignment.copy$())$

if not clause$\_$set:

return partial$\_$assignment # All clauses are satisfied

# Check for empty clause after unit propagation $($UNSAT$)$

for clause in clause$\_$set:

if not clause:

return False

# Choose a variable to branch on $($heuristics can be applied here$)$

unassigned$\_$vars $=[$var for var in set.union$(*$clause$\_$set$)$ if var not in partial$\_$assignment$]$

var $=$ unassigned$\_$vars$[0]$ # Simple heuristic: choose the first unassigned variable

# Try both truth assignments for the chosen variable

result $=$ dpll$\_$sat$\_$solve$($clause$\_$set.copy$(),$ dict$($partial$\_$assignment, $**\{$var: True$\}))$

if result:

return result

result $=$ dpll$\_$sat$\_$solve$($clause$\_$set.copy$(),$ dict$($partial$\_$assignment, $**\{$var: False$\}))$

return result

def $\_$unit$\_$propagate$($clause$\_$set, partial$\_$assignment$)$:

simplified$\_$clauses $=[]$

for clause in clause$\_$set:

# Check for unit clauses $($only one unassigned literal$)$

unassigned$\_$literals $=[$lit for lit in clause if lit not in partial$\_$assignment$]$

if len$($unassigned$\_$literals$)==1$:

literal $=$ unassigned$\_$literals$[0]$

# Imply the assignment based on the remaining literal

partial$\_$assignment$[$literal$]=$ not literal.startswith$("-")$

else:

simplified$\_$clauses.append$($clause$)$

# Return the simplified clause set after removing unit clauses

return simplified$\_$clauses