occam-verify-cli 0.0.538 → 0.0.540

package/src/rule.js

@@ -9,10 +9,11 @@ import { RULE_KIND } from "./kinds";
 import { someSubArray } from "./utilities/array";
 
 export default class Rule {
-  constructor(labels, premises, conclusion) {
+  constructor(labels, premises, conclusion, fileContext) {
     this.labels = labels;
     this.premises = premises;
     this.conclusion = conclusion;
+    this.fileContext = fileContext;
   }
 
   getLabels() {
@@ -27,6 +28,10 @@ export default class Rule {
     return this.conclusion;
   }
 
+  getFileContext() {
+    return this.fileContext;
+  }
+
   matchLabelName(labelName) {
     const matchesLabelName = this.labels.some((label) => {
       const name = labelName, ///
@@ -40,27 +45,27 @@ export default class Rule {
     return matchesLabelName;
   }
 
-  matchStatement(statementNode, proofContext) {
+  matchStatement(statementNode, statementProofContext) {
     let statementNatches;
 
     const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
       const substitutions = [],
-            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions);
+            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementProofContext);
 
       statementNatches = conclusionMatches; ///
     } else {
-      const proofSteps = proofContext.getProofSteps();
+      const proofSteps = statementProofContext.getProofSteps();
 
       statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
         let premisesMatchConclusion = false;
 
         const substitutions = [],
-              premisesMatch = matchPremises(this.premises, proofSteps, substitutions);
+              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, statementProofContext);
 
         if (premisesMatch) {
-          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions);
+          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementProofContext);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -74,27 +79,27 @@ export default class Rule {
     return statementNatches;
   }
 
-  matchMetastatement(metastatementNode, metaproofContext) {
+  matchMetastatement(metastatementNode, metastatementMetaproofContext) {
     let metastatementNatches;
 
     const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
       const substitutions = [],
-            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions);
+            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementMetaproofContext);
 
       metastatementNatches = conclusionMatches; ///
     } else {
-      const metaproofSteps = metaproofContext.getMetaproofSteps();
+      const metaproofSteps = metastatementMetaproofContext.getMetaproofSteps();
 
       metastatementNatches = someSubArray(metaproofSteps, premisesLength, (metaproofSteps) => {
         let premisesMatchConclusion = false;
 
         const substitutions = [],
-              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions);
+              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, metastatementMetaproofContext);
 
         if (premisesMatch) {
-          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions);
+          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementMetaproofContext);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -134,7 +139,7 @@ export default class Rule {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     let rule;
 
     let { labels } = json;
@@ -143,7 +148,7 @@ export default class Rule {
 
     labels = labelsJSON.map((labelJSON) => {
       const json = labelJSON, ///
-            label = Label.fromJSON(json, context);
+            label = Label.fromJSONAndFileContext(json, fileContext);
 
       return label;
     });
@@ -154,7 +159,7 @@ export default class Rule {
 
     premises = premisesJSON.map((premiseJSON) => {
       const json = premiseJSON, ///
-            premise = Premise.fromJSON(json, context);
+            premise = Premise.fromJSONAndFileContext(json, fileContext);
 
       return premise;
     });
@@ -165,27 +170,27 @@ export default class Rule {
 
     json = conclusionJSON;  ///
 
-    conclusion = Conclusion.fromJSON(json, context);
+    conclusion = Conclusion.fromJSONAndFileContext(json, fileContext);
 
-    rule = new Rule(labels, premises, conclusion);
+    rule = new Rule(labels, premises, conclusion, fileContext);
 
     return rule;
   }
 
-  static fromLabelsPremisesAndConclusion(labels, premises, conclusion) {
-    const rule = new Rule(labels, premises, conclusion);
+  static fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext) {
+    const rule = new Rule(labels, premises, conclusion, fileContext);
 
     return rule;
   }
 }
 
-function matchPremise(premise, proofSteps, substitutions) {
+function matchPremise(premise, proofSteps, substitutions, fileContext, statementProofContext) {
   const proofStep = prune(proofSteps, (proofStep) => {
     const subproofNode = proofStep.getSubproofNode(),
           statementNode = proofStep.getStatementNode()
 
     if (subproofNode !== null) {
-      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions);
+      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, statementProofContext);
 
       if (!subProofNodeMatches) {  ///
         return true;
@@ -193,7 +198,7 @@ function matchPremise(premise, proofSteps, substitutions) {
     }
 
     if (statementNode !== null) {
-      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions);
+      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementProofContext);
 
       if (!statementNodeMatches) {  ///
         return true;
@@ -206,9 +211,9 @@ function matchPremise(premise, proofSteps, substitutions) {
   return premiseMatches;
 }
 
-function matchPremises(premise, proofSteps, substitutions) {
+function matchPremises(premise, proofSteps, substitutions, fileContext, statementProofContext) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, proofSteps, substitutions);
+    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, statementProofContext);
 
     if (premiseMatches) {
       return true;
@@ -218,20 +223,20 @@ function matchPremises(premise, proofSteps, substitutions) {
   return premisesMatch;
 }
 
-function matchConclusion(conclusion, statementNode, substitutions) {
-  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions),
+function matchConclusion(conclusion, statementNode, substitutions, fileContext, statementProofContext) {
+  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, statementProofContext),
         conclusionMatches = statementNodeMatches; ///
 
   return conclusionMatches;
 }
 
-function metaMatchPremise(premise, metaproofSteps, substitutions) {
+function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementMetaproofContext) {
   const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
     const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode()
 
     if (ruleSubproofNode !== null) {
-      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions);
+      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetaproofContext);
 
       if (!ruleSubProofNodeMatches) {  ///
         return true;
@@ -239,7 +244,7 @@ function metaMatchPremise(premise, metaproofSteps, substitutions) {
     }
 
     if (metastatementNode !== null) {
-      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions);
+      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext);
 
       if (!metastatementNodeMatches) {  ///
         return true;
@@ -252,9 +257,9 @@ function metaMatchPremise(premise, metaproofSteps, substitutions) {
   return premiseMatches;
 }
 
-function metaMatchPremises(premise, metaproofSteps, substitutions) {
+function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext, metastatementMetaproofContext) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions);
+    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementMetaproofContext);
 
     if (premiseMatches) {
       return true;
@@ -264,8 +269,8 @@ function metaMatchPremises(premise, metaproofSteps, substitutions) {
   return premisesMatch;
 }
 
-function metaMatchConclusion(conclusion, metastatementNode, substitutions) {
-  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions),
+function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, metastatementMetaproofContext) {
+  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext),
         conclusionMatches = metastatementNodeMatches; ///
 
   return conclusionMatches;

package/src/ruleNames.js

@@ -3,14 +3,17 @@
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
+export const VARIABLE_RULE_NAME = "variable";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
 export const STATEMENT_RULE_NAME = "statement";
+export const META_TYPE_RULE_NAME = "meta-type";
+export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
-export const CONSTRUCTOR_DECLARATIONRULE_NAME = "constructorDeclaration";
+export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/supposition.js

@@ -19,7 +19,7 @@ export default class Supposition {
     return this.statementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions) {
+  matchSubproofNode(subproofNode, substitutions, proofContext, statementProofContext) {
     let subproofNodeMatches = false;
 
     const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
@@ -40,7 +40,9 @@ export default class Supposition {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = subproofAssertionStatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                proofContextA = proofContext, ///
+                proofContextB = statementProofContext,  ///
+                nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -52,10 +54,12 @@ export default class Supposition {
     return subproofNodeMatches;
   }
 
-  matchStatementNode(statementNode, substitutions) {
+  matchStatementNode(statementNode, substitutions, proofContext, statementProofContext) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          proofContextA = proofContext, ///
+          proofContextB = statementProofContext,  ///
+          nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
@@ -71,11 +75,11 @@ export default class Supposition {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     const { statement } = json,
           statementString = statement,  ///
-          lexer = context.getLexer(),
-          parser = context.getParser(),
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           supposition = new Supposition(statementNode);
 

package/src/theorem.js

@@ -7,7 +7,7 @@ import { THEOREM_KIND } from "./kinds";
 export default class Theorem extends AxiomLemmaTheoremConjecture {
   static kind = THEOREM_KIND;
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
+  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Theorem, json, fileContext); }
 
-  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
+  static fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequenceAndProofContext(Theorem, labels, suppositions, consequence, proofContext); }
 }

package/src/type.js

@@ -133,14 +133,14 @@ export default class Type {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     let type;
 
     let { superType } = json;
 
     const superTypeJSON = superType;  ///
 
-    superType = superTypeFromSuperTypeJSON(superTypeJSON, context);
+    superType = superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext);
 
     const { name } = json;
 
@@ -190,7 +190,7 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSON(superTypeJSON, context) {
+function superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext) {
   let superType;
 
   const json = superTypeJSON, ///
@@ -200,11 +200,11 @@ function superTypeFromSuperTypeJSON(superTypeJSON, context) {
     superType = objectType; ///
   } else {
     const typeName = name,  ///
-          type = context.findTypeByTypeName(typeName);
+          type = fileContext.findTypeByTypeName(typeName);
 
     superType = (type !== null) ?
                   type :  ///
-                    Type.fromJSON(json, context);  ///
+                    Type.fromJSONAndFileContext(json, fileContext);  ///
   }
 
   return superType;

package/src/utilities/node.js

@@ -4,7 +4,13 @@ import { rewriteNodes } from "occam-grammar-utilities";
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
-import { LABEL_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATIONRULE_NAME } from "../ruleNames";
+import { TYPE_RULE_NAME,
+         LABEL_RULE_NAME,
+         VARIABLE_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         UNQUALIFIED_STATEMENT_RULE_NAME,
+         CONSTRUCTOR_DECLARATION_RULE_NAME,
+         UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 
@@ -16,11 +22,13 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
+      typeNodeQuery = nodeQuery("/variableDeclaration/type!"),
+      variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
 export function termNodeFromTermString(termString, lexer, parser) {
-  const ruleName = CONSTRUCTOR_DECLARATIONRULE_NAME,
+  const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
         content = `Constructor ${termString}
 `,
         node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
@@ -39,6 +47,28 @@ export function labelNodeFromLabelString(labelString, lexer, parser) {
   return labelNode;
 }
 
+export function typeNodeFromVariableString(variableString, lexer, parser) {
+  const ruleName = TYPE_RULE_NAME,
+        content = `Variable ${variableString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        typeDeclarationNode = node, ///
+        typeNode = typeNodeQuery(typeDeclarationNode);
+
+  return typeNode;
+}
+
+export function variableNodeFromVariableString(variableString, lexer, parser) {
+  const ruleName = VARIABLE_RULE_NAME,
+        content = `Variable ${variableString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        variableDeclarationNode = node, ///
+        variableNode = variableNodeQuery(variableDeclarationNode);
+
+  return variableNode;
+}
+
 export function statementNodeFromStatementString(statementString, lexer, parser) {
   const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
         content = `${statementString}

package/src/utilities/query.js

@@ -3,6 +3,7 @@
 import { Query } from "occam-dom";
 
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
       labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
       variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
       referenceNameTerminalNodeQuery = nodeQuery("/reference/@name"),
@@ -57,6 +58,19 @@ export function labelNameFromLabelNode(labelNode) {
   return labelName;
 }
 
+export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
+  let metaTypeName = null;
+
+  if (metaTypeNode !== null) {
+    const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+          metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent();
+
+    metaTypeName = metaTypeTerminalNodeContent; ///
+  }
+
+  return metaTypeName;
+}
+
 export function variableNameFromVariableNode(variableNode) {
   const variableNameTerminalNode = variableNameTerminalNodeQuery(variableNode),
         variableNameTerminalNodeContent = variableNameTerminalNode.getContent(),

package/src/variable.js

@@ -1,19 +1,19 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name) {
-    this.type = type;
+  constructor(name, type) {
     this.name = name;
-  }
-
-  getType() {
-    return this.type;
+    this.type = type;
   }
 
   getName() {
     return this.name;
   }
 
+  getType() {
+    return this.type;
+  }
+
   matchName(name) {
     const matchesName = (this.name === name);
 
@@ -27,8 +27,12 @@ export default class Variable {
     return string;
   }
 
-  static fromTypeAndName(type, name) {
-    const variable = new Variable(type, name);
+  static fromJSONAndFileContext(json, fileContext) {
+    debugger
+  }
+
+  static fromNameAndType(name, type) {
+    const variable = new Variable(name, type);
 
     return variable;
   }

package/src/verifier/metastatementForMetavariable.js

@@ -10,7 +10,7 @@ import { metavariableNameFromMetavariableNode } from "../utilities/query";
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
 export default class MetastatementForMetavariableVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -23,28 +23,28 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               metastatementNodeB = nonTerminalNodeB,  ///
-              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
+              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB);
 
         if (metastatementNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions) {
+  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB) {
     let metastatementNodeVerified = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
+      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB);
 
       metastatementNodeVerified = metaVariableNodeVerified; ///
     }
@@ -52,7 +52,7 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
     return metastatementNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions) {
+  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB) {
     let metavariableNodeVerified;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),

package/src/verifier/statementForMetavariable.js

@@ -11,7 +11,7 @@ const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
 export default class StatementForMetavariableVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
@@ -23,7 +23,7 @@ export default class StatementForMetavariableVerifier extends Verifier {
 
       nonTerminalNodeB = metaArgumentChildNodeB;  ///
 
-      nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);
     } else {
       const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
             nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
@@ -33,7 +33,7 @@ export default class StatementForMetavariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               statementNodeB = nonTerminalNodeB,  ///
-              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions);
+              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, proofContextB);
 
         if (statementNodeVerified) {
           nonTerminalNodeVerified = true;  ///
@@ -42,25 +42,25 @@ export default class StatementForMetavariableVerifier extends Verifier {
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
                 nodesA = nonTerminalNodeAChildNodes, ///
                 nodesB = nonTerminalNodeBChildNodes, ///
-                nodesMatch = this.verifyNodes(nodesA, nodesB, substitutions);
+                nodesMatch = this.verifyNodes(nodesA, nodesB, substitutions, fileContextA, proofContextB);
 
           nonTerminalNodeVerified = nodesMatch;  ///
         }
       } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions) {
+  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, proofContextB) {
     let statementNodeVerified = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
+      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, proofContextB);
 
       statementNodeVerified = metavariableNodeVerified; ///
     }
@@ -68,7 +68,7 @@ export default class StatementForMetavariableVerifier extends Verifier {
     return statementNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
+  verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, proofContextB) {
     let metavariableNodeVerified;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),