occam-verify-cli 0.0.538 → 0.0.539

package/src/premise.js

@@ -22,7 +22,7 @@ export default class Premise {
     return this.metastatementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions) {
+  matchSubproofNode(subproofNode, substitutions, fileContext, statementProofContext) {
     let subproofNodeMatches = false;
 
     const subproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -43,7 +43,9 @@ export default class Premise {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                fileContextA = fileContext, ///
+                proofContextB = statementProofContext,  ///
+                nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -55,16 +57,18 @@ export default class Premise {
     return subproofNodeMatches;
   }
 
-  matchStatementNode(statementNode, substitutions) {
+  matchStatementNode(statementNode, substitutions, fileContext, statementProofContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          fileContextA = fileContext, ///
+          proofContextB = statementProofContext,  ///
+          nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, substitutions) {
+  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetaproofContext) {
     let ruleSubproofNodeMatches = false;
 
     const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -85,7 +89,9 @@ export default class Premise {
           const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                fileContextA = fileContext, ///
+                metaproofContextB = metastatementMetaproofContext,  ///
+                nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -97,10 +103,12 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          fileContextA = fileContext, ///
+          metaproofContextB = metastatementMetaproofContext,  ///
+          nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB),
           metastatementNodeMatches = nonTerminalNodeVerified; ///
 
     return metastatementNodeMatches;

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;  ///
         }
@@ -172,20 +177,20 @@ export default class Rule {
     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/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;

package/src/theorem.js

@@ -9,5 +9,5 @@ export default class Theorem extends AxiomLemmaTheoremConjecture {
 
   static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, context); }
 
-  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/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,8 @@ export default class Variable {
     return string;
   }
 
-  static fromTypeAndName(type, name) {
-    const variable = new Variable(type, name);
+  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),

package/src/verifier/termForVariable.js

@@ -3,14 +3,16 @@
 import Verifier from "../verifier";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
+import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 import { TERM_RULE_NAME } from "../ruleNames";
 import { variableNameFromVariableNode } from "../utilities/query";
+import { verifyTermAgainstConstructors } from "../verify/term";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
 export default class TermForVariableVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -23,28 +25,28 @@ export default class TermForVariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
         const termNodeA = nonTerminalNodeA,  ///
               termNodeB = nonTerminalNodeB,  ///
-              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions);
+              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB);
 
         if (termNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, substitutions) {
+  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB) {
     let termNodeVerified = false;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions);
+      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB);
 
       termNodeVerified = variableVerified; ///
     }
@@ -52,7 +54,7 @@ export default class TermForVariableVerifier extends Verifier {
     return termNodeVerified;
   }
 
-  verifyVariableNode(variableNodeB, termNodeB, substitutions) {
+  verifyVariableNode(variableNodeB, termNodeB, substitutions, proofContextA, proofContextB) {
     let variableVerified;
 
     const variableNameA = variableNameFromVariableNode(variableNodeB),
@@ -74,14 +76,32 @@ export default class TermForVariableVerifier extends Verifier {
 
       if (createSubstitutions) {
         const variableName = variableNameA, ///
-              termNode = termNodeB, ///
-              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
-              substitution = termForVariableSubstitution;  ///
+              proofContext = proofContextA, ///
+              variable = proofContext.findVariableByVariableName(variableName);
 
-        substitutions.push(substitution);
-      }
+        if (variable !== null) {
+          const types = [],
+                context = proofContextB, ///
+                termNode = termNodeB, ///
+                termVerified = verifyTermAgainstConstructors(termNodeB, types, context);
+
+          if (termVerified) {
+            const firstType = first(types),
+                  termType = firstType,
+                  variableType = variable.getType(),
+                  variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+
+            if (variableTypeEqualToOrSuperTypeOfTermType) {
+              const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+                    substitution = termForVariableSubstitution;  ///
+
+              substitutions.push(substitution);
 
-      variableVerified = true;
+              variableVerified = true;
+            }
+          }
+        }
+      }
     }
 
     return variableVerified;

package/src/verify/assertion/type.js

@@ -85,9 +85,9 @@ function verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, co
 
           context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
         } else {
-          const type = assertedType,  ///
-                name = variableName,  ///
-                variable = Variable.fromTypeAndName(type, name),
+          const name = variableName,  ///
+                type = assertedType,  ///
+                variable = Variable.fromNameAndType(name, type),
                 assignment = Assignment.fromVariable(variable);
 
           assignments.push(assignment);

package/src/verify/axiom.js

@@ -44,7 +44,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
       if (consequenceVerified) {
         const firstConsequence = first(consequences),
               consequence = firstConsequence, ///
-              axiom = Axiom.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+              axiom = Axiom.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
         fileContext.addAxiom(axiom);
 

package/src/verify/conjecture.js

@@ -9,6 +9,7 @@ import verifyConsequence from "./consequence";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import proof from "../context/proof";
 
 const proofNodeQuery = nodeQuery("/conjecture/proof!"),
       labelNodesQuery = nodesQuery("/conjecture/label"),
@@ -50,7 +51,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
 
         verifyProof(proofNode, consequence, proofContext);
 
-        const conjecture = Conjecture.fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence);
+        const conjecture = Conjecture.fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext);
 
         fileContext.addConjecture(conjecture);
 

package/src/verify/declaration/metavariable.js

@@ -0,0 +1,20 @@
+"use strict";
+
+import verifyMetavariable from "../../verify/metavariable";
+
+import { nodeQuery } from "../../utilities/query";
+
+const metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
+      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable");
+
+export default function verifyMetavariableDeclaration(metavariableDeclarationNode, fileContext) {
+  let metavariableDeclarationVerified;
+
+  const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
+        metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
+        metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
+
+  metavariableDeclarationVerified = metavariableVVerified;  ///
+
+  return metavariableDeclarationVerified;
+}