occam-verify-cli 1.0.448 → 1.0.472

package/src/utilities/instance.js

@@ -2,7 +2,7 @@
 
 import nominalContext from "../context/nominal";
 
-import { getMetaTypes } from "../metaTypes";
+import { literally } from "../utilities/context";
 import { BASE_TYPE_SYMBOL } from "../constants";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { instantiateCombinator, instantiateConstructor } from "../process/instantiate";
@@ -13,18 +13,17 @@ let bracketedCombinator = null,
 
 export function bracketedCombinatorFromNothing() {
   if (bracketedCombinator === null) {
-    let context;
+    const context = nominalContext; ///
 
-    const string = `(${STATEMENT_META_TYPE_NAME})`;
+    bracketedCombinator = literally((context) => {
+      const bracketedCombinatorString = `(${STATEMENT_META_TYPE_NAME})`,
+            string = bracketedCombinatorString, ///
+            combinatorNode = instantiateCombinator(string, context),
+            bracketedCombinatorNode = combinatorNode,  ///
+            bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
 
-    context = nominalContext; ///
-
-    const combinatorNode = instantiateCombinator(string, context),
-          bracketedCombinatorNode = combinatorNode;  ///
-
-    context = contextFromString(string);
-
-    bracketedCombinator = combinatorFromCombinatorNode(bracketedCombinatorNode, context);
+      return bracketedCombinator;
+    }, context);
   }
 
   return bracketedCombinator;
@@ -32,40 +31,18 @@ export function bracketedCombinatorFromNothing() {
 
 export function bracketedConstructorFromNothing() {
   if (bracketedConstructor === null) {
-    let context;
-
-    const string = `(${BASE_TYPE_SYMBOL})`;
-
-    context = nominalContext; ///
-
-    const constructorNode = instantiateConstructor(string, context),
-          bracketedConstructorNode = constructorNode;  ///
+    const context = nominalContext; ///
 
-    context = contextFromString(string);
+    bracketedConstructor = literally((context) => {
+      const bracketedConstructorString = `(${BASE_TYPE_SYMBOL})`,
+            string = bracketedConstructorString,  ///
+            constructorNode = instantiateConstructor(string, context),
+            bracketedConstructorNode = constructorNode, ///
+            bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
 
-    bracketedConstructor = constructorFromConstructorNode(bracketedConstructorNode, context);
+      return bracketedConstructor;
+    }, context);
   }
 
   return bracketedConstructor;
 }
-
-function contextFromString(string) {
-  const context = {
-    nodeAsString: () => string,
-    getMetaTypes: () => getMetaTypes(),
-    findMetaTypeByMetaTypeName(metaTypeName) {
-      const metaTypes = this.getMetaTypes(),
-            metaType = metaTypes.find((metaType) => {
-              const metaTypeComparesToMetaTypeName = metaType.compareMetaTypeName(metaTypeName);
-
-              if (metaTypeComparesToMetaTypeName) {
-                return true;
-              }
-            }) || null;
-
-      return metaType;
-    }
-  };
-
-  return context;
-}

package/src/utilities/json.js

@@ -2,6 +2,8 @@
 
 import elements from "../elements";
 
+import { findMetaTypeByMetaTypeName } from "../metaTypes";
+
 export function termFromJSON(json, context) {
   let { term } = json;
 
@@ -42,7 +44,7 @@ export function metaTypeFromJSON(json, context) {
     const { name } = json,
           metaTypeName = name;  ///
 
-    metaType = context.findMetaTypeByMetaTypeName(metaTypeName);
+    metaType = findMetaTypeByMetaTypeName(metaTypeName);
   }
 
   return metaType;

package/src/utilities/string.js

@@ -44,7 +44,7 @@ export function premisesStringFromPremises(premises) {
   return premisesString;
 }
 
-export function hypothesesStringFromHypotheses(hypotheses, context) {
+export function hypothesesStringFromHypotheses(hypotheses) {
   const hypothesesString = hypotheses.reduce((hypothesesString, hypothesis) => {
     const hypothesisString = hypothesis.getString();
 
@@ -94,8 +94,8 @@ export function assumptionsStringFromAssumptions(assumptions) {
     const assumptionString = assumption.getString();
 
     assumptionsString = (assumptionsString === null) ?
-                          assumptionString :
-                            `${assumptionsString}, ${assumptionString}`;
+                          assumptionString: ///
+                           `${assumptionsString}, ${assumptionString}`;
 
     return assumptionsString;
   }, null);
@@ -145,6 +145,14 @@ export function equivalenceStringFromTerms(terms) {
   return equivalenceString;
 }
 
+export function termSubstitutionStringFromTermAndVariable(term, variable) {
+  const termString = term.getString(),
+        variableString = variable.getString(),
+        termSubstitutionString = `[${termString} for ${variableString}]`;
+
+  return termSubstitutionString;
+}
+
 export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
   const premisesString = premisesStringFromPremises(premises),
         conclusionString = conclusion.getString(),
@@ -156,6 +164,17 @@ export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conc
   return ruleString;
 }
 
+export function sectionStringFromHypothesesTopLevelAssertion(hypotheses, axiom, lemma, theorem, conjecture) {
+  const topLevelAssertion = (axiom || lemma || theorem || conjecture),
+        topLevelAssertionString = topLevelAssertion.getString(),
+        hypothesesString = hypothesesStringFromHypotheses(hypotheses),
+        sectionString = (topLevelAssertionString !== null) ?
+                          `[${hypothesesString}]::: ${topLevelAssertionString}` :
+                            `[${hypothesesString}]::: `;
+
+  return sectionString;
+}
+
 export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
   const lastProofAssertion = subDerivation.getLastProofAssertion(),
         suppositionsString = suppositionsStringFromSuppositions(suppositions),
@@ -165,6 +184,14 @@ export function subproofStringFromSuppositionsAndSubDerivation(suppositions, sub
   return subproofString;
 }
 
+export function frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable) {
+  const frameString = frame.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${frameString} for [${metavariableString}]]`;
+
+  return string;
+}
+
 export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
   let typeString;
 
@@ -189,44 +216,58 @@ export function procedureCallStringFromProcedureReferenceAndParameters(procedure
   return procedureCallString;
 }
 
-export function sectionStringFromHypothesesAxiomLemmaTheoremAndConjecture(hypotheses, axiom, lemma, theorem, conjecture, context) {
-  const axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture),
-        axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString(),
-        hypothesesString = hypothesesStringFromHypotheses(hypotheses, context),
-        sectionString = (axiomLemmaTheoremOrConjectureString !== null) ?
-                          `[${hypothesesString}]::: ${axiomLemmaTheoremOrConjectureString}` :
-                            `[${hypothesesString}]::: `;
+export function statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        statementSubstitutionString = `[${statementString} for ${metavariableString}]`;
 
-  return sectionString;
+  return statementSubstitutionString;
 }
 
-export function metaLemmaMetatheoremStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction) {
-  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        deductionString = deduction.getString(),
-        labelString = label.getString(),
-        metaLemmaMetatheoremString = (suppositionsString !== null) ?
-                                       `${labelString} :: [${suppositionsString}]...${deductionString}` :
-                                         `${labelString} :: ${deductionString}`;
+export function referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable) {
+  const referenceString = reference.getString(),
+        metavariableString = metavariable.getString(),
+        referenceSubstitutionString = `[${referenceString} for ${metavariableString}]`;
 
-  return metaLemmaMetatheoremString;
+  return referenceSubstitutionString;
 }
 
-export function axiomLemmaTheoremConjectureStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
-  let axiomLemmaTheoremConjectureString;
+export function topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
+  let topLevelAssertionString;
 
   const suppositionsString = suppositionsStringFromSuppositions(suppositions),
         deductionString = deduction.getString(),
         labelsString = labelsStringFromLabels(labels);
 
   if (labelsString !== null) {
-    axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?
-                                          `${labelsString} :: [${suppositionsString}]...${deductionString}` :
-                                            `${labelsString} :: ${deductionString}`;
+    topLevelAssertionString = (suppositionsString !== null) ?
+                               `${labelsString} :: [${suppositionsString}]...${deductionString}` :
+                                 `${labelsString} :: ${deductionString}`;
   } else {
-    axiomLemmaTheoremConjectureString = (suppositionsString !== null) ?
-                                         `[${suppositionsString}]...${deductionString}` :
-                                            deductionString;
+    topLevelAssertionString = (suppositionsString !== null) ?
+                               `[${suppositionsString}]...${deductionString}` :
+                                  deductionString;
   }
 
-  return axiomLemmaTheoremConjectureString;
+  return topLevelAssertionString;
+}
+
+export function topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction) {
+  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
+        deductionString = deduction.getString(),
+        labelString = label.getString(),
+        topLevelMetaAssertionString = (suppositionsString !== null) ?
+                                       `${labelString} :: [${suppositionsString}]...${deductionString}` :
+                                         `${labelString} :: ${deductionString}`;
+
+  return topLevelMetaAssertionString;
+}
+
+export function statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        substitutionString = substitution.getString(),
+        statementSubstitutionString = `[${statementString} for ${metavariableString}${substitutionString}]`;
+
+  return statementSubstitutionString;
 }

package/src/utilities/unification.js

@@ -4,6 +4,7 @@ import { arrayUtilities } from "necessary";
 
 import elements from "../elements";
 
+import { synthetically } from "../utilities/context";
 import { equalityFromStatement,
          judgementFromStatement,
          typeAssertionFromStatement,
@@ -12,7 +13,7 @@ import { equalityFromStatement,
 
 const { backwardsSome } = arrayUtilities;
 
-function unifyStatementWithRule(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementWithRule(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesWithRule = false;
 
   if (reference !== null) {
@@ -40,7 +41,7 @@ function unifyStatementWithRule(statement, reference, satisfiesAssertion, substi
   return statementUnifiesWithRule;
 }
 
-function unifyStatementWithReference(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementWithReference(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesWithReference = false;
 
   if (reference !== null) {
@@ -52,12 +53,14 @@ function unifyStatementWithReference(statement, reference, satisfiesAssertion, s
     const metavariableValidates = reference.validateMetavariable(context);
 
     if (metavariableValidates) {
-      const { StatementSubstitution } = elements,
-            metavariable = reference.getMetavariable(),
-            statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
-            substitution = statementSubstitution; ///
+      const metavariable = reference.getMetavariable();
 
-      substitutions.addSubstitution(substitution, context);
+      synthetically((context) => {
+        const { StatementSubstitution } = elements;
+
+        StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
+
+      }, generalContext, specificContext);
 
       statementUnifiesWithReference = true;
     }
@@ -70,7 +73,7 @@ function unifyStatementWithReference(statement, reference, satisfiesAssertion, s
   return statementUnifiesWithReference;
 }
 
-function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsSatisfiesAssertion = false;
 
   satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
@@ -96,9 +99,9 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
         }
       });
     } else {
-      const axiomLemmaTheoremOrConjecture = context.findAxiomLemmaTheoremOrConjectureByReference(reference);
+      const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
-      if (axiomLemmaTheoremOrConjecture !== null) {
+      if (topLevelAssertion !== null) {
         reference = satisfiesAssertion.getReference();
 
         const axiom = context.findAxiomByReference(reference);
@@ -108,10 +111,10 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
 
           if (satisfiable) {
             const { Substitutions } = elements,
-                  substitutions = Substitutions.fromNothing(),
-                  axiomLemmaTheoremOrConjectureUnifies = axiom.unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context);
+                  substitutions = Substitutions.fromNothing(context),
+                  topLevelAssertionUnifies = axiom.unifyTopLevelAssertion(topLevelAssertion, substitutions, context);
 
-            if (axiomLemmaTheoremOrConjectureUnifies) {
+            if (topLevelAssertionUnifies) {
               const substitutionsCorrelates = satisfiesAssertion.correlateSubstitutions(substitutions, context);
 
               if (substitutionsCorrelates) {
@@ -135,49 +138,49 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
   return statementUnifiesAsSatisfiesAssertion;
 }
 
-function unifyStatementWithAxiomLemmaTheoremOrConjecture(statement, reference, satisfiesAssertion, substitutions, context) {
-  let statementUnifiesWithAxiomLemmaTheoremOrConjecture = false;
+function unifyStatementWithTopLevelAssertion(statement, reference, satisfiesAssertion, context) {
+  let statementUnifiesWithTopLevelAssertion = false;
 
   if (reference !== null) {
     const { Substitutions } = elements,
-          axiomLemmaTheoremOrConjecture = context.findAxiomLemmaTheoremOrConjectureByReference(reference),
+          topLevelAssertion = context.findTopLevelAssertionByReference(reference),
           generalSubstitutions = substitutions; ///
 
-    if (axiomLemmaTheoremOrConjecture !== null) {
+    if (topLevelAssertion !== null) {
       const statementString = statement.getString(),
-            axiomLemmaTheoremOrConjectureString = reference.getString();
+            topLevelAssertionString = reference.getString();
 
-      context.trace(`Unifying the '${statementString}' statement with the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture...`);
+      context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion...`);
 
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
 
-      substitutions = Substitutions.fromNothing();
+      substitutions = Substitutions.fromNothing(context);
 
-      const statementAndSubproofOrProofAssertionsUnify = axiomLemmaTheoremOrConjecture.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context);
+      const statementAndSubproofOrProofAssertionsUnify = topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, substitutions, context);
 
       if (statementAndSubproofOrProofAssertionsUnify) {
-        const { StatementSubstitution } = elements,
-              metavariable = reference.getMetavariable(),
-              statementSubstitution = StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context),
-              substitution = statementSubstitution;  ///
+        const metavariable = reference.getMetavariable();
+
+        synthetically((context) => {
+          const { StatementSubstitution } = elements;
 
-        substitutions = generalSubstitutions; ///
+          StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
-        substitutions.addSubstitution(substitution, context);
+        }, generalContext, specificContext);
 
-        statementUnifiesWithAxiomLemmaTheoremOrConjecture = true;
+        statementUnifiesWithTopLevelAssertion = true;
       }
 
-      if (statementUnifiesWithAxiomLemmaTheoremOrConjecture) {
-        context.debug(`...unified the '${statementString}' statement with the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture.`);
+      if (statementUnifiesWithTopLevelAssertion) {
+        context.debug(`...unified the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion.`);
       }
     }
   }
 
-  return statementUnifiesWithAxiomLemmaTheoremOrConjecture;
+  return statementUnifiesWithTopLevelAssertion;
 }
 
-function unifyStatementAEquality(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementAEquality(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAEquality = false;
 
   if (reference === null) {
@@ -203,7 +206,7 @@ function unifyStatementAEquality(statement, reference, satisfiesAssertion, subst
   return statementUnifiesAEquality;
 }
 
-function unifyStatementAsJudgement(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementAsJudgement(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsJudgement = false;
 
   if (reference === null) {
@@ -225,7 +228,7 @@ function unifyStatementAsJudgement(statement, reference, satisfiesAssertion, sub
   return statementUnifiesAsJudgement;
 }
 
-function unifyStatementAsTypeAssertion(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementAsTypeAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsTypeAssertion = false;
 
   if (reference === null) {
@@ -245,7 +248,7 @@ function unifyStatementAsTypeAssertion(statement, reference, satisfiesAssertion,
   return statementUnifiesAsTypeAssertion;
 }
 
-function unifyStatementAsPropertyAssertion(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementAsPropertyAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsPropertyAssertion = false;
 
   if (reference === null) {
@@ -283,7 +286,7 @@ function unifyStatementAsPropertyAssertion(statement, reference, satisfiesAssert
   return statementUnifiesAsPropertyAssertion;
 }
 
-function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAssertion, substitutions, context) {
+function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesWithSatisfiesAssertion = false;
 
   if (satisfiesAssertion !== null) {
@@ -307,7 +310,7 @@ function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAss
   return statementUnifiesWithSatisfiesAssertion;
 }
 
-function compareStatementWithSubproofOrProofAssertions(statement, reference, satisfiesAssertion, substitutions, context) {
+function compareStatementWithSubproofOrProofAssertions(statement, reference, satisfiesAssertion, context) {
   let statementEquatesWithStepOrSubproofs = false;
 
   if (reference === null) {
@@ -334,7 +337,7 @@ export const unifyStatements = [
   unifyStatementWithRule,
   unifyStatementWithReference,
   unifyStatementAsSatisfiesAssertion,
-  unifyStatementWithAxiomLemmaTheoremOrConjecture,
+  unifyStatementWithTopLevelAssertion,
   unifyStatementAEquality,
   unifyStatementAsJudgement,
   unifyStatementAsTypeAssertion,