def test_00_new_node_type(self):
self.assertEqual(len(CUSTOM_NODE_TYPES), 0, "Initially there should be no custom types")
idx = new_node_type()
self.assertIsNotNone(idx)
with self.assertRaises(AssertionError):
new_node_type(idx)
n = new_node_type(idx+100)
self.assertEqual(n, idx+100)
def test_00_new_node_type(self):
self.assertEqual(len(CUSTOM_NODE_TYPES), 0, "Initially there should be no custom types")
idx = new_node_type()
self.assertIsNotNone(idx)
with self.assertRaises(AssertionError):
new_node_type(idx)
n = new_node_type(idx+100)
self.assertEqual(n, idx+100)
def test_00_new_node_type(self):
self.assertNotIn(199, CUSTOM_NODE_TYPES,
"Initially there should be no custom node with id 199")
idx = new_node_type(node_id=199)
self.assertIsNotNone(idx)
with self.assertRaises(AssertionError):
new_node_type(idx)
n = new_node_type(idx+100)
self.assertEqual(n, idx+100)
def test_00_new_node_type(self):
self.assertNotIn(
199, CUSTOM_NODE_TYPES,
"Initially there should be no custom node with id 199")
idx = new_node_type(node_id=199)
self.assertIsNotNone(idx)
with self.assertRaises(AssertionError):
new_node_type(idx)
n = new_node_type(idx + 100)
self.assertEqual(n, idx + 100)
def test_01_dwf(self):
# Ad-hoc method to handle printing of the new node
def hrprinter_walk_XOR(self, formula):
self.stream.write("(")
yield formula.arg(0)
self.stream.write(" *+* ")
yield formula.arg(1)
self.stream.write(")")
# Shortcuts for function in env
add_dwf = get_env().add_dynamic_walker_function
create_node = get_env().formula_manager.create_node
# Define the new node type and register the walkers in the env
XOR = new_node_type()
add_dwf(XOR, SimpleTypeChecker, SimpleTypeChecker.walk_bool_to_bool)
add_dwf(XOR, HRPrinter, hrprinter_walk_XOR)
# Create a test node (This implicitely calls the Type-checker)
x = Symbol("x")
f1 = create_node(node_type=XOR, args=(x,x))
self.assertIsNotNone(f1)
# String conversion should use the function defined above.
s_f1 = str(f1)
self.assertEqual(s_f1, "(x *+* x)")
# We did not define an implementation for the Simplifier
with self.assertRaises(UnsupportedOperatorError):
f1.simplify()
def test_01_dwf(self):
# Ad-hoc method to handle printing of the new node
def hrprinter_walk_XOR(self, formula):
self.stream.write("(")
self.walk(formula.arg(0))
self.stream.write(" *+* ")
self.walk(formula.arg(1))
self.stream.write(")")
return
# Shortcuts for function in env
add_dwf = get_env().add_dynamic_walker_function
create_node = get_env().formula_manager.create_node
# Define the new node type and register the walkers in the env
XOR = new_node_type()
add_dwf(XOR, SimpleTypeChecker, SimpleTypeChecker.walk_bool_to_bool)
add_dwf(XOR, HRPrinter, hrprinter_walk_XOR)
# Create a test node (This implicitely calls the Type-checker)
x = Symbol("x")
f1 = create_node(node_type=XOR, args=(x,x))
self.assertIsNotNone(f1)
# String conversion should use the function defined above.
s_f1 = str(f1)
self.assertEqual(s_f1, "(x *+* x)")
# We did not define an implementation for the Simplifier
with self.assertRaises(NotImplementedError):
f1.simplify()
def test_conversion_error(self):
from pysmt.type_checker import SimpleTypeChecker
add_dwf = get_env().add_dynamic_walker_function
create_node = get_env().formula_manager.create_node
# Create a node that is not supported by any solver
idx = op.new_node_type()
x = Symbol("x")
add_dwf(idx, SimpleTypeChecker, SimpleTypeChecker.walk_bool_to_bool)
invalid_node = create_node(idx, args=(x, x))
for sname in get_env().factory.all_solvers(logic=QF_BOOL):
with self.assertRaises(ConvertExpressionError):
is_sat(invalid_node, solver_name=sname, logic=QF_BOOL)
def test_conversion_error(self):
from pysmt.type_checker import SimpleTypeChecker
add_dwf = get_env().add_dynamic_walker_function
create_node = get_env().formula_manager.create_node
# Create a node that is not supported by any solver
idx = op.new_node_type()
x = Symbol("x")
add_dwf(idx, SimpleTypeChecker, SimpleTypeChecker.walk_bool_to_bool)
invalid_node = create_node(idx, args=(x,x))
for sname in get_env().factory.all_solvers(logic=QF_BOOL):
with self.assertRaises(ConvertExpressionError):
is_sat(invalid_node, solver_name=sname, logic=QF_BOOL)
def test_walker_new_operators_complete(self):
walkerA = IdentityDagWalker(env=self.env)
idx = op.new_node_type(node_str="fancy_new_node")
walkerB = IdentityDagWalker(env=self.env)
with self.assertRaises(KeyError):
walkerA.functions[idx]
self.assertEqual(walkerB.functions[idx], walkerB.walk_error)
# Use a mixin to handle the node type
class FancyNewNodeWalkerMixin(object):
def walk_fancy_new_node(self, args, **kwargs):
raise UnsupportedOperatorError
class IdentityDagWalker2(IdentityDagWalker, FancyNewNodeWalkerMixin):
pass
walkerC = IdentityDagWalker2(env=self.env)
self.assertEqual(walkerC.functions[idx], walkerC.walk_fancy_new_node)
def test_02_all_types(self):
old_types_set = set(all_types())
new_t = new_node_type()
new_types_set = set(all_types())
self.assertEqual(new_types_set - old_types_set, set([new_t]))
import re
from typing import Set
from pysmt.shortcuts import TRUE, FALSE, And, Or, Symbol, BV, EqualsOrIff, Implies, get_env
from pysmt.typing import BOOL, BVType
from pysmt.parsing import parse, HRParser, HRLexer, PrattParser, Rule, UnaryOpAdapter, InfixOpAdapter
import pysmt.environment
import pysmt.formula
from cosa.encoders.formulae import StringParser
from cosa.utils.logger import Logger
from pysmt.operators import new_node_type
LTL_X = new_node_type(node_str="LTL_X")
LTL_F = new_node_type(node_str="LTL_F")
LTL_G = new_node_type(node_str="LTL_G")
LTL_U = new_node_type(node_str="LTL_U")
LTL_R = new_node_type(node_str="LTL_R")
LTL_O = new_node_type(node_str="LTL_O")
LTL_H = new_node_type(node_str="LTL_H")
ALL_LTL = (LTL_X, LTL_F, LTL_G, LTL_U, LTL_R, LTL_O, LTL_H)
ASSIGN = new_node_type(node_str="ASSIGN")
DEFINE = new_node_type(node_str="DEFINE")
def Assign(left, right):
return get_env().formula_manager.Assign(left, right)
# Linear Temporal Logic
#
# This example shows how to extend pySMT in order to support
# additional operators. This can be achieved without modifying the
# pySMT source code.
#
# We use LTL as an example, and we define some basic operators.
#
# First we need to define the new operators, or "node types"
from pysmt.operators import new_node_type
LTL_X = new_node_type(node_str="LTL_X")
LTL_Y = new_node_type(node_str="LTL_Y")
LTL_Z = new_node_type(node_str="LTL_Z")
LTL_F = new_node_type(node_str="LTL_F")
LTL_G = new_node_type(node_str="LTL_G")
LTL_O = new_node_type(node_str="LTL_O")
LTL_H = new_node_type(node_str="LTL_H")
LTL_U = new_node_type(node_str="LTL_U")
LTL_S = new_node_type(node_str="LTL_S")
ALL_LTL = (LTL_X, LTL_Y, LTL_Z,
LTL_F, LTL_G, LTL_O, LTL_H,
LTL_U, LTL_S)
# The FormulaManager needs to be extended to be able to use these
# operators. Notice that additional checks, and some simplifications
# can be performed at construction time. We keep this example simple.
import pysmt.environment
import pysmt.formula
#adding operators
from pysmt.operators import new_node_type
SIN = new_node_type(node_str="sin")
COS = new_node_type(node_str="cos")
ALL_TRANS = (SIN, COS)
#Extending FormulaManager
import pysmt.environment
import pysmt.formula
class ExtendedFormulaManager(pysmt.formula.FormulaManager):
def Sin(self, arg):
return self.create_node(node_type=SIN, args=(arg, ))
def Cos(self, arg):
return self.create_node(node_type=COS, args=(arg, ))
#updating some walkers with first approach
from pysmt.type_checker import SimpleTypeChecker
SimpleTypeChecker.set_handler(SimpleTypeChecker.walk_real_to_real, *ALL_TRANS)
from pysmt.oracles import FreeVarsOracle, QuantifierOracle
FreeVarsOracle.set_handler(FreeVarsOracle.walk_simple_args, *ALL_TRANS)
QuantifierOracle.set_handler(QuantifierOracle.walk_all, *ALL_TRANS)
from pysmt.rewritings import PrenexNormalizer
PrenexNormalizer.set_handler(PrenexNormalizer.walk_theory_op, *ALL_TRANS)
def test_new_node_type(self):
old = list(all_types())
idx = new_node_type(node_str="xor")
self.assertIsNotNone(idx)
self.assertNotIn(idx, old)
with self.assertRaises(AssertionError):
new_node_type(idx)
XOR = idx
# Ad-hoc method to handle printing of the new node
def hrprinter_walk_xor(self, formula):
self.stream.write("(")
yield formula.arg(0)
self.stream.write(" *+* ")
yield formula.arg(1)
self.stream.write(")")
SimpleTypeChecker.walk_xor = SimpleTypeChecker.walk_bool_to_bool
HRPrinter.walk_xor = hrprinter_walk_xor
# Reset the env to recreate the TypeChecker and HRPrinter
reset_env()
# Shortcuts for function in env
create_node = get_env().formula_manager.create_node
# Create a test node (This implicitly calls the Type-checker)
x = Symbol("x")
f1 = create_node(node_type=XOR, args=(x,x))
self.assertIsNotNone(f1)
# String conversion should use the function defined above.
s_f1 = str(f1)
self.assertEqual(s_f1, "(x *+* x)")
# We did not define an implementation for the Simplifier
with self.assertRaises(UnsupportedOperatorError):
f1.simplify()
# Clean-up
del SimpleTypeChecker.walk_xor
del HRPrinter.walk_xor
class MySimpleTypeChecker(SimpleTypeChecker):
walk_xor = SimpleTypeChecker.walk_bool_to_bool
class MyHRPrinter(HRPrinter):
def walk_xor(self, formula):
return self.walk_nary(formula, " *+* ")
class MyHRSerializer(HRSerializer):
PrinterClass = MyHRPrinter
class MyEnv(Environment):
TypeCheckerClass = MySimpleTypeChecker
HRSerializerClass = MyHRSerializer
with MyEnv() as myenv:
create_node = myenv.formula_manager.create_node
# Create a test node (This implicitly calls the Type-checker)
x = Symbol("x")
f1 = create_node(node_type=XOR, args=(x,x))
self.assertIsNotNone(f1)
# String conversion should use the function defined above.
s_f1 = str(f1)
self.assertEqual(s_f1, "(x *+* x)")
# We did not define an implementation for the Simplifier
with self.assertRaises(UnsupportedOperatorError):
f1.simplify()
return
# Linear Temporal Logic # # This example shows how to extend pySMT in order to support # additional operators. This can be achieved without modifying the # pySMT source code. # # We use LTL as an example, and we define some basic operators. # # First we need to define the new operators, or "node types" from pysmt.operators import new_node_type LTL_X = new_node_type(node_str="LTL_X") LTL_Y = new_node_type(node_str="LTL_Y") LTL_Z = new_node_type(node_str="LTL_Z") LTL_F = new_node_type(node_str="LTL_F") LTL_G = new_node_type(node_str="LTL_G") LTL_O = new_node_type(node_str="LTL_O") LTL_H = new_node_type(node_str="LTL_H") LTL_U = new_node_type(node_str="LTL_U") LTL_S = new_node_type(node_str="LTL_S") ALL_LTL = (LTL_X, LTL_Y, LTL_Z, LTL_F, LTL_G, LTL_O, LTL_H, LTL_U, LTL_S) # The FormulaManager needs to be extended to be able to use these # operators. Notice that additional checks, and some simplifications # can be performed at construction time. We keep this example simple. import pysmt.environment import pysmt.formula class FormulaManager(pysmt.formula.FormulaManager):
def test_02_all_types(self):
old_types_set = set(all_types())
new_t = new_node_type()
new_types_set = set(all_types())
self.assertEqual(new_types_set - old_types_set, set([new_t]))
from pysmt.typing import BOOL, BVType
from pysmt.parsing import parse, HRParser, HRLexer, PrattParser, Rule, UnaryOpAdapter, InfixOpAdapter
import pysmt.environment
import pysmt.formula
from cosa.representation import HTS, TS
from cosa.encoders.formulae import StringParser
from cosa.utils.logger import Logger
from cosa.utils.formula_mngm import get_free_variables, substitute
from cosa.problem import VerificationType
from cosa.utils.formula_mngm import quote_names
from pysmt.operators import new_node_type
LTL_X = new_node_type(node_str="LTL_X")
LTL_F = new_node_type(node_str="LTL_F")
LTL_G = new_node_type(node_str="LTL_G")
LTL_U = new_node_type(node_str="LTL_U")
LTL_R = new_node_type(node_str="LTL_R")
LTL_O = new_node_type(node_str="LTL_O")
LTL_H = new_node_type(node_str="LTL_H")
ALL_LTL = (LTL_X, LTL_F, LTL_G, LTL_U, LTL_R, LTL_O, LTL_H)
class FormulaManager(pysmt.formula.FormulaManager):
"""Extension of FormulaManager to handle LTL Operators."""
def X(self, formula):
return self.create_node(node_type=LTL_X, args=(formula, ))
def F(self, formula):
