occam-verify-cli 1.0.852 → 1.0.857

package/src/element/metavariable.js

@@ -148,10 +148,9 @@ export default define(class Metavariable extends Element {
     let typeVerifies = true;  ///
 
     if (this.type !== null) {
-      const typeString = this.type.getString(),
-            metavariableString = this.getString();
+      const metavariableString = this.getString();
 
-      context.trace(`Verifying the '${metavariableString}' metavariable's '${typeString}' type...`);
+      context.trace(`Verifying the '${metavariableString}' metavariable's type...`);
 
       const typeName = this.type.getName(),
             type = context.findTypeByTypeName(typeName);
@@ -163,7 +162,7 @@ export default define(class Metavariable extends Element {
       }
 
       if (typeVerifies) {
-        context.debug(`...verifieds the '${metavariableString}' metavariable's '${typeString}' type.`);
+        context.debug(`...verifieds the '${metavariableString}' metavariable's type.`);
       }
     }
 
@@ -193,15 +192,15 @@ export default define(class Metavariable extends Element {
     } else {
       let validates = false;
 
-      const typeValidates = this.validateType(strict, context);
+      const nameValidates = this.validateName(strict, context);
 
-      if (typeValidates) {
+      if (nameValidates) {
         const termValidates = this.validateTerm(strict, context);
 
         if (termValidates) {
-          const nameValidates = this.validateName(strict, context);
+          const typeValidates = this.validateType(strict, context);
 
-          if (nameValidates) {
+          if (typeValidates) {
             validates = true;
           }
         }
@@ -223,38 +222,45 @@ export default define(class Metavariable extends Element {
     return metavariable;
   }
 
-  validateType(strict, context) {
-    let typeValidates = false;
+  validateName(strict, context) {
+    let nameValidates = true; ///
 
     const metavariableString = this.getString();  ///
 
-    context.trace(`Validating  the '${metavariableString}' metavariable's type...`);
+    context.trace(`Validating the '${metavariableString}' metavariable's name...`);
 
-    if (this.type === null) {
-      typeValidates = true;
-    } else {
-      const typeString = this.type.getString();
+    const metavariableName = this.getMetavariableName(),  ///
+          declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName);
 
-      context.trace(`A '${typeString}' type is present in the '${metavariableString}' metavariable.`);
+    if (declaredMetavariable !== null) {
+      const metaType = declaredMetavariable.getMetaType(),
+            metaTypeString = metaType.getString();
+
+      this.metaType = metaType;
+
+      context.trace(`Setting the '${metavariableString}' metavariable's meta-type to the '${metaTypeString}' meta-type.`);
+    } else {
+      if (strict) {
+        nameValidates = false;
+      }
     }
 
-    if (typeValidates) {
-      context.trace(`...validated  the '${metavariableString}' metavariable's type.`);
+    if (nameValidates) {
+      context.debug(`...validated the '${metavariableString}' metavariable's name.`);
     }
 
-    return typeValidates;
+    return nameValidates;
   }
 
   validateTerm(strict, context) {
-    let termValidates = true; ///
+    let termValidates = false;
 
-    if (this.term !== null) {
-      termValidates = false;
-
-      const termString = this.term.getString(),
-            metavariableString = this.getString();
+    if (this.term === null) {
+      termValidates = true;
+    } else {
+      const metavariableString = this.getString();
 
-      context.trace(`Validating the '${metavariableString}' metavariable's '${termString}' term...`);
+      context.trace(`Validating the '${metavariableString}' metavariable's term...`);
 
       const metavariableName = this.getMetavariableName(),
             declaredMetavaraible = context.findDeclaredMetavariableByMetavariableName(metavariableName);
@@ -284,41 +290,35 @@ export default define(class Metavariable extends Element {
       }
 
       if (termValidates) {
-        context.debug(`...validated the '${metavariableString}' metavariable's '${termString}' term.`);
+        context.debug(`...validated the '${metavariableString}' metavariable's term.`);
       }
     }
 
     return termValidates;
   }
 
-  validateName(strict, context) {
-    let nameValidates = true; ///
+  validateType(strict, context) {
+    let typeValidates;
 
-    const metavariableName = this.getMetavariableName(),  ///
-          metavariableString = this.getString();  ///
+    if (this.type === null) {
+      typeValidates = true;
+    } else {
+      const metavariableString = this.getString();  ///
 
-    context.trace(`Validating the '${metavariableString}' metavariable's '${metavariableName}' name...`);
+      context.trace(`Validating  the '${metavariableString}' metavariable's type...`);
 
-    const declaredMetavariable = context.findDeclaredMetavariableByMetavariableName(metavariableName);
+      typeValidates = false;
 
-    if (declaredMetavariable !== null) {
-      const metaType = declaredMetavariable.getMetaType(),
-            metaTypeString = metaType.getString();
+      const typeString = this.type.getString();
 
-      this.metaType = metaType;
+      context.trace(`A '${typeString}' type is present in the '${metavariableString}' metavariable.`);
 
-      context.trace(`Setting the '${metavariableString}' metavariable's meta-type to the '${metaTypeString}' meta-type.`);
-    } else {
-      if (strict) {
-        nameValidates = false;
+      if (typeValidates) {
+        context.trace(`...validated  the '${metavariableString}' metavariable's type.`);
       }
     }
 
-    if (nameValidates) {
-      context.debug(`...validated the '${metavariableString}' metavariable's '${metavariableName}' name.`);
-    }
-
-    return nameValidates;
+    return typeValidates;
   }
 
   unifyFrame(frame, generalContext, specificContext) {
@@ -337,16 +337,15 @@ export default define(class Metavariable extends Element {
       frameUnifies = true;
     } else {
       const metavariableNode = metavariable.getNode(),
-            substitution = context.findSubstitutionByMetavariableNode(metavariableNode);
+            derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-      if (substitution !== null) {
-        const substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
+      if (derivedSubstitution !== null) {
+        const derivedSubstitutionFrameComparesToFrame = derivedSubstitution.compareFrame(frame, context);
 
-        if (substitutionFrameComparesToFrame) {
-          const frameSubstitution = substitution, ///
-                frameSubstitutionString = frameSubstitution.getString();
+        if (derivedSubstitutionFrameComparesToFrame) {
+          const derivedSubstitutionString = derivedSubstitution.getString();
 
-          context.trace(`The '${frameSubstitutionString}' frame substitution is already present.`);
+          context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
 
           frameUnifies = true;
         }
@@ -386,22 +385,17 @@ export default define(class Metavariable extends Element {
       statementUnifies = true;
     } else {
       const metavariableNode = metavariable.getNode(),
-            substitutionPresent = (substitution !== null) ?
-                                    context.isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution) :
-                                      context.isSubstitutionPresentByMetavariableNode(metavariableNode);
-
-      if (substitutionPresent) {
-        substitution = (substitution !== null) ?
-                         context.findSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) :
-                           context.findSubstitutionByMetavariableNode(metavariableNode);
+            derivedSubstitution = (substitution !== null) ?
+                                   context.findDerivedSubstitutionByMetavariableNodeAndSubstitution(metavariableNode, substitution) :
+                                     context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-        const substitutionComparesToStatement = substitution.compareStatement(statement, context);
+      if (derivedSubstitution !== null) {
+        const derivedSubstitutionComparesToStatement = derivedSubstitution.compareStatement(statement, context);
 
-        if (substitutionComparesToStatement) {
-          const statementSubstitution = substitution, //
-                statementSubstitutionString = statementSubstitution.getString();
+        if (derivedSubstitutionComparesToStatement) {
+          const derivedSubstitutionString = derivedSubstitution.getString();
 
-          context.trace(`The '${statementSubstitutionString}' statement substitution is already present.`);
+          context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
 
           statementUnifies = true;
         }
@@ -440,16 +434,15 @@ export default define(class Metavariable extends Element {
       referenceUnifies = true;
     } else {
       const metavariableNode = metavariable.getNode(),
-            substitution = context.findSubstitutionByMetavariableNode(metavariableNode);
+            derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-      if (substitution !== null) {
-        const substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
+      if (derivedSubstitution !== null) {
+        const derivedSubstitutionReferenceComparesToReference = derivedSubstitution.compareReference(reference, context);
 
-        if (substitutionReferenceComparesToReference) {
-          const referenceSubstitution = substitution, ///
-                referenceSubstitutionString = referenceSubstitution.getString();
+        if (derivedSubstitutionReferenceComparesToReference) {
+          const derivedSubstitutionString = derivedSubstitution.getString();
 
-          context.trace(`The '${referenceSubstitutionString}' reference substitution is already present.`);
+          context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
 
           referenceUnifies = true;
         }

package/src/element/proofAssertion/premise.js

@@ -118,10 +118,9 @@ export default define(class Premise extends ProofAssertion {
   validateProcedureCall(context) {
     let procedureCallValidates = false;
 
-    const premiseString = this.getString(), ///
-          procedureCallString = this.procedureCall.getString();
+    const premiseString = this.getString(); ///
 
-    context.trace(`Validatting the '${premiseString}' premise's '${procedureCallString}' procedure call...`);
+    context.trace(`Validatting the '${premiseString}' premise's procedure call...`);
 
     const procedureCall = this.procedureCall.validate(context);
 
@@ -130,7 +129,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     if (procedureCallValidates) {
-      context.debug(`...validated the '${premiseString}' premise's '${procedureCallString}' procedure call.`);
+      context.debug(`...validated the '${premiseString}' premise's procedure call.`);
     }
 
     return procedureCallValidates;

package/src/element/reference.js

@@ -6,8 +6,8 @@ import { define } from "../elements";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
 import { referenceFromReferenceNode } from "../utilities/element";
-import { ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
 import { metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
+import { join, ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Reference extends Element {
   constructor(context, string, node, lineIndex, metavariable, topLevelMetaAssertion) {
@@ -106,7 +106,7 @@ export default define(class Reference extends Element {
     context.trace(`Comparing the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference...`);
 
     const label = topLevelMetaAssertion.getLabel(),
-          labelUnifies = this.unifyLabel(label);
+          labelUnifies = this.unifyLabel(label, context);
 
     if (labelUnifies) {
       topLevelMetaAssertionCompares = true;
@@ -155,7 +155,7 @@ export default define(class Reference extends Element {
 
           if (metaType === null) {
             const reference = this, ///
-                  labelPresent = context.isLabelPresentByReference(reference);
+                  labelPresent = context.isLabelPresentByReference(reference, context);
 
             if (labelPresent) {
               validates = true;
@@ -197,10 +197,9 @@ export default define(class Reference extends Element {
   validateMetavariable(context) {
     let metavariableValidates = false;
 
-    const referenceString = this.getString(), ///
-          metavariableString = this.metavariable.getString();
+    const referenceString = this.getString(); ///
 
-    context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable...'`);
+    context.trace(`Validating the '${referenceString}' reference's metavariable...'`);
 
     const metavariable = this.metavariable.validate(context);
 
@@ -211,30 +210,25 @@ export default define(class Reference extends Element {
     }
 
     if (metavariableValidates) {
-      context.debug(`...validated the '${referenceString}' reference's '${metavariableString}' metavariable.'`);
+      context.debug(`...validated the '${referenceString}' reference's metavariable.'`);
     }
 
     return metavariableValidates;
   }
 
-  unifyLabel(label) {
+  unifyLabel(label, context) {
     let labelUnifies = false;
 
-    let context;
-
     const labelString = label.getString(),
-          labelContext = label.getContext(),
           referenceString = this.getString(); ///
 
-    context = labelContext; ///
-
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    const specificContext = labelContext;  ///
+    const generalContext = context; ///
 
-    context = this.getContext();
+    context = label.getContext();
 
-    const generalContext = context; ///
+    const specificContext = context;  ///
 
     reconcile((specificContext) => {
       const metavariable = label.getMetavariable(),
@@ -293,18 +287,20 @@ export default define(class Reference extends Element {
 
     context = temporaryContext; ///
 
-    reconcile((specificContext) => {
-      const metavariable = label.getMetavariable(),
-            metavariableUnifies = this.unifyMetavariable(metavariable, generalContext, specificContext);
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const metavariable = label.getMetavariable(),
+              metavariableUnifies = this.unifyMetavariable(metavariable, generalContext, specificContext);
 
-      if (metavariableUnifies) {
-        this.topLevelMetaAssertion = topLevelMetaAssertion;
+        if (metavariableUnifies) {
+          this.topLevelMetaAssertion = topLevelMetaAssertion;
 
-        specificContext.commit(context);
+          specificContext.commit(context);
 
-        topLevelMetaAssertionUUnifies = true;
-      }
-    }, specificContext);
+          topLevelMetaAssertionUUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (topLevelMetaAssertionUUnifies) {
       context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);

package/src/element/rule.js

@@ -253,9 +253,9 @@ export default define(class Rule extends Element {
       const subproofOrProofAssertionsUnifiesWithPremises = await this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
 
       if (subproofOrProofAssertionsUnifiesWithPremises) {
-        const substitutionsResolved = context.areSubstitutionsResolved();
+        const derivedSubstitutionsResolved = context.areDerivedSubstitutionsResolved();
 
-        if (substitutionsResolved) {
+        if (derivedSubstitutionsResolved) {
           stepAndSubproofOrProofAssertionsUnify = true;
         }
       }
@@ -274,7 +274,7 @@ export default define(class Rule extends Element {
         const subproofOrProofAssertionUnifies = await premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
-          context.resolveSubstitutions();
+          context.resolveDerivedSubstitutions();
 
           return true;
         }

package/src/element/substitution/frame.js

@@ -127,10 +127,9 @@ export default define(class FrameSubstitution extends Substitution {
     let targetFrameValidates = false;
 
     const context = generalContext,  ///
-          targetFrameString = this.targetFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame...`);
+    context.trace(`Validating the '${frameSubstitutionString}' frame substitution's target frame...`);
 
     const targetFrameSingular = this.targetFrame.isSingular();
 
@@ -145,11 +144,13 @@ export default define(class FrameSubstitution extends Substitution {
         }
       }, context);
     } else {
-      context.debug(`The '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame is not singular.`);
+      const targetFrameString = this.targetFrame.getString();
+
+      context.debug(`The '${targetFrameString}' target frame is not singular.`);
     }
 
     if (targetFrameValidates) {
-      context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame...`);
+      context.debug(`...validated the frame substitution's target frame...`);
     }
 
     return targetFrameValidates;
@@ -159,10 +160,9 @@ export default define(class FrameSubstitution extends Substitution {
     let replacementFrameValidates = false;
 
     const context = specificContext,  ///
-          replacementFrameString = this.replacementFrame.getString(),
           frameSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame...`);
+    context.trace(`Validating the '${frameSubstitutionString}' frame substitution's replacement frame...`);
 
     descend((context) => {
       const replacementFrame = this.replacementFrame.validate(context);
@@ -175,7 +175,7 @@ export default define(class FrameSubstitution extends Substitution {
     }, context);
 
     if (replacementFrameValidates) {
-      context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame.`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame substitution's replacement frame.`);
     }
 
     return replacementFrameValidates;

package/src/element/substitution/reference.js

@@ -144,10 +144,9 @@ export default define(class ReferenceSubstitution extends Substitution {
     let targetReferenceValidates = false;
 
     const context = generalContext, ///
-          targetReferenceString = this.targetReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
+    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's target reference...`);
 
     descend((context) => {
       const targetReference = this.targetReference.validate(context);
@@ -158,7 +157,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     }, context);
 
     if (targetReferenceValidates) {
-      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
+      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's target reference...`);
     }
 
     return targetReferenceValidates;
@@ -168,10 +167,9 @@ export default define(class ReferenceSubstitution extends Substitution {
     let replacementReferenceValidates = false;
 
     const context = specificContext,  ///
-          replacementReferenceString = this.replacementReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference...`);
+    context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's replacement reference...`);
 
     descend((context) => {
       const replacementReference = this.replacementReference.validate(context);
@@ -182,7 +180,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     }, context);
 
     if (replacementReferenceValidates) {
-      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference.`);
+      context.debug(`...validated the '${referenceSubstitutionString}' reference substitution's replacement reference.`);
     }
 
     return replacementReferenceValidates;

package/src/element/substitution/statement.js

@@ -163,17 +163,16 @@ export default define(class StatementSubstitution extends Substitution {
 
     if (substitution !== null) {
       const context = generalContext,  ///
-            substitutionString = this.substitution.getString(),
             statementSubstitutionString = this.getString();
 
-      context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution...`);
+      context.trace(`Validating the '${statementSubstitutionString}' statement substitution's substitution...`);
 
       this.substitution = substitution;
 
       substitutionValidates = true;
 
       if (substitutionValidates) {
-        context.debug(`...validatewd the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution.`);
+        context.debug(`...validatewd the '${statementSubstitutionString}' statement substitution's substitution.`);
       }
     }
 
@@ -184,10 +183,9 @@ export default define(class StatementSubstitution extends Substitution {
     let targetStatementValidates = false;
 
     const context = generalContext,  ///
-          targetStatementString = this.targetStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement...`);
+    context.trace(`Validating the '${statementSubstitutionString}' statement substitution's target statement...`);
 
     const targetStatementSingular = this.targetStatement.isSingular();
 
@@ -200,11 +198,13 @@ export default define(class StatementSubstitution extends Substitution {
         }
       }, context);
     } else {
-      context.debug(`The '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement is not singular.`);
+      const targetStatementString = this.targetStatement.getString();
+
+      context.debug(`The '${targetStatementString}' target statement is not singular.`);
     }
 
     if (targetStatementValidates) {
-      context.debug(`...validated the '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement...`);
+      context.debug(`...validated the '${statementSubstitutionString}' statement substitution's target statement...`);
     }
 
     return targetStatementValidates;
@@ -214,10 +214,9 @@ export default define(class StatementSubstitution extends Substitution {
     let replacementStatementValidates = false;
 
     const context = specificContext,  ///
-          replacementStatementString = this.replacementStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement...`);
+    context.trace(`Validating the '${statementSubstitutionString}' statement substitution's replacement statement...`);
 
     descend((context) => {
       const replacementStatement = this.replacementStatement.validate(context);
@@ -228,7 +227,7 @@ export default define(class StatementSubstitution extends Substitution {
     }, context);
 
     if (replacementStatementValidates) {
-      context.debug(`...validated the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement.`);
+      context.debug(`...validated the '${statementSubstitutionString}' statement substitution's replacement statement.`);
     }
 
     return replacementStatementValidates;

package/src/element/substitution/term.js

@@ -130,10 +130,9 @@ export default define(class TermSubstitution extends Substitution {
     let targetTermValidates = false;
 
     const context = generalContext, ///
-          targetTermString = this.targetTerm.getString(),
           termSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${termSubstitutionString}' term substitution's '${targetTermString}' target term...`);
+    context.trace(`Validating the '${termSubstitutionString}' term substitution's target term...`);
 
     const targetTermSingular = this.targetTerm.isSingular();
 
@@ -152,11 +151,13 @@ export default define(class TermSubstitution extends Substitution {
         }
       }, context);
     } else {
-      context.debug(`The '${termSubstitutionString}' term substitution's '${targetTermString}' target term is not singular.`);
+      const targetTermString = this.targetTerm.getString();
+
+      context.debug(`The '${targetTermString}' target term is not singular.`);
     }
 
     if (targetTermValidates) {
-      context.debug(`...validated the '${termSubstitutionString}' term substitution's '${targetTermString}' target term...`);
+      context.debug(`...validated the '${termSubstitutionString}' term substitution's target term...`);
     }
 
     return targetTermValidates;
@@ -166,10 +167,9 @@ export default define(class TermSubstitution extends Substitution {
     let replacementTermValidates = false;
 
     const context = specificContext,  ///
-          replacementTermString = this.replacementTerm.getString(),
           termSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${termSubstitutionString}' term substitution's '${replacementTermString}' replacement term...`);
+    context.trace(`Validating the '${termSubstitutionString}' term substitution's replacement term...`);
 
     descend((context) => {
       const replacementTerm = this.replacementTerm.validate(context, (replacementTerm) => {
@@ -186,7 +186,7 @@ export default define(class TermSubstitution extends Substitution {
     }, context);
 
     if (replacementTermValidates) {
-      context.debug(`...validated the '${termSubstitutionString}' term substitution's '${replacementTermString}' replacement term...`);
+      context.debug(`...validated the '${termSubstitutionString}' term substitution's replacement term...`);
     }
 
     return replacementTermValidates;

package/src/element/topLevelAssertion.js

@@ -315,9 +315,9 @@ export default class TopLevelAssertion extends Element {
         const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
 
         if (subproofOrProofAssertionsUnifiesWithSuppositions) {
-          const substitutionsResolved = context.areSubstitutionsResolved();
+          const derivedSubstitutionsResolved = context.areDerivedSubstitutionsResolved();
 
-          if (substitutionsResolved) {
+          if (derivedSubstitutionsResolved) {
             stepAndSubproofOrProofAssertionsUnify = true;
           }
         }
@@ -337,7 +337,7 @@ export default class TopLevelAssertion extends Element {
         const subproofOrProofAssertionUnifies = await supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
-          context.resolveSubstitutions();
+          context.resolveDerivedSubstitutions();
 
           return true;
         }

package/src/element/topLevelMetaAssertion.js

@@ -3,7 +3,7 @@
 import { Element, asynchronousUtilities } from "occam-languages";
 
 import { enclose } from "../utilities/context";
-import { topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions } from "../utilities/string";
+import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
@@ -259,7 +259,7 @@ export default class TopLevelMetaAssertion extends Element {
           metaLevelAssumptions = metaLevelAssumptionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions),
+          string = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
           topLevelMetaAssertion = new Class(context, string, node, lineIndex, label, suppositions, deduction, proof, metaLevelAssumptions);
 
     return topLevelMetaAssertion;