def list_factored_to_factored_poly_otherorder(sfacts_fc_list, galois=False, vari='T', p=None): """ Either return the polynomial in a nice factored form, or return a pair, with first entry the factored polynomial and the second entry a list describing the Galois groups of the factors. vari allows to choose the variable of the polynomial to be returned. """ gal_list = [] order = TermOrder('M(0,-1,0,-1)') ZZpT = PolynomialRing(ZZ, ['p', vari], order=order) ZZT = PolynomialRing(ZZ, vari) outstr = '' for g, e in sfacts_fc_list: if galois: # hack because currently sage only handles monic polynomials: this_poly = ZZT(list(reversed(g))) this_degree = this_poly.degree() this_number_field = NumberField(this_poly, "a") this_gal = this_number_field.galois_group(type='pari') this_t_number = this_gal.group().__pari__()[2].sage() gal_list.append([this_degree, this_t_number]) # casting from ZZT -> ZZpT if p is None: gtoprint = {(0, i): gi for i, gi in enumerate(g)} else: gtoprint = {} for i, elt in enumerate(g): if elt != 0: val = ZZ(elt).valuation(p) gtoprint[(val, i)] = elt / p**val glatex = latex(ZZpT(gtoprint)) if e > 1: if len(glatex) != 1: outstr += '( %s )^{%d}' % (glatex, e) else: outstr += '%s^{%d}' % (glatex, e) elif len(sfacts_fc_list) > 1: outstr += '( %s )' % (glatex, ) else: outstr += glatex if galois: # 2 factors of degree 2 if len(sfacts_fc_list) == 2: if len(sfacts_fc_list[0][0]) == 3 and len( sfacts_fc_list[1][0]) == 3: troubletest = ZZT(sfacts_fc_list[0][0]).disc() * ZZT( sfacts_fc_list[1][0]).disc() if troubletest.is_square(): gal_list = [[2, 1]] return outstr, gal_list return outstr
def get_order(A): """ Build an order > with Complement(A) > A The set A is represented as a dictionary. e.g. {x2, x3} as {"x1": 0, "x2": 1, "x3": 1} Entries with 1 represents the elements Returns BooleanPolynomialRing equiped with an order > as above and a list components_in_order starting with the largest variables/components. """ ones = [key for key in A if A[key] == 1] zeros = [key for key in A if A[key] == 0] components_in_order = zeros+ones R = BooleanPolynomialRing(names=components_in_order, order=TermOrder('lex')) # ToDo: Use R.clone() return R, components_in_order
def raw_typeset_poly(coeffs, denominator=1, var='x', superscript=True, compress_threshold=100, decreasing=True, final_rawvar=None, **kwargs): """ Generate a raw_typeset string a given integral polynomial, or a linear combination (using subscripts instead of exponents). In either case, the constant term is printed without a variable. It compresses the typeset latex if raw string is too long. INPUT: - ``coeffs`` -- a list of integers - ``denominator`` -- a integer - ``var`` -- a variable name, we count on sage to properly convert it to latex - ``superscript`` -- whether to use superscripts (as opposed to subscripts) - ``compress_threshold`` -- the number of characters by which we would need to reduce the output of the typeset""" if denominator == 1: denominatorraw = denominatortset = "" else: denominatortset = denominatorraw = f"/ {denominator}" R = PolynomialRing(ZZ, var) tset_var = latex(R.gen()) raw_var = var poly = R(coeffs) if poly == 0: return r"\(0\)" raw = str(poly) # figure out if we will compress the polynomial compress_poly = len(raw) + len(denominatorraw) > compress_threshold if compress_poly: denominatortset = f"/ {compress_int(denominator)[0]}" if compress_poly: tset = compress_polynomial(poly, compress_threshold - len(denominatortset), decreasing) else: if decreasing: tset = latex(poly) else: # to lazy to reverse it by hand Rfake = PolynomialRing(ZZ, [f'{raw_var}fake', raw_var], order=TermOrder('M(0,-1,0,-1)')) polytoprint = Rfake({(0, i): c for i, c in enumerate(poly)}) tset = latex(polytoprint) if not superscript: raw = raw.replace('^', '').replace(raw_var + " ", raw_var + "1 ") tset = tset.replace('^', '_').replace(tset_var + " ", tset_var + "_1 ") # in case the last replace doesn't trigger because is at the end if raw.endswith(raw_var): raw += "1" if tset.endswith(tset_var): tset += "_1" if denominator != 1: tset = f"( {tset} ) {denominatortset}" raw = f"({raw}) {denominatorraw}" if final_rawvar: raw = raw.replace(var, final_rawvar) return raw_typeset(raw, rf'\( {tset} \)', compressed=r'\cdots' in tset, **kwargs)
class FreeAlgebraFactory(UniqueFactory): """ A constructor of free algebras. See :mod:`~sage.algebras.free_algebra` for examples and corner cases. EXAMPLES:: sage: FreeAlgebra(GF(5),3,'x') Free Algebra on 3 generators (x0, x1, x2) over Finite Field of size 5 sage: F.<x,y,z> = FreeAlgebra(GF(5),3) sage: (x+y+z)^2 x^2 + x*y + x*z + y*x + y^2 + y*z + z*x + z*y + z^2 sage: FreeAlgebra(GF(5),3, 'xx, zba, Y') Free Algebra on 3 generators (xx, zba, Y) over Finite Field of size 5 sage: FreeAlgebra(GF(5),3, 'abc') Free Algebra on 3 generators (a, b, c) over Finite Field of size 5 sage: FreeAlgebra(GF(5),1, 'z') Free Algebra on 1 generators (z,) over Finite Field of size 5 sage: FreeAlgebra(GF(5),1, ['alpha']) Free Algebra on 1 generators (alpha,) over Finite Field of size 5 sage: FreeAlgebra(FreeAlgebra(ZZ,1,'a'), 2, 'x') Free Algebra on 2 generators (x0, x1) over Free Algebra on 1 generators (a,) over Integer Ring Free algebras are globally unique:: sage: F = FreeAlgebra(ZZ,3,'x,y,z') sage: G = FreeAlgebra(ZZ,3,'x,y,z') sage: F is G True sage: F.<x,y,z> = FreeAlgebra(GF(5),3) # indirect doctest sage: F is loads(dumps(F)) True sage: F is FreeAlgebra(GF(5),['x','y','z']) True sage: copy(F) is F is loads(dumps(F)) True sage: TestSuite(F).run() By :trac:`7797`, we provide a different implementation of free algebras, based on Singular's "letterplace rings". Our letterplace wrapper allows for chosing positive integral degree weights for the generators of the free algebra. However, only (weighted) homogenous elements are supported. Of course, isomorphic algebras in different implementations are not identical:: sage: G = FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace') sage: F == G False sage: G is FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace') True sage: copy(G) is G is loads(dumps(G)) True sage: TestSuite(G).run() :: sage: H = FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace', degrees=[1,2,3]) sage: F != H != G True sage: H is FreeAlgebra(GF(5),['x','y','z'], implementation='letterplace', degrees=[1,2,3]) True sage: copy(H) is H is loads(dumps(H)) True sage: TestSuite(H).run() Free algebras commute with their base ring. :: sage: K.<a,b> = FreeAlgebra(QQ,2) sage: K.is_commutative() False sage: L.<c> = FreeAlgebra(K,1) sage: L.is_commutative() False sage: s = a*b^2 * c^3; s a*b^2*c^3 sage: parent(s) Free Algebra on 1 generators (c,) over Free Algebra on 2 generators (a, b) over Rational Field sage: c^3 * a * b^2 a*b^2*c^3 """ def create_key(self, base_ring, arg1=None, arg2=None, sparse=False, order='degrevlex', names=None, name=None, implementation=None, degrees=None): """ Create the key under which a free algebra is stored. TESTS:: sage: FreeAlgebra.create_key(GF(5),['x','y','z']) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),3,'xyz') (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'], implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3, implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace', degrees=[1,2,3]) ((1, 2, 3), Multivariate Polynomial Ring in x, y, z, x_ over Finite Field of size 5) """ if arg1 is None and arg2 is None and names is None: # this is used for pickling if degrees is None: return (base_ring, ) return tuple(degrees), base_ring PolRing = None # test if we can use libSingular/letterplace if implementation is not None and implementation != 'generic': try: PolRing = PolynomialRing( base_ring, arg1, arg2, sparse=sparse, order=order, names=names, name=name, implementation=implementation if implementation != 'letterplace' else None) if not isinstance(PolRing, MPolynomialRing_libsingular): if PolRing.ngens() == 1: PolRing = PolynomialRing(base_ring, 1, PolRing.variable_names()) if not isinstance(PolRing, MPolynomialRing_libsingular): raise TypeError else: raise TypeError except (TypeError, NotImplementedError), msg: raise NotImplementedError, "The letterplace implementation is not available for the free algebra you requested" if PolRing is not None: if degrees is None: return (PolRing, ) from sage.all import TermOrder T = PolRing.term_order() + TermOrder('lex', 1) varnames = list(PolRing.variable_names()) newname = 'x' while newname in varnames: newname += '_' varnames.append(newname) return tuple(degrees), PolynomialRing( PolRing.base(), varnames, sparse=sparse, order=T, implementation=implementation if implementation != 'letterplace' else None) # normalise the generator names from sage.all import Integer if isinstance(arg1, (int, long, Integer)): arg1, arg2 = arg2, arg1 if not names is None: arg1 = names elif not name is None: arg1 = name if arg2 is None: arg2 = len(arg1) names = sage.structure.parent_gens.normalize_names(arg2, arg1) return base_ring, names
def create_key(self, base_ring, arg1=None, arg2=None, sparse=None, order='degrevlex', names=None, name=None, implementation=None, degrees=None): """ Create the key under which a free algebra is stored. TESTS:: sage: FreeAlgebra.create_key(GF(5),['x','y','z']) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),3,'xyz') (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'], implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3, implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace', degrees=[1,2,3]) ((1, 2, 3), Multivariate Polynomial Ring in x, y, z, x_ over Finite Field of size 5) """ if arg1 is None and arg2 is None and names is None: # this is used for pickling if degrees is None: return (base_ring, ) return tuple(degrees), base_ring # test if we can use libSingular/letterplace if implementation == "letterplace": args = [arg for arg in (arg1, arg2) if arg is not None] kwds = dict(sparse=sparse, order=order, implementation="singular") if name is not None: kwds["name"] = name if names is not None: kwds["names"] = names PolRing = PolynomialRing(base_ring, *args, **kwds) if degrees is None: return (PolRing, ) from sage.all import TermOrder T = PolRing.term_order() + TermOrder('lex', 1) varnames = list(PolRing.variable_names()) newname = 'x' while newname in varnames: newname += '_' varnames.append(newname) R = PolynomialRing(PolRing.base(), varnames, sparse=sparse, order=T) return tuple(degrees), R # normalise the generator names from sage.all import Integer if isinstance(arg1, (Integer, int)): arg1, arg2 = arg2, arg1 if not names is None: arg1 = names elif not name is None: arg1 = name if arg2 is None: arg2 = len(arg1) names = normalize_names(arg2, arg1) return base_ring, names
def create_key(self,base_ring, arg1=None, arg2=None, sparse=False, order='degrevlex', names=None, name=None, implementation=None, degrees=None): """ Create the key under which a free algebra is stored. TESTS:: sage: FreeAlgebra.create_key(GF(5),['x','y','z']) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3) (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),3,'xyz') (Finite Field of size 5, ('x', 'y', 'z')) sage: FreeAlgebra.create_key(GF(5),['x','y','z'], implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),['x','y','z'],3, implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace') (Multivariate Polynomial Ring in x, y, z over Finite Field of size 5,) sage: FreeAlgebra.create_key(GF(5),3,'xyz', implementation='letterplace', degrees=[1,2,3]) ((1, 2, 3), Multivariate Polynomial Ring in x, y, z, x_ over Finite Field of size 5) """ if arg1 is None and arg2 is None and names is None: # this is used for pickling if degrees is None: return (base_ring,) return tuple(degrees),base_ring PolRing = None # test if we can use libSingular/letterplace if implementation is not None and implementation != 'generic': try: PolRing = PolynomialRing(base_ring, arg1, arg2, sparse=sparse, order=order, names=names, name=name, implementation=implementation if implementation != 'letterplace' else None) if not isinstance(PolRing, MPolynomialRing_libsingular): if PolRing.ngens() == 1: PolRing = PolynomialRing(base_ring, 1, PolRing.variable_names()) if not isinstance(PolRing, MPolynomialRing_libsingular): raise TypeError else: raise TypeError except (TypeError, NotImplementedError) as msg: raise NotImplementedError("The letterplace implementation is not available for the free algebra you requested") if PolRing is not None: if degrees is None: return (PolRing,) from sage.all import TermOrder T = PolRing.term_order() + TermOrder('lex',1) varnames = list(PolRing.variable_names()) newname = 'x' while newname in varnames: newname += '_' varnames.append(newname) return tuple(degrees),PolynomialRing(PolRing.base(), varnames, sparse=sparse, order=T, implementation=implementation if implementation != 'letterplace' else None) # normalise the generator names from sage.all import Integer if isinstance(arg1, (int, long, Integer)): arg1, arg2 = arg2, arg1 if not names is None: arg1 = names elif not name is None: arg1 = name if arg2 is None: arg2 = len(arg1) names = sage.structure.parent_gens.normalize_names(arg2, arg1) return base_ring, names
# -*- coding: utf-8; mode: sage -*- from os.path import join from pickle import Pickler from itertools import takewhile from sage.libs.singular.function import singular_function from sage.all import (FreeModule, PolynomialRing, TermOrder, cached_method, gcd, load, QQ, cached_function, ZZ, QuadraticField, PowerSeriesRing, O, is_even) Monomial_Wts = (6, 4, 2) R = PolynomialRing(QQ, names="s6, s4, s2", order=TermOrder('wdegrevlex', Monomial_Wts)) s6, s4, s2 = R.gens() DATA_DIR = "/home/sho/work/rust/hilbert_qexp/hilbert_sqrt2/data" def degree(p): p = R(p) return int(p.weighted_degree(Monomial_Wts)) @cached_function def load_wts_brs(i, parity): brs = load(join(DATA_DIR, "str%s_%s_brs.sobj" % (i, parity))) wts = load(join(DATA_DIR, "str%s_%s_weights.sobj" % (i, parity))) return FormsData(wts, [to_pol_over_q(p) for p in brs])
# -*- coding: utf-8; mode: sage -*- from itertools import takewhile from pickle import Pickler from os.path import join from sage.all import (ZZ, FreeModule, PolynomialRing, QuadraticField, TermOrder, cached_method, flatten, gcd, load, QQ, cached_function, PowerSeriesRing, O) from sage.libs.singular.function import singular_function K = QuadraticField(5) Monomial_Wts = (6, 5, 2) R = PolynomialRing(K, names='g6, g5, g2', order=TermOrder('wdegrevlex', Monomial_Wts)) g6, g5, g2 = R.gens() DATA_DIR = "/home/sho/work/rust/hilbert_sqrt5/data/brackets" smodule = singular_function("module") sideal = singular_function("ideal") squotient = singular_function("quotient") smres = singular_function("mres") slist = singular_function("list") sintersect = singular_function("intersect") ssyz = singular_function("syz") def diag_res(f): R_el = PolynomialRing(QQ, "E4, E6") E4, E6 = R_el.gens() Delta = (E4**3 - E6**2) / 1728 d = {g2: E4, g5: 0, g6: 2 * Delta} return f.subs(d)
log.info(f"working on {fname}:{i}") cols = [ x for x in df.columns if x not in ["bnet", "phenotype"] + benchmark_keys ] log.info(df.loc[i:i, cols]) bnet = df.at[i, "bnet"] phenotype = df.at[i, "phenotype"] start = time.time() polys = parse_bnet_str(fstr=bnet) end = time.time() df.at[i, "t_polynomials"] = round(end - start, 2) R = BooleanPolynomialRing(names=sorted(polys), order=TermOrder("lex")) R.inject_variables() variables = [R.variable(i) for i in range(len(polys))] for name, poly in polys.items(): exec(f"f__{name} = {poly}") start = time.time() ideal_generator_expr = ', '.join(f'f__{name} + {name}' for name in polys) ideal_generators = eval(f"[{ideal_generator_expr}]") end = time.time() df.at[i, "t_ideals"] = round(end - start, 2) start = time.time()