PySMT 0.9.7.dev436__tar.gz → 0.9.7.dev439__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev436
+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.dev436 → pysmt-0.9.7.dev439/PySMT.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PySMT
-Version: 0.9.7.dev436
+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.dev436 → 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", 436)
+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.dev436 → 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.dev436 → 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.dev436 → 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.dev436 → 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.dev436 → 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.dev436 → 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.dev436 → 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.dev436 → pysmt-0.9.7.dev439}/pysmt/smtlib/parser/parser.py

@@ -1619,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

{pysmt-0.9.7.dev436 → pysmt-0.9.7.dev439}/pysmt/smtlib/printers.py

@@ -19,7 +19,6 @@ from io import StringIO
 from typing import Callable, List, Optional, Set, TextIO, Union
 
 import pysmt.operators as op
-from pysmt.environment import get_env
 from pysmt.walkers import TreeWalker, DagWalker, handles
 from pysmt.utils import quote
 from pysmt.fnode import FNode
@@ -59,11 +58,11 @@ def write_annotations_dag(f: Callable) -> Callable:
 
 class SmtPrinter(TreeWalker):
 
-    def __init__(self, stream: TextIO, annotations=None):
-        TreeWalker.__init__(self)
+    def __init__(self, stream: TextIO, annotations=None, env=None):
+        TreeWalker.__init__(self, env=env)
         self.stream = stream
         self.write = self.stream.write
-        self.mgr = get_env().formula_manager
+        self.mgr = self.env.formula_manager
         self.annotations = annotations
 
     def printer(self, f):
@@ -314,7 +313,8 @@ class SmtPrinter(TreeWalker):
         for _ in range(len(assign)):
             self.write("(store ")
 
-        self.write("((as const %s) " % formula.get_type().as_smtlib(False))
+        self.write("((as const %s) " %
+                   self.env.stc.get_type(formula).as_smtlib(False))
         yield formula.array_value_default()
         self.write(")")
 
@@ -328,15 +328,15 @@ class SmtPrinter(TreeWalker):
 
 class SmtDagPrinter(DagWalker):
 
-    def __init__(self, stream: TextIO, template: str=".def_%d", annotations: Optional[Annotations]=None):
-        DagWalker.__init__(self, invalidate_memoization=True)
+    def __init__(self, stream: TextIO, template: str=".def_%d", annotations: Optional[Annotations]=None, env=None):
+        DagWalker.__init__(self, env=env, invalidate_memoization=True)
         self.stream = stream
         self.write = self.stream.write
         self.openings = 0
         self.name_seed = 0
         self.template = template
         self.names: Optional[Set[str]] = None
-        self.mgr = get_env().formula_manager
+        self.mgr = self.env.formula_manager
         self.annotations = annotations
 
     def _push_with_children_to_stack(self, formula: FNode, **kwargs):
@@ -358,7 +358,8 @@ class SmtDagPrinter(DagWalker):
     def printer(self, f: FNode):
         self.openings = 0
         self.name_seed = 0
-        self.names = set(quote(x.symbol_name()) for x in f.get_free_variables())
+        self.names = set(quote(x.symbol_name())
+                         for x in self.env.fvo.get_free_variables(f))
 
         key = self.walk(f)
         self.write(key)
@@ -575,7 +576,7 @@ class SmtDagPrinter(DagWalker):
             self.write(" %s)" % s.symbol_type().as_smtlib(False))
         self.write(") ")
 
-        subprinter = SmtDagPrinter(self.stream)
+        subprinter = SmtDagPrinter(self.stream, env=self.env)
         subprinter.printer(formula.arg(0))
 
         self.write(")))")
@@ -695,7 +696,8 @@ class SmtDagPrinter(DagWalker):
         for _ in range((len(args) - 1) // 2):
             self.write("(store ")
 
-        self.write("((as const %s) " % formula.get_type().as_smtlib(False))
+        self.write("((as const %s) " %
+                   self.env.stc.get_type(formula).as_smtlib(False))
         self.write(args[0])
         self.write(")")
 
@@ -709,7 +711,7 @@ class SmtDagPrinter(DagWalker):
         return sym
 
 
-def to_smtlib(formula: FNode, daggify: bool=True) -> str:
+def to_smtlib(formula: FNode, daggify: bool=True, env=None) -> str:
     """Returns a Smt-Lib string representation of the formula.
 
     The daggify parameter can be used to switch from a linear-size
@@ -722,9 +724,9 @@ def to_smtlib(formula: FNode, daggify: bool=True) -> str:
     buf = StringIO()
     p: Union[SmtDagPrinter, SmtPrinter]
     if daggify:
-        p = SmtDagPrinter(buf)
+        p = SmtDagPrinter(buf, env=env)
     else:
-        p = SmtPrinter(buf)
+        p = SmtPrinter(buf, env=env)
     p.printer(formula)
     res = buf.getvalue()
     buf.close()