occam-verify-cli 1.0.753 → 1.0.757

package/src/element/substitution/statement.js

@@ -201,30 +201,9 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementStatementValidates;
   }
 
-  unifyReplacementStatement(replacementStatement, generalContext, specificContext) {
-    let replacementStatemnentUnifies = false;
-
-    const context = specificContext,  ///
-          substitutionString = this.getString(),  ///
-          replacementStatementString = replacementStatement.getString(),
-          substitutionReplacementStatementString = this.replacementStatement.getString();  ///
-
-    context.trace(`Unifying the '${replacementStatementString}' replacement statement with the '${substitutionString}' substiution's '${substitutionReplacementStatementString}' replacement statement...`);
-
-    const statementUnifies = this.replacementStatement.unifyStatement(replacementStatement, generalContext, specificContext);
-
-    if (statementUnifies) {
-      replacementStatemnentUnifies = true;
-    }
-
-    if (replacementStatemnentUnifies) {
-      context.debug(`...unified the '${replacementStatementString}' replacement statement with the '${substitutionString}' substiution's '${substitutionReplacementStatementString}' replacement statement.`);
-    }
-
-    return replacementStatemnentUnifies;
-  }
-
   unifySubstitution(substitution, generalContext, specificContext) {
+    let substitutionUnifies;
+
     const context = specificContext,
           generalSubstitution = this.substitution,  ///
           specificSubstitution = substitution,  ///
@@ -233,7 +212,13 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
 
-    const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+    reconcile((specificContext) => {
+      substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+
+      if (substitutionUnifies) {
+        specificContext.commit();
+      }
+    }, specificContext);
 
     if (substitutionUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
@@ -242,74 +227,119 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionUnifies;
   }
 
-  resolve(generalContext, specificContext) {
-    let context;
+  uniffyComplexSubstitution(complexSubstitution, generalContext, specificContext) {
+    let substitution = null;
 
-    context = this.getContext();
+    const context = specificContext, ///
+          simpleSubstitutionString = this.getString(),  ///
+          complexSubstitutionString = complexSubstitution.getString();  ///
 
-    const substitutionString = this.getString(); ///
+    context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
 
-    context.trace(`Resolving the ${substitutionString} substitution...`);
+    let simpleSubstitutionUnifies = false;
 
-    context = generalContext; ///
+    reconcile((specificContext) => {
+      const replacementStatement = complexSubstitution.getReplacementStatement(),
+            replacementStatementUnifies = this.unifyReplacementStatement(replacementStatement, generalContext, specificContext);
 
-    const metavariableName = this.getMetavariableName();
+      if (replacementStatementUnifies) {
+        const nested = false,
+              context = specificContext,  ///
+              soleNonTrivialSubstitution = context.getSoleNonTrivialSubstitution(nested);
 
-    context = specificContext;  ///
+        substitution = soleNonTrivialSubstitution;  ///
+      }
+    }, specificContext);
 
-    const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+    if (substitution !== null) {
+      simpleSubstitutionUnifies = true;
+    }
 
-    if (simpleSubstitution !== null) {
-      context = this.getContext();
+    if (simpleSubstitutionUnifies) {
+      context.debug(`...unified the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution.`);
+    }
 
-      const substitution = reconcile((context) => {
-        let substitution = null;
+    return substitution;
+  }
 
-        const specificContext = context;  ///
+  unifyReplacementStatement(replacementStatement, generalContext, specificContext) {
+    let replacementStatemnentUnifies = false;
 
-        context = simpleSubstitution.getContext();
+    const context = specificContext,  ///
+          replacementStatementString = replacementStatement.getString(),
+          substitutionReplacementStatementString = this.replacementStatement.getString();  ///
 
-        const generalContext = context; ///
+    context.trace(`Unifying the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement...`);
 
-        context = specificContext;  ///
+    const statementUnifies = this.replacementStatement.unifyStatement(replacementStatement, generalContext, specificContext);
 
-        const replacementStatementUnifies = simpleSubstitution.unifyReplacementStatement(this.replacementStatement, generalContext, specificContext);
+    if (statementUnifies) {
+      replacementStatemnentUnifies = true;
+    }
 
-        if (replacementStatementUnifies) {
-          const nested = false,
-                soleNonTrivialSubstitution = context.getSoleNonTrivialSubstitution(nested);
+    if (replacementStatemnentUnifies) {
+      context.debug(`...unified the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement.`);
+    }
 
-          substitution = soleNonTrivialSubstitution;  ///
-        }
+    return replacementStatemnentUnifies;
+  }
 
-        return substitution;
-      }, context);
+  unifyWithSipmleSubstitution(simpleSubstitution, generalContext, specificContext) {
+    let substitution;
 
-      if (substitution !== null) {
-        reconcile((specificContext) => {
-          const complexContext = this.getContext(), ///
-                simpleContext = simpleSubstitution.getContext();  ///
+    const complexSubstitution = this; ///
+
+    let context;
+
+    context = this.getContext();
 
-          context = specificContext;  ///
+    specificContext = context;  ///
 
-          join((context) => {
-            const specificContext = context;  ///
+    context = simpleSubstitution.getContext();
 
-            context = this.substitution.getContext();
+    generalContext = context; ///
 
-            const generalContext = context; ///
+    substitution = simpleSubstitution.uniffyComplexSubstitution(complexSubstitution, generalContext, specificContext);
 
-            this.unifySubstitution(substitution, generalContext, specificContext);
-          }, complexContext, simpleContext, context);
+    return substitution;
+  }
 
-          specificContext.commit();
-        }, specificContext);
+  resolve(generalContext, specificContext) {
+    let resolved = false;
+
+    const context = specificContext,  ///
+          substitutionString = this.getString(); ///
 
-        this.resolved = true;
+    context.trace(`Resolving the ${substitutionString} substitution...`);
+
+    const metavariableName = this.getMetavariableName(),
+          simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+
+    if (simpleSubstitution !== null) {
+      const substitution = this.unifyWithSipmleSubstitution(simpleSubstitution, generalContext, specificContext); ///
+
+      if (substitution !== null) {
+        const complexSubstitution = this, ///
+              simpleSubstitutionComplex = simpleSubstitution.getContext(),
+              complexSubstitutionContext = complexSubstitution.getContext();
+
+        join((context) => {
+          const specificContext = context;  ///
+
+          context = this.substitution.getContext();
+
+          const generalContext = context; ///
+
+          this.unifySubstitution(substitution, generalContext, specificContext);
+        }, complexSubstitutionContext, simpleSubstitutionComplex, context);
+
+        resolved = true;
       }
     }
 
-    if (this.resolved) {
+    if (resolved) {
+      this.resolved = true;
+
       context.debug(`...resolved the '${substitutionString}' substitution.`);
     }
   }

package/src/element/topLevelAssertion/axiom.js

@@ -1,9 +1,13 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import TopLevelAssertion from "../topLevelAssertion";
 
 import { define } from "../../elements";
 
+const { backwardsEvery } = arrayUtilities;
+
 export default define(class Axiom extends TopLevelAssertion {
   getAxiomNode() {
     const node = this.getNode(),
@@ -120,7 +124,7 @@ export default define(class Axiom extends TopLevelAssertion {
   unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
-    const axiomString = this.getString(),
+    const axiomString = this.getString(), ///
           subproofString = subproof.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
@@ -130,10 +134,10 @@ export default define(class Axiom extends TopLevelAssertion {
     if (unconditional) {
       context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`);
     } else {
-      const lastProofAssertion = subproof.getLastProofAssertion(),
-            lastProofAssertionUnifies = this.unifyLastProofAssertion(lastProofAssertion, context);
+      const lastStep = subproof.getLastStep(),
+            lastStepUnifies = this.unifyLastStep(lastStep, context);
 
-      if (lastProofAssertionUnifies) {
+      if (lastStepUnifies) {
         const suppositions = subproof.getSuppositions(),
               suppositionsUnify = this.unifySuppositions(suppositions, context);
 
@@ -196,7 +200,7 @@ export default define(class Axiom extends TopLevelAssertion {
     if (generalSuppositionsLength === specificSuppositionsLength) {
       suppositions = specificSuppositions;  ///
 
-      suppositionsUnify = suppositions.every((supposition, index) => {
+      suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
         const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
 
         if (suppositionUnifies) {
@@ -208,32 +212,32 @@ export default define(class Axiom extends TopLevelAssertion {
     return suppositionsUnify;
   }
 
-  unifyLastProofAssertion(lastProofAssertion, context) {
-    let lastProofAssertionUnifies = false;
+  unifyLastStep(lastStep, context) {
+    let lastStepUnifies = false;
 
-    const axiomString = this.getString(),
-          lastProofAssertionString = lastProofAssertion.getString();
+    const axiomString = this.getString(), ///
+          lastStepString = lastStep.getString();
 
-    context.trace(`Unifying the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom...`)
+    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`);
 
-    const statement = lastProofAssertion.getStatement(),
+    const statement = lastStep.getStatement(),
           statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
 
     if (statementUnifiesWithDeduction) {
-      lastProofAssertionUnifies = true;
+      lastStepUnifies = true;
     }
 
-    if (lastProofAssertionUnifies) {
-      context.debug(`...unified the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom.`)
+    if (lastStepUnifies) {
+      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`);
     }
 
-    return lastProofAssertionUnifies;
+    return lastStepUnifies;
   }
 
   unifyTopLevelAssertion(topLevelAssertion, context) {
     let topLevelAssertionUnifies = false;
 
-    const axiomString = this.getString(),
+    const axiomString = this.getString(), ///
           topLevelAssertionString = topLevelAssertion.getString();
 
     context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`);

package/src/element/topLevelAssertion.js

@@ -59,8 +59,6 @@ export default class TopLevelAssertion extends Element {
     this.hypotheses = hypotheses;
   }
 
-  getStatement() { return this.deduction.getStatement(); }
-
   isHypothetical() {
     const hypothesesLength = this.hypotheses.length,
           hypothetical = (hypothesesLength > 0);

package/src/element/topLevelMetaAssertion.js

@@ -46,7 +46,46 @@ export default class TopLevelMetaAssertion extends Element {
     return this.metaLevelSubstitutions;
   }
 
-  getStatement() { return this.deduction.getStatement(); }
+  getStatement() {
+    let statement = null;
+
+    const unconditional = this.isUnconditional();
+
+    if (unconditional) {
+      statement = this.deduction.getStatement();
+    }
+
+    return statement;
+  }
+
+  getStatements() {
+    let statements = null;
+
+    const unconditional = this.isUnconditional();
+
+    if (!unconditional) {
+      const suppositionStatements = this.suppositions.map((supposition) => {
+              const suppositionStatement = supposition.getStatement();
+
+              return suppositionStatement;
+            }),
+            deductionStatement = this.deduction.getStatement();
+
+      statements = [
+        ...suppositionStatements,
+        deductionStatement
+      ];
+    }
+
+    return statements;
+  }
+
+  isUnconditional() {
+    const suppositionsLength = this.suppositions.length,
+          unconditional = (suppositionsLength === 0);
+
+    return unconditional;
+  }
 
   compareReference(reference) {
     const label = this.getLabel(),

package/src/element/variable.js

@@ -126,6 +126,11 @@ export default define(class Variable extends Element {
       const substitutionComparesToTerm = substitution.compareTerm(term, context);
 
       if (substitutionComparesToTerm) {
+        const termSubstitution = substitution,  ///
+              termSubstitutionString = termSubstitution.getString();
+
+        context.trace(`The '${termSubstitutionString}' term substitution is already present.`);
+
         termUnifies = true;
       }
     } else {

package/src/process/unify.js

@@ -304,6 +304,67 @@ class MetavariablePass extends ZipPass {
   ];
 }
 
+class SubstitutionPass extends ZipPass {
+  static maps = [
+    {
+      generalNodeQuery: frameAMetavariableNodeQuery,
+      specificNodeQuery: frameNodeQuery,
+      run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
+        let success = false;
+
+        const frameNode = specificFrameNode, ///
+              metavariableNode = generalFrameMetavariableNode,  ///
+              metavariableName = metavariableNode.getMetavariableName();
+
+        let context;
+
+        context = generalContext; ///
+
+        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+        context = specificContext;  ///
+
+        const frame = context.findFrameByFrameNode(frameNode),
+              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+
+        if (frameUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableNode.getVariableIdentifier();
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
 class IntrinsicLevelPass extends ZipPass {
   static maps = [
     {
@@ -341,6 +402,7 @@ const metaLevelPass = new MetaLevelPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
+      substitutionPass = new SubstitutionPass(),
       intrinsicLevelPass = new IntrinsicLevelPass();
 
 export function unifyStatement(generalStatement, specificStatement, generalContext, specificContext) {
@@ -366,7 +428,7 @@ export function unifySubstitution(generalSubstitution, specificSubstitution, gen
         specificSubstitutionNode = specificSubstitution.getNode(),
         generalNode = generalSubstitutionNode, ///
         specificNode = specificSubstitutionNode,  ///
-        success = metaLevelPass.run(generalNode, specificNode, generalContext, specificContext);
+        success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     substitutionUnifies = true;

package/src/utilities/releaseContext.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import { releaseContextUtilities } from "occam-languages";
-import { fileSystemUtilities as occamFileSystemUtilities } from "occam-file-system";
+import { fileSystemUtilities as occamFileSystemUtilities } from "occam-server";
 import { pathUtilities, fileSystemUtilities as necessaryFileSystemUtilities } from "necessary";
 
 const { loadProject } = occamFileSystemUtilities,

package/src/utilities/string.js

@@ -168,10 +168,10 @@ export function sectionStringFromHypothesesTopLevelAssertion(hypotheses, axiom,
 }
 
 export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
-  const lastProofAssertion = subDerivation.getLastProofAssertion(),
+  const lastStep = subDerivation.getLastStep(),
         suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        lastProofAssertionString = lastProofAssertion.getString(),
-        subproofString = `[${suppositionsString}]...${lastProofAssertionString}`;
+        lastStepString = lastStep.getString(),
+        subproofString = `[${suppositionsString}]...${lastStepString}`;
 
   return subproofString;
 }