def get_Ptolemy_relations(t, N, cohomology_class = None):
if cohomology_class:
cohomology_coefficients = (
cohomology_2_rel_boundary_class_to_coeffs(t, cohomology_class))
eqns = []
for tet in t.tet_list:
i = tet.index
if cohomology_class:
signs = cohomology_coefficients[tet.index]
sign_01 = Z2_to_sign(signs[2] + signs[3])
sign_12 = Z2_to_sign(signs[0] + signs[3])
else:
sign_01 = +1
sign_12 = +1
sign_01 = Polynomial.constantPolynomial(sign_01)
sign_12 = Polynomial.constantPolynomial(sign_12)
for coord in simplex_coords_with_fixed_sum(4, N-2):
eqns.append(
- sign_01 * c_parameter(coord+(1,0,0,1),i)
* c_parameter(coord+(0,1,1,0),i)
- sign_12 * c_parameter(coord+(1,1,0,0),i)
* c_parameter(coord+(0,0,1,1),i)
+ c_parameter(coord+(1,0,1,0),i)
* c_parameter(coord+(0,1,0,1),i))
return eqns
def polynomialNonZeroCondition(eqns, var, andNonOne = False):
variables = get_all_variables(eqns)
prod = Polynomial.fromVariableName(var)
for i in variables:
prod = prod * Polynomial.fromVariableName(i)
if andNonOne:
prod = prod * (Polynomial.constantPolynomial(1) -
Polynomial.fromVariableName(i))
return prod - Polynomial.constantPolynomial(1)
def _setValueInPolynomials(polys, variable, value, nf = None):
res = [
poly.substitute(
{variable:Polynomial.constantPolynomial(value)})
for poly in polys]
if nf:
res = [poly.convertCoefficients(lambda x: x % nf) for poly in res]
return res
def computeNumeric(
p,
substituteDict = {'x' :
Polynomial.constantPolynomial(
nfSolution)}):
c = p.substitute(substituteDict)
assert c.isConstant()
return c.getConstant()
def _solveExactlyOverNumberField(univariatePoly, nf, timeout):
variable = univariatePoly.variables()[0]
def convertXtoY(p):
return p.substitute({'x' : Polynomial.fromVariableName('y')})
univariatePoly = univariatePoly.convertCoefficients(convertXtoY)
univariatePoly = univariatePoly.substitute(
{ variable : Polynomial.constantPolynomial(
Polynomial.fromVariableName('x'))})
if not nf:
assert univariatePoly.isConstant()
newSolution = Polynomial.fromVariableName('x')
newNf = univariatePoly.getConstant()
newExpressionForX = Polynomial.constantPolynomial(0)
else:
nf = convertXtoY(nf)
pariStr = "PRIAVTEsEONF = rnfequation(nfinit(%s), %s, 1)" % (
nf, univariatePoly)
print pariStr
print timeout
r = pari.pari_eval(pariStr, timeout = timeout)
# print r
newNf = Polynomial.parseFromMagma(pari.pari_eval(
"PRIAVTEsEONF[1]", timeout = timeout))
newExpressionForX = Polynomial.parseFromMagma(pari.pari_eval(
"PRIAVTEsEONF[2].pol", timeout = timeout))
factor = int(pari.pari_eval(
"PRIAVTEsEONF[3]", timeout = timeout))
newSolution = (
Polynomial.fromVariableName('x')
- Polynomial.constantPolynomial(factor) * newExpressionForX)
return newSolution, newNf, newExpressionForX
def get_additional_eqns_independent(t, N):
# make sure cusps have indices
# dictionary associating the decoration change vectors to Ptolemy coordinates
d = {}
for i, tet in zip(range(len(t.tet_list)), t.tet_list):
for coord in simplex_coords_with_fixed_sum(4, N):
if not N in coord:
v = [0 for x in range((N-1) * t.num_or_cusps)]
for j, k in zip(range(4), coord):
for p in range(k):
v[ tet.cusp_index[j] + p * t.num_or_cusps ] += 1
d[c_parameter_var(coord, i)] = v
variables = find_independent_integer_vectors(d)
return [
Polynomial.fromVariableName(var) - Polynomial.constantPolynomial(1)
for var in variables]
def conversionFunction(c):
return Polynomial.constantPolynomial(c)
def solvePolynomialEquations(polys,
polynomialSolver,
free_dim = 0,
with_poly_history = False,
poly_history="",
variable_dict = { },
non_linear_equation_encountered=False):
# polys = [polynomial.convertCoefficients(number) for polynomial in polys]
if globalsettings.getSetting("solvePolynomialEquationsLog"):
poly_history += '\n\n\n\n'+'\n'.join(map(_printPoly,polys))+'\n\n============\n'
if not polys:
assert free_dim == 0
if with_poly_history:
return [(variable_dict,poly_history)]
else:
return [variable_dict]
solutions=[]
for i in polys:
assert isinstance(i,Polynomial)
univariate_polys = [ poly for poly in polys if poly.isUnivariate() ]
if globalsettings.getSetting("solvePolynomialEquationsLog"):
poly_history=poly_history+'\n\n'+str(map(_printPoly,univariate_polys))+'\n'
if univariate_polys:
univariate_poly = univariate_polys[0]
# print univariate_poly
variable_name = univariate_poly.variables()[0]
if globalsettings.getSetting("solvePolynomialEquationsLog"):
poly_history = poly_history + '\n\nSolving for %s\n' % variable_name
try:
sol = polynomialSolver(univariate_poly)
if globalsettings.getSetting("solvePolynomialEquationsLog"):
poly_history = poly_history+'\n'+str(sol)+'\n'
except Exception as e:
raise SolverException("Error in find_complex_roots when solving: " +
str(univariate_poly) + " " + repr(e),
poly_history)
assert len(sol)==univariate_poly.degree()
#if not len(sol)==1:
# if non_linear_equation_encountered:
# raise SolverException(
# "Encountered second non linear equation: " +
# str(univariate_poly),
# poly_history)
#
# non_linear_equation_encountered = True
else:
if free_dim == 0:
raise SolverException("No univariate polynomial left",
poly_history)
else:
univariate_poly = None
variable_name = polys[-1].variables()[0]
sol = [random_complex_modulos()]
if globalsettings.getSetting("solvePolynomialEquationsLog"):
poly_history += "In pick random solution for %s:\n %s\n\n" % (variable_name, sol)
free_dim = free_dim - 1
for value in sol:
new_variable_dict = dict(variable_dict)
new_variable_dict[variable_name] = value
new_polys = [
poly.substitute(
{ variable_name : Polynomial.constantPolynomial(value) })
for poly in polys if not poly is univariate_poly]
new_solutions = solvePolynomialEquations(
new_polys,
polynomialSolver = polynomialSolver,
free_dim = free_dim,
with_poly_history = with_poly_history,
poly_history = poly_history,
variable_dict = new_variable_dict)
solutions = solutions + new_solutions
return solutions
def _inverseOfConstantPolynomial(p):
assert p.isConstant()
constant = p.getConstant()
invConstant = Fraction(1,1) / constant
return Polynomial.constantPolynomial(invConstant)
