PySMT 0.9.7.dev433__tar.gz → 0.9.7.dev439__tar.gz

{pysmt-0.9.7.dev433/PySMT.egg-info → pysmt-0.9.7.dev439}/PKG-INFO

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

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439/PySMT.egg-info}/PKG-INFO

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

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/__init__.py

@@ -19,7 +19,7 @@
 from typing import Tuple, Union
 
 
-VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 433)
+VERSION: Union[Tuple[int, int, int], Tuple[int, int, int, str, int]] = (0, 9, 7, "dev", 439)
 
 # Try to provide human-readable version of latest commit for dev versions
 # E.g. v0.5.1-4-g49a49f2-wip

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/factory.py

@@ -615,7 +615,7 @@ class Factory(object):
                 atoms = formula.get_atoms()
                 res = []
                 for a in atoms:
-                    fv = a.get_free_variables()
+                    fv = self.environment.fvo.get_free_variables(a)
                     if any(v in model for v in fv):
                         if solver.get_value(a).is_true():
                             res.append(a)

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/optimization/goal.py

@@ -16,12 +16,12 @@
 #   limitations under the License.
 #
 
-from pysmt.environment import get_env
+from pysmt.environment import Environment, get_env
 from pysmt.exceptions import PysmtValueError
 from pysmt.oracles import get_logic
 from pysmt.logics import Logic, LIA, LRA, BV
 from pysmt.fnode import FNode
-from typing import List, Tuple, Type, cast
+from typing import List, Optional, Tuple, Type, cast
 
 
 class Goal(object):
@@ -51,6 +51,23 @@ class Goal(object):
         ```
     """
 
+    # The class-level default keeps subclasses that do not call Goal.__init__
+    # working against the global environment, as they did before.
+    _env: Optional[Environment] = None
+
+    def __init__(self, env: Optional[Environment]=None):
+        """
+        :param env: The environment the goal lives in; the global one if None
+        """
+        self._env = env if env is not None else get_env()
+
+    @property
+    def env(self) -> Environment:
+        """The environment this goal lives in."""
+        if self._env is None:
+            self._env = get_env()
+        return self._env
+
     def is_maximization_goal(self) -> bool:
         return False
 
@@ -67,7 +84,7 @@ class Goal(object):
         return False
 
     def get_logic(self) -> Logic:
-        logic = get_logic(self.term())
+        logic = get_logic(self.term(), env=self.env)
         if logic <= LIA:
             return LIA
         elif logic <= LRA:
@@ -99,11 +116,14 @@ class MaximizationGoal(Goal):
     Warning: some Optimizer may not support this goal
     """
 
-    def __init__(self, formula: FNode, signed: bool = False):
+    def __init__(self, formula: FNode, signed: bool = False,
+                 env: Optional[Environment]=None):
         """
         :param formula: The target formula
         :type  formula: FNode
+        :param env: The environment the goal lives in; the global one if None
         """
+        Goal.__init__(self, env)
         self.formula = formula
         self._bv_signed = signed
 
@@ -127,11 +147,14 @@ class MinimizationGoal(Goal):
     Warning: some Optimizer may not support this goal
     """
 
-    def __init__(self, formula: FNode, sign: bool = False):
+    def __init__(self, formula: FNode, sign: bool = False,
+                 env: Optional[Environment]=None):
         """
         :param formula: The target formula
         :type  formula: FNode
+        :param env: The environment the goal lives in; the global one if None
         """
+        Goal.__init__(self, env)
         self.formula = formula
         self._bv_signed = sign
 
@@ -156,19 +179,22 @@ class MinMaxGoal(MinimizationGoal):
     Warning: some Optimizer may not support this goal
     """
 
-    def __init__(self, terms: List[FNode], sign: bool = False):
+    def __init__(self, terms: List[FNode], sign: bool = False,
+                 env: Optional[Environment]=None):
         """
         :param terms: List of FNode
+        :param env: The environment the goal lives in; the global one if None
         """
+        if env is None:
+            env = get_env()
         if len(terms) == 0:
             raise PysmtValueError("MinMaxGoal requires at least one term")
-        elif terms[0].get_type().is_bv_type():
-            formula = get_env().formula_manager.MaxBV(sign, terms)
+        elif env.stc.get_type(terms[0]).is_bv_type():
+            formula = env.formula_manager.MaxBV(sign, terms)
         else:
-            formula = get_env().formula_manager.Max(terms)
-        MinimizationGoal.__init__(self, formula)
+            formula = env.formula_manager.Max(terms)
+        MinimizationGoal.__init__(self, formula, sign, env=env)
         self.terms = terms
-        self._bv_signed = sign
 
     def is_minmax_goal(self) -> bool:
         return True
@@ -185,19 +211,22 @@ class MaxMinGoal(MaximizationGoal):
     Warning: some Optimizer may not support this goal
     """
 
-    def __init__(self, terms: List[FNode], sign: bool = False):
+    def __init__(self, terms: List[FNode], sign: bool = False,
+                 env: Optional[Environment]=None):
         """
         :param terms: List of FNode
+        :param env: The environment the goal lives in; the global one if None
         """
+        if env is None:
+            env = get_env()
         if len(terms) == 0:
             raise PysmtValueError("MaxMinGoal requires at least one term")
-        elif terms[0].get_type().is_bv_type():
-            formula = get_env().formula_manager.MinBV(sign, terms)
+        elif env.stc.get_type(terms[0]).is_bv_type():
+            formula = env.formula_manager.MinBV(sign, terms)
         else:
-            formula = get_env().formula_manager.Min(terms)
-        MaximizationGoal.__init__(self, formula)
+            formula = env.formula_manager.Min(terms)
+        MaximizationGoal.__init__(self, formula, sign, env=env)
         self.terms = terms
-        self._bv_signed = sign
 
     def is_maxmin_goal(self) -> bool:
         return True
@@ -211,27 +240,33 @@ class MaxSMTGoal(Goal):
     MaxSMT goal common to all solvers.
     """
 
-    def __init__(self, real_weights: bool=True):
-        """Accepts soft clauses and the relative weights"""
+    def __init__(self, real_weights: bool=True,
+                 env: Optional[Environment]=None):
+        """Accepts soft clauses and the relative weights
+
+        :param env: The environment the goal lives in; the global one if None
+        """
+        Goal.__init__(self, env)
         self.soft: List[Tuple[FNode, FNode]] = []
         self._bv_signed = False
         self._real_weights = real_weights
 
     def add_soft_clause(self, clause: FNode, weight: FNode):
         """Accepts soft clauses and the relative weights"""
-        mgr = get_env().formula_manager
-        if not clause.get_type().is_bool_type():
+        mgr = self.env.formula_manager
+        get_type = self.env.stc.get_type
+        if not get_type(clause).is_bool_type():
             raise PysmtValueError(
                 "Clause '%s' has to be a boolean formula; given type is: '%s'" %
-                (str(clause), str(clause.get_type()))
+                (str(clause), str(get_type(clause)))
             )
         if isinstance(weight, FNode):
             if not weight.is_constant():
                 raise PysmtValueError(
                     "Weight '%s' has to be a constant; given type is: '%s'" %
-                    (str(weight), str(weight.get_type()))
+                    (str(weight), str(get_type(weight)))
                 )
-            weight_type = weight.get_type()
+            weight_type = get_type(weight)
             if not weight_type.is_real_type() and not weight_type.is_int_type():
                 raise PysmtValueError(
                     "Weight '%s' has to be a real or integer type; given type is: '%s'" %
@@ -240,7 +275,7 @@ class MaxSMTGoal(Goal):
             if weight_type.is_real_type() and not self._real_weights:
                 raise PysmtValueError(
                     "Weight '%s' has to be an integer because the flag 'real_weights' is set to 'False'; given type is: '%s'" %
-                    (str(weight), str(weight.get_type()))
+                    (str(weight), str(weight_type))
                 )
             if weight_type.is_int_type() and self._real_weights:
                 weight = mgr.Real(cast(int, weight.constant_value()))
@@ -260,7 +295,7 @@ class MaxSMTGoal(Goal):
 
     def term(self) -> FNode:
         formula = None
-        mgr = get_env().formula_manager
+        mgr = self.env.formula_manager
         zero = mgr.Real(0) if self.real_weights() else mgr.Int(0)
         for (c, w) in self.soft:
             if formula is not None:

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/optimization/optimizer.py

@@ -21,7 +21,7 @@ import warnings
 from pysmt.solvers.solver import Solver
 from pysmt.exceptions import PysmtValueError, GoalNotSupportedError
 from pysmt.optimization.goal import Goal, MaxSMTGoal, MinimizationGoal, MaximizationGoal
-from pysmt.typing import INT, REAL, BVType, _BVType
+from pysmt.typing import INT, REAL, _BVType
 from pysmt.logics import LIA, LRA, BV, QF_LIRA, Logic
 from pysmt.environment import Environment
 from pysmt.fnode import FNode
@@ -118,7 +118,7 @@ class Optimizer(Solver):
         elif otype.is_real_type():
             return REAL
         elif otype.is_bv_type():
-            return BVType(otype.width)
+            return self.environment.type_manager.BVType(otype.width)
         else:
             raise PysmtValueError("Invalid optimization function type: %s" % otype)
 
@@ -263,7 +263,7 @@ class OptSearchInterval(OptComparationFunctions):
 
         lower, upper = None, None
         if not goal.is_maxsmt_goal():
-            term_type = goal.term().get_type()
+            term_type = environment.stc.get_type(goal.term())
             # For bit-vectors, start lower and upper bounds to their width limit
             if term_type.is_bv_type():
                 assert isinstance(term_type, _BVType)
@@ -320,7 +320,7 @@ class OptSearchInterval(OptComparationFunctions):
             l = self._upper - (cast(Union[int, Fraction], abs(self._upper)) + 1)
         elif self._lower is not None and self._upper is None:
             u = self._lower + cast(Union[int, Fraction], abs(self._lower)) + 1
-        term_type = self._obj.term().get_type()
+        term_type = self.environment.stc.get_type(self._obj.term())
         assert l is not None and u is not None
         if term_type.is_int_type() or term_type.is_bv_type():
             pivot = (l + u) // 2
@@ -417,8 +417,9 @@ class OptPareto(OptComparationFunctions):
         return correct_operator(self.goal.term(), self.val)
 
 
-def _warn_diverge_real_goal(goal: Goal):
-    if (goal.is_maximization_goal() or goal.is_minimization_goal()) and goal.term().get_type().is_real_type():
+def _warn_diverge_real_goal(goal: Goal, env: Environment):
+    if (goal.is_maximization_goal() or goal.is_minimization_goal()) and \
+       env.stc.get_type(goal.term()).is_real_type():
         warnings.warn("Algorithm might diverge on Real minimization/maximization objectives.")
 
 
@@ -488,9 +489,9 @@ class ExternalOptimizerMixin(Optimizer):
         """
         Core algorithm for the optimization process.
         Based on the strategy, it will either perform a linear or binary search"""
-        _warn_diverge_real_goal(goal)
+        _warn_diverge_real_goal(goal, self.environment)
         if goal.is_maxsmt_goal():
-            goal = MaximizationGoal(goal.term())
+            goal = MaximizationGoal(goal.term(), env=self.environment)
         model = None
         client_data = self._setup()
 
@@ -528,7 +529,7 @@ class ExternalOptimizerMixin(Optimizer):
         objs = [OptPareto(goal, self.environment) for goal in goals]
 
         for g in goals:
-            _warn_diverge_real_goal(g)
+            _warn_diverge_real_goal(g, self.environment)
 
         terminated = False
         client_data = self._setup()

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/oracles.py

@@ -276,7 +276,8 @@ class TheoryOracle(walkers.DagWalker):
             theory_out = theory_out.combine(t)
         # Check for non-linear counting the arguments having at least
         # one free variable
-        if sum(1 for x in formula.args() if x.get_free_variables()) > 1:
+        if sum(1 for x in formula.args()
+               if self.env.fvo.get_free_variables(x)) > 1:
             theory_out = theory_out.set_linear(False)
         # This is  not in DL anymore
         theory_out = theory_out.set_difference_logic(False)
@@ -324,9 +325,10 @@ class TheoryOracle(walkers.DagWalker):
         for t in args[1:]:
             theory_out = theory_out.combine(t)
         # Check for non-linear
+        get_free_vars = self.env.fvo.get_free_variables
         left, right = formula.args()
-        if len(left.get_free_variables()) != 0 and \
-           len(right.get_free_variables()) != 0:
+        if len(get_free_vars(left)) != 0 and \
+           len(get_free_vars(right)) != 0:
             theory_out = theory_out.set_linear(False)
         elif formula.arg(1).is_zero():
             # DivBy0 is non-linear

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/parsing.py

@@ -306,7 +306,7 @@ class BVTypeTok(GrammarSymbol):
         self.width = width
 
     def nud(self, parser):
-        return types.BVType(self.width)
+        return parser.env.type_manager.BVType(self.width)
 
 class IntTypeTok(GrammarSymbol):
     def nud(self, parser):
@@ -369,7 +369,7 @@ class OpenArrayTypeTok(GrammarSymbol):
             parser.expect(ClosePar, ")")
             return parser.mgr.Array(idx_type, default)
         else:
-            return types.ArrayType(idx_type, el_type)
+            return parser.env.type_manager.ArrayType(idx_type, el_type)
 
 
 class OpenPar(GrammarSymbol):

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/rewritings.py

@@ -40,6 +40,7 @@ class CNFizer(DagWalker):
         DagWalker.__init__(self, environment)
 
         self.mgr = self.env.formula_manager
+        self.simplify = self.env.simplifier.simplify
         self._introduced_variables: Dict[FNode, FNode] = {}
 
     def _key_var(self, formula: FNode) -> FNode:
@@ -72,7 +73,7 @@ class CNFizer(DagWalker):
                     # Prune clauses as ~tl -> l1 v ... v lk
                     simp = None
                     break
-                elif lit == self.mgr.Not(tl).simplify():
+                elif lit == self.simplify(self.mgr.Not(tl)):
                     # Simplify tl -> l1 v ... v lk
                     # into l1 v ... v lk
                     continue
@@ -111,7 +112,7 @@ class CNFizer(DagWalker):
             return args[0]
 
         k = self._key_var(formula)
-        _cnf = [frozenset([k] + [self.mgr.Not(a).simplify() for a,_ in args])]
+        _cnf = [frozenset([k] + [self.simplify(self.mgr.Not(a)) for a,_ in args])]
         for a,c in args:
             _cnf.append(frozenset([a, self.mgr.Not(k)]))
             for clause in c:
@@ -136,15 +137,15 @@ class CNFizer(DagWalker):
         elif a.is_false():
             return self.mgr.TRUE(), CNFizer.TRUE_CNF
         else:
-            return self.mgr.Not(a).simplify(), _cnf
+            return self.simplify(self.mgr.Not(a)), _cnf
 
     def walk_implies(self, formula,  args, **kwargs):
         a, cnf_a = args[0]
         b, cnf_b = args[1]
 
         k = self._key_var(formula)
-        not_a = self.mgr.Not(a).simplify()
-        not_b = self.mgr.Not(b).simplify()
+        not_a = self.simplify(self.mgr.Not(a))
+        not_b = self.simplify(self.mgr.Not(b))
         not_k = self.mgr.Not(k)
 
         return k, (cnf_a | cnf_b | frozenset([frozenset([not_a, b, not_k]),
@@ -156,8 +157,8 @@ class CNFizer(DagWalker):
         b, cnf_b = args[1]
 
         k = self._key_var(formula)
-        not_a = self.mgr.Not(a).simplify()
-        not_b = self.mgr.Not(b).simplify()
+        not_a = self.simplify(self.mgr.Not(a))
+        not_b = self.simplify(self.mgr.Not(b))
         not_k = self.mgr.Not(k)
 
         return k, (cnf_a | cnf_b | frozenset([frozenset([not_a, not_b, k]),
@@ -184,9 +185,9 @@ class CNFizer(DagWalker):
         else:
             (i,cnf_i),(t,cnf_t),(e,cnf_e) = args
             k = self._key_var(formula)
-            not_i = self.mgr.Not(i).simplify()
-            not_t = self.mgr.Not(t).simplify()
-            not_e = self.mgr.Not(e).simplify()
+            not_i = self.simplify(self.mgr.Not(i))
+            not_t = self.simplify(self.mgr.Not(t))
+            not_e = self.simplify(self.mgr.Not(e))
             not_k = self.mgr.Not(k)
 
             return k, (cnf_i | cnf_t | cnf_e |
@@ -198,7 +199,7 @@ class CNFizer(DagWalker):
     @handles(op.THEORY_OPERATORS)
     def walk_theory_op(self, formula, **kwargs):
         #pylint: disable=unused-argument
-        if formula.get_type().is_bool_type():
+        if self.env.stc.get_type(formula).is_bool_type():
             return formula, CNFizer.TRUE_CNF
         return CNFizer.THEORY_PLACEHOLDER
 
@@ -305,7 +306,7 @@ class PolarityCNFizer(CNFizer):
         if pol:
             _cnf.extend(frozenset([a, self.mgr.Not(k)]) for a, _ in args)
         else:
-            _cnf.extend([frozenset([k] + [self.mgr.Not(a).simplify() for a, _ in args])])
+            _cnf.extend([frozenset([k] + [self.simplify(self.mgr.Not(a)) for a, _ in args])])
 
         return k, frozenset(_cnf)
 
@@ -318,7 +319,7 @@ class PolarityCNFizer(CNFizer):
         if pol:
             _cnf.extend([frozenset([self.mgr.Not(k)] + [a for a, _ in args])])
         else:
-            _cnf.extend(frozenset([k, self.mgr.Not(a).simplify()]) for a, c in args)
+            _cnf.extend(frozenset([k, self.simplify(self.mgr.Not(a))]) for a, c in args)
 
         return k, frozenset(_cnf)
 
@@ -327,8 +328,8 @@ class PolarityCNFizer(CNFizer):
         b, cnf_b = args[1]
 
         k = self._key_var(formula)
-        not_a = self.mgr.Not(a).simplify()
-        not_b = self.mgr.Not(b).simplify()
+        not_a = self.simplify(self.mgr.Not(a))
+        not_b = self.simplify(self.mgr.Not(b))
         not_k = self.mgr.Not(k)
         _cnf = []
         if pol:
@@ -345,8 +346,8 @@ class PolarityCNFizer(CNFizer):
         _, cnf_bn = args[3]
 
         k = self._key_var(formula)
-        not_a = self.mgr.Not(a).simplify()
-        not_b = self.mgr.Not(b).simplify()
+        not_a = self.simplify(self.mgr.Not(a))
+        not_b = self.simplify(self.mgr.Not(b))
         not_k = self.mgr.Not(k)
 
         return k, (cnf_ap | cnf_an | cnf_bp | cnf_bn
@@ -360,9 +361,9 @@ class PolarityCNFizer(CNFizer):
             return CNFizer.THEORY_PLACEHOLDER
         (i, cnf_ip), (_, cnf_in), (t, cnf_t), (e, cnf_e) = args
         k = self._key_var(formula)
-        not_i = self.mgr.Not(i).simplify()
-        not_t = self.mgr.Not(t).simplify()
-        not_e = self.mgr.Not(e).simplify()
+        not_i = self.simplify(self.mgr.Not(i))
+        not_t = self.simplify(self.mgr.Not(t))
+        not_e = self.simplify(self.mgr.Not(e))
         not_k = self.mgr.Not(k)
 
         _cnf = []
@@ -590,7 +591,7 @@ class PrenexNormalizer(DagWalker):
         # matrix. If we find a quantifier over a variable in this set
         # we need to alpha-rename before adding the quantifier to the
         # final list and accumulate the matrix.
-        reserved = formula.get_free_variables()
+        reserved = self.env.fvo.get_free_variables(formula)
 
         # We iterate to each argument, each could have a sequence of
         # quantifiers that we need to merge
@@ -603,7 +604,7 @@ class PrenexNormalizer(DagWalker):
                     # we need alpha-renaming: prepare the substitution map
                     sub = dict((v,self.mgr.FreshSymbol(v.symbol_type()))
                                for v in needs_rename)
-                    sub_matrix = sub_matrix.substitute(sub)
+                    sub_matrix = self.env.substituter.substitute(sub_matrix, sub)
 
                     # The new variables for this quantifiers will be
                     # its old variables, minus the one needing
@@ -1109,7 +1110,7 @@ def propagate_toplevel(formula: FNode, env: Optional["pysmt.environment.Environm
             else:
                 sigma[k] = v
 
-    res = formula.substitute(sigma)
+    res = env.substituter.substitute(formula, sigma)
     if preserve_equivalence:
         res = mgr.And(res, mgr.And([mgr.Equals(k, sigma[k]) for k in sigma]))
-    return res.simplify() if do_simplify else res
+    return env.simplifier.simplify(res) if do_simplify else res

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/simplifier.py

@@ -265,7 +265,8 @@ class Simplifier(pysmt.walkers.DagWalker):
         assert len(args) == 1
         sf = args[0]
 
-        varset = set(formula.quantifier_vars()).intersection(sf.get_free_variables())
+        varset = set(formula.quantifier_vars()).intersection(
+            self.env.fvo.get_free_variables(sf))
 
         if len(varset) == 0:
             return sf
@@ -276,7 +277,8 @@ class Simplifier(pysmt.walkers.DagWalker):
         assert len(args) == 1
         sf = args[0]
 
-        varset = set(formula.quantifier_vars()).intersection(sf.get_free_variables())
+        varset = set(formula.quantifier_vars()).intersection(
+            self.env.fvo.get_free_variables(sf))
 
         if len(varset) == 0:
             return sf
@@ -1151,7 +1153,7 @@ class BddSimplifier(Simplifier):
     def abstract_and_simplify(self, formula: FNode) -> FNode:
         abs_formula = self.walk(formula)
         abs_res = self.back(self.convert(abs_formula))
-        res = abs_res.substitute(self.ba_map)
+        res = self.env.substituter.substitute(abs_res, self.ba_map)
         return res
 
     @handles(op.RELATIONS)

{pysmt-0.9.7.dev433 → pysmt-0.9.7.dev439}/pysmt/smtlib/parser/parser.py

@@ -304,6 +304,40 @@ class Tokenizer(object):
 # EOC Tokenizer
 
 
+#
+# Helpers to expand the SMT-LIB n-ary applications of operators that pySMT
+# only exposes as binary ones. The SMT-LIB standard attaches one of the
+# attributes :left-assoc, :right-assoc, :chainable or :pairwise to every such
+# operator; the three functions below implement the first three (:pairwise is
+# already covered by mgr.AllDifferent).
+#
+# In all cases a single argument is accepted and behaves as the identity (or
+# as `true` for the chainable operators, where the conjunction is empty).
+# The standard requires at least two arguments, but pySMT has always been
+# lenient about this for `and`, `or`, `+` and `*`, and we keep it uniform.
+#
+
+def _left_assoc(operator: Callable) -> Callable:
+    """(op a b c) is expanded to (op (op a b) c)"""
+    def res(*args):
+        return functools.reduce(operator, args)
+    return res
+
+
+def _right_assoc(operator: Callable) -> Callable:
+    """(op a b c) is expanded to (op a (op b c))"""
+    def res(*args):
+        return functools.reduce(lambda acc, x: operator(x, acc), reversed(args))
+    return res
+
+
+def _chainable(mgr: FormulaManager, operator: Callable) -> Callable:
+    """(op a b c) is expanded to (and (op a b) (op b c))"""
+    def res(*args):
+        return mgr.And([operator(l, r) for l, r in zip(args, args[1:])])
+    return res
+
+
 class SmtLibParser(object):
     """Parse an SmtLib file and builds an SmtLibScript object.
     The main function is get_script (and its wrapper
@@ -373,22 +407,27 @@ class SmtLibParser(object):
             "!": self._enter_annotation,
             "exists": self._enter_quantifier,
             "forall": self._enter_quantifier,
+            # '+' and '*' are :left-assoc, but pySMT builds them n-ary
+            # natively; the other n-ary operators are folded, see the
+            # _left_assoc/_right_assoc/_chainable helpers above.
             '+': self._operator_adapter(self.Plus),
             '-': self._operator_adapter(self._minus_or_uminus),
             '*': self._operator_adapter(self.Times),
-            '/': self._operator_adapter(self._division),
+            '/': self._operator_adapter(_left_assoc(self._division)),
+            'div': self._operator_adapter(_left_assoc(mgr.Div)),
             'pow': self._operator_adapter(mgr.Pow),
-            '>': self._operator_adapter(self.GT),
-            '<': self._operator_adapter(self.LT),
-            '>=': self._operator_adapter(self.GE),
-            '<=': self._operator_adapter(self.LE),
-            '=': self._operator_adapter(self._equals_or_iff),
+            '>': self._operator_adapter(_chainable(mgr, self.GT)),
+            '<': self._operator_adapter(_chainable(mgr, self.LT)),
+            '>=': self._operator_adapter(_chainable(mgr, self.GE)),
+            '<=': self._operator_adapter(_chainable(mgr, self.LE)),
+            '=': self._operator_adapter(_chainable(mgr, self._equals_or_iff)),
             'not': self._operator_adapter(mgr.Not),
             'and': self._operator_adapter(mgr.And),
             'or': self._operator_adapter(mgr.Or),
-            'xor': self._operator_adapter(mgr.Xor),
-            '=>': self._operator_adapter(mgr.Implies),
-            '<->': self._operator_adapter(mgr.Iff),
+            'xor': self._operator_adapter(_left_assoc(mgr.Xor)),
+            '=>': self._operator_adapter(_right_assoc(mgr.Implies)),
+            # '<->' is a pySMT extension: treated as :left-assoc, like 'xor'
+            '<->': self._operator_adapter(_left_assoc(mgr.Iff)),
             'ite': self._operator_adapter(self.Ite),
             'distinct': self._operator_adapter(self.AllDifferent),
             'to_real': self._operator_adapter(mgr.ToReal),
@@ -407,12 +446,12 @@ class SmtLibParser(object):
             'bvlshr': self._operator_adapter(mgr.BVLShr),
             'bvsub': self._operator_adapter(mgr.BVSub),
             'bvult': self._operator_adapter(mgr.BVULT),
-            'bvxor': self._operator_adapter(mgr.BVXor),
+            'bvxor': self._operator_adapter(_left_assoc(mgr.BVXor)),
             '_': self._smtlib_underscore,
             # Extended Functions
             'bvnand': self._operator_adapter(mgr.BVNand),
             'bvnor': self._operator_adapter(mgr.BVNor),
-            'bvxnor': self._operator_adapter(mgr.BVXnor),
+            'bvxnor': self._operator_adapter(_left_assoc(mgr.BVXnor)),
             'bvcomp': self._operator_adapter(mgr.BVComp),
             'bvsdiv': self._operator_adapter(mgr.BVSDiv),
             'bvsrem': self._operator_adapter(mgr.BVSRem),
@@ -492,7 +531,7 @@ class SmtLibParser(object):
         self.cache.update({'false': mgr.FALSE(), 'true': mgr.TRUE()})
 
     def _minus_or_uminus(self, *args) -> FNode:
-        """Utility function that handles both unary and binary minus"""
+        """Utility function that handles unary and n-ary minus"""
         mgr = self.env.formula_manager
         if len(args) == 1:
             lty = self.get_type(args[0])
@@ -506,9 +545,8 @@ class SmtLibParser(object):
                     return mgr.Real(-1 * args[0].constant_value())
                 mult = mgr.Real(-1)
             return mgr.Times(mult, args[0])
-        else:
-            assert len(args) == 2
-            return self.Minus(args[0], args[1])
+        # '-' is :left-assoc: (- a b c) is (- (- a b) c)
+        return functools.reduce(self.Minus, args)
 
     def _enter_smtlib_as(self, stack: List[List[Union[Callable, FNode, Any]]], tokens: Tokenizer, key: str):
         """Utility function that handles 'as' that is a special function in SMTLIB"""
@@ -1581,9 +1619,11 @@ class SmtLibZ3Parser(SmtLibParser):
         self.interpreted['ubv_to_int'] = self._operator_adapter(mgr.BVToNatural)
 
     def _ext_rotate_left(self, x, y):
-        return self.env.formula_manager.BVRol(x, y.simplify().constant_value())
+        amount = self.env.simplifier.simplify(y).constant_value()
+        return self.env.formula_manager.BVRol(x, amount)
 
     def _ext_rotate_right(self, x, y):
-        return self.env.formula_manager.BVRor(x, y.simplify().constant_value())
+        amount = self.env.simplifier.simplify(y).constant_value()
+        return self.env.formula_manager.BVRor(x, amount)
 
 # EOC SmtLibZ3Parser