def _preprocess_(cls, variables, formula):
variables = tuple(variables)
if set(variables) != free_variables(formula):
raise IvyError("Free variables {} must match formula: {}".format(variables, formula))
if not all(type(v) is Var and first_order_sort(v.sort) for v in variables):
raise IvyError("Concept variables must be first-order: {}".format(variables))
return variables, formula
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 _preprocess_(cls, name, variables, formula):
if not isinstance(name,str):
raise IvyError("Concept name {} is not a string".format(name))
variables = tuple(variables)
# if set(variables) != free_variables(formula):
# raise IvyError("Free variables {} must match formula: {}".format(variables, formula))
if not all(type(v) is Var and first_order_sort(v.sort) for v in variables):
raise IvyError("Concept variables must be first-order: {}".format(variables))
return name,variables, formula
def _to_z3(x):
"""
Convert a term or a sort to a Z3 object.
"""
print "<bhavya> _to_z3 called"
if x in _z3_interpreted:
return _z3_interpreted[x]
elif type(x) is UninterpretedSort:
if x not in _z3_uninterpreted_sorts:
_z3_uninterpreted_sorts[x] = z3.DeclareSort(x.name)
return _z3_uninterpreted_sorts[x]
elif type(x) is FunctionSort:
assert False, "FunctionSort's aren't converted to Z3"
elif type(x) in (Var, Const) and first_order_sort(x.sort):
return z3.Const(x.name + ':' + str(x.sort), to_z3(x.sort))
elif type(x) in (Var, Const) and type(x.sort) is FunctionSort and len(
x.sort.sorts) == 1:
# convert to first order
s = x.sort.sorts[0]
return z3.Const(x.name + ':' + str(s), to_z3(s))
elif type(x) in (Var, Const) and type(x.sort) is FunctionSort:
assert type(
x
) is Const, "Cannot convert high-order variables to Z3, only constants"
return z3.Function(x.name, *(to_z3(s) for s in x.sort))
elif type(x) is Apply and len(x.terms) == 0:
# convert application to use of first order symbol
return to_z3(x.func)
elif type(x) is Apply:
return to_z3(x.func)(*(to_z3(t) for t in x.terms))
elif type(x) in _z3_operators:
return _z3_operators[type(x)](*(to_z3(y) for y in x))
elif type(x) in _z3_quantifiers:
if len(x.variables) == 0:
return to_z3(x.body)
else:
return _z3_quantifiers[type(x)](
[to_z3(v) for v in x.variables],
to_z3(x.body),
)
else:
assert False, type(x)
def _to_z3(x):
"""
Convert a term or a sort to a Z3 object.
"""
if x in _z3_interpreted:
return _z3_interpreted[x]
elif type(x) is UninterpretedSort:
if x not in _z3_uninterpreted_sorts:
_z3_uninterpreted_sorts[x] = z3.DeclareSort(x.name)
return _z3_uninterpreted_sorts[x]
elif type(x) is FunctionSort:
assert False, "FunctionSort's aren't converted to Z3"
elif type(x) in (Var, Const) and first_order_sort(x.sort):
return z3.Const(x.name + ":" + str(x.sort), to_z3(x.sort))
elif type(x) in (Var, Const) and type(x.sort) is FunctionSort and len(x.sort.sorts) == 1:
# convert to first order
s = x.sort.sorts[0]
return z3.Const(x.name + ":" + str(s), to_z3(s))
elif type(x) in (Var, Const) and type(x.sort) is FunctionSort:
assert type(x) is Const, "Cannot convert high-order variables to Z3, only constants"
return z3.Function(x.name, *(to_z3(s) for s in x.sort))
elif type(x) is Apply and len(x.terms) == 0:
# convert application to use of first order symbol
return to_z3(x.func)
elif type(x) is Apply:
return to_z3(x.func)(*(to_z3(t) for t in x.terms))
elif type(x) in _z3_operators:
return _z3_operators[type(x)](*(to_z3(y) for y in x))
elif type(x) in _z3_quantifiers:
if len(x.variables) == 0:
return to_z3(x.body)
else:
return _z3_quantifiers[type(x)]([to_z3(v) for v in x.variables], to_z3(x.body))
else:
assert False, type(x)
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 universe_element_to_concept_name(uc):
assert first_order_sort(uc.sort)
name = uc.name
if str(uc.sort) not in name:
name += ':{}'.format(uc.sort)
return name
