def hadamard_matrix(n): """ Tries to construct a Hadamard matrix using a combination of Paley and Sylvester constructions. EXAMPLES:: sage: hadamard_matrix(12).det() 2985984 sage: 12^6 2985984 sage: hadamard_matrix(2) [ 1 1] [ 1 -1] sage: hadamard_matrix(8) [ 1 1 1 1 1 1 1 1] [ 1 -1 1 -1 1 -1 1 -1] [ 1 1 -1 -1 1 1 -1 -1] [ 1 -1 -1 1 1 -1 -1 1] [ 1 1 1 1 -1 -1 -1 -1] [ 1 -1 1 -1 -1 1 -1 1] [ 1 1 -1 -1 -1 -1 1 1] [ 1 -1 -1 1 -1 1 1 -1] sage: hadamard_matrix(8).det() == 8^4 True """ if not (n % 4 == 0) and (n != 2): raise ValueError("The Hadamard matrix of order %s does not exist" % n) if n == 2: return matrix([[1, 1], [1, -1]]) if is_even(n): N = Integer(n / 2) elif n == 1: return matrix([1]) if is_prime(N - 1) and (N - 1) % 4 == 1: return hadamard_matrix_paleyII(n) elif n == 4 or n % 8 == 0: had = hadamard_matrix(Integer(n / 2)) chad1 = matrix([list(r) + list(r) for r in had.rows()]) mhad = (-1) * had R = len(had.rows()) chad2 = matrix( [list(had.rows()[i]) + list(mhad.rows()[i]) for i in range(R)]) return chad1.stack(chad2) elif is_prime(N - 1) and (N - 1) % 4 == 3: return hadamard_matrix_paleyI(n) else: raise ValueError( "The Hadamard matrix of order %s is not yet implemented." % n)
def hadamard_matrix(n): """ Tries to construct a Hadamard matrix using a combination of Paley and Sylvester constructions. EXAMPLES:: sage: hadamard_matrix(12).det() 2985984 sage: 12^6 2985984 sage: hadamard_matrix(2) [ 1 1] [ 1 -1] sage: hadamard_matrix(8) [ 1 1 1 1 1 1 1 1] [ 1 -1 1 -1 1 -1 1 -1] [ 1 1 -1 -1 1 1 -1 -1] [ 1 -1 -1 1 1 -1 -1 1] [ 1 1 1 1 -1 -1 -1 -1] [ 1 -1 1 -1 -1 1 -1 1] [ 1 1 -1 -1 -1 -1 1 1] [ 1 -1 -1 1 -1 1 1 -1] sage: hadamard_matrix(8).det() == 8^4 True """ if not(n % 4 == 0) and (n != 2): raise ValueError("The Hadamard matrix of order %s does not exist" % n) if n == 2: return matrix([[1, 1], [1, -1]]) if is_even(n): N = Integer(n / 2) elif n == 1: return matrix([1]) if is_prime(N - 1) and (N - 1) % 4 == 1: return hadamard_matrix_paleyII(n) elif n == 4 or n % 8 == 0: had = hadamard_matrix(Integer(n / 2)) chad1 = matrix([list(r) + list(r) for r in had.rows()]) mhad = (-1) * had R = len(had.rows()) chad2 = matrix([list(had.rows()[i]) + list(mhad.rows()[i]) for i in range(R)]) return chad1.stack(chad2) elif is_prime(N - 1) and (N - 1) % 4 == 3: return hadamard_matrix_paleyI(n) else: raise ValueError("The Hadamard matrix of order %s is not yet implemented." % n)
def hadamard_matrix_paleyI(n): """ Implements the Paley type I construction. The Paley type I case corresponds to the case `p \cong 3 \mod{4}` for a prime `p` (see [Hora]_). EXAMPLES: We note that this method returns a normalised Hadamard matrix :: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyI(4) [ 1 1 1 1] [ 1 -1 -1 1] [ 1 1 -1 -1] [ 1 -1 1 -1] """ p = n - 1 if not (is_prime(p) and (p % 4 == 3)): raise ValueError( "The order %s is not covered by the Paley type I construction." % n) H = matrix(ZZ, [[H1(i, j, p) for i in range(n)] for j in range(n)]) # normalising H so that first row and column have only +1 entries. return normalise_hadamard(H)
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), 'conway', None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), 'conway', None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] if modulus is None or modulus == "default": if exists_conway_polynomial(p, n): modulus = "conway" else: if p == 2: modulus = "minimal_weight" else: modulus = "random" elif modulus == "random": modulus += str(random.randint(0, 1 << 128)) if isinstance(modulus, (list, tuple)): modulus = FiniteField(p)['x'](modulus) # some classes use 'random' as the modulus to # generate a random modulus, but we don't want # to cache it elif sage.rings.polynomial.polynomial_element.is_Polynomial( modulus): modulus = modulus.change_variable_name('x') elif not isinstance(modulus, str): raise ValueError("Modulus parameter not understood.") else: # Neither a prime, nor a prime power raise ValueError( "the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def __init__(self, p, name=None, check=True): """ Return a new finite field of order `p` where `p` is prime. INPUT: - ``p`` -- an integer at least 2 - ``name`` -- ignored - ``check`` -- bool (default: ``True``); if ``False``, do not check ``p`` for primality EXAMPLES:: sage: F = FiniteField(3); F Finite Field of size 3 """ p = integer.Integer(p) if check and not arith.is_prime(p): raise ArithmeticError("p must be prime") self.__char = p self._kwargs = {} # FiniteField_generic does nothing more than IntegerModRing_generic, and # it saves a non trivial overhead integer_mod_ring.IntegerModRing_generic.__init__(self, p, category = _FiniteFields)
def __init__(self, p, name=None, check=True): """ Return a new finite field of order $p$ where $p$ is prime. INPUT: - p -- an integer >= 2 - ``name`` -- ignored - ``check`` -- bool (default: True); if False, do not check p for primality EXAMPLES:: sage: FiniteField(3) Finite Field of size 3 sage: FiniteField(next_prime(1000)) Finite Field of size 1009 """ p = integer.Integer(p) if check and not arith.is_prime(p): raise ArithmeticError, "p must be prime" self.__char = p self._IntegerModRing_generic__factored_order = factorization.Factorization([(p,1)], integer.Integer(1)) self._kwargs = {} # FiniteField_generic does nothing more than IntegerModRing_generic, and # it saves a non trivial overhead integer_mod_ring.IntegerModRing_generic.__init__(self, p, category = _FiniteFields)
def __init__(self, p, name=None, check=True): """ Return a new finite field of order `p` where `p` is prime. INPUT: - ``p`` -- an integer at least 2 - ``name`` -- ignored - ``check`` -- bool (default: ``True``); if ``False``, do not check ``p`` for primality EXAMPLES:: sage: F = FiniteField(3); F Finite Field of size 3 """ p = integer.Integer(p) if check and not arith.is_prime(p): raise ArithmeticError, "p must be prime" self.__char = p self._IntegerModRing_generic__factored_order = factorization.Factorization( [(p, 1)], integer.Integer(1)) self._kwargs = {} # FiniteField_generic does nothing more than IntegerModRing_generic, and # it saves a non trivial overhead integer_mod_ring.IntegerModRing_generic.__init__( self, p, category=_FiniteFields)
def apply_sparse(self, x): """ Return the image of x under self. If x is not in self.domain(), raise a TypeError. EXAMPLES: sage: M = ModularSymbols(17,4,-1) sage: T = M.hecke_operator(4) sage: T.apply_sparse(M.0) 64*[X^2,(1,8)] + 24*[X^2,(1,10)] - 9*[X^2,(1,13)] + 37*[X^2,(1,16)] sage: [ T.apply_sparse(x) == T.hecke_module_morphism()(x) for x in M.basis() ] [True, True, True, True] sage: N = ModularSymbols(17,4,1) sage: T.apply_sparse(N.0) Traceback (most recent call last): ... TypeError: x (=[X^2,(0,1)]) must be in Modular Symbols space of dimension 4 for Gamma_0(17) of weight 4 with sign -1 over Rational Field """ if x not in self.domain(): raise TypeError("x (=%s) must be in %s"%(x, self.domain())) # old version just to check for correctness #return self.hecke_module_morphism()(x) p = self.index() if is_prime(p): H = heilbronn.HeilbronnCremona(p) else: H = heilbronn.HeilbronnMerel(p) M = self.parent().module() mod2term = M._mod2term syms = M.manin_symbols() K = M.base_ring() R = M.manin_gens_to_basis() W = R.new_matrix(nrows=1, ncols = R.nrows()) B = M.manin_basis() #from sage.all import cputime #t = cputime() v = x.element() for i in v.nonzero_positions(): for h in H: entries = syms.apply(B[i], h) for k, w in entries: f, s = mod2term[k] if s: W[0,f] += s*K(w)*v[i] #print 'sym', cputime(t) #t = cputime() ans = M( v.parent()((W * R).row(0)) ) #print 'mul', cputime(t) #print 'density: ', len(W.nonzero_positions())/(W.nrows()*float(W.ncols())) return ans
def apply_sparse(self, x): """ Return the image of x under self. If x is not in self.domain(), raise a TypeError. EXAMPLES: sage: M = ModularSymbols(17,4,-1) sage: T = M.hecke_operator(4) sage: T.apply_sparse(M.0) 64*[X^2,(1,8)] + 24*[X^2,(1,10)] - 9*[X^2,(1,13)] + 37*[X^2,(1,16)] sage: [ T.apply_sparse(x) == T.hecke_module_morphism()(x) for x in M.basis() ] [True, True, True, True] sage: N = ModularSymbols(17,4,1) sage: T.apply_sparse(N.0) Traceback (most recent call last): ... TypeError: x (=[X^2,(0,1)]) must be in Modular Symbols space of dimension 4 for Gamma_0(17) of weight 4 with sign -1 over Rational Field """ if x not in self.domain(): raise TypeError, "x (=%s) must be in %s"%(x, self.domain()) # old version just to check for correctness #return self.hecke_module_morphism()(x) p = self.index() if is_prime(p): H = heilbronn.HeilbronnCremona(p) else: H = heilbronn.HeilbronnMerel(p) M = self.parent().module() mod2term = M._mod2term syms = M.manin_symbols() K = M.base_ring() R = M.manin_gens_to_basis() W = R.new_matrix(nrows=1, ncols = R.nrows()) B = M.manin_basis() #from sage.all import cputime #t = cputime() v = x.element() for i in v.nonzero_positions(): for h in H: entries = syms.apply(B[i], h) for k, w in entries: f, s = mod2term[k] if s: W[0,f] += s*K(w)*v[i] #print 'sym', cputime(t) #t = cputime() ans = M( v.parent()((W * R).row(0)) ) #print 'mul', cputime(t) #print 'density: ', len(W.nonzero_positions())/(W.nrows()*float(W.ncols())) return ans
def is_primitive(self,return_base=False): r""" A pillowcase cover is primitive if it does not cover an other pillowcase cover. """ from sage.rings.arith import is_prime if is_prime(self.degree()): return True return bool(gap.IsPrimitive(self.monodromy()))
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), 'conway', None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), 'conway', None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof("arithmetic", proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] if modulus is None or modulus == "default": if exists_conway_polynomial(p, n): modulus = "conway" else: if p == 2: modulus = "minimal_weight" else: modulus = "random" elif modulus == "random": modulus += str(random.randint(0, 1 << 128)) if isinstance(modulus, (list, tuple)): modulus = FiniteField(p)["x"](modulus) # some classes use 'random' as the modulus to # generate a random modulus, but we don't want # to cache it elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus): modulus = modulus.change_variable_name("x") elif not isinstance(modulus, str): raise ValueError("Modulus parameter not understood.") else: # Neither a prime, nor a prime power raise ValueError("the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def is_integral_domain(self, proof = True): """ Return True if and only if the order of self is prime. EXAMPLES:: sage: Integers(389).is_integral_domain() True sage: Integers(389^2).is_integral_domain() False """ return is_prime(self.order())
def is_integral_domain(self, proof=True): """ Return True if and only if the order of self is prime. EXAMPLES:: sage: Integers(389).is_integral_domain() True sage: Integers(389^2).is_integral_domain() False """ return is_prime(self.order())
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial( modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError( "the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def hadamard_matrix_paleyI(n): """ Implements the Paley type I construction. EXAMPLES:: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyI(4) [ 1 -1 -1 -1] [ 1 1 1 -1] [ 1 -1 1 1] [ 1 1 -1 1] """ p = n - 1 if not(is_prime(p) and (p % 4 == 3)): raise ValueError("The order %s is not covered by the Paley type I construction." % n) return matrix(ZZ, [[H1(i, j, p) for i in range(n)] for j in range(n)])
def hadamard_matrix_paleyI(n): """ Implements the Paley type I construction. EXAMPLES:: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyI(4) [ 1 -1 -1 -1] [ 1 1 1 -1] [ 1 -1 1 1] [ 1 1 -1 1] """ if is_prime(n-1) and (n-1)%4==3: p = n-1 else: raise ValueError, "The order %s is not covered by the Paley type I construction."%n return matrix(ZZ,[[H1(i,j,p) for i in range(n)] for j in range(n)])
def _element_constructor_(self, e): """ TESTS:: sage: P = Sets().example() sage: P._element_constructor_(13) == 13 True sage: P._element_constructor_(13).parent() Integer Ring sage: P._element_constructor_(14) Traceback (most recent call last): ... AssertionError: 14 is not a prime number """ p = self.element_class(e) assert is_prime(p), "%s is not a prime number"%(p) return p
def CO_delta(r, p, N, eps): r""" This is used as an intermediate value in computations related to the paper of Cohen-Oesterle. INPUT: - ``r`` - positive integer - ``p`` - a prime - ``N`` - positive integer - ``eps`` - character OUTPUT: element of the base ring of the character EXAMPLES:: sage: G.<eps> = DirichletGroup(7) sage: sage.modular.dims.CO_delta(1,5,7,eps^3) 2 """ if not is_prime(p): raise ValueError, "p must be prime" K = eps.base_ring() if p % 4 == 3: return K(0) if p == 2: if r == 1: return K(1) return K(0) # interesting case: p=1(mod 4). # omega is a primitive 4th root of unity mod p. omega = (IntegerModRing(p).unit_gens()[0])**((p - 1) // 4) # this n is within a p-power root of a "local" 4th root of 1 modulo p. n = Mod(int(omega.crt(Mod(1, N // (p**r)))), N) n = n**(p**(r - 1)) # this is correct now t = eps(n) if t == K(1): return K(2) if t == K(-1): return K(-2) return K(0)
def hadamard_matrix_paleyII(n): """ Implements the Paley type II construction. EXAMPLES:: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyI(12).det() 2985984 sage: 12^6 2985984 """ N = Integer(n/2) p = N - 1 if not(is_prime(p) and (p % 4 == 1)): raise ValueError("The order %s is not covered by the Paley type II construction." % n) S = matrix(ZZ, [[H2(i, j, p) for i in range(N)] for j in range(N)]) return block_matrix([[S + 1, S - 1], [S - 1, -S - 1]])
def CO_delta(r,p,N,eps): r""" This is used as an intermediate value in computations related to the paper of Cohen-Oesterle. INPUT: - ``r`` - positive integer - ``p`` - a prime - ``N`` - positive integer - ``eps`` - character OUTPUT: element of the base ring of the character EXAMPLES:: sage: G.<eps> = DirichletGroup(7) sage: sage.modular.dims.CO_delta(1,5,7,eps^3) 2 """ if not is_prime(p): raise ValueError("p must be prime") K = eps.base_ring() if p%4 == 3: return K(0) if p==2: if r==1: return K(1) return K(0) # interesting case: p=1(mod 4). # omega is a primitive 4th root of unity mod p. omega = (IntegerModRing(p).unit_gens()[0])**((p-1)//4) # this n is within a p-power root of a "local" 4th root of 1 modulo p. n = Mod(int(omega.crt(Mod(1,N//(p**r)))),N) n = n**(p**(r-1)) # this is correct now t = eps(n) if t==K(1): return K(2) if t==K(-1): return K(-2) return K(0)
def hadamard_matrix_paleyII(n): """ Implements the Paley type II construction. EXAMPLES:: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyI(12).det() 2985984 sage: 12^6 2985984 """ N = ZZ(n/2) if is_prime(N-1) and (N-1)%4==1: p = N-1 else: raise ValueError, "The order %s is not covered by the Paley type II construction."%n S = matrix(ZZ,[[H2(i,j,p) for i in range(N)] for j in range(N)]) return block_matrix([[S+1,S-1],[S-1,-S-1]])
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1,name) p, n = arith.factor(order)[0] if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError("the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def eisen(p): """ Return the Eisenstein number `n` which is the numerator of `(p-1)/12`. INPUT: - ``p`` - a prime OUTPUT: Integer EXAMPLES:: sage: [(p,sage.modular.dims.eisen(p)) for p in prime_range(24)] [(2, 1), (3, 1), (5, 1), (7, 1), (11, 5), (13, 1), (17, 4), (19, 3), (23, 11)] """ if not is_prime(p): raise ValueError, "p must be prime" return frac(p-1,12).numerator()
def hadamard_matrix_paleyII(n): """ Implements the Paley type II construction. The Paley type II case corresponds to the case `p \cong 1 \mod{4}` for a prime `p` (see [Hora]_). EXAMPLES:: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyII(12).det() 2985984 sage: 12^6 2985984 We note that the method returns a normalised Hadamard matrix :: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyII(12) [ 1 1 1 1 1 1| 1 1 1 1 1 1] [ 1 1 1 -1 -1 1|-1 -1 1 -1 -1 1] [ 1 1 1 1 -1 -1|-1 1 -1 1 -1 -1] [ 1 -1 1 1 1 -1|-1 -1 1 -1 1 -1] [ 1 -1 -1 1 1 1|-1 -1 -1 1 -1 1] [ 1 1 -1 -1 1 1|-1 1 -1 -1 1 -1] [-----------------+-----------------] [ 1 -1 -1 -1 -1 -1|-1 1 1 1 1 1] [ 1 -1 1 -1 -1 1| 1 -1 -1 1 1 -1] [ 1 1 -1 1 -1 -1| 1 -1 -1 -1 1 1] [ 1 -1 1 -1 1 -1| 1 1 -1 -1 -1 1] [ 1 -1 -1 1 -1 1| 1 1 1 -1 -1 -1] [ 1 1 -1 -1 1 -1| 1 -1 1 1 -1 -1] """ N = Integer(n / 2) p = N - 1 if not (is_prime(p) and (p % 4 == 1)): raise ValueError( "The order %s is not covered by the Paley type II construction." % n) S = matrix(ZZ, [[H2(i, j, p) for i in range(N)] for j in range(N)]) H = block_matrix([[S + 1, S - 1], [1 - S, S + 1]]) # normalising H so that first row and column have only +1 entries. return normalise_hadamard(H)
def hadamard_matrix_paleyII(n): """ Implements the Paley type II construction. The Paley type II case corresponds to the case `p \cong 1 \mod{4}` for a prime `p` (see [Hora]_). EXAMPLES:: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyII(12).det() 2985984 sage: 12^6 2985984 We note that the method returns a normalised Hadamard matrix :: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyII(12) [ 1 1 1 1 1 1| 1 1 1 1 1 1] [ 1 1 1 -1 -1 1|-1 -1 1 -1 -1 1] [ 1 1 1 1 -1 -1|-1 1 -1 1 -1 -1] [ 1 -1 1 1 1 -1|-1 -1 1 -1 1 -1] [ 1 -1 -1 1 1 1|-1 -1 -1 1 -1 1] [ 1 1 -1 -1 1 1|-1 1 -1 -1 1 -1] [-----------------+-----------------] [ 1 -1 -1 -1 -1 -1|-1 1 1 1 1 1] [ 1 -1 1 -1 -1 1| 1 -1 -1 1 1 -1] [ 1 1 -1 1 -1 -1| 1 -1 -1 -1 1 1] [ 1 -1 1 -1 1 -1| 1 1 -1 -1 -1 1] [ 1 -1 -1 1 -1 1| 1 1 1 -1 -1 -1] [ 1 1 -1 -1 1 -1| 1 -1 1 1 -1 -1] """ N = Integer(n/2) p = N - 1 if not(is_prime(p) and (p % 4 == 1)): raise ValueError("The order %s is not covered by the Paley type II construction." % n) S = matrix(ZZ, [[H2(i, j, p) for i in range(N)] for j in range(N)]) H = block_matrix([[S + 1, S - 1], [1 - S, S + 1]]) # normalising H so that first row and column have only +1 entries. return normalise_hadamard(H)
def is_blum_prime(n): r""" Determine whether or not ``n`` is a Blum prime. INPUT: - ``n`` a positive prime. OUTPUT: - ``True`` if ``n`` is a Blum prime; ``False`` otherwise. Let `n` be a positive prime. Then `n` is a Blum prime if `n` is congruent to 3 modulo 4, i.e. `n \equiv 3 \pmod{4}`. EXAMPLES: Testing some integers to see if they are Blum primes:: sage: from sage.crypto.util import is_blum_prime sage: from sage.crypto.util import random_blum_prime sage: is_blum_prime(101) False sage: is_blum_prime(7) True sage: p = random_blum_prime(10**3, 10**5) sage: is_blum_prime(p) True """ if n < 0: return False if is_prime(n): if mod(n, 4).lift() == 3: return True else: return False else: return False
def hadamard_matrix_paleyI(n): """ Implements the Paley type I construction. The Paley type I case corresponds to the case `p \cong 3 \mod{4}` for a prime `p` (see [Hora]_). EXAMPLES: We note that this method returns a normalised Hadamard matrix :: sage: sage.combinat.matrices.hadamard_matrix.hadamard_matrix_paleyI(4) [ 1 1 1 1] [ 1 -1 -1 1] [ 1 1 -1 -1] [ 1 -1 1 -1] """ p = n - 1 if not(is_prime(p) and (p % 4 == 3)): raise ValueError("The order %s is not covered by the Paley type I construction." % n) H = matrix(ZZ, [[H1(i, j, p) for i in range(n)] for j in range(n)]) # normalising H so that first row and column have only +1 entries. return normalise_hadamard(H)
def green_function(self, G, v, **kwds): r""" Evaluates the local Green's function with respect to the morphism ``G`` at the place ``v`` for ``self`` with ``N`` terms of the series or to within a given error bound. Must be over a number field or order of a number field. Note that this is the absolute local Green's function so is scaled by the degree of the base field. Use ``v=0`` for the archimedean place over `\QQ` or field embedding. Non-archimedean places are prime ideals for number fields or primes over `\QQ`. ALGORITHM: See Exercise 5.29 and Figure 5.6 of ``The Arithmetic of Dynamics Systems``, Joseph H. Silverman, Springer, GTM 241, 2007. INPUT: - ``G`` - a projective morphism whose local Green's function we are computing - ``v`` - non-negative integer. a place, use v=0 for the archimedean place kwds: - ``N`` - positive integer. number of terms of the series to use, default: 10 - ``prec`` - positive integer, float point or p-adic precision, default: 100 - ``error_bound`` - a positive real number OUTPUT: - a real number EXAMPLES:: sage: P.<x,y>=ProjectiveSpace(QQ,1) sage: H=Hom(P,P) sage: f=H([x^2+y^2,x*y]); sage: Q=P(5,1) sage: f.green_function(Q,0,N=30) 1.6460930159932946233759277576 :: sage: P.<x,y>=ProjectiveSpace(QQ,1) sage: H=Hom(P,P) sage: f=H([x^2+y^2,x*y]); sage: Q=P(5,1) sage: Q.green_function(f,0,N=200,prec=200) 1.6460930160038721802875250367738355497198064992657997569827 :: sage: K.<w> = QuadraticField(3) sage: P.<x,y> = ProjectiveSpace(K,1) sage: H = Hom(P,P) sage: f = H([17*x^2+1/7*y^2,17*w*x*y]) sage: f.green_function(P.point([w,2],False), K.places()[1]) 1.7236334013785676107373093775 sage: print f.green_function(P([2,1]), K.ideal(7), N=7) 0.48647753726382832627633818586 sage: print f.green_function(P([w,1]), K.ideal(17), error_bound=0.001) -0.70761163353747779889947530309 .. TODO:: Implement general p-adic extensions so that the flip trick can be used for number fields. """ N = kwds.get('N', 10) #Get number of iterates (if entered) err = kwds.get('error_bound', None) #Get error bound (if entered) prec = kwds.get('prec', 100) #Get precision (if entered) R = RealField(prec) localht = R(0) BR = FractionField(self.codomain().base_ring()) GBR = G.change_ring(BR) #so the heights work if not BR in NumberFields(): raise NotImplementedError("Must be over a NumberField or a NumberField Order") #For QQ the 'flip-trick' works better over RR or Qp if isinstance(v, (NumberFieldFractionalIdeal, RingHomomorphism_im_gens)): K = BR elif is_prime(v): K = Qp(v, prec) elif v == 0: K = R v = BR.places(prec=prec)[0] else: raise ValueError("Invalid valuation (=%s) entered."%v) #Coerce all polynomials in F into polynomials with coefficients in K F = G.change_ring(K, False) d = F.degree() dim = F.codomain().ambient_space().dimension_relative() P = self.change_ring(K, False) if err is not None: err = R(err) if not err>0: raise ValueError("Error bound (=%s) must be positive."%err) if G.is_endomorphism() == False: raise NotImplementedError("Error bounds only for endomorphisms") #if doing error estimates, compute needed number of iterates D = (dim + 1) * (d - 1) + 1 #compute upper bound if isinstance(v, RingHomomorphism_im_gens): #archimedean vindex = BR.places(prec=prec).index(v) U = GBR.local_height_arch(vindex, prec=prec) + R(binomial(dim + d, d)).log() else: #non-archimedean U = GBR.local_height(v, prec=prec) #compute lower bound - from explicit polynomials of Nullstellensatz CR = GBR.codomain().ambient_space().coordinate_ring() #.lift() only works over fields I = CR.ideal(GBR.defining_polynomials()) maxh = 0 for k in range(dim + 1): CoeffPolys = (CR.gen(k) ** D).lift(I) Res = 1 h = 1 for poly in CoeffPolys: if poly != 0: for c in poly.coefficients(): Res = lcm(Res, c.denominator()) for poly in CoeffPolys: if poly != 0: if isinstance(v, RingHomomorphism_im_gens): #archimedean if BR == QQ: h = max([(Res*c).local_height_arch(prec=prec) for c in poly.coefficients()]) else: h = max([(Res*c).local_height_arch(vindex, prec=prec) for c in poly.coefficients()]) else: #non-archimedean h = max([c.local_height(v, prec=prec) for c in poly.coefficients()]) if h > maxh: maxh=h if isinstance(v, RingHomomorphism_im_gens): #archimedean L = R(Res / ((dim + 1) * binomial(dim + D - d, D - d) * maxh)).log().abs() else: #non-archimedean L = R(1 / maxh).log().abs() C = max([U, L]) if C != 0: N = R(C/(err)).log(d).abs().ceil() else: #we just need log||P||_v N=1 #START GREEN FUNCTION CALCULATION if isinstance(v, RingHomomorphism_im_gens): #embedding for archimedean local height for i in range(N+1): Pv = [ (v(t).abs()) for t in P ] m = -1 #compute the maximum absolute value of entries of a, and where it occurs for n in range(dim + 1): if Pv[n] > m: j = n m = Pv[n] # add to sum for the Green's function localht += ((1/R(d))**R(i)) * (R(m).log()) #get the next iterate if i < N: P.scale_by(1/P[j]) P = F(P, False) return (1/BR.absolute_degree()) * localht #else - prime or prime ideal for non-archimedean for i in range(N + 1): if BR == QQ: Pv = [ R(K(t).abs()) for t in P ] else: Pv = [ R(t.abs_non_arch(v)) for t in P ] m = -1 #compute the maximum absolute value of entries of a, and where it occurs for n in range(dim + 1): if Pv[n] > m: j = n m = Pv[n] # add to sum for the Green's function localht += ((1/R(d))**R(i)) * (R(m).log()) #get the next iterate if i < N: P.scale_by(1/P[j]) P = F(P, False) return (1/BR.absolute_degree()) * localht
def pthpowers(self, p, Bound): """ Find the indices of proveably all pth powers in the recurrence sequence bounded by Bound. Let `u_n` be a binary recurrence sequence. A ``p`` th power in `u_n` is a solution to `u_n = y^p` for some integer `y`. There are only finitely many ``p`` th powers in any recurrence sequence [SS]. INPUT: - ``p`` - a rational prime integer (the fixed p in `u_n = y^p`) - ``Bound`` - a natural number (the maximum index `n` in `u_n = y^p` that is checked). OUTPUT: - A list of the indices of all ``p`` th powers less bounded by ``Bound``. If the sequence is degenerate and there are many ``p`` th powers, raises ``ValueError``. EXAMPLES:: sage: R = BinaryRecurrenceSequence(1,1) #the Fibonacci sequence sage: R.pthpowers(2, 10**30) # long time (7 seconds) -- in fact these are all squares, c.f. [BMS06] [0, 1, 2, 12] sage: S = BinaryRecurrenceSequence(8,1) #a Lucas sequence sage: S.pthpowers(3,10**30) # long time (3 seconds) -- provably finds the indices of all 3rd powers less than 10^30 [0, 1, 2] sage: Q = BinaryRecurrenceSequence(3,3,2,1) sage: Q.pthpowers(11,10**30) # long time (7.5 seconds) [1] If the sequence is degenerate, and there are are no ``p`` th powers, returns `[]`. Otherwise, if there are many ``p`` th powers, raises ``ValueError``. :: sage: T = BinaryRecurrenceSequence(2,0,1,2) sage: T.is_degenerate() True sage: T.is_geometric() True sage: T.pthpowers(7,10**30) Traceback (most recent call last): ... ValueError: The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers. sage: L = BinaryRecurrenceSequence(4,0,2,2) sage: [L(i).factor() for i in xrange(10)] [2, 2, 2^3, 2^5, 2^7, 2^9, 2^11, 2^13, 2^15, 2^17] sage: L.is_quasigeometric() True sage: L.pthpowers(2,10**30) [] NOTE: This function is primarily optimized in the range where ``Bound`` is much larger than ``p``. """ #Thanks to Jesse Silliman for helpful conversations! #Reset the dictionary of good primes, as this depends on p self._PGoodness = {} #Starting lower bound on good primes self._ell = 1 #If the sequence is geometric, then the `n`th term is `a*r^n`. Thus the #property of being a ``p`` th power is periodic mod ``p``. So there are either #no ``p`` th powers if there are none in the first ``p`` terms, or many if there #is at least one in the first ``p`` terms. if self.is_geometric() or self.is_quasigeometric(): no_powers = True for i in xrange(1, 6 * p + 1): if _is_p_power(self(i), p): no_powers = False break if no_powers: if _is_p_power(self.u0, p): return [0] return [] else: raise ValueError( "The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers." ) #If the sequence is degenerate without being geometric or quasigeometric, there #may be many ``p`` th powers or no ``p`` th powers. elif (self.b**2 + 4 * self.c) == 0: #This is the case if the matrix F is not diagonalizable, ie b^2 +4c = 0, and alpha/beta = 1. alpha = self.b / 2 #In this case, u_n = u_0*alpha^n + (u_1 - u_0*alpha)*n*alpha^(n-1) = alpha^(n-1)*(u_0 +n*(u_1 - u_0*alpha)), #that is, it is a geometric term (alpha^(n-1)) times an arithmetic term (u_0 + n*(u_1-u_0*alpha)). #Look at classes n = k mod p, for k = 1,...,p. for k in xrange(1, p + 1): #The linear equation alpha^(k-1)*u_0 + (k+pm)*(alpha^(k-1)*u1 - u0*alpha^k) #must thus be a pth power. This is a linear equation in m, namely, A + B*m, where A = (alpha**(k - 1) * self.u0 + k * (alpha**(k - 1) * self.u1 - self.u0 * alpha**k)) B = p * (alpha**(k - 1) * self.u1 - self.u0 * alpha**k) #This linear equation represents a pth power iff A is a pth power mod B. if _is_p_power_mod(A, p, B): raise ValueError( "The degenerate binary recurrence sequence has many pth powers." ) return [] #We find ``p`` th powers using an elementary sieve. Term `u_n` is a ``p`` th #power if and only if it is a ``p`` th power modulo every prime `\\ell`. This condition #gives nontrivial information if ``p`` divides the order of the multiplicative group of #`\\Bold(F)_{\\ell}`, i.e. if `\\ell` is ` 1 \mod{p}`, as then only `1/p` terms are ``p`` th #powers modulo `\\ell``. #Thus, given such an `\\ell`, we get a set of necessary congruences for the index modulo the #the period of the sequence mod `\\ell`. Then we intersect these congruences for many primes #to get a tight list modulo a growing modulus. In order to keep this step manageable, we #only use primes `\\ell` that are have particularly smooth periods. #Some congruences in the list will remain as the modulus grows. If a congruence remains through #7 rounds of increasing the modulus, then we check if this corresponds to a perfect power (if #it does, we add it to our list of indices corresponding to ``p`` th powers). The rest of the congruences #are transient and grow with the modulus. Once the smallest of these is greater than the bound, #the list of known indices corresponding to ``p`` th powers is complete. else: if Bound < 3 * p: powers = [] ell = p + 1 while not is_prime(ell): ell = ell + p F = GF(ell) a0 = F(self.u0) a1 = F(self.u1) #a0 and a1 are variables for terms in sequence bf, cf = F(self.b), F(self.c) for n in xrange(Bound): # n is the index of the a0 #Check whether a0 is a perfect power mod ell if _is_p_power_mod(a0, p, ell): #if a0 is a perfect power mod ell, check if nth term is ppower if _is_p_power(self(n), p): powers.append(n) a0, a1 = a1, bf * a1 + cf * a0 #step up the variables else: powers = [ ] #documents the indices of the sequence that provably correspond to pth powers cong = [ 0 ] #list of necessary congruences on the index for it to correspond to pth powers Possible_count = { } #keeps track of the number of rounds a congruence lasts in cong #These parameters are involved in how we choose primes to increase the modulus qqold = 1 #we believe that we know complete information coming from primes good by qqold M1 = 1 #we have congruences modulo M1, this may not be the tightest list M2 = p #we want to move to have congruences mod M2 qq = 1 #the largest prime power divisor of M1 is qq #This loop ups the modulus. while True: #Try to get good data mod M2 #patience of how long we should search for a "good prime" patience = 0.01 * _estimated_time( lcm(M2, p * next_prime_power(qq)), M1, len(cong), p) tries = 0 #This loop uses primes to get a small set of congruences mod M2. while True: #only proceed if took less than patience time to find the next good prime ell = _next_good_prime(p, self, qq, patience, qqold) if ell: #gather congruence data for the sequence mod ell, which will be mod period(ell) = modu cong1, modu = _find_cong1(p, self, ell) CongNew = [ ] #makes a new list from cong that is now mod M = lcm(M1, modu) instead of M1 M = lcm(M1, modu) for k in xrange(M / M1): for i in cong: CongNew.append(k * M1 + i) cong = set(CongNew) M1 = M killed_something = False #keeps track of when cong1 can rule out a congruence in cong #CRT by hand to gain speed for i in list(cong): if not ( i % modu in cong1 ): #congruence in cong is inconsistent with any in cong1 cong.remove(i) #remove that congruence killed_something = True if M1 == M2: if not killed_something: tries += 1 if tries == 2: #try twice to rule out congruences cong = list(cong) qqold = qq qq = next_prime_power(qq) M2 = lcm(M2, p * qq) break else: qq = next_prime_power(qq) M2 = lcm(M2, p * qq) cong = list(cong) break #Document how long each element of cong has been there for i in cong: if i in Possible_count: Possible_count[i] = Possible_count[i] + 1 else: Possible_count[i] = 1 #Check how long each element has persisted, if it is for at least 7 cycles, #then we check to see if it is actually a perfect power for i in Possible_count: if Possible_count[i] == 7: n = Integer(i) if n < Bound: if _is_p_power(self(n), p): powers.append(n) #check for a contradiction if len(cong) > len(powers): if cong[len(powers)] > Bound: break elif M1 > Bound: break return powers
def local_genus_symbol(self, p): """ Returns the Conway-Sloane genus symbol of 2 times a quadratic form defined over ZZ at a prime number p. This is defined (in the Genus_Symbol_p_adic_ring() class in the quadratic_forms/genera subfolder) to be a list of tuples (one for each Jordan component p^m*A at p, where A is a unimodular symmetric matrix with coefficients the p-adic integers) of the following form: 1. If p>2 then return triples of the form [`m`, `n`, `d`] where `m` = valuation of the component `n` = rank of A `d` = det(A) in {1,u} for normalized quadratic non-residue u. 2. If p=2 then return quintuples of the form [`m`,`n`,`s`, `d`, `o`] where `m` = valuation of the component `n` = rank of A `d` = det(A) in {1,3,5,7} `s` = 0 (or 1) if A is even (or odd) `o` = oddity of A (= 0 if s = 0) in Z/8Z = the trace of the diagonalization of A NOTE: The Conway-Sloane convention for describing the prime 'p = -1' is not supported here, and neither is the convention for including the 'prime' Infinity. See note on p370 of Conway-Sloane (3rd ed) for a discussion of this convention. INPUT: -`p` -- a prime number > 0 OUTPUT: Returns a Conway-Sloane genus symbol at p, which is an instance of the Genus_Symbol_p_adic_ring class. EXAMPLES:: sage: Q = DiagonalQuadraticForm(ZZ, [1,2,3,4]) sage: Q.local_genus_symbol(2) Genus symbol at 2 : [[1, 2, 3, 1, 4], [2, 1, 1, 1, 1], [3, 1, 1, 1, 1]] sage: Q.local_genus_symbol(3) Genus symbol at 3 : [[0, 3, 1], [1, 1, -1]] sage: Q.local_genus_symbol(5) Genus symbol at 5 : [[0, 4, 1]] """ ## Check that p is prime and that the form is defined over ZZ. if not is_prime(p): raise TypeError, "Oops! The number " + str(p) + " isn't prime." if not self.base_ring() == IntegerRing(): raise TypeError, "Oops! The quadratic form is not defined over the integers." ## Return the result try: M = self.Hessian_matrix() return LocalGenusSymbol(M, p) except StandardError: raise TypeError, "Oops! There is a problem computing the local genus symbol at the prime " + str(p) + " for this form."
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1, name) p, n = arith.factor(order)[0] # The following is a temporary solution that allows us # to construct compatible systems of finite fields # until algebraic closures of finite fields are # implemented in Sage. It requires the user to # specify two parameters: # # - `conway` -- boolean; if True, this field is # constructed to fit in a compatible system using # a Conway polynomial. # - `prefix` -- a string used to generate names for # automatically constructed finite fields # # See the docstring of FiniteFieldFactory for examples. # # Once algebraic closures of finite fields are # implemented, this syntax should be superseded by # something like the following: # # sage: Fpbar = GF(5).algebraic_closure('z') # sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar # sage: F # Finite field in z3 of size 5^3 # # This temporary solution only uses actual Conway # polynomials (no pseudo-Conway polynomials), since # pseudo-Conway polynomials are not unique, and until # we have algebraic closures of finite fields, there # is no good place to store a specific choice of # pseudo-Conway polynomials. if name is None: if not (kwds.has_key('conway') and kwds['conway']): raise ValueError( "parameter 'conway' is required if no name given") if not kwds.has_key('prefix'): raise ValueError( "parameter 'prefix' is required if no name given") name = kwds['prefix'] + str(n) if kwds.has_key('conway') and kwds['conway']: from conway_polynomials import conway_polynomial if not kwds.has_key('prefix'): raise ValueError( "a prefix must be specified if conway=True") if modulus is not None: raise ValueError( "no modulus may be specified if conway=True") # The following raises a RuntimeError if no polynomial is found. modulus = conway_polynomial(p, n) if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial( modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError( "the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds
def has_equivalent_Jordan_decomposition_at_prime(self, other, p): """ Determines if the given quadratic form has a Jordan decomposition equivalent to that of self. INPUT: a QuadraticForm OUTPUT: boolean EXAMPLES:: sage: Q1 = QuadraticForm(ZZ, 3, [1, 0, -1, 1, 0, 3]) sage: Q2 = QuadraticForm(ZZ, 3, [1, 0, 0, 2, -2, 6]) sage: Q3 = QuadraticForm(ZZ, 3, [1, 0, 0, 1, 0, 11]) sage: [Q1.level(), Q2.level(), Q3.level()] [44, 44, 44] sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q2,2) False sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q2,11) False sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q3,2) False sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q3,11) True sage: Q2.has_equivalent_Jordan_decomposition_at_prime(Q3,2) True sage: Q2.has_equivalent_Jordan_decomposition_at_prime(Q3,11) False """ ## Sanity Checks #if not isinstance(other, QuadraticForm): if type(other) != type(self): raise TypeError, "Oops! The first argument must be of type QuadraticForm." if not is_prime(p): raise TypeError, "Oops! The second argument must be a prime number." ## Get the relevant local normal forms quickly self_jordan = self.jordan_blocks_by_scale_and_unimodular(p, safe_flag= False) other_jordan = other.jordan_blocks_by_scale_and_unimodular(p, safe_flag=False) ## DIAGNOSTIC #print "self_jordan = ", self_jordan #print "other_jordan = ", other_jordan ## Check for the same number of Jordan components if len(self_jordan) != len(other_jordan): return False ## Deal with odd primes: Check that the Jordan component scales, dimensions, and discriminants are the same if p != 2: for i in range(len(self_jordan)): if (self_jordan[i][0] != other_jordan[i][0]) \ or (self_jordan[i][1].dim() != other_jordan[i][1].dim()) \ or (legendre_symbol(self_jordan[i][1].det() * other_jordan[i][1].det(), p) != 1): return False ## All tests passed for an odd prime. return True ## For p = 2: Check that all Jordan Invariants are the same. elif p == 2: ## Useful definition t = len(self_jordan) ## Define t = Number of Jordan components ## Check that all Jordan Invariants are the same (scale, dim, and norm) for i in range(t): if (self_jordan[i][0] != other_jordan[i][0]) \ or (self_jordan[i][1].dim() != other_jordan[i][1].dim()) \ or (valuation(GCD(self_jordan[i][1].coefficients()), p) != valuation(GCD(other_jordan[i][1].coefficients()), p)): return False ## DIAGNOSTIC #print "Passed the Jordan invariant test." ## Use O'Meara's isometry test 93:29 on p277. ## ------------------------------------------ ## List of norms, scales, and dimensions for each i scale_list = [ZZ(2)**self_jordan[i][0] for i in range(t)] norm_list = [ZZ(2)**(self_jordan[i][0] + valuation(GCD(self_jordan[i][1].coefficients()), 2)) for i in range(t)] dim_list = [(self_jordan[i][1].dim()) for i in range(t)] ## List of Hessian determinants and Hasse invariants for each Jordan (sub)chain ## (Note: This is not the same as O'Meara's Gram determinants, but ratios are the same!) -- NOT SO GOOD... ## But it matters in condition (ii), so we multiply all by 2 (instead of dividing by 2 since only square-factors matter, and it's easier.) j = 0 self_chain_det_list = [ self_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j])] other_chain_det_list = [ other_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j])] self_hasse_chain_list = [ self_jordan[j][1].scale_by_factor(ZZ(2)**self_jordan[j][0]).hasse_invariant__OMeara(2) ] other_hasse_chain_list = [ other_jordan[j][1].scale_by_factor(ZZ(2)**other_jordan[j][0]).hasse_invariant__OMeara(2) ] for j in range(1, t): self_chain_det_list.append(self_chain_det_list[j-1] * self_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j])) other_chain_det_list.append(other_chain_det_list[j-1] * other_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j])) self_hasse_chain_list.append(self_hasse_chain_list[j-1] \ * hilbert_symbol(self_chain_det_list[j-1], self_jordan[j][1].Gram_det(), 2) \ * self_jordan[j][1].hasse_invariant__OMeara(2)) other_hasse_chain_list.append(other_hasse_chain_list[j-1] \ * hilbert_symbol(other_chain_det_list[j-1], other_jordan[j][1].Gram_det(), 2) \ * other_jordan[j][1].hasse_invariant__OMeara(2)) ## SANITY CHECK -- check that the scale powers are strictly increasing for i in range(1, len(scale_list)): if scale_list[i-1] >= scale_list[i]: raise RuntimeError, "Oops! There is something wrong with the Jordan Decomposition -- the given scales are not strictly increasing!" ## DIAGNOSTIC #print "scale_list = ", scale_list #print "norm_list = ", norm_list #print "dim_list = ", dim_list #print #print "self_chain_det_list = ", self_chain_det_list #print "other_chain_det_list = ", other_chain_det_list #print "self_hasse_chain_list = ", self_hasse_chain_list #print "other_hasse_chain_det_list = ", other_hasse_chain_list ## Test O'Meara's two conditions for i in range(t-1): ## Condition (i): Check that their (unit) ratio is a square (but it suffices to check at most mod 8). modulus = norm_list[i] * norm_list[i+1] / (scale_list[i] ** 2) if modulus > 8: modulus = 8 if (modulus > 1) and (((self_chain_det_list[i] / other_chain_det_list[i]) % modulus) != 1): #print "Failed when i =", i, " in condition 1." return False ## Check O'Meara's condition (ii) when appropriate if norm_list[i+1] % (4 * norm_list[i]) == 0: if self_hasse_chain_list[i] * hilbert_symbol(norm_list[i] * other_chain_det_list[i], -self_chain_det_list[i], 2) \ != other_hasse_chain_list[i] * hilbert_symbol(norm_list[i], -other_chain_det_list[i], 2): ## Nipp conditions #print "Failed when i =", i, " in condition 2." return False ## All tests passed for the prime 2. return True else: raise TypeError, "Oops! This should not have happened."
def local_genus_symbol(self, p): """ Returns the Conway-Sloane genus symbol of 2 times a quadratic form defined over ZZ at a prime number p. This is defined (in the Genus_Symbol_p_adic_ring() class in the quadratic_forms/genera subfolder) to be a list of tuples (one for each Jordan component p^m*A at p, where A is a unimodular symmetric matrix with coefficients the p-adic integers) of the following form: 1. If p>2 then return triples of the form [`m`, `n`, `d`] where `m` = valuation of the component `n` = rank of A `d` = det(A) in {1,u} for normalized quadratic non-residue u. 2. If p=2 then return quintuples of the form [`m`,`n`,`s`, `d`, `o`] where `m` = valuation of the component `n` = rank of A `d` = det(A) in {1,3,5,7} `s` = 0 (or 1) if A is even (or odd) `o` = oddity of A (= 0 if s = 0) in Z/8Z = the trace of the diagonalization of A NOTE: The Conway-Sloane convention for describing the prime 'p = -1' is not supported here, and neither is the convention for including the 'prime' Infinity. See note on p370 of Conway-Sloane (3rd ed) for a discussion of this convention. INPUT: -`p` -- a prime number > 0 OUTPUT: Returns a Conway-Sloane genus symbol at p, which is an instance of the Genus_Symbol_p_adic_ring class. EXAMPLES:: sage: Q = DiagonalQuadraticForm(ZZ, [1,2,3,4]) sage: Q.local_genus_symbol(2) Genus symbol at 2 : [[1, 2, 3, 1, 4], [2, 1, 1, 1, 1], [3, 1, 1, 1, 1]] sage: Q.local_genus_symbol(3) Genus symbol at 3 : [[0, 3, 1], [1, 1, -1]] sage: Q.local_genus_symbol(5) Genus symbol at 5 : [[0, 4, 1]] """ ## Check that p is prime and that the form is defined over ZZ. if not is_prime(p): raise TypeError, "Oops! The number " + str(p) + " isn't prime." if not self.base_ring() == IntegerRing(): raise TypeError, "Oops! The quadratic form is not defined over the integers." ## Return the result try: M = self.Hessian_matrix() return LocalGenusSymbol(M, p) except Exception: raise TypeError, "Oops! There is a problem computing the local genus symbol at the prime " + str( p) + " for this form."
def local_normal_form(self, p): """ Returns the a locally integrally equivalent quadratic form over the p-adic integers Z_p which gives the Jordan decomposition. The Jordan components are written as sums of blocks of size <= 2 and are arranged by increasing scale, and then by increasing norm. (This is equivalent to saying that we put the 1x1 blocks before the 2x2 blocks in each Jordan component.) INPUT: `p` -- a positive prime number. OUTPUT: a quadratic form over ZZ WARNING: Currently this only works for quadratic forms defined over ZZ. EXAMPLES:: sage: Q = QuadraticForm(ZZ, 2, [10,4,1]) sage: Q.local_normal_form(5) Quadratic form in 2 variables over Integer Ring with coefficients: [ 1 0 ] [ * 6 ] :: sage: Q.local_normal_form(3) Quadratic form in 2 variables over Integer Ring with coefficients: [ 10 0 ] [ * 15 ] sage: Q.local_normal_form(2) Quadratic form in 2 variables over Integer Ring with coefficients: [ 1 0 ] [ * 6 ] """ ## Sanity Checks if (self.base_ring() != IntegerRing()): raise NotImplementedError( "Oops! This currently only works for quadratic forms defined over IntegerRing(). =(" ) if not ((p >= 2) and is_prime(p)): raise TypeError("Oops! p is not a positive prime number. =(") ## Some useful local variables Q = copy.deepcopy(self) Q.__init__(self.base_ring(), self.dim(), self.coefficients()) ## Prepare the final form to return Q_Jordan = copy.deepcopy(self) Q_Jordan.__init__(self.base_ring(), 0) while Q.dim() > 0: n = Q.dim() ## Step 1: Find the minimally p-divisible matrix entry, preferring diagonals ## ------------------------------------------------------------------------- (min_i, min_j) = Q.find_entry_with_minimal_scale_at_prime(p) if min_i == min_j: min_val = valuation(2 * Q[min_i, min_j], p) else: min_val = valuation(Q[min_i, min_j], p) ## Error if we still haven't seen non-zero coefficients! if (min_val == Infinity): raise RuntimeError("Oops! The original matrix is degenerate. =(") ## Step 2: Arrange for the upper leftmost entry to have minimal valuation ## ---------------------------------------------------------------------- if (min_i == min_j): block_size = 1 Q.swap_variables(0, min_i, in_place=True) else: ## Work in the upper-left 2x2 block, and replace it by its 2-adic equivalent form Q.swap_variables(0, min_i, in_place=True) Q.swap_variables(1, min_j, in_place=True) ## 1x1 => make upper left the smallest if (p != 2): block_size = 1 Q.add_symmetric(1, 0, 1, in_place=True) ## 2x2 => replace it with the appropriate 2x2 matrix else: block_size = 2 ## DIAGNOSTIC #print "\n Finished Step 2 \n"; #print "\n Q is: \n" + str(Q) + "\n"; #print " p is: " + str(p) #print " min_val is: " + str( min_val) #print " block_size is: " + str(block_size) #print "\n Starting Step 3 \n" ## Step 3: Clear out the remaining entries ## --------------------------------------- min_scale = p**min_val ## This is the minimal valuation of the Hessian matrix entries. ##DIAGNOSTIC #print "Starting Step 3:" #print "----------------" #print " min_scale is: " + str(min_scale) ## Perform cancellation over Z by ensuring divisibility if (block_size == 1): a = 2 * Q[0, 0] for j in range(block_size, n): b = Q[0, j] g = GCD(a, b) ## DIAGNSOTIC #print "Cancelling from a 1x1 block:" #print "----------------------------" #print " Cancelling entry with index (" + str(upper_left) + ", " + str(j) + ")" #print " entry = " + str(b) #print " gcd = " + str(g) #print " a = " + str(a) #print " b = " + str(b) #print " a/g = " + str(a/g) + " (used for stretching)" #print " -b/g = " + str(-b/g) + " (used for cancelling)" ## Sanity Check: a/g is a p-unit if valuation(g, p) != valuation(a, p): raise RuntimeError( "Oops! We have a problem with our rescaling not preserving p-integrality!" ) Q.multiply_variable( ZZ(a / g), j, in_place=True ) ## Ensures that the new b entry is divisible by a Q.add_symmetric(ZZ(-b / g), j, 0, in_place=True) ## Performs the cancellation elif (block_size == 2): a1 = 2 * Q[0, 0] a2 = Q[0, 1] b1 = Q[1, 0] ## This is the same as a2 b2 = 2 * Q[1, 1] big_det = (a1 * b2 - a2 * b1) small_det = big_det / (min_scale * min_scale) ## Cancels out the rows/columns of the 2x2 block for j in range(block_size, n): a = Q[0, j] b = Q[1, j] ## Ensures an integral result (scale jth row/column by big_det) Q.multiply_variable(big_det, j, in_place=True) ## Performs the cancellation (by producing -big_det * jth row/column) Q.add_symmetric(ZZ(-(a * b2 - b * a2)), j, 0, in_place=True) Q.add_symmetric(ZZ(-(-a * b1 + b * a1)), j, 1, in_place=True) ## Now remove the extra factor (non p-unit factor) in big_det we introduced above Q.divide_variable(ZZ(min_scale * min_scale), j, in_place=True) ## DIAGNOSTIC #print "Cancelling out a 2x2 block:" #print "---------------------------" #print " a1 = " + str(a1) #print " a2 = " + str(a2) #print " b1 = " + str(b1) #print " b2 = " + str(b2) #print " big_det = " + str(big_det) #print " min_scale = " + str(min_scale) #print " small_det = " + str(small_det) #print " Q = \n", Q ## Uses Cassels's proof to replace the remaining 2 x 2 block if (((1 + small_det) % 8) == 0): Q[0, 0] = 0 Q[1, 1] = 0 Q[0, 1] = min_scale elif (((5 + small_det) % 8) == 0): Q[0, 0] = min_scale Q[1, 1] = min_scale Q[0, 1] = min_scale else: raise RuntimeError( "Error in LocalNormal: Impossible behavior for a 2x2 block! \n" ) ## Check that the cancellation worked, extract the upper-left block, and trim Q to handle the next block. for i in range(block_size): for j in range(block_size, n): if Q[i, j] != 0: raise RuntimeError( "Oops! The cancellation didn't work properly at entry (" + str(i) + ", " + str(j) + ").") Q_Jordan = Q_Jordan + Q.extract_variables(range(block_size)) Q = Q.extract_variables(range(block_size, n)) return Q_Jordan
def local_normal_form(self, p): """ Returns the a locally integrally equivalent quadratic form over the p-adic integers Z_p which gives the Jordan decomposition. The Jordan components are written as sums of blocks of size <= 2 and are arranged by increasing scale, and then by increasing norm. (This is equivalent to saying that we put the 1x1 blocks before the 2x2 blocks in each Jordan component.) INPUT: `p` -- a positive prime number. OUTPUT: a quadratic form over ZZ WARNING: Currently this only works for quadratic forms defined over ZZ. EXAMPLES:: sage: Q = QuadraticForm(ZZ, 2, [10,4,1]) sage: Q.local_normal_form(5) Quadratic form in 2 variables over Integer Ring with coefficients: [ 1 0 ] [ * 6 ] :: sage: Q.local_normal_form(3) Quadratic form in 2 variables over Integer Ring with coefficients: [ 10 0 ] [ * 15 ] sage: Q.local_normal_form(2) Quadratic form in 2 variables over Integer Ring with coefficients: [ 1 0 ] [ * 6 ] """ ## Sanity Checks if (self.base_ring() != IntegerRing()): raise NotImplementedError, "Oops! This currently only works for quadratic forms defined over IntegerRing(). =(" if not ((p>=2) and is_prime(p)): raise TypeError, "Oops! p is not a positive prime number. =(" ## Some useful local variables Q = copy.deepcopy(self) Q.__init__(self.base_ring(), self.dim(), self.coefficients()) ## Prepare the final form to return Q_Jordan = copy.deepcopy(self) Q_Jordan.__init__(self.base_ring(), 0) while Q.dim() > 0: n = Q.dim() ## Step 1: Find the minimally p-divisible matrix entry, preferring diagonals ## ------------------------------------------------------------------------- (min_i, min_j) = Q.find_entry_with_minimal_scale_at_prime(p) if min_i == min_j: min_val = valuation(2 * Q[min_i, min_j], p) else: min_val = valuation(Q[min_i, min_j], p) ## Error if we still haven't seen non-zero coefficients! if (min_val == Infinity): raise RuntimeError, "Oops! The original matrix is degenerate. =(" ## Step 2: Arrange for the upper leftmost entry to have minimal valuation ## ---------------------------------------------------------------------- if (min_i == min_j): block_size = 1 Q.swap_variables(0, min_i, in_place = True) else: ## Work in the upper-left 2x2 block, and replace it by its 2-adic equivalent form Q.swap_variables(0, min_i, in_place = True) Q.swap_variables(1, min_j, in_place = True) ## 1x1 => make upper left the smallest if (p != 2): block_size = 1; Q.add_symmetric(1, 0, 1, in_place = True) ## 2x2 => replace it with the appropriate 2x2 matrix else: block_size = 2 ## DIAGNOSTIC #print "\n Finished Step 2 \n"; #print "\n Q is: \n" + str(Q) + "\n"; #print " p is: " + str(p) #print " min_val is: " + str( min_val) #print " block_size is: " + str(block_size) #print "\n Starting Step 3 \n" ## Step 3: Clear out the remaining entries ## --------------------------------------- min_scale = p ** min_val ## This is the minimal valuation of the Hessian matrix entries. ##DIAGNOSTIC #print "Starting Step 3:" #print "----------------" #print " min_scale is: " + str(min_scale) ## Perform cancellation over Z by ensuring divisibility if (block_size == 1): a = 2 * Q[0,0] for j in range(block_size, n): b = Q[0, j] g = GCD(a, b) ## DIAGNSOTIC #print "Cancelling from a 1x1 block:" #print "----------------------------" #print " Cancelling entry with index (" + str(upper_left) + ", " + str(j) + ")" #print " entry = " + str(b) #print " gcd = " + str(g) #print " a = " + str(a) #print " b = " + str(b) #print " a/g = " + str(a/g) + " (used for stretching)" #print " -b/g = " + str(-b/g) + " (used for cancelling)" ## Sanity Check: a/g is a p-unit if valuation (g, p) != valuation(a, p): raise RuntimeError, "Oops! We have a problem with our rescaling not preserving p-integrality!" Q.multiply_variable(ZZ(a/g), j, in_place = True) ## Ensures that the new b entry is divisible by a Q.add_symmetric(ZZ(-b/g), j, 0, in_place = True) ## Performs the cancellation elif (block_size == 2): a1 = 2 * Q[0,0] a2 = Q[0, 1] b1 = Q[1, 0] ## This is the same as a2 b2 = 2 * Q[1, 1] big_det = (a1*b2 - a2*b1) small_det = big_det / (min_scale * min_scale) ## Cancels out the rows/columns of the 2x2 block for j in range(block_size, n): a = Q[0, j] b = Q[1, j] ## Ensures an integral result (scale jth row/column by big_det) Q.multiply_variable(big_det, j, in_place = True) ## Performs the cancellation (by producing -big_det * jth row/column) Q.add_symmetric(ZZ(-(a*b2 - b*a2)), j, 0, in_place = True) Q.add_symmetric(ZZ(-(-a*b1 + b*a1)), j, 1, in_place = True) ## Now remove the extra factor (non p-unit factor) in big_det we introduced above Q.divide_variable(ZZ(min_scale * min_scale), j, in_place = True) ## DIAGNOSTIC #print "Cancelling out a 2x2 block:" #print "---------------------------" #print " a1 = " + str(a1) #print " a2 = " + str(a2) #print " b1 = " + str(b1) #print " b2 = " + str(b2) #print " big_det = " + str(big_det) #print " min_scale = " + str(min_scale) #print " small_det = " + str(small_det) #print " Q = \n", Q ## Uses Cassels's proof to replace the remaining 2 x 2 block if (((1 + small_det) % 8) == 0): Q[0, 0] = 0 Q[1, 1] = 0 Q[0, 1] = min_scale elif (((5 + small_det) % 8) == 0): Q[0, 0] = min_scale Q[1, 1] = min_scale Q[0, 1] = min_scale else: raise RuntimeError, "Error in LocalNormal: Impossible behavior for a 2x2 block! \n" ## Check that the cancellation worked, extract the upper-left block, and trim Q to handle the next block. for i in range(block_size): for j in range(block_size, n): if Q[i,j] != 0: raise RuntimeError, "Oops! The cancellation didn't work properly at entry (" + str(i) + ", " + str(j) + ")." Q_Jordan = Q_Jordan + Q.extract_variables(range(block_size)) Q = Q.extract_variables(range(block_size, n)) return Q_Jordan
def has_equivalent_Jordan_decomposition_at_prime(self, other, p): """ Determines if the given quadratic form has a Jordan decomposition equivalent to that of self. INPUT: a QuadraticForm OUTPUT: boolean EXAMPLES:: sage: Q1 = QuadraticForm(ZZ, 3, [1, 0, -1, 1, 0, 3]) sage: Q2 = QuadraticForm(ZZ, 3, [1, 0, 0, 2, -2, 6]) sage: Q3 = QuadraticForm(ZZ, 3, [1, 0, 0, 1, 0, 11]) sage: [Q1.level(), Q2.level(), Q3.level()] [44, 44, 44] sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q2,2) False sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q2,11) False sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q3,2) False sage: Q1.has_equivalent_Jordan_decomposition_at_prime(Q3,11) True sage: Q2.has_equivalent_Jordan_decomposition_at_prime(Q3,2) True sage: Q2.has_equivalent_Jordan_decomposition_at_prime(Q3,11) False """ ## Sanity Checks #if not isinstance(other, QuadraticForm): if not isinstance(other, type(self)): raise TypeError( "Oops! The first argument must be of type QuadraticForm.") if not is_prime(p): raise TypeError("Oops! The second argument must be a prime number.") ## Get the relevant local normal forms quickly self_jordan = self.jordan_blocks_by_scale_and_unimodular(p, safe_flag=False) other_jordan = other.jordan_blocks_by_scale_and_unimodular(p, safe_flag=False) ## DIAGNOSTIC #print "self_jordan = ", self_jordan #print "other_jordan = ", other_jordan ## Check for the same number of Jordan components if len(self_jordan) != len(other_jordan): return False ## Deal with odd primes: Check that the Jordan component scales, dimensions, and discriminants are the same if p != 2: for i in range(len(self_jordan)): if (self_jordan[i][0] != other_jordan[i][0]) \ or (self_jordan[i][1].dim() != other_jordan[i][1].dim()) \ or (legendre_symbol(self_jordan[i][1].det() * other_jordan[i][1].det(), p) != 1): return False ## All tests passed for an odd prime. return True ## For p = 2: Check that all Jordan Invariants are the same. elif p == 2: ## Useful definition t = len(self_jordan) ## Define t = Number of Jordan components ## Check that all Jordan Invariants are the same (scale, dim, and norm) for i in range(t): if (self_jordan[i][0] != other_jordan[i][0]) \ or (self_jordan[i][1].dim() != other_jordan[i][1].dim()) \ or (valuation(GCD(self_jordan[i][1].coefficients()), p) != valuation(GCD(other_jordan[i][1].coefficients()), p)): return False ## DIAGNOSTIC #print "Passed the Jordan invariant test." ## Use O'Meara's isometry test 93:29 on p277. ## ------------------------------------------ ## List of norms, scales, and dimensions for each i scale_list = [ZZ(2)**self_jordan[i][0] for i in range(t)] norm_list = [ ZZ(2)**(self_jordan[i][0] + valuation(GCD(self_jordan[i][1].coefficients()), 2)) for i in range(t) ] dim_list = [(self_jordan[i][1].dim()) for i in range(t)] ## List of Hessian determinants and Hasse invariants for each Jordan (sub)chain ## (Note: This is not the same as O'Meara's Gram determinants, but ratios are the same!) -- NOT SO GOOD... ## But it matters in condition (ii), so we multiply all by 2 (instead of dividing by 2 since only square-factors matter, and it's easier.) j = 0 self_chain_det_list = [ self_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j]) ] other_chain_det_list = [ other_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j]) ] self_hasse_chain_list = [ self_jordan[j][1].scale_by_factor( ZZ(2)**self_jordan[j][0]).hasse_invariant__OMeara(2) ] other_hasse_chain_list = [ other_jordan[j][1].scale_by_factor( ZZ(2)**other_jordan[j][0]).hasse_invariant__OMeara(2) ] for j in range(1, t): self_chain_det_list.append(self_chain_det_list[j - 1] * self_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j])) other_chain_det_list.append(other_chain_det_list[j - 1] * other_jordan[j][1].Gram_det() * (scale_list[j]**dim_list[j])) self_hasse_chain_list.append(self_hasse_chain_list[j-1] \ * hilbert_symbol(self_chain_det_list[j-1], self_jordan[j][1].Gram_det(), 2) \ * self_jordan[j][1].hasse_invariant__OMeara(2)) other_hasse_chain_list.append(other_hasse_chain_list[j-1] \ * hilbert_symbol(other_chain_det_list[j-1], other_jordan[j][1].Gram_det(), 2) \ * other_jordan[j][1].hasse_invariant__OMeara(2)) ## SANITY CHECK -- check that the scale powers are strictly increasing for i in range(1, len(scale_list)): if scale_list[i - 1] >= scale_list[i]: raise RuntimeError( "Oops! There is something wrong with the Jordan Decomposition -- the given scales are not strictly increasing!" ) ## DIAGNOSTIC #print "scale_list = ", scale_list #print "norm_list = ", norm_list #print "dim_list = ", dim_list #print #print "self_chain_det_list = ", self_chain_det_list #print "other_chain_det_list = ", other_chain_det_list #print "self_hasse_chain_list = ", self_hasse_chain_list #print "other_hasse_chain_det_list = ", other_hasse_chain_list ## Test O'Meara's two conditions for i in range(t - 1): ## Condition (i): Check that their (unit) ratio is a square (but it suffices to check at most mod 8). modulus = norm_list[i] * norm_list[i + 1] / (scale_list[i]**2) if modulus > 8: modulus = 8 if (modulus > 1) and (( (self_chain_det_list[i] / other_chain_det_list[i]) % modulus) != 1): #print "Failed when i =", i, " in condition 1." return False ## Check O'Meara's condition (ii) when appropriate if norm_list[i + 1] % (4 * norm_list[i]) == 0: if self_hasse_chain_list[i] * hilbert_symbol(norm_list[i] * other_chain_det_list[i], -self_chain_det_list[i], 2) \ != other_hasse_chain_list[i] * hilbert_symbol(norm_list[i], -other_chain_det_list[i], 2): ## Nipp conditions #print "Failed when i =", i, " in condition 2." return False ## All tests passed for the prime 2. return True else: raise TypeError("Oops! This should not have happened.")
def green_function(self, G,v, **kwds): r""" Evaluates the local Green's function at the place ``v`` for ``self`` with ``N`` terms of the series or, in dimension 1, to within the specified error bound. Defaults to ``N=10`` if no kwds provided Use ``v=0`` for the archimedean place. Must be over `\ZZ` or `\QQ`. ALGORITHM: See Exercise 5.29 and Figure 5.6 of ``The Arithmetic of Dynamics Systems``, Joseph H. Silverman, Springer, GTM 241, 2007. INPUT: - ``G`` - an endomorphism of self.codomain() - ``v`` - non-negative integer. a place, use v=0 for the archimedean place kwds: - ``N`` - positive integer. number of terms of the series to use - ``prec`` - positive integer, float point or p-adic precision, default: 100 - ``error_bound`` - a positive real number OUTPUT: - a real number Examples:: sage: P.<x,y>=ProjectiveSpace(QQ,1) sage: H=Hom(P,P) sage: f=H([x^2+y^2,x*y]); sage: Q=P(5,1) sage: f.green_function(Q,0,N=30) 1.6460930159932946233759277576 :: sage: P.<x,y>=ProjectiveSpace(QQ,1) sage: H=Hom(P,P) sage: f=H([x^2+y^2,x*y]); sage: Q=P(5,1) sage: Q.green_function(f,0,N=200,prec=200) 1.6460930160038721802875250367738355497198064992657997569827 .. TODO:: error bounds for dimension > 1 """ N = kwds.get('N', None) #Get number of iterates (if entered) err = kwds.get('error_bound', None) #Get error bound (if entered) prec = kwds.get('prec', 100) #Get precision (if entered) R=RealField(prec) if not (v == 0 or is_prime(v)): raise ValueError("Invalid valuation (=%s) entered."%v) if v == 0: K = R else: K = Qp(v, prec) #Coerce all polynomials in F into polynomials with coefficients in K F=G.change_ring(K,False) d = F.degree() D=F.codomain().ambient_space().dimension_relative() if err is not None: if D!=1: raise NotImplementedError("error bounds only for dimension 1") err = R(err) if not err>0: raise ValueError, "Error bound (=%s) must be positive."%err #if doing error estimates, compute needed number of iterates res = F.resultant() #compute maximum coefficient of polynomials of F C = R(G.global_height(prec)) if v == 0: log_fact = R(0) for i in range(2*d+1): log_fact += R(i+1).log() B = max((R(res.abs()) - R(2*d).log() - (2*d-1)*C - log_fact).log().abs(), (C + R(d+1).log()).abs()) else: B = max(R(res.abs()).log() - ((2*d-1)*C).abs(), C.abs()) N = R(B/(err*(d-1))).log(d).abs().ceil() elif N is None: N=10 #default is to do 10 iterations #Coerce the coordinates into Q_v self.normalize_coordinates() if self.codomain().base_ring()==QQ: self.clear_denominators() P=self.change_ring(K,False) #START GREEN FUNCTION CALCULATION g = R(0) for i in range(N+1): m = -1 #compute the maximum absolute value of entries of a, and where it occurs for n in range(D+1): a_v = R(P[n].abs()) if a_v > m: j = n m = a_v #add to Greens function g += (1/R(d))**(i)*R(m).log() #normalize coordinates and evaluate P.scale_by(1/P[j]) P = F(P,False) return g
def pthpowers(self, p, Bound): """ Find the indices of proveably all pth powers in the recurrence sequence bounded by Bound. Let `u_n` be a binary recurrence sequence. A ``p`` th power in `u_n` is a solution to `u_n = y^p` for some integer `y`. There are only finitely many ``p`` th powers in any recurrence sequence [SS]. INPUT: - ``p`` - a rational prime integer (the fixed p in `u_n = y^p`) - ``Bound`` - a natural number (the maximum index `n` in `u_n = y^p` that is checked). OUTPUT: - A list of the indices of all ``p`` th powers less bounded by ``Bound``. If the sequence is degenerate and there are many ``p`` th powers, raises ``ValueError``. EXAMPLES:: sage: R = BinaryRecurrenceSequence(1,1) #the Fibonacci sequence sage: R.pthpowers(2, 10**30) # long time (7 seconds) -- in fact these are all squares, c.f. [BMS06] [0, 1, 2, 12] sage: S = BinaryRecurrenceSequence(8,1) #a Lucas sequence sage: S.pthpowers(3,10**30) # long time (3 seconds) -- provably finds the indices of all 3rd powers less than 10^30 [0, 1, 2] sage: Q = BinaryRecurrenceSequence(3,3,2,1) sage: Q.pthpowers(11,10**30) # long time (7.5 seconds) [1] If the sequence is degenerate, and there are are no ``p`` th powers, returns `[]`. Otherwise, if there are many ``p`` th powers, raises ``ValueError``. :: sage: T = BinaryRecurrenceSequence(2,0,1,2) sage: T.is_degenerate() True sage: T.is_geometric() True sage: T.pthpowers(7,10**30) Traceback (most recent call last): ... ValueError: The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers. sage: L = BinaryRecurrenceSequence(4,0,2,2) sage: [L(i).factor() for i in xrange(10)] [2, 2, 2^3, 2^5, 2^7, 2^9, 2^11, 2^13, 2^15, 2^17] sage: L.is_quasigeometric() True sage: L.pthpowers(2,10**30) [] NOTE: This function is primarily optimized in the range where ``Bound`` is much larger than ``p``. """ #Thanks to Jesse Silliman for helpful conversations! #Reset the dictionary of good primes, as this depends on p self._PGoodness = {} #Starting lower bound on good primes self._ell = 1 #If the sequence is geometric, then the `n`th term is `a*r^n`. Thus the #property of being a ``p`` th power is periodic mod ``p``. So there are either #no ``p`` th powers if there are none in the first ``p`` terms, or many if there #is at least one in the first ``p`` terms. if self.is_geometric() or self.is_quasigeometric(): no_powers = True for i in xrange(1,6*p+1): if _is_p_power(self(i), p) : no_powers = False break if no_powers: if _is_p_power(self.u0,p): return [0] return [] else : raise ValueError, "The degenerate binary recurrence sequence is geometric or quasigeometric and has many pth powers." #If the sequence is degenerate without being geometric or quasigeometric, there #may be many ``p`` th powers or no ``p`` th powers. elif (self.b**2+4*self.c) == 0 : #This is the case if the matrix F is not diagonalizable, ie b^2 +4c = 0, and alpha/beta = 1. alpha = self.b/2 #In this case, u_n = u_0*alpha^n + (u_1 - u_0*alpha)*n*alpha^(n-1) = alpha^(n-1)*(u_0 +n*(u_1 - u_0*alpha)), #that is, it is a geometric term (alpha^(n-1)) times an arithmetic term (u_0 + n*(u_1-u_0*alpha)). #Look at classes n = k mod p, for k = 1,...,p. for k in xrange(1,p+1): #The linear equation alpha^(k-1)*u_0 + (k+pm)*(alpha^(k-1)*u1 - u0*alpha^k) #must thus be a pth power. This is a linear equation in m, namely, A + B*m, where A = (alpha**(k-1)*self.u0 + k*(alpha**(k-1)*self.u1 - self.u0*alpha**k)) B = p*(alpha**(k-1)*self.u1 - self.u0*alpha**k) #This linear equation represents a pth power iff A is a pth power mod B. if _is_p_power_mod(A, p, B): raise ValueError, "The degenerate binary recurrence sequence has many pth powers." return [] #We find ``p`` th powers using an elementary sieve. Term `u_n` is a ``p`` th #power if and only if it is a ``p`` th power modulo every prime `\\ell`. This condition #gives nontrivial information if ``p`` divides the order of the multiplicative group of #`\\Bold(F)_{\\ell}`, i.e. if `\\ell` is ` 1 \mod{p}`, as then only `1/p` terms are ``p`` th #powers modulo `\\ell``. #Thus, given such an `\\ell`, we get a set of necessary congruences for the index modulo the #the period of the sequence mod `\\ell`. Then we intersect these congruences for many primes #to get a tight list modulo a growing modulus. In order to keep this step manageable, we #only use primes `\\ell` that are have particularly smooth periods. #Some congruences in the list will remain as the modulus grows. If a congruence remains through #7 rounds of increasing the modulus, then we check if this corresponds to a perfect power (if #it does, we add it to our list of indices corresponding to ``p`` th powers). The rest of the congruences #are transient and grow with the modulus. Once the smallest of these is greater than the bound, #the list of known indices corresponding to ``p`` th powers is complete. else: if Bound < 3 * p : powers = [] ell = p + 1 while not is_prime(ell): ell = ell + p F = GF(ell) a0 = F(self.u0); a1 = F(self.u1) #a0 and a1 are variables for terms in sequence bf, cf = F(self.b), F(self.c) for n in xrange(Bound): # n is the index of the a0 #Check whether a0 is a perfect power mod ell if _is_p_power_mod(a0, p, ell) : #if a0 is a perfect power mod ell, check if nth term is ppower if _is_p_power(self(n), p): powers.append(n) a0, a1 = a1, bf*a1 + cf*a0 #step up the variables else : powers = [] #documents the indices of the sequence that provably correspond to pth powers cong = [0] #list of necessary congruences on the index for it to correspond to pth powers Possible_count = {} #keeps track of the number of rounds a congruence lasts in cong #These parameters are involved in how we choose primes to increase the modulus qqold = 1 #we believe that we know complete information coming from primes good by qqold M1 = 1 #we have congruences modulo M1, this may not be the tightest list M2 = p #we want to move to have congruences mod M2 qq = 1 #the largest prime power divisor of M1 is qq #This loop ups the modulus. while True: #Try to get good data mod M2 #patience of how long we should search for a "good prime" patience = 0.01 * _estimated_time(lcm(M2,p*next_prime_power(qq)), M1, len(cong), p) tries = 0 #This loop uses primes to get a small set of congruences mod M2. while True: #only proceed if took less than patience time to find the next good prime ell = _next_good_prime(p, self, qq, patience, qqold) if ell: #gather congruence data for the sequence mod ell, which will be mod period(ell) = modu cong1, modu = _find_cong1(p, self, ell) CongNew = [] #makes a new list from cong that is now mod M = lcm(M1, modu) instead of M1 M = lcm(M1, modu) for k in xrange(M/M1): for i in cong: CongNew.append(k*M1+i) cong = set(CongNew) M1 = M killed_something = False #keeps track of when cong1 can rule out a congruence in cong #CRT by hand to gain speed for i in list(cong): if not (i % modu in cong1): #congruence in cong is inconsistent with any in cong1 cong.remove(i) #remove that congruence killed_something = True if M1 == M2: if not killed_something: tries += 1 if tries == 2: #try twice to rule out congruences cong = list(cong) qqold = qq qq = next_prime_power(qq) M2 = lcm(M2,p*qq) break else : qq = next_prime_power(qq) M2 = lcm(M2,p*qq) cong = list(cong) break #Document how long each element of cong has been there for i in cong: if i in Possible_count: Possible_count[i] = Possible_count[i] + 1 else : Possible_count[i] = 1 #Check how long each element has persisted, if it is for at least 7 cycles, #then we check to see if it is actually a perfect power for i in Possible_count: if Possible_count[i] == 7: n = Integer(i) if n < Bound: if _is_p_power(self(n),p): powers.append(n) #check for a contradiction if len(cong) > len(powers): if cong[len(powers)] > Bound: break elif M1 > Bound: break return powers
def create_key_and_extra_args(self, order, name=None, modulus=None, names=None, impl=None, proof=None, **kwds): """ EXAMPLES:: sage: GF.create_key_and_extra_args(9, 'a') ((9, ('a',), x^2 + 2*x + 2, None, '{}', 3, 2, True), {}) sage: GF.create_key_and_extra_args(9, 'a', foo='value') ((9, ('a',), x^2 + 2*x + 2, None, "{'foo': 'value'}", 3, 2, True), {'foo': 'value'}) """ from sage.structure.proof.all import WithProof, arithmetic if proof is None: proof = arithmetic() with WithProof('arithmetic', proof): order = int(order) if order <= 1: raise ValueError("the order of a finite field must be > 1.") if arith.is_prime(order): name = None modulus = None p = integer.Integer(order) n = integer.Integer(1) elif arith.is_prime_power(order): if not names is None: name = names name = normalize_names(1,name) p, n = arith.factor(order)[0] # The following is a temporary solution that allows us # to construct compatible systems of finite fields # until algebraic closures of finite fields are # implemented in Sage. It requires the user to # specify two parameters: # # - `conway` -- boolean; if True, this field is # constructed to fit in a compatible system using # a Conway polynomial. # - `prefix` -- a string used to generate names for # automatically constructed finite fields # # See the docstring of FiniteFieldFactory for examples. # # Once algebraic closures of finite fields are # implemented, this syntax should be superseded by # something like the following: # # sage: Fpbar = GF(5).algebraic_closure('z') # sage: F, e = Fpbar.subfield(3) # e is the embedding into Fpbar # sage: F # Finite field in z3 of size 5^3 # # This temporary solution only uses actual Conway # polynomials (no pseudo-Conway polynomials), since # pseudo-Conway polynomials are not unique, and until # we have algebraic closures of finite fields, there # is no good place to store a specific choice of # pseudo-Conway polynomials. if name is None: if not (kwds.has_key('conway') and kwds['conway']): raise ValueError("parameter 'conway' is required if no name given") if not kwds.has_key('prefix'): raise ValueError("parameter 'prefix' is required if no name given") name = kwds['prefix'] + str(n) if kwds.has_key('conway') and kwds['conway']: from conway_polynomials import conway_polynomial if not kwds.has_key('prefix'): raise ValueError("a prefix must be specified if conway=True") if modulus is not None: raise ValueError("no modulus may be specified if conway=True") # The following raises a RuntimeError if no polynomial is found. modulus = conway_polynomial(p, n) if modulus is None or isinstance(modulus, str): # A string specifies an algorithm to find a suitable modulus. if modulus == "default": # for backward compatibility modulus = None modulus = GF(p)['x'].irreducible_element(n, algorithm=modulus) elif isinstance(modulus, (list, tuple)): modulus = GF(p)['x'](modulus) elif sage.rings.polynomial.polynomial_element.is_Polynomial(modulus): modulus = modulus.change_variable_name('x') else: raise TypeError("wrong type for modulus parameter") else: raise ValueError("the order of a finite field must be a prime power.") return (order, name, modulus, impl, str(kwds), p, n, proof), kwds