occam-verify-cli 0.0.1077 → 0.0.1079

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"),
@@ -71,15 +71,13 @@ class Rule {
     let statementUnified;
 
     const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing();
+          substitutions = Substitutions.fromNothing(),
+          conclusionUnified = this.unifyConclusion(statement, substitutions, localContext);
 
-    statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
+    if (conclusionUnified) {
+      const premisesUnified = this.unifyPremises(substitutions, localContext);
 
-    if (statementUnified) {
-      const proofSteps = localContext.getProofSteps(),
-            proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
-
-      if (proofStepsUnified) {
+      if (premisesUnified) {
         const substitutionsResolved = substitutions.areResolved();
 
         statementUnified = substitutionsResolved; ///
@@ -89,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...`);
 
-    let premises = this.premises;
+    const statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
 
-    premises = reverse(premises); ///
+    conclusionUnified = statementUnified; ///
+
+    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/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/frameForMetavariable.js

@@ -88,6 +88,8 @@ export default class FrameForMetavariableSubstitution extends Substitution {
 
   matchFrameNode(frameNode) { return this.frame.matchFrameNode(frameNode); }
 
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+
   matchMetavariableName(metavariableName) {
     let metavariableNameMatches;
 

package/src/substitution/statementForMetavariable.js

@@ -201,9 +201,9 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
     statement = Statement.fromStatementNode(statementNode, localContext);
 
-    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+    const substitution = null,
           resolved = true,
-          substitution = null,
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
           statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, resolved, statement, metavariable, substitution);
 
     return statementForMetavariableSubstitution;

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/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,86 @@
+"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();
+
+    term = null;
+
+    const 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();
+
+    frame = null;
+
+    const 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.getFrame();
+      }
+    }
+  }
+
+  return frame;
+}
+
+export function statementFromStatementAndSubstitutions(statement, substitutions) {
+  if (statement !== null) {
+    const statementNode = statement.getNode();
+
+    statement = null;
+
+    const 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;
+}