snappy 3.3__cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

snappy/snap/slice_obs_HKL/basics.py

@@ -0,0 +1,236 @@
+from ...sage_helper import _within_sage
+if _within_sage:
+    from ...sage_helper import (ZZ, QQ, GF, PolynomialRing, LaurentPolynomialRing,
+                                CyclotomicField, vector, matrix, is_power_of_two,
+                                identity_matrix, block_matrix, gcd,
+                                VectorSpace, MatrixSpace, ChainComplex,
+                                prime_range, prime_powers)
+    
+from ..nsagetools import (MapToFreeAbelianization,
+                          compute_torsion,
+                          fox_derivative_with_involution,
+                          fox_derivative,
+                          fast_determinant_of_laurent_poly_matrix,
+                          last_square_submatrix,
+                          first_square_submatrix)
+
+def print_function(verbose, indent=0):
+    def answer(*args, **kwargs):
+        if verbose:
+            print((indent - 1)*' ', *args, **kwargs)
+    return answer
+
+
+def homology_of_cyclic_branched_cover(knot_exterior, p):
+    C = knot_exterior.covers(p, cover_type='cyclic')[0]
+    return [d for d in C.homology().elementary_divisors() if d != 0]
+
+
+def primes_appearing(knot_exterior, p):
+    """
+       sage: M = Manifold('K12n731')
+       sage: primes_appearing(M, 3)
+       [2, 13]
+    """
+    C = knot_exterior.covers(p, cover_type='cyclic')[0]
+    divisors = C.homology().elementary_divisors()
+    primes = set()
+    for d in divisors:
+        if d != 0:
+            primes.update([p for p, e in ZZ(d).factor()])
+    return sorted(primes)
+
+
+def nonzero_divisor_product(knot_exterior, p):
+    """
+       sage: M = Manifold('K12n731')
+       sage: nonzero_divisor_product(M, 3)
+       2704
+    """
+    C = knot_exterior.covers(p, cover_type='cyclic')[0]
+    divisors = C.homology().elementary_divisors()
+    ans = 1
+    for d in divisors:
+        if d != 0:
+            ans *= d
+    return ans
+
+
+class MatrixRepresentation():
+    """
+    A representation from a finitely-presented group to GL(n, R),
+    where R is a ring::
+
+       sage: MatSp = MatrixSpace(ZZ, 2)
+       sage: S = MatSp([[0, -1], [1, 0]])
+       sage: T = MatSp([[1, 1], [0, 1]])
+       sage: rho = MatrixRepresentation(['s', 't'], [6*'st'], MatSp, [S, T])
+       sage: rho
+       <MatRep from G(st) to GL(2, Integer Ring)>
+       sage: rho(2*'s') == rho(3*'st') == -identity_matrix(2)
+       True
+       sage: rho('ttsTTTsTTsTTstss')
+       [17 29]
+       [ 7 12]
+    """
+    def __init__(self, generators, relators, image_ring, matrices):
+        if isinstance(matrices, dict):
+            images = matrices
+            all_gens = list(generators) + [g.swapcase() for g in generators]
+            assert set(matrices) == set(all_gens)
+        else:
+            assert len(generators) == len(matrices)
+            images = {}
+            for g, m in zip(generators, matrices):
+                images[g] = m
+                images[g.swapcase()] = image_ring(m.inverse())
+
+        self.images = images
+        self.image_ring = image_ring
+        self.base_ring = self.image_ring.base_ring()
+        self.dim = self.image_ring.ncols()
+        self.generators = generators
+        self.relators = relators
+        assert all(m.parent() == self.image_ring for m in images.values())
+        self._check_rep()
+
+    def _check_rep(self):
+        assert all(self(g + g.swapcase()) == 1 for g in self.generators)
+        assert all(self(rel) == 1 for rel in self.relators)
+
+    def range(self):
+        return self.image_ring
+
+    def __call__(self, word):
+        ans = self.image_ring(1)
+        for w in word:
+            ans = ans * self.images[w]
+        return ans
+
+    def __repr__(self):
+        gens = ''.join(self.generators)
+        return '<MatRep from G(' + gens + ') to GL(%s, %s)>' % (self.dim, self.base_ring)
+
+    def twisted_chain_complex(self):
+        """
+        Returns chain complex of the presentation CW complex of the
+        given group with coefficients twisted by self.
+        """
+        gens, rels, rho = self.generators, self.relators, self
+        d2 = [ [fox_derivative_with_involution(R, rho, g) for R in rels] for g in gens]
+        d2 = block_matrix(d2, nrows=len(gens), ncols=len(rels))
+        d1 = [rho(g.swapcase()) - 1 for g in gens]
+        d1 = block_matrix(d1, nrows=1, ncols=len(gens))
+        C = ChainComplex({1:d1, 2:d2}, degree_of_differential=-1, check=True)
+        return C
+
+    def twisted_cochain_complex(self):
+        """
+        Returns the cochain complex of the presentation CW complex of the
+        given group with coefficients twisted by self.
+        """
+        gens, rels, rho = self.generators, self.relators, self
+        d1 = [[fox_derivative(R, rho, g) for g in gens] for R in rels]
+        d1 = block_matrix(d1, nrows=len(rels), ncols=len(gens))
+        d0 = [rho(g) - 1 for g in gens]
+        d0 = block_matrix(d0, nrow=len(gens), ncols=1)
+        C = ChainComplex({0:d0, 1:d1}, check=True)
+        return C
+
+    def semidirect_rep_from_twisted_cocycle(self, cocycle):
+        """
+        Given a representation rho to GL(R, n) and a rho-twisted
+        1-cocycle, construct the representation to GL(R, n + 1)
+        corresponding to the semidirect product.
+
+        Note: Since we prefer to stick to left-actions only, unlike [HLK],
+        this is the semidirect product associated to the left action of
+        GL(R, n) on V = R^n.  That is, pairs (v, A) with v in V and A in
+        GL(R, n) where (v, A) * (w, B) = (v + A*w, A*B)::
+
+          sage: MatSp =  MatrixSpace(GF(5), 2)
+          sage: A, I = MatSp([[0, 4], [1, 4]]), MatSp(1)
+          sage: G = Manifold('K12a169').fundamental_group()
+          sage: rho = MatrixRepresentation(G.generators(), G.relators(), MatSp, [A, I])
+          sage: cocycle = vector(GF(5), (0, 0, 1, 0))
+          sage: rho_til = rho.semidirect_rep_from_twisted_cocycle(cocycle)
+          sage: rho_til('abAB')
+          [1 0 4]
+          [0 1 1]
+          [0 0 1]
+
+        Note: rho here is rep_theory.cyclic_rep(G, A)
+        """
+        gens, rels, rho = self.generators, self.relators, self
+        n = rho.dim
+        assert len(cocycle) == len(gens)*n
+        new_mats = []
+        for i, g in enumerate(gens):
+            v = matrix([cocycle[i*n:(i+1)*n]]).transpose()
+            zeros = matrix(n*[0])
+            one = matrix([[1]])
+            A = block_matrix([[rho(g), v], [zeros, one]])
+            new_mats.append(A)
+
+        target = MatrixSpace(rho.base_ring, n + 1)
+        return MatrixRepresentation(gens, rels, target, new_mats)
+
+# ----- end class MatrixRepresentation --------------------------------
+
+
+
+
+def normalize_polynomial(f):
+    """
+    Multiply by t^-n so that the constant term is nonzero.
+
+       sage: t = PolynomialRing(ZZ, 't').gen()
+       sage: normalize_polynomial(t**3 + 2*t**2)
+       t + 2
+    """
+    e = min(f.exponents())
+    t = f.parent().gen()
+    return f // t**e
+
+
+def twisted_alexander_polynomial(alpha, reduced=False):
+    """
+    In [HKL], alpha is epsilon x rho; in nsagetools, it would be called
+    phialpha with phi being epsilon.  If reduced is True, the answer is
+    divided by (t - 1).
+    """
+    F = alpha('a').base_ring().base_ring()
+    epsilon = alpha.epsilon
+    gens, rels = alpha.generators, alpha.relators
+    k = len(gens)
+
+    # Make sure this special algorithm applies.
+    assert len(rels) == len(gens) - 1 and epsilon.range().rank() == 1
+
+    # Want the first variable to be homologically nontrivial
+    i0 = next(i for i, g in enumerate(gens) if epsilon(g) != 0)
+    gens = gens[i0:] + gens[:i0]
+
+    # Boundary maps for chain complex
+
+    d2 = [ [fox_derivative_with_involution(R, alpha, g) for R in rels] for g in gens]
+    d2 = block_matrix(d2, nrows=k, ncols=k-1)
+    d1 = [alpha(g.swapcase()) - 1 for g in gens]
+    d1 = block_matrix(d1, nrows=1, ncols=k)
+    assert d1 * d2 == 0
+
+    T = last_square_submatrix(d2)
+    B = first_square_submatrix(d1)
+
+    T = normalize_polynomial(fast_determinant_of_laurent_poly_matrix(T))
+    B = normalize_polynomial(fast_determinant_of_laurent_poly_matrix(B))
+
+    q, r = T.quo_rem(B)
+    assert r == 0
+    ans = normalize_polynomial(q)
+    if reduced:
+        t = ans.parent().gen()
+        ans, r = ans.quo_rem(t - 1)
+        assert r == 0
+    return ans
+

snappy/snap/slice_obs_HKL/direct.py

@@ -0,0 +1,217 @@
+"""
+Here, we take a different approach towards computing the HKL
+topological slice obstructions, which in particular allows us to
+consider characters to Z/(q^e Z) where e > 1.
+
+This code corresponds to Section 3.20 of [DG].
+"""
+
+from ...sage_helper import _within_sage, sage_method
+if _within_sage:
+    from ...sage_helper import (gcd, gap, ZZ, is_prime, is_prime_power,
+                                CyclotomicField, MatrixSpace,
+                                LaurentPolynomialRing)
+
+from ..nsagetools import MapToFreeAbelianization
+from .basics import (MatrixRepresentation,
+                     primes_appearing,
+                     homology_of_cyclic_branched_cover,
+                     twisted_alexander_polynomial,
+                     print_function)
+
+from .poly_norm import (poly_is_a_norm,
+                        poly_is_a_norm_in_some_extension)
+
+
+def abelian_p_group_as_gap_polycyclic(p, invariants):
+    assert all(q % p == 0 for q in invariants)
+    facs = [gap.CyclicGroup(q) for q in invariants]
+    G = gap.DirectProduct(facs)
+    return G.IsomorphismSpecialPcGroup().Image()
+
+
+def possible_metabolizers(abelian_p_group):
+    G = abelian_p_group
+    gap.eval("IsNotFail := function(ans) return ans <> fail; end;")
+    order = ZZ(G.Order())
+    facs = order.factor()
+    assert len(facs) == 1
+    p, n = facs[0]
+    assert n % 2 == 0
+    target = p**(n//2)
+    ans = []
+    for S in G.NormalSubgroups():
+        if S.Order() == target:
+            Q = (G/S).IsomorphismSpecialPcGroup().Image()
+            R = S.IsomorphismSpecialPcGroup().Image()
+            if Q.IsomorphismGroups(R).IsNotFail():
+                ans.append(S)
+    return ans
+
+
+def maximal_abelian_p_quotient(gap_fp_group, p):
+    G = gap_fp_group
+    ab_quo = G.MaximalAbelianQuotient()
+    iso1 = ab_quo.Image().IsomorphismSpecialPcGroup()
+    G_ab = iso1.Image()
+    C = G_ab.SylowComplement(p)
+    p_quo = G_ab.NaturalHomomorphismByNormalSubgroup(C)
+    iso2 = p_quo.Image().IsomorphismSpecialPcGroup()
+    # GAP does composition as though function act on the right
+    return ab_quo * iso1 * p_quo * iso2
+
+
+def power_appearing(n, p):
+    n, p = ZZ(n), ZZ(p)
+    assert is_prime(p)
+    if n == 0:
+        return 0
+    ans = 0
+    while n % p == 0:
+        ans += 1
+        n = n // p
+    return ans
+
+
+def order_of_p_part_of_homology(manifold, p):
+    assert is_prime(p)
+    invariants = manifold.homology().elementary_divisors()
+    e = sum(power_appearing(d, p) for d in invariants)
+    return p**e
+
+
+def in_kernel(gap_hom, subgroup):
+    return all(gap_hom.Image(g).IsOne()
+               for g in subgroup.GeneratorsOfGroup())
+
+
+def rep_from_cyclic_quotient(snappy_group, quotient_group, images):
+    C = quotient_group
+    G = snappy_group
+    K = CyclotomicField(C.Order(), 'z')
+    z = K.gen()
+    R = LaurentPolynomialRing(K, 't')
+    t = R.gen()
+    MatSp = MatrixSpace(R, 1)
+
+    f1 = C.GeneratorsOfGroup()[1]
+    assert f1.Order() == C.Order()
+
+    def to_cyc_field(elt):
+        for e in range(int(C.Order())):
+            if elt == f1**e:
+                return z**e
+
+    epsilon = MapToFreeAbelianization(G)
+    gens, rels = G.generators(), G.relators()
+    final_images = [MatSp(t**(epsilon(g)[0]) * to_cyc_field(m))
+                    for g, m in zip(gens, images)]
+    alpha = MatrixRepresentation(gens, rels, MatSp, final_images)
+    alpha.epsilon = epsilon
+    return alpha
+
+
+def gap_group_with_meridian_killed(G):
+    meridian = []
+    for x in G.meridian():
+        if x.islower():
+            meridian.append(x)
+        else:
+            meridian.append(x.lower() + '^-1')
+    meridian = '*'.join(meridian)
+
+    gap_str = G.gap_string()
+    tail = ']; end,[])'
+    assert gap_str.endswith(tail)
+    gap_str = gap_str.replace(tail, ', ' + meridian + tail)
+    return gap(gap_str)
+
+
+def slicing_obstructed_by_larger_quotient(knot_exterior, p, q,
+                                          ribbon_mode=False, verbose=False):
+    """
+    Here, we take a different approach towards computing the HKL
+    topological slice obstructions, which in particular allows us to
+    consider characters to Z/(q^e Z) where e > 1.
+
+    We forgo the representation theory and work directly with the cyclic
+    (branched) covers themselves.  This amounts to using the original
+    theorem in Kirk-Livingston 1999.
+
+    We cut down the number of possible metabolizers via Sawin's
+    observation that if M is a metabolizer of an abelian p-group H with
+    respect to a nondegenerate bilinear form, then H/M is isomorphic to M.
+
+    See Section 3.20 of [DG] for details::
+
+      sage: M = Manifold('16n192088')
+      sage: slicing_obstructed_by_larger_quotient(M, 2, 3, verbose=True)
+              Homology: [ 81 ]
+              Candidate metabolizers: 1
+              Considing cyclic quotients up to size 3^2
+                  Looking at Z/3^1 with 1 remaining
+                  Looking at Z/3^2 with 1 remaining
+                      Now with 0 remaining
+      True
+
+    Note: This code requires GAP, which is standard in SageMath.
+    """
+    print = print_function(verbose, indent=8)
+    M = knot_exterior.copy()
+    assert M.num_cusps() == 1
+    assert is_prime_power(p) and is_prime(q)
+    M.dehn_fill((p, 0))
+    covers = M.covers(p, cover_type='cyclic')
+    assert len(covers) == 1
+    cover = covers[0]
+    H_q_size = order_of_p_part_of_homology(cover, q)
+    if H_q_size == 1:
+        return False
+    cover.dehn_fill((0, 0))
+    G = cover.fundamental_group()
+    Gbar = gap_group_with_meridian_killed(G)
+    quo_q = maximal_abelian_p_quotient(Gbar, q)
+    H_q = quo_q.Image()
+    assert H_q_size == H_q.Order()
+    print(f'Homology: {H_q.AbelianInvariants()}')
+    metas = possible_metabolizers(H_q)
+    print(f'Candidate metabolizers: {len(metas)}')
+    n = max(power_appearing(M.Exponent(), q) for M in metas)
+    print(f'Considing cyclic quotients up to size {q}^{n}')
+
+    remaining_metas = set(range(len(metas)))  # recorded by index
+    for e in range(1, n + 1):
+        if not remaining_metas:
+            break
+
+        print(4*' ' + f'Looking at Z/{q}^{e} with {len(remaining_metas)} remaining')
+        C = gap.CyclicGroup(q**e)
+        cyclic_quos = H_q.GQuotients(C)
+
+        # We sort the cyclic_quotients by how many metas they would each rule out.
+        would_eliminate = []
+        for f in cyclic_quos:
+            new_obs = {i for i, M in enumerate(metas)
+                       if i in remaining_metas and in_kernel(f, M)}
+            if new_obs:
+                would_eliminate.append((f, new_obs))
+
+        would_eliminate.sort(key=lambda x:len(x[1]), reverse=True)
+
+        # Now compute the twisted alexander polynomials
+        for f, obs in would_eliminate:
+            if len(remaining_metas & obs):
+                images = [f.Image(quo_q.Image(g)) for g in Gbar.GeneratorsOfGroup()]
+                alpha = rep_from_cyclic_quotient(G, C, images)
+                alex = twisted_alexander_polynomial(alpha, reduced=True)
+                if ribbon_mode or q != 2:
+                    norm = poly_is_a_norm(alex)
+                else:
+                    norm = poly_is_a_norm_in_some_extension(alex)
+                if not norm:
+                    remaining_metas = remaining_metas - obs
+                    print(8*' ' + f'Now with {len(remaining_metas)} remaining')
+                    if not remaining_metas:
+                        break
+
+    return len(remaining_metas) == 0

snappy/snap/slice_obs_HKL/poly_norm.py

@@ -0,0 +1,212 @@
+"""
+
+Determining when a polynomial whose coefficients lie in a
+CyclotomicField is a norm.
+
+Uses the method of Sections 3.9 and 3.11 of [DG].
+
+"""
+
+
+from ...sage_helper import _within_sage, sage_method
+if _within_sage:
+    from ...sage_helper import (QQ, PolynomialRing, CyclotomicField)
+
+
+def poly_involution(f):
+    """
+       sage: K = CyclotomicField(3, 'z')
+       sage: R = PolynomialRing(K, 't')
+       sage: z, t = K.gen(), R.gen()
+       sage: poly_involution(z*t**2 + (1/z)*t + 1)
+       t^2 + z*t - z - 1
+    """
+    R = f.parent()
+    t = R.gen()
+    K = R.base_ring()
+    if K.is_finite():
+        n = K.degree()
+        assert n % 2 == 0
+        bar = K.galois_group().gen()**(n/2)
+    else:
+        z = K.gen()
+        bar = K.hom([1/z])
+    ans = R(0)
+    d = f.degree()
+    for e in f.exponents():
+        ans += bar(f[e])*t**(d - e)
+    return ans
+
+
+def poly_is_a_norm(g):
+    """
+    Return whether a symmetric polynomial g(t) over a CyclotomicField is
+    equal to (const) f(t) fbar(t) where fbar is poly_involution(f)::
+
+       sage: K = CyclotomicField(5, 'z')
+       sage: R = PolynomialRing(K, 't')
+       sage: z, t = K.gen(), R.gen()
+       sage: f = z*t**2 + (1/z)*t + 1
+       sage: fbar = poly_involution(f)
+       sage: poly_is_a_norm(z**2 * f * fbar * (t - 1)**2)
+       True
+       sage: poly_is_a_norm(f**2 * fbar)
+       False
+       sage: poly_is_a_norm(f * fbar * (t - 1))
+       False
+       sage: poly_is_a_norm(4*t**2 + (z**3 + z**2 + 5)*t + 4)
+       False
+    """
+    factors = dict(g.factor())
+    for h in factors:
+        assert h.is_monic()
+        hbar = poly_involution(h)
+        hbar = hbar/hbar.leading_coefficient()
+        if hbar == h and factors[h] % 2 != 0:
+            return False
+        elif factors[h] != factors[hbar]:
+            return False
+
+    return True
+
+
+###########################################################################
+#
+# Dealing with F_2-homology as in Section 3.11 of [DG].
+#
+###########################################################################
+
+
+# This code was used to generate the `universal_degree_bound` but GAP
+# is invoked in this file.
+
+gap_code = \
+"""
+IsPowerOfTwo := function(n)
+   return 2^PValuation(n, 2) = n;
+end;
+
+# Given a subgroup H of G, checks if
+#
+# a) H is normal in G
+# b) G/H is Z/2^k Z or Z/2 + Z/2^(k - 1)
+#
+# If so, it returns k; otherwise, it returns 0.
+
+QuotientAbelianOfSpecialType := function(G, H)
+   local Q, ab;
+   if IsPowerOfTwo(Index(G, H)) and IsNormal(G, H) then
+      ab := AbelianInvariants(G/H);
+      if Length(ab) = 1 then
+         return PValuation(ab[1], 2);
+      fi;
+      if Length(ab) = 2 and ab[1] = 2 then
+         return PValuation(ab[2], 2) + 1;
+      fi;
+   fi;
+   return 0;
+end;
+
+# For a Galois Group G, return the largest k so that there a normal H
+# in G with [G:H] = 2^k and G/H is Z/2^k Z or Z/2 + Z/2^(k - 1)
+
+DegreeBound := function(G)
+   local sgs;
+   sgs := List(ConjugacyClassesSubgroups(G), C -> Representative(C));
+   return Maximum(List(sgs, H -> QuotientAbelianOfSpecialType(G, H)));
+end;
+
+# This function computes a degree bound that works for any irreducible
+# polynomial of degree n over *any* number field.
+
+UniversalDegreeBound := function(degree)
+   return Maximum(List([1..NrTransitiveGroups(degree)],
+                  k -> DegreeBound(TransitiveGroup(degree, k))));
+end;
+"""
+
+universal_degree_bound = dict([
+    [ 2, 1 ],
+    [ 4, 2 ],
+    [ 6, 2 ],
+    [ 8, 3 ],
+    [ 10, 3 ],
+    [ 12, 3 ],
+    [ 14, 2 ],
+    [ 16, 4 ],
+    [ 18, 4 ],
+    [ 20, 4 ],
+    [ 22, 2 ],
+    [ 24, 4 ],
+    [ 26, 3 ],
+    [ 28, 3 ],
+    [ 30, 4 ]])
+
+
+def size_split_field_intersect_cyclotomic(poly):
+    """
+    Let G be the Galois group of the given irreducible polynomial. We
+    compute the largest size of G/H where:
+
+    1. H is normal in G, with [G:H] = 2^k.
+
+    2. G/H is abelian and either Z/2^k or Z/2 + Z/2^(k - 1).
+
+    The result is an upper bound on the degree d = 2^k over Q of the
+    intersection of the splitting field of the polynomial with
+    CyclotomicField(2^infinity).  The number k is returned.
+
+    Note: Here we just return the universal degree bound. The
+    implementation used in [SG] computed the actual Galois group when
+    the field is QQ but this avoids a dependency on GAP.
+    """
+    if poly.degree() <= 1:
+        return 0
+
+    return universal_degree_bound[poly.degree()]
+
+
+def poly_is_a_norm_in_some_extension(g):
+    """
+    Given a symmetric polyomial over the rationals, return whether it
+    is a norm in *any* CyclotomicField(2**k, 'z')::
+
+      sage: t = PolynomialRing(QQ, 't').gen()
+      sage: f = (t - 1)*(t**2 - 3*t + 1)
+      sage: poly_is_a_norm_in_some_extension(f)
+      False
+      sage: f = (t**2 - t + 1)**2 * (t**2 - 3*t + 1)
+      sage: poly_is_a_norm_in_some_extension(f)
+      False
+      sage: f = t**4 + 4*t**2 + 1
+      sage: poly_is_a_norm_in_some_extension(f)
+      True
+    """
+    K = g.parent().base_ring()
+    if K == QQ:
+        cyc_order = 1
+    else:
+        assert isinstance(K, type(CyclotomicField(4, 'z')))
+        cyc_order = K.degree() * 2
+
+    factors = dict(g.factor())
+    for h in factors:
+        assert h.is_monic()
+        hbar = poly_involution(h)
+        hbar = hbar/hbar.leading_coefficient()
+        if hbar == h:
+            if factors[h] % 2 == 0:
+                continue
+            else:
+                if h.degree() % 2 == 1:  # any norm has even degree
+                    return False
+                k = size_split_field_intersect_cyclotomic(h)
+                K = CyclotomicField(2**(cyc_order + k + 1), 'z')
+                if not poly_is_a_norm(h.change_ring(K)):
+                    return False
+
+        elif factors[h] != factors[hbar]:
+            return False
+
+    return True
+