occam-verify-cli 1.0.444 → 1.0.448

package/src/element/premise.js

@@ -1,25 +1,26 @@
 "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 { 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;
   }
@@ -36,23 +37,23 @@ export default define(class Premise extends Element {
 
     context.trace(`Verifying the '${premiseString}' premise...`, node);
 
-    if ((this.statement === null) && (this.procedureCall === null)) {
+    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 (this.statement !== null) {
+      if (statement !== null) {
         const stated = true,
               assignments = [],
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statementValidates = statement.validate(assignments, stated, context);
 
         if (statementValidates) {
           const assignmentsAssigned = assignAssignments(assignments, context);
 
           if (assignmentsAssigned) {
-            const { Step } = elements,
-                  step = Step.fromStatement(this.statement, context),
-                  stepOrSubproof = step;  ///
+            const subproofOrProofAssertion = this;  ///
 
-            context.addStepOrSubproof(stepOrSubproof);
+            context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
             verifies = true;
           }
@@ -83,14 +84,22 @@ export default define(class Premise extends Element {
     let unifiesIndependently = false;
 
     const node = this.getNode(),
-          premiseString = this.getString(),  ///
-          generalContext = this.context,  ///
-          specificContext = context;  ///
+          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;
@@ -112,51 +121,54 @@ 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;
   }
 
-  unifySubproof(subproof, substitutions, context) {
-    let subproofUnifies = false;
+  unifyProofAssertion(proofAssertion, substitutions, context) {
+    let proofAssertionUnifies = false;
 
-    const premise = this, ///
-          subproofString = subproof.getString(),
-          premiseStatement = premise.getStatement(),
-          premiseStatementString = premiseStatement.getString();
+    const node = this.getNode(),
+          premiseString = this.getString(),
+          proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement...`);
+    context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`, node);
 
     const specificContext = context;  ///
 
@@ -166,24 +178,28 @@ export default define(class Premise extends Element {
 
     context = specificContext;  ///
 
-    if (this.statement !== null) {
-      const context = generalContext, ///
-            subproofAssertion = subproofAssertionFromStatement(this.statement, context);
+    const statement = proofAssertion.getStatement(),
+          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-      if (subproofAssertion !== null) {
-        subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-      }
+    if (statementUnifies) {
+      proofAssertionUnifies = true;
     }
 
-    if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the premise's '${premiseStatementString}' statement.`);
+    if (proofAssertionUnifies) {
+      context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`, node);
     }
 
-    return subproofUnifies;
+    return proofAssertionUnifies;
   }
 
-  unifyStep(step, substitutions, context) {
-    let stepUnifies = false;
+  unifySubproof(subproof, substitutions, context) {
+    let subproofUnifies = false;
+
+    const node = this.getNode(),
+          premiseString = this.getString(),
+          subproofString = subproof.getString();
+
+    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`, node);
 
     const specificContext = context;  ///
 
@@ -193,14 +209,30 @@ export default define(class Premise extends Element {
 
     context = specificContext;  ///
 
-    const statement = step.getStatement(),
-          statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    const statement = this.getStatement();
 
-    if (statementUnifies) {
-      stepUnifies = true;
+    if (statement !== null) {
+      const statementNode = statement.getNode(),
+            subproofAssertionNode = statementNode.getSubproofAssertionNode();
+
+      if (subproofAssertionNode !== null) {
+        const context = generalContext, ///
+              assertionNode = subproofAssertionNode,  ///
+              assertion = context.findAssertionByAssertionNode(assertionNode)
+
+        if (assertion !== null) {
+          const subproofAssertion = assertion;  ///
+
+          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
+        }
+      }
     }
 
-    return stepUnifies;
+    if (subproofUnifies) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`, node);
+    }
+
+    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/reference.js

@@ -71,13 +71,15 @@ export default define(class Reference extends Element {
   }
 
   validateMetavariable(context) {
-    let metavariableValidates;
+    let metavariableValidates = false;
 
     const referenceMetaType = referenceMetaTypeFromNothing(),
           metaType = referenceMetaType, ///
           metavariableValidatesGivenMetaType = this.metavariable.validateGivenMetaType(metaType, context);
 
-    metavariableValidates = metavariableValidatesGivenMetaType; ///
+    if (metavariableValidatesGivenMetaType) {
+      metavariableValidates = true;
+    }
 
     return metavariableValidates;
   }

package/src/element/rule.js

@@ -165,68 +165,68 @@ export default define(class Rule extends Element {
     return statementUnifiesWithConclusion;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
-    let statementAndStepsOrSubproofsUnify = false;
+  unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
+    let statementAndSubproofOrProofAssertionsUnify = false;
 
     const { Substitutions } = elements,
           substitutions = Substitutions.fromNothing(),
           statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, context);
 
     if (statementUnifiesWithConclusion) {
-      const stepsOrSubproofsUnifiesWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context);
+      const subproofOrProofAssertionsUnifiesWithPremises = this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context);
 
-      if (stepsOrSubproofsUnifiesWithPremises) {
+      if (subproofOrProofAssertionsUnifiesWithPremises) {
         const substitutionsResolved = substitutions.areResolved();
 
         if (substitutionsResolved) {
-          statementAndStepsOrSubproofsUnify = true;
+          statementAndSubproofOrProofAssertionsUnify = true;
         }
       }
     }
 
-    return statementAndStepsOrSubproofsUnify;
+    return statementAndSubproofOrProofAssertionsUnify;
   }
 
-  unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context) {
-    let stepsOrSubproofsUnifiesWithPremise = false;
+  unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context) {
+    let subproofOrProofAssertionsUnifiesWithPremise = false;
 
-    if (!stepsOrSubproofsUnifiesWithPremise) {
+    if (!subproofOrProofAssertionsUnifiesWithPremise) {
       const premiseUnifiesIndependently = premise.unifyIndependently(substitutions, context);
 
       if (premiseUnifiesIndependently) {
-        stepsOrSubproofsUnifiesWithPremise = true;
+        subproofOrProofAssertionsUnifiesWithPremise = true;
       }
     }
 
-    if (!stepsOrSubproofsUnifiesWithPremise) {
-      const stepOrSubproof = extract(stepsOrSubproofs, (stepOrSubproof) => {
-        const stepOrSubproofUnifies = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, context);
+    if (!subproofOrProofAssertionsUnifiesWithPremise) {
+      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context);
 
-        if (stepOrSubproofUnifies) {
+        if (subproofOrProofAssertionUnifies) {
           return true;
         }
       }) || null;
 
-      if (stepOrSubproof !== null) {
-        stepsOrSubproofsUnifiesWithPremise = true;
+      if (subproofOrProofAssertion !== null) {
+        subproofOrProofAssertionsUnifiesWithPremise = true;
       }
     }
 
-    return stepsOrSubproofsUnifiesWithPremise;
+    return subproofOrProofAssertionsUnifiesWithPremise;
   }
 
-  unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, context) {
-    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
+  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, substitutions, context) {
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    const stepsOrSubproofsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiesWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, context);
+    const subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, substitutions, context);
 
       if (stepUnifiesWithPremise) {
         return true;
       }
     });
 
-    return stepsOrSubproofsUnifiesWithPremises;
+    return subproofOrProofAssertionsUnifiesWithPremises;
   }
 
   toJSON() {

package/src/element/statement.js

@@ -254,19 +254,19 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  compareStepsOrSubproofs(stepsOrSubproofs, context) {
-    let comparesToStepsOrSubproofs;
+  compareSubproofOrProofAssertions(subproofOrProofAssertions, context) {
+    let comparesToSubproofOrProofAssertions;
 
-    comparesToStepsOrSubproofs = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
+    comparesToSubproofOrProofAssertions = backwardsSome(subproofOrProofAssertions, (subproofOrProofAssertion) => {
       const statement = this, ///
-            stepOrSubproofComparesToStatement = stepOrSubproof.compareStatement(statement, context);
+            subproofOrProofAssertionComparesToStatement = subproofOrProofAssertion.compareStatement(statement, context);
 
-      if (stepOrSubproofComparesToStatement) {
+      if (subproofOrProofAssertionComparesToStatement) {
         return true;
       }
     });
 
-    return comparesToStepsOrSubproofs;
+    return comparesToSubproofOrProofAssertions;
   }
 
   toJSON() {

package/src/element/step.js

@@ -1,29 +1,21 @@
 "use strict";
 
-import Element from "../element";
 import elements from "../elements";
+import ProofAssertion from "./proofAssertion";
 import TemporaryContext from "../context/temporary";
 
 import { define } from "../elements";
-import { instantiateStep } from "../process/instantiate";
 import { unifyStatements } from "../utilities/unification";
-import { equateStatements } from "../process/equate";
-import { stepFromStepNode } from "../utilities/element";
 import { propertyAssertionFromStatement } from "../utilities/statement";
 
-export default define(class Step extends Element {
+export default define(class Step extends ProofAssertion {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
-    super(context, string, node);
+    super(context, string, node, statement);
 
-    this.statement = statement;
     this.reference = reference;
     this.satisfiesAssertion = satisfiesAssertion;
   }
 
-  getStatement() {
-    return this.statement;
-  }
-
   getReference() {
     return this.reference;
   }
@@ -51,16 +43,11 @@ export default define(class Step extends Element {
     return stated;
   }
 
-  isStep() {
-    const step = true;
-
-    return step;
-  }
-
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
-    const propertyAssertion = propertyAssertionFromStatement(this.statement, context);
+    const statement = this.getStatement(),
+          propertyAssertion = propertyAssertionFromStatement(statement, context);
 
     if (propertyAssertion !== null) {
       comparesToTermAndPropertyRelation = propertyAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
@@ -81,7 +68,9 @@ export default define(class Step extends Element {
 
     context.trace(`Verifying the '${stepString}' step...`, node);
 
-    if (this.statement === null) {
+    const statement = this.getStatement();
+
+    if (statement === null) {
       context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`, node);
     } else {
       const referenceVerifies = this.verifyReference(context);
@@ -91,11 +80,11 @@ export default define(class Step extends Element {
 
         if (satisfiesAssertioVeriries) {
           const stated = this.isStated(),
-                statementValidates = this.statement.validate(assignments, stated, context);
+                statementValidates = statement.validate(assignments, stated, context);
 
           if (statementValidates) {
             const statementUnifies = unifyStatements.some((unifyStatement) => {
-              const statementUnifies = unifyStatement(this.statement, this.reference, this.satisfiesAssertion, substitutions, context);
+              const statementUnifies = unifyStatement(statement, this.reference, this.satisfiesAssertion, substitutions, context);
 
               if (statementUnifies) {
                 return true;
@@ -103,11 +92,9 @@ export default define(class Step extends Element {
             });
 
             if (statementUnifies) {
-              const { Step } = elements,
-                    step = Step.fromStatement(this.statement, context),
-                    stepOrSubproof = step;  ///
+              const subproofOrProofAssertion = this;  ///
 
-              context.addStepOrSubproof(stepOrSubproof);
+              context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
               this.setContext(context);
 
@@ -170,20 +157,6 @@ export default define(class Step extends Element {
     return satisfiesAssertionVerifies;
   }
 
-  compareStatment(statement, context) {
-    let comparesToStatement;
-
-    const leftStatement = statement,  ///
-          rightStatement = this.statement,  ///
-          leftStatementNode = leftStatement.getNode(),
-          rightStatementNode = rightStatement.getNode(),
-          statementsEquate = equateStatements(leftStatementNode, rightStatementNode, context);
-
-    comparesToStatement = statementsEquate;  ///
-
-    return comparesToStatement;
-  }
-
   unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
     let unifiesWithSatisfiesAssertion = false;
 
@@ -218,15 +191,4 @@ export default define(class Step extends Element {
   }
 
   static name = "Step";
-
-  static fromStatement(statement, context) {
-    const statementString = statement.getString(),
-          stepString = statementString, ///
-          string = `${stepString}
-`,
-          stepNode = instantiateStep(string, context),
-          step = stepFromStepNode(stepNode, context);
-
-    return step;;
-  }
 });

package/src/element/subDerivation.js

@@ -10,35 +10,35 @@ import { define } from "../elements";
 const { last } = arrayUtilities;
 
 export default define(class SubDerivation extends Element {
-  constructor(context, string, node, stepsOrSubproofs) {
+  constructor(context, string, node, subproofOrProofAssertions) {
     super(context, string, node);
 
-    this.stepsOrSubproofs = stepsOrSubproofs;
+    this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getStepsOrSubproofs() {
-    return this.stepsOrSubproofs;
+  getSubproofOrProofAssertions() {
+    return this.subproofOrProofAssertions;
   }
 
-  getLastStep() {
-    const lastStepOrSubproof = last(this.stepsOrSubproofs),
-          lastStep = lastStepOrSubproof;  ///
+  getLastProofAssertion() {
+    const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
+          lastProofAssertion = lastSubproofOrProofAssertion;  ///
 
-    return lastStep;
+    return lastProofAssertion;
   }
 
   verify(substitutions, context) {
     let verifies;
 
-    verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
+    verifies = this.subproofOrProofAssertions.every((subproofOrProofAssertion) => { ///
       const assignments = [],
-            stepOrSubproofVarifies = stepOrSubproof.verify(substitutions, assignments, context);
+            subproofOrProofAssertionVarifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofVarifies) {
+      if (subproofOrProofAssertionVarifies) {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          context.addStepOrSubproof(stepOrSubproof);
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
           return true;
         }