occam-verify-cli 0.0.923 → 0.0.925

package/src/verify/assertion/subproof.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import { nodesQuery } from "../../utilities/query";
+import { STATEMENT_META_TYPE_NAME } from "../../metaTypeNames";
+
+const metavariableNodesQuery = nodesQuery("/subproofAssertion/statement/metavariable!");
+
+export default function verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+  let subproofAssertionVerified;
+
+  const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
+
+  localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`, subproofAssertionNode);
+
+  const verifySubproofAssertionFunctions = [
+    verifyDerivedSubproofAssertion,
+    verifyStatedSubproofAssertion
+  ];
+
+  subproofAssertionVerified = verifySubproofAssertionFunctions.some((verifySubproofAssertionFunction) => {
+    const subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, derived, localContext);
+
+    if (subproofAssertionVerified) {
+      return true;
+    }
+  });
+
+  if (subproofAssertionVerified) {
+    localContext.debug(`...verified the '${subproofAssertionString}' subproof assertion.`, subproofAssertionNode);
+  }
+
+  return subproofAssertionVerified;
+}
+
+function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+  let derivedSubproofAssertionVerified = false;
+
+  if (derived) {
+    const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
+
+    if (derivedSubproofAssertionVerified) {
+      localContext.debug(`The '${subproofAssertionString}' derived subproof assertion cannot be verified.`, subproofAssertionNode);
+    }
+  }
+
+  return derivedSubproofAssertionVerified;
+}
+
+function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+  let statedSubproofAssertionVerified = false;
+
+  if (!derived) {
+    const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
+
+    localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`, subproofAssertionNode);
+
+    const metavariableNodes = metavariableNodesQuery(subproofAssertionNode);
+
+    statedSubproofAssertionVerified = metavariableNodes.every((metavariableNode) => {
+      const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+
+      if (metavariable !== null) {
+        const metaTypeName = metavariable.getMetaTypeName();
+
+        if (metaTypeName === STATEMENT_META_TYPE_NAME) {
+          return true;
+        }
+      }
+    });
+
+    if (statedSubproofAssertionVerified) {
+      localContext.debug(`...verified the '${subproofAssertionString}' stated subproof assertion.`, subproofAssertionNode);
+    }
+  }
+
+  return statedSubproofAssertionVerified;
+}

package/src/verify/{typeAssertion.js → assertion/type.js}

@@ -1,17 +1,17 @@
 "use strict";
 
-import Variable from "../variable";
-import verifyTerm from "../verify/term";
-import VariableAssignment from "../assignment/variable";
+import Variable from "../../variable";
+import verifyTerm from "../../verify/term";
+import VariableAssignment from "../../assignment/variable";
 
-import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
+import { first } from "../../utilities/array";
+import { nodeQuery } from "../../utilities/query";
 
 const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!"),
       variableNodeQuery = nodeQuery("/term/variable!");
 
-export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead) {
+export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
   let typeAssertionVerified;
 
   const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
@@ -24,7 +24,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
   ];
 
   typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
-    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, localContext, verifyAhead);
+    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, localContext);
 
     if (typeAssertionVerified) {
       return true;
@@ -38,7 +38,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
   return typeAssertionVerified;
 }
 
-function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead) {
+function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
   let derivedTypeAssertionVerified = false;
 
   if (derived) {
@@ -64,7 +64,7 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
                 const variableNode = variableNodeQuery(termNode);
 
                 if (variableNode === null) {
-                  verifiedAhead = verifyAhead();
+                  verifiedAhead = true;
                 } else {
                   let variable = localContext.findVariableByVariableNode(variableNode);
 
@@ -75,7 +75,7 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
 
                   assignments.push(assignment);
 
-                  verifiedAhead = verifyAhead();
+                  verifiedAhead = true;
 
                   if (!verifiedAhead) {
                     assignments.pop();
@@ -90,14 +90,14 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
     derivedTypeAssertionVerified = termVerified; ///
 
     if (derivedTypeAssertionVerified) {
-      localContext.trace(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);
+      localContext.debug(`...verified the '${typeAssertionString}' derived type assertion.`, typeAssertionNode);
     }
   }
 
   return derivedTypeAssertionVerified;
 }
 
-function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead) {
+function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
   let statedTypeAssertionVerified = false;
 
   if (!derived) {
@@ -123,7 +123,7 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
                 const variableNode = variableNodeQuery(termNode);
 
                 if (variableNode === null) {
-                  verifiedAhead = verifyAhead();
+                  verifiedAhead = true;
                 } else {
                   let variable = localContext.findVariableByVariableNode(variableNode);
 
@@ -134,7 +134,7 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
 
                   assignments.push(assignment);
 
-                  verifiedAhead = verifyAhead();
+                  verifiedAhead = true;
 
                   if (!verifiedAhead) {
                     assignments.pop();
@@ -149,7 +149,7 @@ function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, loca
     statedTypeAssertionVerified = termVerified; ///
 
     if (statedTypeAssertionVerified) {
-      localContext.trace(`...verified the '${typeAssertionString}' stated type assertion.`, typeAssertionNode);
+      localContext.debug(`...verified the '${typeAssertionString}' stated type assertion.`, typeAssertionNode);
     }
   }
 

package/src/verify/axiom.js

@@ -17,8 +17,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
   const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
@@ -26,7 +25,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
           suppositionNodes = suppositionsNodeQuery(axiomNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
@@ -38,7 +38,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
       if (consequentVerified) {
         const firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              axiom = Axiom.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+              substitutions = [],
+              axiom = Axiom.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addAxiom(axiom);
 

package/src/verify/conjecture.js

@@ -19,8 +19,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
   const labelNodes = labelNodesQuery(conjectureNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);  ///
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 
@@ -28,7 +27,8 @@ export default function verifyConjecture(conjectureNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
           suppositionNodes = suppositionsNodeQuery(conjectureNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
@@ -46,7 +46,8 @@ export default function verifyConjecture(conjectureNode, fileContext) {
           verifyProof(proofNode, consequent, localContext);
         }
 
-        const conjecture = Conjecture.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+        const substitutions = [],
+              conjecture = Conjecture.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addConjecture(conjecture);
 

package/src/verify/declaration.js

@@ -26,11 +26,7 @@ export default function verifyDeclaration(declarationNode, declarations, localCo
     const { verifyStatement } = metaLevelNodeVerifier,
           derived = false,
           assignments = [],
-          statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
+          statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {
       const metavariableNode = metavariableNodeQuery(referenceNode),
@@ -57,7 +53,7 @@ function verifyReference(referenceNode, localContext) {
   localContext.trace(`Verifying the '${referenceString}' reference...`, referenceNode);
 
   const metavariableNode = metavariableNodeQuery(referenceNode),
-        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+        metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/derivation.js

@@ -6,18 +6,18 @@ import { nodesQuery } from "../utilities/query";
 
 const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
 
-export default function verifyDerivation(ruleDerivationNode, localContext) {
-  let ruleDerivationVerified;
+export default function verifyDerivation(derivationNode, substitutions, localContext) {
+  let derivationVerified;
 
-  const proofStepNodes = proofStepNodesQuery(ruleDerivationNode);
+  const proofStepNodes = proofStepNodesQuery(derivationNode);
 
-  ruleDerivationVerified = proofStepNodes.every((proofStepNode) => {
-    const proofStepVerified = verifyProofStep(proofStepNode, localContext);
+  derivationVerified = proofStepNodes.every((proofStepNode) => {
+    const proofStepVerified = verifyProofStep(proofStepNode, substitutions, localContext);
 
     if (proofStepVerified) {
       return true;
     }
   });
 
-  return ruleDerivationVerified;
+  return derivationVerified;
 }

package/src/verify/equality.js

@@ -84,7 +84,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext,
     derivedEqualityVerified = termsVerified; ///
 
     if (derivedEqualityVerified) {
-      localContext.trace(`...verified the '${equalityString}' derived equality.`, equalityNode);
+      localContext.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);
     }
   }
 
@@ -134,7 +134,7 @@ function verifyStatedEquality(equalityNode, assignments, derived, localContext,
     statedEqualityVerified = termsVerified; ///
 
     if (statedEqualityVerified) {
-      localContext.trace(`...verified the '${equalityString}' stated equality.`, equalityNode);
+      localContext.debug(`...verified the '${equalityString}' stated equality.`, equalityNode);
     }
   }
 

package/src/verify/frame.js

@@ -56,7 +56,7 @@ function verifyMetavariable(metavariableNode, declarations, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/judgement.js

@@ -144,7 +144,7 @@ function verifyMetavariable(metavariableNode, localContext) {
 
   localContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
 
   if (metavariable !== null) {
     const metaType = metavariable.getMetaType();

package/src/verify/lemma.js

@@ -20,8 +20,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
   const labelNodes = labelNodesQuery(lemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = LocalContext.fromFileContext(fileContext);
+        labelsString = fileContext.nodesAsString(labelNodes);
 
   (labelsString === EMPTY_STRING) ?
     fileContext.trace(`Verifying a lemma...`, lemmaNode) :
@@ -31,7 +30,8 @@ export default function verifyLemma(lemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const suppositions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
+          suppositions = [],
           suppositionNodes = suppositionsNodeQuery(lemmaNode),
           suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
@@ -44,10 +44,13 @@ export default function verifyLemma(lemmaNode, fileContext) {
         const proofNode = proofNodeQuery(lemmaNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              proofVerified = verifyProof(proofNode, consequent, localContext);
+              statementNode = consequent.getStatementNode(),
+              substitutions = [],
+              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const lemma = Lemma.fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext);
+          const substitutions = [],
+                lemma = Lemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addLemma(lemma);
 

package/src/verify/metaLemma.js

@@ -30,22 +30,22 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext), ///
-          substitutions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
           suppositions = [],
           suppositionNodes = suppositionsNodeQuery(metaLemmaNode),
-          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, substitutions, localContext);
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],
             consequentNode = consequentNodeQuery(metaLemmaNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, substitutions, localContext);
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
       if (consequentVerified) {
         const proofNode = proofNodeQuery(metaLemmaNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
+              substitutions = [],
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {

package/src/verify/metastatement.js

@@ -1,9 +1,6 @@
 "use strict";
 
-import verifyJudgement from "../verify/judgement";
 import metaLevelNodeVerifier from "../verifier/node/metaLevel";
-import verifyStatementAsDefinedAssertion from "./statementAsDefinedAssertion";
-import verifyStatementAsContainedAssertion from "./statementAsContainedAssertion";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -17,9 +14,6 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
   const verifyStatementFunctions = [
-    verifyStatementAsJudgement,
-    verifyStatementAsDefinedAssertion,
-    verifyStatementAsContainedAssertion,
     verifyStatementAsIs
   ];
 
@@ -44,29 +38,6 @@ Object.assign(metaLevelNodeVerifier, {
 
 export default verifyStatement;
 
-function verifyStatementAsJudgement(statementNode, assignments, derived, localContext) {
-  let statementVerifiedAsJudgement = false;
-
-  const statementJudgement = isStatementJudgement(statementNode);
-
-  if (statementJudgement) {
-    const statementString = localContext.nodeAsString(statementNode);
-
-    localContext.trace(`Verifying the '${statementString}' statement as a judgement...`, statementNode);
-
-    const judgementNode = judgementNodeQuery(statementNode),
-          judgementVerified = verifyJudgement(judgementNode, assignments, derived, localContext);
-
-    statementVerifiedAsJudgement = judgementVerified;  ///
-
-    if (statementVerifiedAsJudgement) {
-      localContext.debug(`...verified the '${statementString}' statement as a judgement.`, statementNode);
-    }
-  }
-
-  return statementVerifiedAsJudgement;
-}
-
 function verifyStatementAsIs(statementNode, assignments, derived, localContext) {
   let statementVerifiedAsIs;
 
@@ -104,7 +75,7 @@ function verifyDerivedStatementAsIs(statementNode, assignments, derived, localCo
   if (derived) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.debug(`Cannot verify the derived '${statementString}' statement as is.`, statementNode);
+    localContext.debug(`Cannot verify the '${statementString}' derived statement as is.`, statementNode);
   }
 
   return derivedStatementVerifiedAsIs;
@@ -116,7 +87,7 @@ function verifyStatedStatementAsIs(statementNode, assignments, derived, localCon
   if (!derived) {
     const statementString = localContext.nodeAsString(statementNode);
 
-    localContext.trace(`Verifying the stated '${statementString}' statement as is...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' stated statement as is...`, statementNode);
 
     const nonTerminalNode = statementNode, ///
           nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
@@ -128,7 +99,7 @@ function verifyStatedStatementAsIs(statementNode, assignments, derived, localCon
     statedStatementVerifiedAsIs = nonTerminalNodeVerified;  ///
 
     if (statedStatementVerifiedAsIs) {
-      localContext.debug(`...verified the stated '${statementString}' statement as is.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' stated statement as is.`, statementNode);
     }
   }
 

package/src/verify/metatheorem.js

@@ -27,21 +27,21 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext), ///
-          substitutions = [],
+    const localContext = LocalContext.fromFileContext(fileContext),
           suppositions = [],
           suppositionNodes = suppositionsNodeQuery(metatheoremNode),
-          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, substitutions, localContext);
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],
             consequentNode = consequentNodeQuery(metatheoremNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, substitutions, localContext);
+            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
 
       if (consequentVerified) {
         const proofNode = proofNodeQuery(metatheoremNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
+              substitutions = [],
               statementNode = consequent.getStatementNode(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 

package/src/verify/metavariable.js

@@ -73,7 +73,7 @@ export function verifyStandaloneMetavariable(metavariableNode, localContext, ver
 
   localContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
+  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();

package/src/verify/proof.js

@@ -7,13 +7,13 @@ import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!");
 
-export default function verifyProof(proofNode, conclusion, localContext) {
+export default function verifyProof(proofNode, conclusion, substitutions, localContext) {
   let proofVerified = false;
 
   localContext = LocalContext.fromLocalContext(localContext); ///
 
   const derivationNode = derivationNodeQuery(proofNode),
-        derivationVerified = verifyDerivation(derivationNode, localContext);
+        derivationVerified = verifyDerivation(derivationNode, substitutions, localContext);
 
   if (derivationVerified) {
     const lastProofStep = localContext.getLastProofStep();

package/src/verify/proofStep.js

@@ -14,7 +14,7 @@ const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement!");
 
-export default function verifyProofStep(proofStepNode, localContext) {
+export default function verifyProofStep(proofStepNode, substitutions, localContext) {
   let proofStepVerified = false;
 
   const subproofNode = subproofNodeQuery(proofStepNode),
@@ -26,7 +26,7 @@ export default function verifyProofStep(proofStepNode, localContext) {
   } else if (subproofNode !== null) {
     let subproofVerified;
 
-    subproofVerified = verifySubproof(subproofNode, localContext);
+    subproofVerified = verifySubproof(subproofNode, substitutions, localContext);
 
     if (subproofVerified) {
       const proofStep = ProofStep.fromSubproofNode(subproofNode);
@@ -40,7 +40,7 @@ export default function verifyProofStep(proofStepNode, localContext) {
 
     const assignments = [];
 
-    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
+    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, substitutions, assignments, localContext);
 
     if (qualifiedStatementVerified) {
       const assignmentAssigned = assignAssignment(assignments, localContext);

package/src/verify/rule.js

@@ -10,9 +10,9 @@ import verifyConclusion from "../verify/conclusion";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/rule/label"),
+const proofNodeQuery = nodeQuery("/rule/proof!"),
+      labelNodesQuery = nodesQuery("/rule/label"),
       premisesNodeQuery = nodesQuery("/rule/premise"),
-      proofNodeQuery = nodeQuery("/rule/proof!"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion!");
 
 export default function verifyRule(ruleNode, fileContext) {
@@ -27,8 +27,8 @@ export default function verifyRule(ruleNode, fileContext) {
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
 
   if (labelsVerified) {
-    const premises = [],
-          localContext = LocalContext.fromFileContext(fileContext),
+    const localContext = LocalContext.fromFileContext(fileContext),
+          premises = [],
           premiseNodes = premisesNodeQuery(ruleNode),
           premisesVerified = verifyPremises(premiseNodes, premises, localContext);