occam-verify-cli 0.0.922 → 0.0.924

package/src/premise.js

@@ -7,27 +7,18 @@ import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrin
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
+import { statementNodeFromStatementString } from "./utilities/node";
 
-const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!"),
-      subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
-      ruleSubproofPremiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement!/metastatement!"),
-      ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!"),
-      metaSubproofLastMetaproofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaproofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofPremiseStatementNodesQuery = nodesQuery("/subproof/premise/unqualifiedStatement!/statement!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Premise {
-  constructor(metastatementNode, statementNode) {
-    this.metastatementNode = metastatementNode;
+  constructor(statementNode) {
     this.statementnode = statementNode;
   }
 
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
   getStatementNode() {
     return this.statementnode;
   }
@@ -35,9 +26,9 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions, fileContext, localContext) {
     let matchesStatementNode = false;
 
-    if (this.metastatementNode !== null) {
+    if (this.statementNode !== null) {
       const fileContextA = fileContext, ///
-            nonTerminalNodeA = this.metastatementNode,  ///
+            nonTerminalNodeA = this.statementNode,  ///
             nonTerminalNodeB = statementNode,  ///
             localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
@@ -56,98 +47,24 @@ export default class Premise {
   matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
     let matchesSubproofNode = false;
 
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+    if (this.statementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
 
       if (subproofAssertionNode !== null) {
-        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+        const subproofPremiseStatementNodes = subproofPremiseStatementNodesQuery(subproofNode),
               subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
               subproofStatementNodes = [
-                ...subproofSuppositionStatementNodes,
+                ...subproofPremiseStatementNodes,
                 subproofLastProofStepStatementNode
               ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
 
-        matchesSubproofNode = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
+        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
           const fileContextA = fileContext, ///
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+                nonTerminalNodeA = subproofAssertionStatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
                 localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
-                nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return matchesSubproofNode;
-  }
-
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext) {
-    let matchesRuleSubproofNode = false;
-
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
-
-      if (subproofAssertionNode !== null) {
-        const ruleSubproofPremiseMetastatementNodes = ruleSubproofPremiseMetastatementNodesQuery(ruleSubproofNode),
-              ruleSubproofLastRuleProofStepMetastatementNode = ruleSubproofLastRuleProofStepMetastatementNodeQuery(ruleSubproofNode),
-              ruleSubproofMetastatementNodes = [
-                ...ruleSubproofPremiseMetastatementNodes,
-                ruleSubproofLastRuleProofStepMetastatementNode
-              ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
-
-        matchesRuleSubproofNode = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const fileContextA = fileContext, ///
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
-                localContextB = localContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return matchesRuleSubproofNode;
-  }
-
-  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext) {
-    let matchesMetaSubproofNode = false;
-
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
-
-      if (subproofAssertionNode !== null) {
-        const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-              metaSubproofLastMetaproofStepMetastatementNode = metaSubproofLastMetaproofStepMetastatementNodeQuery(metaSubproofNode),
-              metaSubproofMetastatementNodes = [
-                ...metaSubproofMetaSuppositionMetastatementNodes,
-                metaSubproofLastMetaproofStepMetastatementNode
-              ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
-
-        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const fileContextA = fileContext, ///
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
-                localContextB = localContext,  ///
                 nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
@@ -161,37 +78,13 @@ export default class Premise {
       }
     }
 
-    return matchesMetaSubproofNode;
-  }
-
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
-    let matchesMetastatementNode = false;
-
-    if (this.metastatementNode !== null) {
-      const fileContextA = fileContext, ///
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
-            localContextB = localContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      matchesMetastatementNode = nonTerminalNodeVerified; ///
-    }
-
-    return matchesMetastatementNode;
+    return matchesSubproofNode;
   }
 
   toJSON(tokens) {
-    const metastatementString = nodeAsString(this.metastatementNode, tokens),
-          statementString = nodeAsString(this.statementnode, tokens),
-          metastatement = metastatementString, ///
+    const statementString = nodeAsString(this.statementnode, tokens),
           statement = statementString,  ///
           json = {
-            metastatement,
             statement
           };
 
@@ -199,28 +92,18 @@ export default class Premise {
   }
 
   static fromStatementNode(statementNode) {
-    const metastatementNode = null,
-          premise = new Premise(metastatementNode, statementNode);
-
-    return premise;
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
-          premise = new Premise(metastatementNode, statementNode);
+    const premise = new Premise(statementNode);
 
     return premise;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement, statement } = json,
-          metastatementString = metastatement,  ///
+    const { statement } = json,
           statementString = statement, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          premise = new Premise(metastatementNode, statementNode);
+          premise = new Premise(statementNode, statementNode);
 
     return premise;
   }

package/src/rule.js

@@ -46,22 +46,6 @@ export default class Rule {
     return matchesStatement;
   }
 
-  matchMetastatement(metastatementNode, localContext) {
-    let matchesMetastatement = false;
-
-    const metaproofSteps = localContext.getMetaproofSteps(),
-          substitutions = [],
-          premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localContext);
-
-    if (premisesMatch) {
-      const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localContext);
-
-      matchesMetastatement = conclusionMatches;  ///
-    }
-
-    return matchesMetastatement;
-  }
-
   matchMetavariableNode(metavariableNode) {
     const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
@@ -186,54 +170,3 @@ function matchConclusion(conclusion, statementNode, substitutions, fileContext,
 
   return conclusionMatches;
 }
-
-function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext) {
-  let premiseMatches = false;
-
-  const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
-        metaSubproofNode = metaproofStep.getMetaSubproofNode(),
-        metastatementNode = metaproofStep.getMetastatementNode()
-
-  if (ruleSubproofNode !== null) {
-    const premiseMatchesRuleSubproofNode = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesRuleSubproofNode; ///
-  }
-
-  if (metaSubproofNode !== null) {
-    const premiseMatchesMetaSubproofNode = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesMetaSubproofNode; ///
-  }
-
-  if (metastatementNode !== null) {
-    const premiseMatchesMetastatementNode = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesMetastatementNode;  ///
-  }
-
-  return premiseMatches;
-}
-
-function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext, localContext) {
-  premises = reverse(premises); ///
-
-  metaproofSteps = reverse(metaproofSteps); ///
-
-  const premisesMatch = correlate(premises, metaproofSteps, (premise, metaproofStep) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext);
-
-    if (premiseMatches) {
-      return true;
-    }
-  });
-
-  return premisesMatch;
-}
-
-function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localContext) {
-  const conclusionMatchesMetastatementNode = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext),
-        conclusionMatches = conclusionMatchesMetastatementNode; ///
-
-  return conclusionMatches;
-}

package/src/ruleNames.js

@@ -1,8 +1,6 @@
 "use strict";
 
 export const METAVARIABLE_RULE_NAME = "metavariable";
-export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
-export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/substitution/statementForMetavariable.js

@@ -5,6 +5,7 @@ import TermForVariableSubstitution from "./termForVariable";
 import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
 
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
+import { statementNodeFromStatementString, metavariableNodeFromMetavariableString } from "../utilities/node";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, statementNode, substitution) {
@@ -55,6 +56,19 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return matchesMetavariableNode;
   }
 
+  static fromJSONAndFileContext(json, fileContext) {
+    const { metavariable, statement } = json,
+            metavariableString = metavariable,  ///
+            statementString = statement,  ///
+            lexer = fileContext.getLexer(),
+            parser = fileContext.getParser(),
+            statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+            metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
+            statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode);
+
+    return statementForMetavariableSubstitution;
+  }
+
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
     let statementForMetavariableSubstitution;
 

package/src/substitution.js

@@ -24,10 +24,4 @@ export default class Substitution {
 
     return matchesMetavariableNode;
   }
-
-  matchMetastatementNode(metastatementNode) {
-    const matchesMetastatementNode = false;
-
-    return matchesMetastatementNode;
-  }
 }

package/src/supposition.js

@@ -1,9 +1,18 @@
 "use strict";
 
+import LocalContext from "./context/local";
+import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
+import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { statementNodeFromStatementString } from "./utilities/node";
+import {nodeQuery, nodesQuery} from "./utilities/query";
+
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Supposition {
   constructor(statementNode) {
@@ -29,6 +38,43 @@ export default class Supposition {
     return matchesStatementNode;
   }
 
+  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
+    let matchesSubproofNode = false;
+
+    if (this.statementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
+
+      if (subproofAssertionNode !== null) {
+        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+              subproofStatementNodes = [
+                ...subproofSuppositionStatementNodes,
+                subproofLastProofStepStatementNode
+              ],
+              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
+
+        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, ruleSubproofStatementNode) => {
+          const fileContextA = fileContext, ///
+                nonTerminalNodeA = subproofAssertionStatementNode,  ///
+                nonTerminalNodeB = ruleSubproofStatementNode, ///
+                localContextA = LocalContext.fromFileContext(fileContextA),  ///
+                localContextB = localContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
+
+          if (nonTerminalNodeVerified) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return matchesSubproofNode;
+  }
+
   toJSON(tokens) {
     const statementString = nodeAsString(this.statementNode, tokens),
           statement = statementString, ///

package/src/theorem.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
+import TopLevelAssertion from "./topLevelAssertion";
 
-export default class Theorem extends AxiomLemmaTheoremConjecture {
-  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Theorem, json, fileContext); }
+export default class Theorem extends TopLevelAssertion {
+  static fromJSONAndFileContext(json, fileContext) { return TopLevelAssertion.fromJSONAndFileContext(Theorem, json, fileContext); }
 
-  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Theorem, labels, suppositions, consequent, localContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext) { return TopLevelAssertion.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Theorem, labels, suppositions, consequent, substitutions, fileContext); }
 }

package/src/{axiomLemmaTheoremConjecture.js → topLevelAssertion.js}

@@ -3,16 +3,17 @@
 import Label from "./label";
 import Consequent from "./consequent";
 import Supposition from "./supposition";
-import LocalContext from "./context/local";
+import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
 import { reverse, correlate } from "./utilities/array";
 
-export default class AxiomLemmaTheoremConjecture {
-  constructor(labels, suppositions, consequent, localContext) {
+export default class TopLevelAssertion {
+  constructor(labels, suppositions, consequent, substitutions, fileContext) {
     this.labels = labels;
     this.suppositions = suppositions;
     this.consequent = consequent;
-    this.localContext = localContext;
+    this.substitutions = substitutions;
+    this.fileContext = fileContext;
   }
 
   getLabels() {
@@ -27,8 +28,12 @@ export default class AxiomLemmaTheoremConjecture {
     return this.consequent;
   }
 
-  getLocalContext() {
-    return this.localContext;
+  getSubstitutions() {
+    return this.substitutions;
+  }
+
+  getFileContext() {
+    return this.fileContext;
   }
 
   matchStatement(statementNode, localContext) {
@@ -36,10 +41,10 @@ export default class AxiomLemmaTheoremConjecture {
 
     const proofSteps = localContext.getProofSteps(),
           substitutions = [],
-          suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.localContext, localContext);
+          suppositionsMatch = matchSuppositions(this.suppositions, proofSteps, substitutions, this.fileContext, localContext);
 
     if (suppositionsMatch) {
-      const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.localContext, localContext);
+      const consequentMatches = matchConsequent(this.consequent, statementNode, substitutions, this.fileContext, localContext);
 
       statementNatches = consequentMatches;  ///
     }
@@ -71,16 +76,20 @@ export default class AxiomLemmaTheoremConjecture {
             return suppositionJSON;
           }),
           consequentJSON = this.consequent.toJSON(tokens),
-          localContextJSON = this.localContext.toJSON(tokens),
+          substitutionsJSON = this.substitutions.map((substitution) => {
+        const substitutionJSON = substitution.toJSON();
+
+        return substitutionJSON;
+      }),
           labels = labelsJSON,  ///
           suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
-          localContext = localContextJSON,  ///
+          substitutions = substitutionsJSON,  ///
           json = {
             labels,
             suppositions,
             consequent,
-            localContext
+            substitutions
           };
 
     return json;
@@ -98,7 +107,7 @@ export default class AxiomLemmaTheoremConjecture {
       return label;
     });
 
-    let { suppositions, consequent, localContext } = json;
+    let { suppositions, consequent, substitutions } = json;
 
     const suppositionsJSON = suppositions;  ///
 
@@ -115,25 +124,29 @@ export default class AxiomLemmaTheoremConjecture {
 
     consequent = Consequent.fromJSONAndFileContext(json, fileContext);
 
-    const localContextJSON = localContext;  ///
+    const substitutionsJSON = substitutions;  ///
 
-    json = localContextJSON;  ///
+    substitutions = substitutionsJSON.map((substitutionJSON) => {
+      const json = substitutionJSON,  ///
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromJSONAndFileContext(json, fileContext),
+            substitution = statementForMetavariableSubstitution;  ///
 
-    localContext = LocalContext.fromJSONAndFileContext(json, fileContext);
+      return substitution;
+    });
 
-    return new Class(labels, suppositions, consequent, localContext);  ///
+    return new Class(labels, suppositions, consequent, substitutions, fileContext);  ///
   }
 
-  static fromLabelsSuppositionsConsequentAndLocalContext(Class, labels, suppositions, consequent, localContext) { return new Class(labels, suppositions, consequent, localContext); }
+  static fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(Class, labels, suppositions, consequent, substitutions, fileContext) { return new Class(labels, suppositions, consequent, substitutions, fileContext); }
 }
 
-function matchSuppositions(suppositions, proofSteps, substitutions, localContext, statementLocalContext) {
+function matchSuppositions(suppositions, proofSteps, substitutions, fileContext, localContext) {
   suppositions = reverse(suppositions); ///
 
   proofSteps = reverse(proofSteps); ///
 
   const suppositionsMatch = correlate(suppositions, proofSteps, (supposition, proofStep) => {
-    const suppositionMatches = matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext);
+    const suppositionMatches = matchSupposition(supposition, proofStep, substitutions, fileContext, localContext);
 
     if (suppositionMatches) {
       return true;
@@ -143,13 +156,13 @@ function matchSuppositions(suppositions, proofSteps, substitutions, localContext
   return suppositionsMatch;
 }
 
-function matchSupposition(supposition, proofStep, substitutions, localContext, statementLocalContext) {
+function matchSupposition(supposition, proofStep, substitutions, fileContext, localContext) {
   let suppositionMatches = false;
 
   const statementNode = proofStep.getStatementNode();
 
   if (statementNode !== null) {
-    const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
+    const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
     suppositionMatches = suppositionMatchesStatementNode;  ///
   }
@@ -157,8 +170,8 @@ function matchSupposition(supposition, proofStep, substitutions, localContext, s
   return suppositionMatches;
 }
 
-function matchConsequent(consequent, statementNode, substitutions, localContext, statementLocalContext) {
-  const consequentMatchesStatementNode = consequent.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext),
+function matchConsequent(consequent, statementNode, substitutions, fileContext, localContext) {
+  const consequentMatchesStatementNode = consequent.matchStatementNode(statementNode, substitutions, fileContext, localContext),
         consequentMatches = consequentMatchesStatementNode; ///
 
   return consequentMatches;

package/src/utilities/customGrammar.js

@@ -5,11 +5,10 @@ import { CustomGrammar, CombinedCustomGrammar } from "occam-custom-grammars";
 export function customGrammarFromNameAndEntries(name, entries) {
   const termBNF = entries.getTermBNF(),
         statementBNF = entries.getStatementBNF(),
-        metastatementBNF = entries.getMetastatementBNF(),
         typePattern = entries.getTypePattern(),
         symbolPattern = entries.getSymbolPattern(),
         operatorPattern = entries.getOperatorPattern(),
-        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFMetastatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
+        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, typePattern, symbolPattern, operatorPattern);
 
   return customGrammar;
 }