occam-verify-cli 0.0.1074 → 0.0.1075

package/src/lemma.js

@@ -1,12 +1,7 @@
 "use strict";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { EMPTY_STRING } from "./constants";
@@ -28,15 +23,15 @@ class Lemma extends TopLevelAssertion {
       this.fileContext.trace(`Verifying a lemma...`) :
         this.fileContext.trace(`Verifying the '${lemmaString}' lemma...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             suppositionsVerified = this.suppositions.every((supposition) => {
               const suppositionVerified = supposition.verify(localContext);
@@ -50,7 +45,8 @@ class Lemma extends TopLevelAssertion {
         const consequentVerified = this.consequent.verify(localContext);
 
         if (consequentVerified) {
-          const substitutions = Substitutions.fromNothing(),
+          const { Substitutions } = shim,
+                substitutions = Substitutions.fromNothing(),
                 proofVerified = this.proof.verify(substitutions, this.consequent, localContext);
 
           if (proofVerified) {
@@ -74,7 +70,8 @@ class Lemma extends TopLevelAssertion {
   }
 
   static fromLemmaNode(lemmaNode, fileContext) {
-    const proofNode = proofNodeQuery(lemmaNode),
+    const { Label, Proof, Supposition, Consequent } = shim,
+          proofNode = proofNodeQuery(lemmaNode),
           labelNodes = labelNodesQuery(lemmaNode),
           consequentNode = consequentNodeQuery(lemmaNode),
           suppositionNodes = suppositionNodesQuery(lemmaNode),

package/src/metaLemma.js

@@ -1,11 +1,7 @@
 "use strict";
 
-import Label from "./label";
-import Proof from "./proof";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
+import shim from "./shim";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { EMPTY_STRING } from "./constants";
@@ -17,7 +13,7 @@ const proofNodeQuery = nodeQuery("/metaLemma/proof"),
       consequentNodeQuery = nodeQuery("/metaLemma/consequent"),
       suppositionNodesQuery = nodesQuery("/metaLemma/supposition");
 
-export default class MetaLemma extends TopLevelAssertion {
+class MetaLemma extends TopLevelAssertion {
   constructor(fileContext, string, labels, suppositions, consequent, proof, substitutions) {
     super(fileContext, string, labels, suppositions, consequent, proof);
 
@@ -37,15 +33,15 @@ export default class MetaLemma extends TopLevelAssertion {
       this.fileContext.trace(`Verifying a meta-lemma...`) :
         this.fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             suppositionsVerified = this.suppositions.every((supposition) => {
               const suppositionVerified = supposition.verify(localContext);
@@ -82,7 +78,8 @@ export default class MetaLemma extends TopLevelAssertion {
   }
 
   static fromMetaLemmaNode(metaLemmaNode, fileContext) {
-    const proofNode = proofNodeQuery(metaLemmaNode),
+    const { Label, Proof, Consequent, Supposition, Substitutions } = shim,
+          proofNode = proofNodeQuery(metaLemmaNode),
           labelNodes = labelNodesQuery(metaLemmaNode),
           consequentNode = consequentNodeQuery(metaLemmaNode),
           suppositionNodes = suppositionNodesQuery(metaLemmaNode),
@@ -106,3 +103,8 @@ export default class MetaLemma extends TopLevelAssertion {
   }
 }
 
+Object.assign(shim, {
+  MetaLemma
+});
+
+export default MetaLemma;

package/src/metatheorem.js

@@ -1,12 +1,7 @@
 "use strict";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -43,15 +38,15 @@ class Metatheorem extends TopLevelAssertion {
 
     this.fileContext.trace(`Verifying the '${metatheoremString}' metatheorem...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             suppositionsVerified = this.suppositions.every((supposition) => {
               const suppositionVerified = supposition.verify(localContext);
@@ -117,7 +112,8 @@ class Metatheorem extends TopLevelAssertion {
   }
 
   static fromMetatheoremNode(metatheoremNode, fileContext) {
-    const proofNode = proofNodeQuery(metatheoremNode),
+    const { Label, Proof, Consequent, Supposition, Substitutions } = shim,
+          proofNode = proofNodeQuery(metatheoremNode),
           labelNodes = labelNodesQuery(metatheoremNode),
           consequentNode = consequentNodeQuery(metatheoremNode),
           suppositionNodes = suppositionNodesQuery(metatheoremNode),

package/src/metavariable.js

@@ -2,7 +2,6 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import metavariableUnifier from "./unifier/metavariable";
 import FrameForMetavariableSubstitution from "./substitution/frameForMetavariable";
 import StatementForMetavariableSubstitution from "./substitution/statementForMetavariable";
 
@@ -80,11 +79,11 @@ class Metavariable {
 
     localContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const metavariableName = this.name, ///
-          simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
+    const metavariableNode = this.node, ///
+          simpleSubstitutionPresent = substitutions.isSimpleSubstitutionPresentByMetavariableNode(metavariableNode);
 
     if (simpleSubstitutionPresent) {
-      const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName),
+      const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode),
             substitution = simpleSubstitution,  ///
             frameNodeMatches = substitution.matchFrameNode(frameNode);
 
@@ -131,14 +130,13 @@ class Metavariable {
 
     const statementNode = statement.getNode(),
           metavariableNode = this.node, ///
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
           substitutionNode = (substitution !== null) ?
                                 substitution.getSubstitutionNode() :
                                   null,
-          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode);
+          substitutionPresent = substitutions.isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
     if (substitutionPresent) {
-      const substitution = substitutions.findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode),
+      const substitution = substitutions.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
             statementNodeMatches = substitution.matchStatementNode(statementNode);
 
       if (statementNodeMatches) {
@@ -180,8 +178,8 @@ class Metavariable {
 
     localContext.trace(`Unifying the '${substitutionString}' substitution with the '${metavariableString}' metavariable...`);
 
-    const metavariableName = this.name, ///
-          judgement = localContext.findJudgementByMetavariableName(metavariableName);
+    const metavariableNode = this.node, ///
+          judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
     if (judgement !== null){
       const declaration = judgement.getDeclaration();
@@ -203,18 +201,10 @@ class Metavariable {
 
     localContext.trace(`Verifying the '${metavariableString}' metavariable...`);
 
-    const metavariableName = this.name,
-          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-    if (metavariable !== null) {
-      const metavariableA = metavariable, ///
-            metavariableB = this,
-            metavariableNodeA = metavariableA.getNode(), ///
-            metavariableNodeB = metavariableB.getNode(),
-            metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+    const metavariableNode = this.node,
+          metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
 
-      verified = metavariableUnified; ///
-    }
+    verified = metavariablePresent; ///
 
     if (verified) {
       localContext.debug(`...verified the '${metavariableString}' metavariable.`);
@@ -223,12 +213,12 @@ class Metavariable {
     return verified;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;
 
     const metavariableString = this.string; ///
 
-    fileContext.trace(`Verifying the '${metavariableString}' metavariable at top level...`);
+    fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
 
     const metavariableNode = this.node, ///
           metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
@@ -262,7 +252,7 @@ class Metavariable {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${metavariableString}' metavariable at top level.`);
+      fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
     }
 
     return verifiedAtTopLevel;
@@ -276,9 +266,8 @@ class Metavariable {
 
     localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeString}' meta-type...`);
 
-    const name = this.getName(),
-          metavariableName = name,  ///
-          metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+    const metavariableNode = this.node,  ///
+          metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
 
     if (metavariable !== null) {
       const metaTypeMatches = metavariable.matchMetaType(metaType);
@@ -360,8 +349,7 @@ Object.assign(shim, {
 export default Metavariable;
 
 function metavariableFromMetavariableNode(metavariableNode, localContext) {
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
+  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode, localContext);
 
   return metavariable;
 }
@@ -372,9 +360,7 @@ function frameMetavariableFromStatementNode(frameNode, localContext) {
   const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
 
   if (frameMetavariableNode !== null) {
-    const frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode);
-
-    frameMetavariable = localContext.findMetavariableByMetavariableName(frameMetavariableName);
+    frameMetavariable = localContext.findMetavariableByMetavariableNode(frameMetavariableNode, localContext);
   }
 
   return frameMetavariable;
@@ -386,9 +372,7 @@ function statementMetavariableFromStatementNode(statementNode, localContext) {
   const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
   if (statementMetavariableNode !== null) {
-    const statementMetavariableName = metavariableNameFromMetavariableNode(statementMetavariableNode);
-
-    statementMetavariable = localContext.findMetavariableByMetavariableName(statementMetavariableName);
+    statementMetavariable = localContext.findMetavariableByMetavariableNode(statementMetavariableNode, localContext);
   }
 
   return statementMetavariable;

package/src/mixins/statement/qualified/unify.js

@@ -135,8 +135,7 @@ function unifyAWithReference(qualifiedStatement, substitutions, localContext) {
 
   const reference = qualifiedStatement.getReference(),
         metavariableNode = reference.getMetavariableNode(),
-        metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableName(metavariableName);
+        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext);
 
   if (metavariablePresent) {
     const statement = qualifiedStatement.getStatement(),

package/src/mixins/statement/verify.js

@@ -1,10 +1,6 @@
 "use strict";
 
-import Frame from "../../frame";
-import Equality from "../../equality";
-import Judgement from "../../judgement";
-import Declaration from "../../declaration";
-import Metavariable from "../../metavariable";
+import shim from "../../shim";
 import TypeAssertion from "../../assertion/type";
 import DefinedAssertion from "../../assertion/defined";
 import SubproofAssertion from "../../assertion/subproof";
@@ -12,20 +8,21 @@ import ContainedAssertion from "../../assertion/contained";
 
 import { nodeQuery } from "../../utilities/query";
 
-const frameNodeQuery = nodeQuery("/statement/frame!"),
-      equalityNodeQuery = nodeQuery("/statement/equality!"),
-      judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      declarationNodeQuery = nodeQuery("/statement/declaration!"),
+const frameNodeQuery = nodeQuery("/statement/frame"),
+      equalityNodeQuery = nodeQuery("/statement/equality"),
+      judgementNodeQuery = nodeQuery("/statement/judgement"),
+      declarationNodeQuery = nodeQuery("/statement/declaration"),
       metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
-      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
-      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion"),
+      definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion"),
+      subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion"),
+      containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion");
 
 function verifyAsMetavariable(statement, assignments, stated, localContext) {
   let verifiedAsMetavariable = false;
 
-  const statementNode = statement.getNode(),
+  const { Metavariable } = shim,
+        statementNode = statement.getNode(),
         metavariableNode = metavariableNodeQuery(statementNode),
         metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext);
 
@@ -49,7 +46,8 @@ function verifyAsMetavariable(statement, assignments, stated, localContext) {
 function verifyAsEquality(statement, assignments, stated, localContext) {
   let verifiedAsEquality = false;
 
-  const statementNode = statement.getNode(),
+  const { Equality } = shim,
+        statementNode = statement.getNode(),
         equalityNode = equalityNodeQuery(statementNode),
         equality = Equality.fromEqualityNode(equalityNode, localContext);
 
@@ -73,7 +71,8 @@ function verifyAsEquality(statement, assignments, stated, localContext) {
 function verifyAsFrame(statement, assignments, stated, localContext) {
   let verifiedAsFrame = false;
 
-  const statementNode = statement.getNode(),
+  const { Frame } = shim,
+        statementNode = statement.getNode(),
         frameNode = frameNodeQuery(statementNode),
         frame = Frame.fromFrameNode(frameNode, localContext);
 
@@ -97,7 +96,8 @@ function verifyAsFrame(statement, assignments, stated, localContext) {
 function verifyAsJudgement(statement, assignments, stated, localContext) {
   let verifiedAsJudgement = false;
 
-  const statementNode = statement.getNode(),
+  const { Judgement } = shim,
+        statementNode = statement.getNode(),
         judgementNode = judgementNodeQuery(statementNode),
         judgement = Judgement.fromJudgementNode(judgementNode, localContext);
 
@@ -121,7 +121,8 @@ function verifyAsJudgement(statement, assignments, stated, localContext) {
 function verifyAsDeclaration(statement, assignments, stated, localContext) {
   let verifiedAsDeclaration = false;
 
-  const statementNode = statement.getNode(),
+  const { Declaration } = shim,
+        statementNode = statement.getNode(),
         declarationNode = declarationNodeQuery(statementNode),
         declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
 

package/src/mixins/term/verify.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Variable from "../../variable";
+import shim from "../../shim";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -9,7 +9,8 @@ const variableNodeQuery = nodeQuery("/term/variable!");
 function verifyTermAsVariable(term, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;
 
-  const termNode = term.getNode(),
+  const { Variable } = shim,
+        termNode = term.getNode(),
         variableNode = variableNodeQuery(termNode),
         variable = Variable.fromVariableNode(variableNode, localContext);
 

package/src/premise.js

@@ -3,7 +3,6 @@
 import shim from "./shim";
 import LocalContext from "./context/local";
 import SubproofAssertion from "./assertion/subproof";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
@@ -162,7 +161,8 @@ class Premise {
   }
 
   static fromPremiseNode(suppositionNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+    const { UnqualifiedStatement } = shim,
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           premise = new Premise(fileContext, unqualifiedStatement);
 

package/src/proof.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import Derivation from "./derivation";
+import shim from "./shim";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation");
 
-export default class Proof {
+class Proof {
   constructor(derivation) {
     this.derivation = derivation;
   }
@@ -47,7 +47,8 @@ export default class Proof {
     let proof = null;
 
     if (proofNode !== null) {
-      const derivationNode = derivationNodeQuery(proofNode),
+      const { Derivation } = shim,
+            derivationNode = derivationNodeQuery(proofNode),
             derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
 
       proof = new Proof(derivation);
@@ -56,3 +57,9 @@ export default class Proof {
     return proof;
   }
 }
+
+Object.assign(shim, {
+  Proof
+});
+
+export default Proof;

package/src/proofStep.js

@@ -1,10 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import Subproof from "./subproof";
-import Substitutions from "./substitutions";
-import QualifiedStatement from "./statement/qualified";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
@@ -49,7 +45,8 @@ class ProofStep {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const substitutions = Substitutions.fromNothing();
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing();
 
     if (this.qualifiedStatement !== null) {
       const localContextA = localContext, ///
@@ -111,7 +108,8 @@ class ProofStep {
   }
 
   static fromProofStepNode(proofStepNode, fileContext) {
-    const subproofNode = subproofNodeQuery(proofStepNode),
+    const { Subproof, QualifiedStatement, UnqualifiedStatement } = shim,
+          subproofNode = subproofNodeQuery(proofStepNode),
           qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
           unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode),
           subproof = Subproof.fromSubproofNode(subproofNode, fileContext),

package/src/reference.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Metavariable from "./metavariable";
+import shim from "./shim";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
@@ -67,7 +67,8 @@ export default class Reference {
   }
 
   static fromReferenceNode(referenceNode, fileContext) {
-    const metavariableNode = metavariableNodeQuery(referenceNode),
+    const { Metavariable } = shim,
+          metavariableNode = metavariableNodeQuery(referenceNode),
           localContext = LocalContext.fromFileContext(fileContext),
           metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           reference = new Reference(metavariable);

package/src/rule.js

@@ -3,12 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Premise from "./premise";
-import Conclusion from "./conclusion";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 
 import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -75,7 +70,8 @@ class Rule {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const proofSteps = localContext.getProofSteps(),
+    const { Substitutions } = shim,
+          proofSteps = localContext.getProofSteps(),
           substitutions = Substitutions.fromNothing(),
           proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 
@@ -125,15 +121,15 @@ class Rule {
 
     this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             premisesVerified = this.premises.every((premise) => {
               const premiseVerified = premise.verify(localContext);
@@ -150,7 +146,8 @@ class Rule {
           let proofVerified = true; ///
 
           if (this.proof !== null) {
-            const substitutions = Substitutions.fromNothing();
+            const { Substitutions } = shim,
+                  substitutions = Substitutions.fromNothing();
 
             proofVerified = this.proof.verify(substitutions, this.conclusion, localContext);
           }
@@ -204,7 +201,8 @@ class Rule {
   }
 
   static fromRuleNode(ruleNode, fileContext) {
-    const proofNode = proofNodeQuery(ruleNode),
+    const { Label, Proof, Premise, Conclusion } = shim,
+          proofNode = proofNodeQuery(ruleNode),
           labelNodes = labelNodesQuery(ruleNode),
           premiseNodes = premiseNodesQuery(ruleNode),
           conclusionNode = conclusionNodeQuery(ruleNode),

package/src/statement/qualified.js

@@ -12,7 +12,7 @@ import { assignAssignments } from "../utilities/assignments";
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement"),
       referenceNodeQuery = nodeQuery("/qualifiedStatement/reference");
 
-export default class QualifiedStatement {
+class QualifiedStatement {
   constructor(string, statement, reference) {
     this.string = string;
     this.statement = statement;
@@ -127,3 +127,9 @@ export default class QualifiedStatement {
     return qualifiedStatement;
   }
 }
+
+Object.assign(shim, {
+  QualifiedStatement
+});
+
+export default QualifiedStatement;

package/src/statement.js

@@ -171,18 +171,18 @@ class Statement {
     return verified;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const statementNode = this.node,  ///
           statementString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${statementString}' statement at top level...`);
+    fileContext.trace(`Verifying the '${statementString}' statement when declared...`);
 
     verifiedAtTopLevel = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${statementString}' statement at top level.`);
+      fileContext.debug(`...verified the '${statementString}' statement when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/subDerivation.js

@@ -10,7 +10,7 @@ const { last } = arrayUtilities;
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
 
-export default class SubDerivation {
+class SubDerivation {
   constructor(proofSteps) {
     this.proofSteps = proofSteps;
   }
@@ -52,4 +52,10 @@ export default class SubDerivation {
     return subDerivation;
 
   }
-}
+}
+
+Object.assign(shim, {
+  SubDerivation
+});
+
+export default SubDerivation;