occam-verify-cli 0.0.1077 → 0.0.1078

package/lib/utilities/substitutions.js

@@ -0,0 +1,77 @@
+"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(), 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(), 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.getTerm();
+            }
+        }
+    }
+    return frame;
+}
+function statementFromStatementAndSubstitutions(statement, substitutions) {
+    if (statement !== null) {
+        var statementNode = statement.getNode(), 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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsaXRpZXMvc3Vic3RpdHV0aW9ucy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgbm9kZVF1ZXJ5IH0gZnJvbSBcIi4uL3V0aWxpdGllcy9xdWVyeVwiO1xuaW1wb3J0IHsgdmFyaWFibGVOYW1lRnJvbVZhcmlhYmxlTm9kZSB9IGZyb20gXCIuLi91dGlsaXRpZXMvbmFtZVwiO1xuXG5jb25zdCB2YXJpYWJsZU5vZGVRdWVyeSA9IG5vZGVRdWVyeShcIi90ZXJtL3ZhcmlhYmxlIVwiKSxcbiAgICAgIG1ldGF2YXJpYWJsZU5vZGVRdWVyeSA9IG5vZGVRdWVyeShcIi8qL21ldGF2YXJpYWJsZSFcIik7XG5cbmV4cG9ydCBmdW5jdGlvbiB0ZXJtRnJvbVRlcm1BbmRTdWJzdGl0dXRpb25zKHRlcm0sIHN1YnN0aXR1dGlvbnMpIHtcbiAgaWYgKHRlcm0gIT09IG51bGwpIHtcbiAgICBjb25zdCB0ZXJtTm9kZSA9IHRlcm0uZ2V0Tm9kZSgpLFxuICAgICAgICAgIHZhcmlhYmxlTm9kZSA9IHZhcmlhYmxlTm9kZVF1ZXJ5KHRlcm1Ob2RlKTtcblxuICAgIGlmICh2YXJpYWJsZU5vZGUgIT09IG51bGwpIHtcbiAgICAgIGNvbnN0IHZhcmlhYmxlTmFtZSA9IHZhcmlhYmxlTmFtZUZyb21WYXJpYWJsZU5vZGUodmFyaWFibGVOb2RlKSxcbiAgICAgICAgICAgIHN1YnN0aXR1dGlvbiA9IHN1YnN0aXR1dGlvbnMuZmluZFN1YnN0aXR1dGlvbigoc3Vic3RpdHV0aW9uKSA9PiB7XG4gICAgICAgICAgICAgIGNvbnN0IHZhcmlhYmxlTmFtZU1hdGNoZXMgPSBzdWJzdGl0dXRpb24ubWF0Y2hWYXJpYWJsZU5hbWUodmFyaWFibGVOYW1lKTtcblxuICAgICAgICAgICAgICBpZiAodmFyaWFibGVOYW1lTWF0Y2hlcykge1xuICAgICAgICAgICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgICAgICAgICB9XG4gICAgICAgICAgICB9KTtcblxuICAgICAgaWYgKHN1YnN0aXR1dGlvbiAhPT0gbnVsbCkge1xuICAgICAgICB0ZXJtID0gc3Vic3RpdHV0aW9uLmdldFRlcm0oKTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxuICByZXR1cm4gdGVybTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGZyYW1lRnJvbUZyYW1lQW5kU3Vic3RpdHV0aW9ucyhmcmFtZSwgc3Vic3RpdHV0aW9ucykge1xuICBpZiAoZnJhbWUgIT09IG51bGwpIHtcbiAgICBjb25zdCBmcmFtZU5vZGUgPSBmcmFtZS5nZXROb2RlKCksXG4gICAgICAgICAgbWV0YXZhcmlhYmxlTm9kZSA9IG1ldGF2YXJpYWJsZU5vZGVRdWVyeShmcmFtZU5vZGUpO1xuXG4gICAgaWYgKG1ldGF2YXJpYWJsZU5vZGUgIT09IG51bGwpIHtcbiAgICAgIGNvbnN0IHN1YnN0aXR1dGlvbiA9IHN1YnN0aXR1dGlvbnMuZmluZFN1YnN0aXR1dGlvbigoc3Vic3RpdHV0aW9uKSA9PiB7XG4gICAgICAgIGNvbnN0IG1ldGF2YXJpYWJsZU5vZGVNYXRjaGVzID0gc3Vic3RpdHV0aW9uLm1hdGNoTWV0YXZhcmlhYmxlTm9kZShtZXRhdmFyaWFibGVOb2RlKTtcblxuICAgICAgICBpZiAobWV0YXZhcmlhYmxlTm9kZU1hdGNoZXMpIHtcbiAgICAgICAgICByZXR1cm4gdHJ1ZTtcbiAgICAgICAgfVxuICAgICAgfSk7XG5cbiAgICAgIGlmIChzdWJzdGl0dXRpb24gIT09IG51bGwpIHtcbiAgICAgICAgZnJhbWUgPSBzdWJzdGl0dXRpb24uZ2V0VGVybSgpO1xuICAgICAgfVxuICAgIH1cbiAgfVxuXG4gIHJldHVybiBmcmFtZTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHN0YXRlbWVudEZyb21TdGF0ZW1lbnRBbmRTdWJzdGl0dXRpb25zKHN0YXRlbWVudCwgc3Vic3RpdHV0aW9ucykge1xuICBpZiAoc3RhdGVtZW50ICE9PSBudWxsKSB7XG4gICAgY29uc3Qgc3RhdGVtZW50Tm9kZSA9IHN0YXRlbWVudC5nZXROb2RlKCksXG4gICAgICAgICAgbWV0YXZhcmlhYmxlTm9kZSA9IG1ldGF2YXJpYWJsZU5vZGVRdWVyeShzdGF0ZW1lbnROb2RlKTtcblxuICAgIGlmIChtZXRhdmFyaWFibGVOb2RlICE9PSBudWxsKSB7XG4gICAgICBjb25zdCBzdWJzdGl0dXRpb24gPSBzdWJzdGl0dXRpb25zLmZpbmRTdWJzdGl0dXRpb24oKHN1YnN0aXR1dGlvbikgPT4ge1xuICAgICAgICBjb25zdCBtZXRhdmFyaWFibGVOb2RlTWF0Y2hlcyA9IHN1YnN0aXR1dGlvbi5tYXRjaE1ldGF2YXJpYWJsZU5vZGUobWV0YXZhcmlhYmxlTm9kZSk7XG5cbiAgICAgICAgaWYgKG1ldGF2YXJpYWJsZU5vZGVNYXRjaGVzKSB7XG4gICAgICAgICAgcmV0dXJuIHRydWU7XG4gICAgICAgIH1cbiAgICAgIH0pO1xuXG4gICAgICBpZiAoc3Vic3RpdHV0aW9uICE9PSBudWxsKSB7XG4gICAgICAgIHN0YXRlbWVudCA9IHN1YnN0aXR1dGlvbi5nZXRTdGF0ZW1lbnQoKTtcbiAgICAgIH1cbiAgICB9XG4gIH1cblxuICByZXR1cm4gc3RhdGVtZW50O1xufVxuIl0sIm5hbWVzIjpbImZyYW1lRnJvbUZyYW1lQW5kU3Vic3RpdHV0aW9ucyIsInN0YXRlbWVudEZyb21TdGF0ZW1lbnRBbmRTdWJzdGl0dXRpb25zIiwidGVybUZyb21UZXJtQW5kU3Vic3RpdHV0aW9ucyIsInZhcmlhYmxlTm9kZVF1ZXJ5Iiwibm9kZVF1ZXJ5IiwibWV0YXZhcmlhYmxlTm9kZVF1ZXJ5IiwidGVybSIsInN1YnN0aXR1dGlvbnMiLCJ0ZXJtTm9kZSIsImdldE5vZGUiLCJ2YXJpYWJsZU5vZGUiLCJ2YXJpYWJsZU5hbWUiLCJ2YXJpYWJsZU5hbWVGcm9tVmFyaWFibGVOb2RlIiwic3Vic3RpdHV0aW9uIiwiZmluZFN1YnN0aXR1dGlvbiIsInZhcmlhYmxlTmFtZU1hdGNoZXMiLCJtYXRjaFZhcmlhYmxlTmFtZSIsImdldFRlcm0iLCJmcmFtZSIsImZyYW1lTm9kZSIsIm1ldGF2YXJpYWJsZU5vZGUiLCJtZXRhdmFyaWFibGVOb2RlTWF0Y2hlcyIsIm1hdGNoTWV0YXZhcmlhYmxlTm9kZSIsInN0YXRlbWVudCIsInN0YXRlbWVudE5vZGUiLCJnZXRTdGF0ZW1lbnQiXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7OztJQWdDZ0JBLDhCQUE4QjtlQUE5QkE7O0lBdUJBQyxzQ0FBc0M7ZUFBdENBOztJQS9DQUMsNEJBQTRCO2VBQTVCQTs7O3FCQU5VO29CQUNtQjtBQUU3QyxJQUFNQyxvQkFBb0JDLElBQUFBLGdCQUFTLEVBQUMsb0JBQzlCQyx3QkFBd0JELElBQUFBLGdCQUFTLEVBQUM7QUFFakMsU0FBU0YsNkJBQTZCSSxJQUFJLEVBQUVDLGFBQWE7SUFDOUQsSUFBSUQsU0FBUyxNQUFNO1FBQ2pCLElBQU1FLFdBQVdGLEtBQUtHLE9BQU8sSUFDdkJDLGVBQWVQLGtCQUFrQks7UUFFdkMsSUFBSUUsaUJBQWlCLE1BQU07WUFDekIsSUFBTUMsZUFBZUMsSUFBQUEsa0NBQTRCLEVBQUNGLGVBQzVDRyxlQUFlTixjQUFjTyxnQkFBZ0IsQ0FBQyxTQUFDRDtnQkFDN0MsSUFBTUUsc0JBQXNCRixhQUFhRyxpQkFBaUIsQ0FBQ0w7Z0JBRTNELElBQUlJLHFCQUFxQjtvQkFDdkIsT0FBTztnQkFDVDtZQUNGO1lBRU4sSUFBSUYsaUJBQWlCLE1BQU07Z0JBQ3pCUCxPQUFPTyxhQUFhSSxPQUFPO1lBQzdCO1FBQ0Y7SUFDRjtJQUVBLE9BQU9YO0FBQ1Q7QUFFTyxTQUFTTiwrQkFBK0JrQixLQUFLLEVBQUVYLGFBQWE7SUFDakUsSUFBSVcsVUFBVSxNQUFNO1FBQ2xCLElBQU1DLFlBQVlELE1BQU1ULE9BQU8sSUFDekJXLG1CQUFtQmYsc0JBQXNCYztRQUUvQyxJQUFJQyxxQkFBcUIsTUFBTTtZQUM3QixJQUFNUCxlQUFlTixjQUFjTyxnQkFBZ0IsQ0FBQyxTQUFDRDtnQkFDbkQsSUFBTVEsMEJBQTBCUixhQUFhUyxxQkFBcUIsQ0FBQ0Y7Z0JBRW5FLElBQUlDLHlCQUF5QjtvQkFDM0IsT0FBTztnQkFDVDtZQUNGO1lBRUEsSUFBSVIsaUJBQWlCLE1BQU07Z0JBQ3pCSyxRQUFRTCxhQUFhSSxPQUFPO1lBQzlCO1FBQ0Y7SUFDRjtJQUVBLE9BQU9DO0FBQ1Q7QUFFTyxTQUFTakIsdUNBQXVDc0IsU0FBUyxFQUFFaEIsYUFBYTtJQUM3RSxJQUFJZ0IsY0FBYyxNQUFNO1FBQ3RCLElBQU1DLGdCQUFnQkQsVUFBVWQsT0FBTyxJQUNqQ1csbUJBQW1CZixzQkFBc0JtQjtRQUUvQyxJQUFJSixxQkFBcUIsTUFBTTtZQUM3QixJQUFNUCxlQUFlTixjQUFjTyxnQkFBZ0IsQ0FBQyxTQUFDRDtnQkFDbkQsSUFBTVEsMEJBQTBCUixhQUFhUyxxQkFBcUIsQ0FBQ0Y7Z0JBRW5FLElBQUlDLHlCQUF5QjtvQkFDM0IsT0FBTztnQkFDVDtZQUNGO1lBRUEsSUFBSVIsaUJBQWlCLE1BQU07Z0JBQ3pCVSxZQUFZVixhQUFhWSxZQUFZO1lBQ3ZDO1FBQ0Y7SUFDRjtJQUVBLE9BQU9GO0FBQ1QifQ==

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.1077",
+  "version": "0.0.1078",
   "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;
 

package/src/rule.js

@@ -14,7 +14,7 @@ import { labelsFromJSON,
          premisesToPremisesJSON,
          conclusionToConclusionJSON } from "./utilities/json";
 
-const { reverse, correlate } = arrayUtilities;
+const { extract, reverse, backwardsEvery } = arrayUtilities;
 
 const proofNodeQuery = nodeQuery("/rule/proof"),
       labelNodesQuery = nodesQuery("/rule/label"),
@@ -71,15 +71,13 @@ class Rule {
     let statementUnified;
 
     const { Substitutions } = shim,
-          substitutions = Substitutions.fromNothing();
+          substitutions = Substitutions.fromNothing(),
+          conclusionUnified = this.unifyConclusion(statement, substitutions, localContext);
 
-    statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
+    if (conclusionUnified) {
+      const premisesUnified = this.unifyPremises(substitutions, localContext);
 
-    if (statementUnified) {
-      const proofSteps = localContext.getProofSteps(),
-            proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
-
-      if (proofStepsUnified) {
+      if (premisesUnified) {
         const substitutionsResolved = substitutions.areResolved();
 
         statementUnified = substitutionsResolved; ///
@@ -89,24 +87,70 @@ class Rule {
     return statementUnified;
   }
 
-  unifyProofSteps(proofSteps, substitutions, localContext) {
-    let proofStepsUnified;
+  unifyConclusion(statement, substitutions, localContext) {
+    let conclusionUnified;
+
+    const conclusionString = this.conclusion.getString();
+
+    localContext.trace(`Unifying the '${conclusionString}' conclusion...`);
 
-    let premises = this.premises;
+    const statementUnified = this.conclusion.unifyStatement(statement, substitutions, localContext);  ///
 
-    premises = reverse(premises); ///
+    conclusionUnified = statementUnified; ///
+
+    if (conclusionUnified) {
+      localContext.debug(`...unified the '${conclusionString}' conclusion`);
+    }
+
+    return conclusionUnified;
+  }
+
+  unifyPremises(substitutions, localContext) {
+    let proofSteps = localContext.getProofSteps();
 
     proofSteps = reverse(proofSteps); ///
 
-    proofStepsUnified = correlate(premises, proofSteps, (premise, proofStep) => {
-      const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, localContext);
+    const premisesUnified = backwardsEvery(this.premises, (premise) => {
+      const premiseUnified = this.unifyPremise(premise, proofSteps, substitutions, localContext);
 
-      if (proofStepUnified) {
+      if (premiseUnified) {
         return true;
       }
     });
 
-    return proofStepsUnified;
+    return premisesUnified;
+  }
+
+  unifyPremise(premise, proofSteps, substitutions, localContext) {
+    let premiseUnified  =false;
+
+    const premiseString = premise.getString();
+
+    localContext.trace(`Unifying the '${premiseString}' premise...`);
+
+    const premiseResolvedIndependently = premise.resolveIndependently(substitutions, localContext);
+
+    if (premiseResolvedIndependently) {
+      premiseUnified = true;
+    } else {
+      const proofStep = extract(proofSteps, (proofStep) => {
+        const proofStepUnified = premise.unifyProofStep(proofStep, substitutions, localContext);
+
+        if (proofStepUnified) {
+          return true;
+        }
+      });
+
+      if (proofStep !== null) {
+        premiseUnified = true;
+      }
+    }
+
+    if (premiseUnified) {
+      localContext.debug(`...unified the '${premiseString}' premise.`);
+    }
+
+    return premiseUnified;
   }
 
   verify() {

package/src/statement/unqualified.js

@@ -74,6 +74,24 @@ class UnqualifiedStatement {
     return statementUnified;
   }
 
+  resolveIndependently(substitutions, localContextA, localContextB) {
+    let resolveIndependently;
+
+    const unqualifiedStatementString = this.getString();  ///
+
+    localContextB.trace(`Resolving the '${unqualifiedStatementString}' unqualified statement independently...`);
+
+    const statementResolvedIndependently = this.statement.resolveIndependently(substitutions, localContextA, localContextB);
+
+    resolveIndependently = statementResolvedIndependently;  ///
+
+    if (resolveIndependently) {
+      localContextB.debug(`...resolved the '${unqualifiedStatementString}' unqualified statement independently.`);
+    }
+
+    return resolveIndependently;
+  }
+
   unifyStatementWithProofSteps(statement, assignments, stated, localContext) {
     let statementUnifiedWithProofSteps;