def exec_minconcat(self, envr, pm):
result = ProofResult("")
result.source = self
if len(self.args) != 1:
raise ProofError("-inconcat takes one argument, found: " + str(len(self.args)))
intest = self.resolveOrDont(self.args[0])
if not isinstance(intest, judge.InTest):
raise ProofError("-inconcat expects a contains assertion, found: " + intext.shortString())
cc = intest.rhs
if not isinstance(cc, expSemantics.Concat):
raise ProofError("-inconcat expects a concatenation, found: " + cc.shortString())
els = []
for c in cc.elements:
i2 = judge.InTest(None)
i2.nt = intest.nt
i2.lhs = intest.lhs
i2.rhs = c
els.append(i2)
if intest.nt:
r = expSemantics.And(None)
else:
r = expSemantics.Or(None)
r.elements = els
self.results = [r]
result.verbose = pm.getIndent() + self.results[0].shortString()
return result
def mor_callback(self, cases):
comps = []
falseTrip = True
if len(cases.results) < len(cases.cases):
falseTrip = False
for r in cases.results:
if not r.results:
falseTrip = False
elif len(r.results) == 1:
rr = r.results[0]
if rr != expSemantics.FALSE:
falseTrip = False
comps.append(rr)
elif len(r.results) > 1:
result = expSemantics.And(None)
result.elements = r.results
comps.append(result)
if falseTrip:
self.results = [expSemantics.FALSE]
else:
comps = list(set(comps))
if expSemantics.FALSE in comps:
comps.remove(expSemantics.FALSE)
if not comps:
self.results = [expSemantics.TRUE]
elif len(comps) == 1:
self.results = [comps[0]]
else:
result = expSemantics.Or(None)
result.elements = comps
self.results = [result]
def exec_apply(self, envr, pm):
result = ProofResult("")
rule = self.args[0]
guessFV = False
if hasattr(rule, "__iter__"):
guessFV = rule[1]
rule = rule[0]
args = map(lambda x: [x], filter(lambda x: x != None, map(self.resolveOrDont, self.args[1:])))
if self.equals:
map(lambda x: envr.envClosure(x), args)
fail = []
matches = []
for p in rule.premises:
mm = []
for a in args:
for aa in a:
m = aa.isSuperType(p, pm.world.symList)
if m:
mm.append(m)
if not mm:
fail.append(p)
matches.append(mm)
if fail:
raise ProofError("Premises of " + rule.name + " could not be satisfied: " + "; ".join(map(lambda x: x.shortString(), fail)))
#try to unify the matches
poss = [[]]
for mm in matches:
newPoss = []
for m in mm:
for p in poss:
#if m agrees with p, then add p + m to newPoss
if self.matchAgrees(p, m):
newPoss.append(p + m.flatMatches())
poss = newPoss
if not poss:
raise ProofError("Premises of " + rule.name + " could not be satisfied.")
#find the conclusion and apply the possible unifications to it
conc = sum(map(lambda c: map(lambda p: c.substMatch(p), poss), rule.getConclusions()), [])
#fv in conc => forall quant
#if the indhyp is being applied and was not primed (guessFV), then guess the FVs
if not guessFV and conc and rule.freeConc:
r = expSemantics.Forall(None)
r.qVars = rule.freeConc
if len(conc) == 1:
r.rhs = conc[0]
else:
r.rhs = expSemantics.And(None)
r.rhs.elements = conc
conc = [r]
self.results = conc
result.source = self
result.verbose = pm.getIndent() + "Applied " + rule.name + ": " + "; ".join(map(lambda x: x.shortString(), self.results))
return result
def exec_and(self, envr, pm):
result = ProofResult("")
result.source = self
if self.args:
conc = expSemantics.And(self.ast)
conc.elements = map(lambda x: x.resolve(), self.args)
self.results = [conc]
result.verbose = pm.getIndent() + conc.shortString()
return result
def implies_callback(self, cases):
result = expSemantics.Implies(None)
#lhs
if len(self.args) == 1:
result.lhs = self.args[0]
else:
result.lhs = expSemantics.And(None)
result.lhs.elements = self.args
#rhs
if len(cases.results[0].results) == 0:
result.rhs = expSemantics.TRUE
elif len(cases.results[0].results) == 1:
result.rhs = cases.results[0].results[0]
else:
result.rhs = expSemantics.And(None)
result.rhs.elements = cases.results[0].results
self.results = [result]
def forall_callback(self, cases):
result = expSemantics.Forall(None)
#quantifying variables
result.qVars = self.args
#rhs
if len(cases.results[0].results) == 0:
result.rhs = expSemantics.TRUE
elif len(cases.results[0].results) == 1:
result.rhs = cases.results[0].results[0]
else:
result.rhs = expSemantics.And(None)
result.rhs.elements = cases.results[0].results
self.results = [result]
def exec_invert(self, envr, pm):
result = ProofResult("")
result.source = self
pc = self.invertArg(self.args[0], envr, pm)
if not pc:
self.results = [expSemantics.FALSE]
result.verbose = pm.getIndent() + expSemantics.FALSE.shortString()
return result
prems,cases = pc
#package up results or open cases
if self.star:
r = expSemantics.Or(None)
for p in prems:
if len(p) == 0:
cr = expSemantics.TRUE
elif len(p) == 1:
cr = p[0]
else:
cr = expSemantics.And(None)
cr.elements = p
r.elements.append(cr)
if r.elements == 1:
r = r.elements[0]
self.results = [r]
result.verbose = pm.getIndent() + r.shortString()
else:
if len(prems) == 1:
self.results = prems[0]
result.verbose = pm.getIndent() + "; ".join(map(lambda x: x.shortString(), self.results))
else:
self.cases = dict(zip(map(lambda c: c.name, cases), prems))
result.verbose = pm.getIndent() + str(len(prems)) + " cases: " + "; ".join(map(lambda c: c.name, cases))
pm.registerCallBack(self, "mor_callback")
return result