occam-verify-cli 1.0.438 → 1.0.448

package/src/element/premise.js

@@ -1,32 +1,32 @@
 "use strict";
 
-import Element from "../element";
-import elements from "../elements";
+import ProofAssertion from "./proofAssertion";
 import TemporaryContext from "../context/temporary";
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
-import { subproofAssertionFromStatement } from "../utilities/statement";
-import { termsFromJSON, framesFromJSON, statementFromJSON, procedureCallFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../utilities/json";
-
-export default define(class Premise extends Element {
+import { termsFromJSON,
+         framesFromJSON,
+         termsToTermsJSON,
+         statementFromJSON,
+         framesToFramesJSON,
+         procedureCallFromJSON,
+         statementToStatementJSON,
+         procedureCallToProcedureCallJSON } from "../utilities/json";
+
+export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
-    this.statement = statement;
     this.procedureCall = procedureCall;
   }
 
-  getStatement() {
-    return this.statement;
-  }
-
   getProcedureCall() {
     return this.procedureCall;
   }
 
-  validate(context) {
-    let validates = false;
+  verify(context) {
+    let verifies = false;
 
     const temporaryContext = TemporaryContext.fromNothing(context);
 
@@ -35,60 +35,71 @@ export default define(class Premise extends Element {
     const node = this.getNode(),
           premiseString = this.getString(); ///
 
-    context.trace(`Validating the '${premiseString}' premise...`, node);
+    context.trace(`Verifying the '${premiseString}' premise...`, node);
 
-    if (false) {
-      ///
-    } else if (this.statement !== null) {
-      const stated = true,
-            assignments = [],
-            statementValidates = this.statement.validate(assignments, stated, context);
+    const statement = this.getStatement();
+
+    if ((statement === null) && (this.procedureCall === null)) {
+      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);
+    } else {
+      if (statement !== null) {
+        const stated = true,
+              assignments = [],
+              statementValidates = statement.validate(assignments, stated, context);
 
-      if (statementValidates) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        if (statementValidates) {
+          const assignmentsAssigned = assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          const { Step } = elements,
-                step = Step.fromStatement(this.statement, context),
-                stepOrSubproof = step;  ///
+          if (assignmentsAssigned) {
+            const subproofOrProofAssertion = this;  ///
 
-          context.addStepOrSubproof(stepOrSubproof);
+            context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          validates = true;
+            verifies = true;
+          }
         }
       }
-    } else if (this.procedureCall !== null) {
-      const stated = true,
-            assignments = null,
-            procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);
 
-      if (procedureCallVerifies) {
-        validates = true;
+      if (this.procedureCall !== null) {
+        const stated = true,
+              assignments = null,
+              procedureCallVerifies = this.procedureCall.verify(assignments, stated, context);
+
+        if (procedureCallVerifies) {
+          verifies = true;
+        }
       }
-    } else {
-      context.debug(`Unable to validate the '${premiseString}' premise because it is nonsense.`, node);
     }
 
-    if (validates) {
+    if (verifies) {
       this.setContext(context);
 
-      context.debug(`...validated the '${premiseString}' premise.`, node);
+      context.debug(`...verified the '${premiseString}' premise.`, node);
     }
 
-    return validates;
+    return verifies;
   }
 
   unifyIndependently(substitutions, context) {
     let unifiesIndependently = false;
 
-    const premiseString = this.getString(),  ///
-          generalContext = this.context,  ///
-          specificContext = context;  ///
+    const node = this.getNode(),
+          premiseString = this.getString(); ///
 
     context.trace(`Unifying the '${premiseString}' premise independently...`, node);
 
-    if (this.statement !== null) {
-      const statementUnifiesIndependently = this.statement.unifyIndependently(substitutions, generalContext, specificContext);
+    const generalContext = context; ///
+
+    context = this.getContext();
+
+    const specificContext = context;  ///
+
+    context = specificContext;  ///
+
+    const statement = this.getStatement();
+
+    if (statement !== null) {
+      const statementUnifiesIndependently = statement.unifyIndependently(substitutions, generalContext, specificContext);
 
       if (statementUnifiesIndependently) {
         unifiesIndependently = true;
@@ -110,104 +121,118 @@ export default define(class Premise extends Element {
     return unifiesIndependently;
   }
 
-  unifyStepOrSubproof(stepOrSubproof, substitutions, context) {
-    let stepOrSubproofUnifies = false;
+  unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context) {
+    let subproofOrProofAssertionUnifies = false;
 
-    const stepOrSubProofStep = stepOrSubproof.isStep(),
-          subproof = stepOrSubProofStep ?
-                       null :
-                         stepOrSubproof,
-          step = stepOrSubProofStep ?
-                        stepOrSubproof :
-                          null;
+    const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
+          proofAssertion = subproofOrProofAssertionProofAssertion ?
+                        subproofOrProofAssertion :
+                          null,
+          subproof = subproofOrProofAssertionProofAssertion ?
+                        null :
+                          subproofOrProofAssertion;
 
     substitutions.snapshot();
 
     if (subproof !== null) {
       const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
 
-      stepOrSubproofUnifies = subproofUnifies; ///
+      if (subproofUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (step !== null) {
-      const statementUnifies = this.unifyStep(step, substitutions, context);
+    if (proofAssertion !== null) {
+      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
 
-      stepOrSubproofUnifies = statementUnifies;  ///
+      if (proofAssertionUnifies) {
+        subproofOrProofAssertionUnifies = true;
+      }
     }
 
-    if (stepOrSubproofUnifies) {
+    if (subproofOrProofAssertionUnifies) {
       substitutions.resolve(context);
     }
 
-    stepOrSubproofUnifies ?
+    subproofOrProofAssertionUnifies ?
       substitutions.continue() :
         substitutions.rollback(context);
 
-    return stepOrSubproofUnifies;
+    return subproofOrProofAssertionUnifies;
   }
 
-  unifyStep(step, substitutions, context) {
-    let stepUnifies = false;
+  unifyProofAssertion(proofAssertion, substitutions, context) {
+    let proofAssertionUnifies = false;
+
+    const node = this.getNode(),
+          premiseString = this.getString(),
+          proofAssertionString = proofAssertion.getString();
 
-    context = step.getContext();
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`, node);
 
-    const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, context);
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specificContext;  ///
+
+    const statement = proofAssertion.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      stepUnifies = true;
+      proofAssertionUnifies = true;
+    }
+
+    if (proofAssertionUnifies) {
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`, node);
     }
 
-    return stepUnifies;
+    return proofAssertionUnifies;
   }
 
-  unifySubproof(subproof, substitutions, generalContext, specificContext) {
+  unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
+    const node = this.getNode(),
+          premiseString = this.getString(),
+          subproofString = subproof.getString();
 
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`, node);
 
-    if (this.statement !== null) {
-      const context = generalContext,
-            subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+    const specificContext = context;  ///
 
-      if (subproofAssertion !== null) {
-        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-      }
-    }
+    context = this.getContext();
 
-    if (subproofUnifies) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
-    }
+    const generalContext = context; ///
 
-    return subproofUnifies;
-  }
+    context = specificContext;  ///
 
-  unifyStatement(statement, substitutions, context) {
-    let statementUnifies;
+    const statement = this.getStatement();
 
-    const premise = this, ///
-          premiseString = premise.getString(),
-          statementString = statement.getString();
+    if (statement !== null) {
+      const statementNode = statement.getNode(),
+            subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
-    context.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`);
+      if (subproofAssertionNode !== null) {
+        const context = generalContext, ///
+              assertionNode = subproofAssertionNode,  ///
+              assertion = context.findAssertionByAssertionNode(assertionNode)
 
-    if (this.statement !== null) {
-      const generalContext = this.context,  ///
-            specificContext = context;  ///
+        if (assertion !== null) {
+          const subproofAssertion = assertion;  ///
 
-      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+        }
+      }
     }
 
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`);
+    if (subproofUnifies) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`, node);
     }
 
-    return statementUnifies;
+    return subproofUnifies;
   }
 
   toJSON() {

package/src/element/proof.js

@@ -16,12 +16,12 @@ export default define(class Proof extends Element {
     return this.derivation;
   }
 
-  getLastStep() { return this.derivation.getLastStep(); }
+  getLastProofAssertion() { return this.derivation.getLastProofAssertion(); }
 
   getStatement() {
-    const lastStep = this.getLastStep(),
-          lastStepStatement = lastStep.getStatement(),
-          statement = lastStepStatement; ///
+    const lastProofAssertion = this.getLastProofAssertion(),
+          lastProofAssertionStatement = lastProofAssertion.getStatement(),
+          statement = lastProofAssertionStatement; ///
 
     return statement;
   }
@@ -36,9 +36,9 @@ export default define(class Proof extends Element {
     const derivationVerifies = this.derivation.verify(substitutions, context);
 
     if (derivationVerifies) {
-      const lastStep = context.getLastStep();
+      const lastProofAssertion = context.getLastProofAssertion();
 
-      if (lastStep !== null) {
+      if (lastProofAssertion !== null) {
         const statement = this.getStatement(),
               conclusionStatement = conclusion.getStatement(),
               conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);

package/src/element/proofAssertion.js

@@ -0,0 +1,76 @@
+"use strict";
+
+import Element from "../element";
+
+import { equateStatements } from "../process/equate";
+
+export default class ProofAssertion extends Element {
+  constructor(context, string, node, statement) {
+    super(context, string, node);
+
+    this.statement = statement;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  isProofAssertion() {
+    const proofAssertion = true;
+
+    return proofAssertion;
+  }
+
+  compareStatement(statement, context) {
+    let comparesToStatement = false;
+
+    const statementString = statement.getString(),
+          proofAssertionString = this.getString();
+
+    context.trace(`Comparing the '${statementString}' statement to the '${proofAssertionString}' proof assertion...`);
+
+    const leftStatement = statement,  ///
+          rightStatement = this.statement,  ///
+          leftStatementNode = leftStatement.getNode(),
+          rightStatementNode = rightStatement.getNode(),
+          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
+
+    if (statementsEquate) {
+      comparesToStatement = true;
+    }
+
+    if (comparesToStatement) {
+      context.debug(`...compared the '${statementString}' statement to the '${proofAssertionString}' proof assertion.`);
+    }
+
+    return comparesToStatement;
+  }
+
+  unifyStatement(statement, substitutions, context) {
+    let statementUnifies = false;
+
+    if (this.statement !== null) {
+      const node = this.getNode(),
+            premiseString = this.getString(), ///
+            statementString = statement.getString();
+
+      context.trace(`Unifying the '${statementString}' statement with the '${premiseString}' premise...`, node);
+
+      const specificContext = context;  ///
+
+      context = this.getContext();  ///
+
+      const generalContext = context; ///
+
+      context = specificContext;  ///
+
+      statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
+
+      if (statementUnifies) {
+        context.debug(`...unified the '${statementString}' statement with the '${premiseString}' premise.`, node);
+      }
+    }
+
+    return statementUnifies;
+  }
+}

package/src/element/property.js

@@ -20,16 +20,16 @@ export default define(class Property extends Element {
     return this.nominalTypeName;
   }
 
-  matchPropertyName(propertyName) {
-    const propertyNameMatches = (this.name === propertyName);
+  comparePropertyName(propertyName) {
+    const comparesToPropertyName = (this.name === propertyName);
 
-    return propertyNameMatches;
+    return comparesToPropertyName;
   }
 
-  matchNominalTypeName(nominalTypeName) {
-    const nominalTypeNameMatches = (this.nominalTypeName === nominalTypeName);
+  compareNominalTypeName(nominalTypeName) {
+    const comparesToNominalTypeName = (this.nominalTypeName === nominalTypeName);
 
-    return nominalTypeNameMatches;
+    return comparesToNominalTypeName;
   }
 
   toJSON() {

package/src/element/propertyRelation.js

@@ -27,9 +27,9 @@ export default define(class PropertyRelation extends Element {
 
     context.trace(`Verifying the '${propertyRelationString}' property relation...`);
 
-    const termVerifies = this.verifyTerm(context);
+    const termValidates = this.validateTerm(context);
 
-    if (termVerifies) {
+    if (termValidates) {
       const propertyVerifies = this.verifyProperty(context);
 
       verifies = propertyVerifies;
@@ -42,24 +42,24 @@ export default define(class PropertyRelation extends Element {
     return verifies;
   }
 
-  verifyTerm(context) {
-    let termVerifies;
+  validateTerm(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.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;
   }
 
   verifyProperty(context) {
@@ -73,9 +73,9 @@ export default define(class PropertyRelation extends Element {
           propertyName = this.property.getName(),
           termTypeProperties = termType.getProperties(),
           variableTypeProperty = termTypeProperties.find((termTypeProperty) => {
-            const propertyNameMatches = termTypeProperty.matchPropertyName(propertyName);
+            const termTypePropertyComparesToPropertyName = termTypeProperty.comparePropertyName(propertyName);
 
-            if (propertyNameMatches) {
+            if (termTypePropertyComparesToPropertyName) {
               return true;
             }
           }) || null;

package/src/element/reference.js

@@ -4,7 +4,7 @@ import Element from "../element";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { referenceMetaType } from ".//metaType";
+import { referenceMetaTypeFromNothing } from "../metaTypes";
 import { unifyMetavariableIntrinsically } from "../process/unify";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
@@ -35,19 +35,9 @@ export default define(class Reference extends Element {
 
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeA = metavariableNode; ///
-
-    metavariableNode = this.metavariable.getNode();
-
-    const metavariableNodeB = metavariableNode, ///
-          matches = metavariableNodeA.match(metavariableNodeB),
-          metavariableNodeMatches = matches;  ///
-
-    return metavariableNodeMatches; ///
-  }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchNode(metavariableNode); }
 
   verify(context) {
     let verifies = false;
@@ -57,9 +47,9 @@ export default define(class Reference extends Element {
     context.trace(`Verifying the '${referenceString}' reference...`);
 
     if (!verifies) {
-      const metavariableVerifies = this.verifyMetavariable(context);
+      const metavariableValidates = this.validateMetavariable(context);
 
-      verifies = metavariableVerifies; ///
+      verifies = metavariableValidates; ///
     }
 
     if (!verifies) {
@@ -80,15 +70,18 @@ export default define(class Reference extends Element {
     return verifies;
   }
 
-  verifyMetavariable(context) {
-    let metavariableVerifies;
+  validateMetavariable(context) {
+    let metavariableValidates = false;
 
-    const metaType = referenceMetaType, ///
-          metavariableVerifiesGivenMetaType = this.metavariable.verifyGivenMetaType(metaType, context);
+    const referenceMetaType = referenceMetaTypeFromNothing(),
+          metaType = referenceMetaType, ///
+          metavariableValidatesGivenMetaType = this.metavariable.validateGivenMetaType(metaType, context);
 
-    metavariableVerifies = metavariableVerifiesGivenMetaType; ///
+    if (metavariableValidatesGivenMetaType) {
+      metavariableValidates = true;
+    }
 
-    return metavariableVerifies;
+    return metavariableValidates;
   }
 
   unifyLabel(label, substitutions, context) {