occam-verify-cli 0.0.1072 → 0.0.1074

package/src/equality.js

@@ -3,10 +3,12 @@
 import shim from "./shim";
 import equalityUnifier from "./unifier/equality";
 import EqualityAssignment from "./assignment/equality";
+import VariableAssignment from "./assignment/variable";
 
 import { nodeQuery } from "./utilities/query";
 
-const leftTermNodeQuery = nodeQuery("/equality/term[0]"),
+const variableNodeQuery = nodeQuery("/term/variable!"),
+      leftTermNodeQuery = nodeQuery("/equality/term[0]"),
       rightTermNodeQuery = nodeQuery("/equality/term[1]");
 
 export default class Equality {
@@ -28,6 +30,25 @@ export default class Equality {
     return this.rightTerm;
   }
 
+  getType() {
+    let type;
+
+    const leftTermType = this.leftTerm.getType(),
+          rightTermType = this.rightTerm.getType(),
+          leftTermTypeEqualToOrSubTypeOfRightTermType = leftTermType.isEqualToOrSubTypeOf(rightTermType),
+          rightTermTypeEqualToOrSubTypeOfLeftTermType = rightTermType.isEqualToOrSubTypeOf(leftTermType);
+
+    if (leftTermTypeEqualToOrSubTypeOfRightTermType) {
+      type = leftTermType;  ///
+    }
+
+    if (rightTermTypeEqualToOrSubTypeOfLeftTermType) {
+      type = rightTermType; ///
+    }
+
+    return type;
+  }
+
   isReflexive() {
     const leftTermMatchesRightTerm = this.leftTerm.match(this.rightTerm),
           reflexive = leftTermMatchesRightTerm; ///
@@ -51,25 +72,57 @@ export default class Equality {
 
     localContext.trace(`Verifying the '${equalityString}' equality...`);
 
-    let verifiedWhenStated = false,
-        verifiedWhenDerived = false;
-
-    if (stated) {
-      verifiedWhenStated = this.verifyWhenStated(localContext);
-    } else {
-      verifiedWhenDerived = this.verifyWhenDerived(localContext);
-    }
+    const termsVerified = this.verifyTerms(localContext);
 
-    if (verifiedWhenStated || verifiedWhenDerived) {
-      if (assignments !== null) {
-        const equality = this,  //
-              equalityAssignment = EqualityAssignment.fromEquality(equality),
-              assignment = equalityAssignment; ///
+    if (termsVerified) {
+      let verifiedWhenStated = false,
+          verifiedWhenDerived = false;
 
-        assignments.push(assignment);
+      if (stated) {
+        verifiedWhenStated = this.verifyWhenStated(localContext);
+      } else {
+        verifiedWhenDerived = this.verifyWhenDerived(localContext);
       }
 
-      verified = true;
+      if (verifiedWhenStated || verifiedWhenDerived) {
+        if (assignments !== null) {
+          const { Variable } = shim,
+                type = this.getType(),
+                leftTermNode = this.leftTerm.getNode(),
+                rightTermNode = this.rightTerm.getNode(),
+                leftVariableNode = variableNodeQuery(leftTermNode),
+                rightVariableNode = variableNodeQuery(rightTermNode),
+                leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, localContext),
+                rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, localContext);
+
+          let assignment;
+
+          if (leftVariable !== null) {
+            const leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);
+
+            assignment = leftVariableAssignment;  ///
+
+            assignments.push(assignment);
+          }
+
+          if (rightVariable !== null) {
+            const rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);
+
+            assignment = rightVariableAssignment;  ///
+
+            assignments.push(assignment);
+          }
+
+          const equality = this,  //
+                equalityAssignment = EqualityAssignment.fromEquality(equality);
+
+          assignment = equalityAssignment; ///
+
+          assignments.push(assignment);
+        }
+
+        verified = true;
+      }
     }
 
     if (verified) {
@@ -122,9 +175,7 @@ export default class Equality {
 
     localContext.trace(`Verifying the '${equalityString}' stated equality...`);
 
-    const termsVerified = this.verifyTerms(localContext);
-
-    verifiedWhenStated = termsVerified; ///
+    verifiedWhenStated = true;
 
     if (verifiedWhenStated) {
       localContext.debug(`...verified the '${equalityString}' stated equality.`);
@@ -134,19 +185,15 @@ export default class Equality {
   }
 
   verifyWhenDerived(localContext) {
-    let verifiedWhenDerived = false;
+    let verifiedWhenDerived;
 
     const equalityString = this.string; ///
 
     localContext.trace(`Verifying the '${equalityString}' derived equality...`);
 
-    const termsVerified = this.verifyTerms(localContext);
+    const equal = this.isEqual(localContext);
 
-    if (termsVerified) {
-      const equal = this.isEqual(localContext);
-
-      verifiedWhenDerived = equal;  ///
-    }
+    verifiedWhenDerived = equal;  ///
 
     if (verifiedWhenDerived) {
       localContext.debug(`...verified the '${equalityString}' derived equality.`);

package/src/equivalence.js

@@ -2,7 +2,6 @@
 
 import { nodeQuery } from "./utilities/query";
 import { stripBracketsFromTermNode } from "./utilities/brackets";
-import { variableNameFromVariableNode } from "./utilities/name";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
@@ -15,17 +14,18 @@ export default class Equivalence {
     return this.terms;
   }
 
-  setTerms(terms) {
-    this.terms = terms;
-  }
+  addTerm(term, localContext) {
+    const termString = term.getString(),
+          equivalenceString = this.asString();  ///
+
+    localContext.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence.`);
 
-  addTerm(term) {
     this.terms.push(term);
   }
 
-  getType(localContext) {
+  getType() {
     const type = this.terms.reduce((type, term) => {
-      const termType = termTypeFromTerm(term, localContext);
+      const termType = term.getType();
 
       if (type === null) {
         type = termType;  ///
@@ -43,10 +43,10 @@ export default class Equivalence {
     return type;
   }
 
-  matchType(type, localContext) {
+  matchType(type) {
     const typeA = type; ///
 
-    type = this.getType(localContext);
+    type = this.getType();
 
     const typeB = type; ///
 
@@ -198,6 +198,27 @@ export default class Equivalence {
     return implicitlyGroundedTerms;
   }
 
+  asString() {
+    let string;
+
+    string = this.terms.reduce((string, term) => {
+      const termString = term.getString();
+
+      string = (string === null) ?
+                 termString :
+                    `${string} ${termString}`;
+
+      return string;
+    }, null);
+
+    const type = this.getType(),
+          typeString = type.getString();
+
+    string = `${string}:${typeString}`;
+
+    return string;
+  }
+
   static merge(leftEquivalence, rightEquivalence) {
     const leftEquivalenceTerms = leftEquivalence.getTerms(),
           rightEquivalenceTerms = rightEquivalence.getTerms(),
@@ -220,22 +241,3 @@ export default class Equivalence {
     return equivalence;
   }
 }
-
-function termTypeFromTerm(term, localContext) {
-  let termType;
-
-  const termNode = term.getNode(),
-        variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    const variableName = variableNameFromVariableNode(variableNode),
-          variable = localContext.findVariableByVariableName(variableName),
-          variableType = variable.getType();
-
-    termType = variableType;  ///
-  } else {
-    termType = term.getType();
-  }
-
-  return termType;
-}

package/src/mixins/term/verify.js

@@ -4,7 +4,7 @@ import Variable from "../../variable";
 
 import { nodeQuery } from "../../utilities/query";
 
-const variableNodeQuery = nodeQuery("/term/variable");
+const variableNodeQuery = nodeQuery("/term/variable!");
 
 function verifyTermAsVariable(term, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;

package/src/proofStep.js

@@ -7,6 +7,7 @@ import QualifiedStatement from "./statement/qualified";
 import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
+import { assignAssignments } from "./utilities/assignments";
 
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement"),
@@ -91,7 +92,13 @@ class ProofStep {
             assignments = [],
             unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
 
-      verified = unqualifiedStatementVerified;  ///
+      if (unqualifiedStatementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          verified = true;
+        }
+      }
     }
 
     if (verified) {

package/src/statement/unqualified.js

@@ -50,7 +50,6 @@ class UnqualifiedStatement {
       if (verified) {
         localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
       }
-
     } else {
       localContext.debug(`Cannot verify the '${unqualifiedStatementString}' unqualified statement because it is nonsense.`);
     }

package/src/type.js

@@ -36,37 +36,24 @@ class Type {
   }
 
   isSubTypeOf(type) {
-    let subTypeOf = false;
-
-    let superType = this.superType;
-
-    while (superType !== null) {
-      if (superType === type) {
-        subTypeOf = true;
-
-        break;
-      }
-
-      superType = superType.getSuperType();
+    let subTypeOf;
+
+    if (false) {
+      ///
+    } else if (this === objectType) {
+      subTypeOf = false;
+    } else if (this.superType === type) {
+      subTypeOf = true;
+    } else {
+      subTypeOf = this.superType.isSubTypeOf(type);
     }
 
     return subTypeOf;
   }
 
   isSuperTypeOf(type) {
-    let superTypeOf = false;
-
-    let superType = type.getSuperType();
-
-    while (superType !== null) {
-      if (superType === this) {
-        superTypeOf = true;
-
-        break;
-      }
-
-      superType = superType.getSuperType();
-    }
+    const subTypeOf = type.isSubTypeOf(this),
+          superTypeOf = subTypeOf;  ///
 
     return superTypeOf;
   }

package/src/utilities/equivalences.js

@@ -6,9 +6,9 @@ import Equivalence from "../equivalence";
 
 const { push, compress, separate } = arrayUtilities;
 
-export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
-  const typesA = typesFromEquivalences(equivalencesA, localContext),
-        typesB = typesFromEquivalences(equivalencesB, localContext),
+export function mergeEquivalences(equivalencesA, equivalencesB) {
+  const typesA = typesFromEquivalences(equivalencesA),
+        typesB = typesFromEquivalences(equivalencesB),
         types = [
           ...typesA,
           ...typesB
@@ -23,8 +23,8 @@ export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
   const equivalences = types.map((type) => {
     let equivalence;
 
-    const equivalenceA = findEquivalenceByType(equivalencesA, type, localContext),
-          equivalenceB = findEquivalenceByType(equivalencesB, type, localContext);
+    const equivalenceA = findEquivalenceByType(equivalencesA, type),
+          equivalenceB = findEquivalenceByType(equivalencesB, type);
 
     if ((equivalenceA !== null) && (equivalenceB !== null)) {
       const leftEquivalence = equivalenceA, ///
@@ -43,9 +43,9 @@ export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
   return equivalences;
 }
 
-export function findEquivalenceByType(equivalences, type, localContext) {
+export function findEquivalenceByType(equivalences, type) {
   const equivalence = equivalences.find((equivalence) => {
-    const equivalenceMatchesType = equivalence.matchType(type, localContext);
+    const equivalenceMatchesType = equivalence.matchType(type);
 
     if (equivalenceMatchesType) {
       return true;
@@ -127,9 +127,9 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
   }
 }
 
-function typesFromEquivalences(equivalences, localContext) {
+function typesFromEquivalences(equivalences) {
   const types = equivalences.map((equivalence) => {
-    const type = equivalence.getType(localContext);
+    const type = equivalence.getType();
 
     return type;
   });

package/src/variable.js

@@ -70,14 +70,14 @@ class Variable {
           variableName = variableNameFromVariableNode(variableNode),
           variable = localContext.findVariableByVariableName(variableName);
 
-    if (variable === null) {
-      localContext.debug(`The '${variableString}' variable is not present.`);
-    } else {
+    if (variable !== null) {
       const type = variable.getType();
 
       this.type = type;
 
       verified = true;
+    } else {
+      localContext.debug(`The '${variableString}' variable is not present.`);
     }
 
     if (verified) {
@@ -248,11 +248,16 @@ class Variable {
   }
 
   static fromVariableNodeAndType(variableNode, type, localContext) {
-    const node = variableNode,  ///
-          variableName = variableNameFromVariableNode(variableNode),
-          string = localContext.nodeAsString(node),
-          name = variableName,  ///
-          variable = new Variable(localContext, string, node, name, type);
+    let variable = null;
+
+    if (variableNode !== null) {
+      const node = variableNode,  ///
+            variableName = variableNameFromVariableNode(variableNode),
+            string = localContext.nodeAsString(node),
+            name = variableName;  ///
+
+      variable = new Variable(localContext, string, node, name, type);
+    }
 
     return variable;
   }