occam-verify-cli 0.0.1089 → 0.0.1091

package/src/judgement.js

@@ -31,26 +31,26 @@ class Judgement {
 
   matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified;
 
     const judgementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${judgementString}' judgement...`);
+    context.trace(`Verifying the '${judgementString}' judgement...`);
 
-    const frameVerified = this.frame.verify(assignments, stated, localContext);
+    const frameVerified = this.frame.verify(assignments, stated, context);
 
     if (frameVerified) {
-      const declarationVerified = this.declaration.verify(assignments, stated, localContext);
+      const declarationVerified = this.declaration.verify(assignments, stated, context);
 
       if (declarationVerified) {
         let verifiedWhenStated = false,
             verifiedWhenDerived = false;
 
         if (stated) {
-          verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+          verifiedWhenStated = this.verifyWhenStated(assignments, context);
         } else {
-          verifiedWhenDerived = this.verifyWhenDerived(assignments, localContext);
+          verifiedWhenDerived = this.verifyWhenDerived(assignments, context);
         }
 
         if (verifiedWhenStated || verifiedWhenDerived) {
@@ -60,18 +60,18 @@ class Judgement {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${judgementString}' judgement.`);
+      context.debug(`...verified the '${judgementString}' judgement.`);
     }
 
     return verified;
   }
 
-  verifyWhenStated(assignments, localContext) {
+  verifyWhenStated(assignments, context) {
     let verifiedWhenStated;
 
     const judgementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${judgementString}' judgement when stated...`);
+    context.trace(`Verifying the '${judgementString}' judgement when stated...`);
 
     if (assignments !== null) {
       const judgement = this, ///
@@ -84,27 +84,27 @@ class Judgement {
     verifiedWhenStated = true;
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${judgementString}' judgement when stated.`);
+      context.debug(`...verified the '${judgementString}' judgement when stated.`);
     }
 
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(assignments, localContext) {
+  verifyWhenDerived(assignments, context) {
     let verifiedWhenDerived = false;
 
     const judgementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${judgementString}' judgement when derived...`);
+    context.trace(`Verifying the '${judgementString}' judgement when derived...`);
 
     if (!verifiedWhenDerived) {
       const reference = this.declaration.getReference(),
-            metaLemma = localContext.findMetaLemmaByReference(reference),
-            metatheorem = localContext.findMetatheoremByReference(reference),
+            metaLemma = context.findMetaLemmaByReference(reference),
+            metatheorem = context.findMetatheoremByReference(reference),
             metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
       if (metaLemmaMetatheorem !== null) {
-        const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, localContext);
+        const metaLemmaMetatheoremUnified = this.frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem, context);
 
         verifiedWhenDerived = metaLemmaMetatheoremUnified; ///
       }
@@ -112,27 +112,27 @@ class Judgement {
 
     if (!verifiedWhenDerived) {
       const reference = this.declaration.getReference(),
-            axiom = localContext.findAxiomByReference(reference),
-            lemma = localContext.findLemmaByReference(reference),
-            theorem = localContext.findTheoremByReference(reference),
-            conjecture = localContext.findConjectureByReference(reference),
+            axiom = context.findAxiomByReference(reference),
+            lemma = context.findLemmaByReference(reference),
+            theorem = context.findTheoremByReference(reference),
+            conjecture = context.findConjectureByReference(reference),
             axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture);
 
       if (axiomLemmaTheoremOrConjecture !== null) {
-        const axiomLemmaTheoremOrConjectureUnified = this.frame.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, localContext);
+        const axiomLemmaTheoremOrConjectureUnified = this.frame.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, context);
 
         verifiedWhenDerived = axiomLemmaTheoremOrConjectureUnified; ///
       }
     }
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the '${judgementString}' judgement when derived.`);
+      context.debug(`...verified the '${judgementString}' judgement when derived.`);
     }
 
     return verifiedWhenDerived;
   }
 
-  static fromJudgementNode(judgementNode, localContext) {
+  static fromJudgementNode(judgementNode, context) {
     let judgement = null;
 
     if (judgementNode !== null) {
@@ -140,9 +140,9 @@ class Judgement {
             frameNode = frameNodeQuery(judgementNode),
             declarationNode = declarationNodeQuery(judgementNode),
             node = judgementNode, ///
-            string = localContext.nodeAsString(node),
-            frame = Frame.fromFrameNode(frameNode, localContext),
-            declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
+            frame = Frame.fromFrameNode(frameNode, context),
+            string = context.nodeAsString(node),
+            declaration = Declaration.fromDeclarationNode(declarationNode, context);
 
       judgement = new Judgement(string, frame, declaration);
     }

package/src/label.js

@@ -2,6 +2,7 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
+import intrinsicLevelUnifier from "./unifier/intrinsicLevel";
 
 import { nodeQuery } from "./utilities/query";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
@@ -21,6 +22,19 @@ class Label {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
+  unifyReference(reference, generalContext, specificContext) {
+    const { Substitutions } = shim,
+          metavariableNode = this.metavariable.getNode(),
+          referenceMetavariable = reference.getMetavariable(),
+          referenceMetavariableNode = referenceMetavariable.getNode(),
+          metavariableNodeA = referenceMetavariableNode,  ///
+          metavariableNodeB = metavariableNode, ///
+          substitutions = Substitutions.fromNothing(),
+          metavariableUnified = intrinsicLevelUnifier.unify(metavariableNodeA, metavariableNodeB, substitutions, generalContext, specificContext);
+
+    return metavariableUnified;
+  }
+
   verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;
 

package/src/metaType.js

@@ -63,7 +63,7 @@ class MetaType {
     return metaType;
   }
 
-  static fromMetaTypeNode(metaTypeNode, localContext) {
+  static fromMetaTypeNode(metaTypeNode, context) {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
           metaType = metaTypeFromMetaTypeName(metaTypeName);
 

package/src/metavariable.js

@@ -71,14 +71,14 @@ class Metavariable {
     return metavariableNodeMatches;
   }
 
-  unifyFrame(frame, substitutions, localContext) {
+  unifyFrame(frame, substitutions, generalContext, specificContext) {
     let frameUnified = false;
 
     const frameNode = frame.getNode(),
           frameString = frame.getString(),
           metavariableString = this.string; ///
 
-    localContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
+    specificContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
     const metavariableNode = this.node, ///
           simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableNode(metavariableNode);
@@ -93,30 +93,31 @@ class Metavariable {
       }
     } else {
       const metavariableNode = this.node,  ///
-            metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
-            frameMetavariable  = frameMetavariableFromStatementNode(frameNode, localContext);
+            metavariable = metavariableFromMetavariableNode(metavariableNode, generalContext, specificContext),
+            frameMetavariable  = frameMetavariableFromStatementNode(frameNode, generalContext, specificContext);
 
-      if (metavariable === frameMetavariable) {
+      if ((metavariable !== null) && (metavariable === frameMetavariable)) {
         frameUnified = true;
       } else {
         const metavariable = this,  ///
-              frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameAndMetavariable(frame, metavariable, localContext),
+              context = specificContext, ///
+              frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
               substitution = frameForMetavariableSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, localContext);
+        substitutions.addSubstitution(substitution, context);
 
         frameUnified = true;
       }
     }
 
     if (frameUnified) {
-      localContext.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
+      specificContext.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
     }
 
     return frameUnified;
   }
 
-  unifyStatement(statement, substitution, substitutions, localContext) {
+  unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
     let statementUnified = false;
 
     const statementString = statement.getString(),
@@ -125,7 +126,7 @@ class Metavariable {
                                   substitution.getString() :
                                     EMPTY_STRING;
 
-    localContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
@@ -143,68 +144,69 @@ class Metavariable {
       }
     } else {
       const metavariableNode = this.node,  ///
-            metavariable = metavariableFromMetavariableNode(metavariableNode, localContext),
-            statementMetavariable = statementMetavariableFromStatementNode(statementNode, localContext);
+            metavariable = metavariableFromMetavariableNode(metavariableNode, generalContext, specificContext),
+            statementMetavariable = statementMetavariableFromStatementNode(statementNode, generalContext, specificContext);
 
       if ((metavariable !== null) && (metavariable === statementMetavariable)) {
         statementUnified = true;
       } else {
-        const metavariable = this,  ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+        const context = specificContext, ///
+              metavariable = this,  ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context);
 
         substitution = statementForMetavariableSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, localContext);
+        substitutions.addSubstitution(substitution, context);
 
         statementUnified = true;
       }
     }
 
     if (statementUnified) {
-      localContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
     }
 
     return statementUnified;
   }
 
-  unifySubstitution(substitution, localContext) {
+  unifySubstitution(substitution, context) {
     let substitutionUnified = false;
 
     const metavariableString = this.string,  ///
           substitutionString = substitution.getString();
 
-    localContext.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
+    context.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
 
     const metavariableNode = this.node, ///
-          judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
+          judgement = context.findJudgementByMetavariableNode(metavariableNode);
 
     if (judgement !== null){
       const declaration = judgement.getDeclaration();
 
-      substitutionUnified = declaration.unifySubstitution(substitution, localContext);
+      substitutionUnified = declaration.unifySubstitution(substitution, context);
     }
 
     if (substitutionUnified) {
-      localContext.debug(`...unified the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
+      context.debug(`...unified the '${substitutionString}' substitution with the '${metavariableString}' metavariable.`);
     }
 
     return substitutionUnified;
   }
 
-  verify(localContext) {
+  verify(context) {
     let verified;
 
     const metavariableString = this.string; ///
 
-    localContext.trace(`Verifying the '${metavariableString}' metavariable...`);
+    context.trace(`Verifying the '${metavariableString}' metavariable...`);
 
     const metavariableNode = this.node,
-          metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
+          metavariablePresent = context.isMetavariablePresentByMetavariableNode(metavariableNode);
 
     verified = metavariablePresent; ///
 
     if (verified) {
-      localContext.debug(`...verified the '${metavariableString}' metavariable.`);
+      context.debug(`...verified the '${metavariableString}' metavariable.`);
     }
 
     return verified;
@@ -227,9 +229,7 @@ class Metavariable {
       const termNode = termNodeQuery(this.node);
 
       if (termNode !== null) {
-        const termString = this.fileContext.nodeAsString(termNode);
-
-        this.fileContext.debug(`The '${termString}' term was found when a type should have been present.`);
+        this.fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
       } else {
         const typeNode = typeNodeQuery(this.node);
 
@@ -255,16 +255,18 @@ class Metavariable {
     return verifiedAtTopLevel;
   }
 
-  verifyGivenMetaType(metaType, localContext) {
+  verifyGivenMetaType(metaType, context) {
     let verifiedGivenMetaType = false;
 
     const metavariableString = this.string,  ///
           metaTypeString = metaType.getString();
 
-    localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
+    context.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
     const metavariableNode = this.node,  ///
-          metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+          specificContext = context,  ///
+          generalContext = context, ///
+          metavariable = generalContext.findMetavariableByMetavariableNode(metavariableNode, specificContext);
 
     if (metavariable !== null) {
       const metaTypeMatches = metavariable.matchMetaType(metaType);
@@ -273,7 +275,7 @@ class Metavariable {
     }
 
     if (verifiedGivenMetaType) {
-      localContext.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
+      context.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type.`);
     }
 
     return verifiedGivenMetaType;
@@ -306,17 +308,17 @@ class Metavariable {
     return metavariable;
   }
 
-  static fromMetavariableNode(metavariableNode, localContext) {
+  static fromMetavariableNode(metavariableNode, context) {
     let metavariable = null;
 
     if (metavariableNode !== null) {
       const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
             node = metavariableNode,  ///
             name = metavariableName,  ///
-            string = localContext.nodeAsString(node),
+            string = context.nodeAsString(node),
             metaType = null;
 
-      metavariable = new Metavariable(localContext, string, node, name, metaType);
+      metavariable = new Metavariable(context, string, node, name, metaType);
     }
 
     return metavariable;
@@ -327,12 +329,13 @@ class Metavariable {
           metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
           metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
           metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          localContext = LocalContext.fromFileContext(fileContext),
           metavariableString = fileContext.nodeAsString(metavariableNode),
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
           string = metavariableString,  ///
           node = metavariableNode,  ///
           name = metavariableName,  ///
-          metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
+          metaType = MetaType.fromMetaTypeNode(metaTypeNode, context),
           metavariable = new Metavariable(fileContext, string, node, name, metaType);
 
     return metavariable;
@@ -345,31 +348,36 @@ Object.assign(shim, {
 
 export default Metavariable;
 
-function metavariableFromMetavariableNode(metavariableNode, localContext) {
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
+function metavariableFromMetavariableNode(metavariableNode, generalContext, specificContext) {
+  const context = generalContext, ///
+        metavariable = context.findMetavariableByMetavariableNode(metavariableNode, specificContext);
 
   return metavariable;
 }
 
-function frameMetavariableFromStatementNode(frameNode, localContext) {
+function frameMetavariableFromStatementNode(frameNode, generalContext, specificContext) {
   let frameMetavariable = null;
 
   const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
 
   if (frameMetavariableNode !== null) {
-    frameMetavariable = localContext.findMetavariableByMetavariableNode(frameMetavariableNode, localContext);
+    const context = generalContext; ///
+
+    frameMetavariable = context.findMetavariableByMetavariableNode(frameMetavariableNode, specificContext);
   }
 
   return frameMetavariable;
 }
 
-function statementMetavariableFromStatementNode(statementNode, localContext) {
+function statementMetavariableFromStatementNode(statementNode, generalContext, specificContext) {
   let statementMetavariable = null;
 
   const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
   if (statementMetavariableNode !== null) {
-    statementMetavariable = localContext.findMetavariableByMetavariableNode(statementMetavariableNode, localContext);
+    const context = generalContext;
+
+    statementMetavariable = context.findMetavariableByMetavariableNode(statementMetavariableNode, specificContext);
   }
 
   return statementMetavariable;

package/src/mixins/statement/qualified/unify.js

@@ -4,92 +4,92 @@ import StatementForMetavariableSubstitution from "../../../substitution/statemen
 
 import { trim } from "../../../utilities/string";
 
-function unifyAWithRule(qualifiedStatement, substitutions, localContext) {
+function unifyAWithRule(qualifiedStatement, substitutions, context) {
   let unifiedWithRule = false;
 
   const reference = qualifiedStatement.getReference(),
-        rule = localContext.findRuleByReference(reference);
+        rule = context.findRuleByReference(reference);
 
   if (rule !== null) {
     const referenceString = reference.getString(),
           qualifiedStatementString = trim(qualifiedStatement.getString());  ///
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' rule...`);
+    context.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' rule...`);
 
     const statement = qualifiedStatement.getStatement(),
-          statementUnified = rule.unifyStatement(statement, localContext);
+          statementUnified = rule.unifyStatement(statement, context);
 
     unifiedWithRule = statementUnified;  ///
 
     if (unifiedWithRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' rule.`);
+      context.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' rule.`);
     }
   }
 
   return unifiedWithRule;
 }
 
-function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
+function unifyAWithReference(qualifiedStatement, substitutions, context) {
   let unifiedWithReference = false;
 
   const reference = qualifiedStatement.getReference(),
         metavariableNode = reference.getMetavariableNode(),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
+        metavariablePresent = context.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
     const statement = qualifiedStatement.getStatement(),
           statementString = statement.getString(),
           referenceString = reference.getString();
 
-    localContext.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
+    context.trace(`Unifying the '${statementString}' qualified statement with the '${referenceString}' reference...`);
 
     const metavariable = reference.getMetavariable(),
-          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+          statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
           substitution = statementForMetavariableSubstitution; ///
 
-    substitutions.addSubstitution(substitution, localContext);
+    substitutions.addSubstitution(substitution, context);
 
     unifiedWithReference = true;
 
     if (unifiedWithReference) {
-      localContext.debug(`...unified the '${statementString}' qualified statement with the '${referenceString}' reference.`);
+      context.debug(`...unified the '${statementString}' qualified statement with the '${referenceString}' reference.`);
     }
   }
 
   return unifiedWithReference;
 }
 
-function unifyAWithAxiomLemmaTheoremOrConjecture(qualifiedStatement, substitutions, localContext) {
+function unifyAWithAxiomLemmaTheoremOrConjecture(qualifiedStatement, substitutions, context) {
   let unifiedWithAxiomLemmaTheoremOrConjecture = false;
 
   const reference = qualifiedStatement.getReference(),
-        axiom = localContext.findAxiomByReference(reference),
-        lemma = localContext.findLemmaByReference(reference),
-        theorem = localContext.findTheoremByReference(reference),
-        conjecture = localContext.findConjectureByReference(reference),
+        axiom = context.findAxiomByReference(reference),
+        lemma = context.findLemmaByReference(reference),
+        theorem = context.findTheoremByReference(reference),
+        conjecture = context.findConjectureByReference(reference),
         axiomLemmaTheoremConjecture = (axiom || lemma || theorem || conjecture);
 
   if (axiomLemmaTheoremConjecture !== null) {
     const referenceString = reference.getString(),
           qualifiedStatementString = trim(qualifiedStatement.getString());  ///
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom, lemma, theorem or conjecture...`);
+    context.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom, lemma, theorem or conjecture...`);
 
     const statement = qualifiedStatement.getStatement(),
-          statementUnified = axiomLemmaTheoremConjecture.unifyStatement(statement, localContext);
+          statementUnified = axiomLemmaTheoremConjecture.unifyStatement(statement, context);
 
     if (statementUnified) {
       const metavariable = reference.getMetavariable(),
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, localContext),
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
             substitution = statementForMetavariableSubstitution; ///
 
-      substitutions.addSubstitution(substitution, localContext);
+      substitutions.addSubstitution(substitution, context);
 
       unifiedWithAxiomLemmaTheoremOrConjecture = true;
     }
 
     if (unifiedWithAxiomLemmaTheoremOrConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom, lemma, theorem or conjecture.`);
+      context.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${referenceString}' axiom, lemma, theorem or conjecture.`);
     }
   }
 

package/src/mixins/statement/resolve.js

@@ -8,52 +8,52 @@ import { nodeQuery } from "../../utilities/query";
 const definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion"),
       containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion");
 
-function resolveAsDefinedAssertion(statement, substitutions, localContextA, localContextB) {
+function resolveAsDefinedAssertion(statement, substitutions, generalContext, specificContext) {
   let resolvedAsDefinedAssertion = false;
 
-  const localContext = localContextA, ///
+  const context = generalContext, ///
         statementNode = statement.getNode(),
         definedAssertionNode = definedAssertionNodeQuery(statementNode),
-        definedAssertion = DefinedAssertion.fromDefinedAssertionNode(definedAssertionNode, localContext);
+        definedAssertion = DefinedAssertion.fromDefinedAssertionNode(definedAssertionNode, context);
 
   if (definedAssertion !== null) {
     const statementString = statement.getString();
 
-    localContextB.trace(`Resolving the '${statementString}' statement as a defined assertion...`);
+    specificContext.trace(`Resolving the '${statementString}' statement as a defined assertion...`);
 
-    const localContext = localContextB, ///
+    const localContext = specificContext, ///
           definedAssertionVerified = definedAssertion.resolve(substitutions, localContext);
 
     resolvedAsDefinedAssertion = definedAssertionVerified; ///
 
     if (resolvedAsDefinedAssertion) {
-      localContextB.debug(`...resolved the '${statementString}' statement as a defined assertion.`);
+      specificContext.debug(`...resolved the '${statementString}' statement as a defined assertion.`);
     }
   }
 
   return resolvedAsDefinedAssertion;
 }
 
-function resolveAsContainedAssertion(statement, substitutions, localContextA, localContextB) {
+function resolveAsContainedAssertion(statement, substitutions, generalContext, specificContext) {
   let resolvedAsContainedAssertion = false;
 
-  const localContext = localContextA, ///
+  const context = generalContext, ///
         statementNode = statement.getNode(),
         containedAssertionNode = containedAssertionNodeQuery(statementNode),
-        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, localContext);
+        containedAssertion = ContainedAssertion.fromContainedAssertionNode(containedAssertionNode, context);
 
   if (containedAssertion !== null) {
     const statementString = statement.getString();
 
-    localContextB.trace(`Resolving the '${statementString}' statement as a contained assertion...`);
+    specificContext.trace(`Resolving the '${statementString}' statement as a contained assertion...`);
 
-    const localContext = localContextB, ///
+    const localContext = specificContext, ///
           containedAssertionVerified = containedAssertion.resolve(substitutions, localContext);
 
     resolvedAsContainedAssertion = containedAssertionVerified; ///
 
     if (resolvedAsContainedAssertion) {
-      localContextB.debug(`...resolved the '${statementString}' statement as a contained assertion.`);
+      specificContext.debug(`...resolved the '${statementString}' statement as a contained assertion.`);
     }
   }