def randchain(ring, n, m):
V = Space(ring, n, 1, "V")
U = Space(ring, m, 0, "U")
B = Lin.rand(U, V)
A = B.kernel()
A = Lin(A.tgt, A.src.asgrade(2), A.A) # yikes
assert (B * A).is_zero()
C = B.cokernel()
C = Lin(C.tgt.asgrade(-1), C.src, C.A)
assert (C * B).is_zero()
c = Chain([A, B, C])
return c
def test_chain_tensor():
#p = argv.get("p", 3)
#ring = element.FiniteField(p)
ring = element.Q
space = Space(ring)
m = argv.get("m", 3)
n = argv.get("n", 4)
one = ring.one
if argv.toric:
V = Space(ring, n, 1, "V")
U = Space(ring, m, 0, "U")
A = Lin(U, V)
for i in range(m):
A[i, i] = one
A[i, (i + 1) % m] = -one
elif argv.surface:
V = Space(ring, m, 1, "V")
U = Space(ring, m - 1, 0, "U")
A = Lin(U, V)
for i in range(m - 1):
A[i, i] = one
A[i, (i + 1) % m] = -one
else:
V = Space(ring, n, 1, "V")
U = Space(ring, m, 0, "U")
A = Lin.rand(U, V)
c = Chain([A])
print(c)
c.dump()
def rand(cls, tgt, src):
assert tgt.hom == src.hom
shape = tgt.shape
lins = [[Lin.rand(tgt[i, j], src[i, j]) for j in range(shape[1])]
for i in range(shape[0])]
return Cell2(tgt, src, lins)
def test_chainmap():
p = argv.get("p", 2)
ring = element.FiniteField(p)
#ring = element.Q
one = ring.one
space = Space(ring)
def mk_ising(m, n):
U = Space(ring, m, 0, "U")
V = Space(ring, n, 1, "V")
A = Lin(U, V) # U <--- V
for i in range(m):
A[i, i] = one
if i + 1 < n:
A[i, i + 1] = -one
return A
A = mk_ising(3, 4)
c = Chain([A])
f = c.identity()
zero = ChainMap(c, c)
assert f != zero
assert f == f
assert f != 2 * f
assert f + f == 2 * f
assert f - f == zero
B = mk_ising(2, 2)
d = Chain([B])
fn = Lin(A.src, B.src)
for i in range(len(B.src)):
fn[i, i] = one
fm = Lin(A.tgt, B.tgt)
for i in range(len(B.tgt)):
fm[i, i] = one
f = ChainMap(c, d, [fn, fm])
# -----------------------------------
m, n = 8, 10
V1 = Space(ring, n, 1, "V1")
V0 = Space(ring, m, 0, "V0")
A = Lin.rand(V0, V1) # V0 <--- V1
c = Chain([A])
U0 = Space(ring, m, 0, "U0")
f0 = Lin.rand(V0, U0)
f1, B = A.pullback(f0)
d = Chain([B])
f = ChainMap(c, d, [f1, f0])
# -----------------------------------
# construct a chain map (and a chain) from a
# pullback of a grade zero map.
m, n, p = 5, 6, 1
V1 = Space(ring, n, 1, "V1")
V0 = Space(ring, m, 0, "V0")
#A = Lin.rand(V0, V1) # V0 <--- V1
A = Lin(V0, V1)
for i in range(m):
A[i, i] = one
A[i, (i + 1)] = one
a = Chain([A])
#print("A:")
#print(A)
U0 = Space(ring, p, 0, "U0")
f0 = Lin(V0, U0)
for i in range(p):
f0[i, i] = one
f1, B = A.pullback(f0)
b = Chain([B])
#print("B:")
#print(B)
f = ChainMap(a, b, [f1, f0])
#print(f0)
#print(f1)
g = ChainMap(a, b)
h = f.coequalizer(g)
#print(h)
#print(h[0])
#print(h[1])
c = h.tgt
C = c[0]
#print(C.shape, C.rank())
#print(C)
# -----------------------------------
# construct a 'puncture' of a repitition code
# as a cokernel
m, n, p = 5, 6, 1
V1 = Space(ring, n, 1, "V1")
V0 = Space(ring, m, 0, "V0")
#A = Lin.rand(V0, V1) # V0 <--- V1
A = Lin(V0, V1)
for i in range(m):
A[i, i] = one
A[i, (i + 1)] = one
a = Chain([A])
U1 = Space(ring, 1, 1, "U1")
U0 = Space(ring, 2, 0, "U0")
B = Lin(U0, U1)
B[0, 0] = one
B[1, 0] = one
b = Chain([B])
offset = 2 # where to puncture
f0 = Lin(V0, U0)
f0[0 + offset, 0] = one
f0[1 + offset, 1] = one
f1 = Lin(V1, U1)
f1[offset + 1, 0] = one
f = ChainMap(a, b, [f1, f0])
h = f.cokernel()
c = h.tgt
# -----------------------------------
# Here we puncture a bit from a parity check matrix
# by using a cokernel. This deletes that column,
# as well as all the rows with support therein.
m, n, p = 5, 6, 1
V1 = Space(ring, n, 1, "V1")
V0 = Space(ring, m, 0, "V0")
A = Lin.rand(V0, V1) # V0 <--- V1
a = Chain([A])
#print(A)
col = 0
rows = []
for i in range(V0.n):
if A[i, col]:
rows.append(i)
U1 = Space(ring, 1, 1, "U1")
U0 = Space(ring, len(rows), 0, "U0")
B = Lin(U0, U1)
for i in range(U0.n):
B[i, 0] = one
b = Chain([B])
#print(B)
f0 = Lin(V0, U0)
for i, row in enumerate(rows):
f0[row, i] = one
#print(f0)
f1 = Lin(V1, U1)
f1[col, 0] = one
f = ChainMap(a, b, [f1, f0])
h = f.cokernel()
c = h.tgt
