occam-verify-cli 1.0.768 → 1.0.776

package/src/utilities/context.js

@@ -1,38 +1,53 @@
 "use strict";
 
-import ScopedContext from "../context/scoped";
+import ProofContext from "../context/proof";
+import NestedContext from "../context/nested";
+import TheticContext from "../context/thetic";
 import NominalContext from "../context/nominal";
 import LiteralContext from "../context/literal";
 import LiminalContext from "../context/liminal";
+import IllativeContext from "../context/illative";
 import EphemeralContext from "../context/ephemeral";
 import BranchingContext from "../context/branching";
 import SyntheticContext from "../context/synthetic";
 
-export function nominally(innerFunction) {
-  let context;
+import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
-  const nominalContext = NominalContext.fromNothing();
+export function join(innerFunction, ...contexts) {
+  const syntheticContext = SyntheticContext.fromContexts(...contexts),
+        context = syntheticContext;  ///
 
-  context = nominalContext; ///
+  return innerFunction(context);
+}
 
-  const literalContext = LiteralContext.fromNothing(context);
+export function choose(innerFunction, context) {
+  const branchingContext = BranchingContext.fromNothing(context);
 
-  context = literalContext;  ///
+  context = branchingContext;  ///
 
   return innerFunction(context);
 }
 
-export function join(innerFunction, ...contexts) {
-  const syntheticContext = SyntheticContext.fromContexts(...contexts),
-        context = syntheticContext;  ///
+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 declare(innerFunction, context) {
+  const theticContext = TheticContext.fromNothing(context);
 
-  context = branchingContext;  ///
+  context = theticContext;  ///
+
+  return innerFunction(context);
+}
+
+export function descend(innerFunction, context) {
+  const nestedContext = NestedContext.fromNothing(context);
+
+  context = nestedContext;  ///
 
   return innerFunction(context);
 }
@@ -61,6 +76,54 @@ export function instantiate(innerFunction, context) {
   return innerFunction(context);
 }
 
+export function nominally(innerFunction) {
+  let context;
+
+  const nominalContext = NominalContext.fromNothing();
+
+  context = nominalContext; ///
+
+  const literalContext = LiteralContext.fromNothing(context);
+
+  context = literalContext;  ///
+
+  return innerFunction(context);
+}
+
+export function simplify(innerFunction, context) {
+  let contextExtraneousContext = isContextExtraneousContext(context);
+
+  while (contextExtraneousContext) {
+    context = context.getContext();
+
+    contextExtraneousContext = isContextExtraneousContext(context);
+  }
+
+  const ephemeralContext = EphemeralContext.fromNothing(context);
+
+  context = ephemeralContext; ///
+
+  return innerFunction(context);
+}
+
+export function serialise(innerFunction, context) {
+  const ephemeralContext = context, ///
+        ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
+        contextJSON = ephemeralContextJSON; ///
+
+  context = contextJSON;  ///
+
+  return innerFunction(context);
+}
+
+export function unserialise(innerFunction, json, context) {
+  const ephemeralContext = ephemeralContextFromJSON(json, context);
+
+  context = ephemeralContext; ///
+
+  return innerFunction(json, context);
+}
+
 export async function asyncRestrict(innerFunction, metaLevelSubstitutions, context) {
   if (context === undefined) {
     context = metaLevelSubstitutions;  ///
@@ -68,9 +131,9 @@ export async function asyncRestrict(innerFunction, metaLevelSubstitutions, conte
     metaLevelSubstitutions = null;
   }
 
-  const scopedContext = ScopedContext.fromMetaLevelSubstitutions(metaLevelSubstitutions, context);
+  const proofContext = ProofContext.fromMetaLevelSubstitutions(metaLevelSubstitutions, context);
 
-  context = scopedContext;  ///
+  context = proofContext;  ///
 
   return await innerFunction(context);
 }
@@ -83,27 +146,15 @@ export async function asyncReconcile(innerFunction, context) {
   return await innerFunction(context);
 }
 
-export function sanitisedContextFromContext(context) {
-  let contextExtraneousContext = isContextExtraneousContext(context);
-
-  while (contextExtraneousContext) {
-    context = context.getContext();
-
-    contextExtraneousContext = isContextExtraneousContext(context);
-  }
-
-  const ephemeralContext = EphemeralContext.fromNothing(context),
-        sanitisedContext = ephemeralContext; ///
-
-  return sanitisedContext;
-}
-
 function isContextExtraneousContext(context) {
   const contextLiminalContext = (context instanceof LiminalContext),
         contextEphemeralContext = (context instanceof EphemeralContext),
         contextBranchingContext = (context instanceof BranchingContext),
         contextSyntheticContext = (context instanceof SyntheticContext),
-        contextExtraneousContext = (contextLiminalContext || contextEphemeralContext || contextBranchingContext || contextSyntheticContext);
+        contextExtraneousContext = ( contextLiminalContext
+                                  || contextEphemeralContext
+                                  || contextBranchingContext
+                                  || contextSyntheticContext );
 
   return contextExtraneousContext;
 }

package/src/utilities/element.js

@@ -2,9 +2,9 @@
 
 import elements from "../elements";
 
-import { instantiate } from "../utilities/context";
 import { baseTypeFromNothing } from "../utilities/type";
-import { instantiateReference } from "../process/instantiate";
+import { simplify, instantiate,} from "../utilities/context";
+import { instantiateLabel, instantiateReference } from "../process/instantiate";
 import { equivalenceStringFromTerms,
          typeStringFromNominalTypeName,
          rulsStringFromLabelsPremisesAndConclusion,
@@ -13,7 +13,6 @@ import { equivalenceStringFromTerms,
          procedureCallStringFromProcedureReferenceAndParameters,
          topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
          topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
-import EphemeralContext from "../context/ephemeral";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -321,11 +320,9 @@ export function referenceFromReferenceNode(referenceNode, context) {
   const { Reference } = elements,
         node = referenceNode, ///
         string = context.nodeAsString(node),
-        metavariable = metavariableFromReferenceNode(referenceNode, context);
-
-  context = null;
-
-  const reference = new Reference(context, string, node, metavariable);
+        metavariable = metavariableFromReferenceNode(referenceNode, context),
+        topLevelMetaAssertion = topLevelMetaAssertionFromReferenceNode(referenceNode, context),
+        reference = new Reference(context, string, node, metavariable, topLevelMetaAssertion);
 
   return reference;
 }
@@ -509,13 +506,14 @@ export function suppositionFromSuppositionNode(suppositionNode, context) {
 export function equivalenceFromEquivalenceNode(equivalenceNode, context) {
   const { Equivalence } = elements,
         node = equivalenceNode, ///
+        type = typeFromEquivalenceNode(equivalenceNode, context),
         terms = termsFromEquivalenceNode(equivalenceNode, context),
         equivalenceString = equivalenceStringFromTerms(terms),
         string = equivalenceString; ///
 
   context = null;
 
-  const equivalence = new Equivalence(context, string, node, terms);
+  const equivalence = new Equivalence(context, string, node, type, terms);
 
   return equivalence;
 }
@@ -677,12 +675,6 @@ export function subproofAssertionFromSubproofAssertionNode(subproofAssertionNode
   return subproofAssertion;
 }
 
-export function substitutionsFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
-  const substitutions = [];
-
-  return substitutions;
-}
-
 export function containedAssertionFromContainedAssertionNode(containedAssertionNode, context) {
   const { ContainedAssertion } = elements,
         node = containedAssertionNode,  ///
@@ -945,7 +937,9 @@ export function referenceFromStepNode(stepNode, context) {
   const referenceNode = stepNode.getReferenceNode();
 
   if (referenceNode !== null) {
-    reference = referenceFromReferenceNode(referenceNode, context);
+    const referenceString = context.nodeAsString(referenceNode);
+
+    reference = referenceFromReferenceString(referenceString, context);
   }
 
   return reference;
@@ -1042,6 +1036,12 @@ export function typeFromConstructorNode(ocnstructorNode, context) {
   return type;
 }
 
+export function typeFromEquivalenceNode(equivalenceNode, context) {
+  const type = null;
+
+  return type;
+}
+
 export function assumptionsFromFrameNode(frameNode, context) {
   const assumptionNodes = frameNode.getAssumptionNodes(),
         assumptions = assumptionsFromAssumptionNodes(assumptionNodes, context);
@@ -1361,16 +1361,11 @@ export function metavariableFromReferenceNode(referenceNode, context) {
 }
 
 export function referenceFromMetavariableNode(metavariableNode, context) {
-  const metavariableString = context.nodeAsString(metavariableNode);
+  const metavariableString = context.nodeAsString(metavariableNode),
+        referenceString = metavariableString, ///
+        reference = referenceFromReferenceString(referenceString, context);
 
-  return instantiate((context) => {
-    const referenceString = metavariableString, ///
-          string = referenceString,  ///
-          referenceNode = instantiateReference(string, context),
-          reference = referenceFromReferenceNode(referenceNode, context);
-
-    return reference;
-  }, context);
+  return reference;
 }
 
 export function termFromJDefinedAssertionNode(definedAssertionNode, context) {
@@ -1607,7 +1602,8 @@ export function proofFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, cont
 
 export function labelFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   const labelNode = metaLemmaMetathoremNode.getLabelNode(),
-        label = labelFromLabelNode(labelNode, context);
+        labelString = context.nodeAsString(labelNode),
+        label = labelFromLabelString(labelString, context);
 
   return label;
 }
@@ -1729,7 +1725,8 @@ export function signatureFromJSatisfiesAssertionNode(sasisfiesAssertionNode, con
 
 export function referenceFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
   const referenceNode = sasisfiesAssertionNode.getReferenceNode(),
-        reference = referenceFromReferenceNode(referenceNode, context);
+        referenceString = context.nodeAsString(referenceNode),
+        reference = referenceFromReferenceString(referenceString, context);
 
   return reference;
 }
@@ -1754,6 +1751,12 @@ export function resolvedFromStatementSubstitutionNode(statementSubstitutionNode,
   return resolved;
 }
 
+export function topLevelMetaAssertionFromReferenceNode(referenceNode, context) {
+  const topLevelMetaAssertion = null;
+
+  return topLevelMetaAssertion;
+}
+
 export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   const deductionNode = metaLemmaMetathoremNode.getDeductionNode(),
         deduction = deductionFromDeductionNode(deductionNode, context);
@@ -1887,14 +1890,16 @@ export function metavariableFromMetavariableDeclarationNode(metavariableDeclarat
 
 export function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
   const targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode(),
-        targetRefernece = referenceFromReferenceNode(targetReferenceNode, context);
+        targetReferenceString = context.nodeAsString(targetReferenceNode),
+        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
 
   return targetRefernece;
 }
 
 export function targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context) {
   const targetReferenceNode = metaLevelSubstitutionNode.getTargetReferenceNode(),
-        targetRefernece = referenceFromReferenceNode(targetReferenceNode, context);
+        targetReferenceString = context.nodeAsString(targetReferenceNode),
+        targetRefernece = referenceFromReferenceString(targetReferenceString, context);
 
   return targetRefernece;
 }
@@ -1932,7 +1937,8 @@ export function frameSubstitutionFromStatementSubstitutionNode(statementSubstitu
 
 export function replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
   const replacementReferenceNode = referenceSubstitutionNode.getReplacementReferenceNode(),
-        replacementReference = referenceFromReferenceNode(replacementReferenceNode, context);
+        replacementReferenceString = context.nodeAsString(replacementReferenceNode),
+        replacementReference = referenceFromReferenceString(replacementReferenceString, context);
 
   return replacementReference;
 }
@@ -1980,7 +1986,8 @@ export function typesFromTypesNode(typesNode, context) {
 
 export function labelsFromLabelNodes(labelNodes, context) {
   const labels = labelNodes.map((labelNode) => {
-    const label = labelFromLabelNode(labelNode, context);
+    const labelString = context.nodeAsString(labelNode),
+          label = labelFromLabelString(labelString, context);
 
     return label;
   });
@@ -2069,3 +2076,33 @@ export function stepsOrSubproofsFromSubDerivationNode(subDerivationNode, context
 
   return stepsOrSubproofs;
 }
+
+export function labelFromLabelString(labelString, context) {
+  let label;
+
+  simplify((context) => {
+    instantiate((context) => {
+      const string = labelString,  ///
+            labelNode = instantiateLabel(string, context);
+
+      label = labelFromLabelNode(labelNode, context);
+    }, context);
+  }, context);
+
+  return label;
+}
+
+export function referenceFromReferenceString(referenceString, context) {
+  let reference;
+
+  simplify((context) => {
+    instantiate((context) => {
+      const string = referenceString,  ///
+            referenceNode = instantiateReference(string, context);
+
+      reference = referenceFromReferenceNode(referenceNode, context);
+    }, context);
+  }, context);
+
+  return reference;
+}

package/src/utilities/json.js

@@ -56,6 +56,19 @@ export function typeFromJSON(json, context) {
   return type;
 }
 
+export function labelFromJSON(json, context) {
+  let { label } = json;
+
+  const { Label } = elements,
+    labelJSON = label;  ///
+
+  json = labelJSON; ///
+
+  label = Label.fromJSON(json, context);
+
+  return label;
+}
+
 export function frameFromJSON(json, context) {
   let { frame } = json;
 
@@ -270,19 +283,6 @@ export function rulesFromJSON(json, context) {
   return rules;
 }
 
-export function labelFromJSON(json, context) {
-  let { label } = json;
-
-  const { Label } = elements,
-        labelJSON = label;  ///
-
-  json = labelJSON; ///
-
-  label = Label.fromJSON(json, context);
-
-  return label;
-}
-
 export function framesFromJSON(json, context) {
   let { frames } = json;
 

package/src/utilities/statement.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import { equalityFromStatementNode,
-         judgementFromStatementNode,
+import { judgementFromStatementNode,
          metavariableFromStatementNode,
          typeAssertionFromStatementNode,
          definedAssertionFromStatementNode,
@@ -10,13 +9,6 @@ import { equalityFromStatementNode,
          containedAssertionFromStatementNode,
          satisfiesAssertionFromStatementNode } from "../utilities/element";
 
-export function equalityFromStatement(statement, context) {
-  const statementNode = statement.getNode(),
-        equality = equalityFromStatementNode(statementNode, context);
-
-  return equality;
-}
-
 export function judgementFromStatement(statement, context) {
   const statementNode = statement.getNode(),
         judgement = judgementFromStatementNode(statementNode, context);

package/src/utilities/string.js

@@ -108,8 +108,8 @@ export function suppositionsStringFromSuppositions(suppositions) {
     const suppositionString = supposition.getString();
 
     suppositionsString = (suppositionsString === null) ?
-                           suppositionString: ///
-                            `${suppositionsString}, ${suppositionString}`;
+                            suppositionString: ///
+                             `${suppositionsString}, ${suppositionString}`;
 
     return suppositionsString;
   }, null);
@@ -117,6 +117,20 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
+export function metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions) {
+  const metaLevelSubstitutionsString = metaLevelSubstitutions.reduce((metaLevelSubstitutionsString, metaLevelSubstitution) => {
+    const metaLevelSubstitutionString = metaLevelSubstitution.getString();
+
+    metaLevelSubstitutionsString = (metaLevelSubstitutionsString === null) ?
+                                     metaLevelSubstitutionString: ///
+                                      `${metaLevelSubstitutionsString}, ${metaLevelSubstitutionString}`;
+
+    return metaLevelSubstitutionsString;
+  }, null);
+
+  return metaLevelSubstitutionsString;
+}
+
 export function signatureStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
         signatureString = `[${termsString}]`;

package/src/utilities/unification.js

@@ -4,8 +4,8 @@ import { arrayUtilities } from "necessary";
 
 import elements from "../elements";
 
-import { equalityFromStatement,
-         judgementFromStatement,
+import { descend } from "./context";
+import { judgementFromStatement,
          typeAssertionFromStatement,
          propertyAssertionFromStatement,
          satisfiesAssertionFromStatement } from "../utilities/statement";
@@ -49,7 +49,7 @@ async function unifyStatementWithReference(statement, reference, satisfiesAssert
 
     context.trace(`Unifying the '${statementString}' statement with the '${referenceString}' reference...`);
 
-    const topLevelAssertion = context.findTopLevelAssertionByReference(reference, context);
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
@@ -91,9 +91,9 @@ async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfie
 
     context.trace(`Unifying the '${statementString}' statement as a satisfies assertion...`);
 
-    const stated = true;
-
-    satisfiesAssertion.verifySignature(stated, context);
+    descend((context) => {
+      satisfiesAssertion.verifySignature(context);
+    }, context);
 
     if (reference === null) {
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
@@ -106,7 +106,7 @@ async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfie
         }
       });
     } else {
-      const topLevelAssertion = context.findTopLevelAssertionByReference(reference, context);
+      const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
       if (topLevelAssertion !== null) {
         reference = satisfiesAssertion.getReference();
@@ -147,7 +147,7 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
   let statementUnifiesWithTopLevelAssertion = false;
 
   if (reference !== null) {
-    const topLevelAssertion = context.findTopLevelAssertionByReference(reference, context);
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
       const statementString = statement.getString(),
@@ -175,7 +175,8 @@ async function unifyStatementAsEquality(statement, reference, satisfiesAssertion
   let statementUnifiesAEquality = false;
 
   if (reference === null) {
-    const equality = equalityFromStatement(statement, context);
+    const { Equality } = elements,
+          equality = Equality.fromStatement(statement, context);
 
     if (equality !== null) {
       const statementString = statement.getString();