occam-verify-cli 1.0.4 → 1.0.6

package/lib/mixins/term/verify.js

@@ -16,6 +16,23 @@ function _interop_require_default(obj) {
     };
 }
 var variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
+function unifyWithBracketedConstructor(term, context, verifyAhead) {
+    var unifiedWithBracketedConstructor;
+    var BracketedConstructor = _dom.default.BracketedConstructor, bracketedConstructor = BracketedConstructor.fromNothing();
+    unifiedWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
+    return unifiedWithBracketedConstructor;
+}
+function unifyWithConstructors(term, context, verifyAhead) {
+    var unifiedWithConstructors;
+    var constructors = context.getConstructors();
+    unifiedWithConstructors = constructors.some(function(constructor) {
+        var unifiedWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
+        if (unifiedWithConstructor) {
+            return true;
+        }
+    });
+    return unifiedWithConstructors;
+}
 function verifyTermAsVariable(term, localContext, verifyAhead) {
     var termVerifiedAsVariable = false;
     var Variable = _dom.default.Variable, context = localContext, termNode = term.getNode(), variableNode = variableNodeQuery(termNode), variable = Variable.fromVariableNode(variableNode, context);
@@ -36,28 +53,32 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
     }
     return termVerifiedAsVariable;
 }
-function unifyWithBracketedConstructor(term, context, verifyAhead) {
-    var unifiedWithBracketedConstructor;
-    var BracketedConstructor = _dom.default.BracketedConstructor, bracketedConstructor = BracketedConstructor.fromNothing();
-    unifiedWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
-    return unifiedWithBracketedConstructor;
-}
-function unifyWithConstructors(term, context, verifyAhead) {
-    var unifiedWithConstructors;
-    var constructors = context.getConstructors();
-    unifiedWithConstructors = constructors.some(function(constructor) {
-        var unifiedWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
-        if (unifiedWithConstructor) {
-            return true;
+function verifyAsPropertyRelation(term, context, verifyAhead) {
+    var verifiedAsPropertyRelation = false;
+    var PropertyRelation = _dom.default.PropertyRelation, termNode = term.getNode(), propertyRelation = PropertyRelation.fromTermNode(termNode, context);
+    if (propertyRelation !== null) {
+        var termString = term.getString();
+        context.trace("Verifying the '".concat(termString, "' term as a property relation..."));
+        var propertyRelationVerified = propertyRelation.verify(context);
+        if (propertyRelationVerified) {
+            var verifiedAhead;
+            var type = propertyRelation.getType();
+            term.setType(type);
+            verifiedAhead = verifyAhead();
+            verifiedAsPropertyRelation = verifiedAhead; ///
         }
-    });
-    return unifiedWithConstructors;
+        if (verifiedAsPropertyRelation) {
+            context.debug("...verified the '".concat(termString, "' statement as a property relation."));
+        }
+    }
+    return verifiedAsPropertyRelation;
 }
 var verifyMixins = [
-    verifyTermAsVariable,
     unifyWithBracketedConstructor,
-    unifyWithConstructors
+    unifyWithConstructors,
+    verifyTermAsVariable,
+    verifyAsPropertyRelation
 ];
 var _default = verifyMixins;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9taXhpbnMvdGVybS92ZXJpZnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmltcG9ydCBkb20gZnJvbSBcIi4uLy4uL2RvbVwiO1xuXG5pbXBvcnQgeyBub2RlUXVlcnkgfSBmcm9tIFwiLi4vLi4vdXRpbGl0aWVzL3F1ZXJ5XCI7XG5cbmNvbnN0IHZhcmlhYmxlTm9kZVF1ZXJ5ID0gbm9kZVF1ZXJ5KFwiL3Rlcm0vdmFyaWFibGUhXCIpO1xuXG5mdW5jdGlvbiB1bmlmeVdpdGhCcmFja2V0ZWRDb25zdHJ1Y3Rvcih0ZXJtLCBjb250ZXh0LCB2ZXJpZnlBaGVhZCkge1xuICBsZXQgdW5pZmllZFdpdGhCcmFja2V0ZWRDb25zdHJ1Y3RvcjtcblxuICBjb25zdCB7IEJyYWNrZXRlZENvbnN0cnVjdG9yIH0gPSBkb20sXG4gICAgICAgIGJyYWNrZXRlZENvbnN0cnVjdG9yID0gQnJhY2tldGVkQ29uc3RydWN0b3IuZnJvbU5vdGhpbmcoKTtcblxuICB1bmlmaWVkV2l0aEJyYWNrZXRlZENvbnN0cnVjdG9yID0gYnJhY2tldGVkQ29uc3RydWN0b3IudW5pZnlUZXJtKHRlcm0sIGNvbnRleHQsIHZlcmlmeUFoZWFkKTtcblxuICByZXR1cm4gdW5pZmllZFdpdGhCcmFja2V0ZWRDb25zdHJ1Y3Rvcjtcbn1cblxuZnVuY3Rpb24gdW5pZnlXaXRoQ29uc3RydWN0b3JzKHRlcm0sIGNvbnRleHQsIHZlcmlmeUFoZWFkKSB7XG4gIGxldCB1bmlmaWVkV2l0aENvbnN0cnVjdG9ycztcblxuICBjb25zdCBjb25zdHJ1Y3RvcnMgPSBjb250ZXh0LmdldENvbnN0cnVjdG9ycygpO1xuXG4gIHVuaWZpZWRXaXRoQ29uc3RydWN0b3JzID0gY29uc3RydWN0b3JzLnNvbWUoKGNvbnN0cnVjdG9yKSA9PiB7XG4gICAgY29uc3QgdW5pZmllZFdpdGhDb25zdHJ1Y3RvciA9IGNvbnN0cnVjdG9yLnVuaWZ5VGVybSh0ZXJtLCBjb250ZXh0LCB2ZXJpZnlBaGVhZCk7XG5cbiAgICBpZiAodW5pZmllZFdpdGhDb25zdHJ1Y3Rvcikge1xuICAgICAgcmV0dXJuIHRydWU7XG4gICAgfVxuICB9KTtcblxuICByZXR1cm4gdW5pZmllZFdpdGhDb25zdHJ1Y3RvcnM7XG59XG5cbmZ1bmN0aW9uIHZlcmlmeVRlcm1Bc1ZhcmlhYmxlKHRlcm0sIGxvY2FsQ29udGV4dCwgdmVyaWZ5QWhlYWQpIHtcbiAgbGV0IHRlcm1WZXJpZmllZEFzVmFyaWFibGUgPSBmYWxzZTtcblxuICBjb25zdCB7IFZhcmlhYmxlIH0gPSBkb20sXG4gICAgICAgIGNvbnRleHQgPSBsb2NhbENvbnRleHQsIC8vL1xuICAgICAgICB0ZXJtTm9kZSA9IHRlcm0uZ2V0Tm9kZSgpLFxuICAgICAgICB2YXJpYWJsZU5vZGUgPSB2YXJpYWJsZU5vZGVRdWVyeSh0ZXJtTm9kZSksXG4gICAgICAgIHZhcmlhYmxlID0gVmFyaWFibGUuZnJvbVZhcmlhYmxlTm9kZSh2YXJpYWJsZU5vZGUsIGNvbnRleHQpO1xuXG4gIGlmICh2YXJpYWJsZSAhPT0gbnVsbCkge1xuICAgIGNvbnN0IHRlcm1TdHJpbmcgPSB0ZXJtLmdldFN0cmluZygpO1xuXG4gICAgbG9jYWxDb250ZXh0LnRyYWNlKGBWZXJpZnlpbmcgdGhlICcke3Rlcm1TdHJpbmd9JyB0ZXJtIGFzIGEgdmFyaWFibGUuLi5gKTtcblxuICAgIGNvbnN0IHZhcmlhYmxlVmVyaWZpZWQgPSB2YXJpYWJsZS52ZXJpZnkobG9jYWxDb250ZXh0KTtcblxuICAgIGlmICh2YXJpYWJsZVZlcmlmaWVkKSB7XG4gICAgICBsZXQgdmVyaWZpZWRBaGVhZDtcblxuICAgICAgY29uc3QgdHlwZSA9IHZhcmlhYmxlLmdldFR5cGUoKTtcblxuICAgICAgdGVybS5zZXRUeXBlKHR5cGUpO1xuXG4gICAgICB2ZXJpZmllZEFoZWFkID0gdmVyaWZ5QWhlYWQoKTtcblxuICAgICAgdGVybVZlcmlmaWVkQXNWYXJpYWJsZSA9IHZlcmlmaWVkQWhlYWQ7IC8vL1xuICAgIH1cblxuICAgIGlmICh0ZXJtVmVyaWZpZWRBc1ZhcmlhYmxlKSB7XG4gICAgICBsb2NhbENvbnRleHQuZGVidWcoYC4uLnZlcmlmaWVkIHRoZSAnJHt0ZXJtU3RyaW5nfScgdGVybSBhcyBhIHZhcmlhYmxlLmApO1xuICAgIH1cbiAgfVxuXG4gIHJldHVybiB0ZXJtVmVyaWZpZWRBc1ZhcmlhYmxlO1xufVxuXG5mdW5jdGlvbiB2ZXJpZnlBc1Byb3BlcnR5UmVsYXRpb24odGVybSwgY29udGV4dCwgdmVyaWZ5QWhlYWQpIHtcbiAgbGV0IHZlcmlmaWVkQXNQcm9wZXJ0eVJlbGF0aW9uID0gZmFsc2U7XG5cbiAgY29uc3QgeyBQcm9wZXJ0eVJlbGF0aW9uIH0gPSBkb20sXG4gICAgICAgIHRlcm1Ob2RlID0gdGVybS5nZXROb2RlKCksXG4gICAgICAgIHByb3BlcnR5UmVsYXRpb24gPSBQcm9wZXJ0eVJlbGF0aW9uLmZyb21UZXJtTm9kZSh0ZXJtTm9kZSwgY29udGV4dCk7XG5cbiAgaWYgKHByb3BlcnR5UmVsYXRpb24gIT09IG51bGwpIHtcbiAgICBjb25zdCB0ZXJtU3RyaW5nID0gdGVybS5nZXRTdHJpbmcoKTtcblxuICAgIGNvbnRleHQudHJhY2UoYFZlcmlmeWluZyB0aGUgJyR7dGVybVN0cmluZ30nIHRlcm0gYXMgYSBwcm9wZXJ0eSByZWxhdGlvbi4uLmApO1xuXG4gICAgY29uc3QgcHJvcGVydHlSZWxhdGlvblZlcmlmaWVkID0gcHJvcGVydHlSZWxhdGlvbi52ZXJpZnkoY29udGV4dCk7XG5cbiAgICBpZiAocHJvcGVydHlSZWxhdGlvblZlcmlmaWVkKSB7XG4gICAgICBsZXQgdmVyaWZpZWRBaGVhZDtcblxuICAgICAgY29uc3QgdHlwZSA9IHByb3BlcnR5UmVsYXRpb24uZ2V0VHlwZSgpO1xuXG4gICAgICB0ZXJtLnNldFR5cGUodHlwZSk7XG5cbiAgICAgIHZlcmlmaWVkQWhlYWQgPSB2ZXJpZnlBaGVhZCgpO1xuXG4gICAgICB2ZXJpZmllZEFzUHJvcGVydHlSZWxhdGlvbiA9IHZlcmlmaWVkQWhlYWQ7IC8vL1xuICAgIH1cblxuICAgIGlmICh2ZXJpZmllZEFzUHJvcGVydHlSZWxhdGlvbikge1xuICAgICAgY29udGV4dC5kZWJ1ZyhgLi4udmVyaWZpZWQgdGhlICcke3Rlcm1TdHJpbmd9JyBzdGF0ZW1lbnQgYXMgYSBwcm9wZXJ0eSByZWxhdGlvbi5gKTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4gdmVyaWZpZWRBc1Byb3BlcnR5UmVsYXRpb247XG59XG5cbmNvbnN0IHZlcmlmeU1peGlucyA9IFtcbiAgdW5pZnlXaXRoQnJhY2tldGVkQ29uc3RydWN0b3IsXG4gIHVuaWZ5V2l0aENvbnN0cnVjdG9ycyxcbiAgdmVyaWZ5VGVybUFzVmFyaWFibGUsXG4gIHZlcmlmeUFzUHJvcGVydHlSZWxhdGlvblxuXTtcblxuZXhwb3J0IGRlZmF1bHQgdmVyaWZ5TWl4aW5zO1xuIl0sIm5hbWVzIjpbInZhcmlhYmxlTm9kZVF1ZXJ5Iiwibm9kZVF1ZXJ5IiwidW5pZnlXaXRoQnJhY2tldGVkQ29uc3RydWN0b3IiLCJ0ZXJtIiwiY29udGV4dCIsInZlcmlmeUFoZWFkIiwidW5pZmllZFdpdGhCcmFja2V0ZWRDb25zdHJ1Y3RvciIsIkJyYWNrZXRlZENvbnN0cnVjdG9yIiwiZG9tIiwiYnJhY2tldGVkQ29uc3RydWN0b3IiLCJmcm9tTm90aGluZyIsInVuaWZ5VGVybSIsInVuaWZ5V2l0aENvbnN0cnVjdG9ycyIsInVuaWZpZWRXaXRoQ29uc3RydWN0b3JzIiwiY29uc3RydWN0b3JzIiwiZ2V0Q29uc3RydWN0b3JzIiwic29tZSIsImNvbnN0cnVjdG9yIiwidW5pZmllZFdpdGhDb25zdHJ1Y3RvciIsInZlcmlmeVRlcm1Bc1ZhcmlhYmxlIiwibG9jYWxDb250ZXh0IiwidGVybVZlcmlmaWVkQXNWYXJpYWJsZSIsIlZhcmlhYmxlIiwidGVybU5vZGUiLCJnZXROb2RlIiwidmFyaWFibGVOb2RlIiwidmFyaWFibGUiLCJmcm9tVmFyaWFibGVOb2RlIiwidGVybVN0cmluZyIsImdldFN0cmluZyIsInRyYWNlIiwidmFyaWFibGVWZXJpZmllZCIsInZlcmlmeSIsInZlcmlmaWVkQWhlYWQiLCJ0eXBlIiwiZ2V0VHlwZSIsInNldFR5cGUiLCJkZWJ1ZyIsInZlcmlmeUFzUHJvcGVydHlSZWxhdGlvbiIsInZlcmlmaWVkQXNQcm9wZXJ0eVJlbGF0aW9uIiwiUHJvcGVydHlSZWxhdGlvbiIsInByb3BlcnR5UmVsYXRpb24iLCJmcm9tVGVybU5vZGUiLCJwcm9wZXJ0eVJlbGF0aW9uVmVyaWZpZWQiLCJ2ZXJpZnlNaXhpbnMiXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQWdIQTs7O2VBQUE7OzswREE5R2dCO3FCQUVVOzs7Ozs7QUFFMUIsSUFBTUEsb0JBQW9CQyxJQUFBQSxnQkFBUyxFQUFDO0FBRXBDLFNBQVNDLDhCQUE4QkMsSUFBSSxFQUFFQyxPQUFPLEVBQUVDLFdBQVc7SUFDL0QsSUFBSUM7SUFFSixJQUFNLEFBQUVDLHVCQUF5QkMsWUFBRyxDQUE1QkQsc0JBQ0ZFLHVCQUF1QkYscUJBQXFCRyxXQUFXO0lBRTdESixrQ0FBa0NHLHFCQUFxQkUsU0FBUyxDQUFDUixNQUFNQyxTQUFTQztJQUVoRixPQUFPQztBQUNUO0FBRUEsU0FBU00sc0JBQXNCVCxJQUFJLEVBQUVDLE9BQU8sRUFBRUMsV0FBVztJQUN2RCxJQUFJUTtJQUVKLElBQU1DLGVBQWVWLFFBQVFXLGVBQWU7SUFFNUNGLDBCQUEwQkMsYUFBYUUsSUFBSSxDQUFDLFNBQUNDO1FBQzNDLElBQU1DLHlCQUF5QkQsWUFBWU4sU0FBUyxDQUFDUixNQUFNQyxTQUFTQztRQUVwRSxJQUFJYSx3QkFBd0I7WUFDMUIsT0FBTztRQUNUO0lBQ0Y7SUFFQSxPQUFPTDtBQUNUO0FBRUEsU0FBU00scUJBQXFCaEIsSUFBSSxFQUFFaUIsWUFBWSxFQUFFZixXQUFXO0lBQzNELElBQUlnQix5QkFBeUI7SUFFN0IsSUFBTSxBQUFFQyxXQUFhZCxZQUFHLENBQWhCYyxVQUNGbEIsVUFBVWdCLGNBQ1ZHLFdBQVdwQixLQUFLcUIsT0FBTyxJQUN2QkMsZUFBZXpCLGtCQUFrQnVCLFdBQ2pDRyxXQUFXSixTQUFTSyxnQkFBZ0IsQ0FBQ0YsY0FBY3JCO0lBRXpELElBQUlzQixhQUFhLE1BQU07UUFDckIsSUFBTUUsYUFBYXpCLEtBQUswQixTQUFTO1FBRWpDVCxhQUFhVSxLQUFLLENBQUMsQUFBQyxrQkFBNEIsT0FBWEYsWUFBVztRQUVoRCxJQUFNRyxtQkFBbUJMLFNBQVNNLE1BQU0sQ0FBQ1o7UUFFekMsSUFBSVcsa0JBQWtCO1lBQ3BCLElBQUlFO1lBRUosSUFBTUMsT0FBT1IsU0FBU1MsT0FBTztZQUU3QmhDLEtBQUtpQyxPQUFPLENBQUNGO1lBRWJELGdCQUFnQjVCO1lBRWhCZ0IseUJBQXlCWSxlQUFlLEdBQUc7UUFDN0M7UUFFQSxJQUFJWix3QkFBd0I7WUFDMUJELGFBQWFpQixLQUFLLENBQUMsQUFBQyxvQkFBOEIsT0FBWFQsWUFBVztRQUNwRDtJQUNGO0lBRUEsT0FBT1A7QUFDVDtBQUVBLFNBQVNpQix5QkFBeUJuQyxJQUFJLEVBQUVDLE9BQU8sRUFBRUMsV0FBVztJQUMxRCxJQUFJa0MsNkJBQTZCO0lBRWpDLElBQU0sQUFBRUMsbUJBQXFCaEMsWUFBRyxDQUF4QmdDLGtCQUNGakIsV0FBV3BCLEtBQUtxQixPQUFPLElBQ3ZCaUIsbUJBQW1CRCxpQkFBaUJFLFlBQVksQ0FBQ25CLFVBQVVuQjtJQUVqRSxJQUFJcUMscUJBQXFCLE1BQU07UUFDN0IsSUFBTWIsYUFBYXpCLEtBQUswQixTQUFTO1FBRWpDekIsUUFBUTBCLEtBQUssQ0FBQyxBQUFDLGtCQUE0QixPQUFYRixZQUFXO1FBRTNDLElBQU1lLDJCQUEyQkYsaUJBQWlCVCxNQUFNLENBQUM1QjtRQUV6RCxJQUFJdUMsMEJBQTBCO1lBQzVCLElBQUlWO1lBRUosSUFBTUMsT0FBT08saUJBQWlCTixPQUFPO1lBRXJDaEMsS0FBS2lDLE9BQU8sQ0FBQ0Y7WUFFYkQsZ0JBQWdCNUI7WUFFaEJrQyw2QkFBNkJOLGVBQWUsR0FBRztRQUNqRDtRQUVBLElBQUlNLDRCQUE0QjtZQUM5Qm5DLFFBQVFpQyxLQUFLLENBQUMsQUFBQyxvQkFBOEIsT0FBWFQsWUFBVztRQUMvQztJQUNGO0lBRUEsT0FBT1c7QUFDVDtBQUVBLElBQU1LLGVBQWU7SUFDbkIxQztJQUNBVTtJQUNBTztJQUNBbUI7Q0FDRDtJQUVELFdBQWVNIn0=

package/lib/utilities/context.js

@@ -0,0 +1,103 @@
+"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, {
+    containedAssertionFromStatement: function() {
+        return containedAssertionFromStatement;
+    },
+    definedAssertionFromStatement: function() {
+        return definedAssertionFromStatement;
+    },
+    equalityFromStatement: function() {
+        return equalityFromStatement;
+    },
+    judgementFromStatement: function() {
+        return judgementFromStatement;
+    },
+    metavariableFromFrame: function() {
+        return metavariableFromFrame;
+    },
+    metavariableFromStatement: function() {
+        return metavariableFromStatement;
+    },
+    propertyAssertionFromStatement: function() {
+        return propertyAssertionFromStatement;
+    },
+    subproofAssertionFromStatement: function() {
+        return subproofAssertionFromStatement;
+    },
+    typeAssertionFromStatement: function() {
+        return typeAssertionFromStatement;
+    }
+});
+var _dom = /*#__PURE__*/ _interop_require_default(require("../dom"));
+var _local = /*#__PURE__*/ _interop_require_default(require("../context/local"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function metavariableFromFrame(frame, context) {
+    context = contextFromFrame(frame, context); ///
+    var Metavariable = _dom.default.Metavariable, frameNode = frame.getNode(), metavariable = Metavariable.fromFrameNode(frameNode, context);
+    return metavariable;
+}
+function equalityFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var Equality = _dom.default.Equality, statementNode = statement.getNode(), equality = Equality.fromStatementNode(statementNode, context);
+    return equality;
+}
+function judgementFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var Judgement = _dom.default.Judgement, statementNode = statement.getNode(), judgement = Judgement.fromStatementNode(statementNode, context);
+    return judgement;
+}
+function metavariableFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var Metavariable = _dom.default.Metavariable, statementNode = statement.getNode(), metavariable = Metavariable.fromStatementNode(statementNode, context);
+    return metavariable;
+}
+function typeAssertionFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var TypeAssertion = _dom.default.TypeAssertion, statementNode = statement.getNode(), typeAssertion = TypeAssertion.fromStatementNode(statementNode, context);
+    return typeAssertion;
+}
+function definedAssertionFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var DefinedAssertion = _dom.default.DefinedAssertion, statementNode = statement.getNode(), definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);
+    return definedAssertion;
+}
+function propertyAssertionFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var PropertyAssertion = _dom.default.PropertyAssertion, statementNode = statement.getNode(), propertyAssertion = PropertyAssertion.fromStatementNode(statementNode, context);
+    return propertyAssertion;
+}
+function containedAssertionFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var ContainedAssertion = _dom.default.ContainedAssertion, statementNode = statement.getNode(), containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);
+    return containedAssertion;
+}
+function subproofAssertionFromStatement(statement, context) {
+    context = contextFromStatement(statement, context); ///
+    var SubproofAssertion = _dom.default.SubproofAssertion, statementNode = statement.getNode(), subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);
+    return subproofAssertion;
+}
+function contextFromFrame(frame, context) {
+    var frameTokens = frame.getTokens(), tokens = frameTokens, localContext = _local.default.fromContextAndTokens(context, tokens);
+    context = localContext; ///
+    return context;
+}
+function contextFromStatement(statement, context) {
+    var statementTokens = statement.getTokens(), tokens = statementTokens, localContext = _local.default.fromContextAndTokens(context, tokens);
+    context = localContext; ///
+    return context;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/utilities/context.js"],"sourcesContent":["\"use strict\";\n\nimport dom from \"../dom\";\nimport LocalContext from \"../context/local\";\n\nexport function metavariableFromFrame(frame, context) {\n  context = contextFromFrame(frame, context); ///\n\n  const { Metavariable } = dom,\n        frameNode = frame.getNode(),\n        metavariable = Metavariable.fromFrameNode(frameNode, context);\n\n  return metavariable;\n}\n\nexport function equalityFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Equality } = dom,\n        statementNode = statement.getNode(),\n        equality = Equality.fromStatementNode(statementNode, context);\n\n  return equality;\n}\n\nexport function judgementFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Judgement } = dom,\n        statementNode = statement.getNode(),\n        judgement = Judgement.fromStatementNode(statementNode, context);\n\n  return judgement;\n}\n\nexport function metavariableFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { Metavariable } = dom,\n        statementNode = statement.getNode(),\n        metavariable = Metavariable.fromStatementNode(statementNode, context);\n\n  return metavariable;\n}\n\nexport function typeAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { TypeAssertion } = dom,\n        statementNode = statement.getNode(),\n        typeAssertion = TypeAssertion.fromStatementNode(statementNode, context);\n\n  return typeAssertion;\n}\n\nexport function definedAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { DefinedAssertion } = dom,\n        statementNode = statement.getNode(),\n        definedAssertion = DefinedAssertion.fromStatementNode(statementNode, context);\n\n  return definedAssertion;\n}\n\nexport function propertyAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { PropertyAssertion } = dom,\n        statementNode = statement.getNode(),\n        propertyAssertion = PropertyAssertion.fromStatementNode(statementNode, context);\n\n  return propertyAssertion;\n}\n\nexport function containedAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { ContainedAssertion } = dom,\n        statementNode = statement.getNode(),\n        containedAssertion = ContainedAssertion.fromStatementNode(statementNode, context);\n\n  return containedAssertion;\n}\n\nexport function subproofAssertionFromStatement(statement, context) {\n  context = contextFromStatement(statement, context); ///\n\n  const { SubproofAssertion } = dom,\n        statementNode = statement.getNode(),\n        subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, context);\n\n  return subproofAssertion;\n}\n\nfunction contextFromFrame(frame, context) {\n  const frameTokens = frame.getTokens(),\n        tokens = frameTokens, ///\n        localContext = LocalContext.fromContextAndTokens(context, tokens);\n\n  context = localContext; ///\n\n  return context;\n}\n\nfunction contextFromStatement(statement, context) {\n  const statementTokens = statement.getTokens(),\n        tokens = statementTokens, ///\n        localContext = LocalContext.fromContextAndTokens(context, tokens);\n\n  context = localContext; ///\n\n  return context;\n}\n"],"names":["containedAssertionFromStatement","definedAssertionFromStatement","equalityFromStatement","judgementFromStatement","metavariableFromFrame","metavariableFromStatement","propertyAssertionFromStatement","subproofAssertionFromStatement","typeAssertionFromStatement","frame","context","contextFromFrame","Metavariable","dom","frameNode","getNode","metavariable","fromFrameNode","statement","contextFromStatement","Equality","statementNode","equality","fromStatementNode","Judgement","judgement","TypeAssertion","typeAssertion","DefinedAssertion","definedAssertion","PropertyAssertion","propertyAssertion","ContainedAssertion","containedAssertion","SubproofAssertion","subproofAssertion","frameTokens","getTokens","tokens","localContext","LocalContext","fromContextAndTokens","statementTokens"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,7 +12,7 @@
   "dependencies": {
     "argumentative": "^2.0.32",
     "necessary": "^14.2.1",
-    "occam-custom-grammars": "^5.0.1040",
+    "occam-custom-grammars": "^5.0.1042",
     "occam-entities": "^1.0.272",
     "occam-file-system": "^6.0.294",
     "occam-furtle": "^2.0.34",

package/src/dom/metavariable.js

@@ -13,7 +13,7 @@ import { domAssigned } from "../dom";
 import { EMPTY_STRING } from "../constants";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
-import { metavariableFromFrame, metavariableFromStatement } from "../utilities/verification";
+import { metavariableFromFrame, metavariableFromStatement } from "../utilities/context";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../utilities/unification";
 import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "../utilities/name";
 

package/src/dom/premise.js

@@ -4,7 +4,7 @@ import dom from "../dom";
 
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
-import { subproofAssertionFromStatement } from "../utilities/verification";
+import { subproofAssertionFromStatement } from "../utilities/context";
 import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default domAssigned(class Premise {

package/src/dom/relation/property.js

@@ -0,0 +1,153 @@
+"use strict";
+
+import dom from "../../dom";
+
+import { nodeQuery } from "../../utilities/query";
+import { domAssigned } from "../../dom";
+
+const termNodeQuery = nodeQuery("/propertyRelation/term"),
+      propertyNodeQuery = nodeQuery("/propertyRelation/property"),
+      propertyRelationNodeQuery = nodeQuery("/term/propertyRelation");
+
+export default domAssigned(class PropertyRelation {
+  constructor(string, node, tokens, property, term) {
+    this.string = string;
+    this.node = node;
+    this.tokens = tokens;
+    this.property = property;
+    this.term = term;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  getProperty() {
+    return this.property;
+  }
+
+  getTerm() {
+    return this.term;
+  }
+
+  getType() { return this.property.getType(); }
+
+  verify(context) {
+    let verified = false;
+
+    const propertyRelationString = this.string; ///
+
+    context.trace(`Verifying the '${propertyRelationString}' property relation...`);
+
+    const termVerified = this.verifyTerm(context);
+
+    if (termVerified) {
+      const propertyVerified = this.verifyProperty(context);
+
+      if (propertyVerified) {
+        const type = this.property.getType();
+
+        this.term.setType(type);
+
+        verified = true;
+      }
+    }
+
+    if (verified) {
+      context.debug(`...verified the '${propertyRelationString}' property relation.`);
+    }
+
+    return verified;
+  }
+
+  verifyProperty(context) {
+    let propertyVerified;
+
+    const propertyString = this.property.getString(),
+          propertyRelationString = this.string; ///
+
+    context.trace(`Verifying the '${propertyRelationString}' property relation's '${propertyString}' property...`);
+
+    const termType = this.term.getType(),
+          propertyName = this.property.getName(),
+          termTypeProperties = termType.getProperties(),
+          termTypeProperty = termTypeProperties.find((termTypeProperty) => {
+            const propertyNameMatches = termTypeProperty.matchPropertyName(propertyName);
+
+            if (propertyNameMatches) {
+              return true;
+            }
+          }) || null;
+
+    if (termTypeProperty === null) {
+      const termString = this.term.getString(),
+            termTypeName = termType.getName();
+
+      context.debug(`The '${propertyName}' property is not a property of the '${termString}' term's '${termTypeName}' type.`);
+    } else {
+      const type = termType;
+
+      this.property.setType(type);
+
+      propertyVerified = true;
+    }
+
+    if (propertyVerified) {
+      context.debug(`...verified the '${propertyRelationString}' property relation's '${propertyString}' property.`);
+    }
+
+    return propertyVerified;
+  }
+
+  verifyTerm(context) {
+    let termVerified;
+
+    const termString = this.term.getString(),
+          propertyRelationString = this.string; ///
+
+    context.trace(`Verifying the '${propertyRelationString}' property relation's '${termString}' term...`);
+
+    termVerified = this.term.verify(context, () => {
+      const verifiedAhead = true;
+
+      return verifiedAhead;
+    });
+
+    if (termVerified) {
+      context.debug(`...verified the '${propertyRelationString}' property relation's '${termString}' term.`);
+    }
+
+    return termVerified;
+  }
+
+  static name = "PropertyRelation";
+
+  static fromTermNode(termNode, context) {
+    let propertyRelation = null;
+
+    const propertyRelationNode = propertyRelationNodeQuery(termNode);
+
+    if (propertyRelationNode !== null) {
+      const { Term, Property } = dom,
+            node = propertyRelationNode,  ///
+            string = context.nodeAsString(node),
+            tokens = context.nodeAsTokens(node),
+            termNode = termNodeQuery(propertyRelationNode),
+            propertyNode = propertyNodeQuery(propertyRelationNode),
+            property = Property.fromPropertyNode(propertyNode, context),
+            term = Term.fromTermNode(termNode, context);
+
+      propertyRelation = new PropertyRelation(string, node, tokens, property, term);
+    }
+
+    return propertyRelation;
+  }
+});

package/src/dom/statement.js

@@ -11,7 +11,7 @@ import { domAssigned } from "../dom";
 import { unifyStatement } from "../utilities/unification";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
-import { definedAssertionFromStatement, containedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/verification";
+import { definedAssertionFromStatement, containedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/context";
 
 const { match, backwardsSome } = arrayUtilities;
 

package/src/dom/supposition.js

@@ -4,7 +4,7 @@ import dom from "../dom";
 
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
-import { subproofAssertionFromStatement } from "../utilities/verification";
+import { subproofAssertionFromStatement } from "../utilities/context";
 import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
 
 export default domAssigned(class Supposition {

package/src/index.js

@@ -37,6 +37,7 @@ import SubDerivation from "./dom/subDerivation";
 import TypeAssertion from "./dom/assertion/type";
 import TypeDeclaration from "./dom/declaration/type";
 import DefinedAssertion from "./dom/assertion/defined";
+import PropertyRelation from "./dom/relation/property";
 import SubproofAssertion from "./dom/assertion/subproof";
 import PropertyAssertion from "./dom/assertion/property";
 import ContainedAssertion from "./dom/assertion/contained";

package/src/mixins/proofStep/unify.js

@@ -2,7 +2,7 @@
 
 import StatementSubstitution from "../../substitution/statement";
 
-import { equalityFromStatement, judgementFromStatement, typeAssertionFromStatement } from "../../utilities/verification";
+import { equalityFromStatement, judgementFromStatement, typeAssertionFromStatement } from "../../utilities/context";
 
 function unifyAWithRule(statement, reference, substitutions, context) {
   let unifiedWithRule = false;

package/src/mixins/statement/verify.js

@@ -9,7 +9,7 @@ import { equalityFromStatement,
          definedAssertionFromStatement,
          propertyAssertionFromStatement,
          containedAssertionFromStatement,
-         subproofAssertionFromStatement } from "../../utilities/verification";
+         subproofAssertionFromStatement } from "../../utilities/context";
 
 function unifyWithBracketedCombinator(statement, assignments, stated, context) {
   stated = true;  ///

package/src/mixins/term/verify.js

@@ -6,6 +6,33 @@ import { nodeQuery } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
+function unifyWithBracketedConstructor(term, context, verifyAhead) {
+  let unifiedWithBracketedConstructor;
+
+  const { BracketedConstructor } = dom,
+        bracketedConstructor = BracketedConstructor.fromNothing();
+
+  unifiedWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
+
+  return unifiedWithBracketedConstructor;
+}
+
+function unifyWithConstructors(term, context, verifyAhead) {
+  let unifiedWithConstructors;
+
+  const constructors = context.getConstructors();
+
+  unifiedWithConstructors = constructors.some((constructor) => {
+    const unifiedWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
+
+    if (unifiedWithConstructor) {
+      return true;
+    }
+  });
+
+  return unifiedWithConstructors;
+}
+
 function verifyTermAsVariable(term, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;
 
@@ -42,37 +69,45 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
   return termVerifiedAsVariable;
 }
 
-function unifyWithBracketedConstructor(term, context, verifyAhead) {
-  let unifiedWithBracketedConstructor;
+function verifyAsPropertyRelation(term, context, verifyAhead) {
+  let verifiedAsPropertyRelation = false;
 
-  const { BracketedConstructor } = dom,
-        bracketedConstructor = BracketedConstructor.fromNothing();
+  const { PropertyRelation } = dom,
+        termNode = term.getNode(),
+        propertyRelation = PropertyRelation.fromTermNode(termNode, context);
 
-  unifiedWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
+  if (propertyRelation !== null) {
+    const termString = term.getString();
 
-  return unifiedWithBracketedConstructor;
-}
+    context.trace(`Verifying the '${termString}' term as a property relation...`);
 
-function unifyWithConstructors(term, context, verifyAhead) {
-  let unifiedWithConstructors;
+    const propertyRelationVerified = propertyRelation.verify(context);
 
-  const constructors = context.getConstructors();
+    if (propertyRelationVerified) {
+      let verifiedAhead;
 
-  unifiedWithConstructors = constructors.some((constructor) => {
-    const unifiedWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
+      const type = propertyRelation.getType();
 
-    if (unifiedWithConstructor) {
-      return true;
+      term.setType(type);
+
+      verifiedAhead = verifyAhead();
+
+      verifiedAsPropertyRelation = verifiedAhead; ///
     }
-  });
 
-  return unifiedWithConstructors;
+    if (verifiedAsPropertyRelation) {
+      context.debug(`...verified the '${termString}' statement as a property relation.`);
+    }
+  }
+
+  return verifiedAsPropertyRelation;
 }
 
 const verifyMixins = [
-  verifyTermAsVariable,
   unifyWithBracketedConstructor,
-  unifyWithConstructors
+  unifyWithConstructors,
+  verifyTermAsVariable,
+  verifyAsPropertyRelation
 ];
 
 export default verifyMixins;