occam-verify-cli 1.0.852 → 1.0.858

package/src/context/{ephemeral.js → mnemic.js}

@@ -37,7 +37,7 @@ import { termsFromJSON,
 
 const { push } = arrayUtilities;
 
-export default class EphemeralContext extends Context {
+export default class MnemicContext extends Context {
   constructor(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions) {
     super(context);
 
@@ -178,7 +178,7 @@ export default class EphemeralContext extends Context {
           termA = term, ///
           termString = term.getString();
 
-    context.trace(`Adding the '${termString}' term to the ephemeral context...`);
+    context.trace(`Adding the '${termString}' term to the mnemic context...`);
 
     const terms = this.getTerms(),
           termB = terms.find((term) => {
@@ -191,12 +191,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (termB !== null) {
-      context.trace(`The '${termString}' term has already been added to the ephemeral context.`);
+      context.trace(`The '${termString}' term has already been added to the mnemic context.`);
     } else {
       this.terms.push(term);
     }
 
-    context.debug(`...added the '${termString}' term to the ephemeral context.`);
+    context.debug(`...added the '${termString}' term to the mnemic context.`);
   }
 
   addFrame(frame) {
@@ -204,7 +204,7 @@ export default class EphemeralContext extends Context {
           frameA = frame, ///
           frameString = frame.getString();
 
-    context.trace(`Adding the '${frameString}' frame to the ephemeral context...`);
+    context.trace(`Adding the '${frameString}' frame to the mnemic context...`);
 
     const frames = this.getFrames(),
           frameB = frames.find((frame) => {
@@ -217,12 +217,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (frameB !== null) {
-      context.trace(`The '${frameString}' frame has already been added to the ephemeral context.`);
+      context.trace(`The '${frameString}' frame has already been added to the mnemic context.`);
     } else {
       this.frames.push(frame);
     }
 
-    context.debug(`...added the '${frameString}' frame to the ephemeral context.`);
+    context.debug(`...added the '${frameString}' frame to the mnemic context.`);
   }
 
   addEquality(equality) {
@@ -230,7 +230,7 @@ export default class EphemeralContext extends Context {
           equalityA = equality, ///
           equalityString = equality.getString();
 
-    context.trace(`Adding the '${equalityString}' equality to the ephemeral context...`);
+    context.trace(`Adding the '${equalityString}' equality to the mnemic context...`);
 
     const equalities = this.getEqualities(),
           equalityB = equalities.find((equality) => {
@@ -243,12 +243,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (equalityB !== null) {
-      context.trace(`The '${equalityString}' equality has already been added to the ephemeral context.`);
+      context.trace(`The '${equalityString}' equality has already been added to the mnemic context.`);
     } else {
       this.equalities.push(equality);
     }
 
-    context.debug(`...added the '${equalityString}' equality to the ephemeral context.`);
+    context.debug(`...added the '${equalityString}' equality to the mnemic context.`);
   }
 
   addJudgement(judgement) {
@@ -256,7 +256,7 @@ export default class EphemeralContext extends Context {
           judgementA = judgement, ///
           judgementString = judgement.getString();
 
-    context.trace(`Adding the '${judgementString}' judgement to the ephemeral context...`);
+    context.trace(`Adding the '${judgementString}' judgement to the mnemic context...`);
 
     const judgements = this.getJudgements(),
           judgementB = judgements.find((judgement) => {
@@ -269,12 +269,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (judgementB !== null) {
-      context.trace(`The '${judgementString}' judgement has already been added to the ephemeral context.`);
+      context.trace(`The '${judgementString}' judgement has already been added to the mnemic context.`);
     } else {
       this.judgements.push(judgement);
     }
 
-    context.debug(`...added the '${judgementString}' judgement to the ephemeral context.`);
+    context.debug(`...added the '${judgementString}' judgement to the mnemic context.`);
   }
 
   addStatement(statement) {
@@ -282,7 +282,7 @@ export default class EphemeralContext extends Context {
           statementA = statement, ///
           statementString = statement.getString();
 
-    context.trace(`Adding the '${statementString}' statement to the ephemeral context...`);
+    context.trace(`Adding the '${statementString}' statement to the mnemic context...`);
 
     const statements = this.getStatements(),
           statementB = statements.find((statement) => {
@@ -295,12 +295,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (statementB !== null) {
-      context.trace(`The '${statementString}' statement has already been added to the ephemeral context.`);
+      context.trace(`The '${statementString}' statement has already been added to the mnemic context.`);
     } else {
       this.statements.push(statement);
     }
 
-    context.debug(`...added the '${statementString}' statement to the ephemeral context.`);
+    context.debug(`...added the '${statementString}' statement to the mnemic context.`);
   }
 
   addAssertion(assertion) {
@@ -308,7 +308,7 @@ export default class EphemeralContext extends Context {
           assertionA = assertion, ///
           assertionString = assertion.getString();
 
-    context.trace(`Adding the '${assertionString}' assertion to the ephemeral context...`);
+    context.trace(`Adding the '${assertionString}' assertion to the mnemic context...`);
 
     const assertions = this.getAssumptions(),
           assertionB = assertions.find((assertion) => {
@@ -321,12 +321,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (assertionB !== null) {
-      context.trace(`The '${assertionString}' assertion has already been added to the ephemeral context.`);
+      context.trace(`The '${assertionString}' assertion has already been added to the mnemic context.`);
     } else {
       this.assertions.push(assertion);
     }
 
-    context.debug(`...added the '${assertionString}' assertion to the ephemeral context.`);
+    context.debug(`...added the '${assertionString}' assertion to the mnemic context.`);
   }
 
   addReference(reference) {
@@ -334,7 +334,7 @@ export default class EphemeralContext extends Context {
           referenceA = reference, ///
           referenceString = reference.getString();
 
-    context.trace(`Adding the '${referenceString}' reference to the ephemeral context...`);
+    context.trace(`Adding the '${referenceString}' reference to the mnemic context...`);
 
     const references = this.getReferences(),
           referenceB = references.find((reference) => {
@@ -347,12 +347,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (referenceB !== null) {
-      context.trace(`The '${referenceString}' reference has already been added to the ephemeral context.`);
+      context.trace(`The '${referenceString}' reference has already been added to the mnemic context.`);
     } else {
       this.references.push(reference);
     }
 
-    context.debug(`...added the '${referenceString}' reference to the ephemeral context.`);
+    context.debug(`...added the '${referenceString}' reference to the mnemic context.`);
   }
 
   addAssumption(assumption) {
@@ -360,7 +360,7 @@ export default class EphemeralContext extends Context {
           assumptionA = assumption, ///
           assumptionString = assumption.getString();
 
-    context.trace(`Adding the '${assumptionString}' assumption to the ephemeral context...`);
+    context.trace(`Adding the '${assumptionString}' assumption to the mnemic context...`);
 
     const assumptions = this.getAssumptions(),
           assumptionB = assumptions.find((assumption) => {
@@ -373,12 +373,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (assumptionB !== null) {
-      context.trace(`The '${assumptionString}' assumption has already been added to the ephemeral context.`);
+      context.trace(`The '${assumptionString}' assumption has already been added to the mnemic context.`);
     } else {
       this.assumptions.push(assumption);
     }
 
-    context.debug(`...added the '${assumptionString}' assumption to the ephemeral context.`);
+    context.debug(`...added the '${assumptionString}' assumption to the mnemic context.`);
   }
 
   addMetavariable(metavariable) {
@@ -386,7 +386,7 @@ export default class EphemeralContext extends Context {
           metavariableA = metavariable, ///
           metavariableString = metavariable.getString();
 
-    context.trace(`Adding the '${metavariableString}' metavariable to the ephemeral context...`);
+    context.trace(`Adding the '${metavariableString}' metavariable to the mnemic context...`);
 
     const metavariables = this.getMetavariables(),
           metavariableB = metavariables.find((metavariable) => {
@@ -399,12 +399,12 @@ export default class EphemeralContext extends Context {
           }) || null;
 
     if (metavariableB !== null) {
-      context.trace(`The '${metavariableString}' metavariable has already been added to the ephemeral context.`);
+      context.trace(`The '${metavariableString}' metavariable has already been added to the mnemic context.`);
     } else {
       this.metavariables.push(metavariable);
     }
 
-    context.debug(`...added the '${metavariableString}' metavariable to the ephemeral context.`);
+    context.debug(`...added the '${metavariableString}' metavariable to the mnemic context.`);
   }
 
   addSubstitution(substitution) {
@@ -412,25 +412,25 @@ export default class EphemeralContext extends Context {
           substitutionA = substitution, ///
           substitutionString = substitution.getString();
 
-    context.trace(`Adding the '${substitutionString}' substitution to the ephemeral context...`);
+    context.trace(`Adding the '${substitutionString}' substitution to the mnemic context...`);
 
     const substitutions = this.getSubstitutions(),
           substitutionB = substitutions.find((substitution) => {
             const substitutionB = substitution, ///
                   substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
-      
+
             if (substitutionAEqualToSubstitutionB) {
               return true;
             }
           }) || null;
 
     if (substitutionB !== null) {
-      context.trace(`The '${substitutionString}' substitution has already been added to the ephemeral context.`);
+      context.trace(`The '${substitutionString}' substitution has already been added to the mnemic context.`);
     } else {
       this.substitutions.push(substitution);
     }
 
-    context.debug(`...added the '${substitutionString}' substitution to the ephemeral context.`);
+    context.debug(`...added the '${substitutionString}' substitution to the mnemic context.`);
   }
 
   addTerms(terms) {
@@ -488,9 +488,7 @@ export default class EphemeralContext extends Context {
   }
 
   addSubstitutions(substitutions) {
-    substitutions.forEach((substitution) => {
-      this.addSubstitution(substitution);
-    });
+    ///
   }
 
   findVariableByVariableNode(variableNode) {
@@ -801,11 +799,11 @@ export default class EphemeralContext extends Context {
           assumptions = null,
           metavariables = null,
           substitutions = null,
-          emphemeralContext = new EphemeralContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);
+          mnemicContext = new MnemicContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);
 
-    emphemeralContext.initialise(json);
+    mnemicContext.initialise(json);
 
-    return emphemeralContext;
+    return mnemicContext;
   }
 
   static fromNothing(context) {
@@ -819,8 +817,8 @@ export default class EphemeralContext extends Context {
           assumptions = [],
           metavariables = [],
           substitutions = [],
-          emphemeralContext = new EphemeralContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);
+          mnemicContext = new MnemicContext(context, terms, frames, equalities, judgements, assertions, statements, references, assumptions, metavariables, substitutions);
 
-    return emphemeralContext;
+    return mnemicContext;
   }
 }

package/src/context.js

@@ -104,6 +104,14 @@ export default class Context extends ContextBase {
     return substitutions;
   }
 
+  getDerivedSubstitutions(derivedSubstitutions = []) {
+    const context = this.getContext();
+
+    context.getDerivedSubstitutions(derivedSubstitutions);
+
+    return derivedSubstitutions;
+  }
+
   getEquivalences() {
     const context = this.getContext(),
           equivalences = context.getEquivalences();
@@ -160,7 +168,9 @@ export default class Context extends ContextBase {
 
     const parentContext = context; ///
 
-    metavariable = parentContext.findMetavariable(metavariable, childContext);  ///
+    context = childContext; ///
+
+    metavariable = parentContext.findMetavariable(metavariable, context);
 
     return metavariable;
   }
@@ -374,15 +384,25 @@ export default class Context extends ContextBase {
 
     context = this.getContext();
 
-    const parentContext = context,  ///
-          metavariablePresent = parentContext.isMetavariablePresent(metavariable, childContext);
+    const parentContext = context;  ///
+
+    context = childContext; ///
+
+    const metavariablePresent = parentContext.isMetavariablePresent(metavariable, context);
 
     return metavariablePresent;
   }
 
-  isLabelPresentByReference(reference) {
-    const context = this.getContext(),
-          labelPresent = context.isLabelPresentByReference(reference);
+  isLabelPresentByReference(reference, context = null) {
+    const childContext = context; ///
+
+    context = this.getContext();
+
+    const parentContext = context;  ///
+
+    context = childContext; ///
+
+    const labelPresent = parentContext.isLabelPresentByReference(reference, context);
 
     return labelPresent;
   }
@@ -485,11 +505,11 @@ export default class Context extends ContextBase {
     return referencePresent;
   }
 
-  isSubstitutionPresentByMetavariableNode(metavariableNode) {
+  isDerivedSubstitutionPresentByMetavariableNode(metavariableNode) {
     const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentByMetavariableNode(metavariableNode);
+          derivedSubstitutionPresent = context.isDerivedSubstitutionPresentByMetavariableNode(metavariableNode);
 
-    return substitutionPresent;
+    return derivedSubstitutionPresent;
   }
 
   isDeclaredJudgementPresentByMetavariableNode(metavariableNode) {
@@ -499,11 +519,11 @@ export default class Context extends ContextBase {
     return declaredJudgementPresent;
   }
 
-  isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution) {
+  isDerivedSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution) {
     const context = this.getContext(),
-      substitutionPresent = context.isSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution);
+          derivedSubstitutionPresent = context.isDerivedSubstitutionPresentByMetavariableNodeAndSubstitution(metavariableNode, substitution);
 
-    return substitutionPresent;
+    return derivedSubstitutionPresent;
   }
 
   isMetaLevel() {

package/src/element/assertion/contained.js

@@ -103,13 +103,11 @@ export default define(class ContainedAssertion extends Assertion {
       const termString = this.term.getString(),
             containedAssertionString = this.getString(); ///
 
-      context.trace(`Validating the '${containedAssertionString}' contained assertion's '${termString}' term...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertion's term...`);
 
       const termSingular = this.term.isSingular();
 
-      if (!termSingular) {
-        context.debug(`The '${termString}' term is not singular.`);
-      } else {
+      if (termSingular) {
         const term = this.term.validate(context, (term) => {
           const validatesForwards = true;
 
@@ -123,8 +121,10 @@ export default define(class ContainedAssertion extends Assertion {
         }
 
         if (termValidates) {
-          context.debug(`...validated the '${containedAssertionString}' contained assertion's '${termString}' term.`);
+          context.debug(`...validated the '${containedAssertionString}' contained assertion's term.`);
         }
+      } else {
+        context.debug(`The '${termString}' term is not singular.`);
       }
     }
 
@@ -138,7 +138,7 @@ export default define(class ContainedAssertion extends Assertion {
       const frameString = this.frame.getString(),
             containedAssertionString = this.getString(); ///
 
-      context.trace(`Validating the '${containedAssertionString}' contained assertion's '${frameString}' frame...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertion's frame...`);
 
       const frameSingular = this.frame.isSingular();
 
@@ -155,7 +155,7 @@ export default define(class ContainedAssertion extends Assertion {
       }
 
       if (frameValidates) {
-        context.debug(`...validated the '${containedAssertionString}' contained assertion's '${frameString}' frame.`);
+        context.debug(`...validated the '${containedAssertionString}' contained assertion's frame.`);
       }
     }
 

package/src/element/assertion/defined.js

@@ -94,13 +94,11 @@ export default define(class DefinedAssertion extends Assertion {
       const termString = this.term.getString(), ///
             definedAssertionString = this.getString();  ///
 
-      context.trace(`Validating the '${definedAssertionString}' defined assertion's '${termString}' term...`);
+      context.trace(`Validating the '${definedAssertionString}' defined assertion's term...`);
 
       const termSingular = this.term.isSingular();
 
-      if (!termSingular) {
-        context.debug(`The '${termString}' term is not singular.`);
-      } else {
+      if (termSingular) {
         const term = this.term.validate(context, (term) => {
           const validatesForwards = true;
 
@@ -114,8 +112,10 @@ export default define(class DefinedAssertion extends Assertion {
         }
 
         if (termValidates) {
-          context.debug(`...validates the'${definedAssertionString}' defined assertion's '${termString}' term.`);
+          context.debug(`...validates the'${definedAssertionString}' defined assertion's term.`);
         }
+      } else {
+        context.debug(`The '${termString}' term is not singular.`);
       }
     }
 

package/src/element/assertion/satisfies.js

@@ -91,10 +91,9 @@ export default define(class SatisfiesAssertion extends Assertion {
   validateReference(context) {
     let referenceVerifies = false;
 
-    const referenceString = this.reference.getString(),
-          satisfiesAssertionString = this.getString();  ///
+    const satisfiesAssertionString = this.getString();  ///
 
-    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertino's '${referenceString}' reference...`);
+    context.trace(`Validating the '${satisfiesAssertionString}' satisfies assertino's reference...`);
 
     const axiom = context.findAxiomByReference(this.reference);
 
@@ -107,7 +106,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     }
 
     if (referenceVerifies) {
-      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertino's '${referenceString}' reference.`);
+      context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertino's reference.`);
     }
 
     return referenceVerifies;

package/src/element/assertion/type.js

@@ -86,10 +86,9 @@ export default define(class TypeAssertion extends Assertion {
   validateType(context) {
     let typeValidates;
 
-    const typeString = this.type.getString(),
-          typeAssertionString = this.getString();  ///
+    const typeAssertionString = this.getString();  ///
 
-    context.trace(`Validating the '${typeAssertionString}' type assertion's '${typeString}' type...`);
+    context.trace(`Validating the '${typeAssertionString}' type assertion's type...`);
 
     const nominalTypeName = this.type.getNominalTypeName(),
           type = context.findTypeByNominalTypeName(nominalTypeName);
@@ -99,11 +98,13 @@ export default define(class TypeAssertion extends Assertion {
 
       typeValidates = true;
     } else {
+      const typeString = this.type.getString();
+
       context.debug(`The '${typeString}' type is not present.`);
     }
 
     if (typeValidates) {
-      context.debug(`...validated the '${typeAssertionString}' type assertion's '${typeString}' type.`);
+      context.debug(`...validated the '${typeAssertionString}' type assertion's type.`);
     }
 
     return typeValidates;

package/src/element/assumption/metaLevel.js

@@ -119,10 +119,9 @@ export default define(class MetaLevelAssumption extends Element {
   validateReference(context) {
     let referenceValidates = false;
 
-    const referenceString = this.reference.getString(),
-          metaLevelAssumptionString = this.getString();  ///
+    const metaLevelAssumptionString = this.getString();  ///
 
-    context.trace(`Validating the '${metaLevelAssumptionString}' meta-level assumption's '${referenceString}' reference...`);
+    context.trace(`Validating the '${metaLevelAssumptionString}' meta-level assumption's reference...`);
 
     const reference = this.reference.validate(context);
 
@@ -139,7 +138,7 @@ export default define(class MetaLevelAssumption extends Element {
     }
 
     if (referenceValidates) {
-      context.debug(`...validated the '${metaLevelAssumptionString}' meta-level assumption's '${referenceString}' reference.`);
+      context.debug(`...validated the '${metaLevelAssumptionString}' meta-level assumption's reference.`);
     }
 
     return referenceValidates;
@@ -148,10 +147,9 @@ export default define(class MetaLevelAssumption extends Element {
   validateStatement(context) {
     let statementValidates = false;
 
-    const metaLevelAssumptionString = this.getString(),  ///
-          statementString = this.statement.getString();
+    const metaLevelAssumptionString = this.getString();  ///
 
-    context.trace(`Validating the '${metaLevelAssumptionString}' meta-level assumption's '${statementString}' statement...`);
+    context.trace(`Validating the '${metaLevelAssumptionString}' meta-level assumption's statement...`);
 
     descend((context) => {
       const statement = this.statement.validate(context);
@@ -162,7 +160,7 @@ export default define(class MetaLevelAssumption extends Element {
     }, context);
 
     if (statementValidates) {
-      context.debug(`...validated the '${metaLevelAssumptionString}' meta-level assumption's '${statementString}' statement.`);
+      context.debug(`...validated the '${metaLevelAssumptionString}' meta-level assumption's statement.`);
     }
 
     return statementValidates;

package/src/element/assumption.js

@@ -112,37 +112,33 @@ export default define(class Assumption extends Element {
   validateReference(context) {
     let referenceValidates = false;
 
-    const referenceString = this.reference.getString(),
-          assumptionString = this.getString();  ///
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference...`);
+    context.trace(`Validating the '${assumptionString}' assumption's reference...`);
 
     const reference = this.reference.validate(context);
 
     if (reference !== null) {
-      const metavariable = this.reference.getMetavariable(),
+      const metavariable = reference.getMetavariable(),
             metavariablePresent = context.isMetavariablePresent(metavariable, context);
 
       if (metavariablePresent) {
+        this.reference = reference;
+
         referenceValidates = true;
       } else {
-        const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference),
-              topLevelMetaAssertionsCompare = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
-                const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+        const topLevelMetaAssertionsUnify = this.unifyTopLevelMetaAssertions(reference, context);
 
-                if (topLevelMetaAssertionUnifies) {
-                  return true;
-                }
-              });
+        if (topLevelMetaAssertionsUnify) {
+          this.reference = reference;
 
-        if (topLevelMetaAssertionsCompare) {
           referenceValidates = true;
         }
       }
     }
 
     if (referenceValidates) {
-      context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' reference.`);
+      context.debug(`...validated the '${assumptionString}' assumption's reference.`);
     }
 
     return referenceValidates;
@@ -151,10 +147,9 @@ export default define(class Assumption extends Element {
   validateStatement(context) {
     let statementValidates = false;
 
-    const assumptionString = this.getString(),  ///
-          statementString = this.statement.getString();
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
+    context.trace(`Validating the '${assumptionString}' assumption's statement...`);
 
     const statement = this.statement.validate(context);
 
@@ -163,7 +158,7 @@ export default define(class Assumption extends Element {
     }
 
     if (statementValidates) {
-      context.debug(`...validated the '${assumptionString}' assumption's '${statementString}' statement.`);
+      context.debug(`...validated the '${assumptionString}' assumption's statement.`);
     }
 
     return statementValidates;
@@ -267,6 +262,22 @@ export default define(class Assumption extends Element {
     return topLevelMetaAssertionUnifies;
   }
 
+  unifyTopLevelMetaAssertions(reference, context) {
+    let topLevelMetaAssertionsUnify;
+
+    const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(reference);
+
+    topLevelMetaAssertionsUnify = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
+      const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+
+      if (topLevelMetaAssertionUnifies) {
+        return true;
+      }
+    });
+
+    return topLevelMetaAssertionsUnify;
+  }
+
   static name = "Assumption";
 
   toJSON() {

package/src/element/combinator.js

@@ -56,10 +56,9 @@ export default define(class Combinator extends Element {
   validateStatement(context) {
     let statementValidates = false;
 
-    const statementString = this.statement.getString(),
-          combinatorString = this.getString();  ///
+    const combinatorString = this.getString();  ///
 
-    context.trace(`Validating the '${combinatorString}' combinator's '${statementString}' statement...`);
+    context.trace(`Validating the '${combinatorString}' combinator's statement...`);
 
     const statementValidatesAsCombinator = validateStatementAsCombinator(this.statement, context);
 
@@ -68,7 +67,7 @@ export default define(class Combinator extends Element {
     }
 
     if (statementValidates) {
-      context.debug(`...validated the '${combinatorString}' combinator's '${statementString}' statement.`);
+      context.debug(`...validated the '${combinatorString}' combinator's statement.`);
     }
 
     return statementValidates;