occam-verify-cli 0.0.1074 → 0.0.1077

package/src/proofStep.js

@@ -1,14 +1,15 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import shim from "./shim";
-import Subproof from "./subproof";
-import Substitutions from "./substitutions";
-import QualifiedStatement from "./statement/qualified";
-import UnqualifiedStatement from "./statement/unqualified";
+import metaLevelUnifier from "./unifier/metaLevel";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
 
+const { match } = arrayUtilities;
+
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement"),
       unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement");
@@ -49,55 +50,112 @@ class ProofStep {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const substitutions = Substitutions.fromNothing();
+    if ((this.qualifiedStatement !== null) || (this.unqualifiedStatement !== null !== null)) {
+      const statementString = statement.getString();
 
-    if (this.qualifiedStatement !== null) {
-      const localContextA = localContext, ///
-            localContextB = localContext; ///
+      localContext.trace(`Unifying the '${statementString}' statement...`);
 
-      statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
-    }
+      const { Substitutions } = shim,
+            localContextA = localContext, ///
+            localContextB = localContext, ///
+            substitutions = Substitutions.fromNothing();
 
-    if (this.unqualifiedStatement !== null) {
-      const localContextA = localContext, ///
-            localContextB = localContext; ///
+      if (this.qualifiedStatement !== null) {
+        statementUnified = this.qualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      }
 
-      statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
-    }
+      if (this.unqualifiedStatement !== null) {
+        statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      }
 
-    const substitutionsLength = substitutions.getLength();
+      const substitutionsLength = substitutions.getLength();
 
-    if (substitutionsLength > 0) {
-      statementUnified = false;
+      if (substitutionsLength > 0) {
+        statementUnified = false;
+      }
+
+      if (statementUnified) {
+        localContext.debug(`...unified the '${statementString}' statement.`);
+      }
     }
 
     return statementUnified;
   }
 
+  unifySubproofAssertion(subproofAssertion, localContext) {
+    let subproofAssertionUnified = false;
+
+    if (this.subproof !== null) {
+      const subproofString = this.subproof.getString(),
+            subproofAssertionString = subproofAssertion.getString();
+
+      localContext.trace(`Unifying the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof...`);
+
+      const { Substitutions } = shim,
+            substitutions = Substitutions.fromNothing(),
+            subproofStatements = this.subproof.getStatements(),
+            subproofAssertionStatements = subproofAssertion.getStatements();
+
+      subproofAssertionUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+        const subproofAssertionStatementNode = subproofAssertionStatement.getNode(),
+              subproofStatementNode = subproofStatement.getNode(),
+              nodeA = subproofAssertionStatementNode,  ///
+              nodeB = subproofStatementNode,  ///
+              localContextA = localContext, ///
+              localContextB = localContext, ///
+              unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+        if (unifiedAtMetaLevel) {
+          return true;
+        }
+      });
+
+      if (subproofAssertionUnified) {
+        const substitutionsLength = substitutions.getLength();
+
+        if (substitutionsLength > 0) {
+          subproofAssertionUnified = false;
+        }
+      }
+
+      if (subproofAssertionUnified) {
+        localContext.trace(`...unified the '${subproofAssertionString}' subproof assertion with the '${subproofString}' subproof.`);
+      }
+    }
+
+    return subproofAssertionUnified;
+  }
+
   verify(substitutions, localContext) {
     let verified = false;
 
+    let stated = false;
+
+    const assignments = [];
+
+    let subproofVerified = false,
+        qualifiedStatementVerified = false,
+        unqualifiedStatementVerified = false;
+
     if (false) {
       ///
     } else if (this.subproof !== null) {
-      const subproofVerified = this.subproof.verify(substitutions, localContext);
-
-      verified = subproofVerified;  ///
+      subproofVerified = this.subproof.verify(substitutions, localContext);
     } else if (this.qualifiedStatement !== null) {
-      const qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, localContext);
+      stated = true;
 
-      verified = qualifiedStatementVerified;  ///
+      qualifiedStatementVerified = this.qualifiedStatement.verify(substitutions, assignments, stated, localContext);
     } else if (this.unqualifiedStatement !== null) {
-      const stated = false,
-            assignments = [],
-            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+      stated = false;
+
+      unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+    }
 
-      if (unqualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
+    if (subproofVerified || qualifiedStatementVerified || unqualifiedStatementVerified) {
+      const assignmentsAssigned = assignAssignments(assignments, localContext);
 
-        if (assignmentsAssigned) {
-          verified = true;
-        }
+      if (assignmentsAssigned) {
+        verified = true;
       }
     }
 
@@ -111,7 +169,8 @@ class ProofStep {
   }
 
   static fromProofStepNode(proofStepNode, fileContext) {
-    const subproofNode = subproofNodeQuery(proofStepNode),
+    const { Subproof, QualifiedStatement, UnqualifiedStatement } = shim,
+          subproofNode = subproofNodeQuery(proofStepNode),
           qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
           unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode),
           subproof = Subproof.fromSubproofNode(subproofNode, fileContext),

package/src/reference.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Metavariable from "./metavariable";
+import shim from "./shim";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
@@ -67,7 +67,8 @@ export default class Reference {
   }
 
   static fromReferenceNode(referenceNode, fileContext) {
-    const metavariableNode = metavariableNodeQuery(referenceNode),
+    const { Metavariable } = shim,
+          metavariableNode = metavariableNodeQuery(referenceNode),
           localContext = LocalContext.fromFileContext(fileContext),
           metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           reference = new Reference(metavariable);

package/src/rule.js

@@ -3,12 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Premise from "./premise";
-import Conclusion from "./conclusion";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 
 import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -73,23 +68,19 @@ class Rule {
   }
 
   unifyStatement(statement, localContext) {
-    let statementUnified = false;
+    let statementUnified;
 
-    const proofSteps = localContext.getProofSteps(),
-          substitutions = Substitutions.fromNothing(),
-          proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing();
 
-    if (proofStepsUnified) {
-      const statementUnifiedWithConclusion = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
+    statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
 
-      if (statementUnifiedWithConclusion) {
-        const localContextB = localContext; ///
+    if (statementUnified) {
+      const proofSteps = localContext.getProofSteps(),
+            proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 
-        localContext = LocalContext.fromFileContext(this.fileContext);
-
-        const localContextA = localContext; ///
-
-        const substitutionsResolved = substitutions.resolve(localContextA, localContextB);
+      if (proofStepsUnified) {
+        const substitutionsResolved = substitutions.areResolved();
 
         statementUnified = substitutionsResolved; ///
       }
@@ -125,15 +116,15 @@ class Rule {
 
     this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             premisesVerified = this.premises.every((premise) => {
               const premiseVerified = premise.verify(localContext);
@@ -150,7 +141,8 @@ class Rule {
           let proofVerified = true; ///
 
           if (this.proof !== null) {
-            const substitutions = Substitutions.fromNothing();
+            const { Substitutions } = shim,
+                  substitutions = Substitutions.fromNothing();
 
             proofVerified = this.proof.verify(substitutions, this.conclusion, localContext);
           }
@@ -204,7 +196,8 @@ class Rule {
   }
 
   static fromRuleNode(ruleNode, fileContext) {
-    const proofNode = proofNodeQuery(ruleNode),
+    const { Label, Proof, Premise, Conclusion } = shim,
+          proofNode = proofNodeQuery(ruleNode),
           labelNodes = labelNodesQuery(ruleNode),
           premiseNodes = premiseNodesQuery(ruleNode),
           conclusionNode = conclusionNodeQuery(ruleNode),

package/src/statement/qualified.js

@@ -12,7 +12,7 @@ import { assignAssignments } from "../utilities/assignments";
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement"),
       referenceNodeQuery = nodeQuery("/qualifiedStatement/reference");
 
-export default class QualifiedStatement {
+class QualifiedStatement {
   constructor(string, statement, reference) {
     this.string = string;
     this.statement = statement;
@@ -71,7 +71,7 @@ export default class QualifiedStatement {
     return statementUnified;
   }
 
-  verify(substitutions, localContext) {
+  verify(substitutions, assignments, stated, localContext) {
     let verified;
 
     const qualifiedStatementString = this.string; ///
@@ -79,9 +79,7 @@ export default 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);
@@ -127,3 +125,9 @@ export default class QualifiedStatement {
     return qualifiedStatement;
   }
 }
+
+Object.assign(shim, {
+  QualifiedStatement
+});
+
+export default QualifiedStatement;

package/src/statement.js

@@ -171,18 +171,18 @@ class Statement {
     return verified;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const statementNode = this.node,  ///
           statementString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${statementString}' statement at top level...`);
+    fileContext.trace(`Verifying the '${statementString}' statement when declared...`);
 
     verifiedAtTopLevel = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${statementString}' statement at top level.`);
+      fileContext.debug(`...verified the '${statementString}' statement when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/subDerivation.js

@@ -10,7 +10,7 @@ const { last } = arrayUtilities;
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
 
-export default class SubDerivation {
+class SubDerivation {
   constructor(proofSteps) {
     this.proofSteps = proofSteps;
   }
@@ -52,4 +52,10 @@ export default class SubDerivation {
     return subDerivation;
 
   }
-}
+}
+
+Object.assign(shim, {
+  SubDerivation
+});
+
+export default SubDerivation;

package/src/subproof.js

@@ -1,16 +1,16 @@
 "use strict";
 
-import Supposition from "./supposition";
+import shim from "./shim";
+
 import LocalContext from "./context/local";
-import SubDerivation from "./subDerivation";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import {subproofNodeAsSubproofString, subproofStringFromSubproofNode} from "./utilities/subproof";
+import { subproofStringFromSubproofNode } from "./utilities/subproof";
 
 const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
-export default class Subproof {
+class Subproof {
   constructor(string, suppositions, subDerivation) {
     this.string = string;
     this.suppositions = suppositions;
@@ -79,7 +79,8 @@ export default class Subproof {
     let subproof = null;
 
     if (subproofNode !== null) {
-      const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+      const { Supposition, SubDerivation } = shim,
+            subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
             suppositionNodes = suppositionNodesQuery(subproofNode),
             subDerivationNode = subDerivationNodeQuery(subproofNode),
             string = subproofString,  ///
@@ -96,3 +97,9 @@ export default class Subproof {
     return subproof;
   }
 }
+
+Object.assign(shim, {
+  Subproof
+});
+
+export default Subproof;

package/src/substitution/statementForMetavariable.js

@@ -3,21 +3,25 @@
 import shim from "../shim";
 import Substitution from "../substitution";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 import metaLevelUnifier from "../unifier/metaLevel";
 
 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;
   }
@@ -30,10 +34,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return this.substitution;
   }
 
-  getMetavariableName() {
-    const metavariableName = this.metavariable.getName();
+  getMetavariableNode() {
+    const metavariableNode = this.metavariable.getNode();
 
-    return metavariableName;
+    return metavariableNode;
   }
 
   isSimple() {
@@ -43,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 metavariableName = this.getMetavariableName(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName);
+    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) {
@@ -83,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);
@@ -104,7 +115,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   unifyStatement(statement, localContextA, localContextB) {
     let substitution = null;
 
-    const substitutions = Substitutions.fromNothing(),
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing(),
           statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
@@ -128,7 +140,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementNodeMatches;
   }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
   matchSubstitutionNode(substitutionNode) {
     let substitutionNodeMatches;
@@ -146,12 +158,12 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return substitutionNodeMatches;
   }
 
-  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
+          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
 
-    return metavariableNameAndSubstitutionNodeMatches;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   toJSON() {
@@ -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;
   }
@@ -188,9 +201,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
     statement = Statement.fromStatementNode(statementNode, localContext);
 
-    const substitution = null,
-          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+    const string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+          resolved = true,
+          substitution = null,
+          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/substitution.js

@@ -35,10 +35,10 @@ class Substitution {
     return substitutionNode;
   }
 
-  getMetavariableName() {
-    const metavariableName = null;
+  getMetavariableNode() {
+    const metavariableNode = null;
 
-    return metavariableName;
+    return metavariableNode;
   }
 
   isSimple() {
@@ -90,16 +90,16 @@ class Substitution {
     return variableNameMatches;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = false;
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = false;
 
-    return metavariableNameMatches;
+    return metavariableNodeMatches;
   }
 
-  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const metavariableNameAndSubstitutionNodeMatches = false;
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeAndSubstitutionNodeMatches = false;
 
-    return metavariableNameAndSubstitutionNodeMatches;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {