occam-verify-cli 1.0.809 → 1.0.816

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) {

package/src/element/proofAssertion/supposition.js

@@ -158,6 +158,47 @@ export default define(class Supposition extends ProofAssertion {
     return suppositionUnifies;
   }
 
+  async unifyIndependently(context) {
+    let unifiesIndependently = false;
+
+    const suppositionString = this.getString(); ///
+
+    context.trace(`Unifying the '${suppositionString}' supposition 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 '${suppositionString}' supposition independenly.`);
+    }
+
+    return unifiesIndependently;
+  }
+
   unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
     let subproofOrProofAssertionUnifies;
 
@@ -265,47 +306,6 @@ export default define(class Supposition extends ProofAssertion {
     return subproofUnifies;
   }
 
-  async unifyIndependently(context) {
-    let unifiesIndependently = false;
-
-    const suppositionString = this.getString(); ///
-
-    context.trace(`Unifying the '${suppositionString}' supposition 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 '${suppositionString}' supposition independenly.`);
-    }
-
-    return unifiesIndependently;
-  }
-
   toJSON() {
     const context = this.getContext();
 

package/src/element/proofAssertion.js

@@ -28,27 +28,28 @@ export default class ProofAssertion extends Element {
     return proofAssertion;
   }
 
-  compareStatement(statement, context) {
-    let comparesToStatement = false;
+  compareStep(step, context) {
+    let comparesToStep = false;
 
-    const statementString = statement.getString(),
+    const stepString = step.getString(),
           proofAssertionString = this.getString();  ///
 
-    context.trace(`Comparing the '${statementString}' statement to the '${proofAssertionString}' proof assertion...`);
+    context.trace(`Comparing the '${stepString}' step to the '${proofAssertionString}' proof assertion...`);
 
-    const leftStatement = statement,  ///
+    const statement = step.getStatement(),
+          leftStatement = statement,  ///
           rightStatement = this.statement,  ///
           statementsEquate = equateStatements(leftStatement, rightStatement, context);
 
     if (statementsEquate) {
-      comparesToStatement = true;
+      comparesToStep = true;
     }
 
-    if (comparesToStatement) {
-      context.debug(`...compared the '${statementString}' statement to the '${proofAssertionString}' proof assertion.`);
+    if (comparesToStep) {
+      context.debug(`...compared the '${stepString}' step to the '${proofAssertionString}' proof assertion.`);
     }
 
-    return comparesToStatement;
+    return comparesToStep;
   }
 
   unifyStatement(statement, generalContext, specificContext) {

package/src/element/reference.js

@@ -32,12 +32,6 @@ export default define(class Reference extends Element {
     return referenceNode;
   }
 
-  getMetavariableName() {
-    const metavariableName = this.metavariable.getName();
-
-    return metavariableName;
-  }
-
   getMetavariableNode() {
     const metavariableNode = this.metavariable.getNode();
 
@@ -65,13 +59,17 @@ export default define(class Reference extends Element {
   compareParameter(parameter) {
     let comparesToParamter = false;
 
-    const parameterName = parameter.getName();
+    const singular = this.isSingular();
 
-    if (parameterName !== null) {
-      const metavariableName = this.getMetavariableName();
+    if (singular) {
+      const parameterName = parameter.getName();
 
-      if (parameterName === metavariableName) {
-        comparesToParamter = true;
+      if (parameterName !== null) {
+        const metavariableName = this.getMetavariableName();
+
+        if (parameterName === metavariableName) {
+          comparesToParamter = true;
+        }
       }
     }
 
@@ -98,8 +96,6 @@ export default define(class Reference extends Element {
     return comparesToMetavariable;
   }
 
-  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
-
   compareTopLevelMetaAssertion(topLevelMetaAssertion) {
     let topLevelMetaAssertionCompares = false;
 

package/src/element/rule.js

@@ -7,8 +7,8 @@ import { define } from "../elements";
 import { enclose } from "../utilities/context";
 import { labelsFromJSON, premisesFromJSON, conclusionFromJSON, labelsToLabelsJSON, premisesToPremisesJSON, conclusionToConclusionJSON } from "../utilities/json";
 
-const { reverse, extract } = arrayUtilities,
-      { asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
+const { reverse } = arrayUtilities,
+      { asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default define(class Rule extends Element {
   constructor(context, string, node, proof, labels, premises, conclusion) {
@@ -43,38 +43,16 @@ export default define(class Rule extends Element {
     return ruleNode;
   }
 
-  compareMetavariableName(metavariableName) {
-    const comparesToMetavariableName = this.labels.some((label) => {
-      const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.labels.some((label) => {
+      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
 
-      if (labelComparesToMetavariableName) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
 
-    return comparesToMetavariableName;
-  }
-
-  unifyStatementWithConclusion(statement, context) {
-    let statementUnifiesWithConclusion = false;
-
-    const ruleString = this.getString(),
-          statementString = statement.getString(),
-          conclusionString = this.conclusion.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion...`);
-
-    const statementUnifies = this.conclusion.unifyStatement(statement, context);
-
-    if (statementUnifies) {
-      statementUnifiesWithConclusion = true;
-    }
-
-    if (statementUnifiesWithConclusion) {
-      context.debug(`...unified the '${statementString}' statement with the '${ruleString}' rule's '${conclusionString}' conclusion.`);
-    }
-
-    return statementUnifiesWithConclusion;
+    return metavariableNodeMatches;
   }
 
   async verify() {
@@ -246,59 +224,61 @@ export default define(class Rule extends Element {
     return conclusionVerifies;
   }
 
-  async unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
-    let statementAndSubproofOrProofAssertionsUnify = false;
+  async unifyStepWithConclusion(step, context) {
+    let stepUnifiesWithConclusion = false;
 
-    const statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, context);
+    await this.break(context);
 
-    if (statementUnifiesWithConclusion) {
-      const subproofOrProofAssertionsUnifiesWithPremises = await this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
+    const ruleString = this.getString(),
+          stepString = step.getString(),
+          conclusionString = this.conclusion.getString();
 
-      if (subproofOrProofAssertionsUnifiesWithPremises) {
-        const substitutionsResolved = context.areSubstitutionsResolved();
+    context.trace(`Unifying the '${stepString}' step with the '${ruleString}' rule's '${conclusionString}' conclusion...`);
 
-        if (substitutionsResolved) {
-          statementAndSubproofOrProofAssertionsUnify = true;
-        }
-      }
+    const stepUnifies = this.conclusion.unifyStep(step, context);
+
+    if (stepUnifies) {
+      stepUnifiesWithConclusion = true;
     }
 
-    return statementAndSubproofOrProofAssertionsUnify;
+    if (stepUnifiesWithConclusion) {
+      context.debug(`...unified the '${stepString}' step with the '${ruleString}' rule's '${conclusionString}' conclusion.`);
+    }
+
+    return stepUnifiesWithConclusion;
   }
 
-  async unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context) {
-    let subproofOrProofAssertionsUnifiesWithPremises;
+  async unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context) {
+    let stepAndSubproofOrProofAssertionsUnify = false;
 
-    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
+    const statementUnifiesWithConclusion = await this.unifyStepWithConclusion(step, context);
 
-    subproofOrProofAssertionsUnifiesWithPremises = asyncBackwardsEvery(this.premises, async (premise) => {
-      const stepUnifiesWithPremise = await this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context);
+    if (statementUnifiesWithConclusion) {
+      const subproofOrProofAssertionsUnifiesWithPremises = await this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
 
-      if (stepUnifiesWithPremise) {
-        return true;
+      if (subproofOrProofAssertionsUnifiesWithPremises) {
+        const substitutionsResolved = context.areSubstitutionsResolved();
+
+        if (substitutionsResolved) {
+          stepAndSubproofOrProofAssertionsUnify = true;
+        }
       }
-    });
+    }
 
-    return subproofOrProofAssertionsUnifiesWithPremises;
+    return stepAndSubproofOrProofAssertionsUnify;
   }
 
   async unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context) {
     let subproofOrProofAssertionsUnifiesWithPremise = false;
 
+    await this.break(context);
+
     if (!subproofOrProofAssertionsUnifiesWithPremise) {
-      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
-        const subproofOrProofAssertionUnifies = premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
+      const subproofOrProofAssertion = await asyncExtract(subproofOrProofAssertions, async (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = await premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
-          const specificContext = context;  ///
-
-          context = this.getContext();
-
-          const generalContext = context; ///
-
-          context = specificContext;  ///
-
-          context.resolveSubstitutions(generalContext, specificContext);
+          context.resolveSubstitutions();
 
           return true;
         }
@@ -320,6 +300,22 @@ export default define(class Rule extends Element {
     return subproofOrProofAssertionsUnifiesWithPremise;
   }
 
+  async unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context) {
+    let subproofOrProofAssertionsUnifiesWithPremises;
+
+    subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
+
+    subproofOrProofAssertionsUnifiesWithPremises = await asyncBackwardsEvery(this.premises, async (premise) => {
+      const stepUnifiesWithPremise = await this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context);
+
+      if (stepUnifiesWithPremise) {
+        return true;
+      }
+    });
+
+    return subproofOrProofAssertionsUnifiesWithPremises;
+  }
+
   toJSON() {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           premisesJSON = premisesToPremisesJSON(this.premises),

package/src/element/signature.js

@@ -122,7 +122,7 @@ export default define(class Signature extends Element {
     return termsValidate
   }
 
-  compare(signature, substitutions, generalContext, specificContext) {
+  compareSignature(signature, substitutions, generalContext, specificContext) {
     const terms = signature.getTerms(),
           termsA = this.terms,  ///
           termsB = terms, ///
@@ -153,9 +153,9 @@ export default define(class Signature extends Element {
               }
             }
           }),
-          compares = matches; ///
+          comparesToSignature = matches; ///
 
-    return compares;
+    return comparesToSignature;
   }
 
   compareSubstitutions(substitutions, context) {
@@ -169,9 +169,9 @@ export default define(class Signature extends Element {
     const array = substitutions.getArray(),
           compares = compare(this.terms, array, (term, substitution) => {
             const substitutionTerm = substitution.getTerm(),
-                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
+                  substitutionTermComparesToTerm = substitutionTerm.compareTerm(term);
 
-            if (substitutionTermEqualToTerm) {
+            if (substitutionTermComparesToTerm) {
               return true;
             }
           });
@@ -198,9 +198,9 @@ export default define(class Signature extends Element {
     const array = substitutions.getArray(),
           correlates = correlate(this.terms, array, (term, substitution) => {
             const substitutionTerm = substitution.getTerm(),
-                  substitutionTermEqualToTerm = substitutionTerm.isEqualTo(term);
+                  substitutionTermComparesToTerm = substitutionTerm.compareTerm(term);
 
-            if (substitutionTermEqualToTerm) {
+            if (substitutionTermComparesToTerm) {
               return true;
             }
           });

package/src/element/statement.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import { Element } from "occam-languages";
-import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { unifyStatement } from "../process/unify";
@@ -9,8 +8,6 @@ import { validateStatements } from "../utilities/validation";
 import { instantiateStatement } from "../process/instantiate";
 import { join, reconcile, instantiate } from "../utilities/context";
 
-const { backwardsSome } = arrayUtilities;
-
 export default define(class Statement extends Element {
   getStatementNode() {
     const node = this.getNode(),
@@ -19,13 +16,6 @@ export default define(class Statement extends Element {
     return statementNode;
   }
 
-  getMetavariableName() {
-    const sttaementNode = this.getStatementNode(),
-          metavariableName = sttaementNode.getMetavariableName();
-
-    return metavariableName;
-  }
-
   getTermSubstitutionNode() {
     const statementNode = this.getNode(),
           termSubstitutionNode = statementNode.getTermSubstitutionNode();
@@ -40,11 +30,33 @@ export default define(class Statement extends Element {
     return frameSubstitutionNode;
   }
 
-  isSingular() {
-    const statementNode = this.getStatementNode(),
-          singular = statementNode.isSingular();
+  getMetavariableNode() {
+    let metavariableNode = null;
 
-    return singular;
+    const singular = this.isSingular();
+
+    if (singular) {
+      const statementNode = this.getStatementNode();
+
+      metavariableNode = statementNode.getMetavariableNode();
+    }
+
+    return metavariableNode;
+  }
+
+  getMetavariableName() {
+    let metavariableName = null;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const statementNode = this.getStatementNode(),
+            metavariableNode = statementNode.getMetavariableNode();
+
+      metavariableName = metavariableNode.getMetavariableName();
+    }
+
+    return metavariableName;
   }
 
   isEqualTo(statement) {
@@ -55,6 +67,13 @@ export default define(class Statement extends Element {
     return equalTo;
   }
 
+  isSingular() {
+    const statementNode = this.getStatementNode(),
+          singular = statementNode.isSingular();
+
+    return singular;
+  }
+
   matchStatementNode(statementNode) {
     const node = statementNode, ///
           nodeMatches = this.matchNode(node),
@@ -63,79 +82,46 @@ export default define(class Statement extends Element {
     return statementNodeMatches;
   }
 
-  compareParameter(parameter) {
-    let comparesToParamter = false;
+  matchMetavariableNode(metavariableNode) {
+    let metavariableNodeMatches = false;
 
     const singular = this.isSingular();
 
     if (singular) {
-      const parameterName = parameter.getName();
+      const metavariableNodeA = metavariableNode, ///
+            statementNode = this.getStatementNode();
 
-      if (parameterName !== null) {
-        const metavariableName = this.getMetavariableName();
-
-        if (parameterName === metavariableName) {
-          comparesToParamter = true;
-        }
-      }
-    }
-
-    return comparesToParamter;
-  }
+      metavariableNode = statementNode.getMetavariableNode();
 
-  compareMetavariable(metavariable) {
-    let comparesToMetavariableName;
+      const metavariableNodeB = metavariableNode, ///
+            metavariableNodeAMatchesMetavariableNodeB = metavariableNodeA.match(metavariableNodeB);
 
-    const singular = this.isSingular();
-
-    if (singular) {
-      let metavariableName;
-
-      metavariableName = metavariable.getName();
-
-      const metavariableNameA = metavariableName; ///
-
-      metavariableName = this.getMetavariableName();
-
-      const metavariableNameB = metavariableName; ///
-
-      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
+      if (metavariableNodeAMatchesMetavariableNodeB) {
+        metavariableNodeMatches = true;
+      }
     }
 
-    return comparesToMetavariableName;
+    return metavariableNodeMatches;
   }
 
-  compareMetavariableName(metavariableName) {
-    let comparesToMetavariableName = false;
+  compareParameter(parameter) {
+    let comparesToParamter = false;
 
     const singular = this.isSingular();
 
     if (singular) {
-      const metavariableNameA = metavariableName ///
-
-      metavariableName = this.getMetavariableName();
-
-      const metavariableNameB = metavariableName; ///
-
-      comparesToMetavariableName = (metavariableNameA === metavariableNameB);
-    }
-
-    return comparesToMetavariableName;
-  }
-
-  compareSubproofOrProofAssertions(subproofOrProofAssertions, context) {
-    let comparesToSubproofOrProofAssertions;
+      const parameterName = parameter.getName();
 
-    comparesToSubproofOrProofAssertions = backwardsSome(subproofOrProofAssertions, (subproofOrProofAssertion) => {
-      const statement = this, ///
-            subproofOrProofAssertionComparesToStatement = subproofOrProofAssertion.compareStatement(statement, context);
+      if (parameterName !== null) {
+        const metavariableName = this.getMetavariableName();
 
-      if (subproofOrProofAssertionComparesToStatement) {
-        return true;
+        if (parameterName === metavariableName) {
+          comparesToParamter = true;
+        }
       }
-    });
+    }
 
-    return comparesToSubproofOrProofAssertions;
+    return comparesToParamter;
   }
 
   findValidStatment(context) {

package/src/element/subproof.js

@@ -54,10 +54,10 @@ export default define(class Subproof extends Element {
     return proofAssertion;
   }
 
-  compareStatement(statement, context) {
-    const statementUnifies = false;
+  compareStep(step, context) {
+    const comparesToStep = false;
 
-    return statementUnifies;
+    return comparesToStep;
   }
 
   async verify(context) {