occam-verify-cli 1.0.437 → 1.0.444

package/src/element/axiomLemmaTheoremConjecture.js

@@ -81,16 +81,45 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return supposition;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = this.labels.some((label) => {
-      const metavariableNameMatches = label.matchMetavariableName(metavariableName);
+  compareMetavariableName(metavariableName) {
+    const comparesToMetavariableName = this.labels.some((label) => {
+      const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
 
-      if (metavariableNameMatches) {
+      if (labelComparesToMetavariableName) {
         return true;
       }
     });
 
-    return metavariableNameMatches;
+    return comparesToMetavariableName;
+  }
+
+  correlateHypotheses(context) {
+    let correlatesToHypotheses;
+
+    const hypothetical = this.isHypothetical();
+
+    if (hypothetical) {
+      const steps = context.getSteps(),
+            topLevelAssertionString = this.getString();  ///
+
+      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`, this.node);
+
+      correlatesToHypotheses = correlate(this.hypotheses, steps, (hypothesis, step) => {
+        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
+
+        if (hypothesesEqualToStep) {
+          return true;
+        }
+      });
+
+      if (correlatesToHypotheses) {
+        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`, this.node);
+      }
+    } else {
+      correlatesToHypotheses = true
+    }
+
+    return correlatesToHypotheses;
   }
 
   verify() {
@@ -171,35 +200,6 @@ export default class AxiomLemmaTheoremConjecture extends Element {
     return proofVerifies;
   }
 
-  correlateHypotheses(context) {
-    let hypothesesCorrelate;
-
-    const hypothetical = this.isHypothetical();
-
-    if (hypothetical) {
-      const steps = context.getSteps(),
-            topLevelAssertionString = this.string;  ///
-
-      context.trace(`Correlating the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture...`, this.node);
-
-      hypothesesCorrelate = correlate(this.hypotheses, steps, (hypothesis, step) => {
-        const hypothesesEqualToStep = hypothesis.isEqualToStep(step, context);
-
-        if (hypothesesEqualToStep) {
-          return true;
-        }
-      });
-
-      if (hypothesesCorrelate) {
-        context.debug(`...correlated the hypotheses of the '${topLevelAssertionString}' axiom, lemma, theorem or conjecture.`, this.node);
-      }
-    } else {
-      hypothesesCorrelate = true
-    }
-
-    return hypothesesCorrelate;
-  }
-
   unifyStatementWithDeduction(statement, substitutions, context) {
     let statementUnifiesWithDeduction = false;
 
@@ -215,9 +215,9 @@ export default class AxiomLemmaTheoremConjecture extends Element {
   unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
     let statementAndStepsOrSubproofsUnifies = false;
 
-    const hypothesesCorrelate = this.correlateHypotheses(context);
+    const correlatesToHypotheses = this.correlateHypotheses(context);
 
-    if (hypothesesCorrelate) {
+    if (correlatesToHypotheses) {
       const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
 
       if (statementUnifiesWithDeduction) {

package/src/element/{statement/combinator → combinator}/bracketed.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import CombinatorStatement from "../../statement/combinator";
+import Combinator from "../combinator";
 
-import { define } from "../../../elements";
-import { bracketedCombinatorStatementFromNothing } from "../../../utilities/instance";
+import { define } from "../../elements";
+import { bracketedCombinatorFromNothing } from "../../utilities/instance";
 
-export default define(class BracketedCombinatorStatement extends CombinatorStatement {
+export default define(class BracketedCombinator extends Combinator {
   unifyStatement(statement, assignments, stated, context) {
     let statementUnifies;
 
@@ -22,11 +22,11 @@ export default define(class BracketedCombinatorStatement extends CombinatorState
     return statementUnifies;
   }
 
-  static name = "BracketedCombinatorStatement";
+  static name = "BracketedCombinator";
 
   static fromNothing() {
-    const bracketedCombinatorStatement = bracketedCombinatorStatementFromNothing();
+    const bracketedCombinator = bracketedCombinatorFromNothing();
 
-    return bracketedCombinatorStatement;
+    return bracketedCombinator;
   }
 });

package/src/element/combinator.js

@@ -0,0 +1,90 @@
+"use strict";
+
+import Element from "../element";
+
+import { define } from "../elements";
+import { verifyCombinator } from "../process/verify";
+import { unifyStatementWithCombinator } from "../process/unify";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+export default define(class Combinator extends Element {
+  constructor(context, string, node, statement) {
+    super(context, string, node)
+
+    this.statement = statement;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  verify() {
+    let verifies;
+
+    const node = this.getNode(),
+          context = this.getContext(),
+          combinatorString = this.getString();  ///
+
+    context.trace(`Verifying the '${combinatorString}' combinator...`, node);
+
+    const combinator = this,  ///
+          combinatorVerifies = verifyCombinator(combinator, context);
+
+    if (combinatorVerifies) {
+      verifies = true;
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${combinatorString}' combinator.`, node);
+    }
+
+    return verifies;
+  }
+
+  unifyStatement(statement, assignments, stated, context) {
+    let statementUnifies;
+
+    const statementString = statement.getString(),
+          combinatorString = this.getString();  ///
+
+    context.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
+
+    const specifiContext = context; ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specifiContext; ///
+
+    const combinator = this, ///
+          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, generalContext, specifiContext);
+
+    statementUnifies = statementUnifiesWithCombinator; ///
+
+    if (statementUnifies) {
+      context.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
+    }
+
+    return statementUnifies;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          statement = statementJSON,  ///
+          json = {
+            statement,
+          };
+
+    return json;
+  }
+
+  static name = "Combinator";
+
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
+          combinator = new Combinator(statement);
+
+    return combinator;
+  }
+});

package/src/element/conclusion.js

@@ -24,25 +24,27 @@ export  default define(class Conclusion extends Element {
 
     context = temporaryContext; ///
 
-    const conclusionString = this.string;  ///
+    const node = this.getNode(),
+          conclusionString = this.getString();  ///
 
-    context.trace(`Verifying the '${conclusionString}' conclusion...`, this.node);
+    context.trace(`Verifying the '${conclusionString}' conclusion...`, node);
 
-    if (this.statement !== null) {
+    if (this.statement === null) {
+      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, node);
+    } else {
       const stated = true,
             assignments = null,
-            statementVerifies = this.statement.verify(assignments, stated, context);
-
-      verifies = statementVerifies; ///
+            statementValidates = this.statement.validate(assignments, stated, context);
 
-    } else {
-      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, this.node);
+      if (statementValidates) {
+        verifies = true;
+      }
     }
 
     if (verifies) {
-      this.context = context;
+      this.setContext(context);
 
-      context.debug(`...verified the '${conclusionString}' conclusion.`, this.node);
+      context.debug(`...verified the '${conclusionString}' conclusion.`, node);
     }
 
     return verifies;

package/src/element/{term/constructor → constructor}/bracketed.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import elements from "../../../elements";
+import elements from "../../elements";
 import Constructor from "../constructor";
 
-import { define } from "../../../elements";
-import { bracketedConstructorTermFromNothing } from "../../../utilities/instance";
+import { define } from "../../elements";
+import { bracketedConstructorFromNothing } from "../../utilities/instance";
 
 export default define(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
@@ -55,8 +55,8 @@ export default define(class BracketedConstructor extends Constructor {
   static name = "BracketedConstructor";
 
   static fromNothing() {
-    const bracketedConstructorTerm = bracketedConstructorTermFromNothing();
+    const bracketedConstructor = bracketedConstructorFromNothing();
 
-    return bracketedConstructorTerm;
+    return bracketedConstructor;
   }
 });

package/src/element/{term/constructor.js → constructor.js}

@@ -1,13 +1,15 @@
 "use strict";
 
-import elements from "../../elements";
+import Element from "../element";
 
-import { define } from "../../elements";
-import { unifyTermWithConstructorTerm } from "../../process/unify";
-import { termFromJSON, termToTermJSON } from "../../utilities/json";
+import { define } from "../elements";
+import { unifyTermWithConstructor } from "../process/unify";
+import { termFromJSON, termToTermJSON } from "../utilities/json";
+
+export default define(class Constructor extends Element {
+  constructor(context, string, node, term) {
+    super(context, string, node);
 
-export default define(class ConstructorTerm {
-  constructor(term) {
     this.term = term;
   }
 
@@ -15,24 +17,22 @@ export default define(class ConstructorTerm {
     return this.term;
   }
 
-  getType() { return this.term.getType(); }
-
-  getString() { return this.term.getString(); }
-
   isProvisional() { return this.term.isProvisional(); }
 
+  getType() { return this.term.getType(); }
+
   setType(type) { this.term.setType(type); }
 
   unifyTerm(term, context, verifyAhead) {
     let termUnifies = false;
 
     const termString = term.getString(),
-          constructorTermString = this.getString();
+          constructorString = this.getString();
 
-    context.trace(`Unifying the '${termString}' term with the '${constructorTermString}' constructor's term...`);
+    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
 
-    const constructorTerm = this, ///
-          termUnifiesWithConstructor = unifyTermWithConstructorTerm(term, constructorTerm, context);
+    const constructor = this, ///
+          termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, context);
 
     if (termUnifiesWithConstructor) {
       let verifiesAhead;
@@ -47,7 +47,7 @@ export default define(class ConstructorTerm {
     }
 
     if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the '${constructorTermString}' constructor's term.`);
+      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`);
     }
 
     return termUnifies;
@@ -63,19 +63,11 @@ export default define(class ConstructorTerm {
     return json;
   }
 
-  static name = "ConstructorTerm";
+  static name = "Constructor";
 
   static fromJSON(json, context) {
     const term = termFromJSON(json, context),
-          constructor = new ConstructorTerm(term);
-
-    return constructor;
-  }
-
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    const { Term } = elements,
-          term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, context),
-          constructor = new ConstructorTerm(term);
+          constructor = new Constructor(term);
 
     return constructor;
   }

package/src/element/declaration/combinator.js

@@ -25,7 +25,7 @@ export default define(class CombinatorDeclaration extends Declaration {
 
     context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`, node);
 
-    const combinatorVerifies = this.verifyCombinator();
+    const combinatorVerifies = this.combinator.verify();
 
     if (combinatorVerifies) {
       context.addCombinator(this.combinator);
@@ -40,26 +40,5 @@ export default define(class CombinatorDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyCombinator() {
-    let statementVerifies;
-
-    const node = this.getNode(),
-          context = this.getContext(),
-          combinatorString = this.combinator.getString();
-
-    context.trace(`Verifying the '${combinatorString}' combinator...`, node);
-
-    const statement = this.combinator.getStatement(),
-          statementNode = statement.getNode();
-
-    statementVerifies = verifyStatement(statementNode, context);
-
-    if (statementVerifies) {
-      context.debug(`...verified the '${combinatorString}' combinator.`, node);
-    }
-
-    return statementVerifies;
-  }
-
   static name = "CombinatorDeclaration";
 });

package/src/element/declaration/complexType.js

@@ -112,10 +112,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
-          typeNameMatches = this.type.matchTypeName(typeName);
+          typeComparesToTypeName = this.type.compareTypeName(typeName);
 
-    if (typeNameMatches) {
-      context.trace(`The super-type's name matches the ${typeName}' complex type's name.`, node);
+    if (typeComparesToTypeName) {
+      context.trace(`The super-type's name compares to the ${typeName}' complex type's name.`, node);
     } else {
       const oldSuperType = superType;
 
@@ -237,9 +237,9 @@ export default define(class ComplexTypeDeclaration extends Declaration {
 
     const propertyName = property.getName(),
           count = properties.reduce((count, property) => {
-            const propertyNameMatches = property.matchPropertyName(propertyName);
+            const propertyComparesToPropertyName = property.comparePropertyName(propertyName);
 
-            if (propertyNameMatches) {
+            if (propertyComparesToPropertyName) {
               count++;
             }
 
@@ -252,15 +252,15 @@ export default define(class ComplexTypeDeclaration extends Declaration {
       const superTypes = this.type.getSuperTypes(),
             superType = superTypes.find((superType) => {
               const superTypeProperties = superType.getProperties(),
-                    propertyNameMatches = superTypeProperties.some((superTypeProperty) => {
-                      const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
+                    superTypePropertyComparesToPropertyName = superTypeProperties.some((superTypeProperty) => {
+                      const superTypePropertyComparesToPropertyName = superTypeProperty.comparePropertyName(propertyName);
 
-                      if (propertyNameMatches) {
+                      if (superTypePropertyComparesToPropertyName) {
                         return true;
                       }
                     });
 
-              if (propertyNameMatches) {
+              if (superTypePropertyComparesToPropertyName) {
                 return true;
               }
             }) || null;
@@ -291,9 +291,9 @@ export default define(class ComplexTypeDeclaration extends Declaration {
 
     context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`, node);
 
-    const nominalTypeNameMatches = this.type.matchNominalTypeName(nominalTypeName);
+    const typeComparesToNominalTypeName = this.type.compareNominalTypeName(nominalTypeName);
 
-    if (nominalTypeNameMatches) {
+    if (typeComparesToNominalTypeName) {
       propertyNominalTypeNameVerifies = true;
     } else {
       const typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);

package/src/element/declaration/constructor.js

@@ -3,7 +3,7 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { verifyTerm } from "../../process/verify";
+import { validateTerm } from "../../process/validate";
 
 export default define(class ConstructorDeclaration extends Declaration {
   constructor(context, string, node, constructor) {
@@ -28,9 +28,9 @@ export default define(class ConstructorDeclaration extends Declaration {
     const constructorTypeVerifies = this.verifyConstructorType();
 
     if (constructorTypeVerifies) {
-      const constructorVerifies = this.verifyConstructor();
+      const constructorValidates = this.verifyConstructor();
 
-      if (constructorVerifies) {
+      if (constructorValidates) {
         context.addConstructor(this.constructor);
 
         verifies = true;
@@ -45,7 +45,7 @@ export default define(class ConstructorDeclaration extends Declaration {
   }
 
   verifyConstructor() {
-    let constructorVerifies;
+    let constructorValidates = false;
 
     const node = this.getNode(),
           context = this.getContext(),
@@ -54,15 +54,18 @@ export default define(class ConstructorDeclaration extends Declaration {
     context.trace(`Verifying the '${constructorString}' constructor...`, node);
 
     const term = this.constructor.getTerm(),
-          termNode = term.getNode();
+          termNode = term.getNode(),
+          termValidates = validateTerm(termNode, context);
 
-    constructorVerifies = verifyTerm(termNode, context);
+    if (termValidates) {
+      constructorValidates = true;
+    }
 
-    if (constructorVerifies) {
+    if (constructorValidates) {
       context.debug(`...verified the '${constructorString}' constructor.`, node);
     }
 
-    return constructorVerifies;
+    return constructorValidates;
   }
 
   verifyConstructorType() {
@@ -90,9 +93,9 @@ export default define(class ConstructorDeclaration extends Declaration {
     } else {
       const includeSupertypes = false,
             provisional = type.isProvisional(includeSupertypes),
-            provisionalMatches = type.matchProvisional(provisional);
+            typeComparesToProvisional = type.compareProvisional(provisional);
 
-      if (!provisionalMatches) {
+      if (!typeComparesToProvisional) {
         provisional ?
           context.debug(`The '${typeString}' type is present but not provisional.`, node) :
             context.debug(`The '${typeString}' type is present but provisional.`, node);

package/src/element/declaration/simpleType.js

@@ -108,10 +108,10 @@ export default define(class SimpleTypeDeclaration extends Declaration {
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
-          typeNameMatches = this.type.matchTypeName(typeName);
+          typeComparesToTypeName = this.type.compareTypeName(typeName);
 
-    if (typeNameMatches) {
-      context.trace(`The super-type's name matches the ${typeName}' simple type's name.`, node);
+    if (typeComparesToTypeName) {
+      context.trace(`The super-type's name compares to the ${typeName}' simple type's name.`, node);
     } else {
       const oldSuperType = superType;
 

package/src/element/declaration/typePrefix.js

@@ -30,7 +30,7 @@ export default define(class TypePrefixDeclaration extends Declaration {
           typesLength = types.length;
 
     if (typesLength > 0) {
-      context.debug(`Cannot verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, node);
+      context.debug(`Unable to verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, node);
     } else {
       const typePrefixVerifies = this.verifyTypePrefix();
 

package/src/element/declaration/variable.js

@@ -93,9 +93,9 @@ export default define(class VariableDeclaration extends Declaration {
     } else {
       const includeSupertypes = false,
             provisional = type.isProvisional(includeSupertypes),
-            provisionalMatches = type.matchProvisional(provisional);
+            typeComparesToProvisional = type.compareProvisional(provisional);
 
-      if (!provisionalMatches) {
+      if (!typeComparesToProvisional) {
         provisional ?
           context.debug(`The '${typeString}' type is present but not provisional.`, node) :
             context.debug(`The '${typeString}' type is present but provisional.`, node);

package/src/element/deduction.js

@@ -24,24 +24,27 @@ export default define(class Deduction extends Element {
 
     context = temporaryContext; ///
 
-    const deductionString = this.string;  ///
+    const node = this.getNode(),
+          deductionString = this.getString();  ///
 
-    context.trace(`Verifying the '${deductionString}' deduction...`, this.node);
+    context.trace(`Verifying the '${deductionString}' deduction...`, node);
 
-    if (this.statement !== null) {
+    if (this.statement === null) {
+      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, node);
+    } else {
       const stated = true,
             assignments = null,
-            statementVerifies = this.statement.verify(assignments, stated, context);
+            statementVealidates = this.statement.validate(assignments, stated, context);
 
-      verifies = statementVerifies; ///
-    } else {
-      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, this.node);
+      if (statementVealidates) {
+        verifies = true;
+      }
     }
 
     if (verifies) {
-      this.context = context;
+      this.setContext(context);
 
-      context.debug(`...verified the '${deductionString}' deduction.`, this.node);
+      context.debug(`...verified the '${deductionString}' deduction.`, node);
     }
 
     return verifies;

package/src/element/derivation.js

@@ -35,16 +35,12 @@ export default define(class Derivation extends Element {
             stepOrSubproofVerifies = stepOrSubproof.verify(substitutions, assignments, context);
 
       if (stepOrSubproofVerifies) {
-        const stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
+        const assignmentsAssigned = assignAssignments(assignments, context);
 
-        if (stepOrSubproofUnifies) {
-          const assignmentsAssigned = assignAssignments(assignments, context);
+        if (assignmentsAssigned) {
+          context.addStepOrSubproof(stepOrSubproof);
 
-          if (assignmentsAssigned) {
-            context.addStepOrSubproof(stepOrSubproof);
-
-            return true;
-          }
+          return true;
         }
       }
     });