occam-verify-cli 0.0.469 → 0.0.471

package/src/utilities/metaAssertion.js

@@ -0,0 +1,176 @@
+"use strict";
+
+import { first, second, third } from "../utilities/array";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { LEFT_BRACKET, RIGHT_BRACKET, BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH } from "../constants";
+
+export function matchBracketedMetastatementChildNode(childNodes, callback) {
+  let bracketedMetastatementChildNodeMatches = false;
+
+  const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromChildNodes(childNodes);
+
+  if (bracketedMetastatementChildNode !== null) {
+    bracketedMetastatementChildNodeMatches = callback(bracketedMetastatementChildNode);
+  }
+
+  return bracketedMetastatementChildNodeMatches;
+}
+
+export function matchTopmostMetaAssertionMetastatementNode(topmostMetaAssertionMetastatementNode, topmostMetastatementNode) {
+  let metaAssertionMetastatementNodeMatches;
+
+  const metastatementNode = topmostMetastatementNode, ///
+        metaAssertionMetastatementNode = topmostMetaAssertionMetastatementNode;  ///
+
+  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode);
+
+  if (!metaAssertionMetastatementNodeMatches) {
+    const nonTerminalNode = metastatementNode,  ///
+          childNodes = nonTerminalNode, ///
+          bracketedMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(childNodes, (bracketedMetastatementChildNode) => {
+            const metastatementNode = bracketedMetastatementChildNode,  ///
+                  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode),
+                  bracketedMetastatementChildNodeMatches = metaAssertionMetastatementNodeMatches;
+
+            return bracketedMetastatementChildNodeMatches;
+          });
+
+    metaAssertionMetastatementNodeMatches = bracketedMetastatementChildNodeMatches;  ///
+  }
+
+  if (!metaAssertionMetastatementNodeMatches) {
+    const metaAssertionNonTerminalNode = metaAssertionMetastatementNode,  ///
+          metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
+          bracketedMetaAssertionMetastatementChildNodeMatches = matchBracketedMetastatementChildNode(metaAssertionChildNodes, (bracketedMetaAssertionMetastatementChildNode) => {
+            const metaAssertionMetastatementNode = bracketedMetaAssertionMetastatementChildNode,  ///
+                  metaAssertionMetastatementNodeMatches = matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode),
+                  bracketedMetaAssertionMetastatementChildNodeMatches = metaAssertionMetastatementNodeMatches;
+
+            return bracketedMetaAssertionMetastatementChildNodeMatches;
+          });
+
+    metaAssertionMetastatementNodeMatches = bracketedMetaAssertionMetastatementChildNodeMatches;  ///
+  }
+
+  const topmostMetaAssertionMetastatementNodeMatches = metaAssertionMetastatementNodeMatches;  ///
+
+  return topmostMetaAssertionMetastatementNodeMatches;
+}
+
+export function bracketedMetastatementChildNodeFromChildNodes(childNodes) {
+  let bracketedMetastatementChildNode = null;
+
+  const childNodesLength = childNodes.length;
+
+  if (childNodesLength === BRACKETED_METASTATEMENT_CHILD_NODES_LENGTH) {
+    const firstChildNode = first(childNodes),
+          thirdChildNode = third(childNodes),
+          secondChildNode = second(childNodes),
+          firstChildNodeTerminalNode = firstChildNode.isTerminalNode(),
+          thirdChildNodeTerminalNode = thirdChildNode.isTerminalNode(),
+          secondChildNodeNonTerminalNode = secondChildNode.isNonTerminalNode();
+
+    if (firstChildNodeTerminalNode && secondChildNodeNonTerminalNode && thirdChildNodeTerminalNode) {
+      const nonTerminalNode = secondChildNode,  ///
+            firstTerminalNode = firstChildNode, ///
+            secondTerminalNode = thirdChildNode,  ///
+            nonTerminalNodeRuleName = nonTerminalNode.getRuleName(),
+            firstTerminalNodeContent = firstTerminalNode.getContent(),
+            secondTerminalNodeContent = secondTerminalNode.getContent(),
+            firstTerminalNodeContentLeftBracket = (firstTerminalNodeContent === LEFT_BRACKET),
+            secondTerminalNodeContentRightBracket = (secondTerminalNodeContent === RIGHT_BRACKET),
+            nonTerminalNodeRuleNameMetastatementRuleName = (nonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+      if (firstTerminalNodeContentLeftBracket && nonTerminalNodeRuleNameMetastatementRuleName && secondTerminalNodeContentRightBracket) {
+        bracketedMetastatementChildNode = nonTerminalNode;  ///
+      }
+    }
+  }
+
+  return bracketedMetastatementChildNode;
+}
+
+function matchMetaAssertionNode(metaAssertionNode, node) {
+  let metaAssertionNodeMatches = false;
+
+  const nodeTerminalNode = node.isTerminalNode(),
+    ruleNodeTerminalNode = metaAssertionNode.isTerminalNode();
+
+  if (nodeTerminalNode === ruleNodeTerminalNode) {
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+        metaAssertionTerminalNode = metaAssertionNode,  ///
+        metaAssertionTerminalNodeMatches = matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode);
+
+      metaAssertionNodeMatches = metaAssertionTerminalNodeMatches;  ///
+    } else {
+      const nonTerminalNode = node, ///
+        metaAssertionNonTerminalNode = metaAssertionNode,  ///
+        metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
+
+      metaAssertionNodeMatches = metaAssertionNonTerminalNodeMatches; ///
+    }
+  }
+
+  return metaAssertionNodeMatches;
+}
+
+function matchMetaAssertionNodes(metaAssertionNodes, nodes) {
+  let metaAssertionNodesMatches = false;
+
+  const nodesLength = nodes.length,
+    metaAssertionNodesLength = metaAssertionNodes.length;
+
+  if (nodesLength === metaAssertionNodesLength) {
+    metaAssertionNodesMatches = nodes.every((node, index) => {
+      const metaAssertionNode = metaAssertionNodes[index],
+        metaAssertionNodeMatches = matchMetaAssertionNode(metaAssertionNode, node);
+
+      if (metaAssertionNodeMatches) {
+        return true;
+      }
+    });
+  }
+
+  return metaAssertionNodesMatches;
+}
+
+function matchMetaAssertionTerminalNode(metaAssertionTerminalNode, terminalNode) {
+  let metaAssertionTerminalNodeMatches = false;
+
+  const matches = metaAssertionTerminalNode.match(terminalNode);
+
+  if (matches) {
+    metaAssertionTerminalNodeMatches = true;
+  }
+
+  return metaAssertionTerminalNodeMatches;
+}
+
+function matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode) {
+  let metaAssertionNonTerminalNodeMatches = false;
+
+  const ruleName = nonTerminalNode.getRuleName(),
+    metaAssertionRuleName = metaAssertionNonTerminalNode.getRuleName(); ///
+
+  if (ruleName === metaAssertionRuleName) {
+    const childNodes = nonTerminalNode.getChildNodes(),
+      nodes = childNodes, ///
+      metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
+      metaAssertionNodes = metaAssertionChildNodes, ///
+      metaAssertionNodesMatches = matchMetaAssertionNodes(metaAssertionNodes, nodes);
+
+    metaAssertionNonTerminalNodeMatches = metaAssertionNodesMatches;  ///
+  }
+
+  return metaAssertionNonTerminalNodeMatches;
+}
+
+function matchMetaAssertionMetastatementNode(metaAssertionMetastatementNode, metastatementNode) {
+  const nonTerminalNode = metastatementNode,  ///
+    metaAssertionNonTerminalNode = metaAssertionMetastatementNode,  ///
+    metaAssertionNonTerminalNodeMatches = matchMetaAssertionNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode),
+    metaAssertionMetastatementNodeNatches = metaAssertionNonTerminalNodeMatches;  ///
+
+  return metaAssertionMetastatementNodeNatches;
+}

package/src/utilities/node.js

@@ -0,0 +1,72 @@
+"use strict";
+
+export function matchNode(nodeA, nodeB) {
+  let nodeMatches = false;
+
+  const nodeATerminalNode = nodeA.isTerminalNode(),
+        nodeBTerminalNode = nodeB.isTerminalNode();
+
+  if (nodeATerminalNode === nodeBTerminalNode) {
+    if (nodeATerminalNode) {
+      const terminalNodeA = nodeA,  ///
+            terminalNodeB = nodeB,  ///
+            terminalNodeMatches = matchTerminalNode(terminalNodeA, terminalNodeB);
+
+      nodeMatches = terminalNodeMatches;  ///
+    } else {
+      const nonTerminalNodeA = nodeA,  ///
+            nonTerminalNodeB = nodeB, ///
+            nonTerminalNodeMatches = matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+
+      nodeMatches = nonTerminalNodeMatches; ///
+    }
+  }
+
+  return nodeMatches;
+}
+
+function matchNodes(nodesA, nodesB) {
+  let nodesMatch = false;
+
+  const nodesALength = nodesA.length,
+        nodesBLength = nodesB.length;
+
+  if (nodesALength === nodesBLength) {
+    nodesMatch = nodesA.every((nodeA, index) => {
+      const nodeB = nodesB[index],
+            nodeMatches = matchNode(nodeA, nodeB);
+
+      if (nodeMatches) {
+        return true;
+      }
+    })
+  }
+
+  return nodesMatch;
+}
+
+function matchTerminalNode(terminalNodeA, terminalNodeB) {
+  const matches = terminalNodeA.match(terminalNodeB),
+        terminalNodeMatches = matches;  ///
+
+  return terminalNodeMatches;
+}
+
+function matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB) {
+  let nonTerminalNodeMatches = false;
+
+  const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+        nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+  if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+    const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+          nodesA = nonTerminalNodeAChildNodes, ///
+          nodesB = nonTerminalNodeBChildNodes, ///
+          nodesMatch = matchNodes(nodesA, nodesB);
+
+    nonTerminalNodeMatches = nodesMatch; ///
+  }
+
+  return nonTerminalNodeMatches;
+}

package/src/verify/antecedent.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Assertion from "../assertion";
+import ProofStep from "../step/proof";
 import Antecedent from "../antecedent";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
@@ -19,12 +19,12 @@ export default function verifyAntecedent(antecedentNode, antecedents, proofConte
 
   if (unqualifiedStatementVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
-          assertion = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode),
+          proofStep = ProofStep.fromStatementNode(statementNode),
           antecedent = Antecedent.fromStatementNode(statementNode);
 
     antecedents.push(antecedent);
 
-    proofContext.addAssertion(assertion);
+    proofContext.addProofStep(proofStep);
 
     antecedentOrAntecedentsVerified = true;
   }

package/src/verify/derivation.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Assertion from "../assertion";
+import ProofStep from "../step/proof";
 import ProofContext from "../context/proof";
 import verifyQualifiedStatement from "../verify/statement/qualified";
 import verifyUnqualifiedStatement from "../verify/statement/unqualified";
@@ -8,7 +8,8 @@ import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { SUBPROOF_RULE_NAME, QUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
 
-const derivationNodeQuery = nodeQuery("/subproof/derivation|abridgedDerivation!"),  ///
+const statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
+      derivationNodeQuery = nodeQuery("/subproof/derivation|abridgedDerivation!"),  ///
       derivationChildNodesQuery = nodesQuery("/derivation|abridgedDerivation/*"),
       unqualifiedStatementNodesQuery = nodesQuery("/subproof/unqualifiedStatement")
 
@@ -54,9 +55,9 @@ function verifyDerivationChild(derivationChildNode, proofContext) {
             subproofVerified = verifySubproof(subproofNode, proofContext);
 
       if (subproofVerified) {
-        const assertion = Assertion.fromSubproofNode(subproofNode);
+        const proofStep = ProofStep.fromSubproofNode(subproofNode);
 
-        proofContext.addAssertion(assertion);
+        proofContext.addProofStep(proofStep);
 
         derivationChildVerified = true;
       }
@@ -69,9 +70,10 @@ function verifyDerivationChild(derivationChildNode, proofContext) {
             qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, proofContext);
 
       if (qualifiedStatementVerified) {
-        const assertion = Assertion.fromQualifiedStatementNode(qualifiedStatementNode);
+        const statementNode = statementNodeQuery(qualifiedStatementNode),
+              proofStep = ProofStep.fromStatementNode(statementNode);
 
-        proofContext.addAssertion(assertion);
+        proofContext.addProofStep(proofStep);
 
         derivationChildVerified = qualifiedStatementVerified; ///
       }
@@ -84,9 +86,10 @@ function verifyDerivationChild(derivationChildNode, proofContext) {
             unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
 
       if (unqualifiedStatementVerified) {
-        const assertion = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode);
+        const statementNode = statementNodeQuery(unqualifiedStatementNode),
+              proofStep = ProofStep.fromStatementNode(statementNode);
 
-        proofContext.addAssertion(assertion);
+        proofContext.addProofStep(proofStep);
 
         derivationChildVerified = true;
       }
@@ -114,9 +117,10 @@ function verifySubproof(subproofNode, proofContext) {
 
   if (unqualifiedStatementsVerified) {
     unqualifiedStatementNodes.forEach((unqualifiedStatementNode) => {
-      const assertion = Assertion.fromUnqualifiedStatementNode(unqualifiedStatementNode);
+      const statementNode = statementNodeQuery(unqualifiedStatementNode),
+            proofStep = ProofStep.fromStatementNode(statementNode);
 
-      proofContext.addAssertion(assertion);
+      proofContext.addProofStep(proofStep);
     });
 
     const derivationNode = derivationNodeQuery(subproofNode),

package/src/verify/equality.js

@@ -18,19 +18,14 @@ export default function verifyEquality(equalityNode, proofContext) {
 
   proofContext.debug(`Verifying the '${equalityString}' equality...`);
 
-  const types = [],
-        context = proofContext,
-        firstTermNode = firstTermNodeQuery(equalityNode),
-        secondTermNode = secondTermNodeQuery(equalityNode),
-        firstTermVerified = verifyTerm(firstTermNode, types, context),
-        secondTermVerified = verifyTerm(secondTermNode, types, context);
+  const equalityTypesVerified = verifyEqualityTypes(equalityNode, proofContext);
 
-  if (firstTermVerified && secondTermVerified) {
-    const firstType = first(types),
-          secondType = second(types),
-          firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType = firstType.isEqualToSubTypeOfOrSuperTypeOf(secondType);
+  if (equalityTypesVerified) {
+    const derived = proofContext.isDerived();
 
-    if (firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType) {
+    if (derived) {
+      debugger
+    } else {
       equalityVerified = true;
     }
   }
@@ -45,3 +40,26 @@ export default function verifyEquality(equalityNode, proofContext) {
 
   return equalityVerified;
 }
+
+function verifyEqualityTypes(equalityNode, proofContext) {
+  let equalityTypesVerified = false;
+
+  const types = [],
+        context = proofContext,  ///
+        firstTermNode = firstTermNodeQuery(equalityNode),
+        secondTermNode = secondTermNodeQuery(equalityNode),
+        firstTermVerified = verifyTerm(firstTermNode, types, context),
+        secondTermVerified = verifyTerm(secondTermNode, types, context);
+
+  if (firstTermVerified && secondTermVerified) {
+    const firstType = first(types),
+          secondType = second(types),
+          firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType = firstType.isEqualToSubTypeOfOrSuperTypeOf(secondType);
+
+    if (firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType) {
+      equalityTypesVerified = true;
+    }
+  }
+
+  return equalityTypesVerified;
+}

package/src/verify/metaDerivation.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import MetaAssertion from "../metaAssertion";
+import MetaproofStep from "../step/metaproof";
 import MetaproofContext from "../context/metaproof";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
@@ -8,7 +8,8 @@ import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified"
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { META_SUBPROOF_RULE_NAME, QUALIFIED_METASTATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 
-const metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation|abridgedMetaDerivation!"),  ///
+const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
+      metaDerivationNodeQuery = nodeQuery("/metaSubproof/metaDerivation|abridgedMetaDerivation!"),  ///
       metaDerivationChildNodesQuery = nodesQuery("/metaDerivation|abridgedMetaDerivation/*"),
       unqualifiedMetastatementNodesQuery = nodesQuery("/metaSubproof/unqualifiedMetastatement")
 
@@ -54,9 +55,9 @@ function verifyMetaDerivationChild(metaDerivationChildNode, metaproofContext) {
             metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, metaproofContext);
 
       if (metaSubproofVerified) {
-        const metaAssertion = MetaAssertion.fromMetaSubproofNode(metaSubproofNode);
+        const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
 
-        metaproofContext.addMetaAssertion(metaAssertion);
+        metaproofContext.addMetaproofStep(metaproofStep);
 
         metaDerivationChildVerified = true;
       }
@@ -69,9 +70,10 @@ function verifyMetaDerivationChild(metaDerivationChildNode, metaproofContext) {
             qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
       if (qualifiedMetastatementVerified) {
-        const metaAssertion = MetaAssertion.fromQualifiedMetastatementNode(qualifiedMetastatementNode);
+        const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-        metaproofContext.addMetaAssertion(metaAssertion);
+        metaproofContext.addMetaproofStep(metaproofStep);
 
         metaDerivationChildVerified = qualifiedMetastatementVerified; ///
       }
@@ -84,9 +86,10 @@ function verifyMetaDerivationChild(metaDerivationChildNode, metaproofContext) {
             unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
       if (unqualifiedMetastatementVerified) {
-        const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+        const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+              metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-        metaproofContext.addMetaAssertion(metaAssertion);
+        metaproofContext.addMetaproofStep(metaproofStep);
 
         metaDerivationChildVerified = true;
       }
@@ -114,9 +117,10 @@ function verifyMetaSubproof(metaSubproofNode, metaproofContext) {
 
   if (unqualifiedMetastatementsVerified) {
     unqualifiedMetastatementNodes.forEach((unqualifiedMetastatementNode) => {
-      const metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode);
+      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-      metaproofContext.addMetaAssertion(metaAssertion);
+      metaproofContext.addMetaproofStep(metaproofStep);
     });
 
     const metaDerivationNode = metaDerivationNodeQuery(metaSubproofNode),

package/src/verify/metaproof.js

@@ -1,12 +1,14 @@
 "use strict";
 
-import MetaAssertion from "../metaAssertion";
+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 metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
+const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!"),
+      metaDerivationNodeQuery = nodeQuery("/metaproof/metaDerivation!"),
       qualifiedMetastatementNodeQuery = nodeQuery("/metaproof/qualifiedMetastatement!");
 
 export default function verifyMetaproof(metaproofNode, conclusion, metaproofContext) {
@@ -25,23 +27,36 @@ export default function verifyMetaproof(metaproofNode, conclusion, metaproofCont
   }
 
   if (qualifiedMetastatementNode !== null) {
+    let derived;
+
+    derived = true;
+
+    metaproofContext.setDerived(derived);
+
     qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, metaproofContext);
 
+    derived = false;
+
+    metaproofContext.setDerived(derived);
+
     if (qualifiedMetastatementVerified) {
-      const metaAssertion = MetaAssertion.fromQualifiedMetastatementNode(qualifiedMetastatementNode);
+      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-      metaproofContext.addMetaAssertion(metaAssertion);
+      metaproofContext.addMetaproofStep(metaproofStep);
     }
   }
 
   if (metaDerivationVerified || qualifiedMetastatementVerified) {
-    const lastMetaAssertion = metaproofContext.getLastMetaAssertion(),
-          metaAssertion = lastMetaAssertion, ///
-          metastatementNode = conclusion.getMetastatementNode(),
-          metaAssertionMetastatementNode = metaAssertion.getMetastatementNode(),
-          metaAssertionMetastatementNodeMatches = matchMetaProofMetastatementNode(metaAssertionMetastatementNode, metastatementNode);
-
-    metaproofVerified = metaAssertionMetastatementNodeMatches;  ///
+    const lastMetaproofStep = metaproofContext.getLastMetaproofStep(),
+          metaproofStep = lastMetaproofStep, ///
+          metastatementNode = metaproofStep.getMetastatementNode(),
+          conclusionMetastatementNode = conclusion.getMetastatementNode(),
+          nodeA = metastatementNode,  ///
+          nodeB = conclusionMetastatementNode,  ///
+          nodeMatches = matchNode(nodeA, nodeB);
+
+    metaproofVerified = nodeMatches;  ///
   }
 
   metaproofVerified ?
@@ -50,83 +65,3 @@ export default function verifyMetaproof(metaproofNode, conclusion, metaproofCont
 
   return metaproofVerified;
 }
-
-function matchMetaProofMetastatementNode(metaAssertionMetastatementNode, metastatementNode) {
-  const metaAssertionNonTerminalNode = metaAssertionMetastatementNode,  ///
-        nonTerminalNode = metastatementNode,  ///
-        metaAssertionNonTerminalNodeMatches = matchMetaProofNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode),
-        metaAssertionMetastatementNodeMatches = metaAssertionNonTerminalNodeMatches;  ///
-
-  return metaAssertionMetastatementNodeMatches;
-}
-
-function matchMetaProofNode(metaAssertionNode, node) {
-  let metaAssertionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = metaAssertionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            metaAssertionTerminalNode = metaAssertionNode,  ///
-            metaAssertionTerminalNodeMatches = matchMetaProofTerminalNode(metaAssertionTerminalNode, terminalNode);
-
-      metaAssertionNodeMatches = metaAssertionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            metaAssertionNonTerminalNode = metaAssertionNode,  ///
-            metaAssertionNonTerminalNodeMatches = matchMetaProofNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode);
-
-      metaAssertionNodeMatches = metaAssertionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return metaAssertionNodeMatches;
-}
-
-function matchMetaProofNodes(metaAssertionNodes, nodes) {
-  let metaAssertionNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        metaAssertionNodesLength = metaAssertionNodes.length;
-
-  if (nodesLength === metaAssertionNodesLength) {
-    metaAssertionNodesMatches = nodes.every((node, index) => {
-      const metaAssertionNode = metaAssertionNodes[index],
-            metaAssertionNodeMatches = matchMetaProofNode(metaAssertionNode, node);
-
-      if (metaAssertionNodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return metaAssertionNodesMatches;
-}
-
-function matchMetaProofTerminalNode(metaAssertionTerminalNode, terminalNode) {
-  const matches = metaAssertionTerminalNode.match(terminalNode),
-        metaAssertionTerminalNodeMatches = matches;  ///
-
-  return metaAssertionTerminalNodeMatches;
-}
-
-function matchMetaProofNonTerminalNode(metaAssertionNonTerminalNode, nonTerminalNode) {
-  let metaAssertionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        metaAssertionRuleName = metaAssertionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === metaAssertionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          metaAssertionChildNodes = metaAssertionNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          metaAssertionNodes = metaAssertionChildNodes, ///
-          metaAssertionNodesMatches = matchMetaProofNodes(metaAssertionNodes, nodes);
-
-    metaAssertionNonTerminalNodeMatches = metaAssertionNodesMatches; ///
-  }
-
-  return metaAssertionNonTerminalNodeMatches;
-}

package/src/verify/metastatement/unqualified.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import MetaAssertion from "../../metaAssertion";
 import verifyMetastatement from "../../verify/metastatement";
 
 import { nodeQuery } from "../../utilities/query";
@@ -26,8 +25,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
       const derived = metaproofContext.isDerived();
 
       if (derived) {
-        const metaAssertion = MetaAssertion.fromMetastatementNode(metastatementNode),
-              metaAssertionMatches = metaproofContext.matchMetaAssertion(metaAssertion);
+        const metaAssertionMatches = metaproofContext.matchMetastatement(metastatementNode);
 
         unqualifiedMetastatementVerified = metaAssertionMatches;  ///
       } else {

package/src/verify/premiseOrPremises.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Premise from "../premise";
-import MetaAssertion from "../metaAssertion";
+import MetaproofStep from "../step/metaproof";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -21,12 +21,12 @@ export default function verifyPremiseOrPremises(premiseOrPremisesNode, premises,
 
     if (unqualifiedMetastatementVerified) {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            metaAssertion = MetaAssertion.fromUnqualifiedMetastatementNode(unqualifiedMetastatementNode),
+            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode),
             premise = Premise.fromMetastatementNode(metastatementNode);
 
       premises.push(premise);
 
-      metaproofContext.addMetaAssertion(metaAssertion);
+      metaproofContext.addMetaproofStep(metaproofStep);
 
       return true;
     }