occam-verify-cli 0.0.491 → 0.0.494

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/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;
+}

package/src/verify/metaDerivation.js

@@ -2,6 +2,7 @@
 
 import MetaproofStep from "../step/metaproof";
 import MetaproofContext from "../context/metaproof";
+import verifyMetaAntecedent from "../verify/metaAntecedent";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
@@ -10,8 +11,8 @@ import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED
 
 const childNodesQuery = nodesQuery("/metaDerivation|metaSubDerivation/*"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation"),
-      unqualifiedMetastatementNodesQuery = nodesQuery("/metaSubproof/unqualifiedMetastatement");
+      metaAntecedentNodesQuery = nodesQuery("/metaSubproof/metaAntecedent"),
+      metaSubDerivationNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation");
 
 export default function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
   let metaDerivationVerified;
@@ -20,7 +21,7 @@ export default function verifyMetaDerivation(metaDerivationNode, metaproofContex
 
   const childNodes = childNodesQuery(metaDerivationNode);
 
-  metaDerivationVerified = childNodes.every((childNode) => {  ///
+  metaDerivationVerified = childNodes.every((childNode) => {
     const childVerified = verifyChild(childNode, metaproofContext);
 
     if (childVerified) {
@@ -36,13 +37,13 @@ export default function verifyMetaDerivation(metaDerivationNode, metaproofContex
 }
 
 function verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext) {
-  let metaDerivationVerified;
+  let metaSubDerivationVerified;
 
   metaproofContext.begin(metaSubDerivationNode);
 
   const childNodes = childNodesQuery(metaSubDerivationNode);
 
-  metaDerivationVerified = childNodes.every((childNode) => {  ///
+  metaSubDerivationVerified = childNodes.every((childNode) => {
     const childVerified = verifyChild(childNode, metaproofContext);
 
     if (childVerified) {
@@ -50,11 +51,11 @@ function verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext) {
     }
   });
 
-  metaDerivationVerified ?
+  metaSubDerivationVerified ?
     metaproofContext.complete(metaSubDerivationNode) :
       metaproofContext.halt(metaSubDerivationNode);
 
-  return metaDerivationVerified;
+  return metaSubDerivationVerified;
 }
 
 function verifyMetaSubproof(metaSubproofNode, metaproofContext) {
@@ -62,23 +63,17 @@ function verifyMetaSubproof(metaSubproofNode, metaproofContext) {
 
   metaproofContext = MetaproofContext.fromMetaproofContext(metaproofContext); ///
 
-  const unqualifiedMetastatementNodes = unqualifiedMetastatementNodesQuery(metaSubproofNode),
-        unqualifiedMetastatementsVerified = unqualifiedMetastatementNodes.every((unqualifiedMetastatementNode) => {
-          const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
+  const metaAntecedents = [],
+        metaAntecedentNodes = metaAntecedentNodesQuery(metaSubproofNode),
+        metaAntecedentsVerified = metaAntecedentNodes.every((metaAntecedentNode) => {
+          const metaAntecedentVerified = verifyMetaAntecedent(metaAntecedentNode, metaAntecedents, metaproofContext);
 
-          if (unqualifiedMetastatementVerified) {
+          if (metaAntecedentVerified) {
             return true;
           }
         });
 
-  if (unqualifiedMetastatementsVerified) {
-    unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      metaproofContext.addMetaproofStep(metaproofStep);
-    });
-
+  if (metaAntecedentsVerified) {
     const metaSubDerivationNode = metaSubDerivationNodeQuery(metaSubproofNode),
           metaSubDerivationVerified = verifyMetaSubDerivation(metaSubDerivationNode, metaproofContext);
 

package/src/verify/metaproof.js

@@ -1,15 +1,11 @@
 "use strict";
 
-import MetaproofStep from "../step/metaproof";
 import verifyMetaDerivation from "../verify/metaDerivation";
-import verifyQualifiedMetastatement from "./metastatement/qualified";
 
 import { matchNode } from "../utilities/node";
 import { nodeQuery } from "../utilities/query";
 
-const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!"),
-      metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
-      qualifiedMetastatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!");
+const metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!");
 
 export default function verifyMetaproof(metaproofNode, conclusion, metaproofContext) {
   let metaproofVerified = false;
@@ -17,27 +13,9 @@ export default function verifyMetaproof(metaproofNode, conclusion, metaproofCont
   metaproofContext.begin(metaproofNode);
 
   const metaDerivationNode = metaDerivationNodeQuery(metaproofNode),
-        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaproofNode);
+        metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, metaproofContext);
 
-  let metaDerivationVerified = false,
-      qualifiedMetastatementVerified = false;
-
-  if (metaDerivationNode !== null) {
-    metaDerivationVerified = verifyMetaDerivation(metaDerivationNode, metaproofContext);
-  }
-
-  if (qualifiedMetastatementNode !== null) {
-    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
-
-    if (qualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      metaproofContext.addMetaproofStep(metaproofStep);
-    }
-  }
-
-  if (metaDerivationVerified || qualifiedMetastatementVerified) {
+  if (metaDerivationVerified) {
     const lastMetaproofStep = metaproofContext.getLastMetaproofStep(),
           metaproofStep = lastMetaproofStep, ///
           metastatementNode = metaproofStep.getMetastatementNode(),

package/src/verify/metastatement.js

@@ -0,0 +1,15 @@
+"use strict";
+
+export default function verifyMetastatement(metastatementNode, qualified, metaproofContext) {
+  let metastatementVerified = true;
+
+  metaproofContext.begin(metastatementNode);
+
+  ///
+
+  metastatementVerified ?
+    metaproofContext.complete(metastatementNode) :
+      metaproofContext.halt(metastatementNode);
+
+  return metastatementVerified;
+}