occam-verify-cli 0.0.869 → 0.0.871

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/axiom.js

@@ -9,21 +9,21 @@ import verifySuppositions from "../verify/suppositions";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/axiom//reference/label"),
+const labelsNodeQuery = nodeQuery("/axiom/labels!"),
       consequentNodeQuery = nodeQuery("/axiom/consequent!"),
       suppositionsNodeQuery = nodesQuery("/axiom/supposition");
 
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
-  const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(axiomNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const suppositions = [],

package/src/verify/conjecture.js

@@ -11,21 +11,21 @@ import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/conjecture/proof!"),
-      labelNodesQuery = nodesQuery("/conjecture//reference/label"),
+      labelsNodeQuery = nodeQuery("/conjecture/labels!"),
       consequentNodeQuery = nodeQuery("/conjecture/consequent!"),
       suppositionsNodeQuery = nodesQuery("/conjecture/supposition");
 
 export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
-  const labelNodes = labelNodesQuery(conjectureNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(conjectureNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const suppositions = [],

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/label.js

@@ -2,21 +2,20 @@
 
 import Label from "../label";
 
-export default function verifyLabel(labelNode, labels, fileContext) {
+export default function verifyLabel(labelsMetavariableNode, labels, fileContext) {
   let labelVerified = false;
 
-  const labelString = fileContext.nodeAsString(labelNode);
+  const labelMetavariableString = fileContext.nodeAsString(labelsMetavariableNode);
 
-  fileContext.trace(`Verifying the '${labelString}' label...`, labelNode);
+  fileContext.trace(`Verifying the '${labelMetavariableString}' label...`, labelsMetavariableNode);
 
-  const labelPresent = fileContext.isLabelPresentByLabelNode(labelNode);
+  const labelPresent = fileContext.isLabelPresentByLabelMetavariableNode(labelsMetavariableNode);
 
   if (labelPresent) {
-    const labelString = fileContext.nodeAsString(labelNode);
-
-    fileContext.debug(`The '${labelString}' label is already present.`, labelNode);
+    fileContext.debug(`The '${labelMetavariableString}' label is already present.`, labelsMetavariableNode);
   } else {
-    const label = Label.fromLabelNode(labelNode);
+    const metavariableNode = labelsMetavariableNode,  ///
+          label = Label.fromMetavariableNode(metavariableNode);
 
     labels.push(label);
 
@@ -24,7 +23,7 @@ export default function verifyLabel(labelNode, labels, fileContext) {
   }
 
   if (labelVerified) {
-    fileContext.debug(`...verified the '${labelString}' label.`, labelNode);
+    fileContext.debug(`...verified the '${labelMetavariableString}' label.`, labelsMetavariableNode);
   }
 
   return labelVerified;

package/src/verify/labels.js

@@ -2,16 +2,26 @@
 
 import verifyLabel from "../verify/label";
 
-export default function verifyLabels(labelNodes, labels, fileContext) {
+import { nodesQuery } from "../utilities/query";
+
+const labelsMetavariableNodesQuery = nodesQuery("/labels/metavariable");
+
+export default function verifyLabels(labelsNode, labels, fileContext) {
   let labelsVerified;
 
-  labelsVerified = labelNodes.every((labelNode) => {
-    const labelVerified = verifyLabel(labelNode, labels, fileContext);
+  if (labelsNode === null) {
+    labelsVerified = true;
+  } else {
+    const labelsMetavariableNodes = labelsMetavariableNodesQuery(labelsNode);
+
+    labelsVerified = labelsMetavariableNodes.every((labelsMetavariableNode) => {
+      const labelVerified = verifyLabel(labelsMetavariableNode, labels, fileContext);
 
-    if (labelVerified) {
-      return true;
-    }
-  });
+      if (labelVerified) {
+        return true;
+      }
+    });
+  }
 
   return labelsVerified;
 }

package/src/verify/lemma.js

@@ -12,15 +12,15 @@ import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/lemma/proof!"),
-      labelNodesQuery = nodesQuery("/lemma//reference/label"),
+      labelsNodeQuery = nodeQuery("/lemma/labels!"),
       consequentNodeQuery = nodeQuery("/lemma/consequent!"),
       suppositionsNodeQuery = nodesQuery("/lemma/supposition");
 
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
-  const labelNodes = labelNodesQuery(lemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(lemmaNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localContext = LocalContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
@@ -28,7 +28,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
       fileContext.trace(`Verifying the '${labelsString}' lemma...`, lemmaNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const suppositions = [],

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";
@@ -11,7 +11,7 @@ import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metaLemma//reference/label"),
+const labelsNodeQuery = nodeQuery("/metaLemma/labels!"),
       metaproofNodeQuery = nodeQuery("/metaLemma/metaproof!"),
       metaConsequentNodeQuery = nodeQuery("/metaLemma/metaConsequent!"),
       metaSuppositionsNodeQuery = nodesQuery("/metaLemma/metaSupposition");
@@ -19,8 +19,8 @@ const labelNodesQuery = nodesQuery("/metaLemma//reference/label"),
 export default function verifyMetaLemma(metaLemmaNode, fileContext) {
   let metaLemmaVerified = false;
 
-  const labelNodes = labelNodesQuery(metaLemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(metaLemmaNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localMetaContext = LocalMetaContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
@@ -28,7 +28,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
       fileContext.trace(`Verifying the '${labelsString}' meta-lLemma...`, metaLemmaNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const 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/metastatement/qualified.js

@@ -2,8 +2,8 @@
 
 import { nodeQuery } from "../../utilities/query";
 
-const labelNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/label!"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
+const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!"),
+      referenceMetavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!");
 
 export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext) {
   let qualifiedMetastatementVerified = false;
@@ -16,8 +16,9 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
     localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-    const labelNode = labelNodeQuery(qualifiedMetastatementNode),
-          rule = localMetaContext.findRuleByLabelNode(labelNode);
+    const referenceMetavariableNode = referenceMetavariableNodeQuery(qualifiedMetastatementNode),
+          labelMetavariableNode = referenceMetavariableNode,  ///
+          rule = localMetaContext.findRuleByLabelMetavariableNode(labelMetavariableNode);
 
     if (rule !== null) {
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);

package/src/verify/metatheorem.js

@@ -10,7 +10,7 @@ import verifyMetaSuppositions from "../verify/metaSuppositions";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metatheorem//reference/label"),
+const labelsNodeQuery = nodeQuery("/metatheorem/labels!"),
       metaproofNodeQuery = nodeQuery("/metatheorem/metaproof!"),
       metaConsequentNodeQuery = nodeQuery("/metatheorem/metaConsequent!"),
       metaSuppositionsNodeQuery = nodesQuery("/metatheorem/metaSupposition");
@@ -18,14 +18,14 @@ const labelNodesQuery = nodesQuery("/metatheorem//reference/label"),
 export default function verifyMetatheorem(metatheoremNode, fileContext) {
   let metatheoremVerified = false;
 
-  const labelNodes = labelNodesQuery(metatheoremNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(metatheoremNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localMetaContext = LocalMetaContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' metatheorem...`, metatheoremNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const metaSuppositions = [],