occam-verify-cli 0.0.940 → 0.0.942

package/src/rule.js

@@ -3,6 +3,7 @@
 import Label from "./label";
 import Premise from "./premise";
 import Conclusion from "./conclusion";
+import Substitutions from "./substitutions";
 
 import { reverse, correlate } from "./utilities/array";
 
@@ -34,7 +35,7 @@ export default class Rule {
     let statementUnified = false;
 
     const proofSteps = localContext.getProofSteps(),
-          substitutions = [],
+          substitutions = Substitutions.fromNothing(),
           premisesUnified = unifyPremises(this.premises, proofSteps, substitutions, this.fileContext, localContext);
 
     if (premisesUnified) {
@@ -133,6 +134,8 @@ function matchPremise(premise, proofStep, substitutions, fileContext, localConte
   const subproofNode = proofStep.getSubproofNode(),
         statementNode = proofStep.getStatementNode();
 
+  substitutions.snapshot();
+
   if (subproofNode !== null) {
     const subproofUnified = premise.unifySubproof(subproofNode, substitutions, fileContext, localContext);
 
@@ -145,6 +148,10 @@ function matchPremise(premise, proofStep, substitutions, fileContext, localConte
     premiseUnified = statementUnified;  ///
   }
 
+  premiseUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
+
   return premiseUnified;
 }
 
@@ -165,8 +172,17 @@ function unifyPremises(premises, proofSteps, substitutions, fileContext, localCo
 }
 
 function unifyConclusion(conclusion, statementNode, substitutions, fileContext, localContext) {
-  const statementUnified = conclusion.unifyStatement(statementNode, substitutions, fileContext, localContext),
-        conclusionUnified = statementUnified; ///
+  let conclusionUnified;
+
+  substitutions.snapshot();
+
+  const statementUnified = conclusion.unifyStatement(statementNode, substitutions, fileContext, localContext);
+
+  conclusionUnified = statementUnified; ///
+
+  conclusionUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
 
   return conclusionUnified;
 }

package/src/substitution/termForVariable.js

@@ -106,7 +106,7 @@ function substituteTermNode(termNode, substitutions) {
   const termVariableNode = variableNodeQuery(termNode);
 
   if (termVariableNode !== null) {
-    substitutions.some((substitution) => {
+    substitutions.someSubstitution((substitution) => {
       const substitutionMatchesVariableNode = substitution.matchVariableNode(termVariableNode);
 
       if (substitutionMatchesVariableNode) {
@@ -121,7 +121,7 @@ function substituteTermNode(termNode, substitutions) {
 }
 
 function substituteVariableNode(variableNode, substitutions) {
-  substitutions.some((substitution) => {
+  substitutions.someSubstitution((substitution) => {
     const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
 
     if (substitutionMatchesVariableNode) {

package/src/substitutions.js

@@ -0,0 +1,103 @@
+"use strict";
+
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
+
+import { prune, compare } from "./utilities/array";
+
+export default class Substitutions {
+  constructor(array, savedArray) {
+    this.array = array;
+    this.savedArray = savedArray;
+  }
+
+  getArray() {
+    return this.array;
+  }
+
+  getSavedArray() {
+    return this.savedArray;
+  }
+
+  hasChanged() {
+    const compares = compare(this.array, this.savedArray),
+          changed = !compares;  ///
+
+    return changed;
+  }
+
+  findSubstitution(callback) { return this.array.find(callback); }
+
+  someSubstitution(callback) { return this.array.some(callback); }
+
+  everySubstitution(callback) { return this.array.every(callback); }
+
+  addSubstitution(substitution) { this.array.push(substitution); }
+
+  removeSubstitution(substitution) {
+    const substitutionA = substitution; ///
+
+    prune(this.array, (substitution) => {
+      const substitutionB = substitution; ///
+
+      if (substitutionA !== substitutionB) {
+        return true;
+      }
+    });
+  }
+
+  snapshot() {
+    this.savedArray = [
+      ...this.array
+    ];
+  }
+
+  rollback() {
+    const start = 0,
+          end = Infinity;
+
+    this.array.splice(start, end, ...this.savedArray);
+
+    this.savedArray = null;
+  }
+
+  continue() {
+    this.savedArray = null;
+  }
+
+  transform() {
+    ///
+  }
+
+  toJSON(tokens) {
+    const json = this.array.map((substitution) => {
+      const substitutionJSON = substitution.toJSON(tokens);
+
+      return substitutionJSON;
+    });
+
+    return json;
+  }
+
+  static fromNothing() {
+    const array = [],
+          savedArray = null,
+          substitutions = new Substitutions(array, savedArray);
+
+    return substitutions;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    const substitutionsJSON = json, ///
+          array = substitutionsJSON.map((substitutionJSON) => {
+            const json = substitutionJSON,  ///
+                  statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
+                  substitution = statementForMetavariableSubstitution;  ///
+
+            return substitution;
+          }),
+          savedArray = null,
+          substitutions = new Substitutions(array, savedArray);
+
+    return substitutions;
+  }
+}

package/src/supposition.js

@@ -47,7 +47,6 @@ export default class Supposition {
 
       if (subproofAssertionNode !== null) {
         const fileContextA = fileContext, ///
-              localContextA = LocalContext.fromFileContext(fileContextA),
               localContextB = localContext,  ///
               subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
               subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
@@ -58,7 +57,8 @@ export default class Supposition {
               subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
 
         subproofUnified = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
-          const nodeA = subproofAssertionStatementNode,  ///
+          const localContextA = LocalContext.fromFileContext(fileContextA),
+                nodeA = subproofAssertionStatementNode,  ///
                 nodeB = subproofStatementNode, ///
                 unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 

package/src/topLevelAssertion.js

@@ -3,7 +3,7 @@
 import Label from "./label";
 import Consequent from "./consequent";
 import Supposition from "./supposition";
-import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
+import Substitutions from "./substitutions";
 
 import { reverse, correlate } from "./utilities/array";
 
@@ -40,7 +40,7 @@ export default class TopLevelAssertion {
     let statementUnified = false;
 
     const proofSteps = localContext.getProofSteps(),
-          substitutions = [],
+          substitutions = Substitutions.fromNothing(),
           suppositionsUnified = unifySuppositions(this.suppositions, proofSteps, substitutions, this.fileContext, localContext);
 
     if (suppositionsUnified) {
@@ -76,11 +76,7 @@ export default class TopLevelAssertion {
             return suppositionJSON;
           }),
           consequentJSON = this.consequent.toJSON(tokens),
-          substitutionsJSON = this.substitutions.map((substitution) => {
-            const substitutionJSON = substitution.toJSON();
-
-            return substitutionJSON;
-          }),
+          substitutionsJSON = this.substitutions.toJSON(tokens),
           labels = labelsJSON,  ///
           suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
@@ -126,13 +122,9 @@ export default class TopLevelAssertion {
 
     const substitutionsJSON = substitutions;  ///
 
-    substitutions = substitutionsJSON.map((substitutionJSON) => {
-      const json = substitutionJSON,  ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
-            substitution = statementForMetavariableSubstitution;  ///
+    json = substitutionsJSON; ///
 
-      return substitution;
-    });
+    substitutions = Substitutions.fromJSONAndFileContext(json, fileContext);
 
     return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
   }
@@ -159,6 +151,8 @@ function unifySuppositions(suppositions, proofSteps, substitutions, fileContext,
 function unifySupposition(supposition, proofStep, substitutions, fileContext, localContext) {
   let suppositionUnified = false;
 
+  substitutions.snapshot();
+
   const subproofNode = proofStep.getSubproofNode(),
         statementNode = proofStep.getStatementNode();
 
@@ -174,12 +168,25 @@ function unifySupposition(supposition, proofStep, substitutions, fileContext, lo
     suppositionUnified = statementUnified;  ///
   }
 
+  suppositionUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
+
   return suppositionUnified;
 }
 
 function unifyConsequent(consequent, statementNode, substitutions, fileContext, localContext) {
-  const statementUnified = consequent.unifyStatement(statementNode, substitutions, fileContext, localContext),
-        consequentUnified = statementUnified; ///
+  let consequentUnified;
+
+  substitutions.snapshot();
+
+  const statementUnified = consequent.unifyStatement(statementNode, substitutions, fileContext, localContext);
+
+  consequentUnified = statementUnified; ///
+
+  consequentUnified ?
+    substitutions.continue() :
+      substitutions.rollback();
 
   return consequentUnified;
 }

package/src/unify/metavariableAgainstStatement.js

@@ -7,7 +7,7 @@ import StatementForMetavariableSubstitution from "../substitution/statementForMe
 export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, unifyAhead) {
   let metavariableUnifiedAgainstStatement = false;
 
-  const substitution = substitutions.find((substitution) => {
+  const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
     if (substitutionMatchesMetavariableNodeA) {
@@ -67,12 +67,12 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
           statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
           substitution = statementForMetavariableSubstitution;  ///
 
-    substitutions.push(substitution);
+    substitutions.addSubstitution(substitution);
 
     unifiedAhead = unifyAhead();
 
     if (!unifiedAhead) {
-      substitutions.pop();
+      substitutions.removeSubstitution(substitution);
     }
 
     metavariableUnifiedAgainstStatement = unifiedAhead;  ///

package/src/unify/variableAgainstTerm.js

@@ -11,7 +11,7 @@ const variableNodeQuery = nodeQuery("/term/variable");
 export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
   let variableUnifiedAgainstTerm = false;
 
-  const substitution = substitutions.find((substitution) => {
+  const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
 
     if (substitutionMatchesVariableNodeA) {
@@ -54,12 +54,12 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
                         termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
                         substitution = termForVariableSubstitution;  ///
 
-                  substitutions.push(substitution);
+                  substitutions.addSubstitution(substitution);
 
                   verifiedAhead = verifyAhead();
 
                   if (!verifiedAhead) {
-                    substitutions.pop();
+                    substitutions.removeSubstitution(substitution);
                   }
                 }
               }

package/src/utilities/array.js

@@ -12,6 +12,21 @@ export function reverse(array) {
   return array;
 }
 
+export function compare(arrayA, arrayB) {
+  let compares = false;
+
+  const arrayALength = arrayA.length,
+        arrayBLength = arrayB.length;
+
+  if (arrayALength === arrayBLength) {
+    const correlates = correlate(arrayA, arrayB);
+
+    compares = correlates;  ///
+  }
+
+  return compares;
+}
+
 export function correlate(arrayA, arrayB, callback) {
   arrayB = [  ///
     ...arrayB

package/src/verifier/metaLevel.js

@@ -1,11 +1,11 @@
 "use strict";
 
 import Verifier from "../verifier";
+import verifyTerm from "../verify/term";
+import verifyVariable from "../verify/variable";
+import verifyMetavariable from "../verify/metavariable";
 
 import { nodeQuery } from "../utilities/query";
-import { verifyStandaloneTerm } from "../verify/term";
-import { verifyStandaloneVariable } from "../verify/variable";
-import { verifyStandaloneMetavariable } from "../verify/metavariable";
 
 const termNodeQuery = nodeQuery("/term!"),
       variableNodeQuery = nodeQuery("/variable!"),
@@ -31,8 +31,7 @@ class MetaLevelVerifier extends Verifier {
     {
       nodeQuery: metavariableNodeQuery,
       verify: (metavariableNode, localContext, verifyAhead) => {
-        const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead),
-              metavariableVerified = standaloneMetavariableVerified;  ///
+        const metavariableVerified = verifyMetavariable(metavariableNode, localContext, verifyAhead);
 
         return metavariableVerified;
       }
@@ -40,8 +39,7 @@ class MetaLevelVerifier extends Verifier {
     {
       nodeQuery: variableNodeQuery,
       verify: (variableNode, localContext, verifyAhead) => {
-        const standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
-              variableVerified = standaloneVariableVerified;  ///
+        const variableVerified = verifyVariable(variableNode, localContext, verifyAhead);
 
         return variableVerified;
       }
@@ -49,8 +47,8 @@ class MetaLevelVerifier extends Verifier {
     {
       nodeQuery: termNodeQuery,
       verify: (termNode, localContext, verifyAhead) => {
-        const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-              termVerified = standaloneTermVerified;  ///
+        const terms = [],
+              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
 
         return termVerified;
       }

package/src/verifier/statementAsCombinator.js

@@ -1,11 +1,11 @@
 "use strict";
 
 import Verifier from "../verifier";
+import verifyType from "../verify/type";
+import verifyTerm from "../verify/term";
+import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
-import { verifyStandaloneType } from "../verify/type";
-import { verifyStandaloneTerm } from "../verify/term";
-import { verifyStandaloneStatement } from "../verify/statement";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),
@@ -32,8 +32,8 @@ class StatementAsCombinatorVerifier extends Verifier {
     {
       nodeQuery: termNodeQuery,
       verify: (termNode, localContext, verifyAhead) => {
-        const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-              termVerified = standaloneTermVerified;  ///
+        const terms = [],
+              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
 
         return termVerified;
       }
@@ -41,8 +41,7 @@ class StatementAsCombinatorVerifier extends Verifier {
     {
       nodeQuery: typeNodeQuery,
       verify: (typeNode, localContext, verifyAhead) => {
-        const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-              typeVerified = standaloneTypeVerified;  ///
+        const typeVerified = verifyType(typeNode, localContext, verifyAhead);
 
         return typeVerified;
       }
@@ -50,8 +49,18 @@ class StatementAsCombinatorVerifier extends Verifier {
     {
       nodeQuery: statementNodeQuery,
       verify: (statementNode, localContext, verifyAhead) => {
-        const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
-              statementVerified = standaloneStatementVerified;  ///
+        let statementVerified;
+
+        const derived = false,
+              assignments = [];
+
+        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
+
+        if (statementVerified) {
+          const verifiedAhead = verifyAhead();
+
+          statementVerified = verifiedAhead;  ///
+        }
 
         return statementVerified;
       }

package/src/verifier/termAsConstructor.js

@@ -1,11 +1,11 @@
 "use strict";
 
 import Verifier from "../verifier";
+import verifyTerm from "../verify/term";
+import verifyType from "../verify/type";
 import LocalContext from "../context/local";
 
 import { nodeQuery } from "../utilities/query";
-import { verifyStandaloneType } from "../verify/type";
-import { verifyStandaloneTerm } from "../verify/term";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!");
@@ -31,9 +31,9 @@ class TermAsConstructorVerifier extends Verifier {
     {
       nodeQuery: termNodeQuery,
       verify: (termNode, fileContext, verifyAhead) => {
-        const localContext = LocalContext.fromFileContext(fileContext),
-              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-              termVerified = standaloneTermVerified;  ///
+        const terms = [],
+              localContext = LocalContext.fromFileContext(fileContext),
+              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
 
         return termVerified;
       }
@@ -42,8 +42,7 @@ class TermAsConstructorVerifier extends Verifier {
       nodeQuery: typeNodeQuery,
       verify: (typeNode, fileContext, verifyAhead) => {
         const localContext = LocalContext.fromFileContext(fileContext),
-              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-              typeVerified = standaloneTypeVerified;  ///
+              typeVerified = verifyType(typeNode, localContext, verifyAhead);
 
         return typeVerified;
       }

package/src/verifier/topLevel.js

@@ -0,0 +1,160 @@
+"use strict";
+
+import Verifier from "../verifier";
+import verifyError from "../verify/error";
+import verifyRule from "../verify/rule";
+import verifyAxiom from "../verify/axiom";
+import verifyLemma from "../verify/lemma";
+import verifyTheorem from "../verify/theorem";
+import verifyMetaLemma from "../verify/metaLemma";
+import verifyConjecture from "../verify/conjecture";
+import verifyMetatheorem from "../verify/metatheorem";
+import verifyTypeDeclaration from "../verify/declaration/type";
+import verifyVariableDeclaration from "../verify/declaration/variable";
+import verifyCombinatorDeclaration from "../verify/declaration/combinator";
+import verifyConstructorDeclaration from "../verify/declaration/constructor";
+import verifyMetavariableDeclaration from "../verify/declaration/metavariable";
+
+import { nodeQuery } from "../utilities/query";
+
+const errorNodeQuery = nodeQuery("/error"),
+      ruleNodeQuery = nodeQuery("/rule!"),
+      axiomNodeQuery = nodeQuery("/axiom!"),
+      lemmaNodeQuery = nodeQuery("/lemma!"),
+      theoremNodeQuery = nodeQuery("/theorem!"),
+      metaLemmaNodeQuery = nodeQuery("/metaLemma!"),
+      conjectureNodeQuery = nodeQuery("/conjecture!"),
+      metatheoremNodeQuery = nodeQuery("/metatheorem!"),
+      typeDeclarationNodeQuery = nodeQuery("/typeDeclaration!"),
+      variableDeclarationNodeQuery = nodeQuery("/variableDeclaration!"),
+      combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration!"),
+      constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration!"),
+      metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration!");
+
+class TopLevelVerifier extends Verifier {
+  verify(node, fileContext) {
+    let verified;
+
+    const nonTerminalNode = node, ///
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, fileContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    verified = nonTerminalNodeVerified;  ///
+
+    return verified;
+  }
+
+  static maps = [
+    {
+      nodeQuery: errorNodeQuery,
+      verify: (errorNode, fileContext) => {
+        const errorVerified = verifyError(errorNode, fileContext);
+
+        return errorVerified;
+      }
+    },
+    {
+      nodeQuery: ruleNodeQuery,
+      verify: (ruleNode, fileContext) => {
+        const ruleVerified = verifyRule(ruleNode, fileContext);
+
+        return ruleVerified;
+      }
+    },
+    {
+      nodeQuery: axiomNodeQuery,
+      verify: (axiomNode, fileContext) => {
+        const axiomVerified = verifyAxiom(axiomNode, fileContext);
+
+        return axiomVerified;
+      }
+    },
+    {
+      nodeQuery: lemmaNodeQuery,
+      verify: (lemmaNode, fileContext) => {
+        const lemmaVerified = verifyLemma(lemmaNode, fileContext);
+
+        return lemmaVerified;
+      }
+    },
+    {
+      nodeQuery: theoremNodeQuery,
+      verify: (theoremNode, fileContext) => {
+        const theoremVerified = verifyTheorem(theoremNode, fileContext);
+
+        return theoremVerified;
+      }
+    },
+    {
+      nodeQuery: metaLemmaNodeQuery,
+      verify: (metaLemmaNode, fileContext) => {
+        const metaLemmaVerified = verifyMetaLemma(metaLemmaNode, fileContext);
+
+        return metaLemmaVerified;
+      }
+    },
+    {
+      nodeQuery: conjectureNodeQuery,
+      verify: (conjectureNode, fileContext) => {
+        const conjectureVerified = verifyConjecture(conjectureNode, fileContext);
+
+        return conjectureVerified;
+      }
+    },
+    {
+      nodeQuery: metatheoremNodeQuery,
+      verify: (metatheoremNode, fileContext) => {
+        const metatheoremVerified = verifyMetatheorem(metatheoremNode, fileContext);
+
+        return metatheoremVerified;
+      }
+    },
+    {
+      nodeQuery: typeDeclarationNodeQuery,
+      verify: (typeDeclarationNode, fileContext) => {
+        const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
+
+        return typeDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: variableDeclarationNodeQuery,
+      verify: (variableDeclarationNode, fileContext) => {
+        const variableDeclarationVerified = verifyVariableDeclaration(variableDeclarationNode, fileContext);
+
+        return variableDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: combinatorDeclarationNodeQuery,
+      verify: (combinatorDeclarationNode, fileContext) => {
+        const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext);
+
+        return combinatorDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: constructorDeclarationNodeQuery,
+      verify: (constructorDeclarationNode, fileContext) => {
+        const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, fileContext);
+
+        return constructorDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: metavariableDeclarationNodeQuery,
+      verify: (metavariableDeclarationNode, fileContext) => {
+        const metavariableDeclarationVerified = verifyMetavariableDeclaration(metavariableDeclarationNode, fileContext);
+
+        return metavariableDeclarationVerified;
+      }
+    }
+  ];
+}
+
+const topLevelVerifier = new TopLevelVerifier();
+
+export default topLevelVerifier;

package/src/verify/axiom.js

@@ -3,6 +3,7 @@
 import Axiom from "../axiom";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -37,8 +38,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
 
       if (consequentVerified) {
         const firstConsequent = first(consequents),
+              substitutions = Substitutions.fromNothing(),
               consequent = firstConsequent, ///
-              substitutions = [],
               axiom = Axiom.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addAxiom(axiom);