occam-verify-cli 0.0.1003 → 0.0.1006

package/src/verify/premise.js

@@ -1,49 +0,0 @@
-"use strict";
-
-import Premise from "../premise";
-import ProofStep from "../proofStep";
-import verifyStatement from "../verify/statement";
-
-import { nodeQuery } from "../utilities/query";
-import { assignAssignments } from "../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!");
-
-export default function verifyPremise(premiseNode, premises, localContext) {
-  let premiseVerified;
-
-  const premiseString = localContext.nodeAsString(premiseNode);
-
-  localContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const stated = true,
-          assignments = [],
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-      if (assignmentsAssigned) {
-        const premise = Premise.fromStatementNode(statementNode),
-              proofStep = ProofStep.fromStatementNode(statementNode);
-
-        premises.push(premise);
-
-        localContext.addProofStep(proofStep);
-
-        premiseVerified = true;
-      }
-    }
-  }
-
-  if (premiseVerified) {
-    localContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
-  }
-
-  return premiseVerified;
-}

package/src/verify/premises.js

@@ -1,17 +0,0 @@
-"use strict";
-
-import verifyPremise from "../verify/premise";
-
-export default function verifyPremises(premiseNodes, premises, localContext) {
-  let premisesVerified;
-
-  premisesVerified = premiseNodes.every((premiseNode) => {
-    const premiseVerified = verifyPremise(premiseNode, premises, localContext);
-
-    if (premiseVerified) {
-      return true;
-    }
-  });
-
-  return premisesVerified;
-}

package/src/verify/proof.js

@@ -1,31 +0,0 @@
-"use strict";
-
-import LocalContext from "../context/local";
-import verifyDerivation from "../verify/derivation";
-
-import { nodeQuery } from "../utilities/query";
-
-const derivationNodeQuery = nodeQuery("/proof/derivation!");
-
-export default function verifyProof(proofNode, statementNode, substitutions, localContext) {
-  let proofVerified = false;
-
-  localContext = LocalContext.fromLocalContext(localContext); ///
-
-  const derivationNode = derivationNodeQuery(proofNode),
-        derivationVerified = verifyDerivation(derivationNode, substitutions, localContext);
-
-  if (derivationVerified) {
-    const lastProofStep = localContext.getLastProofStep();
-
-    if (lastProofStep !== null) {
-      const lastProofStepStatementNode = lastProofStep.getStatementNode(),
-            lastStatementNode = lastProofStepStatementNode, ///
-            statementNodeMatchesLastStatementNode = statementNode.match(lastStatementNode);
-
-      proofVerified = statementNodeMatchesLastStatementNode;  ///
-    }
-  }
-
-  return proofVerified;
-}

package/src/verify/rule.js

@@ -1,71 +0,0 @@
-"use strict";
-
-import Rule from "../rule";
-import verifyProof from "../verify/proof";
-import LocalContext from "../context/local";
-import verifyLabels from "../verify/labels";
-import verifyPremises from "../verify/premises";
-import verifyConclusion from "../verify/conclusion";
-
-import { first } from "../utilities/array";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import Substitutions from "../substitutions";
-
-const proofNodeQuery = nodeQuery("/rule/proof!"),
-      labelNodesQuery = nodesQuery("/rule/label"),
-      premisesNodeQuery = nodesQuery("/rule/premise"),
-      conclusionNodeQuery = nodeQuery("/rule/conclusion!");
-
-export default function verifyRule(ruleNode, fileContext) {
-  let ruleVerified = false;
-
-  const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = fileContext.nodesAsString(labelNodes);
-
-  fileContext.trace(`Verifying the '${labelsString}' rule...`, ruleNode);
-
-  const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
-
-  if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext),
-          premises = [],
-          premiseNodes = premisesNodeQuery(ruleNode),
-          premisesVerified = verifyPremises(premiseNodes, premises, localContext);
-
-    if (premisesVerified) {
-      const conclusions = [],
-            conclusionNode = conclusionNodeQuery(ruleNode),
-            conclusionVerified = verifyConclusion(conclusionNode, conclusions, localContext);
-
-      if (conclusionVerified) {
-        let proofVerified = true; ///
-
-        const firstConclusion = first(conclusions),
-              proofNode = proofNodeQuery(ruleNode),
-              conclusion = firstConclusion; ///
-
-        if (proofNode !== null) {
-          const substitutions = Substitutions.fromNothing(),
-                statementNode = conclusion.getStatementNode();
-
-          proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
-        }
-
-        if (proofVerified) {
-          const rule = Rule.fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext);
-
-          fileContext.addRule(rule);
-
-          ruleVerified = true;
-        }
-      }
-    }
-  }
-
-  if (ruleVerified) {
-    fileContext.debug(`...verified the '${labelsString}' rule.`, ruleNode);
-  }
-
-  return ruleVerified;
-}

package/src/verify/statement/qualified.js

@@ -1,40 +0,0 @@
-"use strict";
-
-import verifyStatement from "../../verify/statement";
-import unifyQualifiedStatement from "../../unify/qualifiedStatement";
-
-import { nodeQuery } from "../../utilities/query";
-import { assignAssignments } from "../../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
-
-export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerified = false;
-
-  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-  localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
-
-  if (!qualifiedStatementVerified) {
-    const stated = true,
-          assignments = [],
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const qualifiedStatementUnified = unifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
-
-      if (qualifiedStatementUnified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-        qualifiedStatementVerified = assignmentsAssigned; ///
-      }
-    }
-  }
-
-  if (qualifiedStatementVerified) {
-    localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
-  }
-
-  return qualifiedStatementVerified;
-}

package/src/verify/statement/unqualified.js

@@ -1,49 +0,0 @@
-"use strict";
-
-import verifyStatement from "../../verify/statement";
-import unifyUnqualifiedStatement from "../../unify/unqualifiedStatement";
-
-import { nodeQuery } from "../../utilities/query";
-import { assignAssignments } from "../../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
-
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, localContext) {
-  let unqualifiedStatementVerified = false;
-
-  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
-
-  localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
-
-  if (!unqualifiedStatementVerified) {
-    const stated = false,
-          assignments = [],
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-      unqualifiedStatementVerified = assignmentsAssigned;  ///
-    }
-  }
-
-  if (!unqualifiedStatementVerified) {
-    const stated = true,
-          assignments = null,
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const unqualifiedStatementUnified = unifyUnqualifiedStatement(unqualifiedStatementNode, localContext);
-
-      unqualifiedStatementVerified = unqualifiedStatementUnified; ///
-    }
-  }
-
-  if (unqualifiedStatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
-  }
-
-  return unqualifiedStatementVerified;
-}

package/src/verify/statement.js

@@ -1,312 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-import verifyFrame from "../verify/frame";
-import verifyEquality from "../verify/equality";
-import verifyJudgement from "../verify/judgement";
-import verifyDeclaration from "../verify/declaration";
-import verifyTypeAssertion from "../verify/assertion/type";
-import metavariableUnifier from "../unifier/metavariable";
-import verifyDefinedAssertion from "../verify/assertion/defined";
-import verifySubproofAssertion from "../verify/assertion/subproof";
-import verifyContainedAssertion from "../verify/assertion/contained";
-import unifyStatementWithCombinators from "../unify/statementWithCombinators";
-import unifyStatementWithBracketedCombinator from "../unify/statementWithBracketedCombinator";
-
-import { nodeQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-
-const frameNodeQuery = nodeQuery("/statement/frame!"),
-      equalityNodeQuery = nodeQuery("/statement/equality!"),
-      judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      declarationNodeQuery = nodeQuery("/statement/declaration!"),
-      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
-      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
-
-const unifyStatementFunctions = [
-        unifyStatementWithBracketedCombinator,
-        unifyStatementWithCombinators
-      ],
-      verifyStatementFunctions = [
-        verifyStatementAsMetavariable,
-        verifyStatementAsEquality,
-        verifyStatementAsFrame,
-        verifyStatementAsJudgement,
-        verifyStatementAsDeclaration,
-        verifyStatementAsTypeAssertion,
-        verifyStatementAsDefinedAssertion,
-        verifyStatementAsSubproofAssertion,
-        verifyStatementAsContainedAssertion
-      ];
-
-function verifyStatement(statementNode, assignments, stated, localContext) {
-  let statementVerified = false;
-
-  const statementString = localContext.nodeAsString(statementNode);
-
-  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
-
-  if (!statementVerified) {
-    const statementUnified = unifyStatementFunctions.some((unifyStatementFunction) => {
-      const statementUnified = unifyStatementFunction(statementNode, assignments, stated, localContext);
-
-      if (statementUnified) {
-        return true;
-      }
-    });
-
-    statementVerified = statementUnified; ///
-  }
-
-  if (!statementVerified) {
-    statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
-      const statementVerified = verifyStatementFunction(statementNode, assignments, stated, localContext);
-
-      if (statementVerified) {
-        return true;
-      }
-    });
-  }
-
-  if (statementVerified) {
-    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
-  }
-
-  return statementVerified;
-}
-
-Object.assign(shim, {
-  verifyStatement
-});
-
-export default verifyStatement;
-
-function verifyStatementAsMetavariable(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsMetavariable = false;
-
-  const metavariableNode = metavariableNodeQuery(statementNode);
-
-  if (metavariableNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
-
-    const metavariableUnified = unifyMetavariable(metavariableNode, localContext);
-
-    statementVerifiedAsMetavariable = metavariableUnified;  ///
-
-    if (statementVerifiedAsMetavariable) {
-      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsMetavariable;
-}
-
-function verifyStatementAsEquality(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsEquality = false;
-
-  const equalityNode = equalityNodeQuery(statementNode);
-
-  if (equalityNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
-
-    const equalityVerified = verifyEquality(equalityNode, assignments, stated, localContext);
-
-    statementVerifiedAsEquality = equalityVerified; ///
-
-    if (statementVerifiedAsEquality) {
-      localContext.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsEquality;
-}
-
-function verifyStatementAsFrame(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsFrame = false;
-
-  const frameNode = frameNodeQuery(statementNode);
-
-  if (frameNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a frame...`, statementNode);
-
-    const frameVerified = verifyFrame(frameNode, assignments, stated, localContext);
-
-    statementVerifiedAsFrame = frameVerified; ///
-
-    if (statementVerifiedAsFrame) {
-      localContext.debug(`...verified the '${statementString}' statement as a frame.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsFrame;
-}
-
-function verifyStatementAsJudgement(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsJudgement = false;
-
-  const judgementNode = judgementNodeQuery(statementNode);
-
-  if (judgementNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
-
-    const judgementVerified = verifyJudgement(judgementNode, assignments, stated, localContext);
-
-    statementVerifiedAsJudgement = judgementVerified;  ///
-
-    if (statementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsJudgement;
-}
-
-function verifyStatementAsDeclaration(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsDeclaration = false;
-
-  const declarationNode = declarationNodeQuery(statementNode);
-
-  if (declarationNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a declaration...`, statementNode);
-
-    const declarationVerified = verifyDeclaration(declarationNode, assignments, stated, localContext);
-
-    statementVerifiedAsDeclaration = declarationVerified; ///
-
-    if (statementVerifiedAsDeclaration) {
-      localContext.debug(`...verified the '${statementString}' statement as a declaration.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsDeclaration;
-}
-
-function verifyStatementAsTypeAssertion(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsTypeAssertion = false;
-
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
-
-  if (typeAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
-
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, stated, localContext);
-
-    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
-
-    if (statementVerifiedAsTypeAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsTypeAssertion;
-}
-
-function verifyStatementAsDefinedAssertion(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsDefinedAssertion = false;
-
-  const definedAssertionNode = definedAssertionNodeQuery(statementNode);
-
-  if (definedAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
-
-    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext);
-
-    statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
-
-    if (statementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsDefinedAssertion;
-}
-
-function verifyStatementAsSubproofAssertion(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsSubproofAssertion = false;
-
-  const subproofAssertionNode = subproofAssertionNodeQuery(statementNode);
-
-  if (subproofAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`, statementNode);
-
-    const subproofAssertionVerified = verifySubproofAssertion(subproofAssertionNode, assignments, stated, localContext);
-
-    statementVerifiedAsSubproofAssertion = subproofAssertionVerified; ///
-
-    if (statementVerifiedAsSubproofAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a subproof assertion.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsSubproofAssertion;
-}
-
-function verifyStatementAsContainedAssertion(statementNode, assignments, stated, localContext) {
-  let statementVerifiedAsContainedAssertion = false;
-
-  const containedAssertionNode = containedAssertionNodeQuery(statementNode);
-
-  if (containedAssertionNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a contained assertion...`, statementNode);
-
-    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, stated, localContext);
-
-    statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
-
-    if (statementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${statementString}' statement as a contained assertion.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsContainedAssertion;
-}
-
-function unifyMetavariable(metavariableNode, localContext) {
-  let metavariableUnified;
-
-  const metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Unifying the '${metavariableString}' metavariable...`, metavariableNode);
-
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-  if (metavariable !== null) {
-    const metavariableNodeA = metavariableNode; ///
-
-    metavariableNode = metavariable.getNode();
-
-    const metavariableNodeB = metavariableNode; ///
-
-    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
-
-    metavariableUnified = unified;  ///
-  }
-
-  if (metavariableUnified) {
-    localContext.debug(`...unified the '${metavariableString}' metavariable.`, metavariableNode);
-  }
-
-  return metavariableUnified;
-}

package/src/verify/statementAsCombinator.js

@@ -1,27 +0,0 @@
-"use strict";
-
-import Combinator from "../combinator";
-import statementAsCombinatorVerifier from "../verifier/statementAsCombinator";
-
-export default function verifyStatementAsCombinator(statementNode, fileContext) {
-  let statementVerifiedAsCombinator;
-
-  const statementString = fileContext.nodeAsString(statementNode);
-
-  fileContext.trace(`Verifying the '${statementString}' statement as a combinator...`, statementNode);
-
-  statementVerifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
-
-  if (statementVerifiedAsCombinator) {
-    const tokens = fileContext.getTokens(),
-          combinator = Combinator.fromStatementNodeAndTokens(statementNode, tokens);
-
-    fileContext.addCombinator(combinator);
-  }
-
-  if (statementVerifiedAsCombinator) {
-    fileContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
-  }
-
-  return statementVerifiedAsCombinator;
-}

package/src/verify/statementGivenMetaType.js

@@ -1,52 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-
-import { nodeQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-
-const metavariableNodeQuery = nodeQuery("/statement/metavariable!");
-
-export default function verifyStatementGivenMetaType(statementNode, metaType, assignments, stated, localContext) {
-  let statementVerifiedGivenMetaType;
-
-  const metaTypeName = metaType.getName();
-
-  switch (metaTypeName) {
-    case FRAME_META_TYPE_NAME:
-    case REFERENCE_META_TYPE_NAME: {
-      debugger
-
-      statementVerifiedGivenMetaType = false;
-
-      const metavariableNode = metavariableNodeQuery(statementNode);
-
-      if (metavariableNode !== null) {
-        const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-              metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-        if (metavariable !== null) {
-          const metavariableMetaType = metavariable.getMetaType();
-
-          if (metavariableMetaType === metaType) {
-            statementVerifiedGivenMetaType = true;
-          }
-        }
-      }
-
-      break;
-    }
-
-    case STATEMENT_META_TYPE_NAME: {
-      const { verifyStatement } = shim,
-            statementVerified = verifyStatement(statementNode, assignments, stated, localContext)
-
-      statementVerifiedGivenMetaType = statementVerified; ///
-
-      break;
-    }
-  }
-
-  return statementVerifiedGivenMetaType;
-}

package/src/verify/subproof.js

@@ -1,32 +0,0 @@
-"use strict";
-
-import LocalContext from "../context/local";
-import verifySuppositions from "../verify/suppositions";
-import verifySubDerivation from "../verify/subDerivation";
-
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
-      subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
-
-export default function verifySubproof(subproofNode, substitutions, localContext) {
-  let subproofVerified = false;
-
-  localContext = LocalContext.fromLocalContext(localContext);  ///
-
-  const suppositions = [],
-        suppositionNodes = suppositionNodesQuery(subproofNode),
-        suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
-
-  if (suppositionsVerified) {
-    const subDerivationNode = subDerivationNodeQuery(subproofNode),
-          subDerivationVerified = verifySubDerivation(subDerivationNode, substitutions, localContext);
-
-    if (subDerivationVerified) {
-      subproofVerified = true;
-    }
-  }
-
-  return subproofVerified;
-}
-