occam-verify-cli 1.0.220 → 1.0.224

package/src/mixins/step/unify.js

@@ -14,7 +14,7 @@ import { equalityFromStatement,
 const { backwardsSome } = arrayUtilities;
 
 function unifyWithRule(statement, reference, substitutions, context) {
-  let unifiedWithRule = false;
+  let unifiesWithRule = false;
 
   if (reference !== null) {
     const rule = context.findRuleByReference(reference);
@@ -26,26 +26,28 @@ function unifyWithRule(statement, reference, substitutions, context) {
       context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule...`);
 
       const stepsOrSubproofs = context.getStepsOrSubproofs(),
-            statementAndStepsUnified = rule.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+            statementAndStepsUnify = rule.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
 
-      unifiedWithRule = statementAndStepsUnified;  ///
+      if (statementAndStepsUnify) {
+        unifiesWithRule = true;
+      }
 
-      if (unifiedWithRule) {
+      if (unifiesWithRule) {
         context.debug(`...unified the '${statementString}' statement with the '${ruleString}' rule.`);
       }
     }
   }
 
-  return unifiedWithRule;
+  return unifiesWithRule;
 }
 
 function unifyWithReference(statement, reference, substitutions, context) {
-  let unifiedWithReference = false;
+  let unifiesWithReference = false;
 
   if (reference !== null) {
-    const metavariableVerified = reference.verifyMetavariable(context);
+    const metavariableVerifies = reference.verifyMetavariable(context);
 
-    if (metavariableVerified) {
+    if (metavariableVerifies) {
       const statementString = statement.getString(),
             referenceString = reference.getString();
 
@@ -59,19 +61,19 @@ function unifyWithReference(statement, reference, substitutions, context) {
 
       substitutions.addSubstitution(substitution, specificContext);
 
-      unifiedWithReference = true;
+      unifiesWithReference = true;
 
-      if (unifiedWithReference) {
+      if (unifiesWithReference) {
         context.debug(`...unified the '${statementString}' statement with the '${referenceString}' reference.`);
       }
     }
   }
 
-  return unifiedWithReference;
+  return unifiesWithReference;
 }
 
 function unifyAsSatisfiesAssertion(statement, reference, substitutions, context) {
-  let unifiedAsSatisfiesAssertion = false;
+  let unifiesAsSatisfiesAssertion = false;
 
   const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
 
@@ -88,10 +90,10 @@ function unifyAsSatisfiesAssertion(statement, reference, substitutions, context)
     if (reference === null) {
       const stepsOrSubproofs = context.getStepsOrSubproofs();
 
-      unifiedAsSatisfiesAssertion = backwardsSome(stepsOrSubproofs, (stepsOrSubproof) => {
-        const satisfiedAssertionUnified = stepsOrSubproof.unifySatisfiesAssertion(satisfiesAssertion, context);
+      unifiesAsSatisfiesAssertion = backwardsSome(stepsOrSubproofs, (stepsOrSubproof) => {
+        const satisfiedAssertionUnifies = stepsOrSubproof.unifySatisfiesAssertion(satisfiesAssertion, context);
 
-        if (satisfiedAssertionUnified) {
+        if (satisfiedAssertionUnifies) {
           return true;
         }
       });
@@ -105,27 +107,29 @@ function unifyAsSatisfiesAssertion(statement, reference, substitutions, context)
 
         if (axiom !== null) {
           const substitutions = Substitutions.fromNothing(),
-                axiomLemmaTheoremConjectureUnified = axiom.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context);
+                axiomLemmaTheoremConjectureUnifies = axiom.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context);
 
-          if (axiomLemmaTheoremConjectureUnified) {
-            const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
+          if (axiomLemmaTheoremConjectureUnifies) {
+            const substitutionsCorrelates = satisfiesAssertion.correlateSubstitutions(substitutions, context);
 
-            unifiedAsSatisfiesAssertion = substitutionsMatch;  ///
+            if (substitutionsCorrelates) {
+              unifiesAsSatisfiesAssertion = true;
+            }
           }
         }
       }
     }
 
-    if (unifiedAsSatisfiesAssertion) {
+    if (unifiesAsSatisfiesAssertion) {
       context.debug(`...unified the '${statementString}' statement as a satisfies assertion.`);
     }
   }
 
-  return unifiedAsSatisfiesAssertion;
+  return unifiesAsSatisfiesAssertion;
 }
 
 function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, substitutions, context) {
-  let unifiedWithAxiomLemmaTheoremOrConjecture = false;
+  let unifiesWithAxiomLemmaTheoremOrConjecture = false;
 
   if (reference !== null) {
     const axiomLemmaTheoremConjecture = context.findAxiomLemmaTheoremConjectureByReference(reference),
@@ -141,9 +145,9 @@ function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, substituti
 
       substitutions = Substitutions.fromNothing();
 
-      const statementAndStepsUnified = axiomLemmaTheoremConjecture.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
+      const statementAndStepsUnify = axiomLemmaTheoremConjecture.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
 
-      if (statementAndStepsUnified) {
+      if (statementAndStepsUnify) {
         const { StatementSubstitution } = dom,
               metavariable = reference.getMetavariable(),
               specificContext = context,  ///
@@ -154,20 +158,20 @@ function unifyWithAxiomLemmaTheoremOrConjecture(statement, reference, substituti
 
         substitutions.addSubstitution(substitution, specificContext);
 
-        unifiedWithAxiomLemmaTheoremOrConjecture = true;
+        unifiesWithAxiomLemmaTheoremOrConjecture = true;
       }
 
-      if (unifiedWithAxiomLemmaTheoremOrConjecture) {
+      if (unifiesWithAxiomLemmaTheoremOrConjecture) {
         context.debug(`...unified the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`);
       }
     }
   }
 
-  return unifiedWithAxiomLemmaTheoremOrConjecture;
+  return unifiesWithAxiomLemmaTheoremOrConjecture;
 }
 
-function unifyAsEquality(statement, reference, substitutions, context) {
-  let unifiedAsEquality = false;
+function unifyAEquality(statement, reference, substitutions, context) {
+  let unifiesAEquality = false;
 
   if (reference === null) {
     const equality = equalityFromStatement(statement, context);
@@ -177,17 +181,23 @@ function unifyAsEquality(statement, reference, substitutions, context) {
 
       context.trace(`Unifying the '${statementString}' statement as an equality...`);
 
-      unifiedAsEquality = true;
+      const equalityEqual = equality.isEqual(context);
+
+      if (equalityEqual) {
+        unifiesAEquality = true;
+      }
 
-      context.debug(`...unified the '${statementString}' statement as an equality.`);
+      if (unifiesAEquality) {
+        context.debug(`...unified the '${statementString}' statement as an equality.`);
+      }
     }
   }
 
-  return unifiedAsEquality;
+  return unifiesAEquality;
 }
 
 function unifyAsJudgement(statement, reference, substitutions, context) {
-  let unifiedAsJudgement = false;
+  let unifiesAsJudgement = false;
 
   if (reference === null) {
     const judgement = judgementFromStatement(statement, context);
@@ -197,17 +207,19 @@ function unifyAsJudgement(statement, reference, substitutions, context) {
 
       context.trace(`Unifying the '${statementString}' statement as a judgement...`);
 
-      unifiedAsJudgement = true;
+      unifiesAsJudgement = true;
 
-      context.debug(`...unified the '${statementString}' statement as a judgement.`);
+      if (unifiesAsJudgement) {
+        context.debug(`...unified the '${statementString}' statement as a judgement.`);
+      }
     }
   }
 
-  return unifiedAsJudgement;
+  return unifiesAsJudgement;
 }
 
 function unifyAsTypeAssertion(statement, reference, substitutions, context) {
-  let unifiedAsTypeAssertion = false;
+  let unifiesAsTypeAssertion = false;
 
   if (reference === null) {
     const typeAssertion = typeAssertionFromStatement(statement, context);
@@ -217,17 +229,17 @@ function unifyAsTypeAssertion(statement, reference, substitutions, context) {
 
       context.trace(`Unifying the '${statementString}' statement as a type assertion...`);
 
-      unifiedAsTypeAssertion = true;
+      unifiesAsTypeAssertion = true;
 
       context.debug(`...unified the '${statementString}' statement as a type assertion.`);
     }
   }
 
-  return unifiedAsTypeAssertion;
+  return unifiesAsTypeAssertion;
 }
 
 function unifyAsPropertyAssertion(statement, reference, substitutions, context) {
-  let unifiedAsPropertyAssertion = false;
+  let unifiesAsPropertyAssertion = false;
 
   if (reference === null) {
     const propertyAssertion = propertyAssertionFromStatement(statement, context);
@@ -241,7 +253,7 @@ function unifyAsPropertyAssertion(statement, reference, substitutions, context)
             equivalence = context.findEquivalenceByTerm(term);
 
       if (equivalence !== null) {
-        unifiedAsPropertyAssertion = equivalence.someOtherTerm(term, (term) => {  ///
+        const propertyAssertionMatches = equivalence.someOtherTerm(term, (term) => {  ///
           const propertyRelation = propertyAssertion.getPropertyRelation(),
                 propertyAssertionMatches = context.matchTermAndPropertyRelation(term, propertyRelation);
 
@@ -249,32 +261,23 @@ function unifyAsPropertyAssertion(statement, reference, substitutions, context)
             return true;
           }
         });
+
+        if (propertyAssertionMatches) {
+          unifiesAsPropertyAssertion = true;
+        }
       }
 
-      if (unifiedAsPropertyAssertion) {
+      if (unifiesAsPropertyAssertion) {
         context.debug(`...unified the '${statementString}' statement as a property assertion.`);
       }
     }
   }
 
-  return unifiedAsPropertyAssertion;
-}
-
-function unifyWithStepsOrSubproofs(statement, reference, substitutions, context) {
-  let unifiedWithStepOrSubproofs = false;
-
-  if (reference === null) {
-    const stepsOrSubproofs = context.getStepsOrSubproofs(),
-          statementUnifiedWithSteps = statement.unifyWithStepsOrSubproofs(stepsOrSubproofs, context);
-
-    unifiedWithStepOrSubproofs = statementUnifiedWithSteps; ///
-  }
-
-  return unifiedWithStepOrSubproofs;
+  return unifiesAsPropertyAssertion;
 }
 
 function unifyWithSatisfiesAssertion(statement, reference, substitutions, context) {
-  let unifiedWithSatisfiesAssertion;
+  let unifiesWithSatisfiesAssertion = false;
 
   const stepsOrSubproofs = context.getStepsOrSubproofs(),
         satisfiesAssertions = stepsOrSubproofs.reduce((satisfiesAssertions, stepOrSubproof) => {
@@ -293,17 +296,35 @@ function unifyWithSatisfiesAssertion(statement, reference, substitutions, contex
           }
 
           return satisfiesAssertions;
-        }, []);
+        }, []),
+        statementUnifies = backwardsSome(satisfiesAssertions, (satisfiesAssertion) => {
+          const statementUnifies = satisfiesAssertion.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+
+          if (statementUnifies) {
+            return true;
+          }
+        });
+
+  if (statementUnifies) {
+    unifiesWithSatisfiesAssertion = true;
+  }
+
+  return unifiesWithSatisfiesAssertion;
+}
 
-  unifiedWithSatisfiesAssertion = backwardsSome(satisfiesAssertions, (satisfiesAssertion) => {
-    const statementUnified = satisfiesAssertion.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+function equateWithStepsOrSubproofs(statement, reference, substitutions, context) {
+  let unifiesWithStepOrSubproofs = false;
 
-    if (statementUnified) {
-      return true;
+  if (reference === null) {
+    const stepsOrSubproofs = context.getStepsOrSubproofs(),
+          statementUnifiesWithSteps = statement.equateWithStepsOrSubproofs(stepsOrSubproofs, context);
+
+    if (statementUnifiesWithSteps) {
+      unifiesWithStepOrSubproofs = true;
     }
-  });
+  }
 
-  return unifiedWithSatisfiesAssertion;
+  return unifiesWithStepOrSubproofs;
 }
 
 const unifyMixins = [
@@ -311,12 +332,12 @@ const unifyMixins = [
   unifyWithReference,
   unifyAsSatisfiesAssertion,
   unifyWithAxiomLemmaTheoremOrConjecture,
-  unifyAsEquality,
+  unifyAEquality,
   unifyAsJudgement,
   unifyAsTypeAssertion,
   unifyAsPropertyAssertion,
-  unifyWithStepsOrSubproofs,
-  unifyWithSatisfiesAssertion
+  unifyWithSatisfiesAssertion,
+  equateWithStepsOrSubproofs
 ];
 
 export default unifyMixins;

package/src/mixins/term/verify.js

@@ -3,34 +3,34 @@
 import dom from "../../dom";
 
 function unifyWithBracketedConstructor(term, context, verifyAhead) {
-  let unifiedWithBracketedConstructor;
+  let unifiesWithBracketedConstructor;
 
   const { BracketedConstructor } = dom,
         bracketedConstructor = BracketedConstructor.fromNothing();
 
-  unifiedWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
+  unifiesWithBracketedConstructor = bracketedConstructor.unifyTerm(term, context, verifyAhead);
 
-  return unifiedWithBracketedConstructor;
+  return unifiesWithBracketedConstructor;
 }
 
 function unifyWithConstructors(term, context, verifyAhead) {
-  let unifiedWithConstructors;
+  let unifiesWithConstructors;
 
   const constructors = context.getConstructors();
 
-  unifiedWithConstructors = constructors.some((constructor) => {
-    const unifiedWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
+  unifiesWithConstructors = constructors.some((constructor) => {
+    const unifiesWithConstructor = constructor.unifyTerm(term, context, verifyAhead);
 
-    if (unifiedWithConstructor) {
+    if (unifiesWithConstructor) {
       return true;
     }
   });
 
-  return unifiedWithConstructors;
+  return unifiesWithConstructors;
 }
 
 function verifyTermAsVariable(term, localContext, verifyAhead) {
-  let termVerifiedAsVariable = false;
+  let termVerifiesAsVariable = false;
 
   const { Variable } = dom,
         context = localContext, ///
@@ -44,10 +44,10 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
 
     localContext.trace(`Verifying the '${termString}' term as a variable...`);
 
-    const variableVerified = variable.verify(localContext);
+    const variableVerifies = variable.verify(localContext);
 
-    if (variableVerified) {
-      let verifiedAhead;
+    if (variableVerifies) {
+      let verifiesAhead;
 
       const variableName = variable.getName();
 
@@ -57,17 +57,17 @@ function verifyTermAsVariable(term, localContext, verifyAhead) {
 
       term.setType(type);
 
-      verifiedAhead = verifyAhead();
+      verifiesAhead = verifyAhead();
 
-      termVerifiedAsVariable = verifiedAhead; ///
+      termVerifiesAsVariable = verifiesAhead; ///
     }
 
-    if (termVerifiedAsVariable) {
+    if (termVerifiesAsVariable) {
       localContext.debug(`...verified the '${termString}' term as a variable.`);
     }
   }
 
-  return termVerifiedAsVariable;
+  return termVerifiesAsVariable;
 }
 
 const verifyMixins = [

package/src/substitutions.js

@@ -200,20 +200,19 @@ export default class Substitutions {
     specificContext.trace(`Removed the ${substitutionString} substitution.`);
   }
 
-  matchSubstitutions(substitutions) {
+  correlateSubstitutions(substitutions) {
     const array = substitutions.getArray(),
           arrayA = array, ///
           arrayB = this.array,  ///
           correlates = correlate(arrayA, arrayB, (substitutionA, substitutionB) => {
-            const substitutionAMatchesSubstitutionB = substitutionA.match(substitutionB);
+            const substitutionAIsEQualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
 
-            if (substitutionAMatchesSubstitutionB) {
+            if (substitutionAIsEQualToSubstitutionB) {
               return true;
             }
-          }),
-          match = correlates; ///
+          });
 
-    return match;
+    return correlates;
   }
 
   removeTrivialSubstitutions()  {

package/src/unifier/equantional.js

@@ -0,0 +1,90 @@
+"use strict";
+
+import Unifier from "../unifier";
+
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/term");
+
+class EquationalUnifier extends Unifier {
+  equateTerms(leftTermNode, rightTermNode, context) {
+    let termsEquate;
+
+    const generalNonTerminalNode = leftTermNode, ///
+          specificNonTerminalNode = rightTermNode, ///
+          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, context);
+
+    termsEquate = nonTerminalNodeUnifies; ///
+
+    return termsEquate;
+  };
+
+  equateStatements(statementANode, statementBNode, context) {
+    let statementsEquate;
+
+    const generalNonTerminalNode = statementANode, ///
+          specificNonTerminalNode = statementBNode, ///
+          nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, context);
+
+    statementsEquate = nonTerminalNodeUnifies; ///
+
+    return statementsEquate;
+  };
+
+  static maps = [
+    {
+      generalNodeQuery: termNodeQuery,  ///
+      specificNodeQuery: termNodeQuery, ///
+      unify: (leftTermNode, rightTermNode, context) => {
+        let termUnifies = false;
+
+        if (!termUnifies) {
+          const depth = Infinity,
+                leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode, depth);
+
+          if (leftTermNodeMatchesRightTermNode) {
+            termUnifies = true;
+          }
+        }
+
+        if (!termUnifies) {
+          const equivalences = context.getEquivalences(),
+                termNodes = [
+                  leftTermNode,
+                  rightTermNode
+                ],
+                equivalence = equivalences.findEquivalenceByTermNodes(termNodes);
+
+          if (equivalence !== null) {
+            termUnifies = true;
+          }
+        }
+
+        if (!termUnifies) {
+          const depth = 1,
+                leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode, depth);
+
+          if (leftTermNodeMatchesRightTermNode) {
+            const leftNonTerminalNode = leftTermNode, ///
+                  rightNonTerminalNode = rightTermNode, ///
+                  leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+                  rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+                  leftChildNodes = leftNonTerminalNodeChildNodes, ///
+                  rightChildNodes = rightNonTerminalNodeChildNodes, ///
+                  childNodesUnify = equationalUnifier.unifyChildNodes(leftChildNodes, rightChildNodes, context);
+
+            if (childNodesUnify) {
+              termUnifies = true;
+            }
+          }
+        }
+
+        return termUnifies;
+      }
+    }
+  ];
+}
+
+const equationalUnifier = new EquationalUnifier();
+
+export default equationalUnifier;

package/src/unifier/intrinsicLevel.js

@@ -10,13 +10,13 @@ const termNodeQuery = nodeQuery("/term"),
 
 class IntrinsicLevelUnifier extends Unifier {
   unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext) {
-    let unifiedAtIntrinsicLevel;
+    let unifiesAtIntrinsicLevel;
 
-    const nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+    const nonTerminalNodeUnifies = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-    unifiedAtIntrinsicLevel = nonTerminalNodeUnified; ///
+    unifiesAtIntrinsicLevel = nonTerminalNodeUnifies; ///
 
-    return unifiedAtIntrinsicLevel;
+    return unifiesAtIntrinsicLevel;
   }
 
   static maps = [
@@ -24,7 +24,7 @@ class IntrinsicLevelUnifier extends Unifier {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
-        let termUnified;
+        let termUnifies;
 
         const { Term, Variable } = dom,
               termNode = specificTermNode, ///
@@ -40,9 +40,9 @@ class IntrinsicLevelUnifier extends Unifier {
 
         const term = Term.fromTermNode(termNode, context);
 
-        termUnified = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+        termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
 
-        return termUnified;
+        return termUnifies;
       }
     }
   ];