occam-verify-cli 1.0.72 → 1.0.75

package/src/dom/proof.js

@@ -17,12 +17,12 @@ export default domAssigned(class Proof {
     return this.derivation;
   }
 
-  getLastProofStep() { return this.derivation.getLastProofStep(); }
+  getLastStep() { return this.derivation.getLastStep(); }
 
   getStatement() {
-    const lastProofStep = this.getLastProofStep(),
-          lastProofStepStatement = lastProofStep.getStatement(),
-          statement = lastProofStepStatement; ///
+    const lastStep = this.getLastStep(),
+          lastStepStatement = lastStep.getStatement(),
+          statement = lastStepStatement; ///
 
     return statement;
   }
@@ -37,9 +37,9 @@ export default domAssigned(class Proof {
     const derivationVerified = this.derivation.verify(substitutions, context);
 
     if (derivationVerified) {
-      const lastProofStep = context.getLastProofStep();
+      const lastStep = context.getLastStep();
 
-      if (lastProofStep !== null) {
+      if (lastStep !== null) {
         const statement = this.getStatement(),
               conclusionStatement = conclusion.getStatement(),
               conclusionStatementEqualToStatement = conclusionStatement.isEqualTo(statement);

package/src/dom/reference.js

@@ -10,7 +10,7 @@ import { referenceMetaType } from "../dom/metaType";
 import { unifyMetavariableIntrinsically } from "../utilities/unification";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-const proofStepReferenceNodeQuery = nodeQuery("/proofStep/reference"),
+const stepReferenceNodeQuery = nodeQuery("/step/reference"),
       procedureCallReferenceNodeQuery = nodeQuery("/procedureCall/reference"),
       declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable"),
       satisfyingAssertionMetavariableNodeQuery = nodeQuery("/satisfyingAssertion/metavariable");
@@ -186,13 +186,13 @@ export default domAssigned(class Reference {
     return reference;
   }
 
-  static fromProofStepNode(proofStepNode, fileContext) {
+  static fromStepNode(stepNode, fileContext) {
     let reference = null;
 
-    const proofStepReferenceNode = proofStepReferenceNodeQuery(proofStepNode);
+    const stepReferenceNode = stepReferenceNodeQuery(stepNode);
 
-    if (proofStepReferenceNode !== null) {
-      const referenceNode = proofStepReferenceNode; ///
+    if (stepReferenceNode !== null) {
+      const referenceNode = stepReferenceNode; ///
 
       reference = referenceFromReferenceNode(referenceNode, fileContext);
     }

package/src/dom/rule.js

@@ -69,8 +69,8 @@ export default domAssigned(class Rule {
     return metavariableNameMatches;
   }
 
-  unifyStatementAndProofStepSubproofs(statement, proofStepSubproofs, context) {
-    let statementAndProofStepSubproofsUnified = false;
+  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, context) {
+    let statementAndStepsOrSubproofsUnified = false;
 
     const localContext = LocalContext.fromFileContext(this.fileContext),
           generalContext = localContext, ///
@@ -80,16 +80,16 @@ export default domAssigned(class Rule {
           statementUnifiedWithConclusion = this.unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifiedWithConclusion) {
-      const proofStepSubproofsUnifiedWithPremises = this.unifyProofStepSubproofsWithPremises(proofStepSubproofs, substitutions, generalContext, specificContext);
+      const stepsOrSubproofsUnifiedWithPremises = this.unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, generalContext, specificContext);
 
-      if (proofStepSubproofsUnifiedWithPremises) {
+      if (stepsOrSubproofsUnifiedWithPremises) {
         const substitutionsResolved = substitutions.areResolved();
 
-        statementAndProofStepSubproofsUnified = substitutionsResolved; ///
+        statementAndStepsOrSubproofsUnified = substitutionsResolved; ///
       }
     }
 
-    return statementAndProofStepSubproofsUnified;
+    return statementAndStepsOrSubproofsUnified;
   }
 
   unifyStatementWithConclusion(statement, substitutions, generalContext, specificContext) {
@@ -102,43 +102,43 @@ export default domAssigned(class Rule {
     return statementUnifiedWithConclusion;
   }
 
-  unifyProofStepSubproofsWithPremises(proofStepSubproofs, substitutions, generalContext, specificContext) {
-    proofStepSubproofs = reverse(proofStepSubproofs); ///
+  unifyStepsOrSubproofsWithPremises(stepsOrSubproofs, substitutions, generalContext, specificContext) {
+    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
 
-    const proofStepSubproofsUnifiedWithPremises = backwardsEvery(this.premises, (premise) => {
-      const proofStepUnifiedWithPremise = this.unifyProofStepSubproofsWithPremise(proofStepSubproofs, premise, substitutions, generalContext, specificContext);
+    const stepsOrSubproofsUnifiedWithPremises = backwardsEvery(this.premises, (premise) => {
+      const stepUnifiedWithPremise = this.unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, generalContext, specificContext);
 
-      if (proofStepUnifiedWithPremise) {
+      if (stepUnifiedWithPremise) {
         return true;
       }
     });
 
-    return proofStepSubproofsUnifiedWithPremises;
+    return stepsOrSubproofsUnifiedWithPremises;
   }
 
-  unifyProofStepSubproofsWithPremise(proofStepSubproofs, premise, substitutions, generalContext, specificContext) {
-    let proofStepSubproofsUnifiedWithPremise  =false;
+  unifyStepsOrSubproofsWithPremise(stepsOrSubproofs, premise, substitutions, generalContext, specificContext) {
+    let stepsOrSubproofsUnifiedWithPremise  =false;
 
     const context = specificContext,  ///
           premiseUnifiedIndependently = premise.unifyIndependently(substitutions, context);
 
     if (premiseUnifiedIndependently) {
-      proofStepSubproofsUnifiedWithPremise = true;
+      stepsOrSubproofsUnifiedWithPremise = true;
     } else {
-      const proofStep = extract(proofStepSubproofs, (proofStepSubproof) => {
-        const proofStepSubproofUnified = premise.unifyProofStepSubproof(proofStepSubproof, substitutions, generalContext, specificContext);
+      const step = extract(stepsOrSubproofs, (stepOrSubproof) => {
+        const stepOrSubproofUnified = premise.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
 
-        if (proofStepSubproofUnified) {
+        if (stepOrSubproofUnified) {
           return true;
         }
       }) || null;
 
-      if (proofStep !== null) {
-        proofStepSubproofsUnifiedWithPremise = true;
+      if (step !== null) {
+        stepsOrSubproofsUnifiedWithPremise = true;
       }
     }
 
-    return proofStepSubproofsUnifiedWithPremise;
+    return stepsOrSubproofsUnifiedWithPremise;
   }
 
   verify() {

package/src/dom/statement.js

@@ -15,10 +15,10 @@ import { definedAssertionFromStatement, containedAssertionFromStatement, subproo
 
 const { match, backwardsSome } = arrayUtilities;
 
-const statementTermNodesQuery = nodesQuery("/statement//term"),
+const stepStatementNodeQuery = nodeQuery("/step/statement"),
+      statementTermNodesQuery = nodesQuery("/statement//term"),
       statementFrameNodesQuery = nodesQuery("/statement//frame"),
       premiseStatementNodeQuery = nodeQuery("/premise/statement"),
-      proofStepStatementNodeQuery = nodeQuery("/proofStep/statement"),
       deductionStatementNodeQuery = nodeQuery("/deduction/statement"),
       conclusionStatementNodeQuery = nodeQuery("/conclusion/statement"),
       suppositionStatementNodeQuery = nodeQuery("/supposition/statement"),
@@ -233,19 +233,19 @@ export default domAssigned(class Statement {
     return unifiedIndependently;
   }
 
-  unifyWithProofStepSubproofs(proofStepSubproofs, context) {
-    let unifiedWithProofSteps;
+  unifyWithStepsOrSubproofs(stepsOrSubproofs, context) {
+    let unifiedWithSteps;
 
-    unifiedWithProofSteps = backwardsSome(proofStepSubproofs, (proofStepSubproof) => {
+    unifiedWithSteps = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
       const statement = this, ///
-            statementUnified =proofStepSubproof.unifyStatement(statement, context);
+            statementUnified =stepOrSubproof.unifyStatement(statement, context);
 
       if (statementUnified) {
         return true;
       }
     });
 
-    return unifiedWithProofSteps;
+    return unifiedWithSteps;
   }
 
   toJSON() {
@@ -287,13 +287,13 @@ export default domAssigned(class Statement {
     return statement;
   }
 
-  static fromProofStepNode(proofStepNode, fileContext) {
+  static fromStepNode(stepNode, fileContext) {
     let statement = null;
 
-    const proofStepStatementNode = proofStepStatementNodeQuery(proofStepNode);
+    const stepStatementNode = stepStatementNodeQuery(stepNode);
 
-    if (proofStepStatementNode !== null) {
-      const statementNode = proofStepStatementNode; ///
+    if (stepStatementNode !== null) {
+      const statementNode = stepStatementNode; ///
 
       statement = statementFromStatementNode(statementNode, fileContext);
     }

package/src/dom/{proofStep.js → step.js}

@@ -1,16 +1,16 @@
 "use strict";
 
 import dom from "../dom";
-import unifyMixins from "../mixins/proofStep/unify";
+import unifyMixins from "../mixins/step/unify";
 import Substitutions from "../substitutions";
 
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { propertyAssertionFromStatement } from "../utilities/context";
 
-const proofStepNodeQuery = nodeQuery("/proofStep");
+const stepNodeQuery = nodeQuery("/step");
 
-export default domAssigned(class ProofStep {
+export default domAssigned(class Step {
   constructor(string, statement, reference) {
     this.string = string;
     this.statement = statement;
@@ -35,10 +35,10 @@ export default domAssigned(class ProofStep {
     return qualified;
   }
 
-  isProofStep() {
-    const proofStep = true;
+  isStep() {
+    const step = true;
 
-    return proofStep;
+    return step;
   }
 
   matchTermAndPropertyRelation(term, propertyRelation, context) {
@@ -56,9 +56,9 @@ export default domAssigned(class ProofStep {
   unify(substitutions, context) {
     let unified;
 
-    const proofStepString = this.string;  ///
+    const stepString = this.string;  ///
 
-    context.trace(`Unifying the '${proofStepString}' proof step...`);
+    context.trace(`Unifying the '${stepString}' step...`);
 
     unified = unifyMixins.some((unifyMixin) => {
       const unified = unifyMixin(this.statement, this.reference, substitutions, context);
@@ -69,7 +69,7 @@ export default domAssigned(class ProofStep {
     });
 
     if (unified) {
-      context.debug(`...unified the '${proofStepString}' proof step.`);
+      context.debug(`...unified the '${stepString}' step.`);
     }
 
     return unified;
@@ -78,9 +78,9 @@ export default domAssigned(class ProofStep {
   verify(substitutions, assignments, context) {
     let verified = false;
 
-    const proofStepString = this.string;
+    const stepString = this.string;
 
-    context.trace(`Verifying the '${proofStepString}' proof step...`);
+    context.trace(`Verifying the '${stepString}' step...`);
 
     if (this.statement !== null) {
       const qualified = this.isQualified(),
@@ -97,11 +97,11 @@ export default domAssigned(class ProofStep {
         }
       }
     } else {
-      context.debug(`Cannot verify the '${proofStepString}' proof step because it is nonsense.`);
+      context.debug(`Cannot verify the '${stepString}' step because it is nonsense.`);
     }
 
     if (verified) {
-      context.debug(`...verified the '${proofStepString}' proof step.`);
+      context.debug(`...verified the '${stepString}' step.`);
     }
 
     return verified;
@@ -126,32 +126,32 @@ export default domAssigned(class ProofStep {
     return statementUnified;
   }
 
-  static name = "ProofStep";
+  static name = "Step";
 
   static fromStatement(statement, context) {
     const statementString = statement.getString(),
           string = statementString, ///
           reference = null,
-          proofStep = new ProofStep(string, statement, reference);
+          step = new Step(string, statement, reference);
 
-    return proofStep;
+    return step;
   }
 
-  static fromProofStepSubproofNode(proofStepSubproofNode, fileContext) {
-    let proofStep = null;
+  static fromStepOrSubproofNode(stepOrSubproofNode, fileContext) {
+    let step = null;
 
-    const proofStepNode = proofStepNodeQuery(proofStepSubproofNode);
+    const stepNode = stepNodeQuery(stepOrSubproofNode);
 
-    if (proofStepNode !== null) {
+    if (stepNode !== null) {
       const { Statement, Reference } = dom,
-            node = proofStepNode, ///
+            node = stepNode, ///
             string = fileContext.nodeAsString(node),
-            statement = Statement.fromProofStepNode(proofStepNode, fileContext),
-            reference = Reference.fromProofStepNode(proofStepNode, fileContext);
+            statement = Statement.fromStepNode(stepNode, fileContext),
+            reference = Reference.fromStepNode(stepNode, fileContext);
 
-      proofStep = new ProofStep(string, statement, reference);
+      step = new Step(string, statement, reference);
     }
 
-    return proofStep;
+    return step;
   }
 });

package/src/dom/subDerivation.js

@@ -10,39 +10,39 @@ import { assignAssignments } from "../utilities/assignments";
 
 const { last } = arrayUtilities;
 
-const proofStepSubproofNodesQuery = nodesQuery("/subDerivation/proofStep|subproof");
+const stepOrSubproofNodesQuery = nodesQuery("/subDerivation/step|subproof");
 
 export default domAssigned(class SubDerivation {
-  constructor(proofStepSubproofs) {
-    this.proofStepSubproofs = proofStepSubproofs;
+  constructor(stepsOrSubproofs) {
+    this.stepsOrSubproofs = stepsOrSubproofs;
   }
 
-  getProofStepSubproofs() {
-    return this.proofStepSubproofs;
+  getStepsOrSubproofs() {
+    return this.stepsOrSubproofs;
   }
 
-  getLastProofStep() {
-    const lastProofStepSubproof = last(this.proofStepSubproofs),
-          lastProofStep = lastProofStepSubproof;  ///
+  getLastStep() {
+    const lastStepOrSubproof = last(this.stepsOrSubproofs),
+          lastStep = lastStepOrSubproof;  ///
 
-    return lastProofStep;
+    return lastStep;
   }
 
   verify(substitutions, context) {
     let verified;
 
-    verified = this.proofStepSubproofs.every((proofStepSubproof) => { ///
+    verified = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
       const assignments = [],
-            proofStepSubproofVerified = proofStepSubproof.verify(substitutions, assignments, context);
+            stepOrSubproofVerified = stepOrSubproof.verify(substitutions, assignments, context);
 
-      if (proofStepSubproofVerified) {
-        const proofStepSubproofUnified = proofStepSubproof.unify(substitutions, context);
+      if (stepOrSubproofVerified) {
+        const stepOrSubproofUnified = stepOrSubproof.unify(substitutions, context);
 
-        if (proofStepSubproofUnified) {
+        if (stepOrSubproofUnified) {
           const assignmentsAssigned = assignAssignments(assignments, context);
 
           if (assignmentsAssigned) {
-            context.addProofStepSubproof(proofStepSubproof);
+            context.addStepOrSubproof(stepOrSubproof);
 
             return true;
           }
@@ -56,23 +56,23 @@ export default domAssigned(class SubDerivation {
   static name = "SubDerivation";
 
   static fromSubDerivationNode(subDerivationNode, fileContext) {
-    const proofStepSubproofs = proofStepSubproofFromSubDerivationNode(subDerivationNode, fileContext),
-          subDerivation = new SubDerivation(proofStepSubproofs);
+    const stepsOrSubproofs = stepOrSubproofFromSubDerivationNode(subDerivationNode, fileContext),
+          subDerivation = new SubDerivation(stepsOrSubproofs);
 
     return subDerivation;
   }
 });
 
-function proofStepSubproofFromSubDerivationNode(subDerivationNode, fileContext) {
-  const { ProofStep, Subproof } = dom,
-        proofStepSubproofNodes = proofStepSubproofNodesQuery(subDerivationNode),
-        proofStepSubproofs = proofStepSubproofNodes.map((proofStepSubproofNode) => {
-          const subproof = Subproof.fromProofStepSubproofNode(proofStepSubproofNode, fileContext),
-                proofStep = ProofStep.fromProofStepSubproofNode(proofStepSubproofNode, fileContext),
-                proofStepSubproof = (proofStep || subproof);
+function stepOrSubproofFromSubDerivationNode(subDerivationNode, fileContext) {
+  const { Step, Subproof } = dom,
+        stepOrSubproofNodes = stepOrSubproofNodesQuery(subDerivationNode),
+        stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
+          const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
+                step = Step.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
+                stepOrSubproof = (step || subproof);
 
-          return proofStepSubproof;
+          return stepOrSubproof;
         });
 
-  return proofStepSubproofs;
+  return stepsOrSubproofs;
 }

package/src/dom/subproof.js

@@ -35,28 +35,28 @@ export default domAssigned(class Subproof {
     return this.subDerivation;
   }
 
-  getLastProofStep() { return this.subDerivation.getLastProofStep(); }
+  getLastStep() { return this.subDerivation.getLastStep(); }
 
   getStatements() {
-    const lastProofStep = this.getLastProofStep(),
+    const lastStep = this.getLastStep(),
           suppositionStatements = this.suppositions.map((supposition) => {
             const suppositionStatement = supposition.getStatement();
 
             return suppositionStatement;
           }),
-          lastProofStepStatement = lastProofStep.getStatement(),
+          lastStepStatement = lastStep.getStatement(),
           statements = [
             ...suppositionStatements,
-            lastProofStepStatement
+            lastStepStatement
           ];
 
     return statements;
   }
 
-  isProofStep() {
-    const proofStep = false;
+  isStep() {
+    const sStep = false;
 
-    return proofStep;
+    return sStep;
   }
 
   unifyStatement(statement, context) {
@@ -117,10 +117,10 @@ export default domAssigned(class Subproof {
 
   static name = "Subproof";
 
-  static fromProofStepSubproofNode(proofStepSubproofNode, fileContext) {
+  static fromStepOrSubproofNode(sStepOrSubproofNode, fileContext) {
     let subproof = null;
 
-    const subproofNode = subproofNodeQuery(proofStepSubproofNode);
+    const subproofNode = subproofNodeQuery(sStepOrSubproofNode);
 
     if (subproofNode !== null) {
       const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),

package/src/dom/supposition.js

@@ -44,11 +44,11 @@ export default domAssigned(class Supposition {
         const assignmentsAssigned = assignAssignments(assignments, context);
 
         if (assignmentsAssigned) {
-          const { ProofStep } = dom,
-                proofStep = ProofStep.fromStatement(this.statement, context),
-                proofStepSubproof = proofStep;  ///
+          const { Step } = dom,
+                step = Step.fromStatement(this.statement, context),
+                stepOrSubproof = step;  ///
 
-          context.addProofStepSubproof(proofStepSubproof);
+          context.addStepOrSubproof(stepOrSubproof);
 
           verified = true;
         }
@@ -90,51 +90,51 @@ export default domAssigned(class Supposition {
     return unifiedIndependently;
   }
 
-  unifyProofStepSubproof(proofStepSubproof, substitutions, generalContext, specificContext) {
-    let proofStepSubproofUnified = false;
+  unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext) {
+    let stepOrSubproofUnified = false;
 
-    const proofStepSubProofProofStep = proofStepSubproof.isProofStep(),
-          subproof = proofStepSubProofProofStep ?
-                       null :
-                         proofStepSubproof,
-          proofStep = proofStepSubProofProofStep ?
-                        proofStepSubproof :
-                          null;
+    const stepOrSubProofStep = stepOrSubproof.isStep(),
+          subproof = stepOrSubProofStep ?
+                        null :
+                          stepOrSubproof,
+          step = stepOrSubProofStep ?
+                   stepOrSubproof :
+                     null;
 
     substitutions.snapshot();
 
     if (subproof !== null) {
       const subproofUnified = this.unifySubproof(subproof, substitutions, generalContext, specificContext);
 
-      proofStepSubproofUnified = subproofUnified; ///
+      stepOrSubproofUnified = subproofUnified; ///
     }
 
-    if (proofStep !== null) {
-      const statementUnified = this.unifyProofStep(proofStep, substitutions, generalContext, specificContext);
+    if (step !== null) {
+      const statementUnified = this.unifyStep(step, substitutions, generalContext, specificContext);
 
-      proofStepSubproofUnified = statementUnified;  ///
+      stepOrSubproofUnified = statementUnified;  ///
     }
 
-    if (proofStepSubproofUnified) {
+    if (stepOrSubproofUnified) {
       substitutions.resolve(generalContext, specificContext);
     }
 
-    proofStepSubproofUnified ?
+    stepOrSubproofUnified ?
       substitutions.continue() :
         substitutions.rollback(specificContext);
 
-    return proofStepSubproofUnified;
+    return stepOrSubproofUnified;
   }
 
-  unifyProofStep(proofStep, substitutions, generalContext, specificContext) {
-    let proofStepUnified;
+  unifyStep(step, substitutions, generalContext, specificContext) {
+    let stepUnified;
 
-    const statement = proofStep.getStatement(),
+    const statement = step.getStatement(),
           statementUnified = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
-    proofStepUnified = statementUnified;  ///
+    stepUnified = statementUnified;  ///
 
-    return proofStepUnified;
+    return stepUnified;
   }
 
   unifySubproof(subproof, substitutions, generalContext, specificContext) {

package/src/dom/topLevelAssertion.js

@@ -156,8 +156,8 @@ export default class TopLevelAssertion {
     return deductionUnified;
   }
 
-  unifyStatementAndProofStepSubproofs(statement, proofStepSubproofs, substitutions, context) {
-    let statementAndProofStepSubproofsUnified = false;
+  unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context) {
+    let statementAndStepsOrSubproofsUnified = false;
 
     const localContext = LocalContext.fromFileContext(this.fileContext),
           generalContext = localContext, ///
@@ -165,55 +165,55 @@ export default class TopLevelAssertion {
           statementUnifiedWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifiedWithDeduction) {
-      const proofStepSubproofsUnifiedWithSuppositions = this.unifyProofStepSubproofsWithSuppositions(proofStepSubproofs, substitutions, generalContext, specificContext);
+      const stepsOrSubproofsUnifiedWithSuppositions = this.unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext);
 
-      if (proofStepSubproofsUnifiedWithSuppositions) {
+      if (stepsOrSubproofsUnifiedWithSuppositions) {
         const substitutionsResolved = substitutions.areResolved();
 
-        statementAndProofStepSubproofsUnified = substitutionsResolved; ///
+        statementAndStepsOrSubproofsUnified = substitutionsResolved; ///
       }
     }
 
-    return statementAndProofStepSubproofsUnified;
+    return statementAndStepsOrSubproofsUnified;
   }
 
-  unifyProofStepSubproofsWithSupposition(proofStepSubproofs, supposition, substitutions, generalContext, specificContext) {
-    let proofStepSubproofsUnifiedWithSupposition  =false;
+  unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext) {
+    let stepsOrSubproofsUnifiedWithSupposition  =false;
 
     const context = specificContext,  ///
           suppositionUnifiedIndependently = supposition.unifyIndependently(substitutions, context);
 
     if (suppositionUnifiedIndependently) {
-      proofStepSubproofsUnifiedWithSupposition = true;
+      stepsOrSubproofsUnifiedWithSupposition = true;
     } else {
-      const proofStep = extract(proofStepSubproofs, (proofStepSubproof) => {
-        const proofStepUnified = supposition.unifyProofStepSubproof(proofStepSubproof, substitutions, generalContext, specificContext);
+      const step = extract(stepsOrSubproofs, (stepOrSubproof) => {
+        const stepUnified = supposition.unifyStepOrSubproof(stepOrSubproof, substitutions, generalContext, specificContext);
 
-        if (proofStepUnified) {
+        if (stepUnified) {
           return true;
         }
       }) || null;
 
-      if (proofStep !== null) {
-        proofStepSubproofsUnifiedWithSupposition = true;
+      if (step !== null) {
+        stepsOrSubproofsUnifiedWithSupposition = true;
       }
     }
 
-    return proofStepSubproofsUnifiedWithSupposition;
+    return stepsOrSubproofsUnifiedWithSupposition;
   }
 
-  unifyProofStepSubproofsWithSuppositions(proofStepSubproofs, substitutions, generalContext, specificContext) {
-    proofStepSubproofs = reverse(proofStepSubproofs); ///
+  unifyStepsOrSubproofsWithSuppositions(stepsOrSubproofs, substitutions, generalContext, specificContext) {
+    stepsOrSubproofs = reverse(stepsOrSubproofs); ///
 
-    const proofStepSubproofsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
-      const proofStepSubproofsUnifiedWithSupposition = this.unifyProofStepSubproofsWithSupposition(proofStepSubproofs, supposition, substitutions, generalContext, specificContext);
+    const stepsOrSubproofsUnifiedWithSuppositions = backwardsEvery(this.suppositions, (supposition) => {
+      const stepsOrSubproofsUnifiedWithSupposition = this.unifyStepsOrSubproofsWithSupposition(stepsOrSubproofs, supposition, substitutions, generalContext, specificContext);
 
-      if (proofStepSubproofsUnifiedWithSupposition) {
+      if (stepsOrSubproofsUnifiedWithSupposition) {
         return true;
       }
     });
 
-    return proofStepSubproofsUnifiedWithSuppositions;
+    return stepsOrSubproofsUnifiedWithSuppositions;
   }
 
   toJSON() {