occam-verify-cli 1.0.438 → 1.0.444

package/src/context/temporary.js

@@ -159,9 +159,9 @@ export default class TemporaryContext {
 
   findTermByTermNode(termNode) {
     const term = this.terms.find((term) => {
-      const termMatchesTermNode = term.matchTermNode(termNode);
+      const termNodeMatches = term.matchNode(termNode);
 
-      if (termMatchesTermNode) {
+      if (termNodeMatches) {
         return true;
       }
     }) || null;
@@ -171,9 +171,9 @@ export default class TemporaryContext {
 
   findFrameByFrameNode(frameNode) {
     const frame = this.frames.find((frame) => {
-      const frameMatchesFrameNode = frame.matchFrameNode(frameNode);
+      const frameNodeMatches = frame.matchNode(frameNode);
 
-      if (frameMatchesFrameNode) {
+      if (frameNodeMatches) {
         return true;
       }
     }) || null;
@@ -183,9 +183,9 @@ export default class TemporaryContext {
 
   findStatementByStatementNode(statementNode) {
     const statement = this.statements.find((statement) => {
-      const statementMatchesStatementNode = statement.matchStatementNode(statementNode);
+      const statementNodeMatches = statement.matchNode(statementNode);
 
-      if (statementMatchesStatementNode) {
+      if (statementNodeMatches) {
         return true;
       }
     }) || null;
@@ -195,9 +195,9 @@ export default class TemporaryContext {
 
   findAssertionByAssertionNode(assertionNode) {
     const assertion = this.assertions.find((assertion) => {
-      const assertionMatchesAssertionNode = assertion.matchAssertionNode(assertionNode);
+      const assertionNodeMatches = assertion.matchNode(assertionNode);
 
-      if (assertionMatchesAssertionNode) {
+      if (assertionNodeMatches) {
         return true;
       }
     }) || null;
@@ -219,9 +219,9 @@ export default class TemporaryContext {
 
   findSubstitutionBySubstitutionNode(substitutionNode) {
     const substitution = this.substitutions.find((substitution) => {
-      const substitutionMatchesSubtitutionNode = substitution.matchSubstitutionNode(substitutionNode);
+      const substitutionNodeMatches = substitution.matchNode(substitutionNode);
 
-      if (substitutionMatchesSubtitutionNode) {
+      if (substitutionNodeMatches) {
         return true;
       }
     }) || null;
@@ -349,7 +349,7 @@ export default class TemporaryContext {
 
   isMetavariableDefined(metavariable) { return this.context.isMetavariableDefined(metavariable); }
 
-  matchTermAndPropertyRelation(term, propertyRelation) { return this.context.matchTermAndPropertyRelation(term, propertyRelation); }
+  compareTermAndPropertyRelation(term, propertyRelation) { return this.context.compareTermAndPropertyRelation(term, propertyRelation); }
 
   nodeAsString(node) { return this.context.nodeAsString(node); }
 

package/src/element/assertion/contained.js

@@ -3,12 +3,11 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { containedAssertionFromStatementNode } from "../../utilities/element";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class ContainedAssertion extends Assertion {
-  constructor(string, node, term, frame, negated, statement) {
-    super(string, node);
+  constructor(cpontext, string, node, term, frame, negated, statement) {
+    super(context, string, node);
 
     this.term = term;
     this.frame = frame;
@@ -39,11 +38,11 @@ export default define(class ContainedAssertion extends Assertion {
 
     context.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
 
-    const termVerifies = this.verifyTerm(assignments, stated, context),
+    const termValidates = this.validateTerm(assignments, stated, context),
           frameVerifies = this.verifyFrame(assignments, stated, context),
-          statementVerifies = this.verifyStatement(assignments, stated, context)
+          statementValidates = this.validateStatement(assignments, stated, context)
 
-    if (termVerifies || frameVerifies || statementVerifies) {
+    if (termValidates || frameVerifies || statementValidates) {
       let verifiesWhenStated = false,
           verifiesWhenDerived = false;
 
@@ -65,32 +64,32 @@ export default define(class ContainedAssertion extends Assertion {
     return verifies;
   }
 
-  verifyTerm(assignments, stated, context) {
-    let termVerifies = false;
+  validateTerm(assignments, stated, context) {
+    let termValidates = false;
 
     if (this.term !== null) {
       const termString = this.term.getString();
 
-      context.trace(`Verifying the '${termString}' term...`);
+      context.trace(`Validating the '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        termVerifies = this.term.verify(context, () => {
+        termValidates = this.term.validate(context, () => {
           const verifiesAhead = true;
 
           return verifiesAhead;
         });
 
-        if (termVerifies) {
-          context.debug(`...verified the '${termString}' term.`);
+        if (termValidates) {
+          context.debug(`...validated the '${termString}' term.`);
         }
       }
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   verifyFrame(assignments, stated, context) {
@@ -121,26 +120,26 @@ export default define(class ContainedAssertion extends Assertion {
     return frameVerifies;
   }
 
-  verifyStatement(assignments, stated, context) {
-    let statementVerifies = false;
+  validateStatement(assignments, stated, context) {
+    let statementValidates = false;
 
     if (this.statement !== null) {
       const statementString = this.statement.getString();
 
-      context.trace(`Verifying the '${statementString}' statement...`);
+      context.trace(`Validating the '${statementString}' statement...`);
 
       stated = true;  ///
 
       assignments = null; ///
 
-      statementVerifies = this.statement.verify(assignments, stated, context);
+      statementValidates = this.statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
-        context.debug(`...verified the '${statementString}' statement.`);
+      if (statementValidates) {
+        context.debug(`...validated the '${statementString}' statement.`);
       }
     }
 
-    return statementVerifies;
+    return statementValidates;
   }
 
   verifyWhenStated(assignments, context) {

package/src/element/assertion/defined.js

@@ -4,12 +4,11 @@ import elements from "../../elements";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { definedAssertionFromStatementNode } from "../../utilities/element";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 
 export default define(class DefinedAssertion extends Assertion {
-  constructor(string, node, term, frame, negated) {
-    super(string, node);
+  constructor(context, string, node, term, frame, negated) {
+    super(context, string, node);
 
     this.term = term;
     this.frame= frame;
@@ -35,10 +34,10 @@ export default define(class DefinedAssertion extends Assertion {
 
     context.trace(`Verifying the '${definedAssertionString}' defined assertion...`);
 
-    const termVerifies = this.verifyTerm(assignments, stated, context),
+    const termValidates = this.validateTerm(assignments, stated, context),
           frameVerifies = this.verifyFrame(assignments, stated, context);
 
-    if (termVerifies || frameVerifies) {
+    if (termValidates || frameVerifies) {
       let verifiesWhenStated = false,
           verifiesWhenDerived = false;
 
@@ -60,32 +59,32 @@ export default define(class DefinedAssertion extends Assertion {
     return verifies;
   }
 
-  verifyTerm(assignments, stated, context) {
-    let termVerifies = false;
+  validateTerm(assignments, stated, context) {
+    let termValidates = false;
 
     if (this.term !== null) {
       const termString = this.term.getString(); ///
 
-      context.trace(`Verifying the '${termString}' term...`);
+      context.trace(`Validating the '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        termVerifies = this.term.verify(context, () => {
+        termValidates = this.term.validate(context, () => {
           const verifiesAhead = true;
 
           return verifiesAhead;
         });
 
-        if (termVerifies) {
-          context.debug(`...verified the '${termString}' term.`);
+        if (termValidates) {
+          context.debug(`...validated the '${termString}' term.`);
         }
       }
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   verifyFrame(assignments, stated, context) {

package/src/element/assertion/property.js

@@ -7,8 +7,8 @@ import { define } from "../../elements";
 import { variableAssignmentFromVariable } from "../../process/assign";
 
 export default define(class PropertyAssertion extends Assertion {
-  constructor(string, node, term, propertyRelation) {
-    super(string, node);
+  constructor(context, string, node, term, propertyRelation) {
+    super(context, string, node);
 
     this.term = term;
     this.propertyRelation = propertyRelation;
@@ -22,14 +22,14 @@ export default define(class PropertyAssertion extends Assertion {
     return this.propertyRelation;
   }
 
-  matchTermAndPropertyRelation(term, propertyRelation, context) {
-    let propertyMatchesTermAndPropertyRelation = false;
+  compareTermAndPropertyRelation(term, propertyRelation, context) {
+    let comparesToTermAndPropertyRelation = false;
 
     const termString = term.getString(),
           propertyRelationString = propertyRelation.getString(),
-          propertyAssertionString = this.getString();
+          propertyAssertionString = this.getString(); ///
 
-    context.trace(`Matching the '${termString}' term and '${propertyRelationString}' property relation against the '${propertyAssertionString}' property assertion...`);
+    context.trace(`Comparing the '${propertyAssertionString}' property assertion to the '${termString}' term and '${propertyRelationString}' property relation...`);
 
     const termA = term,
           termB = this.term, ///
@@ -38,14 +38,14 @@ export default define(class PropertyAssertion extends Assertion {
     if (termAEqualToTermB) {
       const propertyRelationEqualToPropertyRelation = this.propertyRelation.isEqualTo(propertyRelation);
 
-      propertyMatchesTermAndPropertyRelation = propertyRelationEqualToPropertyRelation;  ///
+      comparesToTermAndPropertyRelation = propertyRelationEqualToPropertyRelation;  ///
     }
 
-    if (propertyMatchesTermAndPropertyRelation) {
-      context.debug(`...matched the '${termString}' term and '${propertyRelationString}' property relation against the '${propertyAssertionString}' property assertion.`);
+    if (comparesToTermAndPropertyRelation) {
+      context.debug(`...compared the '${propertyAssertionString}' property assertion to the '${termString}' term and '${propertyRelationString}' property relation.`);
     }
 
-    return propertyMatchesTermAndPropertyRelation;
+    return comparesToTermAndPropertyRelation;
   }
 
   verify(assignments, stated, context) {
@@ -55,9 +55,9 @@ export default define(class PropertyAssertion extends Assertion {
 
     context.trace(`Verifying the '${propertyAssertionString}' property assertion...`);
 
-    const termVerifies = this.verifyTerm(assignments, stated, context);
+    const termValidates = this.validateTerm(assignments, stated, context);
 
-    if (termVerifies) {
+    if (termValidates) {
       const propertyRelationVerifies = this.verifyPropertyRelation(assignments, stated, context);
 
       if (propertyRelationVerifies) {
@@ -89,24 +89,24 @@ export default define(class PropertyAssertion extends Assertion {
     return verifies;
   }
 
-  verifyTerm(assignments, stated, context) {
-    let termVerifies;
+  validateTerm(assignments, stated, context) {
+    let termValidates;
 
     const termString = this.term.getString();
 
-    context.trace(`Verifying the '${termString}' term...`);
+    context.trace(`Validating the '${termString}' term...`);
 
-    termVerifies = this.term.verify(context, () => {
+    termValidates = this.term.verify(context, () => {
       const verifiesAhead = true;
 
       return verifiesAhead;
     });
 
-    if (termVerifies) {
-      context.debug(`...verified the '${termString}' term.`);
+    if (termValidates) {
+      context.debug(`...validated the '${termString}' term.`);
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   verifyPropertyRelation(assignments, stated, context) {
@@ -126,7 +126,7 @@ export default define(class PropertyAssertion extends Assertion {
   }
 
   verifyWhenStated(assignments, context) {
-    let verifiesWhenStated = false;
+    let verifiesWhenStated;
 
     const propertyAssertionString = this.getString(); ///
 

package/src/element/assertion/satisfies.js

@@ -6,8 +6,8 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 
 export default define(class SatisfiesAssertion extends Assertion {
-  constructor(string, node, signature, reference) {
-    super(string, node);
+  constructor(context, string, node, signature, reference) {
+    super(context, string, node);
 
     this.signature = signature;
     this.reference = reference;
@@ -97,9 +97,9 @@ export default define(class SatisfiesAssertion extends Assertion {
 
       substitutions = Substitutions.fromNothing();
 
-      const signatureMatches = axiom.matchSignature(this.signature, substitutions, context);
+      const axiomComparesToSignature = axiom.compareSignature(this.signature, substitutions, context);
 
-      if (signatureMatches) {
+      if (axiomComparesToSignature) {
         const substitutionsB = substitutions; ///
 
         substitutions = Substitutions.fromNothing();
@@ -108,9 +108,9 @@ export default define(class SatisfiesAssertion extends Assertion {
 
         if (statementUnifies) {
           const substitutionsA = substitutions, ///
-                substitutionsMatch = substitutionsA.correlateSubstitutions(substitutionsB);
+                substitutionsCorrelate = substitutionsA.correlateSubstitutions(substitutionsB);
 
-          if (!substitutionsMatch) {
+          if (!substitutionsCorrelate) {
             const substitutionsAString = substitutionsA.asString(),
                   substitutionsBString = substitutionsB.asString();
 

package/src/element/assertion/subproof.js

@@ -10,8 +10,8 @@ import { unifyStatement } from "../../process/unify";
 const { match } = arrayUtilities;
 
 export default define(class SubproofAssertion extends Assertion {
-  constructor(string, node, statements) {
-    super(string, node);
+  constructor(context, string, node, statements) {
+    super(context, string, node);
 
     this.statements = statements;
   }
@@ -20,38 +20,40 @@ export default define(class SubproofAssertion extends Assertion {
     return this.statements;
   }
 
-  verify(assignments, stated, context) {
-    let verifies;
+  validate(assignments, stated, context) {
+    let validates = false;
 
     const subproofAssertionString = this.getString();  ///
 
-    context.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
+    context.trace(`Validating the '${subproofAssertionString}' subproof assertion...`);
 
-    const statementsVerify = this.verifyStatements(assignments, stated, context);
+    const statementsValidate = this.validateStatements(assignments, stated, context);
 
-    verifies = statementsVerify;  ///
+    if (statementsValidate) {
+      validates = true;
+    }
 
-    if (verifies) {
-      context.debug(`...verified the '${subproofAssertionString}' subproof assertion.`);
+    if (validates) {
+      context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyStatements(assignments, stated, context) {
+  validateStatements(assignments, stated, context) {
     stated = true;  ///
 
     assignments = null; ///
 
-    const statementsVerify = this.statements.map((statement) => {
-      const statementVerifies = statement.verify(assignments, stated, context);
+    const statementsValidate = this.statements.map((statement) => {
+      const statementValidates = statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
+      if (statementValidates) {
         return true;
       }
     });
 
-    return statementsVerify;
+    return statementsValidate;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {

package/src/element/assertion/type.js

@@ -7,8 +7,8 @@ import { define } from "../../elements";
 import { variableAssignmentFromVariable } from "../../process/assign";
 
 export default define(class TypeAssertion extends Assertion {
-  constructor(string, node, term, type) {
-    super(string, node);
+  constructor(context, string, node, term, type) {
+    super(context, string, node);
 
     this.term = term;
     this.type = type;

package/src/element/assertion.js

@@ -6,6 +6,4 @@ export default class Assertion extends Element {
   constructor(context, string, node) {
     super(context, string, node);
   }
-
-  matchAssertionNode(assertionNode) { return this.node.match(assertionNode); }
 }

package/src/element/assumption.js

@@ -31,13 +31,13 @@ export default define(class Assumption extends Element {
     return simple;
   }
 
-  matchSubstitution(substitution, context) {
-    let substitutionMatches = false;
+  compareSubstitution(substitution, context) {
+    let comparesToSubstituion = false;
 
     const assumptionString = this.string,  ///
           substitutionString = substitution.getString();
 
-    context.trace(`Matching the '${substitutionString}' substitution against the '${assumptionString}' assumption...`);
+    context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
 
     const simple = this.isSimple();
 
@@ -46,9 +46,12 @@ export default define(class Assumption extends Element {
             judgement = context.findJudgementByMetavariable(metavariable);
 
       if (judgement !== null) {
-        const assumption = judgement.getDeclaration();
+        const assumption = judgement.getDeclaration(),
+              assumptionComaresToSubstitution = assumption.compareSubstitution(substitution, context);
 
-        substitutionMatches = assumption.matchSubstitution(substitution, context);
+        if (assumptionComaresToSubstitution) {
+          comparesToSubstituion = true;
+        }
       }
     } else {
       const statement = substitution.getStatement(),
@@ -57,15 +60,15 @@ export default define(class Assumption extends Element {
             referenceMetavariableEqualToMetavariable = this.reference.isMetavariableEqualToMetavariable(metavariable);
 
       if (statementEqualToStatement && referenceMetavariableEqualToMetavariable) {
-        substitutionMatches = true;
+        comparesToSubstituion = true;
       }
     }
 
-    if (substitutionMatches) {
-      context.debug(`...matches the '${assumptionString}' substitution against the '${substitutionString}' assumption.`);
+    if (comparesToSubstituion) {
+      context.debug(`...compared the '${substitutionString}' assumption to the '${assumptionString}' substitution.`);
     }
 
-    return substitutionMatches;
+    return comparesToSubstituion;
   }
 
   verify(assignments, stated, context) {
@@ -85,9 +88,9 @@ export default define(class Assumption extends Element {
       const referenceVerified = this.verifyReference(assignments, stated, context);
 
       if (referenceVerified) {
-        const statementVerifies = this.verifyStatement(assignments, stated, context);
+        const statementValidates = this.validateStatement(assignments, stated, context);
 
-        if (statementVerifies) {
+        if (statementValidates) {
           let verifiesWhenStated = false,
               verifiesWhenDerived = false;
 
@@ -128,28 +131,28 @@ export default define(class Assumption extends Element {
     return referenceVerified;
   }
 
-  verifyStatement(assignments, stated, context) {
-    let statementVerifies;
+  validateStatement(assignments, stated, context) {
+    let statementValidates;
 
     if (this.statement === null) {
-      statementVerifies = true;
+      statementValidates = true;
     } else {
       const statementString = this.statement.getString();
 
-      context.trace(`Verifying the '${statementString}' statement...`);
+      context.trace(`Validating the '${statementString}' statement...`);
 
       stated = true;  ///
 
       assignments = null; ///
 
-      statementVerifies = this.statement.verify(assignments, stated, context);
+      statementValidates = this.statement.validate(assignments, stated, context);
 
-      if (statementVerifies) {
-        context.debug(`...verified the '${statementString}' statement.`);
+      if (statementValidates) {
+        context.debug(`...validated the '${statementString}' statement.`);
       }
     }
 
-    return statementVerifies;
+    return statementValidates;
   }
 
   verifyReferenceAsMetavariable(assignments, stated, context) {

package/src/element/axiom.js

@@ -56,8 +56,8 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     return signatureVerifies;
   }
 
-  matchSignature(signature, substitutions, context) {
-    let signatureMatches = false;
+  compareSignature(signature, substitutions, context) {
+    let comparesToSignature = false;
 
     const satisfiable = this.isSatisfiable();
 
@@ -73,10 +73,10 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
 
       const generalContext = context;  ///
 
-      signatureMatches = signatureA.match(signatureB, substitutions, generalContext, specificContext);
+      comparesToSignature = signatureA.compare(signatureB, substitutions, generalContext, specificContext);
     }
 
-    return signatureMatches;
+    return comparesToSignature;
   }
 
   unifyStep(step, substitutions, context) {
@@ -93,7 +93,7 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     const unconditional = this.isUnconditional();
 
     if (!unconditional) {
-      context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
+      context.trace(`Unable to unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
     } else {
       const statement = step.getStatement(),
             statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
@@ -145,7 +145,7 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     const unconditional = this.isUnconditional();
 
     if (unconditional) {
-      context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
+      context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
     } else {
       const lastStep = subproof.getLastStep(),
             lastStepUnifies = this.unifyLastStep(lastStep, substitutions, context);
@@ -213,17 +213,13 @@ export default define(class Axiom extends AxiomLemmaTheoremConjecture {
     if (generalSuppositionsLength === specificSuppositionsLength) {
       suppositions = specificSuppositions;  ///
 
-      const suppositionsMatch = suppositions.every((supposition, index) => {
+      suppositionsUnify = suppositions.every((supposition, index) => {
         const suppositionUnifies = this.unifySupposition(supposition, index, substitutions, generalContext, specificContext);
 
         if (suppositionUnifies) {
           return true;
         }
       });
-
-      if (suppositionsMatch) {
-        suppositionsUnify = true;
-      }
     }
 
     return suppositionsUnify;