occam-verify-cli 0.0.869 → 0.0.870

package/src/verifier/nodes/statementAgainstCombinator.js

@@ -1,89 +1,86 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
-import termAgainstConstructorNodesVerifier from "../../verifier/nodes/termAgainstConstructor";
+import verifyArgumentAgainstArgument from "../../verify/argumentAgainstArgument";
+import verifyStatementAgainstMetaType from "../../verify/statementAgainstMetaType";
 
 import { nodeQuery } from "../../utilities/query";
-import { STATEMENT_META_TYPE_NAME } from "../../metaTypeNames";
-import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
+import { verifyNodes } from "../../utilities/verifier";
 
-const metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
-      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
+const argumentNodeQuery = nodeQuery("/argument!"),
+      metaArgumentMetaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
+      metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!");
 
 class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNode = nonTerminalNodeA, ///
-          combinatorNonTerminalNode = nonTerminalNodeB, ///
-          ruleName = nonTerminalNode.getRuleName(), ///
-          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: metaArgumentStatementNodeQuery,
+        nodeQueryB: metaArgumentMetaTypeNodeQuery,
+        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-    if (ruleName === combinatorRuleName) {
-      switch (ruleName) {
-        case META_ARGUMENT_RULE_NAME: {
-          const metaArgumentNode = nonTerminalNode, ///
-                combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead);
+          const metaArgumentMetaTypeNodeB = nodeB,  ///
+                metaArgumentStatementNodeA = nodeA, ///
+                metaArgumentStatementVerifiedAgainstMetaArgumentMetaType =
 
-          nonTerminalNodeVerified = metaArgumentNodeVerified; ///
+                  this.verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead);
 
-          break;
-        }
+          nonTerminalNodeVerified = metaArgumentStatementVerifiedAgainstMetaArgumentMetaType; ///
 
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = combinatorNonTerminalNode, ///
-                argumentNodeVerified = termAgainstConstructorNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: argumentNodeQuery,
+        nodeQueryB: argumentNodeQuery,
+        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-          nonTerminalNodeVerified = argumentNodeVerified; ///
+          const argumentNodeA = nodeA,  ///
+                argumentNodeB = nodeB,  ///
+                argumentNodeVerifiedAgainstArgumentNode =
 
-          break;
-        }
+                  this.verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead);
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+          nonTerminalNodeVerified = argumentNodeVerifiedAgainstArgumentNode; ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
       }
-    }
+    ];
+
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead) {
-    let metaArgumentNodeVerified = false;
+  verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead) {
+    let metaArgumentStatementVerifiedAgainstMetaArgumentMetaType = false;
 
-    const metaArgumentString = localContext.nodeAsString(metaArgumentNode);
+    const metaTypeNode = metaArgumentMetaTypeNodeB, ///
+          statementNode = metaArgumentStatementNodeA,  ///
+          statementVerifiedAgainstMetaType = verifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, verifyAhead);
 
-    const statementNode = statementNodeQuery(metaArgumentNode),
-          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
+    metaArgumentStatementVerifiedAgainstMetaArgumentMetaType = statementVerifiedAgainstMetaType; ///
 
-    if (statementNode === null) {
-      localContext.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
-    } else {
-      if (combinatorMetaTYpeNode === null) {
-        const combinatorMetaargumentString = localContext.nodeAsString(combinatorMetaargumentNode);
+    return metaArgumentStatementVerifiedAgainstMetaArgumentMetaType;
+  }
 
-        localContext.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
-      } else {
-        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
-              content = combinatorMetaTypeTerminalNode.getContent(),
-              contentStatementMetaType = (content === STATEMENT_META_TYPE_NAME);
+  verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead) {
+    let argumentNodeVerifiedAgainstArgumentNode;
 
-        if (!contentStatementMetaType) {
-          localContext.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE_NAME}' but got '${content}' instead.`, metaArgumentNode);
-        } else {
-          const verifiedAhead = verifyAhead();
+    const argumentVerifiedAgainstArgument = verifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, verifyAhead);
 
-          metaArgumentNodeVerified = verifiedAhead; ///
-        }
-      }
-    }
+    argumentNodeVerifiedAgainstArgumentNode = argumentVerifiedAgainstArgument; ///
 
-    return metaArgumentNodeVerified;
+    return argumentNodeVerifiedAgainstArgumentNode;
   }
 }
 

package/src/verifier/nodes/termAgainstConstructor.js

@@ -1,102 +1,61 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
+import verifyTermAgainstType from "../../verify/termAgainstType";
 
-import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
-import { ARGUMENT_RULE_NAME } from "../../ruleNames";
+import { verifyNodes } from "../../utilities/verifier";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!");
 
 class TermAgainstConstructorNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNode = nonTerminalNodeA, ///
-          constructorNonTerminalNode = nonTerminalNodeB, ///
-          ruleName = nonTerminalNode.getRuleName(), ///
-          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: termNodeQuery,
+        nodeQueryB: typeNodeQuery,
+        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-    if (ruleName === constructorRuleName) {
-      switch (ruleName) {
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = constructorNonTerminalNode, ///
-                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);
+          const termNodeA = nodeA,  ///
+                typeNodeB = nodeB,  ///
+                termNodeVerifiedAgainstTypeNode =
 
-          nonTerminalNodeVerified = argumentNodeVerified; ///
+                  this.verifyTermNodeAgainstTypeNode(termNodeA, typeNodeB, localContext, verifyAhead);
 
-          break;
-        }
-
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, localContext, verifyAhead);
+          nonTerminalNodeVerified = termNodeVerifiedAgainstTypeNode;  ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
       }
-    }
-
-    return nonTerminalNodeVerified;
-  }
+    ];
 
-  verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead) {
-    let argumentNodeVerified = false;
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-    const argumentString = localContext.nodeAsString(argumentNode);
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-    const typeNode = typeNodeQuery(argumentNode);
-
-    if (typeNode !== null) {
-      localContext.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);
-    } else {
-      const termNode = termNodeQuery(argumentNode);
-
-      if (!argumentNodeVerified) {
-        const constructorTermNode = termNodeQuery(constructorArgumentNode);
-
-        if (constructorTermNode !== null) {
-          const node = termNode,  ///
-                constructorNode = constructorTermNode,  ///
-                nodeVerified = this.verifyNode(node, constructorNode, localContext, verifyAhead);
-
-          argumentNodeVerified = nodeVerified;  ///
-        }
-      }
-
-      if (!argumentNodeVerified) {
-        const constructorTypeNode = typeNodeQuery(constructorArgumentNode);
-
-        if (constructorTypeNode !== null) {
-          const { verifyTerm } = termAgainstConstructorNodesVerifier,
-                terms = [],
-                termVerified = verifyTerm(termNode, terms, localContext, () => {
-                  let verifiedAhead = false;
-
-                  const firstTerm = first(terms),
-                        term = firstTerm, ///
-                        termType = term.getType(),
-                        constructorType = localContext.findTypeByTypeNode(constructorTypeNode),
-                        termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
+    return nonTerminalNodeVerified;
+  }
 
-                  if (termTypeEqualToOrSubTypeOfType) {
-                    verifiedAhead = verifyAhead();
-                  }
+  verifyTermNodeAgainstTypeNode(termNodeA, typeNodeB, localContext, verifyAhead) {
+    let termNodeVerifiedAgainstTypeNode;
 
-                  return verifiedAhead;
-                });
+    const { verifyTerm } = termAgainstConstructorNodesVerifier,
+          termNode = termNodeA, ///
+          typeNode = typeNodeB, ///
+          typeVerifiedAgainstTerm = verifyTermAgainstType(termNode, typeNode, localContext, verifyAhead, verifyTerm);
 
-          argumentNodeVerified = termVerified;  ///
-        }
-      }
-    }
+    termNodeVerifiedAgainstTypeNode = typeVerifiedAgainstTerm; ///
 
-    return argumentNodeVerified;
+    return termNodeVerifiedAgainstTypeNode;
   }
 }
 
 const termAgainstConstructorNodesVerifier = new TermAgainstConstructorNodesVerifier();
 
 export default termAgainstConstructorNodesVerifier;
-

package/src/verify/argumentAgainstArgument.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import termAgainstConstructorNodesVerifier from "../verifier/nodes/termAgainstConstructor";
+
+export default function verifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, verifyAhead) {
+  let argumentVerifiedAgainstArgument;
+
+  const nonTerminalNodeA = argumentNodeA, ///
+        nonTerminalNodeB = argumentNodeB, ///
+        nonTerminalNodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+
+  argumentVerifiedAgainstArgument = nonTerminalNodeVerified; ///
+
+  return argumentVerifiedAgainstArgument;
+}

package/src/verify/containment.js

@@ -6,9 +6,9 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable!"),
       metaArgumentTermNodesQuery = nodesQuery("/metaArgument//term"),
-      metaArgumentVariableNodesQuery = nodesQuery("/metaArgument//variable");
+      metastatementVariableNodesQuery = nodesQuery("/metastatement//variable");
 
-export default function verifyContainment(termNode, containmentNode, metaArgumentNode, localContext) {
+export default function verifyContainment(termNode, containmentNode, metastatementNode, localContext) {
   let containmentVerified = false;
 
   const contained = containedFromContainmentNode(containmentNode),
@@ -17,7 +17,7 @@ export default function verifyContainment(termNode, containmentNode, metaArgumen
   if (false) {
     ///
   } else if (variableNode !== null) {
-    const metaArgumentVariableNodes = metaArgumentVariableNodesQuery(metaArgumentNode),
+    const metaArgumentVariableNodes = metastatementVariableNodesQuery(metastatementNode),
           variableNodeMatchesMetaArgumentVariableNode = metaArgumentVariableNodes.some((metaArgumentVariableNode) => {
             const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metaArgumentVariableNode);
 
@@ -38,7 +38,7 @@ export default function verifyContainment(termNode, containmentNode, metaArgumen
       }
     }
   } else if (termNode !== null) {
-    const metaArgumentTermNodes = metaArgumentTermNodesQuery(metaArgumentNode),
+    const metaArgumentTermNodes = metaArgumentTermNodesQuery(metastatementNode),
           termNodeMatchesMetaArgumentTermNode = metaArgumentTermNodes.some((metaArgumentTermNode) => {
             const termNodeMatchesMetaArgumentTermNode = termNode.match(metaArgumentTermNode);
 

package/src/verify/equality.js

@@ -19,7 +19,7 @@ export default function verifyEquality(equalityNode, assignments, derived, local
 
   const verifyEqualityFunctions = [
     verifyDerivedEquality,
-    verifyGivenEquality
+    verifyStatedEquality
   ];
 
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
@@ -91,13 +91,13 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext,
   return derivedEqualityVerified;
 }
 
-function verifyGivenEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
-  let givenEqualityVerified = false;
+function verifyStatedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
+  let statedEqualityVerified = false;
 
   if (!derived) {
     const equalityString = localContext.nodeAsString(equalityNode);
 
-    localContext.trace(`Verifying the '${equalityString}' given equality...`, equalityNode);
+    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);
 
     const terms = [],
           leftTermNode = leftTermNodeQuery(equalityNode),
@@ -131,12 +131,12 @@ function verifyGivenEquality(equalityNode, assignments, derived, localContext, v
             return verifiedAhead;
           });
 
-    givenEqualityVerified = termsVerified; ///
+    statedEqualityVerified = termsVerified; ///
 
-    if (givenEqualityVerified) {
-      localContext.trace(`...verified the '${equalityString}' given equality.`, equalityNode);
+    if (statedEqualityVerified) {
+      localContext.trace(`...verified the '${equalityString}' stated equality.`, equalityNode);
     }
   }
 
-  return givenEqualityVerified;
+  return statedEqualityVerified;
 }

package/src/verify/metaDerivation.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import LocalContext from "../context/local";
 import MetaproofStep from "../step/metaproof";
+import LocalMetaContext from "../context/localMeta";
 import verifyMetaSuppositions from "../verify/metaSuppositions";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
@@ -15,13 +15,13 @@ const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
       metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
       metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
 
-export default function verifyMetaDerivation(metaDerivationNode, localContext) {
+export default function verifyMetaDerivation(metaDerivationNode, localMetaContext) {
   let metaDerivationVerified;
 
   const childNodes = childNodesQuery(metaDerivationNode);
 
   metaDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localContext);
+    const childVerified = verifyChild(childNode, localMetaContext);
 
     if (childVerified) {
       return true;
@@ -31,13 +31,13 @@ export default function verifyMetaDerivation(metaDerivationNode, localContext) {
   return metaDerivationVerified;
 }
 
-function verifyMetaSubDerivation(metaSubDerivationNode, localContext) {
+function verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext) {
   let metaSubDerivationVerified;
 
   const childNodes = childNodesQuery(metaSubDerivationNode);
 
   metaSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, localContext);
+    const childVerified = verifyChild(childNode, localMetaContext);
 
     if (childVerified) {
       return true;
@@ -47,18 +47,18 @@ function verifyMetaSubDerivation(metaSubDerivationNode, localContext) {
   return metaSubDerivationVerified;
 }
 
-function verifyMetaSubproof(metaSubproofNode, localContext) {
+function verifyMetaSubproof(metaSubproofNode, localMetaContext) {
   let metaSubproofVerified = false;
 
-  localContext = LocalContext.fromLocalContext(localContext); ///
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
 
   const metaSuppositions = [],
         metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
-        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localContext);
+        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext);
 
   if (metaSuppositionsVerified) {
     const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
-          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, localContext);
+          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, localMetaContext);
 
     if (metaSubDerivationVerified) {
       metaSubproofVerified = true;
@@ -68,7 +68,7 @@ function verifyMetaSubproof(metaSubproofNode, localContext) {
   return metaSubproofVerified;
 }
 
-function verifyChild(childNode, localContext) {
+function verifyChild(childNode, localMetaContext) {
   let childVerified = false;
 
   const childNodeRuleName = childNode.getRuleName();
@@ -79,12 +79,12 @@ function verifyChild(childNode, localContext) {
 
       const metaSubproofNode = childNode;  ///
 
-      metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, localContext);
+      metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, localMetaContext);
 
       if (metaSubproofVerified) {
         const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
 
-        localContext.addMetaproofStep(metaproofStep);
+        localMetaContext.addMetaproofStep(metaproofStep);
 
         childVerified = true;
       }
@@ -99,10 +99,10 @@ function verifyChild(childNode, localContext) {
             assignments = [],
             qualifiedMetastatementNode = childNode;  ///
 
-      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localContext);
+      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext);
 
       if (qualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localContext);
+        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
 
         qualifiedMetastatementVerified = assignmentAssigned; ///
       }
@@ -111,7 +111,7 @@ function verifyChild(childNode, localContext) {
         const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
               metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-        localContext.addMetaproofStep(metaproofStep);
+        localMetaContext.addMetaproofStep(metaproofStep);
 
         childVerified = true; ///
       }
@@ -126,10 +126,10 @@ function verifyChild(childNode, localContext) {
             assignments = [],
             unqualifiedMetastatementNode = childNode;  ///
 
-      unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
+      unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localMetaContext);
 
       if (unqualifiedMetastatementVerified) {
-        const assignmentAssigned = assignAssignment(assignments, localContext);
+        const assignmentAssigned = assignAssignment(assignments, localMetaContext);
 
         unqualifiedMetastatementVerified = assignmentAssigned;  ///
       }
@@ -138,7 +138,7 @@ function verifyChild(childNode, localContext) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
               metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-        localContext.addMetaproofStep(metaproofStep);
+        localMetaContext.addMetaproofStep(metaproofStep);
 
         childVerified = true;
       }

package/src/verify/metaLemma.js

@@ -2,7 +2,7 @@
 
 import MetaLemma from "../metaLemma";
 import verifyLabels from "../verify/labels";
-import verifyMetaProof from "../verify/metaproof";
+import verifyMetaproof from "../verify/metaproof";
 import LocalMetaContext from "../context/localMeta";
 import verifyMetaConsequent from "../verify/metaConsequent";
 import verifyMetaSuppositions from "../verify/metaSuppositions";
@@ -44,7 +44,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
         const metaproofNode = metaproofNodeQuery(metaLemmaNode),
               firstMetaConsequent = first(metaConsequents),
               metaConsequent = firstMetaConsequent, ///
-              metaproofVerified = verifyMetaProof(metaproofNode, metaConsequent, localMetaContext);
+              metaproofVerified = verifyMetaproof(metaproofNode, metaConsequent, localMetaContext);
 
         if (metaproofVerified) {
           const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, metaSuppositions, metaConsequent, localMetaContext);

package/src/verify/metaproof.js

@@ -1,22 +1,19 @@
 "use strict";
 
-import LocalContext from "../context/local";
 import verifyMetaDerivation from "../verify/metaDerivation";
 
 import { nodeQuery } from "../utilities/query";
 
 const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
 
-export default function verifyMetaproof(metaproofNode, conclusion, localContext) {
+export default function verifyMetaproof(metaproofNode, conclusion, localMetaproof) {
   let metaproofVerified = false;
 
-  localContext = LocalContext.fromLocalContext(localContext); ///
-
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, localContext);
+        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, localMetaproof);
 
   if (metaDerivationVerified) {
-    const lastMetaproofStep = localContext.getLastMetaproofStep();
+    const lastMetaproofStep = localMetaproof.getLastMetaproofStep();
 
     if (lastMetaproofStep !== null) {
       const metaproofStep = lastMetaproofStep, ///

package/src/verify/metavariable.js

@@ -2,7 +2,6 @@
 
 import Metavariable from "../metavariable";
 import MetavariableAssignment from "../assignment/metavariable";
-import verifyGivenMetavariable from "../verify/givenMetavariable";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -44,16 +43,19 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 }
 
 export function verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead) {
-  let standaloneMetavariableVerified;
+  let standaloneMetavariableVerified = false;
 
   const metavariableString = localMetaContext.nodeAsString(metavariableNode);
 
   localMetaContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariables = [],
-        givenMetavariableVerified = verifyGivenMetavariable(metavariableNode, metavariables, localMetaContext, verifyAhead);
+  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
-  standaloneMetavariableVerified = givenMetavariableVerified; ///
+  if (metavariablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    standaloneMetavariableVerified = verifiedAhead; ///
+  }
 
   if (standaloneMetavariableVerified) {
     localMetaContext.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);

package/src/verify/metavariableAgainstMetastatement.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
+
+export default function verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, localContextA, localMetaContextB, verifyAhead) {
+  let metavariableVerifiedAgainstMetastatement = false;
+
+  const substitution = substitutions.find((substitution) => {
+    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNode);
+
+    if (substitutionMatchesMetavariableNodeA) {
+      return true;
+    }
+  }) || null;
+
+  if (substitution !== null) {
+    const metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
+
+    if (metastatementNodeMatches) {
+      const verifiedAhead = verifyAhead();
+
+      metavariableVerifiedAgainstMetastatement = verifiedAhead; ///
+    }
+  } else {
+    let verifiedAhead;
+
+    const metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
+          substitution = metastatementForMetavariableSubstitution;  ///
+
+    substitutions.push(substitution);
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      substitutions.pop();
+    }
+
+    metavariableVerifiedAgainstMetastatement = verifiedAhead; ///
+  }
+
+  return metavariableVerifiedAgainstMetastatement;
+}