occam-verify-cli 0.0.1089 → 0.0.1091

package/src/statement.js

@@ -16,8 +16,8 @@ import { statementNodeFromUnqualifiedStatementNode,
          unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "./utilities/node";
 
 const statementNodeQuery = nodeQuery("/*//statement"),
-      statementVariableNodesQuery = nodesQuery("/statement//variable"),
-      statementMetavariableNodesQuery = nodesQuery("/statement//metavariable");
+      statementTermNodesQuery = nodesQuery("/statement//term"),
+      statementFrameNodesQuery = nodesQuery("/statement//frame");
 
 class Statement {
   constructor(string, node, tokens) {
@@ -46,58 +46,58 @@ class Statement {
     return equalTo;
   }
 
-  isVariableContained(variable, localContext) {
-    let variableContained;
+  isTermContained(term, context) {
+    let termContained;
 
-    const variableString = variable.getString(),
+    const termString = term.getString(),
           statementString = this.string;  ///
 
-    localContext.trace(`Is the '${variableString}' variable contained in the '${statementString}' statement...`);
+    context.trace(`Is the '${termString}' term contained in the '${statementString}' statement...`);
 
-    const variableNode = variable.getNode(),
+    const termNode = term.getNode(),
           statementNode = this.node,
-          statementVariableNodes = statementVariableNodesQuery(statementNode);
+          statementTermNodes = statementTermNodesQuery(statementNode);
 
-    variableContained = statementVariableNodes.some((statementVariableNode) => {  ///
-      const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
+    termContained = statementTermNodes.some((statementTermNode) => {  ///
+      const termNodeMatchesStatementVariableNode = termNode.match(statementTermNode);
 
-      if (variableNodeMatchesStatementVariableNode) {
+      if (termNodeMatchesStatementVariableNode) {
         return true;
       }
     });
 
-    if (variableContained) {
-      localContext.debug(`...the '${variableString}' variable is contained in the '${statementString}' statement.`);
+    if (termContained) {
+      context.debug(`...the '${termString}' term is contained in the '${statementString}' statement.`);
     }
 
-    return variableContained;
+    return termContained;
   }
 
-  isMetavariableContained(metavariable, localContext) {
-    let metavariableContained;
+  isFrameContained(frame, context) {
+    let frameContained;
 
-    const metavariableString = metavariable.getString(),
+    const frameString = frame.getString(),
           statementString = this.string;  ///
 
-    localContext.trace(`Is the '${metavariableString}' metavariable contained in the '${statementString}' statement...`);
+    context.trace(`Is the '${frameString}' frame contained in the '${statementString}' statement...`);
 
-    const metavariableNode = metavariable.getNode(),
+    const frameNode = frame.getNode(),
           statementNode = this.node,
-          statementMetavariableNodes = statementMetavariableNodesQuery(statementNode);
+          statementFrameNodes = statementFrameNodesQuery(statementNode);
 
-    metavariableContained = statementMetavariableNodes.some((statementMetavariableNode) => {  ///
-      const metavariableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
+    frameContained = statementFrameNodes.some((statementFrameNode) => {  ///
+      const frameNodeMatchesStatementMetavariableNode = frameNode.match(statementFrameNode);
 
-      if (metavariableNodeMatchesStatementMetavariableNode) {
+      if (frameNodeMatchesStatementMetavariableNode) {
         return true;
       }
     });
 
-    if (metavariableContained) {
-      localContext.debug(`...the '${metavariableString}' metavariable is contained in the '${statementString}' statement.`);
+    if (frameContained) {
+      context.debug(`...the '${frameString}' frame is contained in the '${statementString}' statement.`);
     }
 
-    return metavariableContained;
+    return frameContained;
   }
 
   matchStatementNode(statementNode) {
@@ -106,20 +106,16 @@ class Statement {
     return statementNodeMatches;
   }
 
-  resolveIndependently(substitutions, localContextA, localContextB) {
+  resolveIndependently(substitutions, generalContext, specificContext) {
     let resolvedIndependently;
 
     const statement = this, ///
           statementString = this.string;  ///
 
-    localContextB.trace(`Resolving the '${statementString}' statement independently...`);
-
-    const context = localContextA;  ///
-
-    localContextA = LocalContext.fromContextAndTokens(context, this.tokens);
+    specificContext.trace(`Resolving the '${statementString}' statement independently...`);
 
     const resolved = resolveMixins.some((resolveMixin) => {
-      const resolved = resolveMixin(statement, substitutions, localContextA, localContextB);
+      const resolved = resolveMixin(statement, substitutions, generalContext, specificContext);
 
       if (resolved) {
         return true;
@@ -129,52 +125,53 @@ class Statement {
     resolvedIndependently = resolved; ///
 
     if (resolvedIndependently) {
-      localContextB.debug(`...resolved the '${statementString}' statement independently.`);
+      specificContext.debug(`...resolved the '${statementString}' statement independently.`);
     }
 
     return resolvedIndependently;
   }
 
-  unifyStatement(statement, substitutions, localContextA, localContextB) {
+  unifyStatement(statement, substitutions, generalContext, specificContext) {
     let statementUnified;
 
-    const statementA = this,  ///
-          statementB = statement, ///
-          statementAString = statementA.getString(),
-          statementBString = statementB.getString();
+    const generalStatement = this,  ///
+          specificStatement = statement, ///
+          generalStatementString = generalStatement.getString(),
+          specificStatementString = specificStatement.getString();
 
-    localContextB.trace(`Unifying the '${statementBString}' statement with the '${statementAString}' statement...`);
+    specificContext.trace(`Unifying the '${specificStatementString}' statement with the '${generalStatementString}' statement...`);
 
-    const statementANode = statementA.getNode(),
-          statementBNode = statementB.getNode(),
-          context = localContextA,  ///
-          nodeA = statementANode, ///
-          nodeB = statementBNode; ///
+    const context = generalContext, ///
+          localContext = LocalContext.fromContextAndTokens(context, this.tokens);
 
-    localContextA = LocalContext.fromContextAndTokens(context, this.tokens);
+    generalContext = localContext;  ///
 
-    const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+    const generalStatementNode = generalStatement.getNode(),  ///
+          specificStatementNode = specificStatement.getNode(),  ///
+          generalNode = generalStatementNode, ///
+          specificNode = specificStatementNode,
+          unifiedAtMetaLevel = metaLevelUnifier.unify(generalNode, specificNode, substitutions, generalContext, specificContext);
 
     statementUnified = unifiedAtMetaLevel; ///
 
     if (statementUnified) {
-      localContextB.debug(`...unified the '${statementBString}' statement with the '${statementAString}' statement.`);
+      specificContext.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
     }
 
     return statementUnified;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified = false;
 
     const statement = this, ///
           statementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${statementString}' statement...`);
+    context.trace(`Verifying the '${statementString}' statement...`);
 
     if (!verified) {
       verified = verifyMixins.some((verifyMixin) => {
-        const verified = verifyMixin(statement, assignments, stated, localContext);
+        const verified = verifyMixin(statement, assignments, stated, context);
 
         if (verified) {
           return true;
@@ -184,7 +181,7 @@ class Statement {
 
     if (!verified) {
       const unified = unifyMixins.some((unifyMixin) => {
-        const unified = unifyMixin(statement, assignments, stated, localContext);
+        const unified = unifyMixin(statement, assignments, stated, context);
 
         if (unified) {
           return true;
@@ -195,7 +192,7 @@ class Statement {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${statementString}' statement.`);
+      context.debug(`...verified the '${statementString}' statement.`);
     }
 
     return verified;
@@ -218,24 +215,24 @@ class Statement {
     return verifiedAtTopLevel;
   }
 
-  verifyGivenMetaType(metaType, assignments, stated, localContext) {
+  verifyGivenMetaType(metaType, assignments, stated, context) {
     let verifiedGivenMetaType = false;
 
     const metaTypeString = metaType.getString(),
           statementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
+    context.trace(`Verifying the '${statementString}' statement given the '${metaTypeString}' meta-type...`);
 
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const verified = this.verify(assignments, stated, localContext)
+      const verified = this.verify(assignments, stated, context)
 
       verifiedGivenMetaType = verified; ///
     }
 
     if (verifiedGivenMetaType) {
-      localContext.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
+      context.debug(`...verified the '${statementString}' statement given the '${metaTypeString}' meta-type.`);
     }
 
     return verifiedGivenMetaType;
@@ -267,13 +264,13 @@ class Statement {
     return statement;
   }
 
-  static fromStatementNode(statementNode, localContext) {
+  static fromStatementNode(statementNode, context) {
     let statement = null;
 
     if (statementNode !== null) {
       const node = statementNode, ///
-            tokens = localContext.nodeAsTokens(node),
-            string = localContext.tokensAsString(tokens);
+            tokens = context.nodeAsTokens(node),
+            string = context.tokensAsString(tokens);
 
       statement = new Statement(string, node, tokens);
     }
@@ -281,21 +278,21 @@ class Statement {
     return statement;
   }
 
-  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+  static fromDefinedAssertionNode(definedAssertionNode, context) {
     const statementNode = statementNodeQuery(definedAssertionNode),
           node = statementNode, ///
-          tokens = localContext.nodeAsTokens(node),
-          string = localContext.tokensAsString(tokens),
+          tokens = context.nodeAsTokens(node),
+          string = context.tokensAsString(tokens),
           statement = new Statement(string, node, tokens);
 
     return statement;
   }
 
-  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+  static fromContainedAssertionNode(containedAssertionNode, context) {
     const statementNode = statementNodeQuery(containedAssertionNode),
           node = statementNode, ///
-          tokens = localContext.nodeAsTokens(node),
-          string = localContext.tokensAsString(tokens),
+          tokens = context.nodeAsTokens(node),
+          string = context.tokensAsString(tokens),
           statement = new Statement(string, node, tokens);
 
     return statement;

package/src/subDerivation.js

@@ -25,11 +25,11 @@ class SubDerivation {
     return lastProofStep;
   }
 
-  verify(substitutions, localContext) {
+  verify(substitutions, context) {
     let verified;
 
     verified = this.proofSteps.every((proofStep) => { ///
-      const proofStepVerified = proofStep.verify(substitutions, localContext);
+      const proofStepVerified = proofStep.verify(substitutions, context);
 
       if (proofStepVerified) {
         return true;
@@ -50,7 +50,6 @@ class SubDerivation {
           subDerivation = new SubDerivation(proofSteps);
 
     return subDerivation;
-
   }
 }
 

package/src/subproof.js

@@ -51,13 +51,15 @@ class Subproof {
     return statements;
   }
 
-  verify(substitutions, localContext) {
+  verify(substitutions, context) {
     let subproofVerified = false;
 
-    localContext = LocalContext.fromLocalContext(localContext);  ///
+    const localContext = LocalContext.fromContext(context);  ///
+
+    context = localContext; ///
 
     const suppositionsVerified = this.suppositions.every((supposition) => {
-      const suppositionVerified = supposition.verify(localContext);
+      const suppositionVerified = supposition.verify(context);
 
       if (suppositionVerified) {
         return true;
@@ -65,7 +67,7 @@ class Subproof {
     });
 
     if (suppositionsVerified) {
-      const subDerivationVerified = this.subDerivation.verify(substitutions, localContext);
+      const subDerivationVerified = this.subDerivation.verify(substitutions, context);
 
       if (subDerivationVerified) {
         subproofVerified = true;

package/src/substitution/frameForMetavariable.js

@@ -15,13 +15,11 @@ const frameNodeQuery = nodeQuery("/substitution/frame[0]"),
       substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(string, frame, metavariable, substitutionNode, substitutionTokens) {
-    super(string);
+  constructor(string, node, tokens, frame, metavariable) {
+    super(string, node, tokens);
 
     this.frame = frame;
     this.metavariable = metavariable;
-    this.substitutionNode = substitutionNode;
-    this.substitutionTokens = substitutionTokens;
   }
 
   getFrame() {
@@ -32,14 +30,6 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return this.metavariable;
   }
 
-  getSubstitutionNode() {
-    return this.substitutionNode;
-  }
-
-  getSubstitutionTokens() {
-    return this.substitutionTokens;
-  }
-
   getMetavariableName() {
     const metavariableName = this.metavariable.getName();
 
@@ -54,22 +44,6 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     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);
-  }
-
-  setSubstitutionTokens(localContext) {
-  }
-
   isEqualTo(substitution) {
     let equalTo = false;
 
@@ -93,18 +67,20 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   matchMetavariableName(metavariableName) {
     let metavariableNameMatches;
 
-    const metavariableNameA = metavariableName; ///
+    const generalMetavariableName = metavariableName; ///
 
     metavariableName = this.metavariable.getName();
 
-    const metavariableNameB = metavariableName; ///
+    const specificMetavariableName = metavariableName; ///
 
-    metavariableNameMatches = (metavariableNameA === metavariableNameB);
+    metavariableNameMatches = (generalMetavariableName === specificMetavariableName);
 
     return metavariableNameMatches;
   }
 
   matchSubstitutionNode(substitutionNode) {
+    debugger
+
     let substitutionNodeMatches;
 
     if ((substitutionNode === null) && (this.substitutionNode === null)) {
@@ -128,7 +104,7 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return metavariableNameAndSubstitutionNodeMatches;
   }
 
-  static fromStatementNode(statementNode, localContext) {
+  static fromStatementNode(statementNode, context) {
     let frameForMetavariableSubstitution = null;
 
     const substitutionNode = substitutionNodeQuery(statementNode);
@@ -139,31 +115,39 @@ export default class FrameForMetavariableSubstitution extends Substitution {
 
       if ((frameNode !== null) && (metavariableNode !== null)) {
         const { Frame, Metavariable } = shim,
-              frame = Frame.fromFrameNode(frameNode, localContext),
-              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
-              string = stringFromFrameAndMetavariable(frame, metavariable, localContext),
-              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
+              frame = Frame.fromFrameNode(frameNode, context),
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
+              node = substitutionNode,  ///
+              tokens = context.nodeAsTokens(node),
+              string = stringFromFrameAndMetavariable(frame, metavariable);
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frame, metavariable, substitutionNode, substitutionTokens);
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, node, tokens, frame, metavariable);
       }
     }
 
     return frameForMetavariableSubstitution;
   }
 
-  static fromFrameAndMetavariable(frame, metavariable, localContext) {
-    const string = stringFromFrameAndMetavariable(frame, metavariable, localContext),
-          substitutionNode = null,
-          substitutionTokens = null,
-          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frame, metavariable, substitutionNode, substitutionTokens);
+  static fromFrameAndMetavariable(frame, metavariable, context) {
+    const lexer = context.getLexer(),
+          parser = context.getParser(),
+          string = stringFromFrameAndMetavariable(frame, metavariable),
+          substitutionString = string,  ///
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+          substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
+          substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, substitutionNode),
+          node = substitutionNode,  //
+          tokens = substitutionTokens,  ///
+          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, node, tokens, frame, metavariable);
 
     return statementForMetavariableSubstitution;
   }
 }
 
-function stringFromFrameAndMetavariable(frame, metavariable, localContext) {
-  const frameNode = frame.getNode(),
-        frameString = localContext.nodeAsString(frameNode),
+function stringFromFrameAndMetavariable(frame, metavariable) {
+  const frameString = frame.getString(),
         metavariableString = metavariable.getString(),
         string = `[${frameString} for [${metavariableString}]]`;