occam-verify-cli 0.0.1067 → 0.0.1069

package/src/reference.js

@@ -1,8 +1,11 @@
 "use strict";
 
 import Metavariable from "./metavariable";
+import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
+import { referenceMetaType } from "./metaType";
+import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
 
 const metavariableNodeQuery = nodeQuery("//reference/metavariable");
 
@@ -25,24 +28,27 @@ export default class Reference {
     return metavariableNode;
   }
 
-  verifyAtTopLevel(fileContext) {
-    let verifiedAtTopLevel;
+  verify(localContext) {
+    let verified;
 
     const referenceString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${referenceString}' reference at top level...`);
+    localContext.trace(`Verifying the '${referenceString}' reference...`);
 
-    verifiedAtTopLevel = true;
+    const metaType = referenceMetaType, ///
+          metavariableVerifiedGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, localContext);
 
-    if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${referenceString}' reference at top level.`);
+    verified = metavariableVerifiedGivenMetaType; ///
+
+    if (verified) {
+      localContext.debug(`...verified the '${referenceString}' reference.`);
     }
 
-    return verifiedAtTopLevel;
+    return verified;
   }
 
   toJSON() {
-    const metavariableJSON = this.metavariable.toJSON(),
+    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           metavariable = metavariableJSON,  ///
           string = this.string,
           json = {
@@ -54,22 +60,16 @@ export default class Reference {
   }
 
   static fromJSON(json, fileContext) {
-    const { string } = json;
-
-    let { metavariable } = json;
-
-    json = metavariable;  ///
-
-    metavariable = Metavariable.fromJSON(json, fileContext);
-
-    const reference = new Reference(string, metavariable);
+    const metavariable = metavariableFromJSON(json, fileContext),
+          reference = new Reference(string, metavariable);
 
     return reference;
   }
 
   static fromReferenceNode(referenceNode, fileContext) {
     const metavariableNode = metavariableNodeQuery(referenceNode),
-          metavariable = Metavariable.fromMetavariableNode(metavariableNode, fileContext),
+          localContext = LocalContext.fromFileContext(fileContext),
+          metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           reference = new Reference(metavariable);
 
     return reference;

package/src/rule.js

@@ -2,6 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
+import shim from "./shim";
 import Label from "./label";
 import Proof from "./proof";
 import Premise from "./premise";
@@ -9,7 +10,14 @@ import Conclusion from "./conclusion";
 import LocalContext from "./context/local";
 import Substitutions from "./substitutions";
 
+import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "./utilities/query";
+import { labelsFromJSON,
+         premisesFromJSON,
+         conclusionFromJSON,
+         labelsToLabelsJSON,
+         premisesToPremisesJSON,
+         conclusionToConclusionJSON } from "./utilities/json";
 
 const { reverse, correlate } = arrayUtilities;
 
@@ -18,9 +26,10 @@ const proofNodeQuery = nodeQuery("/rule/proof"),
       premiseNodesQuery = nodesQuery("/rule/premise"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion");
 
-export default class Rule {
-  constructor(fileContext, labels, premises, conclusion, proof) {
+class Rule {
+  constructor(fileContext, string, labels, premises, conclusion, proof) {
     this.fileContext = fileContext;
+    this.string = string;
     this.labels = labels;
     this.premises = premises;
     this.conclusion = conclusion;
@@ -31,6 +40,10 @@ export default class Rule {
     return this.fileContext;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getLabels() {
     return this.labels;
   }
@@ -70,7 +83,13 @@ export default class Rule {
       const statementUnifiedWithConclusion = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
 
       if (statementUnifiedWithConclusion) {
-        const substitutionsResolved = substitutions.resolve(localContext);
+        const localContextB = localContext; ///
+
+        localContext = LocalContext.fromFileContext(this.fileContext);
+
+        const localContextA = localContext; ///
+
+        const substitutionsResolved = substitutions.resolve(localContextA, localContextB);
 
         statementUnified = substitutionsResolved; ///
       }
@@ -102,9 +121,9 @@ export default class Rule {
   verify() {
     let verified = false;
 
-    const labelsString = labelsStringFromLabels(this.labels);
+    const ruleString = this.string; ///
 
-    this.fileContext.trace(`Verifying the '${labelsString}' rule...`);
+    this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
 
     const labelsVerifiedAtTopLevel = this.labels.every((label) => {
       const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
@@ -148,24 +167,16 @@ export default class Rule {
     }
 
     if (verified) {
-      this.fileContext.debug(`...verified the '${labelsString}' rule.`);
+      this.fileContext.debug(`...verified the '${ruleString}' rule.`);
     }
 
     return verified;
   }
 
   toJSON() {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON();
-
-            return labelJSON;
-          }),
-          premisesJSON = this.premises.map((premise) => {
-            const premiseJSON = premise.toJSON();
-
-            return premiseJSON;
-          }),
-          conclusionJSON = this.conclusion.toJSON(),
+    const labelsJSON = labelsToLabelsJSON(this.labels),
+          premisesJSON = premisesToPremisesJSON(this.premises),
+          conclusionJSON = conclusionToConclusionJSON(this.conclusion),
           labels = labelsJSON,  ///
           premises = premisesJSON,  ///
           conclusion = conclusionJSON,  ///
@@ -181,39 +192,13 @@ export default class Rule {
   static fromJSON(json, fileContext) {
     let rule;
 
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSON(json, fileContext);
-
-      return label;
-    });
-
-    let { premises } = json;
-
-    const premisesJSON = premises;  ///
-
-    premises = premisesJSON.map((premiseJSON) => {
-      const json = premiseJSON, ///
-            premise = Premise.fromJSON(json, fileContext);
-
-      return premise;
-    });
+    const proof = null,
+          labels = labelsFromJSON(json, fileContext),
+          premises = premisesFromJSON(json, fileContext),
+          conclusion = conclusionFromJSON(json, fileContext),
+          string = stringFromLabels(labels);
 
-    let { conclusion } = json;
-
-    const conclusionJSON = conclusion;  ///
-
-    json = conclusionJSON;  ///
-
-    conclusion = Conclusion.fromJSON(json, fileContext);
-
-    const proof = null;
-
-    rule = new Rule(fileContext, labels, premises, conclusion, proof);
+    rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;
   }
@@ -234,19 +219,16 @@ export default class Rule {
             return premise;
           }),
           conclusion = Conclusion.fromConclusionNode(conclusionNode, fileContext),
+          string = stringFromLabels(labels),
           proof = Proof.fromProofNode(proofNode, fileContext),
-          rule = new Rule(fileContext, labels, premises, conclusion, proof);
+          rule = new Rule(fileContext, string, labels, premises, conclusion, proof);
 
     return rule;
   }
 }
 
-function labelsStringFromLabels(labels) {
-  const labelsString = labels.map((label) => {
-          const labelString = label.getString();
-
-          return labelString;
-        });
+Object.assign(shim, {
+  Rule
+});
 
-  return labelsString;
-}
+export default Rule;

package/src/statement/unqualified.js

@@ -1,14 +1,19 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import shim from "../shim";
 import LocalContext from "../context/local";
 
 import { trim } from "../utilities/string";
 import { nodeQuery } from "../utilities/query";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+const { reverse } = arrayUtilities;
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
-export default class UnqualifiedStatement {
+class UnqualifiedStatement {
   constructor(string, statement) {
     this.string = string;
     this.statement = statement;
@@ -32,7 +37,15 @@ export default class UnqualifiedStatement {
 
       const statementVerified = this.statement.verify(assignments, stated, localContext);
 
-      verified = statementVerified; ///
+      if (statementVerified) {
+        verified = true;
+      } else {
+        const statementUnifiedWithProofSteps = this.unifyStatementWithProofSteps(this.statement, assignments, stated, localContext);
+
+        if (statementUnifiedWithProofSteps) {
+          verified = true;
+        }
+      }
 
       if (verified) {
         localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
@@ -62,8 +75,26 @@ export default class UnqualifiedStatement {
     return statementUnified;
   }
 
+  unifyStatementWithProofSteps(statement, assignments, stated, localContext) {
+    let statementUnifiedWithProofSteps;
+
+    let proofSteps = localContext.getProofSteps();
+
+    proofSteps = reverse(proofSteps); ///
+
+    statementUnifiedWithProofSteps = proofSteps.some((proofStep) => {
+      const statementUnified = proofStep.unifyStatement(statement, localContext);
+
+      if (statementUnified) {
+        return true;
+      }
+    });
+
+    return statementUnifiedWithProofSteps;
+  }
+
   toJSON() {
-    const statementJSON = this.statement.toJSON(),
+    const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///
           string = this.string, ///
           json = {
@@ -75,15 +106,8 @@ export default class UnqualifiedStatement {
   }
 
   static fromJSON(json, fileContext) {
-    const { Statement } = shim;
-
-    let { statement } = json;
-
-    json = statement; ///
-
-    statement = Statement.fromJSON(json, fileContext);
-
     const { string } = json,
+          statement = statementFromJSON(json, fileContext),
           unqualifiedStatement = new UnqualifiedStatement(string, statement);
 
     return unqualifiedStatement;
@@ -111,3 +135,9 @@ export default class UnqualifiedStatement {
     return unqualifiedStatement;
   }
 }
+
+Object.assign(shim, {
+  UnqualifiedStatement
+});
+
+export default UnqualifiedStatement;

package/src/statement.js

@@ -117,16 +117,19 @@ class Statement {
 
     const statementANode = statementA.getNode(),
           statementBNode = statementB.getNode(),
+          context = localContextA,  ///
           nodeA = statementANode, ///
           nodeB = statementBNode; ///
 
-    localContextA = LocalContext.fromLocalContextAndTokens(localContextA, this.tokens);
+    localContextA = LocalContext.fromContextAndTokens(context, this.tokens);
 
     const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
     statementUnified = unifiedAtMetaLevel; ///
 
-    localContextB.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+    if (statementUnified) {
+      localContextB.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+    }
 
     return statementUnified;
   }
@@ -219,9 +222,9 @@ class Statement {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
-          statementString = string, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
+          statementString = string, ///
           unqualifiedStatementString = unqualifiedStatementStringFromStatementString(statementString),
           unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
           unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),

package/src/substitution/frameForMetavariable.js

@@ -4,92 +4,126 @@ import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
+import { substitutionNodeFromUnqualifiedStatementNode,
+         unqualifiedStatementStringFromSubstitutionString,
+         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "../utilities/node";
+import { unqualifiedStatementTokensFromUnqualifiedStatementString,
+         substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode } from "../utilities/tokens";
 
-const substitutionNodeQuery = nodeQuery("/statement/substitution"),
-      substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
+const frameNodeQuery = nodeQuery("/substitution/frame[0]"),
+      metavariableNodeQuery = nodeQuery("/substitution/frame[1]/metavariable!"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(string, frameNode, metavariableNode, substitutionNode) {
+  constructor(string, frame, metavariable, substitutionNode, substitutionTokens) {
     super(string);
 
-    this.frameNode = frameNode;
-    this.metavariableNode = metavariableNode;
+    this.frame = frame;
+    this.metavariable = metavariable;
     this.substitutionNode = substitutionNode;
+    this.substitutionTokens = substitutionTokens;
   }
 
-  getFrameNode() {
-    return this.frameNode;
+  getFrame() {
+    return this.frame;
   }
 
-  getMetavariableNode() {
-    return this.metavariableNode;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getSubstitutionNode() {
     return this.substitutionNode;
   }
 
-  transformed(substitutions) {
-    let transformedSubstitution = null;
+  getSubstitutionTokens() {
+    return this.substitutionTokens;
+  }
 
-    const transformedFrameNode = transformFrameNode(this.frameNode, substitutions),
-          transformedMetavariableNode = transformMetavariableNode(this.metavariableNode, substitutions);
+  getMetavariableName() {
+    const metavariableName = this.metavariable.getName();
 
-    if ((transformedFrameNode !== null) && (transformedMetavariableNode !== null)) {
-      const string = null,  ///
-            frameNode = transformedFrameNode, ///
-            metavariableNode = transformedMetavariableNode, ///
-            substitutionNode = null,
-            frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
+    return metavariableName;
+  }
 
-      transformedSubstitution = frameForMetavariableSubstitution;  ///
-    }
+  getSubstitutionString() {
+    const frameString = this.frame.getString(),
+          metavariableString = this.metavariable.getString(),
+          substitutionString = `[[${frameString}] for [${metavariableString}]]`;
+
+    return substitutionString;
+  }
+
+  setSubstitutionNodeAndTokens(localContext) {
+    const lexer = localContext.getLexer(),
+          parser = localContext.getParser(),
+          substitutionString = this.getSubstitutionString(),
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
+
+    this.substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+    this.substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, this.substitutionNode);
+  }
 
-    return transformedSubstitution;
+  setSubstitutionTokens(localContext) {
   }
 
   isEqualTo(substitution) {
     let equalTo = false;
 
     const frameNode = substitution.getFrameNode(),
-          metavariableNode = substitution.getMetavariableNode();
+          metavariableName = substitution.getMetavariableName();
 
-    if ((frameNode !== null) && (metavariableNode !== null)) {
+    if ((frameNode !== null) && (metavariableName !== null)) {
       const frameNodeMatches = this.matchFrameNode(frameNode),
-            metavariableNodeMatches = this.matchMetavariableNode(metavariableNode);
+            metavariableNameMatches = this.matchMetavariableName(metavariableName);
 
-      equalTo = (frameNodeMatches && metavariableNodeMatches);
+      equalTo = (frameNodeMatches && metavariableNameMatches);
     }
 
     return equalTo;
   }
 
-  matchFrameNode(frameNode) {
-    const frameNodeMatches = this.frameNode.match(frameNode);
+  matchFrameNode(frameNode) { return this.frame.matchFrameNode(frameNode); }
 
-    return frameNodeMatches;
-  }
+  matchMetavariableName(metavariableName) {
+    let metavariableNameMatches;
+
+    const metavariableNameA = metavariableName; ///
+
+    metavariableName = this.metavariable.getName();
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const metavariableNameB = metavariableName; ///
 
-    return metavariableNodeMatches;
+    metavariableNameMatches = (metavariableNameA === metavariableNameB);
+
+    return metavariableNameMatches;
   }
 
   matchSubstitutionNode(substitutionNode) {
-    const substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+    let substitutionNodeMatches;
+
+    if ((substitutionNode === null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = true;
+    } else if ((substitutionNode === null) && (this.substitutionNode !== null)) {
+      substitutionNodeMatches = false;
+    } else if ((substitutionNode !== null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = false;
+    } else {
+      substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+    }
 
     return substitutionNodeMatches;
   }
 
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
+          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
 
-    return metavariableNodeAndSubstitutionNodeMatches;
+    return metavariableNameAndSubstitutionNodeMatches;
   }
 
   static fromStatementNode(statementNode, localContext) {
@@ -98,18 +132,17 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode !== null) {
-      let substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+      const frameNode = frameNodeQuery(substitutionNode),
+            metavariableNode = metavariableNodeQuery(substitutionNode);
 
-      if (substitutionFrameNode !== null) {
+      if ((frameNode !== null) && (metavariableNode !== null)) {
         const { Frame, Metavariable } = shim,
-              substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
-              metavariableNode = substitutionMetavariableNode,  ///
-              frameNode = substitutionFrameNode,  ///
-              frame = Frame.fromTermNode(frameNode, localContext),
-              variable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
-              string = stringFromFrameAndMetavariable(frame, variable, localContext);
-
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
+              frame = Frame.fromFrameNode(frameNode, localContext),
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              string = stringFromFrameAndMetavariable(frame, metavariable, localContext),
+              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
+
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frame, metavariable, substitutionNode, substitutionTokens);
       }
     }
 
@@ -118,60 +151,14 @@ export default class FrameForMetavariableSubstitution extends Substitution {
 
   static fromFrameAndMetavariable(frame, metavariable, localContext) {
     const string = stringFromFrameAndMetavariable(frame, metavariable, localContext),
-          frameNode = frame.getNode(),
-          metavariableNode = metavariable.getNode(),
           substitutionNode = null,
-          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
+          substitutionTokens = null,
+          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frame, metavariable, substitutionNode, substitutionTokens);
 
     return statementForMetavariableSubstitution;
   }
 }
 
-function transformFrameNode(frameNode, substitutions) {
-  let transformedFrameNode = null;
-
-  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
-
-  if (frameMetavariableNode !== null) {
-    const metavariableNode = frameMetavariableNode;  ///
-
-    substitutions.someSubstitution((substitution) => {
-      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
-
-      if (metavariableNodeMatches) {
-        const frameNode = substitution.getFrameNode();
-
-        transformedFrameNode = frameNode; ////
-
-        return true;
-      }
-    });
-  }
-
-  return transformedFrameNode;
-}
-
-function transformMetavariableNode(metavariableNode, substitutions) {
-  let transformedMetavariableNode = null;
-
-  substitutions.someSubstitution((substitution) => {
-    const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
-
-    if (metavariableNodeMatches) {
-      const frameNode = substitution.getFrameNode(),
-            frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
-
-      if (frameMetavariableNode !== null) {
-        transformedMetavariableNode = frameMetavariableNode;  ///
-
-        return true;
-      }
-    }
-  });
-
-  return transformedMetavariableNode;
-}
-
 function stringFromFrameAndMetavariable(frame, metavariable, localContext) {
   const frameNode = frame.getNode(),
         frameString = localContext.nodeAsString(frameNode),