occam-verify-cli 0.0.923 → 0.0.925

package/src/verify/statement/qualified.js

@@ -15,18 +15,17 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        verifyQualifiedStatementFunctions = [
-          verifyQualifiedStatementAAgainstRule,
-          verifyQualifiedStatementAAgainstReference,
-          verifyQualifiedStatementAAgainstAxiom,
-          verifyQualifiedStatementAAgainstLemma,
-          verifyQualifiedStatementAAgainstTheorem,
-          verifyQualifiedStatementAAgainstConjecture
-        ];
+  const verifyQualifiedStatementFunctions = [
+    verifyQualifiedStatementAAgainstRule,
+    verifyQualifiedStatementAAgainstAxiom,
+    verifyQualifiedStatementAAgainstLemma,
+    verifyQualifiedStatementAAgainstTheorem,
+    verifyQualifiedStatementAAgainstConjecture,
+    verifyQualifiedStatementAAgainstReference
+  ];
 
   qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
-    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, metavariableNode, substitutions, localContext);
+    const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
 
     if (qualifiedStatementVerified) {
       return true;
@@ -36,11 +35,7 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   if (qualifiedStatementVerified) {
     const derived = false,
           statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     qualifiedStatementVerified = statementVerified; ///
   }
@@ -52,10 +47,11 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstRule = false;
 
-  const rule = localContext.findRuleByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        rule = localContext.findRuleByMetavariableNode(metavariableNode);
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -76,10 +72,11 @@ function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, metavariab
   return qualifiedStatementVerifiedAgainstRule;
 }
 
-function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstAxiom = false;
 
-  const axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -100,10 +97,11 @@ function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, metavaria
   return qualifiedStatementVerifiedAgainstAxiom;
 }
 
-function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstLemma = false;
 
-  const lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -124,10 +122,11 @@ function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, metavaria
   return qualifiedStatementVerifiedAgainstLemma;
 }
 
-function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstTheorem = false;
 
-  const theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -148,10 +147,11 @@ function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, metavar
   return qualifiedStatementVerifiedAgainstTheorem;
 }
 
-function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstConjecture = false;
 
-  const conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -172,22 +172,19 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, meta
   return qualifiedStatementVerifiedAgainstConjecture;
 }
 
-function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, metavariableNode, substitutions, localContext) {
+function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementVerifiedAgainstReference = false;
 
-  const metavariableString = localContext.nodeAsString(metavariableNode),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext),
+  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
+        metavariableString = localContext.nodeAsString(metavariableNode),
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
         qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference...`, qualifiedStatementNode);
 
   if (metavariablePresent) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-      metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutions, () => {
-        const verifiedAhead = true;
-
-        return verifiedAhead;
-      });
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead);
 
     qualifiedStatementVerifiedAgainstReference = metavariableVerifiedAgainstStatement; ///
   }

package/src/verify/statement/unqualified.js

@@ -7,28 +7,70 @@ import { nodeQuery } from "../../utilities/query";
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
-  let unqualifiedStatementVerified = false;
+  let unqualifiedStatementVerified;
 
-  const statementNode = statementNodeQuery(unqualifiedStatementNode),
-        unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
 
   localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
 
+  const verifyUnqualifiedStatementFunctions = [
+    verifyDerivedUnqualifiedStatement,
+    verifyStatedUnqualifiedStatement
+  ];
+
+  unqualifiedStatementVerified = verifyUnqualifiedStatementFunctions.some((verifyUnqualifiedStatementFunction) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatementFunction(unqualifiedStatementNode, assignments, derived, localContext);
+
+    if (unqualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  if (unqualifiedStatementVerified) {
+    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
+  }
+
+  return unqualifiedStatementVerified;
+}
+
+function verifyDerivedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
+  let derivedUnqualifiedStatementVerified = false;
+
   if (derived) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${unqualifiedStatementString}' derived unqualified statement...`, unqualifiedStatementNode);
+
     const matchesStatementNode = localContext.matchStatementNode(statementNode);
 
-    unqualifiedStatementVerified = matchesStatementNode;  ///
+    derivedUnqualifiedStatementVerified = matchesStatementNode;  ///
+
+    if (derivedUnqualifiedStatementVerified) {
+      localContext.debug(`...verified the '${unqualifiedStatementString}' derived unqualified statement.`, unqualifiedStatementNode);
+    }
   }
 
-  if (!unqualifiedStatementVerified) {
+  return derivedUnqualifiedStatementVerified;
+}
+
+function verifyStatedUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
+  let statedUnqualifiedStatementVerified = false;
+
+  if (!derived) {
+    const statementNode = statementNodeQuery(unqualifiedStatementNode),
+          unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${unqualifiedStatementString}' stated unqualified statement...`, unqualifiedStatementNode);
+
     const statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-    unqualifiedStatementVerified = statementVerified; ///
-  }
+    statedUnqualifiedStatementVerified = statementVerified; ///
 
-  if (unqualifiedStatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
+    if (statedUnqualifiedStatementVerified) {
+      localContext.debug(`...verified the '${unqualifiedStatementString}' stated unqualified statement.`, unqualifiedStatementNode);
+    }
   }
 
-  return unqualifiedStatementVerified;
+  return statedUnqualifiedStatementVerified;
 }

package/src/verify/statement.js

@@ -1,18 +1,23 @@
 "use strict";
 
 import verifyEquality from "../verify/equality";
-import bracketedCombinator from "../ocmbinator/bracketed";
-import verifyTypeAssertion from "../verify/typeAssertion";
-import verifyStatementAsDefinedAssertion from "../verify/statementAsDefinedAssertion";
-import verifyStatementAsContainedAssertion from "../verify/statementAsContainedAssertion";
+import verifyJudgement from "../verify/judgement";
+import verifyTypeAssertion from "../verify/assertion/type";
+import verifyDefinedAssertion from "../verify/assertion/defined";
+import verifySubproofAssertion from "../verify/assertion/subproof";
+import verifyContainedAssertion from "../verify/assertion/contained";
 import statementAgainstCombinatorNodesVerifier from "../verifier/nodes/statementAgainstCombinator";
 
 import { nodeQuery } from "../utilities/query";
-import { isStatementDefinedAssertion } from "../verify/statementAsDefinedAssertion";
-import { isStatementContainedAssertion } from "../verify/statementAsContainedAssertion";
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+      judgementNodeQuery = nodeQuery("/statement/judgement!"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
 
 function verifyStatement(statementNode, assignments, derived, localContext) {
   let statementVerified;
@@ -22,9 +27,12 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
   const verifyStatementFunctions = [
+    verifyStatementAsMetavariable,
     verifyStatementAsEquality,
+    verifyStatementAsJudgement,
     verifyStatementAsTypeAssertion,
     verifyStatementAsDefinedAssertion,
+    verifyStatementAsSubproofAssertion,
     verifyStatementAsContainedAssertion,
     verifyStatementAgainstCombinators
   ];
@@ -53,7 +61,7 @@ export function verifyStandaloneStatement(statementNode, localContext, verifyAhe
 
   const derived = false,
         assignments = [],
-        statementVerified = verifyStatement(statementNode, assignments, derived);
+        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
   if (statementVerified) {
     const verifiedAhead = verifyAhead();
@@ -77,15 +85,14 @@ export default verifyStatement;
 export function verifyStatementAsEquality(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsEquality = false;
 
-  const statementEquality = isStatementEquality(statementNode);
+  const equalityNode = equalityNodeQuery(statementNode);
 
-  if (statementEquality) {
+  if (equalityNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
     localContext.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-    const equalityNode = equalityNodeQuery(statementNode),
-          equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -104,19 +111,14 @@ export function verifyStatementAsEquality(statementNode, assignments, derived, l
 export function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsTypeAssertion = false;
 
-  const statementTypeAssertion = isStatementTypeAssertion(statementNode);
+  const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
-  if (statementTypeAssertion) {
+  if (typeAssertionNode !== null) {
     const statementString = localContext.nodeAsString(statementNode);
 
     localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
 
-    const typeAssertionNode = typeAssertionNodeQuery(statementNode),
-          typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
 
@@ -128,21 +130,154 @@ export function verifyStatementAsTypeAssertion(statementNode, assignments, deriv
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAgainstCombinators = false;
+function verifyStatementAsJudgement(statementNode, assignments, derived, 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, derived, localContext);
+
+    statementVerifiedAsJudgement = judgementVerified;  ///
+
+    if (statementVerifiedAsJudgement) {
+      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsJudgement;
+}
+
+function verifyStatementAsMetavariable(statementNode, assignments, derived, 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 metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+
+    if (metavariable !== null) {
+      const metaTypeName  = metavariable.getMetaTypeName();
+
+      if (metaTypeName === STATEMENT_META_TYPE_NAME) {
+        statementVerifiedAsMetavariable = true;
+      }
+    }
+
+    if (statementVerifiedAsMetavariable) {
+      localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsMetavariable;
+}
+
+function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, 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, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
+
+    if (statementVerifiedAsDefinedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsDefinedAssertion;
+}
+
+function verifyStatementAsSubproofAssertion(statementNode, assignments, derived, 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, derived, localContext, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    statementVerifiedAsSubproofAssertion = subproofAssertionVerified; ///
+
+    if (statementVerifiedAsSubproofAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsSubproofAssertion;
+}
+
+function verifyStatementAsContainedAssertion(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAsContainedAssertion = false;
+
+  const containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if (containedAssertionNode !== null) {
+    const statementString = localContext.nodeAsString(statementNode);
+
+    localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
+
+    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext, () => {
+      const verifiedAhead = true;
 
-  const statementEquality = isStatementEquality(statementNode),
-        statementTypeAssertion = isStatementTypeAssertion(statementNode),
-        statementDefinedAssertion = isStatementDefinedAssertion(statementNode),
-        statementContainedAssertion = isStatementContainedAssertion(statementNode);
+      return verifiedAhead;
+    });
 
-  if (!statementEquality && !statementTypeAssertion && !statementDefinedAssertion && !statementContainedAssertion) {
-    let combinators = localContext.getCombinators();
+    statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
 
-    combinators = [ ///
-      bracketedCombinator,
-      ...combinators
-    ];
+    if (statementVerifiedAsContainedAssertion) {
+      localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsContainedAssertion;
+}
+
+function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
+  let statementVerifiedAgainstCombinators = false;
+
+  const equalityNode = equalityNodeQuery(statementNode),
+        judgementNode = judgementNodeQuery(statementNode),
+        metavariableNode = metavariableNodeQuery(statementNode),
+        typeAssertionNode = typeAssertionNodeQuery(statementNode),
+        definedAssertionNode = definedAssertionNodeQuery(statementNode),
+        subproofAssertionNode = subproofAssertionNodeQuery(statementNode),
+        containedAssertionNode = containedAssertionNodeQuery(statementNode);
+
+  if (  (equalityNode === null) &&
+        (judgementNode === null) &&
+        (metavariableNode === null) &&
+        (typeAssertionNode === null) &&
+        (definedAssertionNode === null) &&
+        (subproofAssertionNode === null) &&
+        (containedAssertionNode === null) ) {
+
+    const combinators = localContext.getCombinators();
 
     statementVerifiedAgainstCombinators = combinators.some((combinator) => {
       const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, localContext);
@@ -180,18 +315,4 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
   }
 
   return statementVerifiedAgainstCombinator;
-}
-
-function isStatementEquality(statementNode) {
-  const equalityNode = equalityNodeQuery(statementNode),
-        statementEquality = (equalityNode !== null);
-
-  return statementEquality;
-}
-
-function isStatementTypeAssertion(statementNode) {
-  const typeAssertionNode = typeAssertionNodeQuery(statementNode),
-        statementTypeAssertion = (typeAssertionNode !== null);
-
-  return statementTypeAssertion;
-}
+}

package/src/verify/subDerivation.js

@@ -4,14 +4,14 @@ import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
 
-export default function verifySubDerivation(subDerivationNode, localContext) {
+export default function verifySubDerivation(subDerivationNode, substitutions, localContext) {
   let subDerivationVerified;
 
   const proofStepNodes = proofStepNodesQuery(subDerivationNode);
 
   subDerivationVerified = proofStepNodes.every((proofStepNode) => {
     const { verifyProofStep } = verifySubDerivation,
-          proofStepVerified = verifyProofStep(proofStepNode, localContext);
+          proofStepVerified = verifyProofStep(proofStepNode, substitutions, localContext);
 
     if (proofStepVerified) {
       return true;

package/src/verify/subproof.js

@@ -9,7 +9,7 @@ import { nodeQuery, nodesQuery } from "../utilities/query";
 const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
-export default function verifySubproof(subproofNode, localContext) {
+export default function verifySubproof(subproofNode, substitutions, localContext) {
   let subproofVerified = false;
 
   localContext = LocalContext.fromLocalContext(localContext);  ///
@@ -20,7 +20,7 @@ export default function verifySubproof(subproofNode, localContext) {
 
   if (suppositionsVerified) {
     const subDerivationNode = subDerivationNodeQuery(subproofNode),
-          subDerivationVerified = verifySubDerivation(subDerivationNode, localContext);
+          subDerivationVerified = verifySubDerivation(subDerivationNode, substitutions, localContext);
 
     if (subDerivationVerified) {
       subproofVerified = true;

package/src/verify/termAsConstructor.js

@@ -11,9 +11,9 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
 
   fileContext.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
 
-  const nonTerminalNode = termNode, ///
+  const localContext = LocalContext.fromFileContext(fileContext),
+        nonTerminalNode = termNode, ///
         childNodes = nonTerminalNode.getChildNodes(),
-        localContext = LocalContext.fromFileContext(fileContext),
         childNodesVerified = termAsConstructorNodeVerifier.verifyChildNodes(childNodes, localContext, () => {
           const verifiedAhead = true;
 

package/src/verify/theorem.js

@@ -27,9 +27,9 @@ export default function verifyTheorem(theoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositionNodes = suppositionsNodeQuery(theoremNode),
+    const localContext = LocalContext.fromFileContext(fileContext),
           suppositions = [],
-          localContext = LocalContext.fromFileContext(fileContext),
+          suppositionNodes = suppositionsNodeQuery(theoremNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
@@ -41,10 +41,13 @@ export default function verifyTheorem(theoremNode, fileContext) {
         const proofNode = proofNodeQuery(theoremNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, localContext);
+              statementNode = consequent.getStatementNode(),
+              substitutions = [],
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const theorem = Theorem.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+          const substitutions = [],
+                theorem = Theorem.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addTheorem(theorem);