occam-verify-cli 1.0.28 → 1.0.30

package/src/equivalence.js

@@ -58,7 +58,7 @@ export default class Equivalence {
 
   equateTerm(term) {
     const termA = term, ///
-          termEquates = this.terms.some((term) => {
+          termEquates = this.someTerm((term) => {
             const termB = term, ///
                   termAEqualToTermB = termA.isEqualTo(termB);
 
@@ -73,7 +73,7 @@ export default class Equivalence {
   matchTermNode(termNode) {
     termNode = stripBracketsFromTermNode(termNode); ///
 
-    const termNodeMatches = this.terms.some((term) => {
+    const termNodeMatches = this.someTerm((term) => {
       const termNodeMatches = term.matchTermNode(termNode);
 
       if (termNodeMatches) {
@@ -84,11 +84,23 @@ export default class Equivalence {
     return termNodeMatches;
   }
 
+  matchTermNodes(termNodes) {
+    const termNodesMatch = termNodes.every((termNode) => {
+      const termNodeMatches = this.matchTermNode(termNode);
+
+      if (termNodeMatches) {
+        return true;
+      }
+    });
+
+    return termNodesMatch;
+  }
+
   matchVariableNode(variableNode) {
     const variableNodeA = variableNode, ///
-          variableNodeMatches = this.terms.some((term) => {
+          variableNodeMatches = this.someTerm((term) => {
             const termNode = term.getNode(),
-                  variableNode = variableNodeQuery(termNode);
+              variableNode = variableNodeQuery(termNode);
 
             if (variableNode !== null) {
               const variableNodeB = variableNode, ///
@@ -103,16 +115,21 @@ export default class Equivalence {
     return variableNodeMatches;
   }
 
-  matchTermNodes(termNodes) {
-    const termNodesMatch = termNodes.every((termNode) => {
-      const termNodeMatches = this.matchTermNode(termNode);
+  someTerm(callback) { return this.terms.some(callback); }
 
-      if (termNodeMatches) {
-        return true;
-      }
-    });
+  someOtherTerm(term, callback) {
+    const termA = term, ///
+          terms = this.terms.filter((term) => {
+            const termB = term, ///
+                  termAEqualToTermB = termA.isEqualTo(termB);
 
-    return termNodesMatch;
+            if (!termAEqualToTermB) {
+              return true;
+            }
+          }),
+          result = terms.some(callback);
+
+    return result;
   }
 
   getGroundedTerms(definedVariables, groundedTerms, context) {

package/src/mixins/proofStep/unify.js

@@ -2,7 +2,7 @@
 
 import StatementSubstitution from "../../substitution/statement";
 
-import { equalityFromStatement, judgementFromStatement, typeAssertionFromStatement } from "../../utilities/context";
+import { equalityFromStatement, judgementFromStatement, typeAssertionFromStatement, propertyAssertionFromStatement } from "../../utilities/context";
 
 function unifyAWithRule(statement, reference, substitutions, context) {
   let unifiedWithRule = false;
@@ -155,6 +155,38 @@ function unifyAsTypeAssertion(statement, reference, substitutions, context) {
   return unifiedAsTypeAssertion;
 }
 
+function unifyAsPropertyAssertion(statement, reference, substitutions, context) {
+  let unifiedAsPropertyAssertion = false;
+
+  if (reference === null) {
+    const propertyAssertion = propertyAssertionFromStatement(statement, context);
+
+    if (propertyAssertion !== null) {
+      const statementString = statement.getString();
+
+      context.trace(`Unifying the '${statementString}' statement as a property assertion...`);
+
+      const term = propertyAssertion.getTerm(),
+            equivalence = context.findEquivalenceByTerm(term);
+
+      if (equivalence !== null) {
+        unifiedAsPropertyAssertion = equivalence.someOtherTerm(term, (term) => {  ///
+          const propertyRelation = propertyAssertion.getPropertyRelation(),
+                propertyAssertionMatches = context.matchTermAndPropertyRelation(term, propertyRelation);
+
+          if (propertyAssertionMatches) {
+            return true;
+          }
+        });
+      }
+
+      context.debug(`...unified the '${statementString}' statement as a property assertion.`);
+    }
+  }
+
+  return unifiedAsPropertyAssertion;
+}
+
 function unifyWithProofStepSubproofs(statement, reference, substitutions, context) {
   let unifiedWithProofSteps = false;
 
@@ -175,6 +207,7 @@ const unifyMixins = [
   unifyAsEquality,
   unifyAsJudgement,
   unifyAsTypeAssertion,
+  unifyAsPropertyAssertion,
   unifyWithProofStepSubproofs
 ];