occam-verify-cli 1.0.956 → 1.0.973

package/src/{utilities → process}/unification.js

@@ -2,8 +2,6 @@
 
 import elements from "../elements";
 
-import { descend } from "./context";
-
 async function unifyStepWithRule(step, context) {
   let stepUnifiesWithRule = false;
 
@@ -224,8 +222,8 @@ async function unifyStepAsUnqualifiedSignatureAssertion(step, context) {
   return stepUnifiesAsUnqualifiedSignatureAssertion;
 }
 
-async function validateStepAsMetaLevelAssumption(step, context) {
-  let stepValidatesAsMetaLevelAssumption = false;
+async function unifyStepAsQualifiedMetaLevelAssumption(step, context) {
+  let stepUnifiesAsQualifiedMetaLevelAssumption = false;
 
   const metaLevel = context.isMetaLevel();
 
@@ -234,37 +232,33 @@ async function validateStepAsMetaLevelAssumption(step, context) {
 
     if (reference !== null) {
       const stepString = step.getString(),
-            topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+            referenceString = reference.getString();
 
-      if (topLevelAssertion === null) {
-        context.trace(`Validating the '${stepString}' step as a meta-level assumption...`);
+      context.trace(`Unifying the '${stepString}' step as a meta-level assumption with the '${referenceString}' reference...`);
 
-        descend((context) => {
-          let metaLevelAssumption;
+      let metaLevelAssumption;
 
-          const { MetaLevelAssumption } = elements;
+      const { MetaLevelAssumption } = elements;
 
-          metaLevelAssumption = MetaLevelAssumption.fromStep(step, context);
+      metaLevelAssumption = MetaLevelAssumption.fromStep(step, context);
 
-          metaLevelAssumption = metaLevelAssumption.validate(context);  ///
+      metaLevelAssumption = metaLevelAssumption.validate(context);  ///
 
-          if (metaLevelAssumption !== null) {
-            stepValidatesAsMetaLevelAssumption = true;
-          }
-        }, context);
+      if (metaLevelAssumption !== null) {
+        stepUnifiesAsQualifiedMetaLevelAssumption = true;
+      }
 
-        if (stepValidatesAsMetaLevelAssumption) {
-          context.debug(`...validated the '${stepString}' step as a meta-level assumption.`);
-        }
+      if (stepUnifiesAsQualifiedMetaLevelAssumption) {
+        context.debug(`...unified the '${stepString}' step as a meta-level assumption with the '${referenceString}' reference.`);
       }
     }
   }
 
-  return stepValidatesAsMetaLevelAssumption;
+  return stepUnifiesAsQualifiedMetaLevelAssumption;
 }
 
-async function unifyStepAsSignatureAssertion(step, context) {
-  let stepUnifiesAsSignatureAssertion = false;
+async function unifyStepAsQualifiedSignatureAssertion(step, context) {
+  let stepUnifiesAsQualifiedSignatureAssertion = false;
 
   const reference = step.getReference();
 
@@ -285,17 +279,17 @@ async function unifyStepAsSignatureAssertion(step, context) {
         const unifyTopLevelAssertion = await signatureAssertion.unifyTopLevelAssertion(topLevelAssertion, context);
 
         if (unifyTopLevelAssertion) {
-          stepUnifiesAsSignatureAssertion = true;
+          stepUnifiesAsQualifiedSignatureAssertion = true;
         }
 
-        if (stepUnifiesAsSignatureAssertion) {
+        if (stepUnifiesAsQualifiedSignatureAssertion) {
           context.debug(`...unified the '${stepString}' step as a signature assertion with the '${referenceString}' reference.`);
         }
       }
     }
   }
 
-  return stepUnifiesAsSignatureAssertion;
+  return stepUnifiesAsQualifiedSignatureAssertion;
 }
 
 async function compareStepWithSubproofOrProofAssertions(step, context) {
@@ -332,7 +326,7 @@ export const unifySteps = [
   unifyStepAsUnqualifiedTypeAssertion,
   unifyStepAsUnqualifiedPropertyAssertion,
   unifyStepAsUnqualifiedSignatureAssertion,
-  validateStepAsMetaLevelAssumption,
-  unifyStepAsSignatureAssertion,
+  unifyStepAsQualifiedMetaLevelAssumption,
+  unifyStepAsQualifiedSignatureAssertion,
   compareStepWithSubproofOrProofAssertions
 ];

package/src/process/unify.js

@@ -4,6 +4,7 @@ import { queryUtilities, ZipPass as ZipPassBase } from "occam-languages";
 
 import ZipPass from "../pass/zip";
 
+import { reconcile } from "../utilities/context";
 import { FRAME_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 
@@ -159,12 +160,15 @@ class MetaLevelPass extends ZipPassBase {
 
         context = specificContext;  ///
 
-        const specificSignature = context.findSignatureBySignatureNode(specificSignatureNode),
-              signatureUnifies = generalSignature.unifySignature(specificSignature, generalContext, specificContext);
+        const specificSignature = context.findSignatureBySignatureNode(specificSignatureNode);
 
-        if (signatureUnifies) {
-          success = true;
-        }
+        reconcile((context) => {
+          const signatureUnifies = generalSignature.unifySignature(specificSignature, context);
+
+          if (signatureUnifies) {
+            success = true;
+          }
+        }, context)
 
         return success;
       }

package/src/{utilities → process}/validation.js

@@ -2,8 +2,8 @@
 
 import elements from "../elements";
 
-import { choose, descend } from "./context";
-import { provisionallyStringFromProvisional } from "./string";
+import { choose, descend } from "../utilities/context";
+import { provisionallyStringFromProvisional } from "../utilities/string";
 import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 
 function validateTermAsVariable(term, context, validateForwards) {

package/src/utilities/context.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import MenmicContext from "../context/mnemic";
+import MnemicContext from "../context/mnemic";
 import NestedContext from "../context/nested";
 import TheticContext from "../context/thetic";
 import AphasicContext from "../context/aphasic";
@@ -9,33 +9,16 @@ import NominalContext from "../context/nominal";
 import LiteralContext from "../context/literal";
 import LiminalContext from "../context/liminal";
 import PhanericContext from "../context/phaneric";
-import SynopticContext from "../context/synoptic";
 import IllativeContext from "../context/illative";
-import EphemeralContext from "../context/ephemeral";
 import BranchingContext from "../context/branching";
 import NominalFileContext from "../context/file/nominal";
 
 import { mnemicContextFromJSON, mnemicContextsFromJSON, mnemicContextToMnemicContextJSON, mnemicContextsToMnemicContextsJSON } from "../utilities/json";
 
-export function join(innerFunction, ...contexts) {
-  contexts = contexts.filter((context) => {
-    if (context !== null) {
-      return true;
-    }
-  });
-
-  const synopticContext = SynopticContext.fromContexts(contexts),
-        context = synopticContext;  ///
-
-  return innerFunction(context);
-}
-
-export function posit(innerFunction, context) {
-  const ephemeralContext = EphemeralContext.fromNothing(context);
-
-  context = ephemeralContext;  ///
+export function evaluate(procedure, terms) {
+  const context = procedure.getContext();
 
-  return innerFunction(context);
+  return procedure.call(terms, context);
 }
 
 export function ground(innerFunction) {
@@ -52,83 +35,80 @@ export function ground(innerFunction) {
   return innerFunction(context);
 }
 
-export function ablate(innerFunction, forced, context) {
-  if (context === undefined) {
-    context = forced; ///
+export function declare(innerFunction, context) {
+  const theticContext = TheticContext.fromNothing(context);
 
-    forced = false;
-  }
+  context = theticContext;  ///
 
-  const released = context.isReleased();
+  return innerFunction(context);
+}
 
-  if (forced || !released) {
-    context = ablateContext(context);
-  }
+export function derive(innerFunction, context) {
+  const illativeContext = IllativeContext.fromNothing(context);
+
+  context = illativeContext;  ///
 
   return innerFunction(context);
 }
 
-export function choose(innerFunction, context) {
-  const branchingContext = BranchingContext.fromNothing(context);
+export function elide(innerFunction, context) {
+  const aphasicContext = AphasicContext.fromNothing(context);
 
-  context = branchingContext;  ///
+  context = aphasicContext;  ///
 
   return innerFunction(context);
 }
 
-export function derive(innerFunction, context) {
-  const illativeContext = IllativeContext.fromNothing(context);
+export function enclose(innerFunction, context) {
+  const boundedContext = BoundedContext.fromNothing(context);
 
-  context = illativeContext;  ///
+  context = boundedContext;  ///
 
   return innerFunction(context);
 }
 
-export function declare(innerFunction, context) {
-  const theticContext = TheticContext.fromNothing(context);
+export function encapsulate(innerFunction, metaLevelAssumptions, context) {
+  const boundedContext = BoundedContext.fromMetaLevelAssumptions(metaLevelAssumptions, context);
 
-  context = theticContext;  ///
+  context = boundedContext;  ///
 
   return innerFunction(context);
 }
 
-export function descend(innerFunction, context) {
-  const nestedContext = NestedContext.fromNothing(context);
+export function choose(innerFunction, context) {
+  const branchingContext = BranchingContext.fromNothing(context);
 
-  context = nestedContext;  ///
+  context = branchingContext;  ///
 
   return innerFunction(context);
 }
 
-export function attempt(innerFunction, context) {
-  const released = context.isReleased();
-
-  if (!released) {
-    const mnemicContext = MenmicContext.fromNothing(context);
+export function descend(innerFunction, context) {
+  const nestedContext = NestedContext.fromNothing(context);
 
-    context = mnemicContext;  ///
-  }
+  context = nestedContext;  ///
 
   return innerFunction(context);
 }
 
-export function enclose(innerFunction, metaLevelAssumptions, context) {
-  if (context === undefined) {
-    context = metaLevelAssumptions;  ///
+export function ablate(innerFunction, context) {
+  const unreleased = context.isUnreleased();
 
-    metaLevelAssumptions = null;
+  if (unreleased) {
+    context = ablateContext(context); ///
   }
 
-  const boundedContext = BoundedContext.fromMetaLevelAssumptions(metaLevelAssumptions, context);
-
-  context = boundedContext;  ///
-
   return innerFunction(context);
 }
 
-export function manifest(innerFunction, ...contexts) {
-  const phanericContext = PhanericContext.fromContexts(contexts),
-        context = phanericContext;  ///
+export function attempt(innerFunction, context) {
+  const unreleased = context.isUnreleased();
+
+  if (unreleased) {
+    const mnemicContext = MnemicContext.fromNothing(context);
+
+    context = mnemicContext;  ///
+  }
 
   return innerFunction(context);
 }
@@ -141,14 +121,6 @@ export function reconcile(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function sequester(innerFunction, context) {
-  const aphasicContext = AphasicContext.fromNothing(context);
-
-  context = aphasicContext;  ///
-
-  return innerFunction(context);
-}
-
 export function serialise(innerFunction, context) {
   const mnemicContext = context, ///
         mnemicContextJSON = mnemicContextToMnemicContextJSON(mnemicContext),
@@ -159,14 +131,6 @@ export function serialise(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function instantiate(innerFunction, context) {
-  const literalContext = LiteralContext.fromNothing(context);
-
-  context = literalContext;  ///
-
-  return innerFunction(context);
-}
-
 export function unserialise(innerFunction, json, context) {
   const mnemicContext = mnemicContextFromJSON(json, context);
 
@@ -175,26 +139,34 @@ export function unserialise(innerFunction, json, context) {
   return innerFunction(json, context);
 }
 
-export function ablates(innerFunction, ...contexts) {
-  contexts = contexts.map((context) => {  ///
-    const released = context.isReleased();
+export function unserialises(innerFunction, json, context) {
+  const mnemicContexts = mnemicContextsFromJSON(json, context),
+        contexts = mnemicContexts; ///
 
-    if (!released) {
-      context = ablateContext(context);
-    }
+  return innerFunction(json, ...contexts);
+}
 
-    return context;
-  });
+export function instantiate(innerFunction, context) {
+  const literalContext = LiteralContext.fromNothing(context);
 
-  return innerFunction(...contexts);
+  context = literalContext;  ///
+
+  return innerFunction(context);
+}
+
+export function manifest(innerFunction, ...contexts) {
+  const phanericContext = PhanericContext.fromContexts(contexts),
+        context = phanericContext;  ///
+
+  return innerFunction(context);
 }
 
 export function attempts(innerFunction, ...contexts) {
   contexts = contexts.map((context) => {  ///
-    const released = context.isReleased();
+    const unreleased = context.isUnreleased();
 
-    if (!released) {
-      const mnemicContext = MenmicContext.fromNothing(context);
+    if (unreleased) {
+      const mnemicContext = MnemicContext.fromNothing(context);
 
       context = mnemicContext;  ///
     }
@@ -215,60 +187,37 @@ export function serialises(innerFunction, ...contexts) {
   return innerFunction(...contexts);
 }
 
-export function unserialises(innerFunction, json, context) {
-  const mnemicContexts = mnemicContextsFromJSON(json, context),
-        contexts = mnemicContexts; ///
+export function ablates(innerFunction, ...contexts) {
+  contexts = contexts.map((context) => {  ///
+    const unreleased = context.isUnreleased();
 
-  return innerFunction(json, ...contexts);
-}
+    if (unreleased) {
+      context = ablateContext(context); ///
+    }
 
-export function evaluate(procedure, terms) {
-  const context = procedure.getContext();
+    return context;
+  });
 
-  return procedure.call(terms, context);
+  return innerFunction(...contexts);
 }
 
 function ablateContext(context) {
-  const stated = context.isStated();
-
-  let contextExtraneousContext = isContextExtraneousContext(context);
-
-  while (contextExtraneousContext) {
-    context = context.getContext();
-
-    contextExtraneousContext = isContextExtraneousContext(context);
-  }
-
-  const Context = stated ? TheticContext : IllativeContext;
-
-  context = augmentContext(context, Context);
+    let contextGroundedContext = isContextGroundedContext(context);
 
-  return context;
-}
+    while (!contextGroundedContext) {
+      context = context.getContext();
 
-function augmentContext(context, Context) {
-  const contextContext = (context instanceof Context);
-
-  if (!contextContext) {
-    context = Context.fromNothing(context);
-  }
+      contextGroundedContext = isContextGroundedContext(context);
+    }
 
   return context;
 }
 
-function isContextExtraneousContext(context) {
-  const contextSubstantiveContext = isContextSubstantiveContext(context),
-        contextExtraneousContext = !contextSubstantiveContext;
-
-  return contextExtraneousContext;
-}
-
-function isContextSubstantiveContext(context) {
+function isContextGroundedContext(context) {
   const contextTheticContext = (context instanceof TheticContext),
         contextIllativeContext = (context instanceof IllativeContext),
-        contextBoundedContext = (context instanceof BoundedContext),
         contextNominalFileContext = (context instanceof NominalFileContext),
-        contextSubstantiveContext = (contextTheticContext || contextIllativeContext || contextBoundedContext || contextNominalFileContext);
+        contextGroundedContext = (contextTheticContext || contextIllativeContext || contextNominalFileContext);
 
-  return contextSubstantiveContext;
+  return contextGroundedContext;
 }

package/src/utilities/element.js

@@ -808,11 +808,8 @@ export function metaLevelAssumptionFromMetaLevelAssumptionNode(metaLevelAssumpti
         string = context.nodeAsString(node),
         breakPoint = null,
         reference = referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
-        statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
-
-  context = null;
-
-  const metaLevelAssumption = new MetaLevelAssumption(context, string, node, breakPoint, reference, statement);
+        statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
+        metaLevelAssumption = new MetaLevelAssumption(context, string, node, breakPoint, reference, statement);
 
   return metaLevelAssumption;
 }

package/src/utilities/string.js

@@ -258,16 +258,16 @@ export function topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeducti
         suppositionsString = suppositionsStringFromSuppositions(suppositions);
 
   topLevelAssertionString = (labelsString !== null) ?
-                              `${topLevelAssertionString}${labelsString} :: ` :
-                                `${topLevelAssertionString}`;
-
+                             `${topLevelAssertionString}${labelsString}` :
+                               `${topLevelAssertionString}`;
   topLevelAssertionString = (signatureString !== null) ?
-                             `${topLevelAssertionString} ${signatureString}` :
+                             `${topLevelAssertionString}${signatureString}` :
                                `${topLevelAssertionString}`;
 
+
   topLevelAssertionString = (suppositionsString !== null) ?
-                             `${topLevelAssertionString}[${suppositionsString}]...${deductionString}` :
-                               `${topLevelAssertionString}${deductionString}`;
+                             `${topLevelAssertionString} :: [${suppositionsString}]...${deductionString}` :
+                               `${topLevelAssertionString} :: ${deductionString}`;
 
   return topLevelAssertionString;
 }

package/lib/context/ephemeral.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return EphemeralContext;
-    }
-});
-const _context = /*#__PURE__*/ _interop_require_default(require("../context"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-class EphemeralContext extends _context.default {
-    isStated() {
-        const stated = true;
-        return stated;
-    }
-    static fromNothing(context) {
-        const ephemeralContext = new EphemeralContext(context);
-        return ephemeralContext;
-    }
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb250ZXh0L2VwaGVtZXJhbC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IENvbnRleHQgZnJvbSBcIi4uL2NvbnRleHRcIjtcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgRXBoZW1lcmFsQ29udGV4dCBleHRlbmRzIENvbnRleHQge1xuICBpc1N0YXRlZCgpIHtcbiAgICBjb25zdCBzdGF0ZWQgPSB0cnVlO1xuXG4gICAgcmV0dXJuIHN0YXRlZDtcbiAgfVxuXG4gIHN0YXRpYyBmcm9tTm90aGluZyhjb250ZXh0KSB7XG4gICAgY29uc3QgZXBoZW1lcmFsQ29udGV4dCA9IG5ldyBFcGhlbWVyYWxDb250ZXh0KGNvbnRleHQpO1xuXG4gICAgcmV0dXJuIGVwaGVtZXJhbENvbnRleHQ7XG4gIH1cbn0iXSwibmFtZXMiOlsiRXBoZW1lcmFsQ29udGV4dCIsIkNvbnRleHQiLCJpc1N0YXRlZCIsInN0YXRlZCIsImZyb21Ob3RoaW5nIiwiY29udGV4dCIsImVwaGVtZXJhbENvbnRleHQiXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQUlBOzs7ZUFBcUJBOzs7Z0VBRkQ7Ozs7OztBQUVMLE1BQU1BLHlCQUF5QkMsZ0JBQU87SUFDbkRDLFdBQVc7UUFDVCxNQUFNQyxTQUFTO1FBRWYsT0FBT0E7SUFDVDtJQUVBLE9BQU9DLFlBQVlDLE9BQU8sRUFBRTtRQUMxQixNQUFNQyxtQkFBbUIsSUFBSU4saUJBQWlCSztRQUU5QyxPQUFPQztJQUNUO0FBQ0YifQ==