PySMT 0.9.7.dev120__tar.gz → 0.9.7.dev129__tar.gz

{PySMT-0.9.7.dev120/PySMT.egg-info → PySMT-0.9.7.dev129}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: PySMT
-Version: 0.9.7.dev120
+Version: 0.9.7.dev129
 Summary: A solver-agnostic library for SMT Formulae manipulation and solving
 Home-page: http://www.pysmt.org
 Author: PySMT Team

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129/PySMT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.0
 Name: PySMT
-Version: 0.9.7.dev120
+Version: 0.9.7.dev129
 Summary: A solver-agnostic library for SMT Formulae manipulation and solving
 Home-page: http://www.pysmt.org
 Author: PySMT Team

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129}/pysmt/__init__.py

@@ -16,7 +16,7 @@
 #   limitations under the License.
 #
 
-VERSION = (0, 9, 7, "dev", 120)
+VERSION = (0, 9, 7, "dev", 129)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129}/pysmt/cmd/installers/btor.py

@@ -12,9 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import os
+from tempfile import NamedTemporaryFile
 
 from pysmt.cmd.installers.base import SolverInstaller
 
+CYTHON_PATCH = '''\
+--- pyboolector.pyx	2025-05-12 14:01:27.528128358 +0200
++++ pyboolector.pyx.patched	2025-05-12 14:07:26.685645023 +0200
+@@ -1274,7 +1274,7 @@
+                 Parameter ``width`` is only required if ``c`` is an integer.
+         """
+         cdef BoolectorConstNode r
+-        if isinstance(c, int) or (sys.version < '3' and isinstance(c, long)):
++        if isinstance(c, int):
+             if c != 0 and c.bit_length() > width:
+                 raise BoolectorException(
+                           "Value of constant {} (bit width {}) exceeds bit "\\
+'''
+
 
 class BtorInstaller(SolverInstaller):
 
@@ -59,6 +74,14 @@ class BtorInstaller(SolverInstaller):
         SolverInstaller.untar(os.path.join(self.base_dir, self.archive_name),
                               self.extract_path)
 
+        # Patching for cython 3.8
+        with NamedTemporaryFile() as f:
+            f.write(CYTHON_PATCH.encode())
+            f.flush()
+            f.seek(0)
+            SolverInstaller.run("patch src/api/python/pyboolector.pyx -i %s" % f.name,
+                                directory=self.extract_path)
+
         # Build lingeling
         SolverInstaller.run("bash ./contrib/setup-lingeling.sh",
                             directory=self.extract_path)

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129}/pysmt/parsing.py

@@ -126,9 +126,6 @@ class HRLexer(Lexer):
             Rule(r"\"(.*?)\"", self.string_constant, True), # String Constant
             Rule(r"BV\{(\d+)\}", self.bv_type, True),# BV Type
             Rule(r"(Array\{)", OpenArrayTypeTok(), False),# Array Type
-            Rule(r"(Int)", IntTypeTok(), False),# Int Type
-            Rule(r"(Real)", RealTypeTok(), False),# Real Type
-            Rule(r"(Bool)", BoolTypeTok(), False),# Bool Type
             Rule(r"(&)", InfixOpAdapter(self.AndOrBVAnd, 40), False),# conjunction
             Rule(r"(\|)", InfixOpAdapter(self.OrOrBVOr, 30), False),# disjunction
             Rule(r"(!)", UnaryOpAdapter(self.NotOrBVNot, 50), False),# negation
@@ -168,19 +165,10 @@ class HRLexer(Lexer):
             Rule(r"(:=)", ArrStore(), False),# ArrStore
             Rule(r"(::)", InfixOpAdapter(self.mgr.BVConcat, 90), False),# BVXor
             Rule(r"(:)", ExprElse(), False),# colon
-            Rule(r"(False)", Constant(self.mgr.FALSE()), False), # False
-            Rule(r"(True)", Constant(self.mgr.TRUE()), False),# True
             Rule(r"(,)", ExprComma(), False),# comma
             Rule(r"(\.)", ExprDot(), False),# dot
-            Rule(r"(xor)", InfixOpAdapter(self.mgr.BVXor, 10), False),# BVXor
-            Rule(r"(ROR)", InfixOpAdapter(self.BVHack(self.mgr.BVRor), 90), False),# BVRor
-            Rule(r"(ROL)", InfixOpAdapter(self.BVHack(self.mgr.BVRol), 90), False),# BVRol
-            Rule(r"(ZEXT)", InfixOpAdapter(self.BVHack(self.mgr.BVZExt), 90), False),# BVZext
-            Rule(r"(SEXT)", InfixOpAdapter(self.BVHack(self.mgr.BVSExt), 90), False),# BVSext
-            Rule(r"(bvcomp)", InfixOpAdapter(self.mgr.BVComp, 90), False),#
-            Rule(r"(forall)", Quantifier(self.mgr.ForAll, 20), False),#
-            Rule(r"(exists)", Quantifier(self.mgr.Exists, 20), False),#
-            Rule(r"(ToReal)", UnaryOpAdapter(self.mgr.ToReal, 100), False),#
+            Rule(r"(forall\s+)", Quantifier(self.mgr.ForAll, 20), False),#
+            Rule(r"(exists\s+)", Quantifier(self.mgr.Exists, 20), False),#
             Rule(r"(str\.len)", FunctionCallAdapter(self.mgr.StrLength, 100), False), # str_length
             Rule(r"(str\.\+\+)", FunctionCallAdapter(self.mgr.StrConcat, 100), False), # str_concat
             Rule(r"(str\.at)", FunctionCallAdapter(self.mgr.StrCharAt, 100), False), # str_charat
@@ -192,14 +180,28 @@ class HRLexer(Lexer):
             Rule(r"(str\.suffixof)", FunctionCallAdapter(self.mgr.StrSuffixOf, 100), False), # str_suffixof
             Rule(r"(str\.to\.int)", FunctionCallAdapter(self.mgr.StrToInt, 100), False), # str_to_int
             Rule(r"(int\.to\.str)", FunctionCallAdapter(self.mgr.IntToStr, 100), False), # int_to_str
-            Rule(r"(bv2nat)", UnaryOpAdapter(self.mgr.BVToNatural, 100), False),#
             Rule(r"'(.*?)'", self.identifier, True), # quoted identifiers
             Rule(r"([A-Za-z_][A-Za-z0-9_]*)", self.identifier, True),# identifiers
             Rule(r"(.)", self.lexing_error, True), # input error
         ]
-
         self.rules += hr_rules
 
+        self._identifier_map = {
+            "False": Constant(self.mgr.FALSE()), # False
+            "True": Constant(self.mgr.TRUE()),# True
+            "xor": InfixOpAdapter(self.mgr.BVXor, 10),# BVXor
+            "bv2nat": UnaryOpAdapter(self.mgr.BVToNatural, 100),#
+            "bvcomp": InfixOpAdapter(self.mgr.BVComp, 90),#
+            "ROR": InfixOpAdapter(self.BVHack(self.mgr.BVRor), 90),# BVRor
+            "ROL": InfixOpAdapter(self.BVHack(self.mgr.BVRol), 90),# BVRol
+            "ZEXT": InfixOpAdapter(self.BVHack(self.mgr.BVZExt), 90),# BVZext
+            "SEXT": InfixOpAdapter(self.BVHack(self.mgr.BVSExt), 90),# BVSext
+            "ToReal": UnaryOpAdapter(self.mgr.ToReal, 100),#
+            "Int": IntTypeTok(),# Int Type
+            "Real": RealTypeTok(),# Real Type
+            "Bool": BoolTypeTok(),# Bool Type
+        }
+
         self.compile()
 
     def bv_type(self, read):
@@ -219,6 +221,9 @@ class HRLexer(Lexer):
         return Constant(self.mgr.String(read))
 
     def identifier(self, read):
+        res = self._identifier_map.get(read, None)
+        if res is not None:
+            return res
         return Identifier(read, env=self.env)
 
     def UMinusOrBvNeg(self, x):

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129}/pysmt/shortcuts.py

@@ -233,6 +233,31 @@ def Ite(iff, left, right):
     return get_env().formula_manager.Ite(iff, left, right)
 
 
+def Abs(formula):
+    r"""Returns the absolute value of the formula.
+    
+    This is implemented as If(formula > 0, formula, -formula).
+    Works for both integer and real values.
+    
+    :param formula: The formula to compute the absolute value of
+    :returns: The absolute value of the formula
+    :raises: ValueError if the formula type is not integer or real
+    """
+    # Get the type of the formula to determine the appropriate zero value
+    formula_type = get_type(formula)
+    
+    # Create a zero value of the same type as the formula
+    if formula_type == types.INT:
+        zero = Int(0)
+    elif formula_type == types.REAL:
+        zero = Real(0)
+    else:
+        # Raise an error for unsupported types
+        raise ValueError(f"Abs function only supports integer and real types, got {formula_type}")
+    
+    return Ite(GT(formula, zero), formula, Minus(zero, formula))
+
+
 def Symbol(name, typename=types.BOOL):
     """Returns a symbol with the given name and type.
 

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129}/pysmt/solvers/btor.py

@@ -15,12 +15,29 @@
 #   See the License for the specific language governing permissions and
 #   limitations under the License.
 #
+from enum import Enum
+import inspect
 from math import log, ceil
 
 from pysmt.exceptions import SolverAPINotFound
 
 try:
     import pyboolector
+
+    # Fixing interface for cython 3.1+
+    #
+    # Cython 3.1 changed the way enums are handled: the enum values are no
+    # longer added to the global namespace, while the documentation of btor
+    # relied on the old behavior of cython, Here, we first collect all the nums
+    # in the module and then we add their enumerands to the pyboolector module,
+    # making it work on either cython 3.0 or 3.1.
+    enums = []
+    for x in pyboolector.__dict__.values():
+        if inspect.isclass(x) and issubclass(x, Enum):
+            enums.append(x)
+    for x in enums:
+        pyboolector.__dict__.update(x.__members__)
+
 except ImportError:
     raise SolverAPINotFound
 

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129}/pysmt/test/test_formula.py

@@ -19,7 +19,7 @@ import pysmt
 
 from pysmt.typing import BOOL, REAL, INT, FunctionType, BV8, BVType
 from pysmt.shortcuts import Symbol, is_sat, Not, Implies, GT, Plus, Int, Real
-from pysmt.shortcuts import Minus, Times, Xor, And, Or, TRUE, Iff, FALSE, Ite
+from pysmt.shortcuts import Minus, Times, Xor, And, Or, TRUE, Iff, FALSE, Ite, Abs
 from pysmt.shortcuts import Equals
 from pysmt.shortcuts import get_env
 from pysmt.environment import Environment
@@ -317,6 +317,38 @@ class TestFormulaManager(TestCase):
         inv = self.mgr.Real(Fraction(1) / self.rconst.constant_value())
         self.assertEqual(n, self.mgr.Times(self.s, inv))
 
+    def test_abs_shortcut(self):
+        # Test with integer
+        abs_int = Abs(self.p)
+        
+        # Verify the structure of the Abs node
+        self.assertTrue(abs_int.is_ite())
+        self.assertTrue(abs_int.arg(0).is_lt())  # GT is converted to LT with inverted args
+        self.assertEqual(abs_int.arg(0).arg(0), Int(0))  # First arg is 0
+        self.assertEqual(abs_int.arg(0).arg(1), self.p)  # Second arg is p
+        self.assertEqual(abs_int.arg(1), self.p)
+        self.assertTrue(abs_int.arg(2).is_minus())
+        self.assertEqual(abs_int.arg(2).arg(0), Int(0))
+        self.assertEqual(abs_int.arg(2).arg(1), self.p)
+        
+        # Test with real
+        abs_real = Abs(self.r)
+        
+        # Verify the structure of the Abs node
+        self.assertTrue(abs_real.is_ite())
+        self.assertTrue(abs_real.arg(0).is_lt())  # GT is converted to LT with inverted args
+        self.assertEqual(abs_real.arg(0).arg(0), Real(0))  # First arg is 0
+        self.assertEqual(abs_real.arg(0).arg(1), self.r)  # Second arg is r
+        self.assertEqual(abs_real.arg(1), self.r)
+        self.assertTrue(abs_real.arg(2).is_minus())
+        self.assertEqual(abs_real.arg(2).arg(0), Real(0))
+        self.assertEqual(abs_real.arg(2).arg(1), self.r)
+        
+        # Test with boolean (should raise ValueError)
+        bool_var = Symbol("z", BOOL)
+        with self.assertRaises(ValueError):
+            Abs(bool_var)
+
     def test_equals(self):
         n = self.mgr.Equals(self.real_expr, self.real_expr)
         self.assertIsNotNone(n)

{PySMT-0.9.7.dev120 → PySMT-0.9.7.dev129}/pysmt/test/test_hr_parsing.py

@@ -18,8 +18,10 @@
 import unittest
 import tempfile, os
 
+from fractions import Fraction
+
 from pysmt.parsing import HRParser, parse
-from pysmt.shortcuts import Iff, Symbol, And, Or, LE, Real, Plus, Minus
+from pysmt.shortcuts import Iff, Symbol, And, Or, LE, GT, Real, Plus, Minus
 from pysmt.test.examples import get_example_formulae
 from pysmt.exceptions import NoSolverAvailableError
 from pysmt.test import TestCase
@@ -76,6 +78,7 @@ class TestHRParser(TestCase):
         p = HRParser()
         for (f, _, _, _) in get_example_formulae():
             s = f.serialize()
+            print(s)
             res = p.parse(s)
             check = (res == f)
             if not check:
@@ -84,6 +87,12 @@ class TestHRParser(TestCase):
                 except NoSolverAvailableError:
                     pass
 
+    def test_substring(self):
+        p = HRParser()
+        s=Symbol('Intake_Pressure', REAL)
+        res = p.parse('(Intake_Pressure > 91.988 & Intake_Pressure<=116.892)')
+        print(res.serialize())
+        self.assertEqual(res, And(GT(s, Real(Fraction("91.988"))), LE(s, Real(Fraction("116.892")))))
 
 
 if __name__ == '__main__':