occam-verify-cli 0.0.1089 → 0.0.1091

package/lib/verifier/statementAsCombinator.js

@@ -128,7 +128,7 @@ _define_property(StatementAsCombinatorVerifier, "maps", [
     {
         nodeQuery: termNodeQuery,
         verify: function(termNode, fileContext) {
-            var Term = _shim.default.Term, localContext = _local.default.fromFileContext(fileContext), term = Term.fromTermNode(termNode, localContext), termVerified = term.verify(localContext, function() {
+            var Term = _shim.default.Term, localContext = _local.default.fromFileContext(fileContext), context = localContext, term = Term.fromTermNode(termNode, context), termVerified = term.verify(localContext, function() {
                 var verifiedAhead = true;
                 return verifiedAhead;
             });
@@ -150,4 +150,4 @@ _define_property(StatementAsCombinatorVerifier, "maps", [
 var statementAsCombinatorVerifier = new StatementAsCombinatorVerifier();
 var _default = statementAsCombinatorVerifier;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/verifier/termAsConstructor.js

@@ -131,7 +131,7 @@ _define_property(TermAsConstructorVerifier, "maps", [
     {
         nodeQuery: termNodeQuery,
         verify: function(termNode, fileContext, verifyAhead) {
-            var Term = _shim.default.Term, localContext = _local.default.fromFileContext(fileContext), term = Term.fromTermNode(termNode, localContext), termVerified = term.verify(localContext, verifyAhead);
+            var Term = _shim.default.Term, localContext = _local.default.fromFileContext(fileContext), context = localContext, term = Term.fromTermNode(termNode, context), termVerified = term.verify(localContext, verifyAhead);
             return termVerified;
         }
     },
@@ -153,4 +153,4 @@ _define_property(TermAsConstructorVerifier, "maps", [
 var termAsConstructorVerifier = new TermAsConstructorVerifier();
 var _default = termAsConstructorVerifier;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.1089",
+  "version": "0.0.1091",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,7 +12,7 @@
   "dependencies": {
     "argumentative": "^2.0.32",
     "necessary": "^14.2.1",
-    "occam-custom-grammars": "^5.0.897",
+    "occam-custom-grammars": "^5.0.899",
     "occam-entities": "^1.0.176",
     "occam-file-system": "^6.0.214",
     "occam-grammar-utilities": "^8.0.220",

package/src/assertion/contained.js

@@ -39,33 +39,33 @@ export default class ContainedAssertion {
     return this.statement;
   }
 
-  resolve(substitutions, localContext) {
+  resolve(substitutions, context) {
     let resolved;
 
     const containedAssertionString = this.string; ///
 
-    localContext.trace(`Resolving the '${containedAssertionString}' contained assertion...`);
+    context.trace(`Resolving the '${containedAssertionString}' contained assertion...`);
 
     const term = termFromTermAndSubstitutions(this.term, substitutions),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions),
           statement = statementFromStatementAndSubstitutions(this.statement, substitutions),
-          verifiedWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, localContext);
+          verifiedWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, context);
 
     resolved = verifiedWhenDerived; ///
 
     if (resolved) {
-      localContext.debug(`...resolved the '${containedAssertionString}' contained assertion.`);
+      context.debug(`...resolved the '${containedAssertionString}' contained assertion.`);
     }
 
     return resolved;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified = false;
 
     const containedAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
+    context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
 
     stated = true;  ///
 
@@ -76,7 +76,7 @@ export default class ContainedAssertion {
         statementVerified = false;
 
     if (this.term !== null) {
-      termVerified = this.term.verify(localContext, () => {
+      termVerified = this.term.verify(context, () => {
         const verifiedAhead = true;
 
         return verifiedAhead;
@@ -84,11 +84,11 @@ export default class ContainedAssertion {
     }
 
     if (this.frame !== null) {
-      frameVerified = this.frame.verify(assignments, stated, localContext);
+      frameVerified = this.frame.verify(assignments, stated, context);
     }
 
     if (this.statement !== null) {
-      statementVerified = this.statement.verify(assignments, stated, localContext);
+      statementVerified = this.statement.verify(assignments, stated, context);
     }
 
     if (termVerified || frameVerified || statementVerified) {
@@ -96,9 +96,9 @@ export default class ContainedAssertion {
           verifiedWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+        verifiedWhenStated = this.verifyWhenStated(assignments, context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+        verifiedWhenDerived = this.verifyWhenDerived(context);
       }
 
       if (verifiedWhenStated || verifiedWhenDerived) {
@@ -107,54 +107,54 @@ export default class ContainedAssertion {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${containedAssertionString}' contained assertion.`);
+      context.debug(`...verified the '${containedAssertionString}' contained assertion.`);
     }
 
     return verified;
   }
 
-  verifyWhenStated(assignments, localContext) {
+  verifyWhenStated(assignments, context) {
     let verifiedWhenStated;
 
     const containedAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);
+    context.trace(`Verifying the '${containedAssertionString}' stated contained assertion...`);
 
     verifiedWhenStated = true;
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${containedAssertionString}' stated contained assertion.`);
+      context.debug(`...verified the '${containedAssertionString}' stated contained assertion.`);
     }
 
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(localContext) {
+  verifyWhenDerived(context) {
     let verifiedWhenDerived;
 
     const containedAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);
+    context.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);
 
-    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, localContext);
+    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, context);
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);
+      context.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);
     }
 
     return verifiedWhenDerived;
   }
 
-  static fromContainedAssertionNode(containedAssertionNode, localContext) {
+  static fromContainedAssertionNode(containedAssertionNode, context) {
     let containedAssertion = null;
 
     if (containedAssertionNode !== null) {
       const { Term, Frame, Statement } = shim,
             node = containedAssertionNode,  ///
-            string = localContext.nodeAsString(node),
-            term = Term.fromContainedAssertionNode(containedAssertionNode, localContext),
-            frame = Frame.fromContainedAssertionNode(containedAssertionNode, localContext),
-            statement = Statement.fromContainedAssertionNode(containedAssertionNode, localContext),
+            string = context.nodeAsString(node),
+            term = Term.fromContainedAssertionNode(containedAssertionNode, context),
+            frame = Frame.fromContainedAssertionNode(containedAssertionNode, context),
+            statement = Statement.fromContainedAssertionNode(containedAssertionNode, context),
             containedAssertionNegated = isAssertionNegated(containedAssertionNode),
             negated = containedAssertionNegated;  ///
 
@@ -165,38 +165,30 @@ export default class ContainedAssertion {
   }
 }
 
-function verifyWhenDerived(term, frame, statement, negated, localContext) {
+function verifyWhenDerived(term, frame, statement, negated, context) {
   let verifiedWhenDerived = false;
 
   if (term !== null) {
-    const variable = term.getVariable(localContext);
+    const termContained = statement.isTermContained(term, context);
 
-    if (variable !== null) {
-      const variableContained = statement.isVariableContained(variable, localContext);
-
-      if (!negated && variableContained) {
-        verifiedWhenDerived = true;
-      }
+    if (!negated && termContained) {
+      verifiedWhenDerived = true;
+    }
 
-      if (negated && !variableContained) {
-        verifiedWhenDerived = true;
-      }
+    if (negated && !termContained) {
+      verifiedWhenDerived = true;
     }
   }
 
   if (frame !== null) {
-    const metavariable = frame.getMetavariable(localContext);
+    const frameContained = statement.isFrameContained(frame, context);
 
-    if (metavariable !== null) {
-      const metavariableContained = statement.isMetavariableContained(metavariable, localContext);
-
-      if (!negated && metavariableContained) {
-        verifiedWhenDerived = true;
-      }
+    if (!negated && frameContained) {
+      verifiedWhenDerived = true;
+    }
 
-      if (negated && !metavariableContained) {
-        verifiedWhenDerived = true;
-      }
+    if (negated && !frameContained) {
+      verifiedWhenDerived = true;
     }
   }
 

package/src/assertion/defined.js

@@ -39,32 +39,32 @@ export default class DefinedAssertion {
     return this.negated;
   }
 
-  resolve(substitutions, localContext) {
+  resolve(substitutions, context) {
     let resolved;
 
     const definedAssertionString = this.string; ///
 
-    localContext.trace(`Resolving the '${definedAssertionString}' defined assertion...`);
+    context.trace(`Resolving the '${definedAssertionString}' defined assertion...`);
 
     const term = termFromTermAndSubstitutions(this.term, substitutions),
           frame = frameFromFrameAndSubstitutions(this.frame, substitutions),
-          verifiedWhenDerived = verifyWhenDerived(term, frame, this.negated, localContext);
+          verifiedWhenDerived = verifyWhenDerived(term, frame, this.negated, context);
 
     resolved = verifiedWhenDerived; ///
 
     if (resolved) {
-      localContext.debug(`...resolved the '${definedAssertionString}' defined assertion.`);
+      context.debug(`...resolved the '${definedAssertionString}' defined assertion.`);
     }
 
     return resolved;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified = false;
 
     const definedAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
+    context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
 
     stated = true;  ///
 
@@ -74,7 +74,7 @@ export default class DefinedAssertion {
         frameVerified = false;
 
     if (this.term !== null) {
-      termVerified = this.term.verify(localContext, () => {
+      termVerified = this.term.verify(context, () => {
         const verifiedAhead = true;
 
         return verifiedAhead;
@@ -82,7 +82,7 @@ export default class DefinedAssertion {
     }
 
     if (this.frame!== null) {
-      frameVerified = this.frame.verify(assignments, stated, localContext);
+      frameVerified = this.frame.verify(assignments, stated, context);
     }
 
     if (termVerified || frameVerified) {
@@ -90,9 +90,9 @@ export default class DefinedAssertion {
           verifiedWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(localContext);
+        verifiedWhenStated = this.verifyWhenStated(context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+        verifiedWhenDerived = this.verifyWhenDerived(context);
       }
 
       if (verifiedWhenStated || verifiedWhenDerived) {
@@ -101,53 +101,53 @@ export default class DefinedAssertion {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${definedAssertionString}' defined assertion.`);
+      context.debug(`...verified the '${definedAssertionString}' defined assertion.`);
     }
 
     return verified;
   }
 
-  verifyWhenStated(localContext) {
+  verifyWhenStated(context) {
     let verifiedWhenStated;
 
     const definedAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);
+    context.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`);
 
     verifiedWhenStated = true;
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${definedAssertionString}' stated defined assertion.`);
+      context.debug(`...verified the '${definedAssertionString}' stated defined assertion.`);
     }
 
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(localContext) {
+  verifyWhenDerived(context) {
     let verifiedWhenDerived;
 
     const definedAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
+    context.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
 
-    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, localContext);
+    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, context);
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);
+      context.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);
     }
 
     return verifiedWhenDerived;
   }
 
-  static fromDefinedAssertionNode(definedAssertionNode, localContext) {
+  static fromDefinedAssertionNode(definedAssertionNode, context) {
     let definedAssertion = null;
 
     if (definedAssertionNode !== null) {
       const { Term, Frame } = shim,
             node = definedAssertionNode,  ///
-            string = localContext.nodeAsString(node),
-            term = Term.fromDefinedAssertionNode(definedAssertionNode, localContext),
-            frame = Frame.fromDefinedAssertionNode(definedAssertionNode, localContext),
+            string = context.nodeAsString(node),
+            term = Term.fromDefinedAssertionNode(definedAssertionNode, context),
+            frame = Frame.fromDefinedAssertionNode(definedAssertionNode, context),
             definedAssertionNegated = isAssertionNegated(definedAssertionNode),
             negated = definedAssertionNegated;  ///
 
@@ -158,14 +158,14 @@ export default class DefinedAssertion {
   }
 }
 
-function verifyWhenDerived(term, frame, negated, localContext) {
+function verifyWhenDerived(term, frame, negated, context) {
   let verifiedWhenDerived = false;
 
   if (term !== null) {
     const termNode = term.getNode(),
           variableNode = variableNodeQuery(termNode),
           variableName = variableNameFromVariableNode(variableNode),
-          variableDefined = localContext.isVariableDefinedByVariableName(variableName);
+          variableDefined = context.isVariableDefinedByVariableName(variableName);
 
     if (!negated && variableDefined) {
       verifiedWhenDerived = true;
@@ -179,7 +179,7 @@ function verifyWhenDerived(term, frame, negated, localContext) {
   if (frame!== null) {
     const frameNode = frame.getNode(),
           metavariableNode = metavariableNodeQuery(frameNode),
-          metavariableDefined = localContext.isMetavariableDefinedByMetavariableNode(metavariableNode);
+          metavariableDefined = context.isMetavariableDefinedByMetavariableNode(metavariableNode);
 
     if (!negated && metavariableDefined) {
       verifiedWhenDerived = true;

package/src/assertion/subproof.js

@@ -32,13 +32,13 @@ export default class SubproofAssertion {
     return this.statements;
   }
 
-  unifySubproof(subproof, substitutions, fileContext, localContext) {
+  unifySubproof(subproof, substitutions, generalContext, specificContext) {
     let subproofUnified;
 
     const subproofString = subproof.getString(),
           subproofAssertionString = this.string;  ///
 
-    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+    specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
 
     const subproofStatements = subproof.getStatements(),
           subproofAssertionStatements = this.statements;  ///
@@ -46,12 +46,9 @@ export default class SubproofAssertion {
     subproofUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
       const subproofAssertionStatementNode = subproofAssertionStatement.getNode(),
             subproofStatementNode = subproofStatement.getNode(),
-            nodeA = subproofAssertionStatementNode,  ///
-            nodeB = subproofStatementNode,  ///
-            fileContextA = fileContext,  ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
-            localContextB = localContext, ///
-            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+            generalNode = subproofAssertionStatementNode,  ///
+            specificNode = subproofStatementNode,  ///
+            unifiedAtMetaLevel = metaLevelUnifier.unify(generalNode, specificNode, substitutions, generalContext, specificContext);
 
       if (unifiedAtMetaLevel) {
         return true;
@@ -59,25 +56,25 @@ export default class SubproofAssertion {
     });
 
     if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+      specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
     }
 
     return subproofUnified;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified;
 
     const subproofAssertionString = this.string;  ///
 
-    localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
+    context.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
 
     stated = true;  ///
 
     assignments = null; ///
 
     const statementsVerified = this.statements.map((statement) => {
-      const statementVerified = statement.verify(assignments, stated, localContext);
+      const statementVerified = statement.verify(assignments, stated, context);
 
       if (statementVerified) {
         return true;
@@ -89,9 +86,9 @@ export default class SubproofAssertion {
           verifiedWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(localContext);
+        verifiedWhenStated = this.verifyWhenStated(context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+        verifiedWhenDerived = this.verifyWhenDerived(context);
       }
 
       if (verifiedWhenStated || verifiedWhenDerived) {
@@ -100,40 +97,40 @@ export default class SubproofAssertion {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);
+      context.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);
     }
 
     return verified;
   }
 
-  verifyWhenStated(localContext) {
+  verifyWhenStated(context) {
     let verifiedWhenStated;
 
     const subproofAssertionString = this.string;  ///
 
-    localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`);
+    context.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`);
 
     verifiedWhenStated = true;
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`);
+      context.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`);
     }
 
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(localContext) {
+  verifyWhenDerived(context) {
     let derivedSubproofAssertionVerified;
 
     const subproofAssertionString = this.string;  ///
 
-    localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`);
+    context.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`);
 
-    const proofSteps = localContext.getProofSteps();
+    const proofSteps = context.getProofSteps();
 
     derivedSubproofAssertionVerified = proofSteps.some((proofStep) => {
       const subproofAssertion = this,
-            subproofAssertionUnified = proofStep.unifySubproofAssertion(subproofAssertion, localContext);
+            subproofAssertionUnified = proofStep.unifySubproofAssertion(subproofAssertion, context);
 
       if (subproofAssertionUnified) {
         return true;
@@ -141,13 +138,13 @@ export default class SubproofAssertion {
     });
 
     if (derivedSubproofAssertionVerified) {
-      localContext.debug(`...verified the '${subproofAssertionString}' derived subproof assertion.`);
+      context.debug(`...verified the '${subproofAssertionString}' derived subproof assertion.`);
     }
 
     return derivedSubproofAssertionVerified;
   }
 
-  static fromStatementNode(statementNode, localContext) {
+  static fromStatementNode(statementNode, context) {
     let subproofAssertion = null;
 
     const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
@@ -155,10 +152,10 @@ export default class SubproofAssertion {
     if (subproofAssertionNode !== null) {
       const { Statement } = shim,
             statementNodes = statementNodesQuery(subproofAssertionNode),
-            statement = Statement.fromStatementNode(statementNode, localContext),
+            statement = Statement.fromStatementNode(statementNode, context),
             statementString = statement.getString(),
             statements = statementNodes.map((statementNode) => {
-              const statement = Statement.fromStatementNode(statementNode, localContext);
+              const statement = Statement.fromStatementNode(statementNode, context);
 
               return statement;
             }),
@@ -171,14 +168,14 @@ export default class SubproofAssertion {
     return subproofAssertion;
   }
 
-  static fromSubproofAssertionNode(subproofAssertionNode, localContext) {
+  static fromSubproofAssertionNode(subproofAssertionNode, context) {
     let subproofAssertion = null;
 
     if (subproofAssertionNode !== null) {
       const { Statement } = shim,
             statementNodes = statementNodesQuery(subproofAssertionNode),
             statements = statementNodes.map((statementNode) => {
-              const statement = Statement.fromStatementNode(statementNode, localContext);
+              const statement = Statement.fromStatementNode(statementNode, context);
 
               return statement;
             }),