occam-verify-cli 0.0.470 → 0.0.472

package/src/substitution.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { matchBracketedStatementChildNode, bracketedStatementChildNodeFromChildNodes } from "./utilities/statement";
+import { matchNodes, bracketedChildNodeFromChildNodes } from "./utilities/node";
 
 export default class Substitution {
   constructor(variableName, nodes) {
@@ -19,112 +19,41 @@ export default class Substitution {
   matchNodes(nodes) {
     let matches;
 
-    const substitutionNodes = this.nodes,  ///
-          substitutionNonTerminalNodeMatches = matchSubstitutionNodes(substitutionNodes, nodes);
+    const nodesA = this.nodes,  ///
+          nodesB = nodes,
+          metaSubstitutionNodesMatch = matchNodes(nodesA, nodesB);
 
-    matches = substitutionNonTerminalNodeMatches;  ///
+    matches = metaSubstitutionNodesMatch;  ///
 
     if (!matches) {
       const childNodes = nodes, ///
-            bracketedStatementChildNodeMatches = matchBracketedStatementChildNode(childNodes, (bracketedStatementChildNode) => {
-              const nonTerminalNode = bracketedStatementChildNode,  ///
-                    childNodes = nonTerminalNode.getChildNodes(),
-                    nodes = childNodes, ///
-                    assertionNonTerminalNodeMatches = matchSubstitutionNodes(substitutionNodes, nodes),
-                    bracketedStatementChildNodeMatches = assertionNonTerminalNodeMatches; ///
+            bracketedChildNode = bracketedChildNodeFromChildNodes(childNodes);
 
-              return bracketedStatementChildNodeMatches;
-            });
+      if (bracketedChildNode !== null) {
+        const nonTerminalNode = bracketedChildNode,  ///
+              childNodes = nonTerminalNode.getChildNodes(),
+              nodesB = childNodes, ///
+              nodesMatch = matchNodes(nodesA, nodesB);
 
-      matches = bracketedStatementChildNodeMatches; ///
+        matches = nodesMatch; ///
+      }
     }
 
     return matches;
   }
 
-  static fromVariableNameAndNodes(variableName, nodes) {
-    const bracketedStatementChildNode = bracketedStatementChildNodeFromChildNodes(nodes);
+  static fromMetavariableNameAndNodes(variableName, nodes) {
+    const bracketedChildNode = bracketedChildNodeFromChildNodes(nodes);
 
-    if (bracketedStatementChildNode !== null) {
-      const nonTerminalNode = bracketedStatementChildNode,  ///
+    if (bracketedChildNode !== null) {
+      const nonTerminalNode = bracketedChildNode,  ///
             childNodes = nonTerminalNode.getChildNodes();
 
       nodes = childNodes; ///
     }
 
-    const substitution = new Substitution(variableName, nodes);
-
-    return substitution;
-  }
-}
-
-function matchSubstitutionNode(substitutionNode, node) {
-  let substitutionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = substitutionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            substitutionTerminalNode = substitutionNode,  ///
-            substitutionTerminalNodeMatches = matchSubstitutionTerminalNode(substitutionTerminalNode, terminalNode);
-
-      substitutionNodeMatches = substitutionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            substitutionNonTerminalNode = substitutionNode,  ///
-            substitutionNonTerminalNodeMatches = matchSubstitutionNonTerminalNode(substitutionNonTerminalNode, nonTerminalNode);
-
-      substitutionNodeMatches = substitutionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return substitutionNodeMatches;
-}
-
-function matchSubstitutionNodes(substitutionNodes, nodes) {
-  let substitutionNodesMatches = false;
+    const metaSubstitution = new Substitution(variableName, nodes);
 
-  const nodesLength = nodes.length,
-        substitutionNodesLength = substitutionNodes.length;
-
-  if (nodesLength === substitutionNodesLength) {
-    substitutionNodesMatches = nodes.every((node, index) => {
-      const substitutionNode = substitutionNodes[index],
-            substitutionNodeMatches = matchSubstitutionNode(substitutionNode, node);
-
-      if (substitutionNodeMatches) {
-        return true;
-      }
-    })
-  }
-
-  return substitutionNodesMatches;
-}
-
-function matchSubstitutionTerminalNode(substitutionTerminalNode, terminalNode) {
-  const matches = substitutionTerminalNode.match(terminalNode),
-        substitutionTerminalNodeMatches = matches;  ///
-
-  return substitutionTerminalNodeMatches;
-}
-
-function matchSubstitutionNonTerminalNode(substitutionNonTerminalNode, nonTerminalNode) {
-  let substitutionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        substitutionRuleName = substitutionNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === substitutionRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          substitutionChildNodes = substitutionNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          substitutionNodes = substitutionChildNodes, ///
-          substitutionNodesMatches = matchSubstitutionNodes(substitutionNodes, nodes);
-
-    substitutionNonTerminalNodeMatches = substitutionNodesMatches; ///
+    return metaSubstitution;
   }
-
-  return substitutionNonTerminalNodeMatches;
 }

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { front, first, second, third, last, push, prune, filter } = arrayUtilities;
+export const { first, second, third, last, push, prune, filter } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;

package/src/utilities/node.js

@@ -0,0 +1,149 @@
+"use strict";
+
+import { first, second, third } from "./array";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { BRACKETED_CHILD_NODES_LENGTH, LEFT_BRACKET, RIGHT_BRACKET } from "../constants";
+
+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;
+}
+
+export 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;
+}
+
+export function matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB) {
+  let bracketedNodeMatches = false;
+
+  if (!bracketedNodeMatches) {
+    const nonTerminalNodeMatches = matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+
+    bracketedNodeMatches = nonTerminalNodeMatches;  ///
+  }
+
+  if (!bracketedNodeMatches) {
+    const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          childNodesA = nonTerminalNodeAChildNodes, ///
+          bracketedChildNodeA = bracketedChildNodeFromChildNodes(childNodesA);
+
+    if (bracketedChildNodeA !== null) {
+      const nodeA = bracketedChildNodeA,  ///
+            nodeB = nonTerminalNodeB, ///
+            nodeMatches = matchNode(nodeA, nodeB);
+
+      bracketedNodeMatches = nodeMatches; ///
+    }
+  }
+
+  if (!bracketedNodeMatches) {
+    const nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+          childNodesB = nonTerminalNodeBChildNodes, ///
+          bracketedChildNodeB = bracketedChildNodeFromChildNodes(childNodesB);
+
+    if (bracketedChildNodeB !== null) {
+      const nodeB = bracketedChildNodeB,  ///
+            nodeA = nonTerminalNodeA, ///
+            nodeMatches = matchNode(nodeA, nodeB);
+
+      bracketedNodeMatches = nodeMatches; ///
+    }
+  }
+
+  return bracketedNodeMatches;
+}
+
+export function bracketedChildNodeFromChildNodes(childNodes) {
+  let bracketedChildNode = null;
+
+  const childNodesLength = childNodes.length;
+
+  if (childNodesLength === BRACKETED_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) {
+        bracketedChildNode = nonTerminalNode;  ///
+      }
+    }
+  }
+
+  return bracketedChildNode;
+}
+
+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,19 +8,17 @@ 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")
 
 export default function verifyDerivation(derivationNode, proofContext) {
-  let derivationVerified,
-      derived;
+  let derivationVerified;
 
   proofContext.begin(derivationNode);
 
-  derived = true;
-
-  proofContext.setDerived(derived);
+  proofContext.setDerived();
 
   const derivationChildNodes = derivationChildNodesQuery(derivationNode);
 
@@ -32,9 +30,7 @@ export default function verifyDerivation(derivationNode, proofContext) {
     }
   });
 
-  derived = false;
-
-  proofContext.setDerived(derived);
+  proofContext.setDerived();
 
   derivationVerified ?
     proofContext.complete(derivationNode) :
@@ -54,9 +50,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 +65,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 +81,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 +112,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,19 +8,17 @@ 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")
 
 export default function verifyMetaDerivation(metaDerivationNode, metaproofContext) {
-  let metaDerivationVerified,
-      derived;
+  let metaDerivationVerified;
 
   metaproofContext.begin(metaDerivationNode);
 
-  derived = true;
-
-  metaproofContext.setDerived(derived);
+  metaproofContext.setDerived();
 
   const metaDerivationChildNodes = metaDerivationChildNodesQuery(metaDerivationNode);
 
@@ -32,9 +30,7 @@ export default function verifyMetaDerivation(metaDerivationNode, metaproofContex
     }
   });
 
-  derived = false;
-
-  metaproofContext.setDerived(derived);
+  metaproofContext.resetDerived();
 
   metaDerivationVerified ?
     metaproofContext.complete(metaDerivationNode) :
@@ -54,9 +50,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 +65,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 +81,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 +112,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),