Provided with a function callf$2($f$,$p$,$q$)$ whose input is a function and its two arguments, and returns the value of the function applied to the arguments and main $($both of which should not be changed$),$ I need to implement three functions: eval$\_$tt$\_$f$2($f$)$ and equivalent$($tt$1,$tt$2)$ and is$\_$tautology$($tt$).$

The function eval$\_$tt$\_$f$2($f$)$ will, given a two argument Boolean function f as input $($one of the functions in PA$2.$py$),$ return the truth table for f$.$

Use the function make$\_$tt$\_$ins$($n$)$ function implemented in PA$2.$py to create a list with the inputs for the truth table, and then use callf$2$ to append the truth value for f to each row. For example, evalttf$2($iff$)$ should return:

$[[$False$,$ False, True$],[$False$,$ True, False$],[$True$,$ False, False$],[$True$,$ True, True$]]$

The function equivalent$($tt$1,$tt$2)$ should return True if tt$1$ and tt$2$ are logically equivalent and False otherwise.

For example, equivalent$($eval$\_$tt$\_$f$2($PA$2.$implies$),$ eval$\_$tt$\_$f$2($PA$2.$nqIMPnp$))$

should return True.

The function is$\_$tautology$($tt$)$ should return True if the tt parameter has a True value as the output for all possible tt inputs, otherwise it should return false.

My code is incorrect and I need help correcting it as debugging has been rough:

PA$3.$py

import sys

import PA$2$

# provided

def callf$2($f$,$ p$,$ q$)$:

return f$($p$,$q$)$

def eval$\_$tt$\_$f$2($f$)$:

tt$\_$ins $=$ PA$2.$make$\_$tt$\_$ins$(2)$

tt $=[]$

for i in tt$\_$ins:

row $=$ i $+[$f$(*$i$)]$

tt$.$append$($row$)$

return tt

# implement this

def equivalent$($tt$1,$tt$2)$:

min$\_$length $=$ min$($len$($tt$1),$ len$($tt$2))$

for i in range$($min$\_$length$)$:

if tt$1[$i$][-1]!=$ tt$2[$i$][-1]$:

return False

return True

# implement this

def is$\_$tautology$($tt$)$:

for i in tt:

if not i$[-1]$:

return False

return True

# use program input section to input choice

# ex$.$ entering 'iff' will run code after the label # one arg

# and entering 'iff implies' will run code after the labe # one arg and # two args

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

print$("$program$",$ sys$.$argv$[0])$

args $=$ input$().$split$()$

argc $=$ len$($args$)$

f$1=$ args$[0]$

print$($f$1)$

tt$1=[]$

# one arg

if$($f$1==$ "implies"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$implies$)$

if$($f$1==$ "iff"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$iff$)$

if$($f$1==$ "npIMPnq"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$npIMPnq$)$

if$($f$1==$ "nqIMPnp"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$nqIMPnp$)$

if$($f$1==$ "nand"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$nand$)$

if$($f$1==$ "nor"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$nor$)$

if$($f$1==$ "npANDnq"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$npANDnq$)$

if$($f$1==$ "npORnq"$)$: tt$1=$ eval$\_$tt$\_$f$2($PA$2.$npORnq$)$

print$($tt$1)$

# two args

if$($argc$>1)$:

f$2=$ args$[1]$

print$($f$2)$

tt$2=[]$

if$($f$2==$ "implies"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$implies$)$

if$($f$2==$ "iff"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$iff$)$

if$($f$2==$ "npIMPnq"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$npIMPnq$)$

if$($f$2==$ "nqIMPnp"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$nqIMPnp$)$

if$($f$2==$ "nand"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$nand$)$

if$($f$2==$ "nor"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$nor$)$

if$($f$2==$ "npANDnq"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$npANDnq$)$

if$($f$2==$ "npORnq"$)$: tt$2=$ eval$\_$tt$\_$f$2($PA$2.$npORnq$)$

print$($tt$2)$

if equivalent$($tt$1,$tt$2)$:

print$("$equivalent$!")$

else:

print$("$NOT equivalent!"$)$

print$()$

PA$2.$py

import sys

# p implies q

def implies$($p$,$ q$)$:

return not p or q

# not p implies not q

def npIMPnq$($p$,$q$)$:

return p or not$($q$)$

# not q implies not p

def nqIMPnp$($p$,$q$)$:

return q or not$($p$)$

# p if and only if q

# equivalent to: $($p implies q$)$ and $($q implies p$)$

def iff$($p$,$ q$)$:

return $($not$($p$)$ or q$)$ and $($not$($q$)$ or p$)$

# not $($ p and q $)$

def nand$($p$,$ q$)$:

return not$($p and q$)$

# not p and not q

def npANDnq$($p$,$q$)$:

return not$($p$)$ and not$($q$)$

# not $($ p or q$)$

def nor$($p$,$ q$)$:

return not$($p$)$ and not$($q$)$

# not p or not q

def npORnq$($p$,$q$)$:

return not$($p$)$ or not$($q$)$

def make$\_$tt$\_$ins$($n$)$:

if n $==0$:

return $[[]]$

else:

result $=[]$

for t in make$\_$tt$\_$ins$($n $-1)$:

result.append$($t $+[$True$])$

result.append$($t $+[$False$])$

return result

#provided

def run$($f$)$:

print$("$ True,True : $",$ f$($True$,$True$))$

print$("$ True,False : $",$ f$($True$,$False$))$

print$("$ False,True : $",$ f$($False$,$True$))$

print$("$ False,False: $",$ f$($False$,$False$))$

print$()$

#provided

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

print$("$program$",$ sys$.$argv$[0])$

f$1=$ sys$.$argv$[1]$

print$($f$1)$

if$($f$1==$ "implies"$)$:

run$($implies$)$

if$($f$1==$ "iff"$)$:

run$($iff$)$

if$($f$1==$ "npIMPnq"$)$:

run$($npIMPnq$)$

if$($f$1==$ "nqIMPnp"$)$:

run$($nqIMPnp$)$

if$($f$1==$ "nand"$)$:

run$($nand$)$

if$($f$1==$ "nor"$)$:

run$($nor$)$

if$($f$1==$ "npANDnq"$)$:

run$($npANDnq$)$

if$($f$1==$ "npORnq"$)$:

run$($npORnq$)$

if$($f$1=="$tt$")$:

print$($make$\_$tt$\_$ins$($int$($sys$.$argv$[2])))$

Testing eval$\_$tt$\_$f$2$ with implies

Your output: $[[$True$,$ True, True$]]$

Testing eval$\_$tt$\_$f$2$ with nand

Your output: $[[$True$,$ True, False$]]$

So looks like I$\text{'}$m missing one list item and getting if True$/$False wrong