occam-verify-cli 0.0.1075 → 0.0.1078

package/src/rule.js

@@ -14,7 +14,7 @@ import { labelsFromJSON,
          premisesToPremisesJSON,
          conclusionToConclusionJSON } from "./utilities/json";
 
-const { reverse, correlate } = arrayUtilities;
+const { extract, reverse, backwardsEvery } = arrayUtilities;
 
 const proofNodeQuery = nodeQuery("/rule/proof"),
       labelNodesQuery = nodesQuery("/rule/label"),
@@ -68,24 +68,17 @@ class Rule {
   }
 
   unifyStatement(statement, localContext) {
-    let statementUnified = false;
+    let statementUnified;
 
     const { Substitutions } = shim,
-          proofSteps = localContext.getProofSteps(),
           substitutions = Substitutions.fromNothing(),
-          proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
+          conclusionUnified = this.unifyConclusion(statement, substitutions, localContext);
 
-    if (proofStepsUnified) {
-      const statementUnifiedWithConclusion = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
+    if (conclusionUnified) {
+      const premisesUnified = this.unifyPremises(substitutions, localContext);
 
-      if (statementUnifiedWithConclusion) {
-        const localContextB = localContext; ///
-
-        localContext = LocalContext.fromFileContext(this.fileContext);
-
-        const localContextA = localContext; ///
-
-        const substitutionsResolved = substitutions.resolve(localContextA, localContextB);
+      if (premisesUnified) {
+        const substitutionsResolved = substitutions.areResolved();
 
         statementUnified = substitutionsResolved; ///
       }
@@ -94,24 +87,70 @@ class Rule {
     return statementUnified;
   }
 
-  unifyProofSteps(proofSteps, substitutions, localContext) {
-    let proofStepsUnified;
+  unifyConclusion(statement, substitutions, localContext) {
+    let conclusionUnified;
+
+    const conclusionString = this.conclusion.getString();
+
+    localContext.trace(`Unifying the '${conclusionString}' conclusion...`);
+
+    const statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
 
-    let premises = this.premises;
+    conclusionUnified = statementUnified; ///
 
-    premises = reverse(premises); ///
+    if (conclusionUnified) {
+      localContext.debug(`...unified the '${conclusionString}' conclusion`);
+    }
+
+    return conclusionUnified;
+  }
+
+  unifyPremises(substitutions, localContext) {
+    let proofSteps = localContext.getProofSteps();
 
     proofSteps = reverse(proofSteps); ///
 
-    proofStepsUnified = correlate(premises, proofSteps, (premise, proofStep) => {
-      const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, localContext);
+    const premisesUnified = backwardsEvery(this.premises, (premise) => {
+      const premiseUnified = this.unifyPremise(premise, proofSteps, substitutions, localContext);
 
-      if (proofStepUnified) {
+      if (premiseUnified) {
         return true;
       }
     });
 
-    return proofStepsUnified;
+    return premisesUnified;
+  }
+
+  unifyPremise(premise, proofSteps, substitutions, localContext) {
+    let premiseUnified  =false;
+
+    const premiseString = premise.getString();
+
+    localContext.trace(`Unifying the '${premiseString}' premise...`);
+
+    const premiseResolvedIndependently = premise.resolveIndependently(substitutions, localContext);
+
+    if (premiseResolvedIndependently) {
+      premiseUnified = true;
+    } else {
+      const proofStep = extract(proofSteps, (proofStep) => {
+        const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, localContext);
+
+        if (proofStepUnified) {
+          return true;
+        }
+      });
+
+      if (proofStep !== null) {
+        premiseUnified = true;
+      }
+    }
+
+    if (premiseUnified) {
+      localContext.debug(`...unified the '${premiseString}' premise.`);
+    }
+
+    return premiseUnified;
   }
 
   verify() {

package/src/statement/qualified.js

@@ -71,7 +71,7 @@ class QualifiedStatement {
     return statementUnified;
   }
 
-  verify(substitutions, localContext) {
+  verify(substitutions, assignments, stated, localContext) {
     let verified;
 
     const qualifiedStatementString = this.string; ///
@@ -79,9 +79,7 @@ class QualifiedStatement {
     if (this.statement !== null) {
       localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`);
 
-      const stated = true,
-            assignments = [],
-            statementVerified = this.statement.verify(assignments, stated, localContext);
+      const statementVerified = this.statement.verify(assignments, stated, localContext);
 
       if (statementVerified) {
         const unified = this.unify(substitutions, localContext);

package/src/statement/unqualified.js

@@ -74,6 +74,24 @@ class UnqualifiedStatement {
     return statementUnified;
   }
 
+  resolveIndependently(substitutions, localContextA, localContextB) {
+    let resolveIndependently;
+
+    const unqualifiedStatementString = this.getString();  ///
+
+    localContextB.trace(`Resolving the '${unqualifiedStatementString}' unqualified statement independently...`);
+
+    const statementResolvedIndependently = this.statement.resolveIndependently(substitutions, localContextA, localContextB);
+
+    resolveIndependently = statementResolvedIndependently;  ///
+
+    if (resolveIndependently) {
+      localContextB.debug(`...resolved the '${unqualifiedStatementString}' unqualified statement independently.`);
+    }
+
+    return resolveIndependently;
+  }
+
   unifyStatementWithProofSteps(statement, assignments, stated, localContext) {
     let statementUnifiedWithProofSteps;
 

package/src/statement.js

@@ -4,6 +4,7 @@ import shim from "./shim";
 import unifyMixins from "./mixins/statement/unify";
 import verifyMixins from "./mixins/statement/verify";
 import LocalContext from "./context/local";
+import resolveMixins from "./mixins/statement/resolve";
 import metaLevelUnifier from "./unifier/metaLevel";
 import statementAsCombinatorVerifier from "./verifier/statementAsCombinator";
 
@@ -105,6 +106,35 @@ class Statement {
     return statementNodeMatches;
   }
 
+  resolveIndependently(substitutions, localContextA, localContextB) {
+    let resolvedIndependently;
+
+    const statement = this, ///
+          statementString = this.string;  ///
+
+    localContextB.trace(`Resolving the '${statementString}' statement independently...`);
+
+    const context = localContextA;  ///
+
+    localContextA = LocalContext.fromContextAndTokens(context, this.tokens);
+
+    const resolved = resolveMixins.some((resolveMixin) => {
+      const resolved = resolveMixin(statement, substitutions, localContextA, localContextB);
+
+      if (resolved) {
+        return true;
+      }
+    });
+
+    resolvedIndependently = resolved; ///
+
+    if (resolvedIndependently) {
+      localContextB.debug(`...resolved the '${statementString}' statement independently.`);
+    }
+
+    return resolvedIndependently;
+  }
+
   unifyStatement(statement, substitutions, localContextA, localContextB) {
     let statementUnified;
 

package/src/substitution/statementForMetavariable.js

@@ -9,14 +9,19 @@ import { stripBracketsFromStatementNode } from "../utilities/brackets";
 import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
-  constructor(string, statement, metavariable, substitution) {
+  constructor(string, resolved, statement, metavariable, substitution) {
     super(string);
 
+    this.resolved = resolved;
     this.statement = statement;
     this.metavariable = metavariable;
     this.substitution = substitution;
   }
 
+  isResolved() {
+    return this.resolved;
+  }
+
   getStatement() {
     return this.statement;
   }
@@ -42,27 +47,23 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 
   resolve(substitutions, localContextA, localContextB) {
-    let resolved = false;
-
     const substitutionString = this.string;
 
-    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
-
     const metavariableNode = this.getMetavariableNode(),
           simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
 
     if (simpleSubstitution !== null) {
+      localContextB.trace(`Resolving the ${substitutionString} substitution...`);
+
       const substitution = simpleSubstitution,  ///
             substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContextA, localContextB);
 
-      resolved = substitutionResolved; ///
-    }
+      this.resolved = substitutionResolved; ///
 
-    if (resolved) {
-      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
+      if (this.resolved) {
+        localContextB.debug(`...resolved the ${substitutionString} substitution.`);
+      }
     }
-
-    return resolved;
   }
 
   resolveSubstitution(substitution, statement, substitutions, localContextA, localContextB) {
@@ -82,10 +83,21 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
       substitutions.snapshot();
 
-      const nodeA = substitutionA.getSubstitutionNode(),  ///
-            nodeB = substitutionB.getSubstitutionNode(),  ///
+      const substitutionNodeA = substitutionA.getSubstitutionNode(),  ///
+            substitutionNodeB = substitutionB.getSubstitutionNode(),  ///
+            substitutionStringA = localContextA.nodeAsString(substitutionNodeA),
+            substitutionStringB = localContextB.nodeAsString(substitutionNodeB);
+
+      localContextB.trace(`Unifying the '${substitutionStringB}' substitution with the '${substitutionStringA}' substitution...`);
+
+      const nodeA = substitutionNodeA,  ///
+            nodeB = substitutionNodeB,  ///
             unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
+      if (unifiedAtMetaLevel) {
+        localContextB.trace(`...unified the '${substitutionStringB}' substitution with the '${substitutionStringA}' substitution.`);
+      }
+
       unifiedAtMetaLevel ?
         substitutions.continue() :
           substitutions.rollback(localContextB);
@@ -171,10 +183,11 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
+          resolved = true,
           statement = statementFromJSON(json, fileContext),
           metavariable = metavariableFromJSON(json, fileContext),
           substitution = null,  ///
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;
   }
@@ -189,8 +202,9 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     statement = Statement.fromStatementNode(statementNode, localContext);
 
     const substitution = null,
+          resolved = true,
           string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;
   }
@@ -205,7 +219,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     statement = Statement.fromStatementNode(statementNode, localContext);
 
     const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+          resolved = false,
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;
   }

package/src/substitutions.js

@@ -224,24 +224,46 @@ class Substitutions {
   }
 
   resolve(localContextA, localContextB) {
+    const metavariableNodes = this.getMetavariableNodes();
+
+    metavariableNodes.forEach((metavariableNode) => {
+      const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
+            complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+              let resolved;
+
+              const substitutions = this,
+                    substitution = complexSubstitution; ///
+
+              resolved = substitution.isResolved();
+
+              if (!resolved) {
+                substitution.resolve(substitutions, localContextA, localContextB);
+              }
+            });
+
+      if (complexSubstitutionsResolved) {
+        return true;
+      }
+    });
+  }
+
+  areResolved() {
     const metavariableNodes = this.getMetavariableNodes(),
           resolved = metavariableNodes.every((metavariableNode) => {
-                        const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
-                              complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
-                                const substitution = complexSubstitution, ///
-                                      substitutions = this, ///
-                                      substitutionResolved = substitution.resolve(substitutions, localContextA, localContextB);
-
-                                if (substitutionResolved) {
-                                  return true;
-                                }
-                              });
-
-                        if (complexSubstitutionsResolved) {
+            const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
+                  complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+                        const complexSubstitutionResolved = complexSubstitution.isResolved();
+
+                        if (complexSubstitutionResolved) {
                           return true;
                         }
                       });
 
+                    if (complexSubstitutionsResolved) {
+                      return true;
+                    }
+                  });
+
     return resolved;
   }
 

package/src/supposition.js

@@ -59,37 +59,6 @@ class Supposition {
     return verified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const supposition = this, ///
-          subproofString = subproof.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
-
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          statementTokens = statement.getTokens(),
-          context = this.fileContext, ///
-          tokens = statementTokens; ///
-
-    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
-
-    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -98,12 +67,27 @@ class Supposition {
 
     substitutions.snapshot();
 
+    let subproofUnified = false,
+        statementUnified = false;
+
     if (false) {
       ///
     } else if (subproof !== null) {
-      proofStepUnified = this.unifySubproof(subproof, substitutions, localContext);
+      subproofUnified = this.unifySubproof(subproof, substitutions, localContext);
     } else if (statement !== null) {
-      proofStepUnified = this.unifyStatement(statement, substitutions, localContext);
+      statementUnified = this.unifyStatement(statement, substitutions, localContext);
+    }
+
+    if (subproofUnified || statementUnified) {
+      const localContextB = localContext; ///
+
+      localContext = LocalContext.fromFileContext(this.fileContext);
+
+      const localContextA = localContext; ///
+
+      substitutions.resolve(localContextA, localContextB);
+
+      proofStepUnified = true;
     }
 
     proofStepUnified ?
@@ -136,6 +120,37 @@ class Supposition {
     return statementUnified;
   }
 
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const supposition = this, ///
+          subproofString = subproof.getString(),
+          suppositionStatement = supposition.getStatement(),
+          suppositionStatementString = suppositionStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          statementNode = statement.getNode(),
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   toJSON() {
     const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
           unqualifiedStatement = unqualifiedStatementJSON,  ///

package/src/term.js

@@ -42,13 +42,6 @@ class Term {
     this.type = type;
   }
 
-  match(term) {
-    const node = term.getNode(),
-          matches = this.node.match(node);
-
-    return matches;
-  }
-
   getVariable(localContext) {
     let variable = null;
 
@@ -98,6 +91,23 @@ class Term {
     return grounded;
   }
 
+  isEqualTo(term) {
+    let equalTo = false;
+
+    const termNode = term.getNode(),
+          termNodeMatches = this.node.match(termNode);
+
+    if (termNodeMatches) {
+      const termType = term.getType();
+
+      if (this.type === termType) {
+        equalTo = true;
+      }
+    }
+
+    return equalTo;
+  }
+
   matchTermNode(termNode) {
     const termNodeMatches = this.node.match(termNode);
 

package/src/topLevelAssertion.js

@@ -3,6 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import shim from "./shim";
+import LocalContext from "./context/local";
 
 import { EMPTY_STRING } from "./constants";
 import { labelsFromJSON,
@@ -61,15 +62,22 @@ export default class TopLevelAssertion {
   }
 
   unifyStatement(statement, localContext) {
-    let statementUnified = false;
+    let statementUnified;
 
     const { Substitutions } = shim,
-          proofSteps = localContext.getProofSteps(),
-          substitutions = Substitutions.fromNothing(),
-          proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
+          substitutions = Substitutions.fromNothing();
 
-    if (proofStepsUnified) {
-      statementUnified = this.consequent.unifyStatement(statement, substitutions, localContext);
+    statementUnified = this.consequent.unifyStatement(statement, substitutions, localContext);
+
+    if (statementUnified) {
+      const proofSteps = localContext.getProofSteps(),
+            proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
+
+      if (proofStepsUnified) {
+        const substitutionsResolved = substitutions.areResolved();
+
+        statementUnified = substitutionsResolved; ///
+      }
     }
 
     return statementUnified;

package/src/type.js

@@ -83,12 +83,6 @@ class Type {
     return equalToOrSuperTypeOf;
   }
 
-  match(type) {
-    const matches = (type === this);  ///
-
-    return matches;
-  }
-
   matchName(name) {
     const nodeMatches = (this.name === name);
 

package/src/utilities/equivalences.js

@@ -57,9 +57,9 @@ export function findEquivalenceByType(equivalences, type) {
 
 export function findEquivalenceByTerm(equivalences, term) {
   const equivalence = equivalences.find((equivalence) => {
-    const equivalenceMatchesTerm = equivalence.matchTerm(term);
+    const termEquates = equivalence.equateTerm(term);
 
-    if (equivalenceMatchesTerm) {
+    if (termEquates) {
       return true;
     }
   }) || null;

package/src/utilities/substitutions.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+import { variableNameFromVariableNode } from "../utilities/name";
+
+const variableNodeQuery = nodeQuery("/term/variable!"),
+      metavariableNodeQuery = nodeQuery("/*/metavariable!");
+
+export function termFromTermAndSubstitutions(term, substitutions) {
+  if (term !== null) {
+    const termNode = term.getNode(),
+          variableNode = variableNodeQuery(termNode);
+
+    if (variableNode !== null) {
+      const variableName = variableNameFromVariableNode(variableNode),
+            substitution = substitutions.findSubstitution((substitution) => {
+              const variableNameMatches = substitution.matchVariableName(variableName);
+
+              if (variableNameMatches) {
+                return true;
+              }
+            });
+
+      if (substitution !== null) {
+        term = substitution.getTerm();
+      }
+    }
+  }
+
+  return term;
+}
+
+export function frameFromFrameAndSubstitutions(frame, substitutions) {
+  if (frame !== null) {
+    const frameNode = frame.getNode(),
+          metavariableNode = metavariableNodeQuery(frameNode);
+
+    if (metavariableNode !== null) {
+      const substitution = substitutions.findSubstitution((substitution) => {
+        const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+
+        if (metavariableNodeMatches) {
+          return true;
+        }
+      });
+
+      if (substitution !== null) {
+        frame = substitution.getTerm();
+      }
+    }
+  }
+
+  return frame;
+}
+
+export function statementFromStatementAndSubstitutions(statement, substitutions) {
+  if (statement !== null) {
+    const statementNode = statement.getNode(),
+          metavariableNode = metavariableNodeQuery(statementNode);
+
+    if (metavariableNode !== null) {
+      const substitution = substitutions.findSubstitution((substitution) => {
+        const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+
+        if (metavariableNodeMatches) {
+          return true;
+        }
+      });
+
+      if (substitution !== null) {
+        statement = substitution.getStatement();
+      }
+    }
+  }
+
+  return statement;
+}

package/src/variable.js

@@ -164,7 +164,7 @@ class Variable {
             variable = variableFromVariableNode(variableNode, localContext),
             termVariable = termVariableFromTermNode(termNode, localContext);
 
-      if (variable === termVariable) {
+      if ((variable !== null) && (variable === termVariable)) {
         termUnified = true;
       } else {
         const variable = this,  ///