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()
