# Using logic with sets | Python

## austinleath

### April 27th, 2021 09:09:30 AM

```					#Sets
U = {0,1,2,3,4,5,6,7,8,9}
P = {1,2,3,4}
Q = {4,5,6}
R = {3,4,6,8,9}

def set2bits(xs,us) :
bs=[]
for x in us :
if x in xs :
bs.append(1)
else:
bs.append(0)
assert len(us) == len(bs)
return bs

def union(set1,set2) :
finalSet = set()
bitList1 = set2bits(set1, U)
bitList2 = set2bits(set2, U)

for i in range(len(U)) :
if(bitList1[i] or bitList2[i]) :

return finalSet

def intersection(set1,set2) :
finalSet = set()
bitList1 = set2bits(set1, U)
bitList2 = set2bits(set2, U)

for i in range(len(U)) :
if(bitList1[i] and bitList2[i]) :

return finalSet

def compliment(set1) :
finalSet = set()
bitList = set2bits(set1, U)

for i in range(len(U)) :
if(not bitList[i]) :

return finalSet

def implication(a,b):
return union(compliment(a), b)

###########################################################################################
######################         Problems 1-6         #######################################
###########################################################################################

#p \/ (q /\ r) = (p \/ q) /\ (p \/ r)
def prob1():
return union(P, intersection(Q,R)) == intersection(union(P,Q), union(P,R))

#p /\ (q \/ r) = (p /\ q) \/ (p /\ r)
def prob2():
return intersection(P, union(Q,R)) == union(intersection(P,Q), intersection(P,R))

#~(p /\ q) = ~p \/ ~q
def prob3():
return compliment(intersection(P,R)) == union(compliment(P), compliment(R))

#~(p \/ q) = ~p /\ ~q
def prob4():
return compliment(union(P,Q)) == intersection(compliment(P), compliment(Q))

#(p=>q) = (~q => ~p)
def prob5():
return implication(P,Q) == implication(compliment(Q), compliment(P))

#(p => q) /\ (q => r)  =>  (p => r)
def prob6():
return implication(intersection(implication(P,Q), implication(Q,R)), implication(P,R))

print("Problem 1: ", prob1())
print("Problem 2: ", prob2())
print("Problem 3: ", prob3())
print("Problem 4: ", prob4())
print("Problem 5: ", prob5())
print("Problem 6: ", prob6())

'''
Problem 1:  True
Problem 2:  True
Problem 3:  True
Problem 4:  True
Problem 5:  True
Problem 6:  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
'''
```