modify my code such that the truth table algorithm can work with the general knowledge base like for example this

TELL

$($a $<=>($c $=>$ ~d$))$ & b & $($b $=>$ a$)$; c; ~f $||$ g;

ASK

~d & $($~g $=>$ ~f$)$

import re

import itertools

# Function to replace logical operators

def replace$\_$operators$($expr$)$:

# Replace biconditional operators

expr $=$ re$.$sub$($r$\text{'}(\backslash$w$+)\backslash$s$*<=>\backslash$s$*(\backslash$w$+)\text{'},$ r$\text{'}((\backslash 1$ and $\backslash 2)$ or $($not $\backslash 1$ and not $\backslash 2))\text{'},$ expr$)$

# Replace implications

expr $=$ re$.$sub$($r$\text{'}(\backslash$w$+)\backslash$s$*=>\backslash$s$*(\backslash$w$+)\text{'},$ r$\text{'}($not $\backslash 1$ or $\backslash 2)\text{'},$ expr$)$

return expr

# Function to preprocess logical expressions

def preprocess$\_$expression$($expr$)$:

expr $=$ replace$\_$operators$($expr$)$

expr $=$ expr.replace$(\text{'}$~$\text{'},\text{'}$ not $\text{'})$

expr $=$ expr.replace$(\text{'}$&$\text{'},\text{'}$ and $\text{'})$

expr $=$ expr.replace$(\text{'}||\text{'},\text{'}$ or $\text{'})$

return expr

# Function to evaluate logical expressions

def eval$\_$expression$($preprocessed$\_$expr, truth$\_$assignment$)$:

try:

# Ensure all variables are present in the truth assignment

for var in re$.$findall$($r$\text{'}\backslash$b$\backslash$w$+\backslash$b$\text{'},$ preprocessed$\_$expr$)$:

if var not in truth$\_$assignment:

truth$\_$assignment$[$var$]=$ False

return eval$($preprocessed$\_$expr, $\{"\_\_$builtins$\_\_"$: None$\},$ truth$\_$assignment$)$

except Exception as e:

print$($f$"$Error evaluating expression $\text{'}\{$preprocessed$\_$expr$\}\text{'}$: $\{$e$\}")$

return False

# Function to parse propositions from the knowledge base and query separately

def parse$\_$propositions$($expr$)$:

return set$($re$.$findall$($r$\text{'}\backslash$b$\backslash$w$+\backslash$b$\text{'},$ expr$))$

# Truth Table Enumeration algorithm

def tt$\_$entails$($kb$,$ alpha$)$:

kb$\_$props $=$ list$($parse$\_$propositions$($kb$))$

alpha$\_$props $=$ list$($parse$\_$propositions$($alpha$))$

all$\_$props $=$ list$($set$($kb$\_$props $+$ alpha$\_$props$))$

print$("$Propositions:$",$ all$\_$props$)$

return tt$\_$check$\_$all$($kb$,$ alpha, all$\_$props, $\{\})$

def tt$\_$check$\_$all$($kb$,$ alpha, symbols, model$)$:

if not symbols:

if pl$\_$true$($kb$,$ model$)$:

return pl$\_$true$($alpha$,$ model$)$

else:

return True

else:

p$,$ rest $=$ symbols$[0],$ symbols$[1$:$]$

return $($tt$\_$check$\_$all$($kb$,$ alpha, rest, extend$($model$,$ p$,$ True$))$ and

tt$\_$check$\_$all$($kb$,$ alpha, rest, extend$($model$,$ p$,$ False$)))$

def extend$($model$,$ p$,$ value$)$:

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

new$\_$model$[$p$]=$ value

return new$\_$model

def pl$\_$true$($kb$,$ model$)$:

clauses $=[$clause$.$strip$()$ for clause in kb$.$split$(\text{'}$;$\text{'})$ if clause.strip$()]$

#print$("$Evaluating KB with model:", model$)$

for clause in clauses:

preprocessed$\_$clause $=$ preprocess$\_$expression$($clause$)$

if not eval$\_$expression$($preprocessed$\_$clause, model$)$:

#print$($f$"$Clause $\text{'}\{$clause$\}\text{'}$ is false in model $\{$model$\}")$

return False

#print$("$KB is true in model", model$)$

return True

# Modified TT algorithm to count the models

def tt$\_$entails$\_$with$\_$count$($kb$,$ alpha$)$:

kb$\_$props $=$ list$($parse$\_$propositions$($kb$))$

alpha$\_$props $=$ list$($parse$\_$propositions$($alpha$))$

all$\_$props $=$ list$($set$($kb$\_$props $+$ alpha$\_$props$))$

num$\_$models $=0$

num$\_$valid$\_$models $=0$

for values in itertools.product$([$True$,$ False$],$ repeat$=$len$($kb$\_$props$))$:

model $=$ dict$($zip$($kb$\_$props, values$))$

#print$("$Evaluating model:", model$)$

kb$\_$true $=$ pl$\_$true$($kb$,$ model$)$

#print$("$KB is$",$ "true" if kb$\_$true else "false", "for model:", model$)$

if kb$\_$true:

num$\_$models $+=1$

alpha$\_$true $=$ eval$\_$expression$($preprocess$\_$expression$($alpha$),$ model$)$

#print$("$Query is$",$ "true" if alpha$\_$true else "false", "for model:", model$)$

if alpha$\_$true:

num$\_$valid$\_$models $+=1$

#print$($f$"$Final count of valid models: $\{$num$\_$valid$\_$models$\}$ out of $\{$num$\_$models$\}$ models evaluated."$)$

return "YES" if num$\_$valid$\_$models $>0$ else $"$NO$",$ num$\_$valid$\_$models

# Forward Chaining algorithm using PL$-$FC$-$Entails pseudocode

def forward$\_$chaining$($kb$,$ query$)$:

clauses $=[$clause$.$strip$()$ for clause in kb$.$split$(\text{'}$;$\text{'})$ if clause.strip$()]$

agenda $=[]$

inferred $=\{\}$

count $=\{\}$

# Initialize agenda, inferred, and count

for clause in clauses:

if $\text{'}=>\text{'}$ in clause:

premises, conclusion $=$ clause.split$(\text{'}=>\text{'},1)$

premises $=$ premises.strip$().$split$(\text{'}$&$\text{'})$

conclusion $=$ conclusion.strip$()$

count$[$clause$]=$ len$($premises$)$

for p in premises:

if p not in inferred:

inferred$[$p$]=$ False

if p not in agenda:

agenda.append$($p$)$

if conclusion not in inferred:

inferred$[$conclusion$]=$ False

else:

if clause not in inferred:

inferred$[$clause$]=$ False

if clause not in agenda:

agenda.append$($clause$)$

# Process the agenda

while agenda:

p $=$ agenda.pop$(0)$

if not inferred$[$p$]$:

inferred$[$p$]=$ True

for clause in clauses:

if p in clause and $\text{'}=>\text{'}$ in clause:

premises, c