occam-verify-cli 0.0.492 → 0.0.495

package/src/metaAntecedent.js

@@ -0,0 +1,235 @@
+"use strict";
+
+import MetaSubstitution from "./metaSubstitution";
+
+import { first } from "./utilities/array";
+import { nodeAsString } from "./utilities/string";
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { metavariableNameFromMetavariableNode } from "./utilities/query";
+import { metastatementNodeFromMetastatementString } from "./utilities/string";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "./ruleNames";
+
+const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
+      metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
+      unqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/unqualifiedMetastatement/metastatement!"),
+      qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery = nodeQuery("/metaSubproof/subDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
+
+export default class MetaAntecedent {
+  constructor(metastatementNode) {
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  matchSubproofNode(metaSubproofNode, metaSubstitutions) {
+    let metaSubproofNodeMatches = false;
+
+    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(this.metastatementNode);
+
+    if (metaSubproofAssertionNode !== null) {
+      const metaSubproofAssertionMetastatementNodes = metastatementNodesQuery(metaSubproofAssertionNode),
+            unqualifiedMetastatementMetastatementNodes = unqualifiedMetastatementMetastatementNodesQuery(metaSubproofNode),
+            qualifiedOrUnqualifiedMetastatementMetastatementNode = qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery(metaSubproofNode),
+            metastatementNodes = [
+              ...unqualifiedMetastatementMetastatementNodes,
+              qualifiedOrUnqualifiedMetastatementMetastatementNode
+            ],
+            metastatementNodesLength = metastatementNodes.length,
+            metaSubproofAssertionMetastatementNodesLength = metaSubproofAssertionMetastatementNodes.length;
+
+      if (metastatementNodesLength === metaSubproofAssertionMetastatementNodesLength) {
+        metaSubproofNodeMatches = metaSubproofAssertionMetastatementNodes.every((metaSubproofAssertionMetastatementNode, index) => {
+                                    const metastatementNode = metastatementNodes[index],
+                                          nonTerminalNode = metastatementNode, ///
+                                          metaAntecedentNonTerminalNode = metaSubproofAssertionMetastatementNode,  ///
+                                          metaAntecedentNonTerminalNodeMatches = matchMetaAntecedentNonTerminalNode(metaAntecedentNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+                                    if (metaAntecedentNonTerminalNodeMatches) {
+                                      return true;
+                                    }
+                                  });
+      }
+    }
+
+    return metaSubproofNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNode, metaSubstitutions) {
+    const nonTerminalNode = metastatementNode,  ///
+          metaAntecedentNonTerminalNode = this.metastatementNode,  ///
+          metaAntecedentNonTerminalNodeMatches = matchMetaAntecedentNonTerminalNode(metaAntecedentNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          metastatementNodeMatches = metaAntecedentNonTerminalNodeMatches; ///
+
+    return metastatementNodeMatches;
+  }
+
+  toJSON() {
+    const metastatementString = nodeAsString(this.metastatementNode),
+          metastatement = metastatementString, ///
+          json = {
+            metastatement
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, releaseContext) {
+    const { metastatement } = json,
+          metastatementString = metastatement,  ///
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, releaseContext),
+          metaAntecedent = new MetaAntecedent(metastatementNode);
+
+    return metaAntecedent;
+  }
+
+  static fromMetastatementNode(metastatementNode) {
+    const metaAntecedent = new MetaAntecedent(metastatementNode);
+
+    return metaAntecedent;
+  }
+}
+
+function matchMetaAntecedentNode(metaAntecedentNode, node, metaSubstitutions) {
+  let metaAntecedentNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+        ruleNodeTerminalNode = metaAntecedentNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            metaAntecedentTerminalNode = metaAntecedentNode,  ///
+            metaAntecedentTerminalNodeMatches = matchMetaAntecedentTerminalNode(metaAntecedentTerminalNode, terminalNode, metaSubstitutions);
+
+      metaAntecedentNodeMatches = metaAntecedentTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+            metaAntecedentNonTerminalNode = metaAntecedentNode,  ///
+            metaAntecedentNonTerminalNodeMatches = matchMetaAntecedentNonTerminalNode(metaAntecedentNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      metaAntecedentNodeMatches = metaAntecedentNonTerminalNodeMatches; ///
+    }
+  }
+
+  return metaAntecedentNodeMatches;
+}
+
+function matchMetaAntecedentNodes(metaAntecedentNodes, nodes, metaSubstitutions) {
+  let metaAntecedentNodesMatches = false;
+
+  const nodesLength = nodes.length,
+        metaAntecedentNodesLength = metaAntecedentNodes.length;
+
+  if (nodesLength === metaAntecedentNodesLength) {
+    metaAntecedentNodesMatches = nodes.every((node, index) => {
+      const metaAntecedentNode = metaAntecedentNodes[index],
+            metaAntecedentNodeMatches = matchMetaAntecedentNode(metaAntecedentNode, node, metaSubstitutions);
+
+      if (metaAntecedentNodeMatches) {
+        return true;
+      }
+    });
+  }
+
+  return metaAntecedentNodesMatches;
+}
+
+function matchMetaAntecedentMetavariable(metaAntecedentMetavariableNode, nodes, metaSubstitutions) {
+  let metaAntecedentMetavariableMatches;
+
+  const metaAntecedentMetavariableName = metavariableNameFromMetavariableNode(metaAntecedentMetavariableNode),
+        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+          const metavariableName = metaSubstitution.getMetavariableName();
+
+          if (metavariableName === metaAntecedentMetavariableName) {
+            return true;
+          }
+        }) || null;
+
+  if (metaSubstitution !== null) {
+    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+
+    metaAntecedentMetavariableMatches = metaSubstitutionNodesMatch;  ///
+  } else {
+    const metavariableName = metaAntecedentMetavariableName, ///
+          metaSubstitution = MetaSubstitution.fromMetavariableNameAndNodes(metavariableName, nodes);
+
+    metaSubstitutions.push(metaSubstitution);
+
+    metaAntecedentMetavariableMatches = true;
+  }
+
+  return metaAntecedentMetavariableMatches;
+}
+
+function matchMetaAntecedentTerminalNode(metaAntecedentTerminalNode, terminalNode, metaSubstitutions) {
+  const matches = metaAntecedentTerminalNode.match(terminalNode),
+        metaAntecedentTerminalNodeMatches = matches;
+
+  return metaAntecedentTerminalNodeMatches;
+}
+
+function matchMetaAntecedentNonTerminalNode(metaAntecedentNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+  let metaAntecedentNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+        metaAntecedentRuleName = metaAntecedentNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === metaAntecedentRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+          metaAntecedentChildNodes = metaAntecedentNonTerminalNode.getChildNodes(),
+          nodes = childNodes, ///
+          metaAntecedentNodes = metaAntecedentChildNodes, ///
+          metaAntecedentChildNodesMatches = matchMetaAntecedentNodes(metaAntecedentNodes, nodes, metaSubstitutions);
+
+    metaAntecedentNonTerminalNodeMatches = metaAntecedentChildNodesMatches; ///
+
+    if (!metaAntecedentNonTerminalNodeMatches) {
+      const ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME);
+
+      if (ruleNameMetastatementRuleName) {
+        const metastatementNode = nonTerminalNode,  ///
+              metaAntecedentMetastatementNode = metaAntecedentNonTerminalNode,  ///
+              metaAntecedentMetastatementNodeMatches = matchMetaAntecedentMetastatementNode(metaAntecedentMetastatementNode, metastatementNode, metaSubstitutions);
+
+        metaAntecedentNonTerminalNodeMatches = metaAntecedentMetastatementNodeMatches; ///
+      }
+    }
+  }
+
+  return metaAntecedentNonTerminalNodeMatches;
+}
+
+function matchMetaAntecedentMetastatementNode(metaAntecedentMetastatementNode, metastatementNode, metaSubstitutions) {
+  let metaAntecedentMetastatementNodeMatches = false;
+
+  const metaAntecedentNonTerminalNode = metaAntecedentMetastatementNode,  ///
+        metaAntecedentChildNodes = metaAntecedentNonTerminalNode.getChildNodes(),
+        metaAntecedentChildNodesLength = metaAntecedentChildNodes.length;
+
+  if (metaAntecedentChildNodesLength === 1) {
+    const firstMetaAntecedentChildNode = first(metaAntecedentChildNodes),
+          metaAntecedentChildNode = firstMetaAntecedentChildNode,  ///
+          metaAntecedentChildNodeNonTerminalNode = metaAntecedentChildNode.isNonTerminalNode();
+
+    if (metaAntecedentChildNodeNonTerminalNode) {
+      const metaAntecedentNonTerminalChildNode = metaAntecedentChildNode,  ///
+            metaAntecedentNonTerminalChildNodeRuleName = metaAntecedentNonTerminalChildNode.getRuleName(),
+            metaAntecedentNonTerminalChildNodeRuleNameMetavariableRuleName = (metaAntecedentNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+      if (metaAntecedentNonTerminalChildNodeRuleNameMetavariableRuleName) {
+        const metaAntecedentMetavariableNode = metaAntecedentNonTerminalChildNode,  ///
+              nonTerminalNode = metastatementNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodes = childNodes, ///
+              metaAntecedentMetavariableMatches = matchMetaAntecedentMetavariable(metaAntecedentMetavariableNode, nodes, metaSubstitutions);
+
+        metaAntecedentMetastatementNodeMatches = metaAntecedentMetavariableMatches; ///
+      }
+    }
+  }
+
+  return metaAntecedentMetastatementNodeMatches;
+}

package/src/premise.js

@@ -12,8 +12,8 @@ import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME }
 
 const metastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
       metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
-      unqualifiedStatementStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement/statement!"),
-      unqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/unqualifiedMetastatement/metastatement!"),
+      unqualifiedStatementStatementNodesQuery = nodesQuery("/subproof/antecedent/unqualifiedStatement!/statement!"),
+      unqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/metaSubproof/metaAntecedent/unqualifiedMetastatement!/metastatement!"),
       qualifiedOrUnqualifiedStatementStatementNodeQuery = nodeQuery("/subproof/subDerivation/qualifiedStatement|unqualifiedStatement[-1]/statement!"),
       qualifiedOrUnqualifiedMetastatementMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
 

package/src/utilities/releaseContext.js

@@ -9,7 +9,7 @@ export function createReleaseContext(dependency, dependentNames, context, callba
         releaseContext = releaseContextMap[releaseName] || null;
 
   if (releaseContext !== null) {
-    const error = null;
+    const error = checkReleaseMatchesDependency(dependency, dependentNames, releaseContext);
 
     callback(error);
 
@@ -33,18 +33,9 @@ export function createReleaseContext(dependency, dependentNames, context, callba
       return;
     }
 
-    const releaseMatchesDependency = checkReleaseMatchesDependency(dependency, dependentNames, releaseContext, context);
-
-    if (!releaseMatchesDependency)  {
-      const version = releaseContext.getVersion(),
-            versionString = version.toString(),
-            lastDependentName = last(dependentNames),
-            dependentName = lastDependentName,  ///
-            dependencyName = dependency.getName(),
-            shortenedVersion = dependency.getShortedVersion(),
-            shortenedVersionString = shortenedVersion.toString(),
-            error = `Version mismatch: '${dependentName}' requires '${dependencyName}' to be version ${shortenedVersionString}.0 or higher but version ${versionString} has been supplied.`;
+    error = checkReleaseMatchesDependency(dependency, dependentNames, releaseContext);
 
+    if (error !== null)  {
       callback(error);
 
       return;
@@ -78,7 +69,7 @@ export function initialiseReleaseContext(dependency, dependentName, verified, co
     if (!releaseContextVerified) {
       const { log } = context;
 
-      log .error(`Unable to initialise the '${releaseName}' dependency's context because its '${dependentName}' dependent is a package.`);
+      log.error(`Unable to initialise the '${releaseName}' dependency's context because its '${dependentName}' dependent is a package.`);
 
       return;
     }
@@ -105,15 +96,28 @@ export default {
 };
 
 function checkCyclicDependencyExists(dependency, dependentNames) {
+  let error = null;
+
   const dependencyName = dependency.getName(),
         dependentNamesIncludesDependencyName = dependentNames.includes(dependencyName),
         cyclicDependencyExists = dependentNamesIncludesDependencyName;  ///
 
-  return cyclicDependencyExists;
+  if (cyclicDependencyExists) {
+    const firstDependentName = first(dependentNames),
+          dependencyNames = [  ///
+            ...dependentNames,
+            firstDependentName
+          ],
+          dependencyNamesString = dependencyNames.join(`' -> '`);
+
+    error =`There is a cyclic dependency: '${dependencyNamesString}'.`;
+  }
+
+  return error;
 }
 
-function checkReleaseMatchesDependency(dependency, dependentNames, releaseContext, context) {
-  let releaseMatchesDependency = true;
+function checkReleaseMatchesDependency(dependency, dependentNames, releaseContext) {
+  let error = null;
 
   const entries = releaseContext.getEntries(),
         shortenedVersion = dependency.getShortedVersion();
@@ -122,11 +126,19 @@ function checkReleaseMatchesDependency(dependency, dependentNames, releaseContex
     const entriesMatchShortenedVersion = entries.matchShortenedVersion(shortenedVersion);
 
     if (!entriesMatchShortenedVersion) {
-      releaseMatchesDependency = false;
+      const version = releaseContext.getVersion(),
+            versionString = version.toString(),
+            lastDependentName = last(dependentNames),
+            dependentName = lastDependentName,  ///
+            dependencyName = dependency.getName(),
+            shortenedVersion = dependency.getShortedVersion(),
+            shortenedVersionString = shortenedVersion.toString();
+
+      error = `Version mismatch: '${dependentName}' requires '${dependencyName}' to be version ${shortenedVersionString}.0 or higher but version ${versionString} has been supplied.`;
     }
   }
 
-  return releaseMatchesDependency;
+  return error;
 }
 
 function createDependencyReleaseContexts(dependency, dependentNames, context, callback) {
@@ -139,17 +151,9 @@ function createDependencyReleaseContexts(dependency, dependentNames, context, ca
   dependentNames = [ ...dependentNames, dependencyName ];  ///
 
   dependencies.asynchronousForEachDependency((dependency, next, done) => {
-    const cyclicDependencyExists = checkCyclicDependencyExists(dependency, dependentNames);
-
-    if (cyclicDependencyExists) {
-      const firstDependentName = first(dependentNames),
-            dependencyNames = [  ///
-              ...dependentNames,
-              firstDependentName
-            ],
-            dependencyNamesString = dependencyNames.join(`' -> '`),
-            error =`There is a cyclic dependency: '${dependencyNamesString}'.`;
+    const error = checkCyclicDependencyExists(dependency, dependentNames);
 
+    if (error !== null) {
       callback(error);
 
       return;

package/src/verify/antecedent.js

@@ -2,10 +2,10 @@
 
 import ProofStep from "../step/proof";
 import Antecedent from "../antecedent";
+import verifyStatement from "./statement";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
-import verifyStatement from "./statement";
 
 const statementNodeQuery = nodeQuery("/antecedent/unqualifiedStatement!/statement!");
 

package/src/verify/{statementTypeAssertion.js → assertion/type.js}

@@ -1,58 +1,53 @@
 "use strict";
 
-import Variable from "../variable";
+import Variable from "../../variable";
 
-import { first } from "../utilities/array";
-import { nodeAsString } from "../utilities/string";
-import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
-import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../verify/term";
+import { first } from "../../utilities/array";
+import { nodeAsString } from "../../utilities/string";
+import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../../verify/term";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
-      typeNodeQuery = nodeQuery("/typeAssertion/type"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+      typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyStatementTypeAssertion(statementNode, qualified, proofContext) {
-  let statementTypeAssertionVerified = false;
+export default function verifyStatementTypeAssertion(typeAssertionNode, qualified, proofContext) {
+  let typeAssertionVerified = false;
 
-  proofContext.begin(statementNode);
+  proofContext.begin(typeAssertionNode);
 
-  const statementString = nodeAsString(statementNode);
+  const statementString = nodeAsString(typeAssertionNode);
 
-  proofContext.debug(`Verifying the '${statementString}' statement type assertion...`);
+  proofContext.debug(`Verifying the '${statementString}' type assertion...`);
 
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+  const typeNode = typeNodeQuery(typeAssertionNode),
+        typeName = typeNameFromTypeNode(typeNode),
+        typePresent = proofContext.isTypePresentByTypeName(typeName);
 
-  if (typeAssertionNode !== null) {
-    const typeNode = typeNodeQuery(typeAssertionNode),
-          typeName = typeNameFromTypeNode(typeNode),
-          typePresent = proofContext.isTypePresentByTypeName(typeName);
-
-    if (!typePresent) {
-      proofContext.error(`The ${typeName} type is not present.`);
-    } else {
-      if (!statementTypeAssertionVerified) {
-        const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext);
+  if (!typePresent) {
+    proofContext.error(`The ${typeName} type is not present.`);
+  } else {
+    if (!typeAssertionVerified) {
+      const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext);
 
-        statementTypeAssertionVerified = variableTypeAssertionVerified;  ///
-      }
+      typeAssertionVerified = variableTypeAssertionVerified;  ///
+    }
 
-      if (!statementTypeAssertionVerified) {
-        const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext);
+    if (!typeAssertionVerified) {
+      const termTypeAssertionVerified = verifyTermTypeAssertion(typeAssertionNode, qualified, proofContext);
 
-        statementTypeAssertionVerified = termTypeAssertionVerified;  ///
-      }
+      typeAssertionVerified = termTypeAssertionVerified;  ///
     }
   }
 
-  if (statementTypeAssertionVerified) {
+  if (typeAssertionVerified) {
     proofContext.info(`Verified the '${statementString}' statement type assertion.`);
   }
 
-  statementTypeAssertionVerified ?
-    proofContext.complete(statementNode) :
-      proofContext.halt(statementNode);
+  typeAssertionVerified ?
+    proofContext.complete(typeAssertionNode) :
+      proofContext.halt(typeAssertionNode);
 
-  return statementTypeAssertionVerified;
+  return typeAssertionVerified;
 }
 
 function verifyVariableTypeAssertion(typeAssertionNode, qualified, proofContext) {

package/src/verify/derivation.js

@@ -2,6 +2,7 @@
 
 import ProofStep from "../step/proof";
 import ProofContext from "../context/proof";
+import verifyAntecedent from "./antecedent";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -10,8 +11,8 @@ import { SUBPROOF_RULE_NAME, QUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_STATEMEN
 
 const childNodesQuery = nodesQuery("/derivation|subDerivation/*"),
       statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
-      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation"),
-      unqualifiedStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement");
+      antecedentNodesQuery = nodesQuery("/subproof/antecedent"),
+      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
 export default function verifyDerivation(derivationNode, proofContext) {
   let derivationVerified;
@@ -20,7 +21,7 @@ export default function verifyDerivation(derivationNode, proofContext) {
 
   const childNodes = childNodesQuery(derivationNode);
 
-  derivationVerified = childNodes.every((childNode) => {  ///
+  derivationVerified = childNodes.every((childNode) => {
     const childVerified = verifyChild(childNode, proofContext);
 
     if (childVerified) {
@@ -36,13 +37,13 @@ export default function verifyDerivation(derivationNode, proofContext) {
 }
 
 function verifySubDerivation(subDerivationNode, proofContext) {
-  let derivationVerified;
+  let subDerivationVerified;
 
   proofContext.begin(subDerivationNode);
 
   const childNodes = childNodesQuery(subDerivationNode);
 
-  derivationVerified = childNodes.every((childNode) => {  ///
+  subDerivationVerified = childNodes.every((childNode) => {
     const childVerified = verifyChild(childNode, proofContext);
 
     if (childVerified) {
@@ -50,11 +51,11 @@ function verifySubDerivation(subDerivationNode, proofContext) {
     }
   });
 
-  derivationVerified ?
+  subDerivationVerified ?
     proofContext.complete(subDerivationNode) :
       proofContext.halt(subDerivationNode);
 
-  return derivationVerified;
+  return subDerivationVerified;
 }
 
 function verifySubproof(subproofNode, proofContext) {
@@ -62,23 +63,17 @@ function verifySubproof(subproofNode, proofContext) {
 
   proofContext = ProofContext.fromProofContext(proofContext); ///
 
-  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(subproofNode),
-        unqualifiedStatementsVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
-          const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+  const antecedents = [],
+        antecedentNodes = antecedentNodesQuery(subproofNode),
+        antecedentsVerified = antecedentNodes.every((antecedentNode) => {
+          const antecedentVerified = verifyAntecedent(antecedentNode, antecedents, proofContext);
 
-          if (unqualifiedStatementVerified) {
+          if (antecedentVerified) {
             return true;
           }
         });
 
-  if (unqualifiedStatementsVerified) {
-    unqualifiedStatementNodes.forEach((unqualifiedStatementNode) => {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            proofStep = ProofStep.fromStatementNode(statementNode);
-
-      proofContext.addProofStep(proofStep);
-    });
-
+  if (antecedentsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),
           subDerivationVerified = verifySubDerivation(subDerivationNode, proofContext);
 

package/src/verify/metaAntecedent.js

@@ -0,0 +1,44 @@
+"use strict";
+
+import MetaproofStep from "../step/metaproof";
+import MetaAntecedent from "../metaAntecedent";
+import verifyMetastatement from "./metastatement";
+
+import { nodeQuery } from "../utilities/query";
+import { nodeAsString } from "../utilities/string";
+
+const metastatementNodeQuery = nodeQuery("/metaAntecedent/unqualifiedMetastatement!/metastatement!");
+
+export default function verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, metaproofContext) {
+  let metaAntecedentVerified;
+
+  metaproofContext.begin(metaAntecedentNode);
+
+  const metaAntecedentString = nodeAsString(metaAntecedentNode);
+
+  metaproofContext.debug(`Verifying the ${metaAntecedentString} metaAntecedent...`);
+
+  const metastatementNode = metastatementNodeQuery(metaAntecedentNode);
+
+  if (metastatementNode !== null) {
+    const qualified = false,
+          metastatementVerified = verifyMetastatement(metastatementNode, qualified, metaproofContext);
+
+    if (metastatementVerified) {
+      const metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
+            metaAntecedent = MetaAntecedent.fromMetastatementNode(metastatementNode);
+
+      metaAntecedents.push(metaAntecedent);
+
+      metaproofContext.addMetaproofStep(metaproofStep);
+    }
+
+    metaAntecedentVerified = true;
+  }
+
+  metaAntecedentVerified ?
+    metaproofContext.complete(metaAntecedentNode) :
+      metaproofContext.halt(metaAntecedentNode);
+
+  return metaAntecedentVerified;
+}