occam-verify-cli 1.0.220 → 1.0.224

package/src/dom/theorem.js

@@ -6,16 +6,16 @@ import { domAssigned } from "../dom";
 
 export default domAssigned(class Theorem extends TopLevelAssertion {
   verify() {
-    let verified;
+    let verifies;
 
     const fileContext = this.getFileContext(),
           theoremString = this.string;  ///
 
     fileContext.trace(`Verifying the '${theoremString}' theorem...`);
 
-    verified = super.verify();
+    verifies = super.verify();
 
-    if (verified) {
+    if (verifies) {
       const theorem = this; ///
 
       fileContext.addTheorem(theorem);
@@ -23,7 +23,7 @@ export default domAssigned(class Theorem extends TopLevelAssertion {
       fileContext.debug(`...verified the '${theoremString}' theorem.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   static name = "Theorem";

package/src/dom/topLevelAssertion.js

@@ -64,13 +64,6 @@ export default class TopLevelAssertion {
     return supposition;
   }
 
-  isUnconditional() {
-    const suppositionsLength = this.suppositions.length,
-          unconditional = (suppositionsLength === 0);
-
-    return unconditional;
-  }
-
   matchMetavariableName(metavariableName) {
     const metavariableNameMatches = this.labels.some((label) => {
       const metavariableNameMatches = label.matchMetavariableName(metavariableName);
@@ -84,150 +77,123 @@ export default class TopLevelAssertion {
   }
 
   verify() {
-    let verified = false;
+    let verifies = false;
 
-    const labelsVerified = this.verifyLabels();
+    const labelsVerify = this.verifyLabels();
 
-    if (labelsVerified) {
+    if (labelsVerify) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             context = localContext, ///
-            suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(context);
+            suppositionsVerify = this.suppositions.every((supposition) => {
+              const suppositionVerifies = supposition.verify(context);
 
-              if (suppositionVerified) {
+              if (suppositionVerifies) {
                 return true;
               }
             });
 
-      if (suppositionsVerified) {
-        const deductionVerified = this.deduction.verify(context);
+      if (suppositionsVerify) {
+        const deductionVerifies = this.deduction.verify(context);
 
-        if (deductionVerified) {
+        if (deductionVerifies) {
           if (this.proof === null) {
-            verified = true;
+            verifies = true;
           } else {
             const substitutions = Substitutions.fromNothing(),
-                  proofVerified = this.proof.verify(substitutions, this.deduction, context);
+                  proofVerifies = this.proof.verify(substitutions, this.deduction, context);
 
-            verified = proofVerified; ///
+            verifies = proofVerifies; ///
           }
         }
       }
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyLabels() {
-    const labelsVerified = this.labels.every((label) => {
+    const labelsVerify = this.labels.every((label) => {
       const nameOnly = true,
-            labelVerified = label.verify(nameOnly);
+            labelVerifies = label.verify(nameOnly);
 
-      if (labelVerified) {
+      if (labelVerifies) {
         return true;
       }
     });
 
-    return labelsVerified;
-  }
-
-  unifyStatement(statement, context) {
-    let statementUnified;
-
-    const statementString = statement.getString(),
-          axiomLemmaTheoremConjecture = this, ///
-          axiomLemmaTheoremConjectureString = axiomLemmaTheoremConjecture.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture...`);
-
-    const suppositions = this.getSuppositions(),
-          suppositionsLength = suppositions.length;
-
-    if (suppositionsLength === 0) {
-      const substitutions = Substitutions.fromNothing(),
-            localContext = LocalContext.fromFileContext(this.fileContext),
-            generalContext = localContext,  ///
-            specificContext = context,  ///
-            statementUnifiedWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
-
-      statementUnified = statementUnifiedWithDeduction;  ///
-    }
-
-    if (statementUnified) {
-      context.debug(`...unified the '${statementString}' statement with the '${axiomLemmaTheoremConjectureString}' axiom, lemma, theorem or conjecture.`);
-    }
-
-    return statementUnified;
+    return labelsVerify;
   }
 
   unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext) {
-    let deductionUnified;
+    let deductionUnifies;
 
-    const statementUnified = this.deduction.unifyStatement(statement, substitutions, generalContext, specificContext);  ///
+    const statementUnifies = this.deduction.unifyStatement(statement, substitutions, generalContext, specificContext);  ///
 
-    deductionUnified = statementUnified; ///
+    deductionUnifies = statementUnifies; ///
 
-    return deductionUnified;
+    return deductionUnifies;
   }
 
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
-    let statementAndStepsOrSubproofsUnified = false;
+    let statementAndStepsOrSubproofsUnify = false;
 
     const localContext = LocalContext.fromFileContext(this.fileContext),
           generalContext = localContext, ///
           specificContext = context, ///
-          statementUnifiedWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
+          statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
 
-    if (statementUnifiedWithDeduction) {
-      const stepsOrSubproofsUnifiedWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
+    if (statementUnifiesWithDeduction) {
+      const stepsOrSubproofsUnifyWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifiedWithSuppositions) {
+      if (stepsOrSubproofsUnifyWithSuppositions) {
         const substitutionsResolved = substitutions.areResolved();
 
-        statementAndStepsOrSubproofsUnified = substitutionsResolved; ///
+        if (substitutionsResolved) {
+          statementAndStepsOrSubproofsUnify = true;
+        }
       }
     }
 
-    return statementAndStepsOrSubproofsUnified;
+    return statementAndStepsOrSubproofsUnify;
   }
 
   unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
-    let stepsOrSubproofsUnifiedWithSupposition = false;
+    let stepsOrSubproofsUnifyWithSupposition = false;
 
     const context = specificContext,  ///
-          suppositionUnifiedIndependently = supposition.unifyIndependently(substitutions, context);
+          suppositionUnifiesIndependently = supposition.unifyIndependently(substitutions, context);
 
-    if (suppositionUnifiedIndependently) {
-      stepsOrSubproofsUnifiedWithSupposition = true;
+    if (suppositionUnifiesIndependently) {
+      stepsOrSubproofsUnifyWithSupposition = true;
     } else {
       const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnified = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
+        const stepOrSubproofUnifies = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
 
-        if (stepOrSubproofUnified) {
+        if (stepOrSubproofUnifies) {
           return true;
         }
       }) || null;
 
       if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiedWithSupposition = true;
+        stepsOrSubproofsUnifyWithSupposition = true;
       }
     }
 
-    return stepsOrSubproofsUnifiedWithSupposition;
+    return stepsOrSubproofsUnifyWithSupposition;
   }
 
   unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {
     stepsOrSubproofs = reverse(stepsOrSubproofs); ///
 
-    const stepsOrSubproofsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const stepsOrSubproofsUnifiedWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
+    const stepsOrSubproofsUnifyWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
+      const stepsOrSubproofsUnifyWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
 
-      if (stepsOrSubproofsUnifiedWithSupposition) {
+      if (stepsOrSubproofsUnifyWithSupposition) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifiedWithSuppositions;
+    return stepsOrSubproofsUnifyWithSuppositions;
   }
 
   toJSON() {
@@ -255,7 +221,7 @@ export default class TopLevelAssertion {
           suppositions = suppositionsFromJSON(json, fileContext),
           signature = signatureFromJSON(json, fileContext),
           proof = null,
-          string = stringFromLabelsAndDeduction(labels, deduction),
+          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
           topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
 
     return topLevelAssertion;
@@ -273,7 +239,7 @@ export default class TopLevelAssertion {
           deduction = deductionFromDeductionNode(deductionNode, fileContext),
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
           signature = signatureFromSignatureNode(signatureNode, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
+          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
           topLevelAssertion = new Class(fileContext, string, labels, suppositions, deduction, proof, signature);
 
     return topLevelAssertion;
@@ -342,12 +308,27 @@ export function labelsStringFromLabels(labels) {
   return labelsString;
 }
 
-export function stringFromLabelsAndDeduction(labels, deduction) {
-  const deductionString = deduction.getString(),
+export function suppositionsStringFromSuppositions(suppositions) {
+  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
+    const suppositionString = supposition.getString();
+
+    suppositionsString = (suppositionsString !== null) ?
+                           `${suppositionsString}, ${suppositionString}` :
+                             suppositionString;  ///
+
+    return suppositionsString;
+  }, null);
+
+  return suppositionsString;
+}
+
+export function stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
+  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        deductionString = deduction.getString(),
         labelsString = labelsStringFromLabels(labels),
         string = (labelsString === null) ?
                    deductionString : ///
-                    `${labelsString} :: ${deductionString}`;
+                    `${labelsString} :: [${suppositionsString}] ... ${deductionString}`;
 
   return string;
 }

package/src/dom/topLevelMetaAssertion.js

@@ -63,44 +63,44 @@ export default class TopLevelMetaAssertion {
   }
 
   verify() {
-    let verified = false;
+    let verifies = false;
 
-    const labelVerified = this.verifyLabel();
+    const labelVerifies = this.verifyLabel();
 
-    if (labelVerified) {
+    if (labelVerifies) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             context = localContext, ///
-            suppositionsVerified = this.suppositions.every((supposition) => {
-              const suppositionVerified = supposition.verify(context);
+            suppositionsVerify = this.suppositions.every((supposition) => {
+              const suppositionVerifies = supposition.verify(context);
 
-              if (suppositionVerified) {
+              if (suppositionVerifies) {
                 return true;
               }
             });
 
-      if (suppositionsVerified) {
-        const deductionVerified = this.deduction.verify(context);
+      if (suppositionsVerify) {
+        const deductionVerifies = this.deduction.verify(context);
 
-        if (deductionVerified) {
+        if (deductionVerifies) {
           if (this.proof === null) {
-            verified = true;
+            verifies = true;
           } else {
-            const proofVerified = this.proof.verify(this.substitutions, this.deduction, context);
+            const proofVerifies = this.proof.verify(this.substitutions, this.deduction, context);
 
-            verified = proofVerified; ///
+            verifies = proofVerifies; ///
           }
         }
       }
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyLabel() {
     const nameOnly = false,
-          labelVerified = this.label.verify(nameOnly);
+          labelVerifies = this.label.verify(nameOnly);
 
-    return labelVerified;
+    return labelVerifies;
   }
 
   toJSON() {
@@ -128,7 +128,7 @@ export default class TopLevelMetaAssertion {
           suppositions = suppositionsFromJSON(json, fileContext),
           substitutions = substitutionsFromJSON(json, fileContext),
           proof = null,
-          string = stringFromLabelAndDeduction(label, deduction),
+          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
           topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
     return topLevelMetaAssertion;
@@ -145,7 +145,7 @@ export default class TopLevelMetaAssertion {
           deduction = deductionFromDeductionNode(deductionNode, fileContext),
           suppositions = suppositionsFromSuppositionNodes(suppositionNodes, fileContext),
           substitutions = Substitutions.fromNothing(),
-          string = stringFromLabelAndDeduction(label, deduction),
+          string = stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction),
           topLevelMetaAssertion = new Class(fileContext, string, label, suppositions, deduction, proof, substitutions);
 
     return topLevelMetaAssertion;
@@ -172,12 +172,27 @@ function labelStringFromLabel(label) {
   return labelsString;
 }
 
-function stringFromLabelAndDeduction(label, deduction) {
-  const deductionString = deduction.getString(),
+function suppositionsStringFromSuppositions(suppositions) {
+  const suppositionsString = suppositions.reduce((suppositionsString, supposition) => {
+    const suppositionString = supposition.getString();
+
+    suppositionsString = (suppositionsString !== null) ?
+                          `${suppositionsString}, ${suppositionString}` :
+                            suppositionString;  ///
+
+    return suppositionsString;
+  }, null);
+
+  return suppositionsString;
+}
+
+function stringFromLabelASuppositionsAndDeduction(label, suppositions, deduction) {
+  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        deductionString = deduction.getString(),
         labelString = labelStringFromLabel(label),
         string = (labelString === null) ?
                     deductionString : ///
-                     `${labelString} :: ${deductionString}`;
+                     `${labelString} :: [${suppositionsString}] ... ${deductionString}`;
 
   return string;
 }

package/src/dom/type.js

@@ -248,21 +248,33 @@ class Type {
     return type;
   }
 
-  static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
+  static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
+    const typeNode = propertyDeclarationNode.getTypeNode(),
+          type = typeFromTypeNode(typeNode, fileContext);
+
+    return type;
+  }
+
+  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext) {
     const properties = [],
-          provisional = typeDeclarationNode.isProvisional(),
-          typeName = typeDeclarationNode.getTypeName(),
+          provisional = simpleTypeDeclarationNode.isProvisional(),
+          typeName = simpleTypeDeclarationNode.getTypeName(),
           name = typeName,  ///
-          superTypes = superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext),
+          superTypes = superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
   }
 
-  static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
-    const typeNode = propertyDeclarationNode.getTypeNode(),
-          type = typeFromTypeNode(typeNode, fileContext);
+  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+    const provisional = complexTypeDeclarationNode.isProvisional(),
+          typeName = complexTypeDeclarationNode.getTypeName(),
+          name = typeName,
+          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
+          type = new Type(string, name, superTypes, properties, provisional);
 
     return type;
   }
@@ -284,34 +296,17 @@ class Type {
 
     return type;
   }
-
-  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
-    const provisional = complexTypeDeclarationNode.isProvisional(),
-          typeName = complexTypeDeclarationNode.getTypeName(),
-          name = typeName,
-          superTypes = superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          properties = propertiesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          type = new Type(string, name, superTypes, properties, provisional);
-
-    return type;
-  }
 }
 
 export default domAssigned(Type);
 
-function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
-  const superTypeNodes = typeDeclarationNode.getSuperTypeNodes(),
+function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext) {
+  const superTypeNodes = simpleTypeDeclarationNode.getSuperTypeNodes(),
         superTypes = superTypeNodes.map((superTypeNode) => {
           const superType = Type.fromTypeNode(superTypeNode, fileContext);
 
           return superType;
-        }),
-        superTypesLength = superTypes.length;
-
-  if (superTypesLength === 0) {
-    superTypes.push(objectType);
-  }
+        });
 
   return superTypes;
 }
@@ -322,12 +317,7 @@ function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fi
           const superType = Type.fromTypeNode(superTypeNode, fileContext);
 
           return superType;
-        }),
-        superTypesLength = superTypes.length;
-
-  if (superTypesLength === 0) {
-    superTypes.push(objectType);
-  }
+        });
 
   return superTypes;
 }

package/src/dom/variable.js

@@ -62,7 +62,7 @@ export default domAssigned(class Variable {
   }
 
   verify(context) {
-    let verified;
+    let verifies;
 
     const variableString = this.string; ///
 
@@ -76,20 +76,20 @@ export default domAssigned(class Variable {
 
       this.type = type;
 
-      verified = true;
+      verifies = true;
     } else {
       context.debug(`The '${variableString}' variable is not present.`);
     }
 
-    if (verified) {
+    if (verifies) {
       context.debug(`...verified the '${variableString}' variable.`);
     }
 
-    return verified;
+    return verifies;
   }
 
   verifyType(fileContext) {
-    let typeVerified = false;
+    let typeVerifies = false;
 
     const typeString = this.type.getString();
 
@@ -102,18 +102,18 @@ export default domAssigned(class Variable {
     } else {
       this.type = type; ///
 
-      typeVerified = true;
+      typeVerifies = true;
     }
 
-    if (typeVerified) {
+    if (typeVerifies) {
       fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
-    return typeVerified;
+    return typeVerifies;
   }
 
   unifyTerm(term, substitutions, generalContext, specificContext) {
-    let termUnified = false;
+    let termUnifies = false;
 
     const termString = term.getString(),
           variableString = this.string; ///
@@ -124,11 +124,12 @@ export default domAssigned(class Variable {
           substitutionPresent = substitutions.isSubstitutionPresentByVariable(variable);
 
     if (substitutionPresent) {
-      const substitution = substitutions.findSubstitutionByVariable(variable),
-            substitutionTermEqualToTerm = substitution.isTermEqualTo(term);
+      const context = specificContext,  ///
+            substitution = substitutions.findSubstitutionByVariable(variable),
+            substitutionTermEqualToTerm = substitution.isTermEqualTo(term, context);
 
       if (substitutionTermEqualToTerm) {
-        termUnified = true;
+        termUnifies = true;
       }
     } else {
       const { TermSubstitution } = dom,
@@ -139,14 +140,14 @@ export default domAssigned(class Variable {
 
       substitutions.addSubstitution(substitution, specificContext);
 
-      termUnified = true;
+      termUnifies = true;
     }
 
-    if (termUnified) {
+    if (termUnifies) {
       specificContext.debug(`...unified the '${termString}' term with the '${variableString}' variable.`);
     }
 
-    return termUnified;
+    return termUnifies;
   }
 
   toJSON() {