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
'''
R=[]
C=[]
R_dict = mat2rowdict(M)
C_dict = mat2coldict(M)
for k,v in R_dict.items():
R.append(v)
for k,v in C_dict.items():
C.append(v)
if rank(R) != rank(C):
return False
elif my_is_independent(R) == False:
return False
elif my_is_independent(C) == False:
return False
return True
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
'''
R = []
C = []
R_dict = mat2rowdict(M)
C_dict = mat2coldict(M)
for k, v in R_dict.items():
R.append(v)
for k, v in C_dict.items():
C.append(v)
if rank(R) != rank(C):
return False
elif my_is_independent(R) == False:
return False
elif my_is_independent(C) == False:
return False
return True
def is_invertible(M):
numCol = len(M.D[1])
# print(numCol)
# print(rank(list((mat2coldict(M)).values())))
# print(rank(list((mat2rowdict(M)).values())))
colRank = rank(list((mat2coldict(M)).values()))
rowRank = rank(list((mat2rowdict(M)).values()))
if (numCol - colRank) == 0:
return True
elif (numCol - rowRank) == 0:
return True
else:
return False
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
'''
col = list(mat2coldict(M).values())
row = list(mat2rowdict(M).values())
return rank(col) == len(col) and rank(row) == len(row)
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
'''
col = list(mat2coldict(M).values())
row = list(mat2rowdict(M).values())
return rank(col) == len(col) and rank(row) == len(row)
def get_basis(U): rank_ = rank(U) #already contains independent vectors if my_is_independent(U): return U # if not there are superfluous vectors U_basis = [] r = 0 for u in U: if rank(U_basis+[u]) > r: U_basis.append(u) r = rank[u] if r == rank_: return U_basis
def my_is_independent(L):
"""
input: A list, L, of Vecs
output: A boolean indicating if the list is linearly independent
>>> 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})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
"""
from independence import rank
rank_num = rank(L)
if rank_num < len(L):
return False
else:
return True
def is_independent_set(v):
for i in combinations(v, 3):
a, b = zip(*i)
M = list(a) + list(b)
if len(M) != rank(M):
return False
return True
def my_is_independent(L):
'''
Input:
- L: a list of Vecs
Output:
- boolean: true if the list is linearly independent
Examples:
>>> D = {0, 1, 2}
>>> L = [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
>>> L == [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
True
'''
from independence import rank
return rank(L) == len(L)
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 my_is_independent(L):
'''
Input:
- L: a list of Vecs
Output:
- boolean: true if the list is linearly independent
Examples:
>>> D = {0, 1, 2}
>>> L = [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
>>> L == [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
True
'''
return rank(L) == len(L)
def is_independent_set(v): for i in combinations(v,3): a,b=zip(*i) M=list(a)+list(b) if len(M) != rank(M): return False return True
def my_is_independent(L):
'''
input: A list, L, of Vecs
output: A boolean indicating if the list is linearly independent
>>> 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})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
'''
return len(L) == rank(L)
def my_is_independent(L):
if len(L) == independence.rank(L):
return True
else:
return False
'''
input: A list, L, of Vecs
output: A boolean indicating if the list is linearly independent
>>> 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})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
'''
pass
def my_is_independent(L):
'''
input: A list, L, of Vecs
output: A boolean indicating if the list is linearly independent
>>> 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})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
'''
from independence import rank
rank_num = rank(L)
if rank_num < len(L):
return False
else:
return True
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
'''
from independence import is_independent, rank
Mcols = list(mat2coldict(M).values())
Mrows = list(mat2rowdict(M).values())
colrank = rank(Mcols)
return len(Mcols) == len(Mrows) == rank(Mcols)
def sel_all_vecs():
'''
Algo:
1. Start with a0,b0, grow a1,b1,a2,b2 randomly so they are linearly independent.
2. Keep generating random a3,b3 until any 3 pairs of vecs are linearly independent.
3. Keep generating random a4,b4 until any 3 pairs of vecs are linearly independent.
'''
selected = False
while not selected:
fivePairs = []
fivePairs.append((a0, b0))
fivePairs.append((a1, b1))
fivePairs.append((a2, b2))
fivePairs.append((a3, b3))
fivePairs.append((generateSecretVector(a0.D), generateSecretVector(a0.D)))
threePairsList = generateAllThreePairsList(fivePairs)
passed = False
# Look at the printed value of Threes and modify the list below
# based on this
t0 = threePairsList[0]
t1 = threePairsList[1]
t2 = threePairsList[2]
t3 = threePairsList[3]
t4 = threePairsList[4]
t5 = threePairsList[5]
t6 = threePairsList[6]
t7 = threePairsList[7]
t8 = threePairsList[8]
t9 = threePairsList[9]
r1 = independence.rank(t0[0]+t0[1]+t0[2])
r2 = independence.rank(t1[0]+t1[1]+t1[2])
r3 = independence.rank(t2[0]+t2[1]+t2[2])
r4 = independence.rank(t3[0]+t3[1]+t3[2])
r5 = independence.rank(t4[0]+t4[1]+t4[2])
r6 = independence.rank(t5[0]+t5[1]+t5[2])
r7 = independence.rank(t6[0]+t6[1]+t6[2])
r8 = independence.rank(t7[0]+t7[1]+t7[2])
r9 = independence.rank(t8[0]+t8[1]+t8[2])
r10 = independence.rank(t9[0]+t9[1]+t9[2])
if r1 == r2 ==r3 == r4==r5==r6==r7==r8==r9==r10 and r1 == 6:
print(t0)
print(t1)
print(t2)
def my_rank(L):
'''
input: A list, L, of Vecs
output: The rank of the list of Vecs
>>> my_rank([list2vec(v) for v in [[1,2,3],[4,5,6],[1.1,1.1,1.1]]])
2
'''
return (rank(subset_basis(L)))
def my_is_independent(L):
'''
input: A list, L, of Vecs
output: A boolean indicating if the list is linearly independent
'''
if len(L) > rank(L):
return False
return True
def my_is_independent(L): cols = len(L) rows = len(L[0].D) rank_ = min(cols,rows) if rank(L) == rank_: return True else: False
def my_rank(L):
'''
input: A list, L, of Vecs
output: The rank of the list of Vecs
>>> my_rank([list2vec(v) for v in [[1,2,3],[4,5,6],[1.1,1.1,1.1]]])
2
'''
from independence import rank
return rank(L)
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
'''
return True if rank(list(mat2coldict(M).values())) == len(M.D[1]) and len(M.D[1]) == len(M.D[0]) else False
def factor_woojoo(N, primeset):
roots, rowlist = find_candidates(N, primeset)
M = echelon.transformation_rows(rowlist, sorted(primeset, reverse=True))
rank = independence.rank(rowlist)
for i in range(len(M) - 1, rank - 1, -1):
a, b = find_a_and_b(M[i], roots, N)
ans = gcd(a - b, N)
if ans > 1:
return ans
return None
def my_rank(L):
'''
input: A list, L, of Vecs
output: The rank of the list of Vecs
>>> my_rank([list2vec(v) for v in [[1,2,3],[4,5,6],[1.1,1.1,1.1]]])
2
'''
from independence import rank
return rank(L)
def is_invertible(M):
'''
input: A matrix, M
output: 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
'''
if M.D[0] != M.D[1]: return False
rowdict = mat2rowdict(M)
rowlist = list (rowdict.values())
coldict = mat2coldict (M)
collist = list(coldict.values())
# check if the matrix is square and the columns are independent
if rank(rowlist) == rank (collist) and len (collist) == rank (collist): return True
else: return False
def subset_basis(T):
'''
input: A list, T, of Vecs
output: A list, S, containing Vecs from T, that is a basis for the
space spanned by T.
>>> 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})
>>> subset_basis([a0,a1,a2,a3]) == [Vec({'c', 'b', 'a', 'd'},{'a': 1}), Vec({'c', 'b', 'a', 'd'},{'b': 1}), Vec({'c', 'b', 'a', 'd'},{'c': 1})]
True
'''
rank_T = rank(T)
S = []
for x in T:
if(is_independent([S+[x]])):
S.append(x)
if rank(S) == rank_T:break
return S
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
'''
return len(M.D[0]) == len(M.D[1]) and rank(mat2collist(M)) == len(
mat2collist(M))
def morph(S,B): #B is independent list #S is list of vectors # Span(S) = Span(B) returned_list = [] rank_B = rank(B) for b in B: # if set(B) == set(S_rem): # break B.pop(0) cond = B for s in S: if rank(cond+[s])==rank_B: B.append(s) S.remove(s) returned_list.append([b,s]) return returned_list
def subset_basis(T):
"""
input: A list, T, of Vecs
output: A list, S, containing Vecs from T, that is a basis for the
space spanned by T.
>>> 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})
>>> subset_basis([a0,a1,a2,a3]) == [Vec({'c', 'b', 'a', 'd'},{'a': 1}), Vec({'c', 'b', 'a', 'd'},{'b': 1}), Vec({'c', 'b', 'a', 'd'},{'c': 1})]
True
"""
S = []
curRank = 0
for iVec in T:
if rank(S + [iVec]) > curRank:
S.append(iVec)
curRank = rank(S)
return S
def subset_basis(T):
'''
input: A list, T, of Vecs
output: A list, S, containing Vecs from T, that is a basis for the
space spanned by T.
>>> 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})
>>> subset_basis([a0,a1,a2,a3]) == [Vec({'c', 'b', 'a', 'd'},{'a': 1}), Vec({'c', 'b', 'a', 'd'},{'b': 1}), Vec({'c', 'b', 'a', 'd'},{'c': 1})]
True
'''
S = []
curRank = 0
for iVec in T:
if rank(S + [iVec]) > curRank:
S.append(iVec)
curRank = rank(S)
return S
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
"""
if len(M.D[0]) != len(M.D[1]):
return False
L = list(mat2coldict(M).values())
return rank(L) == len(L)
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
'''
# 1. cardinality of row = cardinality of column
# 2. column vectors are linearly independent
c=mat2coldict(M)
return rank([c[x] for x in c]) == len(M.D[1]) and len(M.D[0]) == len(M.D[1])
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
'''
if M.D[0]!=M.D[1]:
return False
M=mat2coldict(M)
M=list(M.values())
return rank(M)==len(M)
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
'''
from matutil import mat2coldict
from independence import rank
if len(M.D[0]) == len(M.D[1]):
M = mat2coldict(M)
M = list(M.values())
return rank(M) == len(M)
return False
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 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
>>> M1 = Mat(({0,1,2},{0,1,2}),{(0,0):1,(0,2):2,(1,2):3,(2,2):4})
>>> is_invertible(M1)
False
'''
if len(M.D[0]) != len(M.D[1]):
return False
if rank(list(mat2coldict(M).values())) != len(M.D[1]):
return False
return True
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 my_is_independent(L):
"""
input: A list, L, of Vecs
output: A boolean indicating if the list is linearly independent
>>> 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})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
"""
return rank(L) == len(L)
def my_is_independent(L):
'''
Input:
- L: a list of Vecs
Output:
- boolean: true if the list is linearly independent
Examples:
>>> D = {0, 1, 2}
>>> L = [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
>>> L == [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
True
'''
"""
for x in L:
if is_superfluous(set(L),x)==True:
return False
return True
"""
from independence import rank
rank_num = rank(L)
if rank_num < len(L):
return False
else:
return True
def my_is_independent(L):
'''
Input:
- L: a list of Vecs
Output:
- boolean: true if the list is linearly independent
Examples:
>>> D = {0, 1, 2}
>>> L = [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
>>> L == [Vec(D,{0: 1}), Vec(D,{1: 1}), Vec(D,{2: 1}), Vec(D,{0: 1, 1: 1, 2: 1}), Vec(D,{0: 1, 1: 1}), Vec(D,{1: 1, 2: 1})]
True
'''
"""
for x in L:
if is_superfluous(set(L),x)==True:
return False
return True
"""
from independence import rank
rank_num = rank(L)
if rank_num < len(L):
return False
else:
return True
def my_is_independent(L):
'''
input: A list, L, of Vecs
output: A boolean indicating if the list is linearly independent
>>> 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})]
>>> my_is_independent(L)
False
>>> my_is_independent(L[:2])
True
>>> my_is_independent(L[:3])
True
>>> my_is_independent(L[1:4])
True
>>> my_is_independent(L[0:4])
False
>>> my_is_independent(L[2:])
False
>>> my_is_independent(L[2:5])
False
'''
from independence import rank
return True if rank(L) == len(L) else False
def my_is_independent(veclist):
return len(veclist) == rank(veclist)
def my_is_independent(L):
return len(L) == rank(L)
'''
lst = []
for l in L:
lst.extend(l)
return lst
secret_a0 = list2vec([one, one, 0, one, 0, one])
secret_b0 = list2vec([one, one, 0, 0, 0, one])
# make initial list of 6 independent vectors
A = [secret_a0, secret_b0]
r = 2
while r < 6:
v = list2vec([randGF2() for i in range(6)])
A.append(v)
temp_rank = rank(A)
if temp_rank == r+1:
r += 1
else:
A.remove(v)
while len(A) < 10:
v1 = list2vec([randGF2() for i in range(6)])
v2 = list2vec([randGF2() for i in range(6)])
L = split_couples(A)
L.append([v1, v2])
C = combinations(L, 3)
valid = all([rank(join_couples(i))==6 for i in C])
if valid:
A.extend([v1, v2])
output: The rank of the list of Vecs
>>> my_rank([list2vec(v) for v in [[1,2,3],[4,5,6],[1.1,1.1,1.1]]])
2
'''
return len(subset_basis(L))
## Problem 8
# Please give each answer as a boolean
u1 = [one, 0, one, 0]
u2 = [0, 0, one, 0]
v1 = [0, one, 0, one]
v2 = [0, 0, 0, one]
urank = rank([list2vec(v) for v in [u1, u2]])
vrank = rank([list2vec(v) for v in [v1, v2]])
combinedrank = rank([list2vec(v) for v in [u1, u2, v1, v2]])
only_share_the_zero_vector_1 = combinedrank == urank + vrank
u1 = [1, 2, 3]
u2 = [1, 2, 0]
v1 = [2, 1, 3]
v2 = [2, 1, 3]
urank = my_rank([list2vec(v) for v in [u1, u2]])
vrank = my_rank([list2vec(v) for v in [v1, v2]])
combinedrank = my_rank([list2vec(v) for v in [u1, u2, v1, v2]])
only_share_the_zero_vector_2 = combinedrank == urank + vrank
u1 = [2, 0, 8, 0]
u2 = [1, 1, 4, 0]
v1 = [2, 1, 1, 1]
v2 = [0, 1, 1, 1]
output: The rank of the list of Vecs >>> my_rank([list2vec(v) for v in [[1,2,3],[4,5,6],[1.1,1.1,1.1]]]) 2 ''' return len(subset_basis(L)) ## Problem 8 # Please give each answer as a boolean u1=[one,0,one,0] u2=[0,0,one,0] v1=[0,one,0,one] v2=[0,0,0,one] urank=rank([list2vec(v) for v in [u1,u2]]) vrank=rank([list2vec(v) for v in [v1,v2]]) combinedrank=rank([list2vec(v) for v in [u1,u2,v1,v2]]) only_share_the_zero_vector_1 = combinedrank==urank+vrank u1=[1,2,3] u2=[1,2,0] v1=[2,1,3] v2=[2,1,3] urank=my_rank([list2vec(v) for v in [u1,u2]]) vrank=my_rank([list2vec(v) for v in [v1,v2]]) combinedrank=my_rank([list2vec(v) for v in [u1,u2,v1,v2]]) only_share_the_zero_vector_2 = combinedrank==urank+vrank u1=[2,0,8,0] u2=[1,1,4,0] v1=[2,1,1,1] v2=[0,1,1,1]
