snappy 3.2__cp311-cp311-macosx_10_12_x86_64.whl

snappy/ptolemy/homology.py

@@ -0,0 +1,165 @@
+from . import matrix
+
+
+def _gcd(s, t):
+    if t == 0:
+        return s
+    return _gcd(t, s % t)
+
+
+def homology_basis_representatives_with_orders(d1, d2, N):
+    """
+    Given two matrices d1 and d2 such that d1 * d2 = 0, computes the
+    homology H_1 = ker(d1) / im(d2) when using Z (when N = 0)
+    or Z/N coefficients. The result is a list of pairs (vector, order)
+    forming a basis of H_1 as Abelian group.
+    A pair (vector, order) consists of a vector c_1 in ker(d1) representing a
+    homology class [c_1] in H_1 with the integer order being the order of [c_1]
+    if it is finite otherwise 0.
+    """
+
+    # two consecutive maps in a chain complex should give zero
+    assert matrix.is_matrix_zero(
+        matrix.matrix_mult(d1, d2))
+
+    # Change the basis of the chain groups C_0, C_1, C_2 by the matrices
+    # basechangeN
+    # transformed_d1 and transformed_d2 are the boundary maps d1 and d2 but
+    # with respect to the new basis. In this new basis, the boundary maps will
+    # have at most one non-zero entry per row, respectively, per column so that
+    # we can directly read of whether a basis vector is in ker(d1) and im(d2).
+    basechange0, basechange1, basechange2, transformed_d1, transformed_d2 = (
+        matrix.simultaneous_smith_normal_form(d1, d2))
+
+    # Perform consistency checks
+    matrix.test_simultaneous_smith_normal_form(
+        d1, d2,
+        basechange0, basechange1, basechange2,
+        transformed_d1, transformed_d2)
+
+    # Perform consistency check
+    assert matrix.is_matrix_zero(
+        matrix.matrix_mult(transformed_d1, transformed_d2))
+
+    # Will hold the result
+    homology_basis = []
+
+    # A list of all the basis vectors
+    basis_vectors = matrix.matrix_transpose(basechange1)
+
+    # Iterate through the basis vectors
+    for i, basis_vector in enumerate(basis_vectors):
+
+        # Get the absolute value of the one non-zero entry in
+        # the i-th column of d1 with respect to the new basis
+        d1_entry = matrix.max_abs_of_col(transformed_d1, i)
+
+        # i-th row of d2
+        d2_entry = matrix.max_abs_of_row(transformed_d2, i)
+
+        # Note that d1 * d2 = 0, so at most one of d1_entry and d2_entry
+        # can be non-zero.
+
+        # If using Z/N coefficients, apply gcd and modulo N to entries.
+        if not N == 0:
+            # We do this because we want to compute the image and the kernel
+            # of maps m: Z/N -> Z/N, x |-> e*x.
+            # For this consider the quantity gcd(e,N) % N.
+            # The image of m consists of multiplies of gcd(e,N) % N.
+            # If gcd(e, N) % N is 0, the kernel is Z/N. If 1, the kernel is 0.
+            # Otherwise, N / (gcd(e, N) % N) is generating the kernel and the
+            # kernel has size gcd(e, N) % N).
+
+            # Example: Z/6 -> Z/6, x |-> 5 * x has full image Z/6 because
+            # gcd(5, 6) = 1. The kernel is 0.
+
+            # Z/6 -> Z/6, x |-> 4 * x has image all even elements in Z/6
+            # because gcd(4, 6) = 2. Its kernel also consists of 2 elements,
+            # namely 0 and 3 = 6 / 2 = 6 / gcd(4, 6).
+
+            d1_entry = _gcd(d1_entry, N) % N
+            d2_entry = _gcd(d2_entry, N) % N
+
+        if d1_entry == 0:
+            # The image of the basis vector is 0, hence the basis vector
+            # is in the kernel of d1.
+
+            # However, it might be entirely killed by the image of d2.
+            # It is not entirely killed if and only if d2 entry is not 1.
+            if not d2_entry == 1:
+                # The basis vector times the d2 entry is in the image of d2
+                # and thus zero in the homology.
+                # Thus the d2 entry determines the order of the homology class
+                # this basis vector represents.
+                if N == 0:
+                    # In the Z-coefficient case, the order is just given by the
+                    # d2 entry. This is even when d2 entry is zero as infinite
+                    # order is encoded by 0.
+                    homology_basis.append( (basis_vector, d2_entry) )
+                else:
+                    if d2_entry == 0:
+                        # If the d2 entry is 0, no multiple of the basis vector
+                        # is killed by the image. But we have Z/N-coefficients,
+                        # so the order is N.
+                        homology_basis.append( (basis_vector, N) )
+                    else:
+                        # Order is just d2 entry.
+                        homology_basis.append( (basis_vector, d2_entry) )
+
+        elif not d1_entry == 1:
+            # d1 entry is neither 0 or 1. In Z-coefficients this means
+            # that no multiple of basis vector can be in the kernel.
+            if not N == 0:
+                # But in Z/N-coefficients, multiplying by N/d1_entry
+                # gives a generator of the kernel that has order d1_entry
+                # in the homology.
+                kernel_vector = [ ( b * N / d1_entry ) % N
+                                  for b in basis_vector ]
+                homology_basis.append( (kernel_vector, d1_entry) )
+
+        # d1 entry is 1, so the basis vector or any multiple of it
+        # is in the kernel. Do not add it
+
+    return homology_basis
+
+
+def homology_representatives(d1, d2, N):
+    """
+    Given two matrices d1 and d2 such that d1 * d2 = 0, computes the
+    homology H_1 = ker(d1) / im(d2) when using Z/N coefficients.
+
+    The result is a list of vectors c_1 for each homology class [c_1].
+    """
+
+    assert N > 1
+
+    # Compute a basis of the homology group
+    homology_basis = homology_basis_representatives_with_orders(d1, d2, N)
+
+    # Enumerate all linear combinations of the basis elements
+    return _enumerate_from_basis(homology_basis, matrix.num_cols(d1), N)
+
+
+def _enumerate_from_basis(basis, l, N):
+    """
+    Given a list of pairs `(v_i, o_i)` where each `v_i` is a vector of length l
+    and an integer N > 2, iterate through all linear combinations
+    `k_0 v_0 + k_1 v_1 + ... + k_m v_m` (modulo N) where `k_i = 0, ..., o_i`.
+
+    If basis is empty, just return zero vector of length l.
+    """
+
+    if len(basis) == 0:
+        # Base case, return zero vector of length l
+        yield l * [ 0 ]
+    else:
+        # Take first pair (vector, order) from given list
+        basis_vector, order = basis[0]
+        # Iterate up until order
+        for i in range(order):
+            # Iterate through all linear combinations of remaining basis
+            # elements
+            for vector in _enumerate_from_basis(basis[1:], l, N):
+                # Return the linear combination of the multiple of this basis
+                # vector and the linear combination of the other basis vectors
+                yield [ (i * b + v) % N for b, v in zip(basis_vector, vector) ]

snappy/ptolemy/magma/default.magma_template

@@ -0,0 +1,229 @@
+// Setting up the Polynomial ring and ideal
+
+R<$VARIABLES> := PolynomialRing(RationalField(), $VARIABLE_NUMBER, "grevlex");
+MyIdeal := ideal<R |
+          $EQUATIONS>;
+
+// Variable names, unfortunately "Names(R)" does not work for old magma versions
+varNames := [ $VARIABLES_QUOTED ];
+
+// Term order in which the decomposition will be reported
+termOrder := "lex";
+
+// Whether to compute witnesses for 1-dim ideals
+computeWitnesses := true;
+
+// Whether to compute the genus for 1-dim ideals
+computeGenuses := true;
+
+// Data necessary to recover all Ptolemy coordinates and the triangulation
+print $QUOTED_PREAMBLE;
+
+// Various helper functions
+function SaturateIdeal(baseRing, theIdeal)
+
+    print "Status: Computing Groebner basis...";
+    time Groebner(theIdeal);
+
+    for i := 1 to Rank(baseRing) do
+        saturatedIdeal := -1;
+        print "Status: Saturating ideal (", i, "/", Rank(baseRing), ")...";
+        time saturatedIdeal := Saturation(theIdeal, baseRing.i);
+        print "Status: Recomputing Groebner basis...";
+        time Groebner(saturatedIdeal);
+        theIdeal := saturatedIdeal;
+    end for;
+
+    print "Status: Dimension of ideal: ", Dimension(saturatedIdeal);
+
+    return saturatedIdeal;
+end function;
+
+function ZeroDimensionalIdealChangeOrder(theIdeal, order)
+    if Dimension(theIdeal) le 0 then
+        print "Status: Changing to term order ", order, "...";
+        time result := ChangeOrder(theIdeal, order);
+        print "Status: Recomputing Groebner basis...";
+        time Groebner(result);
+	print "Status: Confirming is prime...";
+	time isPrime := IsPrime(result);
+	if not isPrime then
+            print "Not prime!";
+            exit;
+	end if;
+        return result;
+    else
+        return theIdeal;
+    end if;
+end function;
+
+function ZeroDimensionalIdealsChangeOrder(theIdeals, order)
+    return [ ZeroDimensionalIdealChangeOrder(theIdeal, order) :
+                                             theIdeal in theIdeals ];
+end function;
+
+function FreeVariablesOfIdeal(varNames, theIdeal)
+    D, vars := Dimension(theIdeal);
+    return [ "\"" cat varNames[var] cat "\"" : var in vars];
+end function;
+
+function FreeVariablesOfIdeals(varNames, theIdeals)
+    return [ FreeVariablesOfIdeal(varNames, theIdeal) : theIdeal in theIdeals];
+end function;
+
+function IsSuitableWitness(theIdeals, theIndex, witnessIdeal)
+    if not Dimension(witnessIdeal) eq 0 then
+        return false;
+    end if;
+    for index := 1 to #theIdeals do
+        if not index eq theIndex then
+            if Dimension(theIdeals[index]) gt 0 then
+                if not Dimension(theIdeals[index] + witnessIdeal) eq -1 then
+                    return false;
+                end if;
+            end if;
+	end if;
+    end for;
+    return true;
+end function;
+
+function IncrementList(theList)
+    for index := #theList to 1 by -1 do
+        if index eq 1 then
+            theList[1] := theList[1] + 1;
+            return theList;
+        else
+	    if theList[index] lt theList[1] then
+                theList[index] := theList[index] + 1;
+                return theList;
+            else
+                theList[index] := 1;
+            end if;
+	end if;
+    end for;
+end function;
+
+function GenerateWitnessIdeal(baseRing, theIdeal, coordinates)
+
+    D, vars := Dimension(theIdeal);
+
+    witnessIdeal := theIdeal;
+
+    for index := 1 to #coordinates do
+        var := vars[index];
+        val := coordinates[index];
+        witnessIdeal := witnessIdeal + ideal<baseRing | baseRing.var - val>;
+    end for;
+
+    return SaturateIdeal(baseRing, witnessIdeal);
+end function;
+
+function FindWitness(baseRing, theIdeals, index)
+    theIdeal := theIdeals[index];
+    D, vars := Dimension(theIdeal);
+
+    if D le 0 then
+        return ideal<baseRing | >;
+    end if;
+
+    coordinates := [1: var in vars];
+
+    while true do
+
+        witnessIdeal := GenerateWitnessIdeal(baseRing, theIdeal, coordinates);
+        print "Status: Testing witness ", coordinates, "...";
+
+        time isSuitable := IsSuitableWitness(theIdeals, index, witnessIdeal);
+        if isSuitable then
+            return RadicalDecomposition(witnessIdeal)[1];
+        end if;
+
+        coordinates := IncrementList(coordinates);
+    end while;
+end function;
+
+function FindWitnesses(baseRing, theIdeals)
+    print "Status: Finding witnesses for non-zero dimensional ideals...";
+    return [ FindWitness(baseRing, theIdeals, index) : index in [1..#theIdeals]];
+end function;
+
+
+
+
+
+
+// Computations begin here
+saturatedIdeal := SaturateIdeal(R, MyIdeal);
+
+// Compute radical decomposition
+print "Status: Computing RadicalDecomposition";
+time P := RadicalDecomposition(saturatedIdeal);
+
+print "Status: Number of components: ", #P;
+
+print "DECOMPOSITION=TYPE: RadicalDecomposition";
+
+// Initialize Porder to -1 so that we can check later whether an error or user
+// interrupt happened.
+Porder := -1;
+
+// change 0-dim components to desired term order
+POrder := ZeroDimensionalIdealsChangeOrder(P, termOrder);
+
+print "IDEAL=DECOMPOSITION" cat "=TIME: ", Cputime();
+
+if Type(POrder) eq RngIntElt then
+    // An error or user interrupt occurred, bail
+    print "IDEAL=DECOMPOSITION" cat "=FAILED";
+    exit;
+end if;
+
+print "IDEAL=DECOMPOSITION" cat "=BEGINS=HERE";
+POrder;
+print "IDEAL=DECOMPOSITION" cat "=ENDS=HERE";
+
+
+print "FREE=VARIABLES=IN=COMPONENTS" cat "=BEGINS=HERE";
+FreeVariablesOfIdeals(varNames, POrder);
+print "FREE=VARIABLES=IN=COMPONENTS" cat "=ENDS=HERE";
+
+if computeWitnesses then
+    witnesses := FindWitnesses(R, POrder);
+    
+    witnessesOrder := -1;
+    witnessesOrder := ZeroDimensionalIdealsChangeOrder(witnesses, termOrder);
+
+    if Type(witnessesOrder) eq RngIntElt then
+        print "WITNESSES=FOR=COMPONENTS" cat "=FAILED";
+        exit;
+    end if;
+
+    print "==WITNESSES=FOR=COMPONENTS" cat "=BEGINS==";
+
+    for witness in witnessesOrder do
+        print "==WITNESSES=BEGINS==";
+        if not IsZero(witness) then
+	    print "==WITNESS=BEGINS==";
+	    witness;
+	    print "==WITNESS=ENDS==";
+        end if;
+        print "==WITNESSES=ENDS==";
+    end for;
+
+    print "==WITNESSES=FOR=COMPONENTS" cat "=ENDS==";
+end if;
+
+if computeGenuses then
+    print "==GENUSES=FOR=COMPONENTS" cat "=BEGINS==";    
+
+    for comp in POrder do
+        print "==GENUS=FOR=COMPONENT=BEGINS==";
+        D, vars := Dimension(comp);
+        if D eq 1 then
+            print Genus(Curve(AffineSpace(R), comp));
+        end if;
+        print "==GENUS=FOR=COMPONENT=ENDS==";
+    end for;
+
+    print "==GENUSES=FOR=COMPONENTS" cat "=ENDS==";    
+end if;

snappy/ptolemy/magma/radicalsOfPrimaryDecomposition.magma_template

@@ -0,0 +1,79 @@
+
+// Setting up the Polynomial ring and ideal
+
+R<$VARIABLES_WITH_NON_ZERO_CONDITION> := PolynomialRing(RationalField(), $VARIABLE_WITH_NON_ZERO_CONDITION_NUMBER);
+MyIdeal := ideal<R |
+          $EQUATIONS_WITH_NON_ZERO_CONDITION>;
+
+// N := Names(R); // unfortunately does not work for old magma versions
+N := [ $VARIABLES_WITH_NON_ZERO_CONDITION_QUOTED ];
+
+
+
+print $QUOTED_PREAMBLE;
+
+
+
+// Initialize Q to -1 so that we can check whether an error happened
+// by checking that Q is still of type integer.
+Q := -1;
+
+// Remember start time to calculate computation time
+primTime := Cputime();
+
+
+
+
+print "DECOMPOSITION=TYPE: Radicals of Primary Decomposition";
+
+P, Q := PrimaryDecomposition(MyIdeal);
+
+
+
+print "IDEAL=DECOMPOSITION" cat "=TIME: ", Cputime(primTime);
+
+if Type(Q) eq RngIntElt then
+    // Some error occurred
+    print "IDEAL=DECOMPOSITION" cat "=FAILED";
+    exit;
+else
+    // Success
+    print "IDEAL=DECOMPOSITION" cat "=BEGINS=HERE";
+    Q;
+    print "IDEAL=DECOMPOSITION" cat "=ENDS=HERE";
+
+
+    print "FREE=VARIABLES=IN=COMPONENTS" cat "=BEGINS=HERE";
+    isFirstComp := true;
+    freeVarStr := "[";
+    for Comp in Q do
+    
+        if isFirstComp then
+            isFirstComp := false;
+        else
+            freeVarStr := freeVarStr cat ",";
+        end if;
+        freeVarStr := freeVarStr cat "\n    [ ";
+        
+        D, Vars := Dimension(Comp);
+
+        isFirstVar := true; 
+        for Var in Vars do
+            if isFirstVar then
+                isFirstVar := false;
+            else
+                freeVarStr := freeVarStr cat ", ";
+            end if;
+ 
+            freeVarStr := freeVarStr cat "\"" cat N[Var] cat "\"";
+        end for;
+
+        freeVarStr := freeVarStr cat " ]";
+    end for;
+    freeVarStr := freeVarStr cat "\n]";
+    print freeVarStr;
+    print "FREE=VARIABLES=IN=COMPONENTS" cat "=ENDS=HERE";
+end if;
+
+print "CPUTIME: ", Cputime(primTime);
+