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)