def p_adic_l_invariant_additive(logA,logB, alpha, beta, Tmatrix):
K = logA.parent()
logA, logB = K(logA), K(logB)
x,y,z,t = Tmatrix.change_ring(K).list()
M = Matrix(K,2,2,[alpha,x*alpha+z*beta,beta, y*alpha+t*beta])
n = Matrix(K,2,1,[logA, logB])
return M.solve_right(n).list()
def matrix_rep(self,B=None):
r"""
Returns a matrix representation of ``self``.
"""
#Express the element in terms of the basis B
if B is None:
B = self._parent.basis()
A=Matrix(self._parent._R,self._parent.dimension(),self._parent.dimension(),[[b._val[ii,0] for b in B] for ii in range(self._depth)])
tmp=A.solve_right(self._val)
return tmp
def matrix_rep(self,B=None):
r"""
Returns a matrix representation of ``self``.
"""
#Express the element in terms of the basis B
if B is None:
B = self._parent.basis()
A = Matrix(self._parent._R,self._parent.dimension(),self._parent.dimension(),[[b._moments[ii,0] for b in B] for ii in range(self._dimension)])
tmp = A.solve_right(self._moments)
return tmp
class _FiniteBasisConverter:
def __init__(self, P, comb_mod, basis):
r"""
Basis should be a finite set of polynomials
"""
self._poly_ring = P
self._module = comb_mod
self._basis = basis
max_deg = max([self._poly_ring(b).degree() for b in self._basis])
monoms = []
for b in self._basis:
poly = self._poly_ring(b)
monoms += poly.monomials()
monoms_list = tuple(Set(monoms))
# check if the basis represented in terms of Monomials is efficient
degs = [self._poly_ring(m).degree() for m in monoms]
min_deg, max_deg = min(degs), max(degs)
monoms_obj = Monomials(self._poly_ring, (min_deg, max_deg + 1))
if monoms_obj.cardinality() < 2 * len(monoms_list):
computational_basis = monoms_obj
else:
computational_basis = monoms_list
self._monomial_module = PolynomialFreeModule(
P=self._poly_ring, basis=computational_basis)
cols = [self._monomial_module(b).to_vector() for b in self._basis]
self._basis_mat = Matrix(cols).transpose()
if self._basis_mat.ncols() > self._basis_mat.rank():
raise ValueError(
"Basis polynomials are not linearly independent")
def convert(self, p):
r"""
Algorithm is to convert all polynomials into monomials and use
linear algebra to solve for the appropriate coefficients in this
common basis.
"""
try:
p_vect = self._monomial_module(p).to_vector()
decomp = self._basis_mat.solve_right(p_vect)
except ValueError:
raise ValueError(
"Value %s is not spanned by the basis polynomials" % p)
polys = [v[1] * self._module.monomial(v[0])
for v in zip(self._basis, decomp)]
module_p = sum(polys, self._module.zero())
return module_p
def matrix_rep(self,B=None):
r"""
EXAMPLES:
This example illustrates ...
::
"""
#Express the element in terms of the basis B
if(B is None):
B=self._parent.basis()
A=Matrix(self._parent._R,self._parent.dimension(),self._parent.dimension(),[[b._val[ii,0] for b in B] for ii in range(self._depth)])
tmp=A.solve_right(self._val)
return tmp
def matrix_rep(self, B=None):
r"""
EXAMPLES:
This example illustrates ...
::
"""
#Express the element in terms of the basis B
if (B is None):
B = self._parent.basis()
A = Matrix(self._parent._R, self._parent.dimension(),
self._parent.dimension(),
[[b._val[ii, 0] for b in B] for ii in range(self._depth)])
tmp = A.solve_right(self._val)
return tmp
def linear_relation(self, List, Psi, verbose=True, prec=None):
for Phi in List:
assert Phi.valuation() >= 0, "Symbols must be integral"
assert Psi.valuation() >= 0
R = self.base()
Rbase = R.base()
w = R.gen()
d = len(List)
if d == 0:
if Psi.is_zero():
return [None, R(1)]
else:
return [None, 0]
if prec is None:
M, var_prec = Psi.precision_absolute()
else:
M, var_prec = prec
p = self.prime()
V = R**d
RSR = LaurentSeriesRing(Rbase, R.variable_name())
VSR = RSR**self.source().ngens()
List_TMs = [VSR(Phi.list_of_total_measures()) for Phi in List]
Psi_TMs = VSR(Psi.list_of_total_measures())
A = Matrix(RSR, List_TMs).transpose()
try:
sol = V([vv.power_series() for vv in A.solve_right(Psi_TMs)])
except ValueError:
#try "least squares"
if verbose:
print "Trying least squares."
sol = (A.transpose() * A).solve_right(A.transpose() * Psi_TMs)
#check precision (could make this better, checking each power of w)
p_prec = M
diff = Psi_TMs - sum([sol[i] * List_TMs[i] for i in range(len(List_TMs))])
for i in diff:
for j in i.list():
if p_prec > j.valuation():
p_prec = j.valuation()
if verbose:
print "p-adic precision is now", p_prec
#Is this right?
sol = V([R([j.add_bigoh(p_prec) for j in i.list()]) for i in sol])
return [sol, R(-1)]
def solve_coefficient_system(Q, equations, vars):
# NOTE: to make things easier (and uniform) in the univariate case a dummy
# variable is added to the polynomial ring. See compute_bd()
a = Q.gens()[:-1]
B = Q.base_ring()
# construct the coefficient system and right-hand side
system = [[e.coefficient({ai:1}) for ai in a] for e in equations]
rhs = [-e.constant_coefficient() for e in equations]
system = Matrix(B, system)
rhs = Matrix(B, rhs).transpose()
# we only allow unique solutions. return None if there are infinitely many
# solutions or if no solution exists. Sage will raise a ValueError in both
# circumstances
try:
sol = system.solve_right(rhs)
except ValueError:
return None
return sol
def solve_coefficient_system(Q, equations, vars):
# NOTE: to make things easier (and uniform) in the univariate case a dummy
# variable is added to the polynomial ring. See compute_bd()
a = Q.gens()[:-1]
B = Q.base_ring()
# construct the coefficient system and right-hand side
system = [[e.coefficient({ai: 1}) for ai in a] for e in equations]
rhs = [-e.constant_coefficient() for e in equations]
system = Matrix(B, system)
rhs = Matrix(B, rhs).transpose()
# we only allow unique solutions. return None if there are infinitely many
# solutions or if no solution exists. Sage will raise a ValueError in both
# circumstances
try:
sol = system.solve_right(rhs)
except ValueError:
return None
return sol
