occam-verify-cli 0.0.864 → 0.0.866

package/src/verifier/nodes/statementAgainstCombinator.js

@@ -4,7 +4,7 @@ import NodesVerifier from "../../verifier/nodes";
 import termAgainstConstructorNodesVerifier from "../../verifier/nodes/termAgainstConstructor";
 
 import { nodeQuery } from "../../utilities/query";
-import { STATEMENT_META_TYPE } from "../../metaTypes";
+import { STATEMENT_META_TYPE_NAME } from "../../metaTypeNames";
 import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
 const metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
@@ -71,10 +71,10 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
       } else {
         const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
               content = combinatorMetaTypeTerminalNode.getContent(),
-              contentStatementMetaType = (content === STATEMENT_META_TYPE);
+              contentStatementMetaType = (content === STATEMENT_META_TYPE_NAME);
 
         if (!contentStatementMetaType) {
-          localContext.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);
+          localContext.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE_NAME}' but got '${content}' instead.`, metaArgumentNode);
         } else {
           const verifiedAhead = verifyAhead();
 

package/src/verifier/nodes/termAgainstConstructor.js

@@ -3,8 +3,8 @@
 import NodesVerifier from "../../verifier/nodes";
 
 import { first } from "../../utilities/array";
+import { nodeQuery } from "../../utilities/query";
 import { ARGUMENT_RULE_NAME } from "../../ruleNames";
-import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!");
@@ -74,11 +74,10 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
                 termVerified = verifyTerm(termNode, terms, localContext, () => {
                   let verifiedAhead = false;
 
-                  const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
-                        firstTerm = first(terms),
+                  const firstTerm = first(terms),
                         term = firstTerm, ///
                         termType = term.getType(),
-                        constructorType = localContext.findTypeByTypeName(constructorTypeName),
+                        constructorType = localContext.findTypeByTypeNode(constructorTypeNode),
                         termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
 
                   if (termTypeEqualToOrSubTypeOfType) {

package/src/verifier/nodes.js

@@ -31,7 +31,7 @@ export default class NodesVerifier {
   }
 
   verifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {
-    let childNodesVerify = false;
+    let childNodesVerified = false;
 
     const childNodesALength = childNodesA.length,
           childNodesBLength = childNodesB.length;
@@ -45,11 +45,11 @@ export default class NodesVerifier {
         const index = 0,
               childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
 
-        childNodesVerify = childNodesVerifyAhead; ///
+        childNodesVerified = childNodesVerifyAhead; ///
       }
     }
 
-    return childNodesVerify;
+    return childNodesVerified;
   }
 
   verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
@@ -74,16 +74,16 @@ export default class NodesVerifier {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             childNodesA = nonTerminalNodeAChildNodes, ///
             childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+            childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
 
-      nonTerminalNodeVerified = childNodesVerify; ///
+      nonTerminalNodeVerified = childNodesVerified; ///
     }
 
     return nonTerminalNodeVerified;
   }
 
   verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
-    let childNodesVerify;
+    let childNodesVerified;
 
     const verifyAhead = remainingArguments.pop(), ///
           childNodesALength = childNodesA.length;
@@ -91,7 +91,7 @@ export default class NodesVerifier {
     if (index === childNodesALength) {
       const verifiedAhead = verifyAhead();
 
-      childNodesVerify = verifiedAhead; ///
+      childNodesVerified = verifiedAhead; ///
     } else {
       const childNodeA = childNodesA[index],
             childNodeB = childNodesB[index],
@@ -106,9 +106,9 @@ export default class NodesVerifier {
               return childNodesVerifyAhead;
             });
 
-      childNodesVerify = nodeVerified;  ///
+      childNodesVerified = nodeVerified;  ///
     }
 
-    return childNodesVerify;
+    return childNodesVerified;
   }
 }

package/src/verify/declaration/metavariable.js

@@ -12,16 +12,17 @@ export default function verifyMetavariableDeclaration(metavariableDeclarationNod
 
   const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
         metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
-        metavariableString = fileContext.nodeAsString(metaTypeNode);
+        metaTypeString = fileContext.nodeAsString(metaTypeNode),
+        metavariableString = fileContext.nodeAsString(metavariableNode);
 
-  fileContext.trace(`Verifying the '${metavariableString}' metavariable declaration...`, metavariableDeclarationNode);
+  fileContext.trace(`Verifying the '${metavariableString}:${metaTypeString}' metavariable declaration...`, metavariableDeclarationNode);
 
   const metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
 
   metavariableDeclarationVerified = metavariableVVerified;  ///
 
   if (metavariableDeclarationVerified) {
-    fileContext.debug(`...verified the '${metavariableString}' metavariable declaration.`, metavariableDeclarationNode);
+    fileContext.debug(`...verified the '${metavariableString}:${metaTypeString}' metavariable declaration.`, metavariableDeclarationNode);
   }
 
   return metavariableDeclarationVerified;

package/src/verify/declaration/topLevel.js

@@ -4,7 +4,9 @@ import verifyRule from "../../verify/rule";
 import verifyAxiom from "../../verify/axiom";
 import verifyLemma from "../../verify/lemma";
 import verifyTheorem from "../../verify/theorem";
+import verifyMetaLemma from "../../verify/metaLemma";
 import verifyConjecture from "../../verify/conjecture";
+import verifyMetatheorem from "../../verify/metatheorem";
 import verifyTypeDeclaration from "../../verify/declaration/type";
 import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
@@ -17,7 +19,9 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
       lemmaNodeQuery = nodeQuery("/topLevelDeclaration/lemma!"),
       theoremNodeQuery = nodeQuery("/topLevelDeclaration/theorem!"),
+      metaLemmaNodeQuery = nodeQuery("/topLevelDeclaration/metaLemma!"),
       conjectureNodeQuery = nodeQuery("/topLevelDeclaration/conjecture!"),
+      metatheoremNodeQuery = nodeQuery("/topLevelDeclaration/metatheorem!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
       variableDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/variableDeclaration!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
@@ -32,7 +36,9 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
         axiomNode = axiomNodeQuery(node),
         lemmaNode = lemmaNodeQuery(node),
         theoremNode = theoremNodeQuery(node),
+        metaLemmaNode = metaLemmaNodeQuery(node),
         conjectureNode = conjectureNodeQuery(node),
+        metatheoremNode = metatheoremNodeQuery(node),
         typeDeclarationNode = typeDeclarationNodeQuery(node),
         variableDeclarationNode = variableDeclarationNodeQuery(node),
         combinatorDeclarationNode = combinatorDeclarationNodeQuery(node),
@@ -57,10 +63,18 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     const theoremVerified = verifyTheorem(theoremNode, fileContext);
 
     topLevelDeclarationVerified = theoremVerified;  ///
+  } else if (metaLemmaNode !== null) {
+    const metaLemmaVerified = verifyMetaLemma(metaLemmaNode, fileContext);
+
+    topLevelDeclarationVerified = metaLemmaVerified;  ///
   } else if (conjectureNode !== null) {
     const conjectureVerified = verifyConjecture(conjectureNode, fileContext);
 
     topLevelDeclarationVerified = conjectureVerified;  ///
+  } else if (metatheoremNode !== null) {
+    const metatheoremVerified = verifyMetatheorem(metatheoremNode, fileContext);
+
+    topLevelDeclarationVerified = metatheoremVerified;  ///
   } else if (typeDeclarationNode !== null) {
     const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
 

package/src/verify/givenMetavariable.js

@@ -0,0 +1,31 @@
+"use strict";
+
+export default function verifyGivenMetavariable(metavariableNode, metavariables, localMetaContext, verifyAhead) {
+  let givenMetavariableVerified = false;
+
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
+
+  localMetaContext.trace(`Verifying the '${metavariableString}' given metavariable...`, metavariableNode);
+
+  const metavariable = localMetaContext.findMetavariableByMetavariableNode(metavariableNode);
+
+  if (metavariable !== null) {
+    let verifiedAhead;
+
+    metavariables.push(metavariable);
+
+    verifiedAhead = verifyAhead();
+
+    if (!verifiedAhead) {
+      metavariables.pop();
+    }
+
+    givenMetavariableVerified = verifiedAhead; ///
+  }
+
+  if (givenMetavariableVerified) {
+    localMetaContext.debug(`...verified the '${metavariableString}' given metavariable.`, metavariableNode);
+  }
+
+  return givenMetavariableVerified;
+}

package/src/verify/givenType.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import { typeNameFromTypeNode } from "../utilities/query";
-
 export default function verifyGivenType(typeNode, types, localContext, verifyAhead) {
   let givenTypeVerified = false;
 
@@ -9,8 +7,7 @@ export default function verifyGivenType(typeNode, types, localContext, verifyAhe
 
   localContext.trace(`Verifying the given '${typeString}' type...`, typeNode);
 
-  const typeName = typeNameFromTypeNode(typeNode),
-        type = localContext.findTypeByTypeName(typeName);
+  const type = localContext.findTypeByTypeNode(typeNode);
 
   if (type !== null) {
     let verifiedAhead;

package/src/verify/label.js

@@ -2,17 +2,14 @@
 
 import Label from "../label";
 
-import { labelNameFromLabelNode } from "../utilities/query";
-
 export default function verifyLabel(labelNode, labels, fileContext) {
   let labelVerified = false;
 
-  const labelName = labelNameFromLabelNode(labelNode),
-        labelString = fileContext.nodeAsString(labelNode);
+  const labelString = fileContext.nodeAsString(labelNode);
 
   fileContext.trace(`Verifying the '${labelString}' label...`, labelNode);
 
-  const labelPresent = fileContext.isLabelPresentByLabelName(labelName);
+  const labelPresent = fileContext.isLabelPresentByLabelNode(labelNode);
 
   if (labelPresent) {
     const labelString = fileContext.nodeAsString(labelNode);

package/src/verify/metaConsequent.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import MetaConsequent from "../metaConsequent";
+import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaConsequent/unqualifiedMetastatement!");
+
+export default function verifyMetaConsequent(metaConsequentNode, metaConsequents, localContext) {
+  let metaConsequentVerified = false;
+
+  const metaConsequentString = localContext.nodeAsString(metaConsequentNode);
+
+  localContext.trace(`Verifying the '${metaConsequentString}' meta-consequent...`, metaConsequentNode);
+
+  const derived = false,
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaConsequentNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localContext);
+
+  if (unqualifiedMetastatementVerified) {
+    metaConsequentVerified = true;
+  }
+
+  if (metaConsequentVerified) {
+    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          metaConsequent = MetaConsequent.fromMetastatementNode(metastatementNode);
+
+    metaConsequents.push(metaConsequent);
+
+    localContext.debug(`...verified the '${metaConsequentString}' meta-consequent.`, metaConsequentNode);
+  }
+
+  return metaConsequentVerified;
+}

package/src/verify/metaDerivation.js

@@ -0,0 +1,151 @@
+"use strict";
+
+import LocalContext from "../context/local";
+import MetaproofStep from "../step/metaproof";
+import verifyMetaSuppositions from "../verify/metaSuppositions";
+import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+
+import { assignAssignment } from "../utilities/assignments";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
+      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
+      metaSuppositionNodesQuery = nodesQuery("/metaSubproof/metaSupposition"),
+      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
+
+export default function verifyMetaDerivation(metaDerivationNode, localContext) {
+  let metaDerivationVerified;
+
+  const childNodes = childNodesQuery(metaDerivationNode);
+
+  metaDerivationVerified = childNodes.every((childNode) => {
+    const childVerified = verifyChild(childNode, localContext);
+
+    if (childVerified) {
+      return true;
+    }
+  });
+
+  return metaDerivationVerified;
+}
+
+function verifyMetaSubDerivation(metaSubDerivationNode, localContext) {
+  let metaSubDerivationVerified;
+
+  const childNodes = childNodesQuery(metaSubDerivationNode);
+
+  metaSubDerivationVerified = childNodes.every((childNode) => {
+    const childVerified = verifyChild(childNode, localContext);
+
+    if (childVerified) {
+      return true;
+    }
+  });
+
+  return metaSubDerivationVerified;
+}
+
+function verifyMetaSubproof(metaSubproofNode, localContext) {
+  let metaSubproofVerified = false;
+
+  localContext = LocalContext.fromLocalContext(localContext); ///
+
+  const metaSuppositions = [],
+        metaSuppositionNodes = metaSuppositionNodesQuery(metaSubproofNode),
+        metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localContext);
+
+  if (metaSuppositionsVerified) {
+    const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
+          metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, localContext);
+
+    if (metaSubDerivationVerified) {
+      metaSubproofVerified = true;
+    }
+  }
+
+  return metaSubproofVerified;
+}
+
+function verifyChild(childNode, localContext) {
+  let childVerified = false;
+
+  const childNodeRuleName = childNode.getRuleName();
+
+  switch (childNodeRuleName) {
+    case META_SUBPROOF_RULE_NAME: {
+      let metaSubproofVerified;
+
+      const metaSubproofNode = childNode;  ///
+
+      metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, localContext);
+
+      if (metaSubproofVerified) {
+        const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
+
+        localContext.addMetaproofStep(metaproofStep);
+
+        childVerified = true;
+      }
+
+      break;
+    }
+
+    case QUALIFIED_METASTATEMENT_RULE_NAME: {
+      let qualifiedMetastatementVerified;
+
+      const derived = true,
+            assignments = [],
+            qualifiedMetastatementNode = childNode;  ///
+
+      qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localContext);
+
+      if (qualifiedMetastatementVerified) {
+        const assignmentAssigned = assignAssignment(assignments, localContext);
+
+        qualifiedMetastatementVerified = assignmentAssigned; ///
+      }
+
+      if (qualifiedMetastatementVerified) {
+        const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+        localContext.addMetaproofStep(metaproofStep);
+
+        childVerified = true; ///
+      }
+
+      break;
+    }
+
+    case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
+      let unqualifiedMetastatementVerified;
+
+      const derived = true,
+            assignments = [],
+            unqualifiedMetastatementNode = childNode;  ///
+
+      unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
+
+      if (unqualifiedMetastatementVerified) {
+        const assignmentAssigned = assignAssignment(assignments, localContext);
+
+        unqualifiedMetastatementVerified = assignmentAssigned;  ///
+      }
+
+      if (unqualifiedMetastatementVerified) {
+        const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+        localContext.addMetaproofStep(metaproofStep);
+
+        childVerified = true;
+      }
+
+      break;
+    }
+  }
+
+  return childVerified;
+}

package/src/verify/metaLemma.js

@@ -0,0 +1,67 @@
+"use strict";
+
+import MetaLemma from "../metaLemma";
+import verifyLabels from "../verify/labels";
+import verifyMetaProof from "../verify/metaproof";
+import LocalMetaContext from "../context/localMeta";
+import verifyMetaConsequent from "../verify/metaConsequent";
+import verifyMetaSuppositions from "../verify/metaSuppositions";
+
+import { first } from "../utilities/array";
+import { EMPTY_STRING } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const labelNodesQuery = nodesQuery("/metaLemma//labels/label"),
+      metaproofNodeQuery = nodeQuery("/metaLemma/metaproof!"),
+      metaConsequentNodeQuery = nodeQuery("/metaLemma/metaConsequent!"),
+      metaSuppositionsNodeQuery = nodesQuery("/metaLemma/metaSupposition");
+
+export default function verifyMetaLemma(metaLemmaNode, fileContext) {
+  let metaLemmaVerified = false;
+
+  const labelNodes = labelNodesQuery(metaLemmaNode),
+        labelsString = fileContext.nodesAsString(labelNodes),
+        localMetaContext = LocalMetaContext.fromFileContext(fileContext);
+
+  (labelsString === EMPTY_STRING) ?
+    fileContext.trace(`Verifying a meta-lLemma...`, metaLemmaNode) :
+      fileContext.trace(`Verifying the '${labelsString}' meta-lLemma...`, metaLemmaNode);
+
+  const labels = [],
+        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+
+  if (labelsVerified) {
+    const metaSuppositions = [],
+          metaSuppositionNodes = metaSuppositionsNodeQuery(metaLemmaNode),
+          metaSuppositionsVerified = verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localMetaContext);
+
+    if (metaSuppositionsVerified) {
+      const metaConsequents = [],
+            metaConsequentNode = metaConsequentNodeQuery(metaLemmaNode),
+            metaConsequentVerified = verifyMetaConsequent(metaConsequentNode, metaConsequents, localMetaContext);
+
+      if (metaConsequentVerified) {
+        const metaproofNode = metaproofNodeQuery(metaLemmaNode),
+              firstMetaConsequent = first(metaConsequents),
+              metaConsequent = firstMetaConsequent, ///
+              metaproofVerified = verifyMetaProof(metaproofNode, metaConsequent, localMetaContext);
+
+        if (metaproofVerified) {
+          const metaLemma = MetaLemma.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, metaSuppositions, metaConsequent, localMetaContext);
+
+          fileContext.addMetaLemma(metaLemma);
+
+          metaLemmaVerified = true;
+        }
+      }
+    }
+  }
+
+  if (metaLemmaVerified) {
+    (labelsString === EMPTY_STRING) ?
+      fileContext.debug(`...verified the meta-lemma.`, metaLemmaNode) :
+        fileContext.debug(`...verified the '${labelsString}' meta-lemma.`, metaLemmaNode);
+  }
+
+  return metaLemmaVerified;
+}

package/src/verify/metaSupposition.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import MetaproofStep from "../step/metaproof";
+import MetaSupposition from "../metaSupposition";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+
+import { nodeQuery } from "../utilities/query";
+import { assignAssignment } from "../utilities/assignments";
+
+const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
+      unqualifiedMetastatementNodeQuery = nodeQuery("/metaSupposition/unqualifiedMetastatement!");
+
+export default function verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext) {
+  let metaSuppositionVerified = false;
+
+  const metaSuppositionString = localContext.nodeAsString(metaSuppositionNode);
+
+  localContext.trace(`Verifying the '${metaSuppositionString}' meta-supposition...`, metaSuppositionNode);
+
+  const derived = false,
+        assignments = [],
+        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaSuppositionNode),
+        unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
+
+  if (unqualifiedMetastatementVerified) {
+    const assignmentAssigned = assignAssignment(assignments, localContext);
+
+    metaSuppositionVerified = assignmentAssigned; ///
+  }
+
+  if (metaSuppositionVerified) {
+    const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+          metaSupposition = MetaSupposition.fromMetastatementNode(metastatementNode),
+          metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
+
+    metaSuppositions.push(metaSupposition);
+
+    localContext.addMetaproofStep(metaproofStep);
+
+    localContext.debug(`...verified the '${metaSuppositionString}' meta-supposition.`, metaSuppositionNode);
+  }
+
+  return metaSuppositionVerified;
+}

package/src/verify/metaSuppositions.js

@@ -0,0 +1,17 @@
+"use strict";
+
+import verifyMetaSupposition from "../verify/metaSupposition";
+
+export default function verifyMetaSuppositions(metaSuppositionNodes, metaSuppositions, localContext) {
+  let metaSuppositionsVerified;
+
+  metaSuppositionsVerified = metaSuppositionNodes.every((metaSuppositionNode) => {
+    const metaSuppositionVerified = verifyMetaSupposition(metaSuppositionNode, metaSuppositions, localContext);
+
+    if (metaSuppositionVerified) {
+      return true;
+    }
+  });
+
+  return metaSuppositionsVerified;
+}

package/src/verify/metaproof.js

@@ -0,0 +1,32 @@
+"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) {
+  let metaproofVerified = false;
+
+  localContext = LocalContext.fromLocalContext(localContext); ///
+
+  const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
+        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, localContext);
+
+  if (metaDerivationVerified) {
+    const lastMetaproofStep = localContext.getLastMetaproofStep();
+
+    if (lastMetaproofStep !== null) {
+      const metaproofStep = lastMetaproofStep, ///
+            metastatementNode = metaproofStep.getMetastatementNode(),
+            conclusionMetastatementNode = conclusion.getMetastatementNode(),
+            metastatementNodeMatchesConclusionMetastatementNode = metastatementNode.match(conclusionMetastatementNode);
+
+      metaproofVerified = metastatementNodeMatchesConclusionMetastatementNode;  ///
+    }
+  }
+
+  return metaproofVerified;
+}

package/src/verify/metastatement/qualified.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
+import { nodeQuery } from "../../utilities/query";
 
 const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/reference!"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
@@ -17,8 +17,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
     localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedMetastatementNode),
-          referenceName = referenceNameFromReferenceNode(referenceNode),
-          rule = localMetaContext.findRuleByReferenceName(referenceName);
+          rule = localMetaContext.findRuleByReferenceNode(referenceNode);
 
     if (rule !== null) {
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);