pyadic.padic

class pyadic.padic.PAdic(num, p=None, k=None, n=0, from_addition=False)

PAdic numbers, with p prime, k digits, n valuation.

property as_dict: Dict reprensentation: {valuation: mantissa digit}.

property as_tuple: Tuple reprensentation of the mantissa.

property as_tuple_from_zero: Tuple representation of the mantissa, shifted to start from p^0 term.

property k

property num: 0 ≤ num ≤ p ^ k - 1

property p: p: prime for the padic.

pyadic.padic.cached_function(func)

pyadic.padic.check_orderable(func)

pyadic.padic.full_range_random_padic_filling(p, k): Returns a random number which translates in a PAdic without any zero digit.

pyadic.padic.padic_log(w, base=None): If the valuation is 0, then bring in radius of convergence using Fermat’s little theorem (w ** (p - 1) = 1 mod p), i.e. log_p(w) = log_p(w^(p - 1)) / (p - 1), with w^(p - 1) = 1 + x, x ~ O(p). Otherwise, factor out p ^ valuation, use that log(a * b) = log(a) + log(b) and that log_p(p ^ valuation) = valuation What about branch? See sage docs.

pyadic.padic.padic_sqrt(x): Working precision padic sqrt.

pyadic.padic.padicfy(func)

pyadic.padic.refine_sqrt_precision(x, s): Given (s | s^2 - x << 1), makes s^2 closer to x.

pyadic.padic.to_base(num, p)

pyadic.finite_field

pyadic.finite_field.LGRR(a, n): Lattice Gaussian Rational Reconstruction

pyadic.finite_field.LGreduction(u, v): Lattice Gaussian Reduction - 2D version of LLL (Lenstra–Lenstra–Lovász)

pyadic.finite_field.MQRR(u, m, T=None): Maximal Quotient Rational Reconstruction (M. B. Monagan)

class pyadic.finite_field.ModP(n, p=None)

Finite field with p elements ($mathbb{FF}_p$), i.e. integers modulo p, with p prime.

n

p

root(n)

roots(n)

sqrt()

pyadic.finite_field.ModPfy(func)

pyadic.finite_field.chained_chinese_remainder(*vals, primes=None): Vectorized (concatenated) version of chinese remainder function.

pyadic.finite_field.chinese_remainder(a1, a2): Given a1 = a % n1 and a2 = a % n2 and assuming gcd(n1,n2)=1 (i.e. n1, n2 co-prime), returns a12 = a % (n1*n2)

pyadic.finite_field.extended_euclidean_algorithm(a, b): Returns Bezout coefficients (s,t) and gcd(a,b) such that: as+bt=gcd(a,b). - Pseudocode from https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm

pyadic.finite_field.finite_field_root(x, n)

pyadic.finite_field.finite_field_roots(x, n): Returns either False or the first digit of the roots in the field.

pyadic.finite_field.finite_field_sqrt(x)

pyadic.finite_field.gcd(a, b)

pyadic.finite_field.isinteger(x)

pyadic.finite_field.rationalise(a, n=None, algorithm=<function MQRR>): Given (a, n) returns a fraction r / s such that r/s % n = a, by lattice reduction. r = sa + mn <-> r/s % n = a

pyadic.finite_field.univariate_finite_field_solver(equation, root_dict, prime): Returns all possible solutions of ‘equation’ over a finite field of cardinality ‘prime’. If already satisfied returns True, if no solution exists returns False.

pyadic.finite_field.update_root_dict(symbol, solutions, root_dict): Given solutions and root_dict returns updated root_dicts.

pyadic.finite_field.vec_ModP(prime, optimize_for_sparse_arrays=True): Vectorized version of ModP.

pyadic.finite_field.vec_chained_FF_rationalize(tensors, primes, factor=1, algorithm=<function LGRR>, optimize_for_sparse_arrays=True): Given list of tensors respectively mod primes, returns the rationalized tensor. Keyword argument factor is pre-multiplied and then devided w.r.t. reconstruction, can be used to aid reconstruction or verify its stability.

Module contents