passagemath-brial 10.6.39__cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

sage/rings/polynomial/pbori/gbrefs.py

@@ -0,0 +1,127 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+import gzip
+from io import StringIO
+import base64 as uu
+import re
+from types import ModuleType
+from .PyPolyBoRi import Polynomial
+AUTO = "auto"
+SINGLE = "single"
+
+
+# def ref_file_name(f):
+#     name=re.sub("data/","",f)
+#     name=sub(r"\.py","",name)
+#     l=name.split("/")[:-1]
+
+
+def reencode_blocks(block_str):
+    return str(block_str).replace(",", "_")
+
+
+def parse_blocks(block_str, data):
+    if block_str == AUTO:
+        return data.block_start_hints
+    if block_str == SINGLE:
+        return []
+    return [int(i) for i in block_str.split(",")]
+
+
+def load_ref_raw(s):
+    s = re.sub("data/", "", s)
+    s = re.sub(r"data\.", "", s)
+    s = re.sub(r"\.py", "", s)
+    s = re.sub(r"\.", "/", s)
+
+    ref_file = "ref/" + s + ".ref"
+    with open(ref_file) as res_f:
+        res = res_f.read()
+    return res
+
+
+def load_ref(s, ordering='lp', blocks=SINGLE):
+    return load_ref_gz_uu(s, ordering, blocks)
+
+
+def ordering_suffix(o, blocks=None):
+    if o == "lp":
+        return ""
+    if re.match("block", o):
+        return "." + o + "_" + reencode_blocks(blocks)
+    return "." + o
+
+
+def number_of_declared_vars(data):
+    try:
+        return data.number_of_declared_vars
+    except AttributeError:
+        return data.r.ngens()
+
+
+def load_ref_gz_uu(s, o, b):
+    s = re.sub("data/", "", s)
+    s = re.sub(r"data\.", "", s)
+    s = re.sub(r"\.py", "", s)
+    s = re.sub(r"\.", "/", s)
+
+    ref_file = "ref/" + s + ordering_suffix(o, b) + ".ref.gz.uu"
+    res = StringIO()
+    uu.decode(ref_file, res)
+    res = res.getvalue()
+    res = StringIO(res)
+    res = gzip.GzipFile(fileobj=res, mode='r').read()
+    res = res.replace(" ", "")
+    return res
+
+
+def convert_refs(ref_file_orig):
+    with open(ref_file_orig) as file:
+        content = file.read()
+    buf_out = StringIO()
+    zipped = gzip.GzipFile(filename=ref_file_orig, mode='w', fileobj=buf_out)
+    zipped.write(content)
+    zipped.close()
+    val = buf_out.getvalue()
+    with open(ref_file_orig + ".gz.uu", "w") as out:
+        uu.encode(out_file=out, in_file=StringIO(val))
+
+
+def dyn_generate(content, name):
+    module = ModuleType(name)
+    import_header = """from .PyPolyBoRi import Variable,Monomial, Polynomial, Ring, OrderCode
+from itertools import chain
+from .blocks import AlternatingBlock,Block,AdderBlock,if_then,HigherOrderBlock,declare_ring as orig_declare_ring,declare_block_scheme,MacroBlock\n
+def declare_ring(blocks, context=None):
+  if context is None:
+    context=globals()
+  return orig_declare_ring(blocks,context)
+"""
+    exec(import_header + content, module.__dict__)
+    if hasattr(module, "ideal"):
+        module.ideal = [Polynomial(p) for p in module.ideal]
+    return module
+
+
+def clean_data(data):
+    for a in dir(data):
+        if a != "r":
+            delattr(data, a)
+
+
+def load_data(file_name, base_dir='./'):
+    in_file = file_name
+    if not re.match("^data", in_file):
+        in_file = "data/" + in_file
+    in_file = re.sub(r".py$", "", in_file)
+    in_file = re.sub(r"\.", "/", in_file)
+    in_file = in_file + ".py"
+    with open(base_dir + in_file) as f:
+        in_file = f.read()
+    return dyn_generate(in_file, "pb_data")
+
+
+def load_file(file_name):
+    with open(file_name) as f:
+        in_file = f.read()
+    return dyn_generate(in_file, "pb_data")

sage/rings/polynomial/pbori/heuristics.py

@@ -0,0 +1,35 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from .PyPolyBoRi import Polynomial, gauss_on_polys
+
+
+def dense_system(I):
+    I = (Polynomial(p) for p in I)
+    I = (p for p in I if not p.is_zero())
+    for p in I:
+        d = p.deg()
+        if d == 1:
+            continue
+        try:
+            if len(p) > 2**d + 5:
+                return True
+        except OverflowError:
+            return True
+    return False
+
+
+def gauss_on_linear(I):
+    I = (Polynomial(p) for p in I)
+    linear = []
+    non_linear = []
+    for p in I:
+        if p.is_zero():
+            continue
+        if p.deg() <= 1:
+            linear.append(p)
+        else:
+            non_linear.append(p)
+    if not linear:
+        return non_linear
+    linear = list(gauss_on_polys(linear))
+    return linear + non_linear

sage/rings/polynomial/pbori/interpolate.py

@@ -0,0 +1,115 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+# Copyright (c) 2005-2007 by The PolyBoRi Team
+from time import process_time as clock
+from random import Random
+
+from .PyPolyBoRi import (Polynomial, Variable, Monomial,
+                         BoolePolynomialVector)
+from .randompoly import gen_random_poly
+from .pbori import (BooleSet, add_up_polynomials, interpolate_smallest_lex,
+                    interpolate)
+from .blocks import Block, declare_ring
+
+
+generator = Random()
+
+
+def add_up_poly_list(l, init):
+    v = BoolePolynomialVector()
+    for p in l:
+        v.append(p)
+    return add_up_polynomials(v, init)
+
+
+def bench_interpolate(degree, nvariables, points):
+    c = points
+    h = len(points) / 2
+    terms = set(c.terms())
+    part1 = generator.sample(terms, h)
+    part1 = add_up_poly_list(part1, Polynomial(c.ring().zero()))
+    part2 = c + part1
+    p = part1
+    q = part2
+    assert part1.set().intersect(part2).empty()
+    c1 = clock()
+    res2 = interpolate_smallest_lex(p, q)
+    c2 = clock()
+    print("finished interpolate_smallest_lex(p,q),len:", len(res2),
+          "time", c2 - c1)
+    c1 = clock()
+    res1 = interpolate(p, q)
+    c2 = clock()
+    print("finished interpolate(p,q)" + len("_smallest_lex") * " " + ",len:",
+          res1.set().size_double(), "time:", c2 - c1)
+    return res2
+
+
+def nf_lex_points(f, p):
+    f = Polynomial(f)
+    p = BooleSet(p)
+    z = f.zeros_in(p)
+    return interpolate_smallest_lex(z, p.diff(z))
+
+
+def gen_random_o_z(points, points_p):
+    k = generator.randrange(len(points) + 1)
+    ones = generator.sample(points, k)
+    vec = BoolePolynomialVector()
+    for p in ones:
+        vec.append(p)
+    ones = add_up_polynomials(vec, Polynomial(points_p.ring().zero()))
+    return interpolate_smallest_lex(points_p.set().diff(ones), ones)
+
+
+def variety_lex_leading_terms(points, variables):
+    assert isinstance(points, BooleSet), "Points needs to be a BooleSet"
+    ring = variables.ring()
+    standards = BooleSet(ring.zero())
+    points_tuple = tuple(points)
+    myvars_div = variables.divisors()
+    if points != myvars_div:
+        standards = BooleSet(ring.one())
+    len_standards = len(standards)
+    standards_old = standards
+    while len_standards < len(points):
+        standards = standards.union(gen_random_o_z(points_tuple, points))
+
+        if standards_old != standards:
+            standards = BooleSet(standards).include_divisors()
+            len_standards = len(standards)
+            standards_old = standards
+
+    return BooleSet(myvars_div.diff(standards)).minimal_elements()
+
+
+def lex_groebner_basis_points(points, variables):
+    leads = variety_lex_leading_terms(points, variables)
+    return [nf_lex_points(l, points) + l for l in leads]
+
+
+def lex_groebner_basis_for_polynomial_via_variety(p):
+    variables = p.vars_as_monomial()
+    return lex_groebner_basis_points(p.zeros_in(variables.divisors()),
+                                     variables)
+
+
+if __name__ == '__main__':
+    nvariables = 100
+    r = declare_ring([Block("x", nvariables)])
+    for number_of_points in (100, 500, 1000, 2000, 3000,
+                             4000, 5000, 10000,
+                             20000, 50000, 100000):
+        print("----------")
+        print("number_of_points:", number_of_points)
+        print("generate points")
+        points = gen_random_poly(r, number_of_points,
+                                 nvariables,
+                                 [Variable(i, r) for i in range(nvariables)])
+        print("points generated")
+        bench_interpolate(nvariables, nvariables, points)
+        vars_mon = Monomial(r)
+        for i in reversed(range(nvariables)):
+            vars_mon = vars_mon * Variable(i, r)
+        print(len(variety_lex_leading_terms(points, vars_mon)),
+              "elements in groebner basis")

sage/rings/polynomial/pbori/interred.py

@@ -0,0 +1,35 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from .pbori import ReductionStrategy
+from .PyPolyBoRi import Polynomial
+
+
+def interred(l, completely=False):
+    r"""
+    Compute a new generating system (g1, ...,gn),
+    spanning the same ideal modulo field equations.
+
+    The system is interreduced: For i!=j:
+    gi.lead() does not divide any leading term of gj.
+
+    If completely is set to ``True``, then also terms in the
+    tail are not reducible by other polynomials.
+    """
+    l = [Polynomial(p) for p in l if p != 0]
+    if not l:
+        return []
+    ring = l[0].ring()
+    l_old = None
+    l = tuple(l)
+    while l_old != l:
+        l_old = l
+        l = sorted(l, key=Polynomial.lead)
+        g = ReductionStrategy(ring)
+        if completely:
+            g.opt_red_tail = True
+        for p in l:
+            gp = g.nf(p)
+            if not gp.is_zero():
+                g.add_generator(gp)
+        l = tuple(e.p for e in g)
+    return l

sage/rings/polynomial/pbori/ll.py

@@ -0,0 +1,292 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from .pbori import (top_index, if_then_else,
+                    substitute_variables, BooleSet,
+                    ll_red_nf_redsb, ll_red_nf_noredsb,
+                    ll_red_nf_noredsb_single_recursive_call)
+from .PyPolyBoRi import (Polynomial, Monomial, Ring, BoolePolynomialVector)
+from .statistics import used_vars_set
+from .rank import rank
+
+lead_index = top_index
+
+
+def combine(reductors, p, reduce=None):
+    p_nav = p.navigation()
+    assert p_nav.value() < reductors.navigation().value()
+    p_else = BooleSet(p_nav.else_branch(), p.ring())
+    if reduce:
+        p_else = reduce(p_else, reductors)
+    return if_then_else(p_nav.value(), reductors, p_else)
+
+
+def llredsb_Cudd_style(polys):
+
+    reductors = Polynomial(polys[0].ring().one()).set() if polys else None
+
+    linear_lead = sorted(polys, key=lead_index, reverse=True)
+    assert len({p.lex_lead() for p in linear_lead}) == len(polys)
+    assert not any(p.constant() for p in polys)
+    assert len([p for p in polys if p.lex_lead_deg() == 1]) == len(polys)
+    assert len({p.navigation().value() for p in polys}) == len(polys)
+    for p in linear_lead:
+        reductors = combine(reductors, p, reduce=ll_red_nf_redsb)
+    return reductors
+
+
+def ll_encode(polys, reduce=False, prot=False, reduce_by_linear=True):
+    polys = [Polynomial(p) for p in polys]
+    linear_lead = sorted(polys, key=lead_index, reverse=True)
+    assert len({p.lex_lead() for p in linear_lead}) == len(polys)
+    assert not any(p.constant() for p in polys)
+    assert len([p for p in polys if p.lex_lead_deg() == 1]) == len(polys)
+    assert len({p.navigation().value() for p in polys}) == len(polys)
+    if (not reduce) and reduce_by_linear:
+        linear_polys = [p for p in polys if p.deg() == 1]
+        if linear_polys:
+            linear_ll = ll_encode(linear_polys, reduce=True,
+                                  reduce_by_linear=False)
+            polys = [p.lex_lead() + ll_red_nf_redsb(p + p.lex_lead(),
+                                                    linear_ll) for p in polys]
+    reduce = ll_red_nf_redsb if reduce else None
+
+    reductors = Polynomial(polys[0].ring().one()).set() if polys else None
+
+    last = None
+    counter = 0
+    for p in linear_lead:
+
+        if prot:
+            counter = counter + 1
+            progress = (counter * 100) / len(linear_lead)
+            if last != progress:
+                print(str(progress) + "%")
+            last = progress
+        reductors = combine(reductors, p, reduce=reduce)
+    return reductors
+
+
+def eliminate(polys, on_the_fly=False, prot=False, reduction_function=None,
+              optimized=True):
+    r"""
+    There exists an optimized variant, which reorders the variable in a different ring.
+    """
+    polys = [Polynomial(p) for p in polys]
+    rest = []
+    linear_leads = []
+    linear_leading_monomials = set()
+    for p in polys:
+        if p.is_zero():
+            continue
+        lm = p.lex_lead()
+        if lm.deg() == 1:
+
+            if lm not in linear_leading_monomials:
+                linear_leading_monomials.add(lm)
+                linear_leads.append(p)
+            else:
+                rest.append(p)
+        else:
+            rest.append(p)
+    if not linear_leads:
+        def identity(p):
+            return p
+        return (linear_leads, identity, rest)
+    if reduction_function is None:
+        if on_the_fly:
+            if optimized:
+                reduction_function = ll_red_nf_noredsb_single_recursive_call
+            else:
+                reduction_function = ll_red_nf_noredsb
+        else:
+            reduction_function = ll_red_nf_redsb
+
+    if optimized:
+        llnf, reduced_list = eliminate_ll_ranked(linear_leads, rest,
+                                                 reduction_function=reduction_function,
+                                                 reduce_ll_system=(not on_the_fly),
+                                                 prot=prot)
+    else:
+        def llnf(p):
+            return reduction_function(p, reductors)
+        reduced_list = []
+        reductors = ll_encode(linear_leads, reduce=(not on_the_fly), prot=prot)
+        for p in rest:
+            rp = reduction_function(p, reductors)
+            if rp.is_one():
+                reduced_list = [rp]
+                break
+            reduced_list.append(rp)
+
+    return (linear_leads, llnf, reduced_list)
+
+
+def construct_map_by_indices(to_ring, idx_mapping):
+    v = BoolePolynomialVector((max(idx_mapping.keys()) + 1) * [to_ring.zero()])
+    for (from_idx, to_idx) in idx_mapping.items():
+        val = to_ring.variable(to_idx)
+        v[from_idx] = val
+    return v
+
+
+def eliminate_ll_ranked(ll_system, to_reduce,
+                        reduction_function=ll_red_nf_noredsb,
+                        reduce_ll_system=False, prot=False):
+
+    assert ll_system
+    from_ring = ll_system[0].ring()
+
+    ll_ranks = rank(ll_system)
+    add_vars = set(used_vars_set(to_reduce).variables()).difference(ll_ranks.
+                                                                    keys())
+    for v in add_vars:
+        ll_ranks[v] = -1
+
+        # pushing variables ignored by ll to the front means,
+        # that the routines will quickly eliminate them
+        # and they won't give any overhead
+    def sort_key(v):
+        return (ll_ranks[v], v.index())
+    sorted_vars = sorted(ll_ranks.keys(), key=sort_key)
+
+    def var_index(v):
+        return next(iter(Monomial(v).variables())).index()
+
+    to_ring = Ring(len(sorted_vars))
+    map_back_indices = {i: var_index(v) for i, v in enumerate(sorted_vars)}
+    map_from_indices = {var_index(v): i for i, v in enumerate(sorted_vars)}
+
+    var_names = [str(v) for v in sorted_vars]
+    try:
+        for (i, v) in enumerate(sorted_vars):
+            assert var_names[i] == str(v), (var_names[i], v, var_index(v), i)
+
+    finally:
+        pass
+    try:
+        map_from_vec = construct_map_by_indices(to_ring, map_from_indices)
+    finally:
+        pass
+    map_back_vec = construct_map_by_indices(from_ring, map_back_indices)
+
+    def map_from(p):
+        res = substitute_variables(to_ring, map_from_vec, p)
+        return res
+
+    def map_back(p):
+        return substitute_variables(from_ring, map_back_vec, p)
+
+    try:
+        ll_opt_encoded = ll_encode([map_from(p) for p in ll_system],
+                                   prot=False,
+                                   reduce=reduce_ll_system)
+
+        def llnf(p):
+            return map_back(reduction_function(map_from(p), ll_opt_encoded))
+        opt_eliminated = [llnf(p) for p in to_reduce]
+    finally:
+        pass
+    return (llnf, opt_eliminated)
+
+
+class RingMap:
+    r"""
+    Define a mapping between two rings by common variable names.
+
+    TESTS::
+
+        sage: from sage.rings.polynomial.pbori.pbori import *
+        sage: from sage.rings.polynomial.pbori.blocks import declare_ring, Block
+        sage: to_ring = declare_ring([Block("x", 10)], globals())
+        sage: from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
+        sage: from sage.rings.polynomial.pbori.ll import RingMap
+        sage: mapping = RingMap(to_ring, from_ring)
+        sage: (x(1)+1).navigation().value()
+        6
+        sage: mapping(x(1)+1)
+        x(1) + 1
+        sage: mapping(x(1)+1).navigation().value()
+        1
+        sage: mapping.invert(mapping(x(1)+1))
+        x(1) + 1
+        sage: mapping.invert(mapping(x(1)+1)).navigation().value()
+        6
+        sage: mapping(y(1)+1)
+        Traceback (most recent call last):
+        ...
+        RuntimeError: Operands come from different manager.
+    """
+
+    def __init__(self, to_ring, from_ring):
+        r"""
+        Initialize map by two given rings.
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori.pbori import *
+            sage: from sage.rings.polynomial.pbori.blocks import declare_ring, Block
+            sage: to_ring = declare_ring([Block("x", 10)], globals())
+            sage: from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
+            sage: from sage.rings.polynomial.pbori.ll import RingMap
+            sage: mapping = RingMap(to_ring, from_ring)
+            sage: mapping(x(1)+1)
+            x(1) + 1
+        """
+        def vars(ring):
+            return [ring.variable(i) for i in range(ring.n_variables())]
+
+        def indices(vars):
+            return {str(v): idx for idx, v in enumerate(vars)}
+
+        self.to_ring = to_ring
+        self.from_ring = from_ring
+        to_vars = vars(to_ring)
+        from_vars = vars(from_ring)
+        to_indices = indices(to_vars)
+        from_indices = indices(from_vars)
+        common = list(set(to_indices.keys()) & set(from_indices.keys()))
+
+        to_map = list(from_vars)
+        for elt in common:
+            to_map[from_indices[elt]] = to_vars[to_indices[elt]]
+
+        from_map = list(to_vars)
+        for elt in common:
+            from_map[to_indices[elt]] = from_vars[from_indices[elt]]
+
+        self.to_map = BoolePolynomialVector(to_map)
+        self.from_map = BoolePolynomialVector(from_map)
+
+    def __call__(self, poly):
+        r"""
+        Execute the map to change rings.
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori.pbori import *
+            sage: from sage.rings.polynomial.pbori.blocks import declare_ring, Block
+            sage: to_ring = declare_ring([Block("x", 10)], globals())
+            sage: from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
+            sage: from sage.rings.polynomial.pbori.ll import RingMap
+            sage: mapping = RingMap(to_ring, from_ring)
+            sage: mapping(x(1)+1)
+            x(1) + 1
+        """
+        return substitute_variables(self.to_ring, self.to_map, poly)
+
+    def invert(self, poly):
+        r"""
+        Inverted map to initial ring.
+
+        EXAMPLES::
+
+            sage: from sage.rings.polynomial.pbori.pbori import *
+            sage: from sage.rings.polynomial.pbori.blocks import declare_ring, Block
+            sage: to_ring = declare_ring([Block("x", 10)], globals())
+            sage: from_ring = declare_ring([Block("y", 5), Block("x", 10)], globals())
+            sage: from sage.rings.polynomial.pbori.ll import RingMap
+            sage: mapping = RingMap(to_ring, from_ring)
+            sage: mapping.invert(mapping(x(1)+1))
+            x(1) + 1
+        """
+        return substitute_variables(self.from_ring, self.from_map, poly)