passagemath-brial 10.8.1a3__cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

sage/rings/polynomial/pbori/cnf.py

@@ -0,0 +1,241 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from random import Random
+
+from sage.rings.polynomial.pbori.pbori import if_then_else as ite
+from sage.rings.polynomial.pbori.PyPolyBoRi import Polynomial
+from sage.rings.polynomial.pbori.statistics import used_vars_set
+
+
+class CNFEncoder:
+    def __init__(self, r, random_seed=16):
+        self.random_generator = Random(random_seed)
+        self.one_set = r.one().set()
+        self.empty_set = r.zero().set()
+        self.r = r
+
+    def zero_blocks(self, f):
+        r"""
+        Divide the zero set of f into blocks.
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori import *
+            sage: r = declare_ring(["x", "y", "z"], dict())
+            sage: from sage.rings.polynomial.pbori.cnf import CNFEncoder
+            sage: e = CNFEncoder(r)
+            sage: e.zero_blocks(r.variable(0)*r.variable(1)*r.variable(2))
+            [{z: 0}, {y: 0}, {x: 0}]
+        """
+        f = Polynomial(f)
+        variables = f.vars_as_monomial()
+
+        space = variables.divisors()
+        variables = list(variables.variables())
+        zeros = f.zeros_in(space)
+        rest = zeros
+        res = []
+
+        # inefficient compared to polynomials lex_lead
+        def choose(s):
+            indices = []
+            assert not s.empty()
+            nav = s.navigation()
+            while not nav.constant():
+                e = nav.else_branch()
+                t = nav.then_branch()
+                if e.constant() and not e.terminal_one():
+                    indices.append(nav.value())
+                    nav = t
+                elif self.random_generator.randint(0, 1):
+                    indices.append(nav.value())
+                    nav = t
+
+                else:
+                    nav = e
+            assert nav.terminal_one()
+            res = self.one_set
+            for i in reversed(indices):
+                res = ite(i, res, self.empty_set)
+            return next(iter(res))
+        while not rest.empty():
+            l = choose(rest)
+            l_variables = set(l.variables())
+
+            def get_val(var):
+                if var in l_variables:
+                    return 1
+                return 0
+            block_dict = {v: get_val(v) for v in variables}
+
+            l = l.set()
+            self.random_generator.shuffle(variables)
+            for v in variables:
+                candidate = l.change(v.index())
+                if candidate.diff(zeros).empty():
+                    l = l.union(candidate)
+                    del block_dict[v]
+            rest = rest.diff(l)
+            res.append(block_dict)
+        return res
+
+    def clauses(self, f):
+        r"""
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori import *
+            sage: r = declare_ring(["x", "y", "z"], dict())
+            sage: from sage.rings.polynomial.pbori.cnf import CNFEncoder
+            sage: e = CNFEncoder(r)
+            sage: sorted(e.clauses(r.variable(0)*r.variable(1)*r.variable(2)), key=lambda d: sorted(d.items()))
+            [{z: 0, y: 0, x: 0}]
+            sage: sorted(e.clauses(r.variable(Integer(1))+r.variable(Integer(0))), key=lambda d: sorted(d.items()))
+            [{y: 0, x: 1}, {y: 1, x: 0}]
+        """
+        # we form an expression for a var configuration *not* lying in the
+        # block it is evaluated to 0 by f, iff it is not lying in any zero
+        # block of f+1
+        return [{variable: 1 - value for variable, value in b.items()}
+                for b in self.zero_blocks(f + 1)]
+
+    def polynomial_clauses(self, f):
+        r"""
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori import *
+            sage: r = declare_ring(["x", "y", "z"], dict())
+            sage: from sage.rings.polynomial.pbori.cnf import CNFEncoder
+            sage: e = CNFEncoder(r)
+            sage: e.polynomial_clauses(r.variable(0)*r.variable(1)*r.variable(2))
+            [x*y*z]
+            sage: v = r.variable
+            sage: p = v(1)*v(2)+v(2)*v(0)+1
+            sage: groebner_basis([p], heuristic = False)==groebner_basis(e.polynomial_clauses(p), heuristic = False)
+            True
+        """
+
+        def product(l):
+            res = l[0]
+            for p in l[1:]:
+                res = res * p
+            # please care about the order of these multiplications for
+            # performance
+            return res
+        return [product([variable + value for (variable, value)
+                         in b.items()]) for b in self.clauses(f)]
+
+    def to_dimacs_index(self, v):
+        return v.index() + 1
+
+    def dimacs_encode_clause(self, c):
+        def get_sign(value):
+            if value == 1:
+                return 1
+            return -1
+
+        items = sorted(c.items(), reverse=True)
+        return " ".join([str(v) for v in [
+            get_sign(value) * self.to_dimacs_index(variable)
+            for (variable, value) in items] + [0]])
+
+    def dimacs_encode_polynomial(self, p):
+        r"""
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori import *
+            sage: d = {}
+            sage: r = declare_ring(["x", "y", "z"], d)
+            sage: from sage.rings.polynomial.pbori.cnf import CNFEncoder
+            sage: e = CNFEncoder(r)
+            sage: sorted(e.dimacs_encode_polynomial(d["x"]+d["y"]+d["z"]))
+            ['-1 -2 -3 0', '-1 2 3 0', '1 -2 3 0', '1 2 -3 0']
+        """
+        return [self.dimacs_encode_clause(c) for c in self.clauses(p)]
+
+    def dimacs_cnf(self, polynomial_system):
+        r"""
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori import *
+            sage: r = declare_ring(["x", "y", "z"], dict())
+            sage: from sage.rings.polynomial.pbori.cnf import CNFEncoder
+            sage: e = CNFEncoder(r)
+            sage: e.dimacs_cnf([r.variable(0)*r.variable(1)*r.variable(2)])
+            'c cnf generated by PolyBoRi\np cnf 3 1\n-1 -2 -3 0'
+            sage: e.dimacs_cnf([r.variable(1)+r.variable(0)])
+            'c cnf generated by PolyBoRi\np cnf 3 2\n-1 2 0\n1 -2 0'
+            sage: e.dimacs_cnf([r.variable(0)*r.variable(1)*r.variable(2), r.variable(1)+r.variable(0)])
+            'c cnf generated by PolyBoRi\np cnf 3 3\n-1 -2 -3 0\n1 -2 0\n-1 2 0'
+        """
+        clauses_list = [c for p in polynomial_system for c in self.
+                        dimacs_encode_polynomial(p)]
+        res = ["c cnf generated by PolyBoRi"]
+        r = polynomial_system[0].ring()
+        n_variables = r.n_variables()
+        res.append(f"p cnf {n_variables} {len(clauses_list)}")
+        res.extend(clauses_list)
+        return "\n".join(res)
+
+
+class CryptoMiniSatEncoder(CNFEncoder):
+    group_counter = 0
+
+    def dimacs_encode_polynomial(self, p):
+        r"""
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori import *
+            sage: d=dict()
+            sage: r = declare_ring(["x", "y", "z"], d)
+            sage: from sage.rings.polynomial.pbori.cnf import CryptoMiniSatEncoder
+            sage: e = CryptoMiniSatEncoder(r)
+            sage: p = d["x"]+d["y"]+d["z"]
+            sage: p.deg()
+            1
+            sage: len(p)
+            3
+            sage: e.dimacs_encode_polynomial(p)
+            ['x1 2 3 0\nc g 1 x + y + z']
+            sage: e.dimacs_encode_polynomial(p+1)
+            ['x1 2 -3 0\nc g 2 x + y + z + 1']
+        """
+        if p.deg() != 1 or len(p) <= 1:
+            res = super().dimacs_encode_polynomial(p)
+        else:
+            invert_last = bool(p.has_constant_part())
+            variables = list(p.vars_as_monomial().variables())
+            indices = [self.to_dimacs_index(v) for v in variables]
+            if invert_last:
+                indices[-1] = -indices[-1]
+            indices.append(0)
+            res = ["x" + " ".join(str(v) for v in indices)]
+        self.group_counter = self.group_counter + 1
+        group_comment = f"\nc g {self.group_counter} {str(p)[:30]}"
+        return [c + group_comment for c in res]
+
+    def dimacs_cnf(self, polynomial_system):
+        r"""
+
+        TESTS::
+
+            sage: from sage.rings.polynomial.pbori import *
+            sage: r = declare_ring(["x", "y", "z"], dict())
+            sage: from sage.rings.polynomial.pbori.cnf import CryptoMiniSatEncoder
+            sage: e = CryptoMiniSatEncoder(r)
+            sage: e.dimacs_cnf([r.variable(0)*r.variable(1)*r.variable(2)])
+            'c cnf generated by PolyBoRi\np cnf 3 1\n-1 -2 -3 0\nc g 1 x*y*z\nc v 1 x\nc v 2 y\nc v 3 z'
+            sage: e.dimacs_cnf([r.variable(1)+r.variable(0)])
+            'c cnf generated by PolyBoRi\np cnf 3 1\nx1 2 0\nc g 2 x + y\nc v 1 x\nc v 2 y'
+            sage: e.dimacs_cnf([r.variable(0)*r.variable(1)*r.variable(2), r.variable(1)+r.variable(0)])
+            'c cnf generated by PolyBoRi\np cnf 3 2\n-1 -2 -3 0\nc g 3 x*y*z\nx1 2 0\nc g 4 x + y\nc v 1 x\nc v 2 y\nc v 3 z'
+        """
+        uv = list(used_vars_set(polynomial_system).variables())
+        res = super().dimacs_cnf(polynomial_system)
+        res += "\n" + "\n".join(f"c v {self.to_dimacs_index(v)} {v}"
+                                for v in uv)
+        return res

sage/rings/polynomial/pbori/easy_polynomials.py

@@ -0,0 +1,59 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from sage.rings.polynomial.pbori.interpolate import (
+    nf_lex_points,
+    variety_lex_leading_terms,
+)
+from sage.rings.polynomial.pbori.pbori import easy_linear_factors
+
+
+def easy_linear_polynomials(p):
+    r"""
+    Get linear polynomials implied by given polynomial.
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.frontend import x
+        sage: from sage.rings.polynomial.pbori.easy_polynomials import easy_linear_polynomials
+        sage: easy_linear_polynomials(x(1)*x(2) + 1)
+        [x(1) + 1, x(2) + 1]
+        sage: easy_linear_polynomials(x(1)*x(2) + 0)
+        []
+        sage: easy_linear_polynomials(x(0)*x(1) + x(0)*x(2) + 1)
+        [x(0) + 1, x(1) + x(2) + 1]
+    """
+    res = []
+    if p.deg() >= 2:
+        if p.vars_as_monomial().deg() > 8:
+            res.extend(q + 1 for q in easy_linear_factors(p + 1))
+        else:
+            res = easy_linear_polynomials_via_interpolation(p)
+    return res
+
+
+def easy_linear_polynomials_via_interpolation(p):
+    r"""
+    Get linear polynomials implied by given polynomial using interpolation of the variety.
+
+    TESTS::
+
+        sage: from sage.rings.polynomial.pbori.frontend import x
+        sage: from sage.rings.polynomial.pbori.easy_polynomials import easy_linear_polynomials_via_interpolation
+        sage: easy_linear_polynomials_via_interpolation(x(1)*x(2) + 1)
+        [x(1) + 1, x(2) + 1]
+        sage: easy_linear_polynomials_via_interpolation(x(1)*x(2) + 0)
+        []
+        sage: easy_linear_polynomials_via_interpolation(x(0)*x(1) + x(0)*x(2) + 1)
+        [x(0) + 1, x(1) + x(2) + 1]
+    """
+    res = []
+    p_vars = p.vars_as_monomial()
+    space = p_vars.divisors()
+    zeros = p.zeros_in(space)
+    lex_leads = variety_lex_leading_terms(zeros, p_vars)
+    for m in lex_leads:
+        if m.deg() == 1:
+            red = m + nf_lex_points(m, zeros)
+            if red.lead_deg() == 1:  # normal ordering
+                res.append(red)
+    return res

sage/rings/polynomial/pbori/fglm.py

@@ -0,0 +1,93 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+from sage.rings.polynomial.pbori.pbori import BooleSet, FGLMStrategy
+from sage.rings.polynomial.pbori.PyPolyBoRi import BoolePolynomialVector, Polynomial
+
+
+def _fglm(I, from_ring, to_ring):
+    r"""
+    Unchecked variant of fglm
+    """
+    vec = BoolePolynomialVector(I)
+    return FGLMStrategy(from_ring, to_ring, vec).main()
+
+
+def fglm(I, from_ring, to_ring):
+    r"""
+    Convert *reduced* Groebner Basis in ``from_ring`` to a GroebnerBasis
+    in ``to_ring``.
+
+    It acts independent of the global ring, which is restored at the end of the
+    computation.
+
+    TESTS::
+
+        sage: from sage.rings.polynomial.pbori import *
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import OrderCode
+        sage: from sage.rings.polynomial.pbori.fglm import fglm
+        sage: dp_asc = OrderCode.dp_asc
+        sage: r = declare_ring(['x','y','z'],dict())
+        sage: old_ring = r
+        sage: new_ring = old_ring.clone(ordering=dp_asc)
+        sage: x,y,z = (old_ring.variable(i) for i in range(3))
+        sage: ideal = [x+z, y+z]  # lp Groebner basis
+        sage: list(fglm(ideal, old_ring, new_ring))
+        [y + x, z + x]
+    """
+    for poly in I:
+        if poly.ring().id() != from_ring.id():
+            raise ValueError("Ideal I must be from the first ring argument")
+    return _fglm(I, from_ring, to_ring)
+
+
+def vars_real_divisors(monomial, monomial_set):
+    r"""
+    Return all elements of ``monomial_set``, which result multiplied by a variable in monomial.
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.pbori import *
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import OrderCode
+        sage: dp_asc = OrderCode.dp_asc
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import Ring
+        sage: r = Ring(1000)
+        sage: x = r.variable
+        sage: b = BooleSet([x(1)*x(2),x(2)])
+        sage: from sage.rings.polynomial.pbori.fglm import vars_real_divisors
+        sage: vars_real_divisors(x(1)*x(2)*x(3),b)
+        {{x(1),x(2)}}
+    """
+    return BooleSet(Polynomial(monomial_set.divisors_of(monomial)).
+                    graded_part(monomial.deg() - 1))
+
+
+def m_k_plus_one(completed_elements, variables):
+    r"""
+    Calculate `m_{k+1}` from the FGLM algorithm.
+
+    Calculate `m_{k+1}` from the FGLM algorithm as described in Wichmann [Wich1997]_.
+
+    .. NOTE::
+
+        It would be nice to be able to efficiently extract the smallest term of a polynomial.
+
+    EXAMPLES::
+
+        sage: from sage.rings.polynomial.pbori.pbori import *
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import OrderCode
+        sage: from sage.rings.polynomial.pbori.fglm import m_k_plus_one
+        sage: dp_asc = OrderCode.dp_asc
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import Ring
+        sage: r = Ring(1000)
+        sage: x = r.variable
+        sage: from sage.rings.polynomial.pbori.PyPolyBoRi import Monomial
+        sage: s = BooleSet([x(1)*x(2),x(1),x(2),Monomial(r),x(3)])
+        sage: variables = BooleSet([x(1),x(2),x(3)])
+        sage: m_k_plus_one(s,variables)
+        x(2)*x(3)
+        sage: r2 = r.clone(ordering=dp_asc)
+        sage: m_k_plus_one(r2(s).set(),r2(variables).set())
+        x(1)*x(3)
+    """
+    return sorted(completed_elements.cartesian_product(variables).diff(
+        completed_elements))[0]

sage/rings/polynomial/pbori/frontend.py

@@ -0,0 +1,70 @@
+# sage_setup: distribution = sagemath-brial
+# sage.doctest: needs sage.rings.polynomial.pbori
+# Import basic functionality
+r"""
+This module defines an initial ring, and patches the declare_ring to use
+a given context.
+
+EXAMPLES::
+
+    sage: from sage.rings.polynomial.pbori.frontend import x
+    sage: x(0)
+    x(0)
+    sage: x(0)*x(0)
+    x(0)
+    sage: x(0) + x(0)
+    0
+    sage: x(9999)
+    x(9999)
+    sage: x(9999)*x(9999)
+    x(9999)
+    sage: x(9999) + x(9999)
+    0
+
+    sage: from sage.rings.polynomial.pbori.frontend import x, polybori_start
+    sage: context = dict(globals())
+    sage: polybori_start(context)
+    ipbori...
+    sage: r = context['declare_ring']('abc')
+    sage: context['a']
+    a
+    sage: r.variable(0)
+    a
+"""
+
+
+from sage.rings.polynomial.pbori.blocks import declare_ring as orig_declare_ring
+from sage.rings.polynomial.pbori.pbori import VariableFactory
+from sage.rings.polynomial.pbori.PyPolyBoRi import Ring
+
+
+def block_scheme_names(blocks):
+    r"""
+    Helper for Singular interface.
+    """
+    context = {}
+    from .blocks import declare_block_scheme
+    declare_block_scheme(blocks, context)
+
+    return list(context.keys())
+
+
+ipbname = 'ipbori'
+
+
+def polybori_start(global_context):
+    def declare_ring(blocks, context=None):
+        if context is None:
+            context = global_context
+
+        return orig_declare_ring(blocks, context)
+    declare_ring.__doc__ = orig_declare_ring.__doc__
+    global_context["declare_ring"] = declare_ring
+
+    print(ipbname + """ -- The interactive command line tool of PolyBoRi/BRiAL %s
+""" % global_context.get("polybori_version", ''))
+
+
+# Here come the defaults
+r = Ring(10000)
+x = VariableFactory(r)