occam-verify-cli 1.0.809 → 1.0.814

package/src/element/assertion/defined.js

@@ -249,11 +249,11 @@ function validateWhenDerived(term, frame, negated, generalContext, specificConte
   const context = specificContext;  ///
 
   if (term !== null) {
-    const variableNode = term.getVariableNode(),
-          variable = context.findVariableByVariableNode(variableNode),
-          variableDefined = isVariableDefined(variable, context);
+    const variableIdentifier = term.getVariableIdentifier(),
+          declaredDariable = context.findDeclaredVariableByVariableIdentifier(variableIdentifier),
+          declaredDariableDefined = isVariableDefined(declaredDariable, context);
 
-    if (!negated && variableDefined) {
+    if (!negated && declaredDariableDefined) {
       validatesWhenDerived = true;
     }
 
@@ -287,9 +287,9 @@ function isVariableDefined(variable, context) {
   equivalences.separateGroundedTermsAndDefinedVariables(groundedTerms, definedVariables, context);
 
   const variableMatchesDefinedVariable = definedVariables.some((definedVariable) => {
-          const definedVariableEqualToVariable = definedVariable.compare(variable);
+          const definedVariableComparesToVariable = definedVariable.compareVariable(variable);
 
-          if (definedVariableEqualToVariable === variable) {
+          if (definedVariableComparesToVariable === variable) {
             return true;
           }
         }),
@@ -299,8 +299,8 @@ function isVariableDefined(variable, context) {
 }
 
 function isMetavariableDefined(metavariable, context) {
-  const metavariableName = metavariable.getNode(),
-        judgementPresent = context.isJudgementPresentByMetavariableName(metavariableName),
+  const metavariableNode = metavariable.getNode(),
+        judgementPresent = context.isJudgementPresentByMetavariableNode(metavariableNode),
         metavariableDefined = judgementPresent; ///
 
   return metavariableDefined

package/src/element/assertion/satisfies.js

@@ -113,13 +113,13 @@ export default define(class SatisfiesAssertion extends Assertion {
     return referenceVerifies;
   }
 
-  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
-    let statementUnifies = false;
+  unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context) {
+    let stepAndSubproofOrProofAssertionsUnify = false;
 
-    const statementString = statement.getString(),
+    const steptString = step.getString(),
           satisfiesAssertionString = this.getString(); ///
 
-    context.trace(`Unifying the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion...`);
+    context.trace(`Unifying the '${steptString}' step with the '${satisfiesAssertionString}' satisfies assertion...`);
 
     this.signature.validate(context);
 
@@ -132,9 +132,9 @@ export default define(class SatisfiesAssertion extends Assertion {
       if (axiomComparesToSignature) {
         const substitutionsB = substitutions; ///
 
-        statementUnifies = axiom.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context);
+        stepAndSubproofOrProofAssertionsUnify = unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
 
-        if (statementUnifies) {
+        if (stepAndSubproofOrProofAssertionsUnify) {
           const substitutionsA = substitutions, ///
                 substitutionsCorrelate = substitutionsA.correlateSubstitutions(substitutionsB);
 
@@ -144,17 +144,17 @@ export default define(class SatisfiesAssertion extends Assertion {
 
             context.trace(`THe signature's ${substitutionsBString} substitutions do not correlate with the unification's ${substitutionsAString} substitutions.`);
 
-            statementUnifies = false;
+            stepAndSubproofOrProofAssertionsUnify = false;
           }
         }
       }
     }
 
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${satisfiesAssertionString}' satisfies assertion.`);
+    if (stepAndSubproofOrProofAssertionsUnify) {
+      context.debug(`...unified the '${steptString}' step with the '${satisfiesAssertionString}' satisfies assertion.`);
     }
 
-    return statementUnifies;
+    return stepAndSubproofOrProofAssertionsUnify;
   }
 
   static name = "SatisfiesAssertion";
@@ -180,6 +180,13 @@ export default define(class SatisfiesAssertion extends Assertion {
     return satisfiesAssertion;
   }
 
+  static fromStep(step, context) {
+    const statementNode = step.getStatementNode(),
+      satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);
+
+    return satisfiesAssertion;
+  }
+
   static fromStatement(statement, context) {
     const statementNode = statement.getNode(),
           satisfiesAssertion = satisfiesAssertionFromStatementNode(statementNode, context);

package/src/element/assertion.js

@@ -18,14 +18,6 @@ export default class Assertion extends Element {
     return assertionNodeMatches;
   }
 
-  findValidAssertion(context) {
-    const assertionNode = this.getAssertionNode(),
-          assertion = context.findAssertionByAssertionNode(assertionNode),
-          validAssertion = assertion;  ///
-
-    return validAssertion;
-  }
-
   isEqualTo(assertion) {
     const assertionNode = assertion.getNode(),
           assertionNodeMatches = this.matchAssertionNode(assertionNode),
@@ -34,6 +26,14 @@ export default class Assertion extends Element {
     return equalTo;
   }
 
+  findValidAssertion(context) {
+    const assertionNode = this.getAssertionNode(),
+          assertion = context.findAssertionByAssertionNode(assertionNode),
+          validAssertion = assertion;  ///
+
+    return validAssertion;
+  }
+
   toJSON() {
     const { name } = this.constructor,
           string = this.getString(),

package/src/element/assumption/metaLevel.js

@@ -233,12 +233,14 @@ export default define(class MetaLevelAssumption extends Element {
     return metaLevelAssumption;
   }
 
-  static fromStatementAndReference(statement, reference, context) {
+  static fromStep(step, context) {
     let metaLevelAssumption;
 
     ablate((context) => {
       instantiate((context) => {
-        const metaLevelAssumptionString = metaLevelAssumptionStringFromStatementAndReference(statement, reference),
+        const statement = step.getStatement(),
+              reference = step.getReference(),
+              metaLevelAssumptionString = metaLevelAssumptionStringFromStatementAndReference(statement, reference),
               string = metaLevelAssumptionString,  ///
               metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context);
 

package/src/element/conclusion.js

@@ -101,13 +101,13 @@ export default define(class Conclusion extends Element {
     return statementValidates;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnifies;
+  unifyStep(step, context) {
+    let stepUnifies = false;
 
-    const statementString = statement.getString(),
+    const stepString = step.getString(),
           conclusionString = this.getString();  ///
 
-    context.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+    context.trace(`Unifying the '${stepString}' step with the '${conclusionString}' conclusion...`);
 
     const specificContext = context;  ///
 
@@ -117,13 +117,18 @@ export default define(class Conclusion extends Element {
 
     context = specificContext;  ///
 
-    statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
+    const statement = step.getStatement(),
+          statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
 
     if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
+      stepUnifies = true;
     }
 
-    return statementUnifies;
+    if (stepUnifies) {
+      context.debug(`...unified the '${stepString}' step with the '${conclusionString}' conclusion.`);
+    }
+
+    return stepUnifies;
   }
 
   toJSON() {

package/src/element/deduction.js

@@ -101,13 +101,13 @@ export default define(class Deduction extends Element {
     return statementValidates;
   }
 
-  unifyStatement(statement, context) {
-    let statementUnifies;
+  unifyStep(step, context) {
+    let stepUnifies = false;
 
-    const statementString = statement.getString(),
+    const stepString = step.getString(),
           deductionString = this.getString();  ///
 
-    context.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
+    context.trace(`Unifying the '${stepString}' step with the '${deductionString}' deduction...`);
 
     const specificContext = context;  ///
 
@@ -117,13 +117,18 @@ export default define(class Deduction extends Element {
 
     context = specificContext;  ///
 
-    statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
+    const statement = step.getStatement(),
+          statementUnifies = this.statement.unifyStatement(statement, generalContext, specificContext);
 
     if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
+      stepUnifies = true;
     }
 
-    return statementUnifies;
+    if (stepUnifies) {
+      context.debug(`...unified the '${stepString}' step with the '${deductionString}' deduction.`);
+    }
+
+    return stepUnifies;
   }
 
   unifyDeduction(deduction, substitutions, generalContext, specificContext) {

package/src/element/frame.js

@@ -40,8 +40,13 @@ export default define(class Frame extends Element {
   }
 
   getMetavariableName() {
-    const frameNode = this.getFrameNode(),
-          metavariableName = frameNode.getMetavariableName();
+    let metavariableName = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      metavariableName = this.metavariable.getName();
+    }
 
     return metavariableName;
   }
@@ -101,24 +106,6 @@ export default define(class Frame extends Element {
     return comparesToParamter;
   }
 
-  compareMetavariableName(metavariableName) {
-    let comparesToMetavariableName = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const metavariableNameA = metavariableName ///
-
-      metavariableName = this.getMetavariableName();
-
-      const metavariableNameB = metavariableName; ///
-
-      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
-    }
-
-    return comparesToMetavariableName;
-  }
-
   findValidFrame(context) {
     const frameNode = this.getFrameNode(),
           frame = context.findFrameByFrameNode(frameNode),

package/src/element/label.js

@@ -26,8 +26,6 @@ export default define(class Label extends Element {
     return labelNode;
   }
 
-  getMetavariableName() { return this.metavariable.getName(); }
-
   getMetavariableNode() { return this.metavariable.getNode(); }
 
   matchLabelNode(labelNode) {
@@ -38,6 +36,8 @@ export default define(class Label extends Element {
     return labelNodeMatches;
   }
 
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+
   compareReference(reference) {
     const metavariable = reference.getMetavariable(),
           metavariableComparesToMetavariable = this.compareMetavariable(metavariable),
@@ -46,9 +46,7 @@ export default define(class Label extends Element {
     return comparesToReference;
   }
 
-  compareMetavariable(metavariable) { return this.metavariable.compare(metavariable); }
-
-  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
+  compareMetavariable(metavariable) { return this.metavariable.compareMetavariable(metavariable); }
 
   verify() {
     let verifies = false;

package/src/element/metavariable.js

@@ -82,7 +82,7 @@ export default define(class Metavariable extends Element {
     return metavariableNodeMatches;
   }
 
-  compare(metavariable) {
+  compareMetavariable(metavariable) {
     const metavariableName = metavariable.getName(),
           comparesToMetavariableName = this.compareMetavariableName(metavariableName),
           comparesToMetavariable = comparesToMetavariableName;  ///
@@ -97,6 +97,14 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
+  findValidMetavariable(context) {
+    const metavariableNode = this.getMetavariableNode(),
+          metavariable = context.findMetavariableByMetavariableNode(metavariableNode),
+          validMetavariable = metavariable; ///
+
+    return validMetavariable;
+  }
+
   verify(context) {
     let verifies = false;
 
@@ -164,14 +172,6 @@ export default define(class Metavariable extends Element {
     return typeVerifies;
   }
 
-  findValidMetavariable(context) {
-    const metavariableNode = this.getMetavariableNode(),
-          metavariable = context.findMetavariableByMetavariableNode(metavariableNode),
-          validMetavariable = metavariable; ///
-
-    return validMetavariable;
-  }
-
   validate(strict, context) {
     if (context === undefined) {
       context = strict; ///
@@ -332,13 +332,14 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
+    const metavariable = this,  ///
+          frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
 
     if (frameMetavariableUnifies) {
       frameUnifies = true;
     } else {
-      const metavariableName = this.getMetavariableName(),
-            substitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+      const metavariableNode = metavariable.getNode(),
+            substitution = context.findSubstitutionByMetavariableNode(metavariableNode);
 
       if (substitution !== null) {
         const substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
@@ -353,7 +354,6 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { FrameSubstitution } = elements,
-              metavariable = this,  ///
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context);
 
         frameSubstitution.validate(generalContext, specificContext);
@@ -387,15 +387,15 @@ export default define(class Metavariable extends Element {
     if (statementMetavariableUnifies) {
       statementUnifies = true;
     } else {
-      const metavariableName = metavariable.getName(),
+      const metavariableNode = metavariable.getNode(),
             substitutionPresent = (substitution !== null) ?
-                                    context.isSubstitutionPresentByMetavariableNameAndSubstitution(metavariableName, substitution) :
-                                      context.isSubstitutionPresentByMetavariableName(metavariableName);
+                                    context.isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution) :
+                                      context.isSubstitutionPresentByMetavariableNode(metavariableNode);
 
       if (substitutionPresent) {
         substitution = (substitution !== null) ?
-                         context.findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) :
-                           context.findSubstitutionByMetavariableName(metavariableName);
+                         context.findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) :
+                           context.findSubstitutionByMetavariableNode(metavariableNode);
 
         const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
@@ -435,13 +435,14 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
-    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
+    const metavariable = this,  ///
+          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const metavariableName = this.getMetavariableName(),
-            substitution = context.findSubstitutionByMetavariableName(metavariableName);
+      const metavariableNode = metavariable.getNode(),
+            substitution = context.findSubstitutionByMetavariableNode(metavariableNode);
 
       if (substitution !== null) {
         const substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
@@ -456,7 +457,6 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { ReferenceSubstitution } = elements,
-              metavariable = this,  ///
               referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context);
 
         referenceSubstitution.validate(generalContext, specificContext);
@@ -512,10 +512,10 @@ export default define(class Metavariable extends Element {
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const metavariableName = this.getMetavariableName(),  ///
-            frameMetavariableComparesToMetvariable = frame.compareMetavariableName(metavariableName);
+      const metavariableNode = this.getMetavariableNode(),  ///
+            metavariableNodeMatches = frame.matchMetavariableNode(metavariableNode);
 
-      if (frameMetavariableComparesToMetvariable) {
+      if (metavariableNodeMatches) {
         frameMetavariableUnifies = true;
       } else {
         const frameSingular = frame.isSingular();
@@ -587,8 +587,8 @@ export default define(class Metavariable extends Element {
           specificContextFilePath = specificContext.getFilePath();
 
     if (generalContextFilePath === specificContextFilePath) {
-      const metavariable = this,  ///
-            statementMetavariableComparesToMetvariable = statement.compareMetavariable(metavariable);
+      const metavariableNode = this.getMetavariableNode(),
+            statementMetavariableComparesToMetvariable = statement.matchMetavariableNode(metavariableNode);
 
       if (statementMetavariableComparesToMetvariable) {
         statementMetavariableUnifies = true;

package/src/element/procedureCall.js

@@ -83,13 +83,22 @@ export default define(class ProcedureCall extends Element {
     context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);
 
     const procedureName = this.getProcedureName(),
-          procedure = context.findProcedureByProcedureName(procedureName);
+          primitives = this.findPrimitives(context),
+          procedure = context.findProcedureByProcedureName(procedureName),
+          terms = termsFromPrimitives(primitives);
+
+    let term = null;
 
     try {
-      const primitives = this.findPrimitives(context),
-            terms = termsFromPrimitives(primitives),
-            term = await evaluate(procedure, terms),
-            boolean = term.isBoolean();
+      term = await evaluate(procedure, terms);
+    } catch (exception) {
+      const message = exception.getMessage();
+
+      context.info(message);
+    }
+
+    if (term !== null) {
+      const boolean = term.isBoolean();
 
       if (!boolean) {
         context.info(`The '${procedureCallString}' procedure call did not return a boolean.`);
@@ -100,10 +109,6 @@ export default define(class ProcedureCall extends Element {
           unifiesIndependently = true;
         }
       }
-    } catch (exception) {
-      const message = exception.getMessage();
-
-      context.info(message);
     }
 
     if (unifiesIndependently) {

package/src/element/proofAssertion/premise.js

@@ -136,6 +136,47 @@ export default define(class Premise extends ProofAssertion {
     return procedureCallValidates;
   }
 
+  async unifyIndependently(context) {
+    let unifiesIndependently = false;
+
+    const premiseString = this.getString(); ///
+
+    context.trace(`Unifying the '${premiseString}' premise independently...`);
+
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
+
+    if (statement !== null) {
+      const specificContext = context;  ///
+
+      context = this.getContext();
+
+      const generalContext = context; ///
+
+      context = specificContext;  ///
+
+      const statementUnifiesIndependently = statement.unifyIndependently(generalContext, specificContext);
+
+      if (statementUnifiesIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (procedureCall !== null) {
+      const procedureCallResolvedIndependently = await procedureCall.unifyIndependently(context);
+
+      if (procedureCallResolvedIndependently) {
+        unifiesIndependently = true;
+      }
+    }
+
+    if (unifiesIndependently) {
+      context.debug(`...unified the '${premiseString}' premise independenly.`);
+    }
+
+    return unifiesIndependently;
+  }
+
   unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
     let subproofOrProofAssertionUnifies;
 
@@ -243,47 +284,6 @@ export default define(class Premise extends ProofAssertion {
     return subproofUnifies;
   }
 
-  async unifyIndependently(context) {
-    let unifiesIndependently = false;
-
-    const premiseString = this.getString(); ///
-
-    context.trace(`Unifying the '${premiseString}' premise independently...`);
-
-    const statement = this.getStatement(),
-          procedureCall = this.getProcedureCall();
-
-    if (statement !== null) {
-      const specificContext = context;  ///
-
-      context = this.getContext();
-
-      const generalContext = context; ///
-
-      context = specificContext;  ///
-
-      const statementUnifiesIndependently = statement.unifyIndependently(generalContext, specificContext);
-
-      if (statementUnifiesIndependently) {
-        unifiesIndependently = true;
-      }
-    }
-
-    if (procedureCall !== null) {
-      const procedureCallResolvedIndependently = await procedureCall.unifyIndependently(context);
-
-      if (procedureCallResolvedIndependently) {
-        unifiesIndependently = true;
-      }
-    }
-
-    if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independenly.`);
-    }
-
-    return unifiesIndependently;
-  }
-
   toJSON() {
     const context = this.getContext();
 

package/src/element/proofAssertion/step.js

@@ -1,15 +1,17 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
 import { asynchronousUtilities } from "occam-languages";
 
 import elements from "../../elements";
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
-import { unifyStatements } from "../../utilities/unification";
+import { unifySteps } from "../../utilities/unification";
 import { derive, attempt, reconcile } from "../../utilities/context";
 
-const { asyncSome } = asynchronousUtilities;
+const { asyncSome } = asynchronousUtilities,
+      { backwardsSome } = arrayUtilities;
 
 export default define(class Step extends ProofAssertion {
   constructor(context, string, node, statement, reference, satisfiesAssertion) {
@@ -34,6 +36,13 @@ export default define(class Step extends ProofAssertion {
     return stepNode;
   }
 
+  getStatementNode() {
+    const statement = this.getStatement(),
+          statementNode = statement.getNode();
+
+    return statementNode;
+  }
+
   isSatisfied() {
     const satisfied = (this.satisfiesAssertion !== null);
 
@@ -46,6 +55,13 @@ export default define(class Step extends ProofAssertion {
     return qualified;
   }
 
+  isUnqualified() {
+    const qualified = this.isQualified(),
+          unqualified = !qualified;
+
+    return unqualified;
+  }
+
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
@@ -60,6 +76,22 @@ export default define(class Step extends ProofAssertion {
     return comparesToTermAndPropertyRelation;
   }
 
+  compareSubproofOrProofAssertions(subproofOrProofAssertions, context) {
+    let comparesToSubproofOrProofAssertions;
+
+    const step = this; ///
+
+    comparesToSubproofOrProofAssertions = backwardsSome(subproofOrProofAssertions, (subproofOrProofAssertion) => {
+      const subproofOrProofAssertionComparesToStatement = subproofOrProofAssertion.compareStep(step, context);
+
+      if (subproofOrProofAssertionComparesToStatement) {
+        return true;
+      }
+    });
+
+    return comparesToSubproofOrProofAssertions;
+  }
+
   async verify(context) {
     let verifies = false;
 
@@ -207,15 +239,13 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Unifying the '${stepString}' step...`);
 
-    const statement = this.getStatement(),
-          reference = this.getReference(),
-          satisfiesAssertion = this.getSatisfiesAssertion();
+    const step = this;  ///
 
-    await asyncSome(unifyStatements, async (unifyStatement) => {
+    await asyncSome(unifySteps, async (unifyStep) => {
       let statementUnifies;
 
       await reconcile(async (context) => {
-        statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
+        statementUnifies = await unifyStep(step, context);
       }, context);
 
       if (statementUnifies) {