occam-verify-cli 1.0.924 → 1.0.932

package/src/utilities/element.js

@@ -6,12 +6,12 @@ import { baseTypeFromNothing } from "../utilities/type";
 import { equivalenceStringFromTerms,
          typeStringFromNominalTypeName,
          rulsStringFromLabelsPremisesAndConclusion,
-         sectionStringFromHypothesesTopLevelAssertion,
          subproofStringFromSuppositionsAndSubDerivation,
+         sectionStringFromHypothesesAndTopLevelAssertion,
          procedureCallStringFromProcedureReferenceAndParameters,
-         topLevelAssertionStringFromLabelsSuppositionsAndDeduction,
          topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction,
-         complexTypeDeclarationStringFromTypeSuperTypesAndProvisional } from "../utilities/string";
+         complexTypeDeclarationStringFromTypeSuperTypesAndProvisional,
+         topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction } from "../utilities/string";
 
 export function typeFromTypeNode(typeNode, context) {
   let type;
@@ -46,11 +46,12 @@ export function termFromTermNode(termNode, context) {
         node = termNode,  ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        type = typeFromTermNode(termNode, context);
+        type = typeFromTermNode(termNode, context),
+        provisional = provisionalFromTermNode(termNode, context);
 
   context = null;
 
-  const term = new Term(context, string, node, lineIndex, type);
+  const term = new Term(context, string, node, lineIndex, type, provisional);
 
   return term;
 }
@@ -122,7 +123,7 @@ export function lemmaFromLemmaNode(lemmaNode, context) {
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction(labels, signature, suppositions, deduction),
         node = lemmaNode, ///
         string = topLevelAsssertionString, ///
         lineIndex = null;
@@ -172,7 +173,7 @@ export function axiomFromAxiomNode(axiomNode, context) {
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction(labels, signature, suppositions, deduction),
         node = axiomNode, ///
         string = topLevelAsssertionString, ///
         lineIndex = null;
@@ -185,20 +186,18 @@ export function axiomFromAxiomNode(axiomNode, context) {
 }
 
 export function sectionFromSectionNode(sectionNode, context) {
-  const hypothesisNodes = sectionNode.getHypothesisNodes(),
+  const { Section } = elements,
+        hypothesisNodes = sectionNode.getHypothesisNodes(),
         hypotheses = hypothesesFromHypothesisNodes(hypothesisNodes, context),
-        axiom = axiomFromSectionNode(sectionNode, context),
-        lemma = lemmaFromSectionNode(sectionNode, context),
-        theorem = theoremFromSectionNode(sectionNode, context),
-        conjecture = conjectureFromSectionNode(sectionNode, context),
-        sectionString = sectionStringFromHypothesesTopLevelAssertion(hypotheses, axiom, lemma, theorem, conjecture),
+        topLevelAssertion = topLevelAssertionFromSectionNode(sectionNode, context),
+        sectionString = sectionStringFromHypothesesAndTopLevelAssertion(hypotheses, topLevelAssertion),
         node = sectionNode, ///
         string = sectionString, ///
         lineIndex = null;
 
   context = null;
 
-  const section = new Section(context, string, node, lineIndex, hypotheses, axiom, lemma, theorem, conjecture);
+  const section = new Section(context, string, node, lineIndex, hypotheses, topLevelAssertion);
 
   return section;
 }
@@ -224,7 +223,7 @@ export function theoremFromTheoremNode(theoremNode, context) {
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction(labels, signature, suppositions, deduction),
         node = theoremNode, ///
         string = topLevelAsssertionString, ///
         lineIndex = null;
@@ -261,12 +260,12 @@ export function variableFromVariableNode(variableNode, context) {
         string = context.nodeAsString(node),
         lineIndex = null,
         type = typeFromVariableNode(variableNode, context),
-        identifier = identifierFromVarialbeNode(variableNode, context),
-        propertyRelations = propertyRelationsFromVariableNode(variableNode, context);
+        identifier = identifierFromVariableNode(variableNode, context),
+        provisional = provisionalFromVariableNode(variableNode, context);
 
   context = null;
 
-  const variable = new Variable(context, string, node, lineIndex, type, identifier, propertyRelations);
+  const variable = new Variable(context, string, node, lineIndex, type, identifier, provisional);
 
   return variable;
 }
@@ -400,7 +399,7 @@ export function parameterFromParameterNode(parameterNode, context) {
 }
 
 export function hypothesisFromHypothesisNode(hypotheseNode, context) {
-  const { Hypothsis } = elements,
+  const { Hypothesis } = elements,
         node = hypotheseNode, ///
         string = context.nodeAsString(node),
         lineIndex = null,
@@ -408,7 +407,7 @@ export function hypothesisFromHypothesisNode(hypotheseNode, context) {
 
   context = null;
 
-  const hypohtesis = new Hypothsis(context, string, node, lineIndex, statement);
+  const hypohtesis = new Hypothesis(context, string, node, lineIndex, statement);
 
   return hypohtesis;
 }
@@ -422,7 +421,7 @@ export function conjectureFromConjectureNode(conjectureNode, context) {
         suppositions = suppositionsFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         signature = signatureFromTopLevelAssertionNode(topLevelAsssertionNode, context),
         hypotheses = hypothesesFromTopLevelAssertionNode(topLevelAsssertionNode, context),
-        topLevelAsssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+        topLevelAsssertionString = topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction(labels, signature, suppositions, deduction),
         node = conjectureNode, ///
         string = topLevelAsssertionString, ///
         lineIndex = null;
@@ -1168,6 +1167,12 @@ export function provisionalFromTypeNode(typeNode, context) {
   return provisional;
 }
 
+export function provisionalFromTermNode(termNode, context) {
+  const provisional = null;
+
+  return provisional;
+}
+
 export function derivationFromProofNode(proofNode, context) {
   const derivationNode = proofNode.getDerivationNode(),
         derivation = derivationFromDerivationNode(derivationNode, context);
@@ -1322,9 +1327,9 @@ export function typeFromTypeAssertionNode(typeAssertionNode, context) {
   return type;
 }
 
-export function identifierFromVarialbeNode(variableNode, context) {
+export function identifierFromVariableNode(variableNode, context) {
   const variableIdentifier = variableNode.getVariableIdentifier(),
-        identifier = variableIdentifier;  ///
+    identifier = variableIdentifier;  ///
 
   return identifier;
 }
@@ -1379,6 +1384,12 @@ export function nominalTypeNameFromTypeNode(typeNode, context) {
   return nominalTypeName;
 }
 
+export function provisionalFromVariableNode(variableNode, context) {
+  const provisional = null;
+
+  return provisional;
+}
+
 export function assumptionFromJudgementNode(judgementNode, context) {
   const assumptionNode = judgementNode.getAssumptionNode(),
         assumption = assumptionFromAssumptionNode(assumptionNode, context);
@@ -1673,6 +1684,16 @@ export function typeFromVariableDeclarationNode(variableDeclarationNode, context
   return type;
 }
 
+export function topLevelAssertionFromSectionNode(sectionNode, context) {
+  const axiom = axiomFromSectionNode(sectionNode, context),
+        lemma = lemmaFromSectionNode(sectionNode, context),
+        theorem = theoremFromSectionNode(sectionNode, context),
+        conjecture = conjectureFromSectionNode(sectionNode, context),
+        topLevelAssertion = (axiom || lemma || theorem || conjecture);
+
+  return topLevelAssertion;
+}
+
 export function procedureCallFromSuppositionNode(suppositionNode, context) {
   let procedureCall = null;
 
@@ -1712,12 +1733,6 @@ export function typeFromBracketedConstructorNode(bracketedCcnstructorNode, conte
   return type;
 }
 
-export function propertyRelationsFromVariableNode(variableNode, context) {
-  const propertyRelations = [];
-
-  return propertyRelations;
-}
-
 export function definedAssertionFromStatementNode(statementNode, context) {
   let definedAssertion = null;
 

package/src/utilities/equivalences.js

@@ -97,7 +97,7 @@ function mergeEquivalence(equivalencesA, equivalenceB, context) {
     const equivalenceBDisjointFromEquivalenceA = equivalenceB.isDisjointFrom(equivalenceA);
 
     if (equivalenceBDisjointFromEquivalenceA) {
-      const mergedEquivalence = equivalenceB;  ///
+      const mergedEquivalence = equivalenceA;  ///
 
       mergedEquivalences.push(mergedEquivalence);
     } else {

package/src/utilities/string.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import { baseTypeFromNothing } from "../utilities/type";
-import { EMPTY_STRING, PROVISIONALLY } from "../constants";
+import { EMPTY_STRING, PROVISIONAL, PROVISIONALLY } from "../constants";
 
 export function termsStringFromTerms(terms) {
   const termsString = terms.reduce((termsString, term) => {
@@ -98,11 +98,19 @@ export function parametersStringFromParameters(parameters) {
 }
 
 export function provisinalStringFromProvisional(provisional) {
-  const provisionString = provisional ?
-                            PROVISIONALLY :
+  const provisinalString = provisional ?
+                            `${PROVISIONAL} ` :
                               EMPTY_STRING;
 
-  return provisionString;
+  return provisinalString;
+}
+
+export function provisionallyStringFromProvisional(provisional) {
+  const provisinallyString = provisional ?
+                              ` ${PROVISIONALLY}` :
+                                 EMPTY_STRING;
+
+  return provisinallyString;
 }
 
 export function suppositionsStringFromSuppositions(suppositions) {
@@ -119,13 +127,6 @@ export function suppositionsStringFromSuppositions(suppositions) {
   return suppositionsString;
 }
 
-export function signatureStringFromTerms(terms) {
-  const termsString = termsStringFromTerms(terms),
-        signatureString = `[${termsString}]`;
-
-  return signatureString;
-}
-
 export function equivalenceStringFromTerms(terms) {
   const termsString = termsStringFromTerms(terms),
         equivalenceString = `[${termsString}]`;
@@ -133,6 +134,14 @@ export function equivalenceStringFromTerms(terms) {
   return equivalenceString;
 }
 
+export function signatureStringFromSignature(signature) {
+  const signatureString = (signature !== null) ?
+                            signature.getString() :
+                              null;
+
+  return signatureString;
+}
+
 export function typeStringFromNominalTypeName(nominalTypeName) {
   const typeString = nominalTypeName;  ///
 
@@ -147,34 +156,20 @@ export function termSubstitutionStringFromTermAndVariable(term, variable) {
   return termSubstitutionString;
 }
 
-export function assumptionStringFromReferenceAndStatement(reference, statement) {
-  const referenceString = reference.getString(),
-        statementString = statement.getString(),
-        assumptionString = `${referenceString} :: ${statementString}`;
-
-  return assumptionString;
-}
-
 export function rulsStringFromLabelsPremisesAndConclusion(labels, premises, conclusion) {
+  let ruleString = EMPTY_STRING;
+
   const conclusionString = conclusion.getString(),
         premisesString = premisesStringFromPremises(premises),
-        labelsString = labelsStringFromLabels(labels),
-        ruleString = (premisesString !== null) ?
-                       `${labelsString} :: [${premisesString}]...${conclusionString}` :
-                         `${labelsString} :: ${conclusionString}`;
+        labelsString = labelsStringFromLabels(labels);
 
-  return ruleString;
-}
+  ruleString = `${ruleString}${labelsString} :: `;
 
-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}]::: `;
+  ruleString = (premisesString !== null) ?
+                 `${ruleString}[${premisesString}]...${conclusionString}` :
+                   `${ruleString}${conclusionString}`;
 
-  return sectionString;
+  return ruleString;
 }
 
 export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
@@ -194,6 +189,14 @@ export function frameSubstitutionStringFromFrameAndMetavariable(frame, metavaria
   return string;
 }
 
+export function sectionStringFromHypothesesAndTopLevelAssertion(hypotheses, topLevelAssertion) {
+  const topLevelAssertionString = topLevelAssertion.getString(),
+        hypothesesString = hypothesesStringFromHypotheses(hypotheses),
+        sectionString = `[${hypothesesString}]::: ${topLevelAssertionString}`;
+
+  return sectionString;
+}
+
 export function metaLevelAssumptionStringFromReferenceAndStatement(reference, statement) {
   const statementString = statement.getString(),
         referneceString = reference.getString(),
@@ -226,26 +229,6 @@ export function referenceSubstitutionStringFromReferenceAndMetavariable(referenc
   return referenceSubstitutionString;
 }
 
-export function topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction) {
-  let topLevelAssertionString;
-
-  const suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        deductionString = deduction.getString(),
-        labelsString = labelsStringFromLabels(labels);
-
-  if (labelsString !== null) {
-    topLevelAssertionString = (suppositionsString !== null) ?
-                               `${labelsString} :: [${suppositionsString}]...${deductionString}` :
-                                 `${labelsString} :: ${deductionString}`;
-  } else {
-    topLevelAssertionString = (suppositionsString !== null) ?
-                               `[${suppositionsString}]...${deductionString}` :
-                                  deductionString;
-  }
-
-  return topLevelAssertionString;
-}
-
 export function complexTypeDeclarationStringFromTypeSuperTypesAndProvisional(type, superTypes, provisional) {
   const typeString = type.getString(),
         superTypesString = superTypesStringFromSuperTypes(superTypes),
@@ -266,6 +249,29 @@ export function topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(lab
   return topLevelMetaAssertionString;
 }
 
+export function topLevelAssertionStringFromLabelsSignatureSuppositionsAndDeduction(labels, signature, suppositions, deduction) {
+  let topLevelAssertionString = EMPTY_STRING;
+
+  const deductionString = deduction.getString(),
+        labelsString = labelsStringFromLabels(labels),
+        signatureString = signatureStringFromSignature(signature),
+        suppositionsString = suppositionsStringFromSuppositions(suppositions);
+
+  topLevelAssertionString = (labelsString !== null) ?
+                              `${topLevelAssertionString}${labelsString} :: ` :
+                                `${topLevelAssertionString}`;
+
+  topLevelAssertionString = (signatureString !== null) ?
+                             `${topLevelAssertionString} ${signatureString}` :
+                               `${topLevelAssertionString}`;
+
+  topLevelAssertionString = (suppositionsString !== null) ?
+                             `${topLevelAssertionString}[${suppositionsString}]...${deductionString}` :
+                               `${topLevelAssertionString}${deductionString}`;
+
+  return topLevelAssertionString;
+}
+
 export function statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution) {
   const statementString = statement.getString(),
         metavariableString = metavariable.getString(),

package/src/utilities/substitutions.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 
 const { compress } = arrayUtilities;
 
-export function termFromTermAndSubstitutions(term, generalContext, specificContext) {
+export function termFromTermAndSubstitutions(term, context) {
   if (term !== null) {
     const termNode = term.getNode(),
           termSingular = term.isSingular();
@@ -13,11 +13,10 @@ export function termFromTermAndSubstitutions(term, generalContext, specificConte
 
     if (termSingular) {
       const variableNode = termNode.getVariableNode(),
-            substitution = specificContext.findSubstitutionByVariableNode(variableNode);
+            derivedSubstitution = context.findDerivedSubstitutionByVariableNode(variableNode);
 
-      if (substitution !== null) {
-        const termSubstitution = substitution,  ///
-              replacementTerm = termSubstitution.getReplacementTerm();
+      if (derivedSubstitution !== null) {
+        const replacementTerm = derivedSubstitution.getReplacementTerm();
 
         term = replacementTerm; ///
       }
@@ -27,7 +26,7 @@ export function termFromTermAndSubstitutions(term, generalContext, specificConte
   return term;
 }
 
-export function frameFromFrameAndSubstitutions(frame, generalContext, specificContext) {
+export function frameFromFrameAndSubstitutions(frame, context) {
   if (frame !== null) {
     const frameNode = frame.getNode(),
           frameSingular = frame.isSingular();
@@ -36,11 +35,10 @@ export function frameFromFrameAndSubstitutions(frame, generalContext, specificCo
 
     if (frameSingular) {
       const metavariableNode = frameNode.getMetavariableNode(),
-            substitution = specificContext.findSubstitutionByMetavariableNode(metavariableNode);
+            derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-      if (substitution !== null) {
-        const frameSubstitution = substitution, ///
-              replacementFrame = frameSubstitution.getReplacementFrame();
+      if (derivedSubstitution !== null) {
+        const replacementFrame = derivedSubstitution.getReplacementFrame();
 
         frame = replacementFrame; ///
       }
@@ -50,43 +48,19 @@ export function frameFromFrameAndSubstitutions(frame, generalContext, specificCo
   return frame;
 }
 
-export function statementFromStatementAndSubstitutions(statement, generalContext, specificContext) {
+export function statementFromStatementAndSubstitutions(statement, context) {
   if (statement !== null) {
     const statementNode = statement.getNode(),
           statementSingular = statement.isSingular();
 
-    statement = null;
+    statement = null;  ///
 
     if (statementSingular) {
-      let substitution = null;
+      const metavariableNode = statementNode.getMetavariableNode(),
+            derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-      const substitutionNode = statementNode.getSubstitutionNode();
-
-      if (substitutionNode !== null) {
-        let context = generalContext; ///
-
-        generalContext = specificContext; ///
-
-        specificContext = context;  ///
-
-        substitution = specificContext.findSubstitutionBySubstitutionNode(substitutionNode);
-
-        context = generalContext; ///
-
-        generalContext = specificContext; ///
-
-        specificContext = context;  ///
-      }
-
-      const metavariableNode = statementNode.getMetavariableNode();
-
-      substitution = (substitution !== null) ?
-                       specificContext.findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) :
-                         specificContext.findSubstitutionByMetavariableNode(metavariableNode);
-
-      if (substitution !== null) {
-        const statementSubstitution = substitution, ///
-              replacementStatement = statementSubstitution.getReplacementStatement();
+      if (derivedSubstitution !== null) {
+        const replacementStatement = derivedSubstitution.getReplacementStatement();
 
         statement = replacementStatement; ///
       }

package/src/utilities/unification.js

@@ -34,49 +34,6 @@ async function unifyStepWithRule(step, context) {
   return stepUnifiesWithRule;
 }
 
-async function unifyStepWithReference(step, context) {
-  let stepUnifiesWithReference = false;
-
-  const reference = step.getReference();
-
-  if (reference !== null) {
-    const stepString = step.getString(),
-          referenceString = reference.getString();
-
-    context.trace(`Unifying the '${stepString}' step with the '${referenceString}' reference...`);
-
-    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
-
-    if (topLevelAssertion !== null) {
-      const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
-            stepAndSubproofOrProofAssertionsUnify = await topLevelAssertion.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
-
-      if (stepAndSubproofOrProofAssertionsUnify) {
-        stepUnifiesWithReference = true;
-      }
-    } else {
-      const metaLevel = context.isMetaLevel();
-
-      if (metaLevel) {
-        descend((context) => {
-          const { MetaLevelAssumption } = elements,
-                metaLevelAssumption = MetaLevelAssumption.fromStep(step, context);
-
-          metaLevelAssumption.validate(context);
-
-          stepUnifiesWithReference = true;
-        }, context);
-      }
-    }
-
-    if (stepUnifiesWithReference) {
-      context.debug(`...unified the '${stepString}' step with the '${referenceString}' reference.`);
-    }
-  }
-
-  return stepUnifiesWithReference;
-}
-
 async function unifyStepWithTopLevelAssertion(step, context) {
   let stepUnifiesWithTopLevelAssertion = false;
 
@@ -86,20 +43,24 @@ async function unifyStepWithTopLevelAssertion(step, context) {
     const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
-      const stepString = step.getString(),
-            topLevelAssertionString = reference.getString();
+      const satisfiable = topLevelAssertion.isSatisfiable();
 
-      context.trace(`Unifying the '${stepString}' step with the '${topLevelAssertionString}' top level assertion...`);
+      if (!satisfiable) {
+        const stepString = step.getString(),
+              topLevelAssertionString = reference.getString();
 
-      const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
-            stepAndSubproofOrProofAssertionsUnify = await topLevelAssertion.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
+        context.trace(`Unifying the '${stepString}' step with the '${topLevelAssertionString}' top level assertion...`);
 
-      if (stepAndSubproofOrProofAssertionsUnify) {
-        stepUnifiesWithTopLevelAssertion = true;
-      }
+        const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
+              stepAndSubproofOrProofAssertionsUnify = await topLevelAssertion.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
 
-      if (stepUnifiesWithTopLevelAssertion) {
-        context.debug(`...unified the '${stepString}' step with the '${topLevelAssertionString}' top level assertion.`);
+        if (stepAndSubproofOrProofAssertionsUnify) {
+          stepUnifiesWithTopLevelAssertion = true;
+        }
+
+        if (stepUnifiesWithTopLevelAssertion) {
+          context.debug(`...unified the '${stepString}' step with the '${topLevelAssertionString}' top level assertion.`);
+        }
       }
     }
   }
@@ -263,8 +224,47 @@ async function unifyStepAsUnqualifiedSignatureAssertion(step, context) {
   return stepUnifiesAsUnqualifiedSignatureAssertion;
 }
 
-async function unifyStepAsSignatureAssertionWithReference(step, context) {
-  let stepUnifiesAsSignatureAssertionWithReference = false;
+async function validateStepAsMetaLevelAssumption(step, context) {
+  let stepValidatesAsMetaLevelAssumption = false;
+
+  const metaLevel = context.isMetaLevel();
+
+  if (metaLevel) {
+    const reference = step.getReference();
+
+    if (reference !== null) {
+      const stepString = step.getString(),
+            topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+
+      if (topLevelAssertion === null) {
+        context.trace(`Validating the '${stepString}' step as a meta-level assumption...`);
+
+        descend((context) => {
+          let metaLevelAssumption;
+
+          const { MetaLevelAssumption } = elements;
+
+          metaLevelAssumption = MetaLevelAssumption.fromStep(step, context);
+
+          metaLevelAssumption = metaLevelAssumption.validate(context);  ///
+
+          if (metaLevelAssumption !== null) {
+            stepValidatesAsMetaLevelAssumption = true;
+          }
+        }, context);
+
+        if (stepValidatesAsMetaLevelAssumption) {
+          context.debug(`...validated the '${stepString}' step as a meta-level assumption.`);
+        }
+      }
+    }
+  }
+
+  return stepValidatesAsMetaLevelAssumption;
+}
+
+async function unifyStepAsSignatureAssertion(step, context) {
+  let stepUnifiesAsSignatureAssertion = false;
 
   const reference = step.getReference();
 
@@ -285,17 +285,17 @@ async function unifyStepAsSignatureAssertionWithReference(step, context) {
         const unifyTopLevelAssertion = await signatureAssertion.unifyTopLevelAssertion(topLevelAssertion, context);
 
         if (unifyTopLevelAssertion) {
-          stepUnifiesAsSignatureAssertionWithReference = true;
+          stepUnifiesAsSignatureAssertion = true;
         }
 
-        if (stepUnifiesAsSignatureAssertionWithReference) {
+        if (stepUnifiesAsSignatureAssertion) {
           context.debug(`...unified the '${stepString}' step as a signature assertion with the '${referenceString}' reference.`);
         }
       }
     }
   }
 
-  return stepUnifiesAsSignatureAssertionWithReference;
+  return stepUnifiesAsSignatureAssertion;
 }
 
 async function compareStepWithSubproofOrProofAssertions(step, context) {
@@ -325,7 +325,6 @@ async function compareStepWithSubproofOrProofAssertions(step, context) {
 
 export const unifySteps = [
   unifyStepWithRule,
-  unifyStepWithReference,
   unifyStepWithTopLevelAssertion,
   unifyStepWithSignatureAssertion,
   unifyStepAsUnqualifiedEquality,
@@ -333,6 +332,7 @@ export const unifySteps = [
   unifyStepAsUnqualifiedTypeAssertion,
   unifyStepAsUnqualifiedPropertyAssertion,
   unifyStepAsUnqualifiedSignatureAssertion,
-  unifyStepAsSignatureAssertionWithReference,
+  validateStepAsMetaLevelAssumption,
+  unifyStepAsSignatureAssertion,
   compareStepWithSubproofOrProofAssertions
 ];

package/src/utilities/validation.js

@@ -3,6 +3,7 @@
 import elements from "../elements";
 
 import { choose, descend } from "./context";
+import { provisionallyStringFromProvisional } from "./string";
 import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 
 function validateTermAsVariable(term, context, validateForwards) {
@@ -23,12 +24,16 @@ function validateTermAsVariable(term, context, validateForwards) {
 
     if (variable !== null) {
       const type = variable.getType(),
-            typeString = type.getString();
+            typeString = type.getString(),
+            provisional = variable.isProvisional(),
+            provisionallyString = provisionallyStringFromProvisional(provisional);
 
-      context.trace(`Setting the '${termString}' term's type to the '${typeString}' type.`);
+      context.trace(`Setting the '${termString}' term's type to the '${typeString}' type${provisionallyString}.`);
 
       term.setType(type);
 
+      term.setProvisional(provisional);
+
       const validatesForwards = validateForwards(term);
 
       if (validatesForwards) {