occam-verify-cli 1.0.444 → 1.0.457

package/src/context/{temporary.js → transient.js}

@@ -2,9 +2,11 @@
 
 import { arrayUtilities } from "necessary";
 
+import { chainContext } from "../utilities/context";
+
 const { extract, compress } = arrayUtilities;
 
-export default class TemporaryContext {
+export default class TransientContext {
   constructor(context, terms, frames, statements, assertions, references, substitutions) {
     this.context = context;
     this.terms = terms;
@@ -13,6 +15,8 @@ export default class TemporaryContext {
     this.assertions = assertions;
     this.references = references;
     this.substitutions = substitutions;
+
+    return chainContext(this);
   }
 
   getContext() {
@@ -231,140 +235,14 @@ export default class TemporaryContext {
 
   getVariables(nested = true) { return this.context.getVariables(nested); }
 
-  getJudgements() { return this.context.getJudgements(); }
-
-  getEquivalences() { return this.context.getEquivalences(); }
-
-  getSteps() { return this.context.getSteps(); }
-
-  getLastStep() { return this.context.getLastStep(); }
-
-  getStepsOrSubproofs() { return this.context.getStepsOrSubproofs(); }
-
-  getFilePath() { return this.context.getFilePath(); }
-
-  getLexer() { return this.context.getLexer(); }
-
-  getParser() { return this.context.getParser(); }
-
-  getAxioms() { return this.context.getAxioms(); }
-
-  getLemmas() { return this.context.getLemmas(); }
-
-  getTheorems() { return this.context.getTheorems(); }
-
-  getConjectures() { return this.context.getConjectures(); }
-
-  getCombinators() { return this.context.getCombinators(); }
-
-  getConstructors() { return this.context.getConstructors(); }
-
-  getTypePrefix() { return this.context.getTypePrefix(); }
-
-  addAxiom(axiom) { this.context.addAxiom(axiom); }
-
-  addLemma(lemma) { this.context.addLemma(lemma); }
-
-  addTheorem(theorem) { this.context.addTheorem(theorem); }
-
-  addEquality(equality) { return this.context.addEquality(equality); }
-
   addVariable(variable, nested = true) { return this.context.addVariable(variable, nested); }
 
-  addJudgement(judgement) { return this.context.addJudgement(judgement); }
-
-  addStepOrSubproof(stepOrSubproof) { this.context.addStepOrSubproof(stepOrSubproof); }
-
-  findProcedureByName(name) { return this.context.findProcedureByName(name); }
-
-  findLabelByReference(reference, context) { return this.context.findLabelByReference(reference, context); }
-
-  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
-
-  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
-
-  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
-
-  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
-
-  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
-
-  findMetaLemmasByReference(reference) { return this.context.findMetaLemmasByReference(reference); }
-
-  findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
-
-  findMetaLemmaMetatheoremByReference(reference) { return this.context.findMetaLemmaMetatheoremByReference(reference); }
-
-  findMetaLemmaMetatheoremsByReference(reference) { return this.context.findMetaLemmaMetatheoremsByReference(reference); }
-
   findVariableByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }
 
-  findJudgementByMetavariable(metavariable) { return this.context.findJudgementByMetavariable(metavariable); }
-
-  findEquivalenceByTerm(term) { return this.context.findEquivalenceByTerm(term); }
-
-  findMetavariable(metavariable) { return this.context.findMetavariable(metavariable); }
-
-  findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }
-
-  findTypeByNominalTypeName(nominalTypeName) { return this.context.findTypeByNominalTypeName(nominalTypeName); }
-
-  findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
-
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
-
-  isProcedurePresentByName(name) { return this.context.isProcedurePresentByName(name); }
-
-  isLabelPresentByReference(reference) { return this.context.isLabelPresentByReference(reference); }
-
-  isMetavariablePresentByReference(reference) { return this.context.isMetavariablePresentByReference(reference); }
-
-  isMetaLemmaMetatheoremPresentByReference(reference) { return this.context.isMetaLemmaMetatheoremPresentByReference(reference); }
-
-  findAxiomLemmaTheoremOrConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremOrConjectureByReference(reference); }
-
-  isMetavariablePresent(metavariable) { return this.context.isMetavariablePresent(metavariable); }
-
   isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }
 
-  isTypePresentByNominalTypeName(nominalTypeName) { return this.context.isTypePresentByNominalTypeName(nominalTypeName); }
-
-  isTypePresentByPrefixedTypeName(prefixedTypeName) { return this.context.isTypePresentByPrefixedTypeName(prefixedTypeName); }
-
-  isTypePrefixPresentByTypePrefixName(typePrefixName) { return this.context.isTypePrefixPresentByTypePrefixName(typePrefixName); }
-
   isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) { return this.context.findVariableByVariableIdentifier(variableIdentifier, nested); }
 
-  isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }
-
-  isLabelPresentByMetavariable(metavariable) { return this.context.isLabelPresentByMetavariable(metavariable); }
-
-  isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }
-
-  isJudgementPresentByMetavariable(metavariable) { return this.context.isJudgementPresentByMetavariable(metavariable); }
-
-  isTermGrounded(term) { return this.context.isTermGrounded(term); }
-
-  isVariableDefined(variable) { return this.context.isVariableDefined(variable); }
-
-  isMetavariableDefined(metavariable) { return this.context.isMetavariableDefined(metavariable); }
-
-  compareTermAndPropertyRelation(term, propertyRelation) { return this.context.compareTermAndPropertyRelation(term, propertyRelation); }
-
-  nodeAsString(node) { return this.context.nodeAsString(node); }
-
-  nodesAsString(node) { return this.context.nodesAsString(node); }
-
-  trace(message, node = null) { this.context.trace(message, node); }
-
-  debug(message, node = null) { this.context.debug(message, node); }
-
-  info(message, node = null) { this.context.info(message, node); }
-
-  warning(message, node = null) { this.context.warning(message, node); }
-
-  error(message, node = null) { this.context.error(message, node); }
-
   merge(context) {
     const terms = context.getTerms(),
           frames = context.getFrames(),
@@ -459,9 +337,9 @@ export default class TemporaryContext {
           assertions = [],
           references = [],
           substitutions = [],
-          temporaryContext = new TemporaryContext(context, terms, frames, statements, assertions, references, substitutions);
+          transientContext = new TransientContext(context, terms, frames, statements, assertions, references, substitutions);
 
-    return temporaryContext;
+    return transientContext;
   }
 
   static fromTermsAndFrames(terms, frames, context) {
@@ -469,8 +347,8 @@ export default class TemporaryContext {
           assertions = [],
           references = [],
           substitutions = [],
-          temporaryContext = new TemporaryContext(context, terms, frames, statements, assertions, references, substitutions);
+          transientContext = new TransientContext(context, terms, frames, statements, assertions, references, substitutions);
 
-    return temporaryContext;
+    return transientContext;
   }
 }

package/src/element/assumption.js

@@ -34,7 +34,7 @@ export default define(class Assumption extends Element {
   compareSubstitution(substitution, context) {
     let comparesToSubstituion = false;
 
-    const assumptionString = this.string,  ///
+    const assumptionString = this.getString(),  ///
           substitutionString = substitution.getString();
 
     context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
@@ -71,75 +71,59 @@ export default define(class Assumption extends Element {
     return comparesToSubstituion;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
-    const assumptionString = this.string;  ///
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Verifying the '${assumptionString}' assumption...`);
+    context.trace(`Validating the '${assumptionString}' assumption...`);
 
     const simple = this.isSimple();
 
     if (simple) {
-      const referenceVerifiesAsMetavariable = this.verifyReferenceAsMetavariable(assignments, stated, context);
+      const referenceValidatesAsMetavariable = this.validateReferenceAsMetavariable(assignments, stated, context);
 
-      verifies = referenceVerifiesAsMetavariable; ///
+      if (referenceValidatesAsMetavariable) {
+        validates = true;
+      }
     } else {
-      const referenceVerified = this.verifyReference(assignments, stated, context);
+      const referenceValidates = this.reference.validate(context);
 
-      if (referenceVerified) {
+      if (referenceValidates) {
         const statementValidates = this.validateStatement(assignments, stated, context);
 
         if (statementValidates) {
-          let verifiesWhenStated = false,
-              verifiesWhenDerived = false;
+          let validatesWhenStated = false,
+              validatesWhenDerived = false;
 
           if (stated) {
-            verifiesWhenStated = this.verifyWhenStated(assignments, context);
+            validatesWhenStated = this.validateWhenStated(assignments, context);
           } else {
-            verifiesWhenDerived = this.verifyWhenDerived(context);
+            validatesWhenDerived = this.validateWhenDerived(context);
           }
 
-          if (verifiesWhenStated || verifiesWhenDerived) {
-            verifies = true;
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
           }
         }
       }
 
-      if (verifies) {
-        context.debug(`...verified the '${assumptionString}' assumption.`);
+      if (validates) {
+        context.debug(`...validated the '${assumptionString}' assumption.`);
       }
     }
 
-    return verifies;
-  }
-
-  verifyReference(assignments, stated, context) {
-    let referenceVerified;
-
-    const referenceString = this.reference.getString(),
-          assumptionString = this.string; ///
-
-    context.trace(`Verifying the '${assumptionString}' assumption's '${referenceString}' reference...`);
-
-    referenceVerified = this.reference.verify(context);
-
-    if (referenceVerified) {
-      context.debug(`...verified the '${assumptionString}' assumption's '${referenceString}' reference.`);
-    }
-
-    return referenceVerified;
+    return validates;
   }
 
   validateStatement(assignments, stated, context) {
-    let statementValidates;
+    let statementValidates = true;  ///
 
-    if (this.statement === null) {
-      statementValidates = true;
-    } else {
-      const statementString = this.statement.getString();
+    if (this.statement !== null) {
+      const assumptionString = this.getString(),
+            statementString = this.statement.getString();
 
-      context.trace(`Validating the '${statementString}' statement...`);
+      context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
 
       stated = true;  ///
 
@@ -148,83 +132,83 @@ export default define(class Assumption extends Element {
       statementValidates = this.statement.validate(assignments, stated, context);
 
       if (statementValidates) {
-        context.debug(`...validated the '${statementString}' statement.`);
+        context.debug(`...validated the '${assumptionString}' assumption's '${statementString}' statement.`);
       }
     }
 
     return statementValidates;
   }
 
-  verifyReferenceAsMetavariable(assignments, stated, context) {
-    let referenceVerifiesAsMetavariable = false;
+  validateReferenceAsMetavariable(assignments, stated, context) {
+    let referenceValidatesAsMetavariable = false;
 
     const referenceString = this.reference.getString(),
-          assumptionString = this.string; ///
+          assumptionString = this.getString(); ///
 
-    context.trace(`Verifying the '${assumptionString}' assumption's '${referenceString}' reference as s metavariable...`);
+    context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference as s metavariable...`);
 
     const metavariable = this.reference.getMetavariable(),
           metavariableName = metavariable.getName(),
           metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
 
     if (metavariablePresent) {
-      referenceVerifiesAsMetavariable = true;
+      referenceValidatesAsMetavariable = true;
     }
 
-    if (referenceVerifiesAsMetavariable) {
-      context.debug(`...verified the '${assumptionString}' assumption's '${referenceString}' reference as a metavariable.`);
+    if (referenceValidatesAsMetavariable) {
+      context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' reference as a metavariable.`);
     }
 
-    return referenceVerifiesAsMetavariable;
+    return referenceValidatesAsMetavariable;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated;
 
-    const assumptionString = this.string;  ///
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Verifying the '${assumptionString}' stated assumption...`);
+    context.trace(`Validating the '${assumptionString}' stated assumption...`);
 
     const metavariablePresent = context.isMetavariablePresentByReference(this.reference);
 
     if (metavariablePresent) {
-      verifiesWhenStated = true;
+      validatesWhenStated = true;
     } else {
-      const metaLemmaMetatheorems = context.findMetaLemmaMetatheoremsByReference(this.reference),
-            metaLemmaMetatheoremsUnify = metaLemmaMetatheorems.every((metaLemmaMetatheorem) => {
-              const metaLemmaMetatheoremUnifies = this.unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context);
+      const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference),
+            topLevelMetaAssertionsUnify = topLevelMetaAssertions.every((topLevelMetaAssertion) => {
+              const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-              if (metaLemmaMetatheoremUnifies) {
+              if (topLevelMetaAssertionUnifies) {
                 return true;
               }
             });
 
-      verifiesWhenStated = metaLemmaMetatheoremsUnify; ///
+      validatesWhenStated = topLevelMetaAssertionsUnify; ///
     }
 
-    if (verifiesWhenStated) {
-      context.debug(`...verified the '${assumptionString}' stated assumption.`);
+    if (validatesWhenStated) {
+      context.debug(`...validated the '${assumptionString}' stated assumption.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
-    const assumptionString = this.string;  ///
+    const assumptionString = this.getString();  ///
 
-    context.trace(`Verifying the '${assumptionString}' derived assumption...`);
+    context.trace(`Validating the '${assumptionString}' derived assumption...`);
 
-    const metaLemmaMetatheoremPresent = context.isMetaLemmaMetatheoremPresentByReference(this.reference);
+    const topLevelMetaAssertionPresent = context.isTopLevelMetaAssertionPresentByReference(this.reference);
 
-    verifiesWhenDerived = metaLemmaMetatheoremPresent; ///
+    validatesWhenDerived = topLevelMetaAssertionPresent; ///
 
-    if (verifiesWhenDerived) {
-      context.debug(`...verified the '${assumptionString}' derived assumption.`);
+    if (validatesWhenDerived) {
+      context.debug(`...validated the '${assumptionString}' derived assumption.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
   unifyStatement(statement, substitutions, generalContext, specificContext) {
@@ -260,7 +244,7 @@ export default define(class Assumption extends Element {
 
     const context = generalContext, ///
           labelString = label.getString(),
-          assumptionString = this.string;  //;/
+          assumptionString = this.getString();  //;/
 
     context.trace(`Unifying the '${labelString}' label with the '${assumptionString}' assumption...`);
 
@@ -275,28 +259,28 @@ export default define(class Assumption extends Element {
     return labelUnifiesWithReference;
   }
 
-  unifyMetaLemmaMetatheorem(metaLemmaMetatheorem, context) {
-    let metaLemmaMetatheoremUnifies = false;
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionUnifies = false;
 
-    const assumptionString = this.string,  ///
-          metaLemmaMetatheoremString = metaLemmaMetatheorem.getString();
+    const assumptionString = this.getString(),  ///
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${assumptionString}' assumption...`);
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
 
     const generalContext = context; ///
 
-    context = metaLemmaMetatheorem.getContext();  ///
+    context = topLevelMetaAssertion.getContext();  ///
 
     const { Substitutions } = elements,
           specificContext = context,  ///
           labelSubstitutions = Substitutions.fromNothing(),
-          label = metaLemmaMetatheorem.getLabel(),
+          label = topLevelMetaAssertion.getLabel(),
           substitutions = labelSubstitutions, ///
           labelUnifies = this.unifyLabel(label, substitutions, generalContext, specificContext);
 
     if (labelUnifies) {
       const statementSubstitutions = Substitutions.fromNothing(),
-            statement = metaLemmaMetatheorem.getStatement(),
+            statement = topLevelMetaAssertion.getStatement(),
             substitutions = statementSubstitutions, ///
             statementUUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
 
@@ -304,18 +288,18 @@ export default define(class Assumption extends Element {
         const labelSubstitutionsCorrelateStatementSubstitutions = labelSubstitutions.correlateSubstitutions(statementSubstitutions);
 
         if (labelSubstitutionsCorrelateStatementSubstitutions) {
-          metaLemmaMetatheoremUnifies = true; ///
+          topLevelMetaAssertionUnifies = true; ///
         }
       }
     }
 
-    if (metaLemmaMetatheoremUnifies) {
+    if (topLevelMetaAssertionUnifies) {
       context = generalContext; ///
 
-      context.trace(`...unified the '${metaLemmaMetatheoremString}' meta-lemma or metatheorem with the '${assumptionString}' assumption...`);
+      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
     }
 
-    return metaLemmaMetatheoremUnifies;
+    return topLevelMetaAssertionUnifies;
   }
 
   toJSON() {

package/src/element/combinator/bracketed.js

@@ -3,7 +3,6 @@
 import Combinator from "../combinator";
 
 import { define } from "../../elements";
-import { bracketedCombinatorFromNothing } from "../../utilities/instance";
 
 export default define(class BracketedCombinator extends Combinator {
   unifyStatement(statement, assignments, stated, context) {
@@ -23,10 +22,4 @@ export default define(class BracketedCombinator extends Combinator {
   }
 
   static name = "BracketedCombinator";
-
-  static fromNothing() {
-    const bracketedCombinator = bracketedCombinatorFromNothing();
-
-    return bracketedCombinator;
-  }
 });

package/src/element/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Element from "../element";
-import TemporaryContext from "../context/temporary";
+import TransientContext from "../context/transient";
 
 import { define } from "../elements";
 import { termsFromJSON, framesFromJSON, statementFromJSON, termsToTermsJSON, framesToFramesJSON, statementToStatementJSON } from "../utilities/json";
@@ -20,9 +20,9 @@ export  default define(class Conclusion extends Element {
   verify(context) {
     let verifies = false;
 
-    const temporaryContext = TemporaryContext.fromNothing(context);
+    const transientContext = TransientContext.fromNothing(context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const node = this.getNode(),
           conclusionString = this.getString();  ///
@@ -53,14 +53,18 @@ export  default define(class Conclusion extends Element {
   unifyStatement(statement, substitutions, context) {
     let statementUnifies;
 
-    const conclusion = this,  ///
-          statementString = statement.getString(),
-          conclusionString = conclusion.getString();
+    const statementString = statement.getString(),
+          conclusionString = this.getString();  ///
 
     context.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
 
-    const generalContext = this.context,  ///
-          specificContext = context;  ///
+    const specificContext = context;  ///
+
+    context = this.getContext();
+
+    const generalContext = context;  ///
+
+    context = specificContext;  ///
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
@@ -105,9 +109,9 @@ export  default define(class Conclusion extends Element {
           statement = statementFromJSON(json, context),
           node = null,
           string = statement.getString(),
-          temporaryContext = TemporaryContext.fromTermsAndFrames(terms, frames, context);
+          transientContext = TransientContext.fromTermsAndFrames(terms, frames, context);
 
-    context = temporaryContext; ///
+    context = transientContext; ///
 
     const conclusion = new Conclusion(context, string, node, statement);
 

package/src/element/constructor/bracketed.js

@@ -4,7 +4,6 @@ import elements from "../../elements";
 import Constructor from "../constructor";
 
 import { define } from "../../elements";
-import { bracketedConstructorFromNothing } from "../../utilities/instance";
 
 export default define(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
@@ -53,10 +52,4 @@ export default define(class BracketedConstructor extends Constructor {
   }
 
   static name = "BracketedConstructor";
-
-  static fromNothing() {
-    const bracketedConstructor = bracketedConstructorFromNothing();
-
-    return bracketedConstructor;
-  }
 });

package/src/element/declaration/combinator.js

@@ -3,7 +3,6 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { verifyStatement } from "../../process/verify";
 
 export default define(class CombinatorDeclaration extends Declaration {
   constructor(context, string, node, combinator) {

package/src/element/declaration/metavariable.js

@@ -76,7 +76,7 @@ export default define(class MetavariableDeclaration extends Declaration {
           context = this.getContext(),
           metavariableString = metavariable.getString();
 
-    context.trace(`Verifying the '${metavariableString}' metavariable when declared...`, node);
+    context.trace(`Verifying the '${metavariableString}' metavariable...`, node);
 
     const metavariableNode = metavariable.getNode(), ///
           termNode = metavariableNode.getTermNode();
@@ -98,7 +98,7 @@ export default define(class MetavariableDeclaration extends Declaration {
     }
 
     if (metavariableVerifies) {
-      context.debug(`...verified the '${metavariableString}' metavariable when declared.`, node);
+      context.debug(`...verified the '${metavariableString}' metavariable.`, node);
     }
 
     return metavariableVerifies;

package/src/element/declaration/variable.js

@@ -65,7 +65,7 @@ export default define(class VariableDeclaration extends Declaration {
       context.debug(`...verified the '${variableString}' variable.`, node);
     }
 
-    return  variableVerifies;
+    return variableVerifies;
   }
 
   verifyVariableType() {
@@ -82,7 +82,9 @@ export default define(class VariableDeclaration extends Declaration {
 
     context.trace(`Verifying the '${typeString}' type...`, node);
 
-    const nominalTypeName = type.getNominalTypeName();
+    const includeSupertypes = false,
+          provisional = type.isProvisional(includeSupertypes),
+          nominalTypeName = type.getNominalTypeName();
 
     type = context.findTypeByNominalTypeName(nominalTypeName);
 
@@ -91,9 +93,7 @@ export default define(class VariableDeclaration extends Declaration {
     if (!typePresent) {
       context.debug(`The '${typeString}' type is not present.`, node);
     } else {
-      const includeSupertypes = false,
-            provisional = type.isProvisional(includeSupertypes),
-            typeComparesToProvisional = type.compareProvisional(provisional);
+      const typeComparesToProvisional = type.compareProvisional(provisional);
 
       if (!typeComparesToProvisional) {
         provisional ?