occam-verify-cli 0.0.682 → 0.0.684

package/src/rule.js

@@ -44,27 +44,27 @@ export default class Rule {
     return labelNameMatches;
   }
 
-  matchStatement(statementNode, statementProofContext) {
+  matchStatement(statementNode, statementLocalContext) {
     let statementNatches;
 
     const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
       const substitutions = [],
-            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementProofContext);
+            conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
 
       statementNatches = conclusionMatches; ///
     } else {
-      const proofSteps = statementProofContext.getProofSteps();
+      const proofSteps = statementLocalContext.getProofSteps();
 
       statementNatches = someSubArray(proofSteps, premisesLength, (proofSteps) => {
         let premisesMatchConclusion = false;
 
         const substitutions = [],
-              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, statementProofContext);
+              premisesMatch = matchPremises(this.premises, proofSteps, substitutions, this.fileContext, statementLocalContext);
 
         if (premisesMatch) {
-          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementProofContext);
+          const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, statementLocalContext);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -78,27 +78,27 @@ export default class Rule {
     return statementNatches;
   }
 
-  matchMetastatement(metastatementNode, metastatementMetaproofContext) {
+  matchMetastatement(metastatementNode, metastatementLocalMetaContext) {
     let metastatementNatches;
 
     const premisesLength = this.premises.length;
 
     if (premisesLength === 0) {
       const substitutions = [],
-            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementMetaproofContext);
+            conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementLocalMetaContext);
 
       metastatementNatches = conclusionMatches; ///
     } else {
-      const metaproofSteps = metastatementMetaproofContext.getMetaproofSteps();
+      const metaproofSteps = metastatementLocalMetaContext.getMetaproofSteps();
 
       metastatementNatches = someSubArray(metaproofSteps, premisesLength, (metaproofSteps) => {
         let premisesMatchConclusion = false;
 
         const substitutions = [],
-              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, metastatementMetaproofContext);
+              premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, metastatementLocalMetaContext);
 
         if (premisesMatch) {
-          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementMetaproofContext);
+          const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, metastatementLocalMetaContext);
 
           premisesMatchConclusion = conclusionMatches;  ///
         }
@@ -181,13 +181,13 @@ export default class Rule {
   }
 }
 
-function matchPremise(premise, proofSteps, substitutions, fileContext, statementProofContext) {
+function matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
   const proofStep = prune(proofSteps, (proofStep) => {
     const subproofNode = proofStep.getSubproofNode(),
           statementNode = proofStep.getStatementNode()
 
     if (subproofNode !== null) {
-      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, statementProofContext);
+      const subProofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, statementLocalContext);
 
       if (!subProofNodeMatches) {  ///
         return true;
@@ -195,7 +195,7 @@ function matchPremise(premise, proofSteps, substitutions, fileContext, statement
     }
 
     if (statementNode !== null) {
-      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementProofContext);
+      const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext);
 
       if (!statementNodeMatches) {  ///
         return true;
@@ -208,9 +208,9 @@ function matchPremise(premise, proofSteps, substitutions, fileContext, statement
   return premiseMatches;
 }
 
-function matchPremises(premise, proofSteps, substitutions, fileContext, statementProofContext) {
+function matchPremises(premise, proofSteps, substitutions, fileContext, statementLocalContext) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, statementProofContext);
+    const premiseMatches = matchPremise(premise, proofSteps, substitutions, fileContext, statementLocalContext);
 
     if (premiseMatches) {
       return true;
@@ -220,20 +220,20 @@ function matchPremises(premise, proofSteps, substitutions, fileContext, statemen
   return premisesMatch;
 }
 
-function matchConclusion(conclusion, statementNode, substitutions, fileContext, statementProofContext) {
-  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, statementProofContext),
+function matchConclusion(conclusion, statementNode, substitutions, fileContext, statementLocalContext) {
+  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext),
         conclusionMatches = statementNodeMatches; ///
 
   return conclusionMatches;
 }
 
-function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementMetaproofContext) {
+function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext) {
   const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
     const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
           metastatementNode = metaproofStep.getMetastatementNode()
 
     if (ruleSubproofNode !== null) {
-      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetaproofContext);
+      const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementLocalMetaContext);
 
       if (!ruleSubProofNodeMatches) {  ///
         return true;
@@ -241,7 +241,7 @@ function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, m
     }
 
     if (metastatementNode !== null) {
-      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext);
+      const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext);
 
       if (!metastatementNodeMatches) {  ///
         return true;
@@ -254,9 +254,9 @@ function metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, m
   return premiseMatches;
 }
 
-function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext, metastatementMetaproofContext) {
+function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext) {
   const premisesMatch = premise.every((premise) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementMetaproofContext);
+    const premiseMatches = metaMatchPremise(premise, metaproofSteps, substitutions, fileContext, metastatementLocalMetaContext);
 
     if (premiseMatches) {
       return true;
@@ -266,8 +266,8 @@ function metaMatchPremises(premise, metaproofSteps, substitutions, fileContext,
   return premisesMatch;
 }
 
-function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, metastatementMetaproofContext) {
-  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetaproofContext),
+function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
+  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext),
         conclusionMatches = metastatementNodeMatches; ///
 
   return conclusionMatches;

package/src/supposition.js

@@ -20,7 +20,7 @@ export default class Supposition {
     return this.statementNode;
   }
 
-  matchSubproofNode(subproofNode, substitutions, proofContext, statementProofContext) {
+  matchSubproofNode(subproofNode, substitutions, localContext, statementLocalContext) {
     let subproofNodeMatches = false;
 
     const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
@@ -41,9 +41,9 @@ export default class Supposition {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = subproofAssertionStatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                proofContextA = proofContext, ///
-                proofContextB = statementProofContext,  ///
-                nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, () => {
+                localContextA = localContext, ///
+                localContextB = statementLocalContext,  ///
+                nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -59,12 +59,12 @@ export default class Supposition {
     return subproofNodeMatches;
   }
 
-  matchStatementNode(statementNode, substitutions, proofContext, statementProofContext) {
+  matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          proofContextA = proofContext, ///
-          proofContextB = statementProofContext,  ///
-          nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, () => {
+          localContextA = localContext, ///
+          localContextB = statementLocalContext,  ///
+          nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/term.js

@@ -0,0 +1,30 @@
+"use strict";
+
+export default class Term {
+  constructor(node, type) {
+    this.node = node;
+    this.type = type;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  match(term) {
+    const node = term.getNode(),
+          matches = this.node.match(node);
+
+    return matches;
+  }
+
+  static fromTermNodeAndType(termNode, type) {
+    const node = termNode,  ///
+          term = new Term(node, type);
+
+    return term;
+  }
+}

package/src/theorem.js

@@ -5,5 +5,5 @@ import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 export default class Theorem extends AxiomLemmaTheoremConjecture {
   static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Theorem, json, fileContext); }
 
-  static fromLabelsSuppositionsConsequentAndProofContext(labels, suppositions, consequent, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndProofContext(Theorem, labels, suppositions, consequent, proofContext); }
+  static fromLabelsSuppositionsConsequentAndLocalContext(labels, suppositions, consequent, localContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequentAndLocalContext(Theorem, labels, suppositions, consequent, localContext); }
 }

package/src/type.js

@@ -74,13 +74,13 @@ export default class Type {
     return equalToOrSuperTypeOf;
   }
 
-  isEqualToOrSubTypeOfOfSuperTypeOf(type) {
+  isEqualToSubTypeOfOrSuperTypeOf(type) {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
           superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSubTypeOfOfSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
+          equalToOrSubTypeOfSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
 
-    return equalToOrSubTypeOfOfSuperTypeOf;
+    return equalToOrSubTypeOfSuperTypeOf;
   }
 
   match(type) {

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { first, second, last, push, prune, filter, clear } = arrayUtilities;
+export const { first, second, last, push, prune, filter, compress } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;

package/src/utilities/collection.js

@@ -0,0 +1,83 @@
+"use strict";
+
+import { compress } from "../utilities/array";
+
+export function mergeCollections(collectionsA, collectionsB) {
+  const typesA = typesFromCollections(collectionsA),
+        typesB = typesFromCollections(collectionsB),
+        types = [
+          ...typesA,
+          ...typesB
+        ];
+
+  compress(types, (typeA, typeB) => {
+    if (typeA === typeB) {
+      return true;
+    }
+  });
+
+  const collections = types.map((type) => {
+    let collection;
+
+    const collectionA = findCollectionByType(collectionsA, type),
+          collectionB = findCollectionByType(collectionsB, type);
+
+    if ((collectionA !== null) && (collectionB !== null)) {
+      collection = Collection.fromCollections(collectionA, collectionB);
+    } else if (collectionA !== null) {
+      collection = collectionA; ///
+    } else if (collectionB !== null) {
+      collection = collectionB; ///
+    }
+
+    return collection;
+  });
+
+  return collections;
+}
+
+export function findCollectionByType(collections, type) {
+  const collection = collections.find((collection) => {
+    const collectionMatchesType = collection.matchType(type);
+
+    if (collectionMatchesType) {
+      return true;
+    }
+  }) || null;
+
+  return collection;
+}
+
+export function findCollectionByTerm(collections, term) {
+  const collection = collections.find((collection) => {
+    const collectionMatchesTerm = collection.matchTerm(term);
+
+    if (collectionMatchesTerm) {
+      return true;
+    }
+  }) || null;
+
+  return collection;
+}
+
+export function findCollectionByTerms(collections, terms) {
+  const collection = collections.find((collection) => {
+    const collectionMatchesTerms = collection.matchTerms(terms);
+
+    if (collectionMatchesTerms) {
+      return true;
+    }
+  }) || null;
+
+  return collection;
+}
+
+function typesFromCollections(collections) {
+  const types = collections.map((collection) => {
+    const type = collection.getType();
+
+    return type;
+  });
+
+  return types;
+}

package/src/verifier/node/metastatement.js

@@ -6,7 +6,7 @@ import { METAVARIABLE_RULE_NAME } from "../../ruleNames";
 import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 
 class MetastatementNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, metaproofContext, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const ruleName = nonTerminalNode.getRuleName(); ///
@@ -14,7 +14,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
     switch (ruleName) {
       case METAVARIABLE_RULE_NAME: {
         const metavariableNode = nonTerminalNode, ///
-              metavariableVerified = verifyMetavariable(metavariableNode, metaproofContext, verifyAhead),
+              metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext, verifyAhead),
               metavariableNodeVerified = metavariableVerified;  ///
 
         nonTerminalNodeVerified = metavariableNodeVerified; ///
@@ -23,7 +23,7 @@ class MetastatementNodeVerifier extends NodeVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, metaproofContext, verifyAhead);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
 
         break;
       }
@@ -37,15 +37,15 @@ const metastatementNodeVerifier = new MetastatementNodeVerifier();
 
 export default metastatementNodeVerifier;
 
-function verifyMetavariable(metavariableNode, metaproofContext, verifyAhead) {
+function verifyMetavariable(metavariableNode, localMetaContext, verifyAhead) {
   let metavariableVerified;
 
-  const metavariableString = metaproofContext.nodeAsString(metavariableNode);
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
 
-  metaproofContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
   const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
+        metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableName(metavariableName);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();
@@ -54,7 +54,7 @@ function verifyMetavariable(metavariableNode, metaproofContext, verifyAhead) {
   }
 
   if (metavariableVerified) {
-    metaproofContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
   }
 
   return metavariableVerified;

package/src/verifier/node/termAsConstructor.js

@@ -58,9 +58,9 @@ export function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {
 
   fileContext.trace(`Verifying the '${termString}' standalone term...`, termNode);
 
-  const types = [],
+  const terms = [],
         context = fileContext,  ///
-        termVerified = verifyTerm(termNode, types, context, verifyAhead);
+        termVerified = verifyTerm(termNode, terms, context, verifyAhead);
 
   standaloneTermVerified = termVerified;  ///
 

package/src/verifier/nodes/metastatementForMetavariable.js

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

package/src/verifier/nodes/statementForMetavariable.js

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

package/src/verifier/nodes/term.js

@@ -76,13 +76,14 @@ export function verifyArgument(argumentNode, constructorArgumentNode, context, v
 
       if (constructorTypeNode !== null) {
         const { verifyTerm } = termNodesVerifier,
-              types = [],
-              termVerified = verifyTerm(termNode, types, context, () => {
+              terms = [],
+              termVerified = verifyTerm(termNode, terms, context, () => {
                 let verifiedAhead = false;
 
                 const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
-                      firstType = first(types),
-                      termType = firstType, ///
+                      firstTerm = first(terms),
+                      term = firstTerm, ///
+                      termType = term.getType(),
                       constructorType = context.findTypeByTypeName(constructorTypeName),
                       termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
 

package/src/verifier/nodes/termForVariable.js

@@ -12,7 +12,7 @@ import { variableNameFromVariableNode } from "../../utilities/query";
 const variableNodeQuery = nodeQuery('/term/variable!');
 
 export default class TermForVariableNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -25,28 +25,28 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
       if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
         const termNodeA = nonTerminalNodeA,  ///
               termNodeB = nonTerminalNodeB,  ///
-              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
+              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         if (termNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
+  verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let termNodeVerified = false;
 
     const variableNodeA = variableNodeQuery(termNodeA);
 
     if (variableNodeA !== null) {
-      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead);
+      const variableVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
       termNodeVerified = variableVerified; ///
     }
@@ -54,7 +54,7 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
     return termNodeVerified;
   }
 
-  verifyVariableNode(variableNodeA, termNodeB, substitutions, proofContextA, proofContextB, verifyAhead) {
+  verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let variableVerified = false;
 
     const variableNameA = variableNameFromVariableNode(variableNodeA),
@@ -80,18 +80,19 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
 
       if (createSubstitutions) {
         const variableName = variableNameA, ///
-              proofContext = proofContextA, ///
-              variable = proofContext.findVariableByVariableName(variableName);
+              localContext = localContextA, ///
+              variable = localContext.findVariableByVariableName(variableName);
 
         if (variable !== null) {
-          const types = [],
-                context = proofContextB, ///
+          const terms = [],
+                context = localContextB, ///
                 termNode = termNodeB, ///
-                termVerified = verifyTerm(termNode, types, context, () => {
+                termVerified = verifyTerm(termNode, terms, context, () => {
                   let verifiedAhead = false;
 
-                  const firstType = first(types),
-                        termType = firstType,
+                  const firstTerm = first(terms),
+                        term = firstTerm, ///
+                        termType = term.getType(),
                         variableType = variable.getType(),
                         variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);