def get_diagram_concept_domain(sig, diagram):
"""
sig is an ivy_logic.Sig object
diagram is a formula
"""
concepts = OrderedDict()
concepts['nodes'] = []
concepts['node_labels'] = []
concepts['edges'] = []
# add equality concept
X = Var('X', TopSort())
Y = Var('Y', TopSort())
concepts['='] = Concept([X, Y], Eq(X, Y))
# add concepts from relations and constants in the signature and
# in the diagram
if sig is not None:
sig_symbols = frozenset(sig.symbols.values())
else:
sig_symbols = frozenset()
for c in sorted(sig_symbols | used_constants(diagram)):
assert type(c) is Const
if first_order_sort(c.sort):
# first order constant, add unary equality concept
X = Var('X', c.sort)
name = '{}:{}'.format(c.name, c.sort)
concepts[name] = Concept([X], Eq(X,c))
concepts['nodes'].append(name)
elif type(c.sort) is FunctionSort and c.sort.arity == 1:
# add unary concept and label
X = Var('X', c.sort.domain[0])
name = '{}'.format(c.name)
concepts[name] = Concept([X], c(X))
elif type(c.sort) is FunctionSort and c.sort.arity == 2:
# add binary concept and edge
X = Var('X', c.sort.domain[0])
Y = Var('Y', c.sort.domain[1])
name = '{}'.format(c.name)
concepts[name] = Concept([X, Y], c(X, Y))
elif type(c.sort) is FunctionSort and c.sort.arity == 3:
# add ternary concept
X = Var('X', c.sort.domain[0])
Y = Var('Y', c.sort.domain[1])
Z = Var('Z', c.sort.domain[2])
name = '{}'.format(c.name)
concepts[name] = Concept([X, Y, Z], c(X, Y, Z))
else:
# skip other symbols
pass
return ConceptDomain(concepts, get_standard_combiners(), get_standard_combinations())
def get_initial_concept_domain(sig):
"""
sig is an ivy_logic.Sig object
"""
concepts = OrderedDict()
concepts['nodes'] = []
concepts['node_labels'] = []
concepts['edges'] = []
# add sort concepts
for s in sorted(sig.sorts.values()):
X = Var('X', s)
concepts[s.name] = Concept([X], Eq(X,X))
concepts['nodes'].append(s.name)
# add equality concept
X = Var('X', TopSort())
Y = Var('Y', TopSort())
concepts['='] = Concept([X, Y], Eq(X, Y))
# add concepts from relations
for c in sorted(sig.symbols.values()):
assert type(c) is Const
if first_order_sort(c.sort):
# first order constant, add unary equality concept
X = Var('X', c.sort)
name = '={}'.format(c.name)
concepts[name] = Concept([X], Eq(X,c))
elif type(c.sort) is FunctionSort and c.sort.arity == 1:
# add unary concept and label
X = Var('X', c.sort.domain[0])
name = '{}'.format(c.name)
concepts[name] = Concept([X], c(X))
elif type(c.sort) is FunctionSort and c.sort.arity == 2:
# add binary concept and edge
X = Var('X', c.sort.domain[0])
Y = Var('Y', c.sort.domain[1])
name = '{}'.format(c.name)
concepts[name] = Concept([X, Y], c(X, Y))
elif type(c.sort) is FunctionSort and c.sort.arity == 3:
# add ternary concept
X = Var('X', c.sort.domain[0])
Y = Var('Y', c.sort.domain[1])
Z = Var('Z', c.sort.domain[2])
name = '{}'.format(c.name)
concepts[name] = Concept([X, Y, Z], c(X, Y, Z))
else:
# skip other symbols
pass
return ConceptDomain(concepts, get_standard_combiners(), get_standard_combinations())
def _materialize_node(self, concept_name):
"""
Materialize a node, returns the witness constant
"""
concept = self.domain.concepts[concept_name]
assert concept.arity == 1
sort = concept.variables[0].sort
assert sort != TopSort()
witnesses = self._get_witnesses(concept_name)
if len(witnesses) > 0:
c = witnesses[0]
else:
c = Const(self._fresh_const_name(), sort)
# TODO: maybe we shouldn't split here, and create the concepts explicitly
X = Var('X', c.sort)
name = '={}'.format(c.name)
self.domain.concepts[name] = Concept(name, [X], Eq(X, c))
self.domain.split(concept_name, name)
self.suppose(concept(c))
return c
return result
if __name__ == '__main__':
S = UninterpretedSort('S')
X, Y, Z = (Var(n, S) for n in ['X', 'Y', 'Z'])
BinRel = FunctionSort(S, S, Boolean)
leq = Const('leq', BinRel)
transitive1 = ForAll((X, Y, Z),
Implies(And(leq(X, Y), leq(Y, Z)), leq(X, Z)))
transitive2 = ForAll((X, Y, Z),
Or(Not(leq(X, Y)), Not(leq(Y, Z)), leq(X, Z)))
transitive3 = Not(
Exists((X, Y, Z), And(leq(X, Y), leq(Y, Z), Not(leq(X, Z)))))
antisymmetric = ForAll((X, Y),
Implies(And(leq(X, Y), leq(Y, X), true), Eq(Y, X)))
print z3_implies(transitive1, transitive2)
print z3_implies(transitive2, transitive3)
print z3_implies(transitive3, transitive1)
print z3_implies(transitive3, antisymmetric)
print
print z3_implies(true, Iff(transitive1, transitive2))
print
x, y = (Const(n, S) for n in ['x', 'y'])
b = Const('b', Boolean)
print z3_implies(b, Eq(Ite(b, x, y), x))
print z3_implies(Not(b), Eq(Ite(b, x, y), y))
print z3_implies(Not(Eq(x, y)), Iff(Eq(Ite(b, x, y), x), b))
elif ((type(t) is ForAll and type(t.body) is And)
or (type(t) is Exists and type(t.body) is Or)):
return normalize_quantifiers(
type(t.body)(*(type(t)(t.variables, x) for x in t.body)))
elif type(t) in (ForAll, Exists):
return type(t)(free_variables(t.body) & frozenset(t.variables),
normalize_quantifiers(t.body))
else:
assert False, type(t)
def is_tautology_equality(t):
"""Returns True if t is Eq(x,x) for some x"""
return type(t) is Eq and t.t1 == t.t2
if __name__ == '__main__':
from logic import *
s1 = UninterpretedSort('s1')
s2 = UninterpretedSort('s2')
X1 = Var('X', s1)
X2 = Var('X', s2)
f = ForAll([X1], Eq(X2, X2))
assert free_variables(f) == {X2}
assert free_variables(f, by_name=True) == set()
assert free_variables(f.body) == {X2}
assert free_variables(f.body, by_name=True) == {'X'}
def is_witness(c):
try:
return z3_implies(f, Eq(x, c))
except SortError:
return False
def get_structure_concept_domain(state, sig=None):
"""
state is an ivy_interp.State with a .universe
sig is an ivy_logic.Sig object
"""
concepts = OrderedDict()
concepts['nodes'] = []
concepts['node_labels'] = []
# add equality concept
X = Var('X', TopSort())
Y = Var('Y', TopSort())
concepts['='] = Concept([X, Y], Eq(X, Y))
# add nodes for universe elements
elements = [uc for s in state.universe for uc in state.universe[s]]
for uc in sorted(elements):
# add unary equality concept
X = Var('X', uc.sort)
name = uc.name
if str(uc.sort) not in name:
name += ':{}'.format(uc.sort)
concepts[name] = Concept([X], Eq(X,uc))
concepts['nodes'].append(name)
# # find which symbols are equal to which universe constant
# equals = dict(
# (uc, [c for c in symbols
# if c != uc and
# c.sort == s and
# z3_implies(state_formula, Eq(c, uc))])
# for s in state.universe
# for uc in state.universe[s]
# )
# add concepts for relations and constants
state_formula = state.clauses.to_formula()
symbols = used_constants(state_formula)
if sig is not None:
symbols = symbols | frozenset(sig.symbols.values())
symbols = symbols - frozenset(elements)
symbols = sorted(symbols)
for c in symbols:
assert type(c) is Const
if first_order_sort(c.sort):
# first order constant, add unary equality concept
X = Var('X', c.sort)
name = '={}'.format(c.name)
concepts[name] = Concept([X], Eq(X,c))
elif type(c.sort) is FunctionSort and c.sort.arity == 1:
# add unary concept and label
X = Var('X', c.sort.domain[0])
name = '{}'.format(c.name)
concepts[name] = Concept([X], c(X))
elif type(c.sort) is FunctionSort and c.sort.arity == 2:
# add binary concept and edge
X = Var('X', c.sort.domain[0])
Y = Var('Y', c.sort.domain[1])
name = '{}'.format(c.name)
concepts[name] = Concept([X, Y], c(X, Y))
elif type(c.sort) is FunctionSort and c.sort.arity == 3:
# add ternary concept
X = Var('X', c.sort.domain[0])
Y = Var('Y', c.sort.domain[1])
Z = Var('Z', c.sort.domain[2])
name = '{}'.format(c.name)
concepts[name] = Concept([X, Y, Z], c(X, Y, Z))
else:
# skip other symbols
pass
return ConceptDomain(concepts, get_standard_combiners(), get_standard_combinations())
def get_standard_combiners():
T = TopSort()
UnaryRelation = FunctionSort(T, Boolean)
BinaryRelation = FunctionSort(T, T, Boolean)
X, Y, Z = (Var(n, T) for n in ['X', 'Y', 'Z'])
U = Var('U', UnaryRelation)
U1 = Var('U1', UnaryRelation)
U2 = Var('U2', UnaryRelation)
B = Var('B', BinaryRelation)
B1 = Var('B1', BinaryRelation)
B2 = Var('B2', BinaryRelation)
result = OrderedDict()
result['none'] = ConceptCombiner([U], Not(Exists([X], U(X))))
result['at_least_one'] = ConceptCombiner([U], Exists([X], U(X)))
result['at_most_one'] = ConceptCombiner([U], ForAll([X,Y], Implies(And(U(X), U(Y)), Eq(X,Y))))
result['node_necessarily'] = ConceptCombiner(
[U1, U2],
ForAll([X], Implies(U1(X), U2(X))),
)
result['node_necessarily_not'] = ConceptCombiner(
[U1, U2],
ForAll([X], Implies(U1(X), Not(U2(X)))),
)
result['mutually_exclusive'] = ConceptCombiner(
[U1, U2],
ForAll([X, Y], Not(And(U1(X), U2(Y))))
)
result['all_to_all'] = ConceptCombiner(
[B, U1, U2],
ForAll([X,Y], Implies(And(U1(X), U2(Y)), B(X,Y)))
)
result['none_to_none'] = ConceptCombiner(
[B, U1, U2],
ForAll([X,Y], Implies(And(U1(X), U2(Y)), Not(B(X,Y))))
)
result['total'] = ConceptCombiner(
[B, U1, U2],
ForAll([X], Implies(U1(X), Exists([Y], And(U2(Y), B(X,Y)))))
)
result['functional'] = ConceptCombiner(
[B, U1, U2],
ForAll([X, Y, Z], Implies(And(U1(X), U2(Y), U2(Z), B(X,Y), B(X,Z)), Eq(Y,Z)))
)
result['surjective'] = ConceptCombiner(
[B, U1, U2],
ForAll([Y], Implies(U2(Y), Exists([X], And(U1(X), B(X,Y)))))
)
result['injective'] = ConceptCombiner(
[B, U1, U2],
ForAll([X, Y, Z], Implies(And(U1(X), U1(Y), U2(Z), B(X,Z), B(Y,Z)), Eq(X,Y)))
)
result['node_info'] = ['none', 'at_least_one', 'at_most_one']
if False:
# this just slows us down, and it's not clear it's needed
# later this should be made customizable by the user
result['edge_info'] = ['all_to_all', 'none_to_none', 'total',
'functional', 'surjective', 'injective']
else:
result['edge_info'] = ['all_to_all', 'none_to_none']
result['node_label'] = ['node_necessarily', 'node_necessarily_not']
return result
def infer_sorts(t, env=None):
"""
Infer the sort of term t in environment env.
env maps symbol names to sort variables.
The result is a pair: (s, tt) where s is a sort or sort variable
with the sort of t in env, and tt is a closure that, when called,
will concretize t according to inferred sort information at its
call time.
If env is not None, it must contain all the free variables and
constants used in t.
"""
if env is None:
names = free_variables(t,
by_name=True).union(x.name
for x in used_constants(t))
env = dict((name, SortVar()) for name in names)
if type(t) in (Var, Const):
if is_polymorphic(t): # each instance can have different sort
s = insert_sortvars(t.sort, {})
else:
s = env[t.name]
unify(s, t.sort)
return s, lambda: type(t)(t.name, convert_from_sortvars(s))
elif type(t) is Apply:
func_s, func_t = infer_sorts(t.func, env)
xys = [infer_sorts(tt, env) for tt in t.terms]
terms_s = [x for x, y in xys]
terms_t = [y for x, y in xys]
sorts = terms_s + [SortVar()]
unify(func_s, FunctionSort(*sorts))
return sorts[-1], lambda: Apply(func_t(), *(x() for x in terms_t))
elif type(t) is Eq:
s1, t1 = infer_sorts(t.t1, env)
s2, t2 = infer_sorts(t.t2, env)
unify(s1, s2)
return Boolean, lambda: Eq(t1(), t2())
elif type(t) is Ite:
s_cond, t_cond = infer_sorts(t.cond, env)
s_then, t_then = infer_sorts(t.t_then, env)
s_else, t_else = infer_sorts(t.t_else, env)
unify(s_cond, Boolean)
unify(s_then, s_else)
return s_then, lambda: Ite(t_cond(), t_then(), t_else())
elif type(t) in (Not, And, Or, Implies, Iff):
xys = [infer_sorts(tt, env) for tt in t]
terms_s = [x for x, y in xys]
terms_t = [y for x, y in xys]
for s in terms_s:
unify(s, Boolean)
return Boolean, lambda: type(t)(*[x() for x in terms_t])
elif type(t) in (ForAll, Exists):
# create a copy of the environment and shadow that quantified
# variables
env = env.copy()
env.update((v.name, SortVar()) for v in t.variables)
vars_t = [infer_sorts(v, env)[1] for v in t.variables]
body_s, body_t = infer_sorts(t.body, env)
unify(body_s, Boolean)
return Boolean, lambda: type(t)(
[x() for x in vars_t],
body_t(),
)
elif hasattr(t, 'clone'):
xys = [infer_sorts(tt, env) for tt in t.args]
terms_t = [y for x, y in xys]
return TopSort(), lambda: t.clone([x() for x in terms_t])
else:
assert False, type(t)
UnaryRelation = FunctionSort(S, Boolean)
BinaryRelation = FunctionSort(S, S, Boolean)
X, Y, Z = (Var(n, S) for n in ['X', 'Y', 'Z'])
U = Var('U', UnaryRelation)
U1 = Var('U1', UnaryRelation)
U2 = Var('U2', UnaryRelation)
B = Var('B', BinaryRelation)
B1 = Var('B1', BinaryRelation)
B2 = Var('B2', BinaryRelation)
nstar = Const('nstar', BinaryRelation)
x = Const('x', S)
y = Const('y', S)
c11 = Concept('xy', [X], And(Eq(x, X), Eq(y, X)))
c10 = Concept('x', [X], And(Eq(x, X), Not(Eq(y, X))))
c01 = Concept('y', [X], And(Not(Eq(x, X)), Eq(y, X)))
c00 = Concept('other', [X], And(Not(Eq(x, X)), Not(Eq(y, X))))
cnstar = Concept('nstar', [X, Y], nstar(X, Y))
cnplus = Concept('nplus', [X, Y], And(nstar(X, Y), Not(Eq(X, Y))))
notexists = ConceptCombiner([U], Not(Exists([X], U(X))))
exists = ConceptCombiner([U], Exists([X], U(X)))
singleton = ConceptCombiner([U],
ForAll([X, Y],
Implies(And(U(X), U(Y)), Eq(X, Y))))
all_to_all = ConceptCombiner([U1, U2, B],
ForAll([X, Y],
Implies(And(U1(X), U2(Y)), B(X, Y))))