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

sage/rings/polynomial/pbori/randompoly.py

@@ -0,0 +1,105 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from random import Random
+from pprint import pformat
+
+from .PyPolyBoRi import (Monomial, Polynomial, Variable)
+from .pbori import random_set, set_random_seed, ll_red_nf_redsb
+from .ll import ll_encode
+from .blocks import declare_ring
+
+
+def gen_random_poly(ring, l, deg, vars_set, seed=123):
+    """
+    Generate a random polynomial with coefficients in ``ring``.
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import Ring, Variable
+        sage: from sage.rings.polynomial.pbori.randompoly import gen_random_poly
+        sage: r = Ring(16)
+        sage: vars = [Variable(i,r) for i in range(10)]
+        sage: gen_random_poly(r, 4, 10, vars)  # random
+        x(0)*x(1)*x(2)*x(5)*x(8)*x(9) + x(0)*x(1)*x(4)*x(6) + x(0)*x(2)*x(3)*x(7)*x(9) + x(5)*x(8)
+    """
+    myrange = vars_set
+    r = Random(seed)
+
+    def helper(samples):
+        if samples == 0:
+            return Polynomial(ring.zero())
+        if samples == 1:
+            d = r.randint(0, deg)
+            variables = r.sample(myrange, d)
+            m = Monomial(ring)
+            for v in sorted(set(variables), reverse=True):
+                m = m * Variable(v, ring)
+            return Polynomial(m)
+        assert samples >= 2
+        return helper(samples // 2) + helper(samples - samples // 2)
+    p = Polynomial(ring.zero())
+    while len(p) < l:
+        p = Polynomial(p.set().union(helper(l - len(p)).set()))
+    return p
+
+
+def sparse_random_system(ring, number_of_polynomials, variables_per_polynomial,
+                         degree, random_seed=None):
+    r"""
+    Generate a sparse random system.
+
+    Generate a system, which is sparse in the sense, that each polynomial
+    contains only a small subset of variables. In each variable that occurs
+    in a polynomial it is dense in the terms up to the given degree
+    (every term occurs with probability 1/2).
+
+    The system will be satisfiable by at least one solution.
+
+    TESTS::
+
+        sage: from sage.rings.polynomial.pbori import Ring, groebner_basis
+        sage: r = Ring(10)
+        sage: from sage.rings.polynomial.pbori.randompoly import sparse_random_system
+        sage: s = sparse_random_system(r, number_of_polynomials=20, variables_per_polynomial=3, degree=2, random_seed=int(123))
+        sage: [p.deg() for p in s]
+        [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+        sage: sorted(groebner_basis(s), reverse=True)
+        [x(0), x(1) + 1, x(2), x(3) + 1, x(4) + 1, x(5), x(6), x(7) + 1, x(8) + 1, x(9) + 1]
+    """
+    if random_seed is not None:
+        set_random_seed(random_seed)
+    random_generator = Random(random_seed)
+    variables = [ring.variable(i) for i in range(ring.n_variables())]
+    solutions = [v + random_generator.randint(0, 1) for v in variables]
+    solutions = ll_encode(solutions)
+    res = []
+    while len(res) < number_of_polynomials:
+        variables_as_monomial = Monomial(
+            random_generator.sample(
+                variables,
+                variables_per_polynomial)
+        )
+        p = Polynomial(random_set(variables_as_monomial, 2 ** (
+            variables_per_polynomial - 1)))
+        p = sum([p.graded_part(i) for i in range(degree + 1)])
+        if p.deg() == degree:
+            res.append(p)
+    # evaluate it to guarantee a solution
+    return [p + ll_red_nf_redsb(p, solutions) for p in res]
+
+
+def sparse_random_system_data_file_content(number_of_variables, **kwds):
+    r"""
+    TESTS::
+
+        sage: from sage.rings.polynomial.pbori.randompoly import sparse_random_system_data_file_content
+        sage: sparse_random_system_data_file_content(10, number_of_polynomials=5, variables_per_polynomial=3, degree=2, random_seed=int(123))
+        "declare_ring(['x'+str(i) for in range(10)])\nideal=\\\n[...]\n\n"
+    """
+    dummy_dict = {}
+    r = declare_ring(['x' + str(i) for i in range(number_of_variables)],
+                     dummy_dict)
+    polynomials = sparse_random_system(r, **kwds)
+    polynomials = pformat(polynomials)
+    return "declare_ring(['x'+str(i) for in range({})])\nideal=\\\n{}\n\n".format(
+        number_of_variables, polynomials)

sage/rings/polynomial/pbori/rank.py

@@ -0,0 +1,27 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+def input_signals(p):
+    return list((p + p.lex_lead()).vars_as_monomial().variables())
+
+
+def output_signal(p):
+    return next(iter(p.lex_lead().variables()))
+
+
+def rank(data):
+    parents = {}
+    res = {}
+    for p in data:
+        out = output_signal(p)
+        parents.setdefault(out, [])
+        for v in input_signals(p):
+            parents.setdefault(v, []).append(out)
+
+    def do_rank(v):
+        if v in res:
+            return res[v]
+        my_res = res[v] = max((do_rank(p) + 1 for p in parents[v]), default=0)
+        return my_res
+    for v in parents:
+        do_rank(v)
+    return res

sage/rings/polynomial/pbori/specialsets.py

@@ -0,0 +1,112 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from .pbori import (top_index, if_then_else,
+                    mod_mon_set, BooleSet, BooleConstant)
+from .PyPolyBoRi import (Polynomial, Monomial, Variable)
+
+
+def all_monomials_of_degree_d_old(d, variables):
+    """
+    Return monomials of degree d in the given variables.
+
+    Obsolete version ?
+    """
+    if d == 0:
+        return BooleConstant(1)
+
+    if not variables:
+        return []
+    variables = sorted(set(variables), reverse=True, key=top_index)
+
+    m = variables[-1]
+    for v in variables[:-1]:
+        m = v + m
+    m = m.set()
+    i = 0
+    res = Polynomial(variables[0].ring().one()).set()
+    while i < d:
+        i += 1
+        res = res.cartesian_product(m).diff(res)
+    return res
+
+
+def all_monomials_of_degree_d(d, variables):
+    """
+    Return monomials of degree d in the given variables.
+    """
+    variables = Monomial(variables)
+    variables = list(variables.variables())
+    if not variables:
+        assert d == 0
+        return BooleConstant(1)
+    ring = variables[0].ring()
+    if d > len(variables):
+        return Polynomial(0, ring)
+    if d < 0:
+        return Polynomial(1, ring)
+
+    deg_variables = variables[-d:]
+    # this ensures sorting by indices
+    res = Monomial(deg_variables)
+
+    for i in range(1, len(variables) - d + 1):
+        deg_variables = variables[-d - i:-i]
+        res = Polynomial(res)
+        nav = res.navigation()
+        navs = []
+        while not nav.constant():
+            navs.append(BooleSet(nav, ring))
+            nav = nav.then_branch()
+        acc = Polynomial(1, ring)
+        for (nav, v) in reversed(zip(navs, deg_variables)):
+            acc = if_then_else(v, acc, nav)
+        res = acc
+    return res.set()
+
+
+def power_set(variables):
+    """
+    Return all subsets of the given variables.
+    """
+    if not variables:
+        return BooleConstant(1)
+    variables = sorted(set(variables), reverse=True, key=top_index)
+    res = Polynomial(1, variables[0].ring()).set()
+    for v in variables:
+        res = if_then_else(v, res, res)
+    return res
+
+
+if __name__ == '__main__':
+    from .blocks import declare_ring, Block
+    r = declare_ring([Block("x", 10000)], globals())
+    print(list(all_monomials_of_degree_d(0, [Variable(i) for i in range(100)])))
+    print(list(all_monomials_of_degree_d(1, [Variable(i) for i in range(10)])))
+    print(list(all_monomials_of_degree_d(2, [Variable(i) for i in range(4)])))
+    print(list(all_monomials_of_degree_d(3, [Variable(i) for i in range(4)])))
+    print(list(all_monomials_of_degree_d(4, [Variable(i) for i in range(4)])))
+    print(list(all_monomials_of_degree_d(0, [])))
+    print(list(all_monomials_of_degree_d(1, [])))
+    print(list(power_set([Variable(i) for i in range(2)])))
+    print(list(power_set([Variable(i) for i in range(4)])))
+    print(list(power_set()))
+    # every monomial in the first 8 var, which is at most linear in the first 5
+    print(list(mod_mon_set(
+        power_set([Variable(i) for i in range(8)]),
+        all_monomials_of_degree_d(2, [Variable(i) for i in range(5)]))))
+
+    # specialized normal form computation
+    print(Polynomial(
+        mod_mon_set(
+            (x(1) * x(2) + x(1) + 1).set(),
+            all_monomials_of_degree_d(2, [Variable(i) for i in range(1000)]))))
+    print(list(mod_mon_set(
+        power_set([Variable(i) for i in range(50)]),
+        all_monomials_of_degree_d(2, [Variable(i) for i in range(1000)]))))
+
+
+def monomial_from_indices(ring, indices):
+    res = Monomial(ring)
+    for i in sorted(indices, reverse=True):
+        res = res * ring.variable(i)
+    return res

sage/rings/polynomial/pbori/statistics.py

@@ -0,0 +1,31 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from .pbori import top_index, BooleConstant
+from .PyPolyBoRi import Monomial, Polynomial
+
+
+def used_vars(l, bound=None):
+    if not l:
+        return BooleConstant(1)
+    m = Monomial(Polynomial(next(iter(l))).vars_as_monomial())
+    for p in l[1:]:
+        m = m * Polynomial(p).vars_as_monomial()
+        if bound and len(m) > bound:
+            return m
+    return m
+
+
+def used_vars_set(l, bound=None):
+    if not l:
+        return BooleConstant(1)
+    s = set()
+    for p in l:
+        s.update(Polynomial(p).vars_as_monomial().variables())
+        if bound and len(s) > bound:
+            break
+    sorted_s = sorted(s, key=top_index, reverse=True)
+    m = Monomial(next(iter(l)).ring())
+    for v in sorted_s:
+        m = v * m
+
+    return m