occam-verify-cli 0.0.1077 → 0.0.1079

package/lib/utilities/equivalences.js

@@ -91,8 +91,8 @@ function findEquivalenceByType(equivalences, type) {
 }
 function findEquivalenceByTerm(equivalences, term) {
     var equivalence = equivalences.find(function(equivalence) {
-        var equivalenceMatchesTerm = equivalence.matchTerm(term);
-        if (equivalenceMatchesTerm) {
+        var termEquates = equivalence.equateTerm(term);
+        if (termEquates) {
             return true;
         }
     }) || null;
@@ -175,4 +175,4 @@ function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquiva
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/equivalences.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport Equivalence from \"../equivalence\";\n\nconst { push, compress, separate } = arrayUtilities;\n\nexport function mergeEquivalences(equivalencesA, equivalencesB) {\n  const typesA = typesFromEquivalences(equivalencesA),\n        typesB = typesFromEquivalences(equivalencesB),\n        types = [\n          ...typesA,\n          ...typesB\n        ];\n\n  compress(types, (typeA, typeB) => {\n    if (typeA === typeB) {\n      return true;\n    }\n  });\n\n  const equivalences = types.map((type) => {\n    let equivalence;\n\n    const equivalenceA = findEquivalenceByType(equivalencesA, type),\n          equivalenceB = findEquivalenceByType(equivalencesB, type);\n\n    if ((equivalenceA !== null) && (equivalenceB !== null)) {\n      const leftEquivalence = equivalenceA, ///\n            rightEquivalence = equivalenceB;  ///\n\n      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);\n    } else if (equivalenceA !== null) {\n      equivalence = equivalenceA; ///\n    } else if (equivalenceB !== null) {\n      equivalence = equivalenceB; ///\n    }\n\n    return equivalence;\n  });\n\n  return equivalences;\n}\n\nexport function findEquivalenceByType(equivalences, type) {\n  const equivalence = equivalences.find((equivalence) => {\n    const equivalenceMatchesType = equivalence.matchType(type);\n\n    if (equivalenceMatchesType) {\n      return true;\n    }\n  }) || null;\n\n  return equivalence;\n}\n\nexport function findEquivalenceByTerm(equivalences, term) {\n  const equivalence = equivalences.find((equivalence) => {\n    const equivalenceMatchesTerm = equivalence.matchTerm(term);\n\n    if (equivalenceMatchesTerm) {\n      return true;\n    }\n  }) || null;\n\n  return equivalence;\n}\n\nexport function findEquivalenceByTermNodes(equivalences, termNodes) {\n  const equivalence = equivalences.find((equivalence) => {\n    const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);\n\n    if (equivalenceMatchesTerms) {\n      return true;\n    }\n  }) || null;\n\n  return equivalence;\n}\n\nexport function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, localContext) {\n  let groundedEquivalences,\n      remainingEquivalences,\n      initiallyGroundedEquivalences,\n      implicitlyGroundedEquivalences;\n\n  remainingEquivalences = [];\n\n  initiallyGroundedEquivalences = [];\n\n  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext);\n\n  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;\n\n  if (initiallyGroundedEquivalencesLength > 0) {\n    groundedEquivalences = initiallyGroundedEquivalences; ///\n\n    let implicitlyGroundedEquivalencesLength = 1;\n\n    while (implicitlyGroundedEquivalencesLength > 0) {\n      let definedVariablesLength = 0,\n          previousDefinedVariablesLength = -1;\n\n      while (definedVariablesLength > previousDefinedVariablesLength) {\n        previousDefinedVariablesLength = definedVariablesLength;  ///\n\n        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext);\n\n        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext);\n\n        definedVariablesLength = definedVariables.length;\n      }\n\n      equivalences = remainingEquivalences; ///\n\n      remainingEquivalences = [];\n\n      implicitlyGroundedEquivalences = [];\n\n      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext);\n\n      push(groundedEquivalences, implicitlyGroundedEquivalences);\n\n      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;  ///\n    }\n  }\n}\n\nfunction typesFromEquivalences(equivalences) {\n  const types = equivalences.map((equivalence) => {\n    const type = equivalence.getType();\n\n    return type;\n  });\n\n  return types;\n}\n\nfunction definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext) {\n  const terms = groundedTerms,  ///\n        variables = definedVariables; ///\n\n  terms.forEach((term) => {\n    const termVariables = term.getVariables(localContext);\n\n    termVariables.forEach((termVariable) => {\n      const variablesIncludesTermVariable = variables.includes(termVariable);\n\n      if (!variablesIncludesTermVariable) {\n        const variable = termVariable;  ///\n\n        variables.push(variable);\n      }\n    });\n  });\n}\n\nfunction separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext) {\n  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {\n    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(localContext);\n\n    if (!equivalenceInitiallyGrounded) {\n      return true;\n    }\n  });\n}\n\nfunction separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext) {\n  separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {\n    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, localContext);\n\n    if (!equivalenceImplicitlyGrounded) {\n      return true;\n    }\n  });\n}\n\nfunction groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext) {\n  groundedEquivalences.forEach((groundedEquivalence) => {\n    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, localContext);\n  });\n}\n"],"names":["findEquivalenceByTerm","findEquivalenceByTermNodes","findEquivalenceByType","groundedTermsAndDefinedVariablesFromFromEquivalences","mergeEquivalences","push","arrayUtilities","compress","separate","equivalencesA","equivalencesB","typesA","typesFromEquivalences","typesB","types","typeA","typeB","equivalences","map","type","equivalence","equivalenceA","equivalenceB","leftEquivalence","rightEquivalence","Equivalence","merge","find","equivalenceMatchesType","matchType","term","equivalenceMatchesTerm","matchTerm","termNodes","equivalenceMatchesTerms","matchTermNodes","groundedTerms","definedVariables","localContext","groundedEquivalences","remainingEquivalences","initiallyGroundedEquivalences","implicitlyGroundedEquivalences","separateInitiallyGroundedEquivalences","initiallyGroundedEquivalencesLength","length","implicitlyGroundedEquivalencesLength","definedVariablesLength","previousDefinedVariablesLength","groundedTermsFromGroundedEquivalencesAndDefinedVariables","definedVariablesFromGroundedTerms","separateImplicitlyGroundedEquivalences","getType","terms","variables","forEach","termVariables","getVariables","termVariable","variablesIncludesTermVariable","includes","variable","equivalenceInitiallyGrounded","isInitiallyGrounded","equivalenceImplicitlyGrounded","isImplicitlyGrounded","groundedEquivalence","getGroundedTerms"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/equivalences.js"],"sourcesContent":["\"use strict\";\n\nimport { arrayUtilities } from \"necessary\";\n\nimport Equivalence from \"../equivalence\";\n\nconst { push, compress, separate } = arrayUtilities;\n\nexport function mergeEquivalences(equivalencesA, equivalencesB) {\n  const typesA = typesFromEquivalences(equivalencesA),\n        typesB = typesFromEquivalences(equivalencesB),\n        types = [\n          ...typesA,\n          ...typesB\n        ];\n\n  compress(types, (typeA, typeB) => {\n    if (typeA === typeB) {\n      return true;\n    }\n  });\n\n  const equivalences = types.map((type) => {\n    let equivalence;\n\n    const equivalenceA = findEquivalenceByType(equivalencesA, type),\n          equivalenceB = findEquivalenceByType(equivalencesB, type);\n\n    if ((equivalenceA !== null) && (equivalenceB !== null)) {\n      const leftEquivalence = equivalenceA, ///\n            rightEquivalence = equivalenceB;  ///\n\n      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);\n    } else if (equivalenceA !== null) {\n      equivalence = equivalenceA; ///\n    } else if (equivalenceB !== null) {\n      equivalence = equivalenceB; ///\n    }\n\n    return equivalence;\n  });\n\n  return equivalences;\n}\n\nexport function findEquivalenceByType(equivalences, type) {\n  const equivalence = equivalences.find((equivalence) => {\n    const equivalenceMatchesType = equivalence.matchType(type);\n\n    if (equivalenceMatchesType) {\n      return true;\n    }\n  }) || null;\n\n  return equivalence;\n}\n\nexport function findEquivalenceByTerm(equivalences, term) {\n  const equivalence = equivalences.find((equivalence) => {\n    const termEquates = equivalence.equateTerm(term);\n\n    if (termEquates) {\n      return true;\n    }\n  }) || null;\n\n  return equivalence;\n}\n\nexport function findEquivalenceByTermNodes(equivalences, termNodes) {\n  const equivalence = equivalences.find((equivalence) => {\n    const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);\n\n    if (equivalenceMatchesTerms) {\n      return true;\n    }\n  }) || null;\n\n  return equivalence;\n}\n\nexport function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, localContext) {\n  let groundedEquivalences,\n      remainingEquivalences,\n      initiallyGroundedEquivalences,\n      implicitlyGroundedEquivalences;\n\n  remainingEquivalences = [];\n\n  initiallyGroundedEquivalences = [];\n\n  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext);\n\n  const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;\n\n  if (initiallyGroundedEquivalencesLength > 0) {\n    groundedEquivalences = initiallyGroundedEquivalences; ///\n\n    let implicitlyGroundedEquivalencesLength = 1;\n\n    while (implicitlyGroundedEquivalencesLength > 0) {\n      let definedVariablesLength = 0,\n          previousDefinedVariablesLength = -1;\n\n      while (definedVariablesLength > previousDefinedVariablesLength) {\n        previousDefinedVariablesLength = definedVariablesLength;  ///\n\n        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext);\n\n        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext);\n\n        definedVariablesLength = definedVariables.length;\n      }\n\n      equivalences = remainingEquivalences; ///\n\n      remainingEquivalences = [];\n\n      implicitlyGroundedEquivalences = [];\n\n      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext);\n\n      push(groundedEquivalences, implicitlyGroundedEquivalences);\n\n      implicitlyGroundedEquivalencesLength = implicitlyGroundedEquivalences.length;  ///\n    }\n  }\n}\n\nfunction typesFromEquivalences(equivalences) {\n  const types = equivalences.map((equivalence) => {\n    const type = equivalence.getType();\n\n    return type;\n  });\n\n  return types;\n}\n\nfunction definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext) {\n  const terms = groundedTerms,  ///\n        variables = definedVariables; ///\n\n  terms.forEach((term) => {\n    const termVariables = term.getVariables(localContext);\n\n    termVariables.forEach((termVariable) => {\n      const variablesIncludesTermVariable = variables.includes(termVariable);\n\n      if (!variablesIncludesTermVariable) {\n        const variable = termVariable;  ///\n\n        variables.push(variable);\n      }\n    });\n  });\n}\n\nfunction separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext) {\n  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {\n    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(localContext);\n\n    if (!equivalenceInitiallyGrounded) {\n      return true;\n    }\n  });\n}\n\nfunction separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext) {\n  separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {\n    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, localContext);\n\n    if (!equivalenceImplicitlyGrounded) {\n      return true;\n    }\n  });\n}\n\nfunction groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext) {\n  groundedEquivalences.forEach((groundedEquivalence) => {\n    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, localContext);\n  });\n}\n"],"names":["findEquivalenceByTerm","findEquivalenceByTermNodes","findEquivalenceByType","groundedTermsAndDefinedVariablesFromFromEquivalences","mergeEquivalences","push","arrayUtilities","compress","separate","equivalencesA","equivalencesB","typesA","typesFromEquivalences","typesB","types","typeA","typeB","equivalences","map","type","equivalence","equivalenceA","equivalenceB","leftEquivalence","rightEquivalence","Equivalence","merge","find","equivalenceMatchesType","matchType","term","termEquates","equateTerm","termNodes","equivalenceMatchesTerms","matchTermNodes","groundedTerms","definedVariables","localContext","groundedEquivalences","remainingEquivalences","initiallyGroundedEquivalences","implicitlyGroundedEquivalences","separateInitiallyGroundedEquivalences","initiallyGroundedEquivalencesLength","length","implicitlyGroundedEquivalencesLength","definedVariablesLength","previousDefinedVariablesLength","groundedTermsFromGroundedEquivalencesAndDefinedVariables","definedVariablesFromGroundedTerms","separateImplicitlyGroundedEquivalences","getType","terms","variables","forEach","termVariables","getVariables","termVariable","variablesIncludesTermVariable","includes","variable","equivalenceInitiallyGrounded","isInitiallyGrounded","equivalenceImplicitlyGrounded","isImplicitlyGrounded","groundedEquivalence","getGroundedTerms"],"mappings":"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"}

package/lib/utilities/substitutions.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    frameFromFrameAndSubstitutions: function() {
+        return frameFromFrameAndSubstitutions;
+    },
+    statementFromStatementAndSubstitutions: function() {
+        return statementFromStatementAndSubstitutions;
+    },
+    termFromTermAndSubstitutions: function() {
+        return termFromTermAndSubstitutions;
+    }
+});
+var _query = require("../utilities/query");
+var _name = require("../utilities/name");
+var variableNodeQuery = (0, _query.nodeQuery)("/term/variable!"), metavariableNodeQuery = (0, _query.nodeQuery)("/*/metavariable!");
+function termFromTermAndSubstitutions(term, substitutions) {
+    if (term !== null) {
+        var termNode = term.getNode();
+        term = null;
+        var variableNode = variableNodeQuery(termNode);
+        if (variableNode !== null) {
+            var variableName = (0, _name.variableNameFromVariableNode)(variableNode), substitution = substitutions.findSubstitution(function(substitution) {
+                var variableNameMatches = substitution.matchVariableName(variableName);
+                if (variableNameMatches) {
+                    return true;
+                }
+            });
+            if (substitution !== null) {
+                term = substitution.getTerm();
+            }
+        }
+    }
+    return term;
+}
+function frameFromFrameAndSubstitutions(frame, substitutions) {
+    if (frame !== null) {
+        var frameNode = frame.getNode();
+        frame = null;
+        var metavariableNode = metavariableNodeQuery(frameNode);
+        if (metavariableNode !== null) {
+            var substitution = substitutions.findSubstitution(function(substitution) {
+                var metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+                if (metavariableNodeMatches) {
+                    return true;
+                }
+            });
+            if (substitution !== null) {
+                frame = substitution.getFrame();
+            }
+        }
+    }
+    return frame;
+}
+function statementFromStatementAndSubstitutions(statement, substitutions) {
+    if (statement !== null) {
+        var statementNode = statement.getNode();
+        statement = null;
+        var metavariableNode = metavariableNodeQuery(statementNode);
+        if (metavariableNode !== null) {
+            var substitution = substitutions.findSubstitution(function(substitution) {
+                var metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+                if (metavariableNodeMatches) {
+                    return true;
+                }
+            });
+            if (substitution !== null) {
+                statement = substitution.getStatement();
+            }
+        }
+    }
+    return statement;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.1077",
+  "version": "0.0.1079",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/assertion/contained.js

@@ -3,6 +3,7 @@
 import shim from "../shim";
 
 import { isAssertionNegated } from "../utilities/assertion";
+import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../utilities/substitutions";
 
 export default class ContainedAssertion {
   constructor(string, node, term, frame, negated, statement) {
@@ -38,6 +39,27 @@ export default class ContainedAssertion {
     return this.statement;
   }
 
+  resolve(substitutions, localContext) {
+    let resolved;
+
+    const containedAssertionString = this.string; ///
+
+    localContext.trace(`Resolving the '${containedAssertionString}' contained assertion...`);
+
+    const term = termFromTermAndSubstitutions(this.term, substitutions),
+          frame = frameFromFrameAndSubstitutions(this.frame, substitutions),
+          statement = statementFromStatementAndSubstitutions(this.statement, substitutions),
+          verifiedWhenDerived = verifyWhenDerived(term, frame, statement, this.negated, localContext);
+
+    resolved = verifiedWhenDerived; ///
+
+    if (resolved) {
+      localContext.debug(`...resolved the '${containedAssertionString}' contained assertion.`);
+    }
+
+    return resolved;
+  }
+
   verify(assignments, stated, localContext) {
     let verified = false;
 
@@ -108,43 +130,13 @@ export default class ContainedAssertion {
   }
 
   verifyWhenDerived(localContext) {
-    let verifiedWhenDerived = false;
+    let verifiedWhenDerived;
 
     const containedAssertionString = this.string; ///
 
     localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`);
 
-    if (this.term !== null) {
-      const variable = this.term.getVariable(localContext);
-
-      if (variable !== null) {
-        const variableContained = this.statement.isVariableContained(variable, localContext);
-
-        if (!this.negated && variableContained) {
-          verifiedWhenDerived = true;
-        }
-
-        if (this.negated && !variableContained) {
-          verifiedWhenDerived = true;
-        }
-      }
-    }
-
-    if (this.frame !== null) {
-      const metavariable = this.frame.getVariable(localContext);
-
-      if (metavariable !== null) {
-        const metavariableContained = this.statement.isMetavariableContained(metavariable, localContext);
-
-        if (!this.negated && metavariableContained) {
-          verifiedWhenDerived = true;
-        }
-
-        if (this.negated && !metavariableContained) {
-          verifiedWhenDerived = true;
-        }
-      }
-    }
+    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.statement, this.negated, localContext);
 
     if (verifiedWhenDerived) {
       localContext.debug(`...verified the '${containedAssertionString}' derived contained assertion.`);
@@ -172,3 +164,41 @@ export default class ContainedAssertion {
     return containedAssertion;
   }
 }
+
+function verifyWhenDerived(term, frame, statement, negated, localContext) {
+  let verifiedWhenDerived = false;
+
+  if (term !== null) {
+    const variable = term.getVariable(localContext);
+
+    if (variable !== null) {
+      const variableContained = statement.isVariableContained(variable, localContext);
+
+      if (!negated && variableContained) {
+        verifiedWhenDerived = true;
+      }
+
+      if (negated && !variableContained) {
+        verifiedWhenDerived = true;
+      }
+    }
+  }
+
+  if (frame !== null) {
+    const metavariable = frame.getMetavariable(localContext);
+
+    if (metavariable !== null) {
+      const metavariableContained = statement.isMetavariableContained(metavariable, localContext);
+
+      if (!negated && metavariableContained) {
+        verifiedWhenDerived = true;
+      }
+
+      if (negated && !metavariableContained) {
+        verifiedWhenDerived = true;
+      }
+    }
+  }
+
+  return verifiedWhenDerived;
+}

package/src/assertion/defined.js

@@ -2,7 +2,13 @@
 
 import shim from "../shim";
 
+import { nodeQuery } from "../utilities/query";
 import { isAssertionNegated } from "../utilities/assertion";
+import { variableNameFromVariableNode } from "../utilities/name";
+import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../utilities/substitutions";
+
+const variableNodeQuery = nodeQuery("/term/variable!"),
+      metavariableNodeQuery = nodeQuery("/frame/metavariable!");
 
 export default class DefinedAssertion {
   constructor(string, node, term, frame, negated) {
@@ -33,6 +39,26 @@ export default class DefinedAssertion {
     return this.negated;
   }
 
+  resolve(substitutions, localContext) {
+    let resolved;
+
+    const definedAssertionString = this.string; ///
+
+    localContext.trace(`Resolving the '${definedAssertionString}' defined assertion...`);
+
+    const term = termFromTermAndSubstitutions(this.term, substitutions),
+          frame = frameFromFrameAndSubstitutions(this.frame, substitutions),
+          verifiedWhenDerived = verifyWhenDerived(term, frame, this.negated, localContext);
+
+    resolved = verifiedWhenDerived; ///
+
+    if (resolved) {
+      localContext.debug(`...resolved the '${definedAssertionString}' defined assertion.`);
+    }
+
+    return resolved;
+  }
+
   verify(assignments, stated, localContext) {
     let verified = false;
 
@@ -98,43 +124,13 @@ export default class DefinedAssertion {
   }
 
   verifyWhenDerived(localContext) {
-    let verifiedWhenDerived = false;
+    let verifiedWhenDerived;
 
     const definedAssertionString = this.string; ///
 
     localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`);
 
-    if (this.term !== null) {
-      const { Variable } = shim,
-            termNode = this.term.getNode(),
-            variable = Variable.fromTermNode(termNode, localContext),
-            variableDefined = localContext.isVariableDefined(variable);
-
-      if (!this.negated && variableDefined) {
-        verifiedWhenDerived = true;
-      }
-
-      if (this.negated && !variableDefined) {
-        verifiedWhenDerived = true;
-      }
-    }
-
-    if (this.frame!== null) {
-      debugger
-
-      const { Metavariable } = shim,
-            frameNode = this.frame.getNode(),
-            metavariable = Metavariable.fromTermNode(frameNode, localContext),
-            metavariableDefined = localContext.isMetametavariableDefined(metavariable);
-
-      if (!this.negated && metavariableDefined) {
-        verifiedWhenDerived = true;
-      }
-
-      if (this.negated && !metavariableDefined) {
-        verifiedWhenDerived = true;
-      }
-    }
+    verifiedWhenDerived = verifyWhenDerived(this.term, this.frame, this.negated, localContext);
 
     if (verifiedWhenDerived) {
       localContext.debug(`...verified the '${definedAssertionString}' derived defined assertion.`);
@@ -161,3 +157,38 @@ export default class DefinedAssertion {
     return definedAssertion;
   }
 }
+
+function verifyWhenDerived(term, frame, negated, localContext) {
+  let verifiedWhenDerived = false;
+
+  if (term !== null) {
+    const termNode = term.getNode(),
+          variableNode = variableNodeQuery(termNode),
+          variableName = variableNameFromVariableNode(variableNode),
+          variableDefined = localContext.isVariableDefinedByVariableName(variableName);
+
+    if (!negated && variableDefined) {
+      verifiedWhenDerived = true;
+    }
+
+    if (negated && !variableDefined) {
+      verifiedWhenDerived = true;
+    }
+  }
+
+  if (frame!== null) {
+    const frameNode = frame.getNode(),
+          metavariableNode = metavariableNodeQuery(frameNode),
+          metavariableDefined = localContext.isJudgementPresentByMetavariableNode(metavariableNode);
+
+    if (!negated && metavariableDefined) {
+      verifiedWhenDerived = true;
+    }
+
+    if (negated && !metavariableDefined) {
+      verifiedWhenDerived = true;
+    }
+  }
+
+  return verifiedWhenDerived;
+}

package/src/context/local.js

@@ -250,7 +250,7 @@ class LocalContext {
     return termGrounded;
   }
 
-  isVariableDefined(variable) {
+  isVariableDefinedByVariableName(variableName) {
     const context = this,
           equivalences = this.getEquivalences(),
           groundedTerms = [],
@@ -259,9 +259,9 @@ class LocalContext {
     groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
 
     const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-            const variableMatchesDefinedVariable = variable.match(definedVariable);
+            const definedVariableName = definedVariable.getName();
 
-            if (variableMatchesDefinedVariable) {
+            if (definedVariableName === variableName) {
               return true;
             }
           }),

package/src/equality.js

@@ -50,8 +50,9 @@ class Equality {
   }
 
   isReflexive() {
-    const leftTermMatchesRightTerm = this.leftTerm.match(this.rightTerm),
-          reflexive = leftTermMatchesRightTerm; ///
+    const rightTermNode = this.rightTerm.getNode(),
+          leftTermNodeMatchesRightTermNode = this.leftTerm.matchTermNode(rightTermNode),
+          reflexive = leftTermNodeMatchesRightTermNode; ///
 
     return reflexive;
   }

package/src/equivalence.js

@@ -56,30 +56,18 @@ export default class Equivalence {
     return typeMatches;
   }
 
-  matchTerm(term) {
+  equateTerm(term) {
     const termA = term, ///
-          termMatches = this.terms.some((term) => {
+          termEquates = this.terms.some((term) => {
             const termB = term, ///
-                  termAMatchesTermB = termA.match(termB);
+                  termAEqualToTermB = termA.isEqualTo(termB);
 
-            if (termAMatchesTermB) {
+            if (termAEqualToTermB) {
               return true;
             }
           });
 
-    return termMatches;
-  }
-
-  matchTerms(terms) {
-    const termsMatch = terms.every((term) => {
-      const termMatches = this.matchTerm(term);
-
-      if (termMatches) {
-        return true;
-      }
-    })
-
-    return termsMatch;
+    return termEquates;
   }
 
   matchTermNode(termNode) {
@@ -206,7 +194,7 @@ export default class Equivalence {
 
       string = (string === null) ?
                  termString :
-                    `${string} ${termString}`;
+                    `${string} = ${termString}`;
 
       return string;
     }, null);

package/src/mixins/statement/resolve.js

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

package/src/premise.js

@@ -28,6 +28,30 @@ class Premise {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
+  resolveIndependently(substitutions, localContext) {
+    let resolvedIndependently;
+
+    const premiseString = this.getString();
+
+    const localContextB = localContext; ///
+
+    localContext = LocalContext.fromFileContext(this.fileContext);
+
+    const localContextA = localContext; ///
+
+    localContextB.trace(`Resolving the '${premiseString}' premise independently...`);
+
+    const unqualifiedStatementResolvedIndependently = this.unqualifiedStatement.resolveIndependently(substitutions, localContextA, localContextB);
+
+    resolvedIndependently = unqualifiedStatementResolvedIndependently;  ///
+
+    if (resolvedIndependently) {
+      localContextB.trace(`...resolved the '${premiseString}' premise independently.`);
+    }
+
+    return resolvedIndependently;
+  }
+
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -97,24 +121,28 @@ class Premise {
           premiseStatement = premise.getStatement(),
           premiseStatementString = premiseStatement.getString();
 
-    localContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+    const localContextB = localContext; ///
 
     const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
           statementTokens = statement.getTokens(),
           context = this.fileContext, ///
           tokens = statementTokens; ///
 
     localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
 
-    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+    const localContextA = localContext; ///
+
+    localContextB.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+
+    const statementNode = statement.getNode(),
+          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
 
     if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, localContextA, localContextB);
     }
 
     if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+      localContextB.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
     }
 
     return subproofUnified;