Description
This function computes the normalization functor from the category of simplicial modules to the category of nonnegatively-graded chain complexes. It is implemented in a functorial way, applying both to simplicial modules and simplicial module maps.
The normalization of a simplicial module $S$ is by definition equal to the complex $N (S)$ with: $$N(S)_n := \bigcap_{i=1}^n \ker d^S_{(n,i)},$$ with differential induced by the face map $d_{(n,0)}^S$. As currently implemented, the normalization does not prune the output; the user should use prune to obtain the best looking output.
The normalize command is implemented so that it first checks whether a simplicial module has been obtained as the Dold-Kan image of some complex. If it has, then it returns that complex without doing any additional computation. If the user prefers that the normalization is computed by definition instead of accessing this cached value, use the option CheckComplex => false.
i1 : R = ZZ/101[x_1..x_3];
|
i2 : K = koszulComplex vars R
1 3 3 1
o2 = R <-- R <-- R <-- R
0 1 2 3
o2 : Complex
|
i3 : S = simplicialModule(K,10, Degeneracy => true)
1 4 10 20 35 56 84 120 165 220 286
o3 = R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- ...
0 1 2 3 4 5 6 7 8 9 10
o3 : SimplicialModule
|
i4 : keys S
o4 = {complexLength, module, ss, dd, ring, complex, topDegree, cache}
o4 : List
|
i5 : K == normalize S
o5 = true
|
i6 : Kn = normalize(S, CheckComplex => false)
1
o6 = R <-- image {0} | 0 0 0 | <-- image {0} | 0 0 0 | <-- image {0} | 0 |
{1} | 1 0 0 | {1} | 0 0 0 | {1} | 0 |
0 {1} | 0 1 0 | {1} | 0 0 0 | {1} | 0 |
{1} | 0 0 1 | {1} | 0 0 0 | {1} | 0 |
{1} | 0 0 0 | {1} | 0 |
1 {1} | 0 0 0 | {1} | 0 |
{1} | 0 0 0 | {1} | 0 |
{2} | 1 0 0 | {1} | 0 |
{2} | 0 1 0 | {1} | 0 |
{2} | 0 0 1 | {1} | 0 |
{2} | 0 |
2 {2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{3} | 1 |
3
o6 : Complex
|
i7 : Kn.dd
1
o7 = 0 : R <------------------- image {0} | 0 0 0 | : 1
| x_1 x_2 x_3 | {1} | 1 0 0 |
{1} | 0 1 0 |
{1} | 0 0 1 |
1 : image {0} | 0 0 0 | <-------------------------- image {0} | 0 0 0 | : 2
{1} | 1 0 0 | {1} | -x_2 -x_3 0 | {1} | 0 0 0 |
{1} | 0 1 0 | {1} | x_1 0 -x_3 | {1} | 0 0 0 |
{1} | 0 0 1 | {1} | 0 x_1 x_2 | {1} | 0 0 0 |
{1} | 0 0 0 |
{1} | 0 0 0 |
{1} | 0 0 0 |
{2} | 1 0 0 |
{2} | 0 1 0 |
{2} | 0 0 1 |
2 : image {0} | 0 0 0 | <---------------- image {0} | 0 | : 3
{1} | 0 0 0 | {2} | x_3 | {1} | 0 |
{1} | 0 0 0 | {2} | -x_2 | {1} | 0 |
{1} | 0 0 0 | {2} | x_1 | {1} | 0 |
{1} | 0 0 0 | {1} | 0 |
{1} | 0 0 0 | {1} | 0 |
{1} | 0 0 0 | {1} | 0 |
{2} | 1 0 0 | {1} | 0 |
{2} | 0 1 0 | {1} | 0 |
{2} | 0 0 1 | {1} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{2} | 0 |
{3} | 1 |
o7 : ComplexMap
|
i8 : K == Kn
o8 = false
|
i9 : K == prune Kn
o9 = true
|
For computational efficiency, this method also checks if the simplicial module has been constructed as a direct sum of simplicial modules. If it has, then it returns the direct sum of the normalizations of each component. If the user prefers that this shortcut is not taken, use CheckSum => false.
i10 : S10 = directSum toList(10: forgetComplex S)
10 40 100 200 350 560 840 1200 1650 2200 2860
o10 = R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- R <-- ...
0 1 2 3 4 5 6 7 8 9 10
o10 : SimplicialModule
|
i11 : elapsedTime prune normalize S10
-- 4.99634s elapsed
10 30 30 10
o11 = R <-- R <-- R <-- R
0 1 2 3
o11 : Complex
|
i12 : elapsedTime prune normalize(S10, CheckSum => false) --about 3-4 times slower; becomes significant for larger ranks
-- 6.72868s elapsed
10 30 30 10
o12 = R <-- R <-- R <-- R
0 1 2 3
o12 : Complex
|
The user may also specify the top homological degree to compute the normalization up to. Note that this can help speed up computational time; if the user knows the normalization should have a shorter length, then they should specify this upper bound in the syntax:
i13 : elapsedTime prune normalize(S10, 3, CheckSum => false) --MUCH FASTER!
-- .0314128s elapsed
10 30 30 10
o13 = R <-- R <-- R <-- R
0 1 2 3
o13 : Complex
|
Again, this method is functorial, and when combined with other methods in this package can be a particularly powerful way of obtaining nontrivial morphisms of complexes. We use this method to obtain the image of the inclusion $$\bigwedge^3 K \to \bigwedge^2 K \otimes K$$ for a Koszul complex K. Constructing this map directly using the naive definitions of tensor products/exterior powers of complexes is not possible in full generality. Taking advantage of the Dold-Kan correspondence and simplicial methods allows us to obtain this inclusion explicitly.
i14 : Q = ZZ/3[a,b];
|
i15 : K = koszulComplex vars Q
1 2 1
o15 = Q <-- Q <-- Q
0 1 2
o15 : Complex
|
i16 : SK = simplicialModule(K,6) --want top degree 6 since the resulting complexes should have length 6
1 3 6 10 15 21 28
o16 = Q <-- Q <-- Q <-- Q <-- Q <-- Q <-- Q <-- ...
0 1 2 3 4 5 6
o16 : SimplicialModule
|
i17 : w21K = extPower(2, SK) ** SK
9 90 450 1575 4410 10584
o17 = 0 <-- Q <-- Q <-- Q <-- Q <-- Q <-- Q <-- ...
0 1 2 3 4 5 6
o17 : SimplicialModule
|
i18 : w3K = extPower(3, SK)
1 20 120 455 1330 3276
o18 = 0 <-- Q <-- Q <-- Q <-- Q <-- Q <-- Q <-- ...
0 1 2 3 4 5 6
o18 : SimplicialModule
|
i19 : H = hashTable for i from 0 to 6 list i => dual wedgeProduct(2,1, dual SK_i);
|
i20 : inclusion = map(w21K, w3K, H);
|
i21 : inc = prune normalize(inclusion,3);
|
i22 : isWellDefined inc
o22 = true
|
i23 : isCommutative inc
o23 = true
|
Taking the cokernel of the above morphism yields a canonically defined Schur functor $\mathbb{S}^{(2,1)} (K)$; constructing this complex using the classical Schur complex definition will yield a complex that does not have finite length homology (and hence isn't even homotopically equivalent).
i24 : S21K = prune coker inc --this is only a snapshot; should go up to degree 6
8 54 144
o24 = Q <-- Q <-- Q
1 2 3
o24 : Complex
|
i25 : (minimize S21K).dd
2 5
o25 = 1 : Q <---------------------- Q : 2
{1} | a 0 b 0 -b |
{1} | 0 a a b a |
5 101
2 : Q <------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Q : 3
{2} | -b 0 b 0 -b 0 0 b2 0 b2 0 0 0 0 -ab b2 0 -b2 0 -b2 b2 0 0 0 0 0 0 b2 -b2 0 b2 b2 0 ab 0 0 0 0 0 b2 0 0 0 0 0 -ab b2 b2 0 0 0 0 0 -b2 b2 ab2 0 -ab2 0 ab2 b3 ab2 b3 0 b3 0 b3 ab2 0 0 b3 0 0 ab2 0 b3 0 0 0 0 0 -ab2 -b3 0 0 0 0 ab2 b3 ab2 b3 0 0 ab3 ab3 0 0 0 0 0 0 |
{2} | -a -b -a -b 0 0 0 ab 0 ab 0 b2 0 0 -a2 -ab 0 0 0 -ab -ab -b2 0 0 0 0 0 ab 0 b2 0 0 0 -a2 -ab 0 0 0 0 -ab -b2 0 0 0 0 -a2 -ab -ab -b2 0 0 0 0 0 0 a2b ab2 -a2b 0 a2b ab2 0 0 0 0 0 ab2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 a2b2 0 0 0 0 0 0 |
{2} | a 0 0 b -a b 0 -ab 0 -ab 0 0 0 0 a2 -ab 0 ab 0 ab -ab 0 0 0 0 0 0 -ab ab 0 -ab -ab 0 0 ab 0 0 0 0 0 b2 0 0 0 0 a2 -ab -ab 0 0 0 0 0 ab -ab -a2b 0 a2b 0 -a2b -ab2 -a2b -ab2 0 -ab2 0 -ab2 -a2b 0 0 -ab2 0 0 -a2b 0 -ab2 0 0 0 0 0 a2b ab2 0 0 0 0 -a2b -ab2 -a2b -ab2 0 0 -a2b2 -a2b2 0 0 0 0 0 0 |
{2} | 0 a 0 -a 0 a 0 0 0 0 0 -ab 0 0 0 -a2 0 -a2 0 0 -a2 ab 0 0 0 0 0 0 -a2 -ab a2 a2 0 0 -a2 0 0 0 0 0 -ab 0 0 0 0 0 -a2 -a2 ab 0 0 0 0 -a2 a2 0 -a2b 0 0 0 0 a3 a2b 0 a2b 0 0 a3 0 0 a2b 0 0 a3 0 a2b 0 0 0 0 0 -a3 -a2b 0 0 0 0 a3 a2b a3 a2b 0 0 a3b 0 0 0 0 0 0 0 |
{2} | 0 0 a b a b 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 a2 ab 0 0 0 0 ab b2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 |
o25 : ComplexMap
|
i26 : prune HH S21K --free part is because we truncated
98
o26 = cokernel {1} | b a 0 0 | <-- cokernel {2} | b a | <-- Q
{1} | 0 0 b a |
2 3
1
o26 : Complex
|