..nodoctest

Finding class invariants

x.__init__(...) initializes x; see help(type(x)) for signature

recip.find_class_invariant.a_to_mu(Psi, A)

Given an ideal A and CM-type Psi, returns mu with mu*mubar in QQ and N_Psi(A) = (mu) if mu exists, and None otherwise

recip.find_class_invariant.list_group(gens)

Given a set of elements of a finite group, lists all elements of the group generated by the given elements.

NOTE: Use group_generators_to_list() instead, as it is better. The function list_group will be removed in a later version.

EXAMPLES:

The matrices M and N were output by an earlier version of reciprocity_map_image. The outputs are equivalent, as the following test shows.:

sage: from recip import *
sage: k = CM_Field((x^2+5)^2-4*5)
sage: Z = k.period_matrices_iter().next()
sage: gens = reciprocity_map_image(Z, 6)
sage: lst = list_group(gens) # long time
Warning: the function list_group will be removed in a later version, use group_generators_to_list instead
sage: M = Matrix(Zmod(6), [[3,1,2,5],[0,2,5,1],[4,2,4,5],[1,4,4,4]])
sage: M in lst # long time, not tested, apparently wrong??
True
sage: N = Matrix(Zmod(6), [[3,0,4,0],[0,5,0,4],[2,4,3,2],[0,2,2,3]])
sage: N in lst # long time, not tested, apparently wrong??
True
sage: lst = list_group([M,N]) # long time
Warning: the function list_group will be removed in a later version, use group_generators_to_list instead
sage: all([g.matrix() in lst for g in gens]) # long time, not tested, apparently wrong??
True
recip.find_class_invariant.make_big_zero(n, big)

Returns \(0\) if \(n==big\) and returns \(n\) otherwise. We need this because permutation groups don’t handle 0 well.

recip.find_class_invariant.make_zero_big(n, big)

Returns \(big\) if \(n==0\) and returns \(n\) otherwise. We need this because permutation groups don’t handle 0 well.

recip.find_class_invariant.principal_type_norms(Psi, modulus)

Returns a set of generators of the image of (H(1) cap I(modulus)) / H(modulus) in (Or / modulus)^* / O^* under the type norm of Psi.

Here I(N) is the group of ideals of the domain of Psi, coprime to N, and H(N) is the subgroup of ideals A such that the type norm of A is principal and generated by mu with mu*mubar in QQ.

Or is the maximal order of the reflex field.

recip.find_class_invariant.reciprocity_map_image(Z, level, modulus=None)

Given a CM period matrix Z, returns Z.epsilon(b) mod level for a set of generators A of the group (H(1) cap I(modulus)) / H(modulus).

Here I(N) is the group of ideals of the reflex field coprime to N, and H(N) is the subgroup of ideals A such that the reflex type norm of A is principal and generated by mu with mu*mubar in QQ.

The b in Z.epsilon(b) is b=mu with mu as in the definition of H(1).

If modulus is None, then take modulus=level

EXAMPLE:

sage: from recip import *
sage: k = CM_Field((x^2+5)^2-4*5)
sage: Z = k.one_period_matrix(); Z
Period Matrix
[-0.30901699437495? + 0.95105651629515?*I -0.50000000000000? + 0.36327126400268?*I]
[-0.50000000000000? + 0.36327126400268?*I  0.30901699437495? + 0.95105651629515?*I]
sage: reciprocity_map_image(Z, 6) # not tested, is this answer correct?
[[1 1 4 1]
[2 4 1 5]
[2 2 0 3]
[1 2 4 2], [3 2 2 0]
[2 3 0 2]
[4 0 3 0]
[2 4 0 5]]
sage: gammas = reciprocity_map_image(Z, 8)
sage: len(gammas)
4
sage: gammas[0] # not tested, is this answer correct?
[0 2 1 6]
[0 1 6 7]
[7 1 2 1]
[2 7 7 2]
recip.find_class_invariant.table(gens, den, select_rows=None)

Returns a table showing the action of gens on the theta’s with characteristics in 1/den.

EXAMPLE:

sage: from recip import *
sage: gens = [GSp_element([[5,0,7,1],[6,6,0,7],[3,6,6,1],[6,1,7,4]],ring=Zmod(8))]
sage: table(gens, 2, select_rows=[0,1,4,6,8])
[            0|            1]
[-------------+-------------]
[           t0|          -t6]
[           t1|           t0]
[           t4|   (zeta8)*t1]
[           t6|(-zeta8^3)*t8]
[           t8|(-zeta8^2)*t4]
[      (zeta8)|    (zeta8^3)]
recip.find_class_invariant.visualize(gens, den, select_rows=None)

Gives a visual representation of the action of gens on the theta’s of characteristic in ZZ/den.

EXAMPLE:

sage: from recip import *
sage: M = []
sage: M.append([[5,0,7,1],[6,6,0,7],[3,6,6,1],[6,1,7,4]])
sage: M.append([[1,6,4,2],[2,3,6,4],[0,4,5,2],[4,4,6,7]])
sage: M.append([[7,0,6,4],[2,1,0,6],[0,2,1,2],[2,2,4,3]])
sage: M.append([[5,0,4,0],[4,1,0,4],[0,4,1,4],[4,4,0,5]])
sage: gens = [GSp_element(m, ring=Zmod(8)) for m in M]
sage: visualize(gens, 2)
On the 8-th powers, the action is (note that 16 means 0):
1: (1,16,6,8,4)(2,15,12,3,9)
2: ()
3: ()
4: ()
Permutation Group with generators [(), (1,16,6,8,4)(2,15,12,3,9)] of order 5
The action on the orbit [0, 1, 4, 6, 8] is as follows
[            0|            1             2             3             4]
[-------------+-------------------------------------------------------]
[           t0|          -t6            t0            t0            t0]
[           t1|           t0            t1           -t1            t1]
[           t4|   (zeta8)*t1            t4  (zeta8^2)*t4           -t4]
[           t6|(-zeta8^3)*t8            t6           -t6            t6]
[           t8|(-zeta8^2)*t4            t8 (-zeta8^2)*t8           -t8]
[      (zeta8)|    (zeta8^3)       (zeta8)    (-zeta8^3)      (-zeta8)]
The action on the orbit [2, 3, 9, 12, 15] is as follows
[            0|            1             2             3             4]
[-------------+-------------------------------------------------------]
[           t2|          t15           -t2  (zeta8^2)*t2           -t2]
[           t3| (zeta8^2)*t9           -t3  (zeta8^2)*t3           -t3]
[           t9|(-zeta8^2)*t2           -t9 (-zeta8^2)*t9           -t9]
[          t12| (zeta8^3)*t3          -t12           t12           t12]
[          t15|(zeta8^3)*t12          -t15 (zeta8^2)*t15          -t15]
[      (zeta8)|    (zeta8^3)       (zeta8)    (-zeta8^3)      (-zeta8)]