occam-verify-cli 1.0.564 → 1.0.570

package/src/element/frame.js

@@ -1,53 +1,26 @@
 "use strict";
 
 import { Element } from "occam-languages";
-import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
 import { assumptionsStringFromAssumptions } from "../utilities/string";
 
-const { first } = arrayUtilities;
-
 export default define(class Frame extends Element {
-  constructor(context, string, node, assumptions) {
+  constructor(context, string, node, assumptions, metavairable) {
     super(context, string, node);
 
     this.assumptions = assumptions;
+    this.metavariable = metavairable;
   }
 
   getAssumptions() {
     return this.assumptions;
   }
 
-  getLength() { return this.assumptions.length; }
-
-  getAssumption() {
-    let assumption = null;
-
-    const length = this.getLength();
-
-    if (length === 1) {
-      const firstAssumption = first(this.assumptions);
-
-      assumption = firstAssumption; ///
-    }
-
-    return assumption;
-  }
-
   getMetavariable() {
-    let metavariable = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const assumption = this.getAssumption();
-
-      metavariable = assumption.getMetavariable();
-    }
-
-    return metavariable;
+    return this.metavariable;
   }
 
   getMetavariableName() {
@@ -59,7 +32,8 @@ export default define(class Frame extends Element {
 
   isSingular() {
     const node = this.getNode(),
-          singular = node.isSingular();
+          frameNode = node, ///
+          singular = frameNode.isSingular();
 
     return singular;
   }
@@ -86,6 +60,17 @@ export default define(class Frame extends Element {
     return metavariableEqualToMetavariable;
   }
 
+  isEqualTo(frame) {
+    const frameA = this, ///
+          frameB = frame, ///
+          frameANode = frameA.getNode(),
+          frameBNode = frameB.getNode(),
+          frameANodeMatchesFrameBNode = frameANode.match(frameBNode),
+          equalTo = frameANodeMatchesFrameBNode; ///
+
+    return equalTo;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -161,9 +146,10 @@ export default define(class Frame extends Element {
 
     context.trace(`Validating the '${frameString}' frame...`);
 
-    const assumptionsValidate = this.validateAssumptions(assignments, stated, context);
+    const assumptionsValidate = this.validateAssumptions(assignments, stated, context),
+          metavariablevalidates = this.validateMetavariable(assignments, stated, context);
 
-    if (assumptionsValidate) {
+    if (assumptionsValidate && metavariablevalidates) {
       let validatesWhenStated = false,
           validatesWhenDerived = false;
 
@@ -230,28 +216,69 @@ export default define(class Frame extends Element {
   validateAssumptions(assignments, stated, context) {
     let assumptionsValidate;
 
-    const frameString = this.getString(), ///
-          assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
+    const singular = this.isSingular();
 
-    context.trace(`Validating the '${assumptionsString}' assumptions of the '${frameString}' frame...`);
+    if (!singular) {
+      const frameString = this.getString(), ///
+            assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
-    stated = true;  ///
+      context.trace(`Validating the '${assumptionsString}' assumptions of the '${frameString}' frame...`);
 
-    assignments = null; ///
+      stated = true;  ///
 
-    assumptionsValidate = this.assumptions.every((assumption) => {
-      const assumptionVerifies = assumption.validate(assignments, stated, context);
+      assignments = null; ///
 
-      return assumptionVerifies;
-    });
+      assumptionsValidate = this.assumptions.every((assumption) => {
+        const assumptionVerifies = assumption.validate(assignments, stated, context);
 
-    if (assumptionsValidate) {
-      context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
+        return assumptionVerifies;
+      });
+
+      if (assumptionsValidate) {
+        context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
+      }
+    } else {
+      assumptionsValidate = true;
     }
 
     return assumptionsValidate;
   }
 
+  validateMetavariable(assignments, stated, context) {
+    let metavariableValidates = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const frameString = this.getString(), ///
+            metavraibleString = this.metavariable.getString();
+
+      context.trace(`Validating the '${frameString}' frame's '${metavraibleString}' metavariable...`);
+
+      const metavariable = context.findMetavariable(this.metavariable);
+
+      if (metavariable !== null) {
+        const metaTypeName = FRAME_META_TYPE_NAME,
+              frameMetaType = findMetaTypeByMetaTypeName(metaTypeName),
+              metavariableValidateGivenMetaType = metavariable.validateGivenMetaType(frameMetaType, context);
+
+        if (metavariableValidateGivenMetaType) {
+          metavariableValidates = true;
+        }
+      } else {
+        context.debug(`The '${frameString}' frame's '${metavraibleString}' metavariable is not present.`);
+      }
+
+      if (metavariableValidates) {
+        context.debug(`...validated the '${frameString}' frame's '${metavraibleString}' metavariable.`);
+      }
+    } else {
+      metavariableValidates = true;
+    }
+
+    return metavariableValidates;
+  }
+
   validateGivenMetaType(metaType, assignments, stated, context) {
     let validatesGivenMetaType = false;
 

package/src/element/judgement.js

@@ -23,7 +23,8 @@ export default define(class Judgement extends Element {
 
   isSingular() {
     const node = this.getNode(),
-          singular = node.isSingular();
+          judgementNode = node, ///
+          singular = judgementNode.isSingular();
 
     return singular;
   }

package/src/element/metavariable.js

@@ -6,7 +6,6 @@ import elements from "../elements";
 
 import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
-import { synthetically } from "../utilities/context";
 import { typeToTypeJSON } from "../utilities/json";
 import { metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
@@ -103,7 +102,7 @@ export default define(class Metavariable extends Element {
     return validatesGivenMetaType;
   }
 
-  unifyFrame(frame, substitutions, generalContext, specificContext) {
+  unifyFrame(frame, generalContext, specificContext) {
     let frameUnifies = false;
 
     const context = specificContext,  ///
@@ -112,30 +111,27 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const frameMetavariableUnifies = this.unifyFrameMetavariable(frame, substitutions, generalContext, specificContext);
+    const metavariable = this, ///
+          frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
 
     if (frameMetavariableUnifies) {
       frameUnifies = true;
     } else {
-      const metavariable = this, ///
-            simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
+      const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
 
-      if (simpleSubstitutionPresent) {
-        const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable),
-              substitution = simpleSubstitution,  ///
+      if (simpleSubstitution !== null) {
+        const substitution = simpleSubstitution,  ///
               substitutionFrameEqualToFrame = substitution.isFrameEqualToFrame(frame);
 
         if (substitutionFrameEqualToFrame) {
           frameUnifies = true;
         }
       } else {
-        const metavariable = this;  ///
+        const { FrameSubstitution } = elements,
+              frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
+              substitution = frameSubstitution; ///
 
-        synthetically((context) => {
-          const { FrameSubstitution } = elements;
-
-          FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context);
-        }, generalContext, specificContext);
+        context.addSubstitution(substitution);
 
         frameUnifies = true;
       }
@@ -148,7 +144,7 @@ export default define(class Metavariable extends Element {
     return frameUnifies;
   }
 
-  unifyStatement(statement, substitution, substitutions, generalContext, specificContext) {
+  unifyStatement(statement, substitution, generalContext, specificContext) {
     let statementUnifies = false;
 
     const context = specificContext,  ///
@@ -160,17 +156,17 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
-    const statementMetavariableUnifies = this.unifyStatementMetavariable(statement, substitutions, generalContext, specificContext);
+    const metavariable = this, ///
+          statementMetavariableUnifies = this.unifyStatementMetavariable(statement, generalContext, specificContext);
 
     if (statementMetavariableUnifies) {
       statementUnifies = true;
     } else {
       const context = specificContext,  ///
-            metavariable = this, ///
-            substitutionPresent = substitutions.isSubstitutionPresentByMetavariableAndSubstitution(metavariable, substitution);
+            substitutionPresent = context.isSubstitutionPresentByMetavariableAndSubstitution(metavariable, substitution);
 
       if (substitutionPresent) {
-        substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
+        substitution = context.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
 
         const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
@@ -178,16 +174,14 @@ export default define(class Metavariable extends Element {
           statementUnifies = true;
         }
       } else {
-        const metavariable = this;  ///
+        const { StatementSubstitution } = elements,
+              statementSubstitution = (substitution !== null) ?
+                                        StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
+                                          StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
-        synthetically((context) => {
-          const { StatementSubstitution } = elements;
+        substitution = statementSubstitution; ///
 
-          (substitution !== null) ?
-            StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
-              StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
-
-        }, generalContext, specificContext);
+        context.addSubstitution(substitution);
 
         statementUnifies = true;
       }
@@ -209,13 +203,13 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
-    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
+    const metavariable = this, ///
+          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, substitutions, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const metavariable = this, ///
-            simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
+      const simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariable(metavariable);
 
       if (simpleSubstitutionPresent) {
         const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariable(metavariable), ///
@@ -226,13 +220,11 @@ export default define(class Metavariable extends Element {
           referenceUnifies = true;
         }
       } else {
-        const metavariable = this;  ///
+        const { ReferenceSubstitution } = elements,
+              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
+              substitution = referenceSubstitution; ///
 
-        synthetically((context) => {
-          const { ReferenceSubstitution } = elements;
-
-          ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context);
-        }, generalContext, specificContext);
+        context.addSubstitution(substitution);
 
         referenceUnifies = true;
       }
@@ -272,7 +264,7 @@ export default define(class Metavariable extends Element {
     return metavariableUnifies;
   }
 
-  unifyFrameMetavariable(frame, substitutions, generalContext, specificContext) {
+  unifyFrameMetavariable(frame, generalContext, specificContext) {
     let frameMetavariableUnifies = false;
 
     const context = specificContext,  ///
@@ -312,7 +304,7 @@ export default define(class Metavariable extends Element {
     return frameMetavariableUnifies;
   }
 
-  unifyStatementMetavariable(statement, substitutions, generalContext, specificContext) {
+  unifyStatementMetavariable(statement, generalContext, specificContext) {
     let statementMetavariableUnifies = false;
 
     const context = specificContext,  ///
@@ -338,7 +330,7 @@ export default define(class Metavariable extends Element {
 
           const generalMetavariable = this, ///
                 specificMetavariable = statementMetavariable, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
+                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
           statementMetavariableUnifies = metavariableUnifiesIntrinsically; ///
 

package/src/element/proofAssertion/premise.js

@@ -4,7 +4,7 @@ import ProofAssertion from "../proofAssertion";
 import assignAssignments from "../../process/assign";
 
 import { define } from "../../elements";
-import { attempt, synthetically } from "../../utilities/context";
+import { attempt, liminally } from "../../utilities/context";
 import { statementFromJSON, procedureCallFromJSON, statementToStatementJSON, procedureCallToProcedureCallJSON } from "../../utilities/json";
 
 export default define(class Premise extends ProofAssertion {
@@ -118,8 +118,13 @@ export default define(class Premise extends ProofAssertion {
     return unifiesIndependently;
   }
 
-  unifySubproofOrProofAssertion(subproofOrProofAssertion, substitutions, context) {
-    let subproofOrProofAssertionUnifies = false;
+  unifySubproofOrProofAssertion(subproofOrProofAssertion, context) {
+    let subproofOrProofAssertionUnifies;
+
+    const premiseString = this.getString(), ///
+          subproofOrProofAssertionString = subproofOrProofAssertion.getString();
+
+    context.trace(`Unifying the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${premiseString}' premise...`);
 
     const subproofOrProofAssertionProofAssertion = subproofOrProofAssertion.isProofAssertion(),
           proofAssertion = subproofOrProofAssertionProofAssertion ?
@@ -129,62 +134,52 @@ export default define(class Premise extends ProofAssertion {
                         null :
                           subproofOrProofAssertion;
 
-    substitutions.snapshot(context);
-
-    if (subproof !== null) {
-      const subproofUnifies = this.unifySubproof(subproof, substitutions, context);
+    if (proofAssertion !== null) {
+      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, context);
 
-      if (subproofUnifies) {
+      if (proofAssertionUnifies) {
         subproofOrProofAssertionUnifies = true;
       }
     }
 
-    if (proofAssertion !== null) {
-      const proofAssertionUnifies = this.unifyProofAssertion(proofAssertion, substitutions, context);
+    if (subproof !== null) {
+      const subproofUnifies = this.unifySubproof(subproof, context);
 
-      if (proofAssertionUnifies) {
+      if (subproofUnifies) {
         subproofOrProofAssertionUnifies = true;
       }
     }
 
     if (subproofOrProofAssertionUnifies) {
-      substitutions.resolve(context);
+      context.debug(`...unified the '${subproofOrProofAssertionString}' subproof or proof assertion with the '${premiseString}' premise.`);
     }
 
-    subproofOrProofAssertionUnifies ?
-      substitutions.continue(context) :
-        substitutions.rollback(context);
-
     return subproofOrProofAssertionUnifies;
   }
 
-  unifyProofAssertion(proofAssertion, substitutions, context) {
-    let proofAssertionUnifies = false;
+  unifyProofAssertion(proofAssertion, context) {
+    let proofAssertionUnifies;
 
     const premiseString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
 
     context.trace(`Unifying the '${proofAssertionString}' proof assertion with the '${premiseString}' premise...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
     const proofAssertionContext = proofAssertion.getContext(),
-          statementUnifies = synthetically((specificContext) => {
-            const statement = proofAssertion.getStatement(),
-                  statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+          premiseContext = this.getContext(),
+          generalContext = premiseContext, ///
+          specificContext = proofAssertionContext; ///
 
-            return statementUnifies;
-          }, specificContext, proofAssertionContext);
+    proofAssertionUnifies = liminally((specificContext) => {
+      const statement = proofAssertion.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-    if (statementUnifies) {
-      proofAssertionUnifies = true;
-    }
+      if (statementUnifies) {
+        specificContext.commit(context);
+
+        return true;
+      }
+    }, specificContext);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
@@ -193,7 +188,7 @@ export default define(class Premise extends ProofAssertion {
     return proofAssertionUnifies;
   }
 
-  unifySubproof(subproof, substitutions, context) {
+  unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
     const premiseString = this.getString(),

package/src/element/proofAssertion/step.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import elements from "../../elements";
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
@@ -59,6 +58,8 @@ export default define(class Step extends ProofAssertion {
   verify(assignments, context) {
     let verifies = false;
 
+    this.break(context);
+
     const stepString = this.getString(); ///
 
     context.trace(`Verifying the '${stepString}' step...`);
@@ -165,9 +166,8 @@ export default define(class Step extends ProofAssertion {
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
-      const { Substitutions } = elements,
-            step = this,  ///
-            substitutions = Substitutions.fromNothing(context),
+      const step = this,  ///
+            substitutions = [],
             stepUnifies = axiom.unifyStep(step, substitutions, context);
 
       if (stepUnifies) {

package/src/element/proofAssertion/supposition.js

@@ -24,9 +24,11 @@ export default define(class Supposition extends ProofAssertion {
     return stated;
   }
 
-  verify(context) {
+  async verify(context) {
     let verifies = false;
 
+    this.break(context);
+
     const suppositionString = this.getString(); ///
 
     context.trace(`Verifying the '${suppositionString}' supposition...`);

package/src/element/proofAssertion.js

@@ -59,7 +59,7 @@ export default class ProofAssertion extends Element {
     statementValidates = this.statement.validate(assignments, stated, context);
 
     if (statementValidates) {
-      context.debug(`...validated the '${proofAssertionString}' proof assertion's '${statementString}' reference. `);
+      context.debug(`...validated the '${proofAssertionString}' proof assertion's '${statementString}' statement. `);
     }
 
     return statementValidates;
@@ -71,14 +71,14 @@ export default class ProofAssertion extends Element {
     if (this.statement !== null) {
       const context = specificContext, ///
             statementString = statement.getString(),
-            proorAssertionString = this.getString();  ///
+            proofAssertionString = this.getString();  ///
 
-      context.trace(`Unifying the '${statementString}' statement with the '${proorAssertionString}' proof assertion...`);
+      context.trace(`Unifying the '${statementString}' statement with the '${proofAssertionString}' proof assertion...`);
 
       statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
       if (statementUnifies) {
-        context.debug(`...unified the '${statementString}' statement with the '${proorAssertionString}' proof assertion.`);
+        context.debug(`...unified the '${statementString}' statement with the '${proofAssertionString}' proof assertion.`);
       }
     }
 

package/src/element/reference.js

@@ -36,6 +36,17 @@ export default define(class Reference extends Element {
 
   isMetavariableEqualToMetavariable(metavariable) { return this.metavariable.isEqualTo(metavariable); }
 
+  isEqualTo(reference) {
+    const referenceA = this, ///
+          referenceB = reference, ///
+          referenceANode = referenceA.getNode(),
+          referenceBNode = referenceB.getNode(),
+          referenceANodeMatchesReferenceBNode = referenceANode.match(referenceBNode),
+          equalTo = referenceANodeMatchesReferenceBNode; ///
+
+    return equalTo;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -214,9 +225,8 @@ export default define(class Reference extends Element {
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
-    const { Substitutions } = elements,
-          label = topLevelMetaAssertion.getLabel(),
-          substitutions = Substitutions.fromNothing(context),
+    const label = topLevelMetaAssertion.getLabel(),
+          substitutions = [],
           labelUnifies = this.unifyLabel(label, substitutions, context);
 
     topLevelMetaAssertionUnifies = labelUnifies;  ///