occam-verify-cli 1.0.230 → 1.0.234

package/src/dom/statement.js

@@ -2,7 +2,6 @@
 
 import { arrayUtilities } from "necessary";
 
-import LocalContext from "../context/local";
 import verifyMixins from "../mixins/statement/verify";
 import StatementPartialContext from "../context/partial/statement";
 
@@ -250,10 +249,10 @@ export default domAssigned(class Statement {
 
   static name = "Statement";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           statementPartialContext = StatementPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = statementPartialContext.getNode(),
           tokens = statementPartialContext.getTokens(),
@@ -262,27 +261,24 @@ export default domAssigned(class Statement {
     return statement;
   }
 
-  static fromStepNode(stepNode, fileContext) {
+  static fromStepNode(stepNode, context) {
     let statement = null;
 
     const statementNode = stepNode.getStatementNode();
 
     if (statementNode !== null) {
-      statement = statementFromStatementNode(statementNode, fileContext);
+      statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromPremiseNode(premiseNode, fileContext) {
+  static fromPremiseNode(premiseNode, context) {
     let statement = null;
 
     const statementNode = premiseNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
@@ -295,84 +291,80 @@ export default domAssigned(class Statement {
     return statement;
   }
 
-  static fromDeductionNode(deductionNode, fileContext) {
+  static fromDeductionNode(deductionNode, context) {
     let statement = null;
 
     const statementNode = deductionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
+      statement = statementFromStatementNode(statementNode, context);
+    }
+
+    return statement;
+  }
+
+  static fromHypothesisNode(hypothesisNode, context) {
+    let statement = null;
+
+    const statementNode = hypothesisNode.getStatementNode();
 
+    if (statementNode !== null) {
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromConclusionNode(conclusionNode, fileContext) {
+  static fromConclusionNode(conclusionNode, context) {
     let statement = null;
 
     const statementNode = conclusionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromSuppositionNode(suppositionNode, fileContext) {
+  static fromSuppositionNode(suppositionNode, context) {
     let statement = null;
 
     const statementNode = suppositionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromDeclarationNode(declarationNode, fileContext) {
+  static fromDeclarationNode(declarationNode, context) {
     let statementNode;
 
     statementNode = declarationNode.getStatementNode(); ///
 
     statementNode = stripBracketsFromStatementNode(statementNode);  ///
 
-    const localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
-          statement = statementFromStatementNode(statementNode, context);
+    const statement = statementFromStatementNode(statementNode, context);
 
     return statement;
   }
 
-  static fromContainedAssertionNode(containedAssertionNode, fileContext) {
+  static fromContainedAssertionNode(containedAssertionNode, context) {
     let statement = null;
 
     const statementNode = containedAssertionNode.getStatementNode();
 
     if (statementNode !== null) {
-      const localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
-
       statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
   }
 
-  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, context) {
     const statementNode = combinatorDeclarationNode.getStatementNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
           statement = statementFromStatementNode(statementNode, context);
 
     return statement;

package/src/dom/step.js

@@ -164,7 +164,7 @@ export default domAssigned(class Step {
     return step;
   }
 
-  static fromStepOrSubproofNode(stepOrSubproofNode, fileContext) {
+  static fromStepOrSubproofNode(stepOrSubproofNode, context) {
     let step = null;
 
     const stepNode = stepOrSubproofNode.isStepNode();
@@ -173,9 +173,9 @@ export default domAssigned(class Step {
       const { Statement, Reference } = dom,
             stepNode = stepOrSubproofNode,  ///
             node = stepNode, ///
-            string = fileContext.nodeAsString(node),
-            statement = Statement.fromStepNode(stepNode, fileContext),
-            reference = Reference.fromStepNode(stepNode, fileContext);
+            string = context.nodeAsString(node),
+            statement = Statement.fromStepNode(stepNode, context),
+            reference = Reference.fromStepNode(stepNode, context);
 
       step = new Step(string, statement, reference);
     }

package/src/dom/subDerivation.js

@@ -52,20 +52,20 @@ export default domAssigned(class SubDerivation {
 
   static name = "SubDerivation";
 
-  static fromSubDerivationNode(subDerivationNode, fileContext) {
-    const stepsOrSubproofs = stepOrSubproofFromSubDerivationNode(subDerivationNode, fileContext),
+  static fromSubDerivationNode(subDerivationNode, context) {
+    const stepsOrSubproofs = stepOrSubproofFromSubDerivationNode(subDerivationNode, context),
           subDerivation = new SubDerivation(stepsOrSubproofs);
 
     return subDerivation;
   }
 });
 
-function stepOrSubproofFromSubDerivationNode(subDerivationNode, fileContext) {
+function stepOrSubproofFromSubDerivationNode(subDerivationNode, context) {
   const { Step, Subproof } = dom,
         stepOrSubproofNodes = subDerivationNode.getStepOrSubproofNodes(),
         stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
-          const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
-                step = Step.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
+          const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, context),
+                step = Step.fromStepOrSubproofNode(stepOrSubproofNode, context),
                 stepOrSubproof = (step || subproof);
 
           return stepOrSubproof;

package/src/dom/subproof.js

@@ -134,16 +134,16 @@ export default domAssigned(class Subproof {
 
   static name = "Subproof";
 
-  static fromStepOrSubproofNode(sStepOrSubproofNode, fileContext) {
+  static fromStepOrSubproofNode(sStepOrSubproofNode, context) {
     let subproof = null;
 
     const subproofNode = sStepOrSubproofNode.isSubproofNode();
 
     if (subproofNode) {
       const subproofNode = sStepOrSubproofNode, ///
-            suppositions = suppositionsFromSubproofNode(subproofNode, fileContext),
-            subDerivation = subDerivationFromSubproofNode(subproofNode, fileContext),
-            subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+            suppositions = suppositionsFromSubproofNode(subproofNode, context),
+            subDerivation = subDerivationFromSubproofNode(subproofNode, context),
+            subproofString = subproofStringFromSubproofNode(subproofNode, context),
             string = subproofString;  ///
 
       subproof = new Subproof(string, suppositions, subDerivation);
@@ -153,11 +153,11 @@ export default domAssigned(class Subproof {
   }
 });
 
-function suppositionsFromSubproofNode(subproofNode, fileContext) {
+function suppositionsFromSubproofNode(subproofNode, context) {
   const { Supposition } = dom,
         suppositionNodes = subproofNode.getSuppositionNodes(),
         suppositions = suppositionNodes.map((suppositionNode) => {
-          const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+          const supposition = Supposition.fromSuppositionNode(suppositionNode, context);
 
           return supposition;
         });
@@ -165,10 +165,10 @@ function suppositionsFromSubproofNode(subproofNode, fileContext) {
   return suppositions;
 }
 
-function subDerivationFromSubproofNode(subproofNode, fileContext) {
+function subDerivationFromSubproofNode(subproofNode, context) {
   const { SubDerivation } = dom,
         subDerivationNode = subproofNode.getSubDerivationNode(),
-        subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, fileContext);
+        subDerivation = SubDerivation.fromSubDerivationNode(subDerivationNode, context);
 
   return subDerivation;
 }

package/src/dom/substitution/statement.js

@@ -171,16 +171,16 @@ export default domAssigned(class StatementSubstitution extends Substitution {
     return json;
   }
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           statementSubstitutionPartialContext = StatementSubstitutionPartialContext.fromStringLexerAndParser(string, lexer, parser),
           node = statementSubstitutionPartialContext.getNode(),
           tokens = statementSubstitutionPartialContext.getTokens(),
           resolved = true,
-          statement = statementFromJSON(json, fileContext),
-          metavariable = metavariableFromJSON(json, fileContext),
+          statement = statementFromJSON(json, context),
+          metavariable = metavariableFromJSON(json, context),
           substitution = null,  ///
           statementSubstitution = new StatementSubstitution(string, node, tokens, resolved, statement, metavariable, substitution);
 

package/src/dom/supposition.js

@@ -220,9 +220,9 @@ export default domAssigned(class Supposition {
 
   static name = "Supposition";
 
-  static fromJSON(json, fileContext) {
-    const statement = statementFromJSON(json, fileContext),
-          procedureCall = procedureCallFromJSON(json, fileContext);
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
+          procedureCall = procedureCallFromJSON(json, context);
 
     let string;
 
@@ -239,12 +239,12 @@ export default domAssigned(class Supposition {
     return supposition;
   }
 
-  static fromSuppositionNode(suppositionNode, fileContext) {
+  static fromSuppositionNode(suppositionNode, context) {
     const { Statement, ProcedureCall } = dom,
           node = suppositionNode, ///
-          string = fileContext.nodeAsString(node),
-          statement = Statement.fromSuppositionNode(suppositionNode, fileContext),
-          procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, fileContext),
+          string = context.nodeAsString(node),
+          statement = Statement.fromSuppositionNode(suppositionNode, context),
+          procedureCall = ProcedureCall.fromSuppositionNode(suppositionNode, context),
           supposition = new Supposition(string, statement, procedureCall);
 
     return supposition

package/src/dom/term.js

@@ -3,7 +3,6 @@
 import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 import verifyMixins from "../mixins/term/verify";
 
 import { domAssigned } from "../dom";
@@ -188,14 +187,12 @@ export default domAssigned(class Term {
 
   static name = "Term";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext,  ///
           termString = string,  ///
           termNode = termNodeFromTermString(termString, context),
           node = termNode,  ///
-          type = typeFromJSON(json, fileContext),
+          type = typeFromJSON(json, context),
           term = new Term(string, node, type);
 
     return term;
@@ -265,11 +262,9 @@ export default domAssigned(class Term {
     return term;
   }
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
     const { Type } = dom,
           termNode = constructorDeclarationNode.getTermNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
           term = termFromTermNode(termNode, context),
           type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
 

package/src/dom/theorem.js

@@ -8,19 +8,19 @@ export default domAssigned(class Theorem extends TopLevelAssertion {
   verify() {
     let verifies;
 
-    const fileContext = this.getFileContext(),
+    const context = this.getContext(),
           theoremString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${theoremString}' theorem...`);
+    context.trace(`Verifying the '${theoremString}' theorem...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const theorem = this; ///
 
-      fileContext.addTheorem(theorem);
+      context.addTheorem(theorem);
 
-      fileContext.debug(`...verified the '${theoremString}' theorem.`);
+      context.debug(`...verified the '${theoremString}' theorem.`);
     }
 
     return verifies;
@@ -28,11 +28,11 @@ export default domAssigned(class Theorem extends TopLevelAssertion {
 
   static name = "Theorem";
 
-  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelAssertion.fromJSON(Theorem, json, context); }
 
-  static fromTheoremNode(theoremNode, fileContext) {
+  static fromTheoremNode(theoremNode, context) {
     const node = theoremNode, ///
-          theorem = TopLevelAssertion.fromNode(Theorem, node, fileContext);
+          theorem = TopLevelAssertion.fromNode(Theorem, node, context);
 
     return theorem;
   }

package/src/dom/topLevelAssertion.js

@@ -10,26 +10,29 @@ import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
          labelsToLabelsJSON,
+         hypothesesFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
          signatureToSignatureJSON,
+         hypothesesToHypothesesJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
-const { reverse, extract, backwardsEvery } = arrayUtilities;
+const { extract, reverse, correlate, backwardsEvery } = arrayUtilities;
 
 export default class TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof, signature) {
-    this.fileContext = fileContext;
+  constructor(context, string, labels, suppositions, deduction, proof, signature, hypotheses) {
+    this.context = context;
     this.string = string;
     this.labels = labels;
     this.suppositions = suppositions;
     this.deduction = deduction;
     this.proof = proof;
     this.signature = signature;
+    this.hypotheses = hypotheses;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -56,8 +59,35 @@ export default class TopLevelAssertion {
     return this.signature;
   }
 
+  getHypotheses() {
+    return this.hypotheses;
+  }
+
+  setContext(context) { this.context = context; }
+
+  setString(string) { this.string = string; }
+
+  setLabels(labels) { this.labels = labels; }
+
+  setSuppositions(suppositions) { this.suppositions = suppositions; }
+
+  setDeduction(deduction) { this.deduction = deduction; }
+
+  setProof(proof) { this.proof = proof; }
+
+  setSignature(signature) { this.signature = signature; }
+
+  setHypotheses(hypotheses) { this.hypotheses = hypotheses; }
+
   getStatement() { return this.deduction.getStatement(); }
 
+  isHypothetical() {
+    const hypothesesLength = this.hypotheses.length,
+          hypothetical = (hypothesesLength > 0);
+
+    return hypothetical;
+  }
+
   isUnconditional() {
     const suppositionsLength = this.suppositions.length,
           unconditional = (suppositionsLength === 0);
@@ -89,7 +119,7 @@ export default class TopLevelAssertion {
     const labelsVerify = this.verifyLabels();
 
     if (labelsVerify) {
-      const localContext = LocalContext.fromFileContext(this.fileContext),
+      const localContext = LocalContext.fromContext(this.context),
             context = localContext, ///
             suppositionsVerify = this.verifySuppositions(context);
 
@@ -160,6 +190,36 @@ export default class TopLevelAssertion {
     return proofVerifies;
   }
 
+  correlateHypotheses(context) {
+    let hypothesesCorrelate;
+
+    const hypothetical = this.isHypothetical();
+
+    if (hypothetical) {
+      const steps = context.getSteps(),
+            topLevelAssertionString = this.string;  ///
+
+      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`);
+
+      hypothesesCorrelate = correlate(this.hypotheses, steps, (hypothesis, step) => {
+        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
+
+        if (hypothesesEqualToStep) {
+          return true;
+        }
+      });
+
+      if (hypothesesCorrelate) {
+        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`);
+      }
+    } else {
+      hypothesesCorrelate = true
+    }
+
+
+    return hypothesesCorrelate;
+  }
+
   unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext) {
     let statementUnifiesWithDeduction = false;
 
@@ -175,21 +235,29 @@ export default class TopLevelAssertion {
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
     let statementAndStepsOrSubproofsUnify = false;
 
-    const localContext = LocalContext.fromFileContext(this.fileContext),
-          generalContext = localContext, ///
-          specificContext = context, ///
-          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+    const hypothetical = this.isHypothetical();
 
-    if (statementUnifiesWithDeduction) {
-      const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
+    if (!hypothetical) {
+      const generalContext = this.context, ///
+            specificContext = context, ///
+            statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifyWithSuppositions) {
-        const substitutionsResolved = substitutions.areResolved();
+      if (statementUnifiesWithDeduction) {
+        const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
 
-        if (substitutionsResolved) {
-          statementAndStepsOrSubproofsUnify = true;
+        if (stepsOrSubproofsUnifyWithSuppositions) {
+          const substitutionsResolved = substitutions.areResolved();
+
+          if (substitutionsResolved) {
+            statementAndStepsOrSubproofsUnify = true;
+          }
         }
       }
+    } else {
+      const statementString = statement.getString(),
+            topLevelAssertionString = this.string;  ///
+
+      context.trace(`Cannot unify the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture with the '${statementString}' and steps or subproofs because it is hypothetical.`);
     }
 
     return statementAndStepsOrSubproofsUnify;
@@ -239,62 +307,67 @@ export default class TopLevelAssertion {
           deductionJSON = deductionToDeductionJSON(this.deduction),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
           signatureJSON = signatureToSignatureJSON(this.signature),
+          hypothesesJSON = hypothesesToHypothesesJSON(this.signature),
           labels = labelsJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
-          signature = signatureJSON,
+          signature = signatureJSON,  ///
+          hypotheses = hypothesesJSON,  ///
           json = {
             labels,
             deduction,
             suppositions,
             signature,
+            hypotheses
           };
 
     return json;
   }
 
-  static fromJSON(Class, json, fileContext) {
-    const labels = labelsFromJSON(json, fileContext),
-          deduction = deductionFromJSON(json, fileContext),
-          suppositions = suppositionsFromJSON(json, fileContext),
-          signature = signatureFromJSON(json, fileContext),
+  static fromJSON(Class, json, context) {
+    const labels = labelsFromJSON(json, context),
+          deduction = deductionFromJSON(json, context),
+          suppositions = suppositionsFromJSON(json, context),
+          signature = signatureFromJSON(json, context),
+          hypotheses = hypothesesFromJSON(json, context),
           proof = null,
           string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
+          topLevelAssertion = new Class(context, string, labels, suppositions, deduction, proof, signature, hypotheses);
 
     return topLevelAssertion;
   }
 
-  static fromNode(Class, node, fileContext) {
+  static fromNode(Class, node, context) {
     const topLevelAssertionNode = node, ///
           proofNode = topLevelAssertionNode.getProofNode(),
           labelNodes = topLevelAssertionNode.getLabelNodes(),
           deductionNode = topLevelAssertionNode.getDeductionNode(),
           suppositionNodes = topLevelAssertionNode.getSuppositionNodes(),
           signatureNode = topLevelAssertionNode.getSignatureNode(),
-          proof = proofFromProofNode(proofNode, fileContext),
-          labels = labelsFromLabelNodes(labelNodes, fileContext),
-          deduction = deductionFromDeductionNode(deductionNode, fileContext),
-          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
-          signature = signatureFromSignatureNode(signatureNode, fileContext),
+          proof = proofFromProofNode(proofNode, context),
+          labels = labelsFromLabelNodes(labelNodes, context),
+          deduction = deductionFromDeductionNode(deductionNode, context),
+          suppositions = suppositionsFromSuppositionNodes(suppositionNodes, context),
+          signature = signatureFromSignatureNode(signatureNode, context),
+          hypotheses = [],
           string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
-          topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
+          topLevelAssertion = new Class(context, string, labels, suppositions, deduction, proof, signature, hypotheses);
 
     return topLevelAssertion;
   }
 }
 
-export function proofFromProofNode(proofNode, fileContext) {
+export function proofFromProofNode(proofNode, context) {
   const { Proof } = dom,
-        proof = Proof.fromProofNode(proofNode, fileContext);
+        proof = Proof.fromProofNode(proofNode, context);
 
   return proof;
 }
 
-export function labelsFromLabelNodes(labelNodes, fileContext) {
+export function labelsFromLabelNodes(labelNodes, context) {
   const { Label } = dom,
         labels = labelNodes.map((labelNode) => {
-          const label = Label.fromLabelNode(labelNode, fileContext);
+          const label = Label.fromLabelNode(labelNode, context);
 
           return label;
         });
@@ -302,29 +375,29 @@ export function labelsFromLabelNodes(labelNodes, fileContext) {
   return labels;
 }
 
-export function signatureFromSignatureNode(signatureNode, fileContext) {
+export function signatureFromSignatureNode(signatureNode, context) {
   let signature = null;
 
   if (signatureNode !== null) {
     const { Signature } = dom;
 
-    signature = Signature.fromSignatureNode(signatureNode, fileContext);
+    signature = Signature.fromSignatureNode(signatureNode, context);
   }
 
   return signature;
 }
 
-export function deductionFromDeductionNode(deductionNode, fileContext) {
+export function deductionFromDeductionNode(deductionNode, context) {
   const { Deduction } = dom,
-        deduction = Deduction.fromDeductionNode(deductionNode, fileContext);
+        deduction = Deduction.fromDeductionNode(deductionNode, context);
 
   return deduction;
 }
 
-export function suppositionsFromSuppositionNodes(suppositionNodes, fileContext) {
+export function suppositionsFromSuppositionNodes(suppositionNodes, context) {
   const { Supposition } = dom,
         suppositions = suppositionNodes.map((suppositionNode) => {
-          const supposition = Supposition.fromSuppositionNode(suppositionNode, fileContext);
+          const supposition = Supposition.fromSuppositionNode(suppositionNode, context);
 
           return supposition;
         });