/** * A contrapositive of a chain is a permutation in which a different literal * is placed at the front. The contrapositives of a chain are logically * equivalent to the original chain. * * @return a list of contrapositives for this chain. */ public List <Chain> getContrapositives() { List <Chain> contrapositives = new List <Chain>(); List <Literal> lits = new List <Literal>(); for (int i = 1; i < literals.Count; i++) { lits.Clear(); lits.Add(literals[i]); lits.AddRange(literals.Take(i)); lits.AddRange(literals.GetRange(i + 1, literals.Count)); Chain cont = new Chain(lits); cont.setProofStep(new ProofStepChainContrapositive(cont, this)); contrapositives.Add(cont); } return(contrapositives); }
public Chain attemptReduction(Chain nearParent, int farParentIndex) { Chain nnpc = null; Literal nearLiteral = nearParent.getHead(); Dictionary<String, List<Chain>> candidateHeads = null; if (nearLiteral.isPositiveLiteral()) { candidateHeads = negHeads; } else { candidateHeads = posHeads; } AtomicSentence nearAtom = nearLiteral.getAtomicSentence(); String nearestKey = nearAtom.getSymbolicName(); List<Chain> farParents = candidateHeads[nearestKey]; if (null != farParents) { Chain farParent = farParents[farParentIndex]; standardizeApart(farParent); Literal farLiteral = farParent.getHead(); AtomicSentence farAtom = farLiteral.getAtomicSentence(); Dictionary<Variable, Term> subst = unifier.unify(nearAtom, farAtom); // If I was able to unify with one // of the far heads if (null != subst) { // Want to always apply reduction uniformly Chain topChain = farParent; Literal botLit = nearLiteral; Chain botChain = nearParent; // Need to apply subst to all of the // literals in the reduction List<Literal> reduction = new List<Literal>(); foreach (Literal l in topChain.getTail()) { AtomicSentence atom = (AtomicSentence)substVisitor.subst( subst, l.getAtomicSentence()); reduction.Add(l.newInstance(atom)); } reduction.Add(new ReducedLiteral((AtomicSentence)substVisitor .subst(subst, botLit.getAtomicSentence()), botLit .isNegativeLiteral())); foreach (Literal l in botChain.getTail()) { AtomicSentence atom = (AtomicSentence)substVisitor.subst( subst, l.getAtomicSentence()); reduction.Add(l.newInstance(atom)); } nnpc = new Chain(reduction); nnpc.setProofStep(new ProofStepChainReduction(nnpc, nearParent, farParent, subst)); } } return nnpc; }
// Returns c if no dropping occurred private Chain tryDropping(Chain c) { Literal head = c.getHead(); if (null != head && (head is ReducedLiteral)) { Chain dropped = new Chain(c.getTail()); dropped.setProofStep(new ProofStepChainDropped(dropped, c)); return dropped; } return c; }
// Returns c if no cancellation occurred private Chain tryCancellation(Chain c) { Literal head = c.getHead(); if (null != head && !(head is ReducedLiteral)) { foreach (Literal l in c.getTail()) { if (l is ReducedLiteral) { // if they can be resolved if (head.isNegativeLiteral() != l.isNegativeLiteral()) { Dictionary<Variable, Term> subst = unifier.unify(head .getAtomicSentence(), l.getAtomicSentence()); if (null != subst) { // I have a cancellation // Need to apply subst to all of the // literals in the cancellation List<Literal> cancLits = new List<Literal>(); foreach (Literal lfc in c.getTail()) { AtomicSentence a = (AtomicSentence)substVisitor .subst(subst, lfc.getAtomicSentence()); cancLits.Add(lfc.newInstance(a)); } Chain cancellation = new Chain(cancLits); cancellation .setProofStep(new ProofStepChainCancellation( cancellation, c, subst)); return cancellation; } } } } } return c; }
// END-InferenceProcedure // // // PRIVATE METHODS // public List<Chain> createChainsFromClauses(List<Clause> clauses) { List<Chain> chains = new List<Chain>(); foreach (Clause c in clauses) { Chain chn = new Chain(c.getLiterals()); chn.setProofStep(new ProofStepChainFromClause(chn, c)); chains.Add(chn); chains.AddRange(chn.getContrapositives()); } return chains; }
public Chain standardizeApart(Chain chain, StandardizeApartIndexical standardizeApartIndexical) { List<Variable> toRename = variableCollector.collectAllVariables(chain); Dictionary<Variable, Term> renameSubstitution = new Dictionary<Variable, Term>(); foreach (Variable var in toRename) { Variable v = null; do { v = new Variable(standardizeApartIndexical.getPrefix() + standardizeApartIndexical.getNextIndex()); // Ensure the new variable name is not already // accidentally used in the sentence } while (toRename.Contains(v)); renameSubstitution.Add(var, v); } if (renameSubstitution.Count > 0) { List<Literal> lits = new List<Literal>(); foreach (Literal l in chain.getLiterals()) { AtomicSentence atom = (AtomicSentence)substVisitor.subst( renameSubstitution, l.getAtomicSentence()); lits.Add(l.newInstance(atom)); } Chain renamed = new Chain(lits); renamed.setProofStep(new ProofStepRenaming(renamed, chain .getProofStep())); return renamed; } return chain; }
/** * A contrapositive of a chain is a permutation in which a different literal * is placed at the front. The contrapositives of a chain are logically * equivalent to the original chain. * * @return a list of contrapositives for this chain. */ public List<Chain> getContrapositives() { List<Chain> contrapositives = new List<Chain>(); List<Literal> lits = new List<Literal>(); for (int i = 1; i < literals.Count; i++) { lits.Clear(); lits.Add(literals[i]); lits.AddRange(literals.Take(i)); lits.AddRange(literals.GetRange(i + 1, literals.Count)); Chain cont = new Chain(lits); cont.setProofStep(new ProofStepChainContrapositive(cont, this)); contrapositives.Add(cont); } return contrapositives; }