def test_unfiy_tricky():
v1 = qvar()
v2 = qvar()
g1 = qfun(v1, v2)
g2 = qfun(v2, qobj())
assert_equal(unify([g1, g2]), qfun(qobj(), qobj()))
def test_unify_types2(self):
x1 = qterm.Variable('x', qvar())
x2 = qterm.Variable('x', qvar())
assert x1 != x2
x1u, x2u = unify_types([x1, x2])
assert x1u == x2u
def print_separation(self, term):
superset, predicate = match_separation(term)
bound = term_builder.build_variable('x', qtype.qvar())
pretty_predicate = substitution.beta_reduce(term_builder.unary_op(predicate, bound))
return '{ %s in %s | %s }' % (self.print_atom(bound),
self.print_term(superset),
self.print_combination(pretty_predicate))
def setup_class(cls):
cls.for_all = Constant('for_all', qfun(qfun(qobj(), qbool()), qbool()))
cls.exists = Constant('exists', qfun(qfun(qobj(), qbool()), qbool()))
cls.not_ = Constant('not', qfun(qbool(), qbool()))
eqvar = qvar()
cls.equals = Constant('=', qfun(eqvar, qfun(eqvar, qbool())))
extensions = [
Type(qbool, 'bool'),
Type(qobj, 'obj'),
Binder(cls.for_all),
Binder(cls.exists),
Operator(cls.not_, 1, 'right', 100),
Operator(cls.equals, 2, 'left', 200),
]
cls.parser = parser.Parser(Syntax(extensions), term_builder)
def build_combination(self, operator, operand):
if qtype.is_variable(operator.qtype):
operator = operator.substitute_type(qtype.qfun(operand.qtype, qtype.qvar()), operator.qtype)
if operator.qtype.name != "fun":
raise TypeError("operators must be functions")
unifier = qtype_unifier.TypeUnifier()
unifier.unify(operator.qtype.args[0], operand.qtype)
for key, value in unifier.get_substitutions().iteritems():
operator = operator.substitute_type(value, key)
operand = operand.substitute_type(value, key)
operator, operand = unify_types([operator, operand])
if operator.qtype.args[0] != operand.qtype:
raise TypeError("operand type must match operator argument type")
return qterm.Combination(operator, operand)
def test_unify():
assert_raises(UnificationError, unify, [qobj(), qbool()])
assert_equal(unify([qobj(), qobj()]), qobj())
assert_equal(unify([qvar(), qobj()]), qobj())
assert_equal(unify([qobj(), qvar()]), qobj())
v1 = qvar()
v2 = qvar()
uni = unify([v1, v2])
assert_true(uni == v1 or uni == v2)
f1 = qfun(qobj(), qbool())
f2 = qfun(qobj(), qobj())
f3 = qfun(qvar(), qobj())
f4 = qfun(qvar(), qvar())
assert_raises(UnificationError, unify, [f1, f2])
assert_equal(unify([f2, f3]), f2)
assert_equal(unify([f2, f4]), f2)
assert_equal(unify([f3, f4]), f3)
def test_unify_types(self):
f1 = qterm.Variable('f', qfun(qvar(), qvar()))
f2 = qterm.Variable('f', qfun(qvar(), qvar()))
assert f1 != f2
f1u, f2u = unify_types([f1, f2])
assert f1u == f2u
# this is a particularly tricky situation
v1 = qvar()
v2 = qvar()
g1 = qterm.Variable('g', qfun(v1, v2))
g2 = qterm.Variable('g', qfun(v2, qobj()))
assert g1 != g2
g1u, g2u = unify_types([g1, g2])
assert g1u == g2u
def p_atomic_variable_type(self, p):
"atomic_type : QMARK IDENT"
if p[2] not in self.type_context:
self.type_context[p[2]] = qtype.qvar()
p[0] = self.type_context[p[2]]
def p_atom(self, p):
"atom : IDENT"
p[0] = self.term_builder.build_variable(p[1], qtype.qvar())
