def selectRandom():
vecs =[(a0,b0)]
for x in range(4):
a = list2vec([randGF2() for x in range(6)])
b = list2vec([randGF2() for x in range(6)])
vecs.append((a,b))
return vecs
def growSec(): from independence import is_independent from itertools import combinations proven = [(a0,b0)] found = False while not found: t = [(list2vec([randGF2() for i in range(6)]),list2vec([randGF2() for i in range(6)])) for j in range(2)] vecs = proven + t if all(is_independent(list(sum(x,()))) for x in combinations(vecs,3)): found = True proven += t found1 = False while not found1: t1 = [(list2vec([randGF2() for i in range(6)]),list2vec([randGF2() for i in range(6)])) for j in range(2)] vecs1 = proven + t1 if all(is_independent(list(sum(x,()))) for x in combinations(vecs1,3)): found1 = True proven += t1 return proven
def selectRandom():
vecs = [(a0, b0)]
for x in range(4):
a = list2vec([randGF2() for x in range(6)])
b = list2vec([randGF2() for x in range(6)])
vecs.append((a, b))
return vecs
def growSec():
from independence import is_independent
from itertools import combinations
proven = [(a0, b0)]
found = False
while not found:
t = [(list2vec([randGF2() for i in range(6)]),
list2vec([randGF2() for i in range(6)])) for j in range(2)]
vecs = proven + t
if all(
is_independent(list(sum(x, ())))
for x in combinations(vecs, 3)):
found = True
proven += t
found1 = False
while not found1:
t1 = [(list2vec([randGF2() for i in range(6)]),
list2vec([randGF2() for i in range(6)])) for j in range(2)]
vecs1 = proven + t1
if all(
is_independent(list(sum(x, ())))
for x in combinations(vecs1, 3)):
found1 = True
proven += t1
return proven
def direct_sum_decompose(U_basis, V_basis, w):
'''
input: A list of Vecs, U_basis, containing a basis for a vector space, U.
A list of Vecs, V_basis, containing a basis for a vector space, V.
A Vec, w, that belongs to the direct sum of these spaces.
output: A pair, (u, v), such that u+v=w and u is an element of U and
v is an element of V.
>>> U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> direct_sum_decompose(U_basis, V_basis, w) == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
True
'''
from hw4 import vec2rep
U = coldict2mat(U_basis)
V = coldict2mat(V_basis)
sum = U_basis + V_basis
sol_w = vec2rep(sum, w)
lenU = len(U_basis)
wu = list2vec([v for i, v in sol_w.f.items() if i < lenU])
wv = list2vec([v for i, v in sol_w.f.items() if i >= lenU])
u = U * wu
v = V * wv
return (u, v)
def direct_sum_decompose(U_basis, V_basis, w):
'''
input: A list of Vecs, U_basis, containing a basis for a vector space, U.
A list of Vecs, V_basis, containing a basis for a vector space, V.
A Vec, w, that belongs to the direct sum of these spaces.
output: A pair, (u, v), such that u+v=w and u is an element of U and
v is an element of V.
>>> U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> direct_sum_decompose(U_basis, V_basis, w) == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
True
'''
from hw4 import vec2rep
U = coldict2mat(U_basis)
V = coldict2mat(V_basis)
sum = U_basis + V_basis
sol_w = vec2rep(sum,w)
lenU = len(U_basis)
wu = list2vec ([ v for i, v in sol_w.f.items () if i < lenU ])
wv = list2vec ([ v for i, v in sol_w.f.items () if i >= lenU ])
u = U*wu
v = V*wv
return (u,v)
def direct_sum_decompose(U_basis, V_basis, w):
'''
input: A list of Vecs, U_basis, containing a basis for a vector space, U.
A list of Vecs, V_basis, containing a basis for a vector space, V.
A Vec, w, that belongs to the direct sum of these spaces.
output: A pair, (u, v), such that u+v=w and u is an element of U and
v is an element of V.
>>> U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> direct_sum_decompose(U_basis, V_basis, w) == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
True
'''
#W_basis = U_basis + V_basis
#rep_w = vec2rep(W_basis, w)
#U = set(range(len(U_basis)))
#rep_u = Vec(U,{u:rep_w[u] for u in U})
#u = coldict2mat(U_basis)*rep_u
#V = set(range(len(U_basis), len(rep_w.D)))
#rep_v = Vec(V,{v:rep_w[v] for v in V})
#v = coldict2mat(V_basis)*rep_v
T = U_basis + V_basis
x = vec2rep(T, w)
rep= list(x.f.values())
u1 = list2vec(rep[0:len(U_basis)])
v1 = list2vec(rep[len(U_basis):len(T)])
u = rep2vec(u1,U_basis)
v = rep2vec(v1,V_basis)
return (u,v)
def compare(sen1, sen2, votingDict):
total = 0
vector = vecutil.list2vec(votingDict.get(sen1))
vector2 = vecutil.list2vec(votingDict.get(sen2))
for k in range(len(vector.f)):
total = total + vector.f.get(k) * vector2.f.get(k)
return (total)
def direct_sum_decompose(U_basis, V_basis, w):
'''
input: A list of Vecs, U_basis, containing a basis for a vector space, U.
A list of Vecs, V_basis, containing a basis for a vector space, V.
A Vec, w, that belongs to the direct sum of these spaces.
output: A pair, (u, v), such that u+v=w and u is an element of U and
v is an element of V.
>>> U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> direct_sum_decompose(U_basis, V_basis, w) == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
True
'''
uv_basis = U_basis + V_basis #basis of space U+V
x = vec2rep(uv_basis,w) #x is the coordination representation in space U+V : uv_basis*x = w
#then split the coordinations : the first len(U_basis) are coordinates in U, the rest are coordinates in V
# coordinates in U
uc = list2vec([x[i] for i in range(len(U_basis))])
# coordinates in V
uv = list2vec([x[i] for i in range(len(U_basis),len(uv_basis))])
u = coldict2mat(U_basis)*uc
v = coldict2mat(V_basis)*uv
return (u,v)
def choose_secret_vector(s,t):
uFound = False
u = list2vec([0,0,0,0,0,0])
while not uFound:
u = list2vec([randGF2() for i in range(6)])
if a0*u == s and b0*u == t:
uFound = True
return u
def bin2vect(n):
num = bin(n)
bin_list = [ one if x == '1' else 0 for x in num[2:]]
if len(bin_list) < 6:
new_lst = [0] * (6 - len(bin_list))
new_lst.extend(bin_list)
return list2vec(new_lst)
return list2vec(bin_list)
def choose_secret_vector(s, t):
uFound = False
u = list2vec([0, 0, 0, 0, 0, 0])
while not uFound:
u = list2vec([randGF2() for i in range(6)])
if a0 * u == s and b0 * u == t:
uFound = True
return u
def choose_secret_vector(s,t):
#GF2 field elements s and t
# output: a random 6 vector u such that a*u = s and b*u = t
u = list2vec([randGF2() for x in range(6)])
while a0 * u != s or b0 * u != t:
u = list2vec([randGF2() for x in range(6)])
return u
def direct_sum_decompose(U, V, w):
U_copy = U.copy()
U_copy.extend(V)
linear_comb = solve(coldict2mat(U_copy), w)
u_linear_comb = list2vec([linear_comb[i] for i in range(len(U))])
v_linear_comb = list2vec(
[linear_comb[i] for i in range(len(U),
len(V) + len(U))])
return (coldict2mat(U) * u_linear_comb, coldict2mat(V) * v_linear_comb)
def find_error(e):
""" Takes error syndrome and return error vector """
v = gf2_to_decimal(e)
err_vector = [0] * 7
pos = dot(list2vec(v), list2vec([1, 2, 4]))
if pos:
pos -= 1 # array from 0
err_vector[pos] = One()
return list2vec(err_vector)
def direct_sum_decompose(U_basis, V_basis, w):
UV = coldict2mat(U_basis+V_basis)
U = coldict2mat(U_basis)
V = coldict2mat(V_basis)
W = solve(UV,w)
Wu = list2vec([v for i, v in W.f.items() if i < len(U_basis)])
Wv = list2vec([v for i, v in W.f.items() if i >= len(U_basis)])
u = U * Wu
v = V * Wv
return (u,v)
def generate_independent_vectors(n):
B = []
while (len(B) < n * 2):
b = list2vec([randGF2() for i in range(6)])
while b == a0 or b == b0:
b = list2vec([randGF2() for i in range(6)])
B.append(b)
if not is_independent(B):
del B[len(B) - 1]
return B
def test_rowlist2echelon(): v1 = list2vec([0,2,3,4,5]) v2 = list2vec([0,0,0,0,5]) v3 = list2vec([1,2,3,4,5]) v4 = list2vec([0,0,0,4,5]) rowlist = [v1,v2,v3,v4] A = rowlist2echelon(rowlist) print(A)
def choose_tokens(a, b):
tokens = [a, b]
for _ in range(1000000):
token_A = list2vec([randGF2() for _ in range(len(a0.D))])
token_B = list2vec([randGF2() for _ in range(len(a0.D))])
if is_token_pair_suitable(tokens, [token_A, token_B]):
tokens = tokens + [token_A, token_B]
if len(tokens) == 10:
return tokens
raise Exception("Unable to pick tokens")
def direct_sum_decompose(U_basis, V_basis, w):
'''
Input:
- U_basis: a list of Vecs forming a basis for a vector space U
- V_basis: a list of Vecs forming a basis for a vector space V
- w: a Vec in the direct sum of U and V
Output:
- a pair (u, v) such that u + v = w, u is in U, v is in V
Example:
>>> D = {0,1,2,3,4,5}
>>> U_basis = [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, w)
>>> (u + v - w).is_almost_zero()
True
>>> U_matrix = coldict2mat(U_basis)
>>> V_matrix = coldict2mat(V_basis)
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> ww = Vec(D,{0: 2, 1: 5, 2: 51, 4: 1, 5: 7})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, ww)
>>> (u + v - ww).is_almost_zero()
True
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> U_basis == [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
True
>>> V_basis == [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
True
>>> w == Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
True
'''
UV_basis = U_basis + V_basis
uv_w = basis.vec2rep(UV_basis,w)
uv_values = list(uv_w.f.values())
udims = len(U_basis)
ux = list2vec(uv_values[:udims])
vy = list2vec(uv_values[udims:])
u = basis.rep2vec(ux, U_basis)
v = basis.rep2vec(vy, V_basis)
return (u,v)
def task2():
row = [(a0, b0)] + [
(list2vec([randGF2() for i in range(6)]), list2vec([randGF2() for i in range(6)])) for j in range(4)
]
while not all(is_independent(list(sum(x, ()))) for x in combinations(row, 3)):
row = [(a0, b0)] + [
(list2vec([randGF2() for i in range(6)]), list2vec([randGF2() for i in range(6)])) for j in range(4)
]
return row
def direct_sum_decompose(U_basis, V_basis, w):
'''
Input:
- U_basis: a list of Vecs forming a basis for a vector space U
- V_basis: a list of Vecs forming a basis for a vector space V
- w: a Vec in the direct sum of U and V
Output:
- a pair (u, v) such that u + v = w, u is in U, v is in V
Example:
>>> D = {0,1,2,3,4,5}
>>> U_basis = [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, w)
>>> (u + v - w).is_almost_zero()
True
>>> U_matrix = coldict2mat(U_basis)
>>> V_matrix = coldict2mat(V_basis)
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> ww = Vec(D,{0: 2, 1: 5, 2: 51, 4: 1, 5: 7})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, ww)
>>> (u + v - ww).is_almost_zero()
True
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> U_basis == [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
True
>>> V_basis == [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
True
>>> w == Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
True
'''
U_V_basis = list(U_basis)
U_V_basis.extend(V_basis)
w_coordinates = vec2rep(U_V_basis, w)
w_u_coord = list()
w_v_coord = list()
for n in range(len(U_V_basis)):
if n < len(U_basis):
w_u_coord.append(w_coordinates[n])
else:
w_v_coord.append(w_coordinates[n])
u = rep2vec(list2vec(w_u_coord), U_basis)
v = rep2vec(list2vec(w_v_coord), V_basis)
return (u, v)
def pick_known_vectors(a, b):
all = [ (a,b),None,None,None,None ]
while True:
for i in range(1,5):
all[i] = (list2vec([ randGF2() for i in range(6) ]),
list2vec([ randGF2() for i in range(6) ]))
ok = True
for x,y,z in combinations(range(5), 3):
L = [ all[x][0], all[x][1], all[y][0], all[y][1], all[z][0], all[z][1] ]
if not is_independent(L):
ok = False
break
if ok:
return all
def helper():
L0 = []
while True:
a1 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b1 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
a2 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b2 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
if is_independent ([a0, b0, a1, b1, a2, b2]) == True:
break
L0 = [a0, b0, a1, b1, a2, b2]
while True:
a3 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b3 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
L1 = [a0, b0, a1, b1, a3, b3]
L2 = [a0, b0, a2, b2, a3, b3]
L3 = [a1, b1, a2, b2, a3, b3]
if is_independent (L1) == True and is_independent (L2) == True and is_independent (L3) == True:
break
while True:
a4 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b4 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
L4 = [a0, b0, a1, b1, a4, b4]
L5 = [a0, b0, a2, b2, a4, b4]
L6 = [a1, b1, a2, b2, a4, b4]
L7 = [a0, b0, a3, b3, a4, b4]
L8 = [a1, b1, a3, b3, a4, b4]
L9 = [a2, b2, a3, b3, a4, b4]
if is_independent (L4) == True and is_independent (L5) == True and is_independent (L6) == True and is_independent (L7) == True and is_independent (L8) == True and is_independent (L9) == True:
break
return a0, b0, a1, b1, a2, b2, a3, b3, a4, b4
def random_select():
while True:
a1 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b1 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
a2 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b2 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
a3 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b3 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
a4 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
b4 = list2vec([randGF2(),randGF2(),randGF2(),randGF2(),randGF2(),randGF2()])
l1 = [a0,a1,a2,b0,b1,b2]
l2 = [a0,a1,a3,b0,b1,b3]
l3 = [a0,a1,a4,b0,b1,b4]
l4 = [a0,a2,a3,b0,b2,b3]
l5 = [a0,a2,a4,b0,b2,b4]
l6 = [a0,a3,a4,b0,b3,b4]
l7 = [a1,a2,a3,b1,b2,b3]
l8 = [a1,a2,a4,b1,b2,b4]
l9 = [a1,a3,a4,b1,b3,b4]
l10 =[a2,a3,a4,b2,b3,b4]
t1 = my_is_independent(l1);
t2 = my_is_independent(l2);
t3 = my_is_independent(l3);
t4 = my_is_independent(l4);
t5 = my_is_independent(l5);
t6 = my_is_independent(l6);
t7 = my_is_independent(l7);
t8 = my_is_independent(l8);
t9 = my_is_independent(l9);
t10 = my_is_independent(l10);
if t1 == True and t2 == True and t3 == True and t4 == True and t5 == True and t6 == True and t7 == True and t8 ==True and t9 == True and t10 == True:
return [a1,b1,a2,b2,a3,b3,a4,b4]
def task2():
row = [(a0,b0)] + [
( list2vec([randGF2() for i in range(6) ]),
list2vec([randGF2() for i in range(6) ])
) for j in range(4) ]
while not all(is_independent(list(sum(x,()))) for x in combinations(row,3)):
row = [(a0,b0)] + [
( list2vec([randGF2() for i in range(6) ]),
list2vec([randGF2() for i in range(6) ])
) for j in range(4) ]
return row
def direct_sum_decompose(U_basis, V_basis, w):
"""
Input:
- U_basis: a list of Vecs forming a basis for a vector space U
- V_basis: a list of Vecs forming a basis for a vector space V
- w: a Vec in the direct sum of U and V
Output:
- a pair (u, v) such that u + v = w, u is in U, v is in V
Example:
>>> D = {0,1,2,3,4,5}
>>> U_basis = [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, w)
>>> (u + v - w).is_almost_zero()
True
>>> U_matrix = coldict2mat(U_basis)
>>> V_matrix = coldict2mat(V_basis)
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> ww = Vec(D,{0: 2, 1: 5, 2: 51, 4: 1, 5: 7})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, ww)
>>> (u + v - ww).is_almost_zero()
True
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> U_basis == [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
True
>>> V_basis == [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
True
>>> w == Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
True
"""
UV_basis = U_basis + V_basis
UV_matrix = coldict2mat(UV_basis)
U_matrix = coldict2mat(U_basis)
V_matrix = coldict2mat(V_basis)
x = solve(UV_matrix, w)
list_x = list(x.f.values())
# print(list_x)
u = U_matrix * list2vec(list_x[0 : len(U_matrix.D[1])])
v = V_matrix * list2vec(list_x[len(U_matrix.D[1]) :])
return (u, v)
def direct_sum_decompose(U_basis, V_basis, w):
'''
Input:
- U_basis: a list of Vecs forming a basis for a vector space U
- V_basis: a list of Vecs forming a basis for a vector space V
- w: a Vec in the direct sum of U and V
Output:
- a pair (u, v) such that u + v = w, u is in U, v is in V
Example:
>>> D = {0,1,2,3,4,5}
>>> U_basis = [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, w)
>>> (u + v - w).is_almost_zero()
True
>>> U_matrix = coldict2mat(U_basis)
>>> V_matrix = coldict2mat(V_basis)
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> ww = Vec(D,{0: 2, 1: 5, 2: 51, 4: 1, 5: 7})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, ww)
>>> (u + v - ww).is_almost_zero()
True
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> U_basis == [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
True
>>> V_basis == [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
True
>>> w == Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
True
'''
UV_basis = U_basis + V_basis
UV_matrix = coldict2mat(UV_basis)
U_matrix = coldict2mat(U_basis)
V_matrix = coldict2mat(V_basis)
x = solve(UV_matrix, w)
list_x = list(x.f.values())
#print(list_x)
u = U_matrix * list2vec(list_x[0:len(U_matrix.D[1])])
v = V_matrix * list2vec(list_x[len(U_matrix.D[1]):])
return (u,v)
def direct_sum_decompose(U_basis, V_basis, w):
'''
Input:
- U_basis: a list of Vecs forming a basis for a vector space U
- V_basis: a list of Vecs forming a basis for a vector space V
- w: a Vec in the direct sum of U and V
Output:
- a pair (u, v) such that u + v = w, u is in U, v is in V
Example:
>>> D = {0,1,2,3,4,5}
>>> U_basis = [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, w)
>>> (u + v - w).is_almost_zero()
True
>>> U_matrix = coldict2mat(U_basis)
>>> V_matrix = coldict2mat(V_basis)
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> ww = Vec(D,{0: 2, 1: 5, 2: 51, 4: 1, 5: 7})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, ww)
>>> (u + v - ww).is_almost_zero()
True
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> U_basis == [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
True
>>> V_basis == [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
True
>>> w == Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
True
'''
M = coldict2mat(U_basis+V_basis)
solution = solve(M, w)
u, v = [], []
U_matrix, V_matrix = coldict2mat(U_basis), coldict2mat(V_basis)
for i in range(len(U_basis) + len(V_basis)):
if i < len(U_basis):
u.append(solution.f[i])
else:
v.append(solution.f[i])
return U_matrix*list2vec(u), V_matrix*list2vec(v)
def find_triangular_matrix_inverse(A):
'''
Supporting GF2 is not required.
Input:
- A: an upper triangular Mat with nonzero diagonal elements
Output:
- Mat that is the inverse of A
Example:
>>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
>>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
True
'''
res = []
#print(A)
n = len(A.D[0])
row_vecs = mat2rowdict(A)
rowlist = list(row_vecs.values())
#print(rowlist)
for i in range(n):
b = list2vec([0] * i + [1] + [0] * (n-i-1))
x = triangular_solve(rowlist, list(A.D[0]), b)
res.append(x)
#print(coldict2mat(res))
return coldict2mat(res)
def choose_secret_vector(s, t):
while True:
secret = [randGF2() for i in range(6)]
secret = list2vec(secret)
print(secret)
if a0 * secret == s and b0 * secret == t:
return secret
def other_vectors():
while True:
l_ = [a0, b0]
for i in range(8):
l_.append(
list2vec([
randGF2(),
randGF2(),
randGF2(),
randGF2(),
randGF2(),
randGF2()
]))
ranks = []
for comb in list(itertools.combinations([0, 2, 4, 6, 8], 3)):
l = [(l_[i], l_[i + 1]) for i in comb]
the_three = [item for sublist in l for item in sublist]
r = rank(the_three)
if r < 6:
continue
else:
ranks.append(r)
if set(ranks) == {6}:
print("yess")
return l_
return l_
def find_triangular_matrix_inverse(A):
"""
Supporting GF2 is not required.
Input:
- A: an upper triangular Mat with nonzero diagonal elements
Output:
- Mat that is the inverse of A
Example:
>>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
>>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
True
"""
res = []
# print(A)
n = len(A.D[0])
row_vecs = mat2rowdict(A)
rowlist = list(row_vecs.values())
# print(rowlist)
for i in range(n):
b = list2vec([0] * i + [1] + [0] * (n - i - 1))
x = triangular_solve(rowlist, list(A.D[0]), b)
res.append(x)
# print(coldict2mat(res))
return coldict2mat(res)
def choose_secret_vector(s,t):
'''(GF2, GF2) -> Vec of GF2
Return random vector u of length 6 such that a0*u == s, b0*u == t.
'''
u = list2vec([randGF2() for i in range(6)])
return u if (a0*u==s) and (b0*u==t) else choose_secret_vector(s,t)
def choose_secret_vector(s,t):
while True:
secret = [ randGF2() for i in range(6) ]
secret = list2vec(secret)
print(secret)
if a0 * secret == s and b0 * secret == t:
return secret
def choose_secret_vector(s, t):
check_random = False
while not (check_random):
u = list2vec([randGF2() for i in range(6)])
if a0 * u == s and b0 * u == t:
check_random = True
return u
def find_average_similarity(sen, sen_set, voting_dict):
"""
Input: the name of a senator, a set of senator names, and a voting dictionary.
Output: the average dot-product between sen and those in sen_set.
Example:
>>> vd = {'Klein': [1,1,1], 'Fox-Epstein': [1,-1,0], 'Ravella': [-1,0,0]}
>>> find_average_similarity('Klein', {'Fox-Epstein','Ravella'}, vd)
-0.5
"""
from vecutil import list2vec
_sum = 0
vec0 = list2vec(voting_dict[sen])
for sen_name in sen_set:
vec1 = list2vec(voting_dict[sen_name])
_sum += vec0 * vec1
return _sum/len(sen_set)
def randGF2_6():
return list2vec(
[randGF2(),
randGF2(),
randGF2(),
randGF2(),
randGF2(),
randGF2()])
def pick_known_vectors(a, b):
all = [(a, b), None, None, None, None]
while True:
for i in range(1, 5):
all[i] = (list2vec([randGF2() for i in range(6)]),
list2vec([randGF2() for i in range(6)]))
ok = True
for x, y, z in combinations(range(5), 3):
L = [
all[x][0], all[x][1], all[y][0], all[y][1], all[z][0],
all[z][1]
]
if not is_independent(L):
ok = False
break
if ok:
return all
def find_triangular_matrix_inverse(A):
'''
input: An upper triangular Mat, A, with nonzero diagonal elements
output: Inverse of A
>>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
>>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
True
'''
R = len(A.D[0])
C = len(A.D[1])
coldict = {}
for i in range(C):
b = [0] * R
b[i] = 1
s = triangular_solve(list(matutil.mat2rowdict(A).values()), list(A.D[0]), list2vec(b))
coldict[i] = s
return coldict2mat(coldict)
# import hw5
# import hw4
# from mat import Mat
# import vecutil
# import matutil
# from vec import Vec
# from GF2 import one
# L = [Vec({0, 1, 2},{0: 1, 1: 0, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 0, 2: 1}), Vec({0, 1, 2},{0: 1, 1: 1, 2: 1}), Vec({0, 1, 2},{0: 1, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 1})]
# hw5.my_is_independent(L)
# hw5.my_is_independent(L[:2])
# S = [vecutil.list2vec(v) for v in [[1,0,0],[0,1,0],[0,0,1]]]
# B = [vecutil.list2vec(v) for v in [[1,1,0],[0,1,1],[1,0,1]]]
# ff = hw5.morph(S, B)
# ff == [(Vec({0, 1, 2},{0: 1, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 1, 1: 0, 2: 0})), (Vec({0, 1, 2},{0: 0, 1: 1, 2: 1}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 0})), (Vec({0, 1, 2},{0: 1, 1: 0, 2: 1}), Vec({0, 1, 2},{0: 0, 1: 0, 2: 1}))]
# a0 = Vec({'a','b','c','d'}, {'a':1})
# a1 = Vec({'a','b','c','d'}, {'b':1})
# a2 = Vec({'a','b','c','d'}, {'c':1})
# a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
# sb = hw5.subset_basis([a0,a1,a2,a3])
# sb == [Vec({'c', 'b', 'a', 'd'},{'a': 1}), Vec({'c', 'b', 'a', 'd'},{'b': 1}), Vec({'c', 'b', 'a', 'd'},{'c': 1})]
# U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
# V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
# w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
# ss = hw5.direct_sum_decompose(U_basis, V_basis, w)
# ss == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
# M = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0})
# hw5.is_invertible(M)
# A = Mat(({0, 1}, {0, 1, 2}), {(0, 1): 2, (1, 2): 1, (0, 0): 1, (1, 0): 3, (0, 2): 3, (1, 1): 1})
# B = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0})
# C = Mat(({0, 1, 2}, {0, 1}), {(0, 1): 0, (2, 0): 2, (0, 0): 1, (1, 0): 0, (1, 1): 1, (2, 1): 1})
# D = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): 5, (1, 2): 2, (0, 0): 1, (2, 0): 4, (1, 0): 2, (2, 2): 7, (0, 2): 8, (2, 1): 6, (1, 1): 5})
# E = Mat(({0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}), {(1, 2): 7, (3, 2): 7, (0, 0): 3, (3, 0): 1, (0, 4): 3, (1, 4): 2, (1, 3): 4, (2, 3): 0, (2, 1): 56, (2, 4): 5, (4, 2): 6, (1, 0): 2, (0, 3): 7, (4, 0): 2, (0, 1): 5, (3, 3): 4, (4, 1): 4, (3, 1): 23, (4, 4): 5, (0, 2): 7, (2, 0): 2, (4, 3): 8, (2, 2): 9, (3, 4): 2, (1, 1): 4})
# M = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (1, 2): 0, (0, 0): 0, (2, 0): 0, (1, 0): one, (2, 2): one, (0, 2): 0, (2, 1): 0, (1, 1): 0})
# hw5.find_matrix_inverse(M) == Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (2, 0): 0, (0, 0): 0, (2, 2): one, (1, 0): one, (1, 2): 0, (1, 1): 0, (2, 1): 0, (0, 2): 0})
# A = matutil.listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
# hw5.find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
def find_triangular_matrix_inverse(A):
'''
input: An upper triangular Mat, A, with nonzero diagonal elements
output: Inverse of A
>>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
>>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
True
'''
R = len(A.D[0])
C = len(A.D[1])
coldict = {}
for i in range(C):
b = [0] * R
b[i] = 1
s = triangular_solve(list(matutil.mat2rowdict(A).values()),
list(A.D[0]), list2vec(b))
coldict[i] = s
return coldict2mat(coldict)
# import hw5
# import hw4
# from mat import Mat
# import vecutil
# import matutil
# from vec import Vec
# from GF2 import one
# L = [Vec({0, 1, 2},{0: 1, 1: 0, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 0, 2: 1}), Vec({0, 1, 2},{0: 1, 1: 1, 2: 1}), Vec({0, 1, 2},{0: 1, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 1})]
# hw5.my_is_independent(L)
# hw5.my_is_independent(L[:2])
# S = [vecutil.list2vec(v) for v in [[1,0,0],[0,1,0],[0,0,1]]]
# B = [vecutil.list2vec(v) for v in [[1,1,0],[0,1,1],[1,0,1]]]
# ff = hw5.morph(S, B)
# ff == [(Vec({0, 1, 2},{0: 1, 1: 1, 2: 0}), Vec({0, 1, 2},{0: 1, 1: 0, 2: 0})), (Vec({0, 1, 2},{0: 0, 1: 1, 2: 1}), Vec({0, 1, 2},{0: 0, 1: 1, 2: 0})), (Vec({0, 1, 2},{0: 1, 1: 0, 2: 1}), Vec({0, 1, 2},{0: 0, 1: 0, 2: 1}))]
# a0 = Vec({'a','b','c','d'}, {'a':1})
# a1 = Vec({'a','b','c','d'}, {'b':1})
# a2 = Vec({'a','b','c','d'}, {'c':1})
# a3 = Vec({'a','b','c','d'}, {'a':1,'c':3})
# sb = hw5.subset_basis([a0,a1,a2,a3])
# sb == [Vec({'c', 'b', 'a', 'd'},{'a': 1}), Vec({'c', 'b', 'a', 'd'},{'b': 1}), Vec({'c', 'b', 'a', 'd'},{'c': 1})]
# U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
# V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
# w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
# ss = hw5.direct_sum_decompose(U_basis, V_basis, w)
# ss == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
# M = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0})
# hw5.is_invertible(M)
# A = Mat(({0, 1}, {0, 1, 2}), {(0, 1): 2, (1, 2): 1, (0, 0): 1, (1, 0): 3, (0, 2): 3, (1, 1): 1})
# B = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0})
# C = Mat(({0, 1, 2}, {0, 1}), {(0, 1): 0, (2, 0): 2, (0, 0): 1, (1, 0): 0, (1, 1): 1, (2, 1): 1})
# D = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): 5, (1, 2): 2, (0, 0): 1, (2, 0): 4, (1, 0): 2, (2, 2): 7, (0, 2): 8, (2, 1): 6, (1, 1): 5})
# E = Mat(({0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}), {(1, 2): 7, (3, 2): 7, (0, 0): 3, (3, 0): 1, (0, 4): 3, (1, 4): 2, (1, 3): 4, (2, 3): 0, (2, 1): 56, (2, 4): 5, (4, 2): 6, (1, 0): 2, (0, 3): 7, (4, 0): 2, (0, 1): 5, (3, 3): 4, (4, 1): 4, (3, 1): 23, (4, 4): 5, (0, 2): 7, (2, 0): 2, (4, 3): 8, (2, 2): 9, (3, 4): 2, (1, 1): 4})
# M = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (1, 2): 0, (0, 0): 0, (2, 0): 0, (1, 0): one, (2, 2): one, (0, 2): 0, (2, 1): 0, (1, 1): 0})
# hw5.find_matrix_inverse(M) == Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (2, 0): 0, (0, 0): 0, (2, 2): one, (1, 0): one, (1, 2): 0, (1, 1): 0, (2, 1): 0, (0, 2): 0})
# A = matutil.listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
# hw5.find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
def choose_secret_vector(s,t):
u = [0, 0, 0, 0, 0, 0]
u[1] = randGF2()
u[2] = randGF2()
u[4] = randGF2()
u[5] = randGF2()
u[0] = t - u[1] - u[5]
u[3] = s - t
return list2vec(u)
def choose_secret_vector(s, t):
u = [0, 0, 0, 0, 0, 0]
u[1] = randGF2()
u[2] = randGF2()
u[4] = randGF2()
u[5] = randGF2()
u[0] = t - u[1] - u[5]
u[3] = s - t
return list2vec(u)
def choose_secret_vector(s,t):
secret_list=[0 for x in range(0,6)]
#print ("Init1")
for i in range(0,6):
secret_list[i]=randGF2();
secret_vec=list2vec(secret_list)
#print ("Init2")
while (a0*secret_vec!=s or b0*secret_vec!=t): #Dont use AND because the while loop should go as long as even one of the conditions is true
for i in range(0,6):
secret_list[i]=randGF2()
#print ("Iteration")
secret_vec=list2vec(secret_list)
return secret_vec
def direct_sum_decompose(U_basis, V_basis, w):
'''
Input:
- U_basis: a list of Vecs forming a basis for a vector space U
- V_basis: a list of Vecs forming a basis for a vector space V
- w: a Vec in the direct sum of U and V
Output:
- a pair (u, v) such that u + v = w, u is in U, v is in V
Example:
>>> D = {0,1,2,3,4,5}
>>> U_basis = [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, w)
>>> (u + v - w).is_almost_zero()
True
>>> U_matrix = coldict2mat(U_basis)
>>> V_matrix = coldict2mat(V_basis)
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> ww = Vec(D,{0: 2, 1: 5, 2: 51, 4: 1, 5: 7})
>>> (u, v) = direct_sum_decompose(U_basis, V_basis, ww)
>>> (u + v - ww).is_almost_zero()
True
>>> (u - U_matrix*solve(U_matrix, u)).is_almost_zero()
True
>>> (v - V_matrix*solve(V_matrix, v)).is_almost_zero()
True
>>> U_basis == [Vec(D,{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec(D,{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec(D,{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
True
>>> V_basis == [Vec(D,{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec(D,{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
True
>>> w == Vec(D,{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
True
'''
rep_w = vec2rep(U_basis + V_basis, w)
rep_u = [rep_w[i] for i in range(len(U_basis))]
rep_v = [rep_w[len(U_basis) + i] for i in range(len(V_basis))]
u = coldict2mat(U_basis) * list2vec(rep_u)
v = coldict2mat(V_basis) * list2vec(rep_v)
return (u, v)
def matrix_inverse(M):
L = []
if is_invertible(M):
print('yayyy')
for e in M.D[0]:
w = [0]*len(M.D[0])
w[e] = one
w = list2vec(w)
L.append(solve(M,w))
#print(L)
return coldict2mat(L)
def golay23Encode(data):
if len(data) != 12:
return None
# convert to a vector over GF(2)
datavec = list2vec(bitArrayToGF2(data))
codeword = datavec * golay23mat
# convert codeword to bit array
codebits = GF2toBitArray(vec2list(codeword))
return data + codebits
def policy_compare(sen_a, sen_b, voting_dict):
"""
Input: last names of sen_a and sen_b, and a voting dictionary mapping senator
names to lists representing their voting records.
Output: the dot-product (as a number) representing the degree of similarity
between two senators' voting policies
Example:
>>> voting_dict = {'Fox-Epstein':[-1,-1,-1,1],'Ravella':[1,1,1,1]}
>>> policy_compare('Fox-Epstein','Ravella', voting_dict)
-2
"""
# from vec import Vec
# from dictutil import list2dict
from vecutil import list2vec
#list_a = voting_data[sen_a]
#dict_a = list2dict(list_a)
vec_a = list2vec(voting_dict[sen_a]) #Vec(set(dict_a.keys()),dict_a)
#list_b = voting_data[sen_b]
#dict_b = list2dict(list_b)
vec_b = list2vec(voting_dict[sen_b]) #Vec(set(dict_b.keys()),dict_b)
return vec_a*vec_b
def choose_secret_vector(s, t):
while True:
u = list2vec(
[randGF2(),
randGF2(),
randGF2(),
randGF2(),
randGF2(),
randGF2()])
if (a0 * u == s) and (b0 * u == t):
break
return u
def linear_regression(data):
datalist = read_vectors(data)
x = list(datalist[0].D)[1]
y = list(datalist[0].D)[0]
x_domain = {1, x}
x_rowlist = []
y_list = []
for v in datalist:
x_rowlist.append(Vec(x_domain, {1: 1, x: v[x]}))
y_list.append(v[y])
y_vec = list2vec(y_list)
minimize = QR_solve(rowdict2mat(x_rowlist), y_vec)
return minimize[1], minimize[x] # return b,a
def direct_sum_decompose(U_basis, V_basis, w):
'''
input: A list of Vecs, U_basis, containing a basis for a vector space, U.
A list of Vecs, V_basis, containing a basis for a vector space, V.
A Vec, w, that belongs to the direct sum of these spaces.
output: A pair, (u, v), such that u+v=w and u is an element of U and
v is an element of V.
>>> U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> direct_sum_decompose(U_basis, V_basis, w) == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
True
'''
dsum_basis = U_basis + V_basis # Basis of the direct sum is the union of the bases of the sub spaces
sol = vec2rep (dsum_basis, w) # get the linear solution that multiplies with dsum_basis that gives w
com = list (sol.f.values()) # break the U and V parts of the solution
uvals = list2vec (com[:len(U_basis)])
vvals = list2vec (com[len(U_basis):])
u = rep2vec(uvals, U_basis)
v = rep2vec(vvals, V_basis)
return u, v
def direct_sum_decompose(U_basis, V_basis, w):
'''
input: A list of Vecs, U_basis, containing a basis for a vector space, U.
A list of Vecs, V_basis, containing a basis for a vector space, V.
A Vec, w, that belongs to the direct sum of these spaces.
output: A pair, (u, v), such that u+v=w and u is an element of U and
v is an element of V.
>>> U_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 1, 2: 0, 3: 0, 4: 6, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 11, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0}), Vec({0, 1, 2, 3, 4, 5},{0: 3, 1: 1.5, 2: 0, 3: 0, 4: 7.5, 5: 0})]
>>> V_basis = [Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 7, 3: 0, 4: 0, 5: 1}), Vec({0, 1, 2, 3, 4, 5},{0: 0, 1: 0, 2: 15, 3: 0, 4: 0, 5: 2})]
>>> w = Vec({0, 1, 2, 3, 4, 5},{0: 2, 1: 5, 2: 0, 3: 0, 4: 1, 5: 0})
>>> direct_sum_decompose(U_basis, V_basis, w) == (Vec({0, 1, 2, 3, 4, 5},{0: 2.0, 1: 4.999999999999972, 2: 0.0, 3: 0.0, 4: 1.0, 5: 0.0}), Vec({0, 1, 2, 3, 4, 5},{0: 0.0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0.0, 5: 0.0}))
True
'''
coeffvec = vec2rep(U_basis+V_basis, w)
u=list2vec([0,0,0,0,0,0])
v=list2vec([0,0,0,0,0,0])
for i in range(len(U_basis)):
u=u+coeffvec[i]*U_basis[i]
for j in range(len(V_basis)):
v=v+coeffvec[j+len(U_basis)]*V_basis[j]
return (u,v)
def getVecs():
while(True):
a1 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
b1 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
a2 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
b2 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
a3 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
b3 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
a4 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
b4 = list2vec([randGF2(), randGF2(), randGF2(), randGF2(), randGF2(), randGF2()])
vecs = [a0,b0,a1,b1,a2,b2,a3,b3,a4,b4]
result = [is_independent([vecs[x],vecs[x+1],vecs[y],vecs[y+1],vecs[z],vecs[z+1]])
for x in range(0,10,2) for y in range(x+2,10,2) for z in range(y+2,10,2)]
if all(result):
return vecs
def find_triangular_matrix_inverse(A):
"""
input: An upper triangular Mat, A, with nonzero diagonal elements
output: Inverse of A
>>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
>>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
True
"""
cd = list()
label_list = list(mat2rowdict(A).keys())
rowlist = list(mat2rowdict(A).values())
for j in label_list:
c = triangular_solve(rowlist, label_list, list2vec([1 if i == j else 0 for i in label_list]))
cd.append(c)
return coldict2mat(cd)
def is_invertible(M):
'''
input: A matrix, M
outpit: A boolean indicating if M is invertible.
>>> M = Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): 0, (1, 2): 1, (3, 2): 0, (0, 0): 1, (3, 3): 4, (3, 0): 0, (3, 1): 0, (1, 1): 2, (2, 1): 0, (0, 2): 1, (2, 0): 0, (1, 3): 0, (2, 3): 1, (2, 2): 3, (1, 0): 0, (0, 3): 0})
>>> is_invertible(M)
True
'''
nullspace = solve(M, list2vec([0]))
ker_zero = nullspace == Vec(nullspace.D, {})
im_f_eq_codomain = independence.rank(subset_basis(matutil.mat2coldict(M).values())) == len(M.D[1])
# invertible if its one-to-one, onto, and square matrix
return ker_zero and im_f_eq_codomain and len(matutil.mat2coldict(M)) == len(matutil.mat2rowdict(M))
def aug_orthonormalize(L):
'''
Input:
- L: a list of Vecs
Output:
- A pair Qlist, Rlist such that:
* coldict2mat(L) == coldict2mat(Qlist) * coldict2mat(Rlist)
* Qlist = orthonormalize(L)
>>> from vec import Vec
>>> D={'a','b','c','d'}
>>> L = [Vec(D, {'a':4,'b':3,'c':1,'d':2}), Vec(D, {'a':8,'b':9,'c':-5,'d':-5}), Vec(D, {'a':10,'b':1,'c':-1,'d':5})]
>>> Qlist, Rlist = aug_orthonormalize(L)
>>> from matutil import coldict2mat
>>> print(coldict2mat(Qlist))
<BLANKLINE>
0 1 2
---------------------
a | 0.73 0.187 0.528
b | 0.548 0.403 -0.653
c | 0.183 -0.566 -0.512
d | 0.365 -0.695 0.181
<BLANKLINE>
>>> print(coldict2mat(Rlist))
<BLANKLINE>
0 1 2
------------------
0 | 5.48 8.03 9.49
1 | 0 11.4 -0.636
2 | 0 0 6.04
<BLANKLINE>
>>> print(coldict2mat(Qlist)*coldict2mat(Rlist))
<BLANKLINE>
0 1 2
---------
a | 4 8 10
b | 3 9 1
c | 1 -5 -1
d | 2 -5 5
<BLANKLINE>
'''
Qlist, Rlist = aug_orthogonalize(L)
norms = [sqrt(x*x) for x in Qlist]
Q = [Qlist[x] / norms[x] for x in range(len(norms))]
##Use the norms to scale the vectors in Rlist
R = [list2vec([norms[x]*t[x] for x in range(len(norms))]) for t in Rlist]
return Q,R
def aug_orthonormalize(L):
'''
Input:
- L: a list of Vecs
Output:
- A pair Qlist, Rlist such that:
* coldict2mat(L) == coldict2mat(Qlist) * coldict2mat(Rlist)
* Qlist = orthonormalize(L)
>>> from vec import Vec
>>> D={'a','b','c','d'}
>>> L = [Vec(D, {'a':4,'b':3,'c':1,'d':2}), Vec(D, {'a':8,'b':9,'c':-5,'d':-5}), Vec(D, {'a':10,'b':1,'c':-1,'d':5})]
>>> Qlist, Rlist = aug_orthonormalize(L)
>>> from matutil import coldict2mat
>>> print(coldict2mat(Qlist))
<BLANKLINE>
0 1 2
---------------------
a | 0.73 0.187 0.528
b | 0.548 0.403 -0.653
c | 0.183 -0.566 -0.512
d | 0.365 -0.695 0.181
<BLANKLINE>
>>> print(coldict2mat(Rlist))
<BLANKLINE>
0 1 2
------------------
0 | 5.48 8.03 9.49
1 | 0 11.4 -0.636
2 | 0 0 6.04
<BLANKLINE>
>>> print(coldict2mat(Qlist)*coldict2mat(Rlist))
<BLANKLINE>
0 1 2
---------
a | 4 8 10
b | 3 9 1
c | 1 -5 -1
d | 2 -5 5
<BLANKLINE>
'''
Qlist, Rlist = aug_orthogonalize(L)
norms = [sqrt(x * x) for x in Qlist]
Q = [Qlist[x] / norms[x] for x in range(len(norms))]
##Use the norms to scale the vectors in Rlist
R = [list2vec([norms[x] * t[x] for x in range(len(norms))]) for t in Rlist]
return Q, R
def exchange(S, A, z):
'''
Input:
- S: a set of Vecs (not necessarily linearly independent)
- A: a set of Vecs, a proper subset of S
- z: an instance of Vec such that A | {z} is linearly independent
Output: a vector w in S but not in A such that Span S = Span ({z} | S - {w})
Examples:
>>> from vecutil import list2vec
>>> from vec import Vec
>>> S = {list2vec(v) for v in [[0,0,5,3],[2,0,1,3],[0,0,1,0],[1,2,3,4]]}
>>> A = {list2vec(v) for v in [[0,0,5,3],[2,0,1,3]]}
>>> z = list2vec([0,2,1,1])
>>> (exchange(S, A, z) == Vec({0, 1, 2, 3},{0: 0, 1: 0, 2: 1, 3: 0})) or (exchange(S, A, z) == Vec({0, 1, 2, 3},{0: 1, 1: 2, 2: 3, 3: 4}))
True
>>> S == {list2vec(v) for v in [[0,0,5,3],[2,0,1,3],[0,0,1,0],[1,2,3,4]]}
True
>>> A == {list2vec(v) for v in [[0,0,5,3],[2,0,1,3]]}
True
>>> z == list2vec([0,2,1,1])
True
>>> from GF2 import one
>>> S = {Vec({0,1,2,3,4}, {i:one, (i+1)%5:one}) for i in range(5)}
>>> A = {list2vec([0,one,one,0,0]),list2vec([0,0,one,one,0])}
>>> z = list2vec([0,0,one,0,one])
>>> exchange(S, A, z) in {list2vec(v) for v in [[one, one,0,0,0],[one,0,0,0,one],[0,0,0,one,one]]}
True
>>> S = {list2vec(v) for v in [[one,0,one,0],[one,one,one,one],[one,one,0,0],[one,one,one,0]]}
>>> A = {list2vec([one,one,one,0])}
>>> z = list2vec([0,one,0,0])
>>> exchange(S, A, z) == list2vec([one,0,one,0])
True
>>> S = {list2vec(v) for v in [[0, 0, 0, one], [0, one, one, one], [0, 0, one, one], [one, 0, 0, 0], [0, one, one, 0]]}
>>> A = {list2vec(v) for v in [[0, one, one, one], [0, 0, 0, one]]}
>>> z = list2vec([0, one, 0, one])
>>> exchange(S, A, z) in [list2vec([0, 0, one, one]), list2vec([0, one, one, 0])]
True
'''
U = S | {z}
V = set([v for v in U if is_superfluous(U,v)])
R = list(V - (A | {z}))
return R[0] if R else list2vec([0 for v in z.D])
def find_matrix_inverse(A):
'''
input: An invertible matrix, A, over GF(2)
output: Inverse of A
>>> M = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (1, 2): 0, (0, 0): 0, (2, 0): 0, (1, 0): one, (2, 2): one, (0, 2): 0, (2, 1): 0, (1, 1): 0})
>>> find_matrix_inverse(M) == Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (2, 0): 0, (0, 0): 0, (2, 2): one, (1, 0): one, (1, 2): 0, (1, 1): 0, (2, 1): 0, (0, 2): 0})
True
'''
R = len(A.D[0])
C = len(A.D[1])
coldict = {}
for i in range(C):
b = [0] * R
b[i] = one
s = solve(A, list2vec(b))
coldict[i] = s
return coldict2mat(coldict)
