occam-verify-cli 0.0.1073 → 0.0.1075

package/src/equivalence.js

@@ -2,7 +2,6 @@
 
 import { nodeQuery } from "./utilities/query";
 import { stripBracketsFromTermNode } from "./utilities/brackets";
-import { variableNameFromVariableNode } from "./utilities/name";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
@@ -15,17 +14,18 @@ export default class Equivalence {
     return this.terms;
   }
 
-  setTerms(terms) {
-    this.terms = terms;
-  }
+  addTerm(term, localContext) {
+    const termString = term.getString(),
+          equivalenceString = this.asString();  ///
+
+    localContext.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence.`);
 
-  addTerm(term) {
     this.terms.push(term);
   }
 
-  getType(localContext) {
+  getType() {
     const type = this.terms.reduce((type, term) => {
-      const termType = termTypeFromTerm(term, localContext);
+      const termType = term.getType();
 
       if (type === null) {
         type = termType;  ///
@@ -43,10 +43,10 @@ export default class Equivalence {
     return type;
   }
 
-  matchType(type, localContext) {
+  matchType(type) {
     const typeA = type; ///
 
-    type = this.getType(localContext);
+    type = this.getType();
 
     const typeB = type; ///
 
@@ -198,6 +198,27 @@ export default class Equivalence {
     return implicitlyGroundedTerms;
   }
 
+  asString() {
+    let string;
+
+    string = this.terms.reduce((string, term) => {
+      const termString = term.getString();
+
+      string = (string === null) ?
+                 termString :
+                    `${string} ${termString}`;
+
+      return string;
+    }, null);
+
+    const type = this.getType(),
+          typeString = type.getString();
+
+    string = `${string}:${typeString}`;
+
+    return string;
+  }
+
   static merge(leftEquivalence, rightEquivalence) {
     const leftEquivalenceTerms = leftEquivalence.getTerms(),
           rightEquivalenceTerms = rightEquivalence.getTerms(),
@@ -220,22 +241,3 @@ export default class Equivalence {
     return equivalence;
   }
 }
-
-function termTypeFromTerm(term, localContext) {
-  let termType;
-
-  const termNode = term.getNode(),
-        variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    const variableName = variableNameFromVariableNode(variableNode),
-          variable = localContext.findVariableByVariableName(variableName),
-          variableType = variable.getType();
-
-    termType = variableType;  ///
-  } else {
-    termType = term.getType();
-  }
-
-  return termType;
-}

package/src/frame.js

@@ -3,8 +3,6 @@
 import { arrayUtilities } from "necessary";
 
 import shim from "./shim";
-import Declaration from "./declaration";
-import Metavariable from "./metavariable";
 
 import { FRAME_META_TYPE_NAME } from "./metaTypeNames";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -76,16 +74,16 @@ class Frame {
     return frameNodeMatches;
   }
 
-  matchMetavariableName(metavariableName) {
-    let metavariableNameMatches = false;
+  matchMetavariableNode(metavariableNode) {
+    let metavariableNodeMatches = false;
 
     const metavariable = this.getMetavariable();
 
     if (metavariable !== null) {
-      metavariableNameMatches = metavariable.matchMetavariableName(metavariableName);
+      metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);
     }
 
-    return metavariableNameMatches;
+    return metavariableNodeMatches;
   }
 
   unifySubstitution(substitution, localContext) {
@@ -259,7 +257,8 @@ class Frame {
     let frame = null;
 
     if (frameNode !== null) {
-      const declarationNodes = declarationNodesQuery(frameNode),
+      const { Declaration, Metavariable } = shim,
+            declarationNodes = declarationNodesQuery(frameNode),
             metavariableNodes = metavariableNodesQuery(frameNode),
             declarations = declarationNodes.map((declarationNode) => {
               const declaration = Declaration.fromDeclarationNode(declarationNode, localContext);
@@ -289,7 +288,8 @@ class Frame {
       const metavariableNode = metavariableNodeQuery(frameNode);
 
       if (metavariableNode !== null) {
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+        const { Metavariable } = shim,
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
               declarations = [],
               metavariables = [
                 metavariable
@@ -313,7 +313,8 @@ class Frame {
       const metavariableNode = metavariableNodeQuery(frameNode);
 
       if (metavariableNode !== null) {
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+        const { Metavariable } = shim,
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
               declarations = [],
               metavariables = [
                 metavariable

package/src/index.js

@@ -6,20 +6,32 @@ import Rule from "./rule";
 import Label from "./label";
 import Axiom from "./axiom";
 import Lemma from "./lemma";
+import Frame from "./frame";
+import Proof from "./proof";
 import Premise from "./premise";
 import Theorem from "./theorem";
+import Equality from "./equality";
 import MetaType from "./metaType";
+import Subproof from "./subproof";
 import Variable from "./variable";
 import Statement from "./statement";
 import ProofStep from "./proofStep";
+import Judgement from "./judgement";
+import MetaLemma from "./metaLemma";
 import Consequent from "./consequent";
 import Conjecture from "./conjecture";
 import Combinator from "./combinator";
 import Conclusion from "./conclusion";
+import Derivation from "./derivation";
+import Declaration from "./declaration";
 import Constructor from "./constructor";
 import Supposition from "./supposition";
 import Metatheorem from "./metatheorem";
 import Metavariable from "./metavariable";
+import Substitution from "./substitution";
+import Substitutions from "./substitutions";
+import SubDerivation from "./subDerivation";
+import QualifiedStatement from "./statement/qualified";
 import UnqualifiedStatement from "./statement/unqualified";
 
 export { default as Log } from "./log";

package/src/judgement.js

@@ -1,7 +1,6 @@
 "use strict";
 
-import Frame from "./frame";
-import Declaration from "./declaration";
+import shim from "./shim";
 import JudgementAssignment from "./assignment/judgement";
 
 import { nodeQuery } from "./utilities/query";
@@ -9,7 +8,7 @@ import { nodeQuery } from "./utilities/query";
 const frameNodeQuery = nodeQuery("/judgement/frame"),
       declarationNodeQuery = nodeQuery("/judgement/declaration");
 
-export default class Judgement {
+class Judgement {
   constructor(string, frame, declaration) {
     this.string = string;
     this.frame = frame;
@@ -30,7 +29,7 @@ export default class Judgement {
 
   getMetavariableNode() { return this.frame.getMetavariableNode(); }
 
-  matchMetavariableName(metavariableName) { return this.frame.matchMetavariableName(metavariableName); }
+  matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
 
   verify(assignments, stated, localContext) {
     let verified;
@@ -117,7 +116,8 @@ export default class Judgement {
     let judgement = null;
 
     if (judgementNode !== null) {
-      const frameNode = frameNodeQuery(judgementNode),
+      const { Frame, Declaration } = shim,
+            frameNode = frameNodeQuery(judgementNode),
             declarationNode = declarationNodeQuery(judgementNode),
             node = judgementNode, ///
             string = localContext.nodeAsString(node),
@@ -130,3 +130,9 @@ export default class Judgement {
     return judgement;
   }
 }
+
+Object.assign(shim, {
+  Judgement
+});
+
+export default Judgement;

package/src/label.js

@@ -2,7 +2,6 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import Metavariable from "./metavariable";
 
 import { nodeQuery } from "./utilities/query";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
@@ -22,12 +21,12 @@ class Label {
 
   matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;
 
     const labelString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${labelString}' label at top level...`);
+    fileContext.trace(`Verifying the '${labelString}' label when declared...`);
 
     const metavariableNode = this.metavariable.getNode(),
           labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
@@ -39,7 +38,7 @@ class Label {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${labelString}' label at top level.`);
+      fileContext.debug(`...verified the '${labelString}' label when declared.`);
     }
 
     return verifiedAtTopLevel;
@@ -63,7 +62,8 @@ class Label {
   }
 
   static fromLabelNode(labelNode, fileContext) {
-    const metavariableNode = metavariableNodeQuery(labelNode),
+    const { Metavariable } = shim,
+          metavariableNode = metavariableNodeQuery(labelNode),
           localContext = LocalContext.fromFileContext(fileContext),
           metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           label = new Label(metavariable);

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);