occam-verify-cli 0.0.526 → 0.0.529

package/src/node/statement/bracketed.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { statementNodeFromStatementString } from "../../utilities/node";
+
+const bracketedStatementString = "(n=m)";
+
+const bracketedStatementNode = statementNodeFromStatementString(bracketedStatementString);
+
+export default bracketedStatementNode;

package/src/node/statement/combinator/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { STATEMENT_META_TYPE_NAME } from "../../../metaTypeNames";
+import { statementNodeFromStatementString } from "../../../utilities/node";
+
+const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
+
+const bracketedCombinatorStatementNode = statementNodeFromStatementString(bracketedCombinatorStatementString);
+
+export default bracketedCombinatorStatementNode;

package/src/node/statement/combinator/equality.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { OBJECT_TYPE_NAME } from "../../../typeNames";
+import { statementNodeFromStatementString } from "../../../utilities/node";
+
+const equalityCombinatorStatementString = `${OBJECT_TYPE_NAME} = ${OBJECT_TYPE_NAME}`;
+
+const equalityCombinatorStatementNode = statementNodeFromStatementString(equalityCombinatorStatementString);
+
+export default equalityCombinatorStatementNode;
+

package/src/node/statement/equality.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { statementNodeFromStatementString } from "../../utilities/node";
+
+const equalityStatementString = "n=m";
+
+const equalityStatementNode = statementNodeFromStatementString(equalityStatementString);
+
+export default equalityStatementNode;
+

package/src/ocmbinator/bracketed.js

@@ -1,15 +1,12 @@
 "use strict";
 
 import Combinator from "../combinator";
-import combinatorReleaseContext from "../context/release/combinator";
 
-import { statementNodeFromStatementString } from "../utilities/string";
+import bracketedCombinatorStatementNode from "../node/statement/combinator/bracketed";
 
 class BracketedCombinator extends Combinator {
   static fromNothing() {
-    const statementString = "(Statement)",
-          releaseContext = combinatorReleaseContext, ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+    const statementNode = bracketedCombinatorStatementNode,  ///
           bracketedCombinator = new BracketedCombinator(statementNode);
 
     return bracketedCombinator;

package/src/ocmbinator/equality.js

@@ -1,15 +1,12 @@
 "use strict";
 
 import Combinator from "../combinator";
-import CombinatorReleaseContext from "../context/release/combinator";
 
-import { statementNodeFromStatementString } from "../utilities/string";
+import equalityCombinatorStatementNode from "../node/statement/combinator/equality";
 
 class EqualityCombinator extends Combinator {
   static fromNothing() {
-    const statementString = "Object = Object",
-          releaseContext = CombinatorReleaseContext, ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+    const statementNode = equalityCombinatorStatementNode,  ///
           equalityCombinator = new EqualityCombinator(statementNode);
 
     return equalityCombinator;

package/src/premise.js

@@ -2,9 +2,9 @@
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { premiseStatementForMetavariableMatcher } from "./matcher/statementForMetavariable/premise";
-import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { premiseMetastatementForMetavariableMatcher } from "./matcher/metastatementForMetavariable/premise";
+import { premiseStatementForMetavariableVerifier } from "./verifier/statementForMetavariable/premise";
+import { metastatementNodeFromMetastatementString } from "./utilities/node";
+import { premiseMetastatementForMetavariableVerifier } from "./verifier/metastatementForMetavariable/premise";
 
 const ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
       ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
@@ -34,16 +34,16 @@ export default class Premise {
               ...subproofSuppositionStatementNodes,
               subproofSubDerivationLastStatementNode
             ],
-            ruleSubproofAssertionMetaSubproofStatementNodes = ruleSubproofAssertionMetaSubproofStatementNodesQuery(subproofAssertionNode),
+            ruleSubproofAssertionMetastatementNodes = ruleSubproofAssertionMetastatementNodesQuery(subproofAssertionNode),
             subproofStatementNodesLength = subproofStatementNodes.length,
-            ruleSubproofAssertionMetaSubproofStatementNodesLength = ruleSubproofAssertionMetaSubproofStatementNodes.length;
+            ruleSubproofAssertionMetastatementNodesLength = ruleSubproofAssertionMetastatementNodes.length;
 
-      if (subproofStatementNodesLength === ruleSubproofAssertionMetaSubproofStatementNodesLength) {
-        subproofNodeMatches = ruleSubproofAssertionMetaSubproofStatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
+      if (subproofStatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
+        subproofNodeMatches = ruleSubproofAssertionMetastatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeMatches = premiseStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                nonTerminalNodeMatches = premiseStatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
           if (nonTerminalNodeMatches) {
             return true;
@@ -58,7 +58,7 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = premiseStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = premiseStatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
@@ -85,7 +85,7 @@ export default class Premise {
                                     const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
                                           nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                                           nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                                          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                                          nonTerminalNodeMatches = premiseMetastatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
                                     if (nonTerminalNodeMatches) {
                                       return true;
@@ -100,7 +100,7 @@ export default class Premise {
   matchMetastatementNode(metastatementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          nonTerminalNodeMatches = premiseMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = premiseMetastatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           metastatementNodeMatches = nonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
@@ -116,10 +116,10 @@ export default class Premise {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { metastatement } = json,
           metastatementString = metastatement,  ///
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, releaseContext),
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           premise = new Premise(metastatementNode);
 
     return premise;

package/src/rule.js

@@ -134,7 +134,7 @@ export default class Rule {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     let rule;
 
     let { labels } = json;
@@ -143,7 +143,7 @@ export default class Rule {
 
     labels = labelsJSON.map((labelJSON) => {
       const json = labelJSON, ///
-            label = Label.fromJSON(json, releaseContext);
+            label = Label.fromJSON(json, lexer, parser);
 
       return label;
     });
@@ -154,7 +154,7 @@ export default class Rule {
 
     premises = premisesJSON.map((premiseJSON) => {
       const json = premiseJSON, ///
-            premise = Premise.fromJSON(json, releaseContext);
+            premise = Premise.fromJSON(json, lexer, parser);
 
       return premise;
     });
@@ -165,7 +165,7 @@ export default class Rule {
 
     json = conclusionJSON;  ///
 
-    conclusion = Conclusion.fromJSON(json, releaseContext);
+    conclusion = Conclusion.fromJSON(json, lexer, parser);
 
     rule = new Rule(labels, premises, conclusion);
 

package/src/ruleNames.js

@@ -5,9 +5,7 @@ export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
-export const VARIABLE_RULE_NAME = "variable";
 export const STATEMENT_RULE_NAME = "statement";
-export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";

package/src/step/metaproof.js

@@ -2,7 +2,7 @@
 
 import { first, second } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
-import { matchBracketedNonTerminalNode } from "../utilities/substitution";
+import { matchMetastatementModuloBrackets } from "../utilities/metaproof";
 
 const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement"),
       ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion"),
@@ -22,41 +22,44 @@ export default class MetaproofStep {
     return this.metastatementNode;
   }
 
-  matchMetastatement(metastatementNode) {
-    let metastatementMatches;
+  match(metastatementNode) {
+    let matches = false;
 
-    const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(metastatementNode);
+    if (!matches) {
+      const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(metastatementNode);
 
-    if (ruleSubproofAssertionNode !== null) {
-      const ruleSubproofAssertionMatches = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
+      if (ruleSubproofAssertionNode !== null) {
+        const matchesRuleSubproofAssertion = this.matchRuleSubproofAssertion(ruleSubproofAssertionNode);
 
-      metastatementMatches = ruleSubproofAssertionMatches;  ///
-    } else {
-      const metastatementsMatch = this.matchMetastatements(metastatementNode);
+        matches = matchesRuleSubproofAssertion;  ///
+      }
+    }
 
-      metastatementMatches = metastatementsMatch; //
+    if (!matches) {
+      const matchesMetastatement = this.matchMetastatement(metastatementNode);
+
+      matches = matchesMetastatement; ///
     }
 
-    return metastatementMatches;
+    return matches;
   }
 
-  matchMetastatements(metastatementNode) {
-    let metastatementsMatch = false;
+  matchMetastatement(metastatementNode) {
+    let matchesMetastatement = false;
 
     if (this.metastatementNode !== null) {
-      const nonTerminalNodeA = metastatementNode, ///
-            nonTerminalNodeB = this.metastatementNode,  ///
-            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB),
-            metastatementNodeMatches = bracketedNodeMatches;  ///
+      const metastatementNodeA = metastatementNode, ///
+            metastatementNodeB = this.metastatementNode,  ///
+            metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-      return metastatementNodeMatches;
+      matchesMetastatement = metastatementMatchesModuloBrackets;  ///
     }
 
-    return metastatementsMatch;
+    return matchesMetastatement;
   }
 
   matchRuleSubproofAssertion(ruleSubproofAssertionNode) {
-    let ruleSubproofAssertionMatches = false;
+    let matchesRuleSubproofAssertion = false;
 
     if (this.ruleSubproofNode !== null) {
       const ruleSubproofAssertionMetastatementNodes = metastatementNodesQuery(ruleSubproofAssertionNode),
@@ -64,23 +67,23 @@ export default class MetaproofStep {
             qualifiedOrUnqualifiedMetastatementMetastatementNodes = qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery(this.ruleSubproofNode),
             firstQualifiedOrUnqualifiedMetastatementMetastatementNode = first(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-      const nonTerminalNodeA = firstRuleSubproofAssertionMetastatementNode,  ///
-            nonTerminalNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-            bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+      const metastatementNodeA = firstRuleSubproofAssertionMetastatementNode,  ///
+            metastatementNodeB = firstQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+            metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-      if (bracketedNodeMatches) {
+      if (metastatementMatchesModuloBrackets) {
         const secondRuleSubproofAssertionMetastatementNode = second(ruleSubproofAssertionMetastatementNodes),
               secondQualifiedOrUnqualifiedMetastatementMetastatementNode = second(qualifiedOrUnqualifiedMetastatementMetastatementNodes);
 
-        const nonTerminalNodeA = secondRuleSubproofAssertionMetastatementNode, ///
-              nonTerminalNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
-              bracketedNodeMatches = matchBracketedNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB);
+        const metastatementNodeA = secondRuleSubproofAssertionMetastatementNode, ///
+              metastatementNodeB = secondQualifiedOrUnqualifiedMetastatementMetastatementNode, ///
+              metastatementMatchesModuloBrackets = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB);
 
-        ruleSubproofAssertionMatches = bracketedNodeMatches; ///
+        matchesRuleSubproofAssertion = metastatementMatchesModuloBrackets; ///
       }
     }
 
-    return ruleSubproofAssertionMatches;
+    return matchesRuleSubproofAssertion;
   }
 
   static fromRuleSubproofNode(ruleSubproofNode) {

package/src/step/proof.js

@@ -1,5 +1,8 @@
 "use strict";
 
+import { META_ARGUMENT_RULE_NAME } from "../ruleNames";
+import { matchStatementModuloBrackets } from "../utilities/proof";
+
 export default class ProofStep {
   constructor(subproofNode, statementNode) {
     this.subproofNode = subproofNode;
@@ -14,6 +17,31 @@ export default class ProofStep {
     return this.statementNode;
   }
 
+  match(statementNode) {
+    let matches;
+
+    const matchesStatement = this.matchStatement(statementNode);
+
+    matches = matchesStatement; //
+
+    return matches;
+  }
+
+  matchStatement(statementNode) {
+    let matchesStatement = false;
+
+    if (this.statementNode !== null) {
+      const ruleName = META_ARGUMENT_RULE_NAME,
+            statementNodeA = statementNode, ///
+            statementNodeB = this.statementNode,  ///
+            statementMatchesModuloBrackets = matchStatementModuloBrackets(statementNodeA, statementNodeB, ruleName);
+
+      matchesStatement = statementMatchesModuloBrackets;  ///
+    }
+
+    return matchesStatement;
+  }
+
   static fromSubproofNode(subproofNode) {
     const statementNode = null,
           metaProofStep = new ProofStep(subproofNode, statementNode);

package/src/substitution/metastatementForMetavariable.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import { matcher } from "../matcher";
-import { METASTATEMENT_RULE_NAME } from "../ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+import matcher from "../matcher";
+
+import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/metaproof";
 
 export default class MetastatementForMetavariableSubstitution {
   constructor(metavariableName, metastatementNode) {
@@ -28,14 +28,11 @@ export default class MetastatementForMetavariableSubstitution {
     matchesMetastatementNode = nodeMatches;  ///
 
     if (!matchesMetastatementNode) {
-      const nonTerminalNode = metastatementNode,  ///
-            childNodes = nonTerminalNode.getChildNodes(), ///
-            ruleName = METASTATEMENT_RULE_NAME;
-
-      metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+      const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
-      if (metastatementNode !== null) {
-        const nodeA = this.metastatementNode,  ///
+      if (bracketedMetastatementChildNode !== null) {
+        const metastatementNode = bracketedMetastatementChildNode, ///
+              nodeA = this.metastatementNode,  ///
               nodeB = metastatementNode,
               nodeMatches = matcher.matchNode(nodeA, nodeB);
 
@@ -49,13 +46,11 @@ export default class MetastatementForMetavariableSubstitution {
   static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
     let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
 
-    const nonTerminalNode = metastatementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          ruleName = METASTATEMENT_RULE_NAME;
+    const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
-    metastatementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+    if (bracketedMetastatementChildNode !== null) {
+      const metastatementNode = bracketedMetastatementChildNode; ///
 
-    if (metastatementNode !== null) {
       metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
     }
 

package/src/substitution/statementForMetavariable.js

@@ -1,8 +1,8 @@
 "use strict";
 
-import { matcher } from "../matcher";
-import { STATEMENT_RULE_NAME } from "../ruleNames";
-import { bracketedNonTerminalChildNodeFromChildNodes } from "../utilities/substitution";
+import matcher from "../matcher";
+
+import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
 export default class StatementForMetavariableSubstitution {
   constructor(metavariableName, statementNode) {
@@ -28,16 +28,13 @@ export default class StatementForMetavariableSubstitution {
     matchesStatementNode = nodeMatches;  ///
 
     if (!matchesStatementNode) {
-      const nonTerminalNode = statementNode,  ///
-            childNodes = nonTerminalNode.getChildNodes(), ///
-            ruleName = STATEMENT_RULE_NAME;
-
-      statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+      const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
-      if (statementNode !== null) {
-        const nodeA = this.statementNode,  ///
+      if (bracketedStatementChildNode !== null) {
+        const statementNode = bracketedStatementChildNode, ///
+              nodeA = this.statementNode,  ///
               nodeB = statementNode,
-              nodeMatches = matchNode(nodeA, nodeB);
+              nodeMatches = matcher.matchNode(nodeA, nodeB);
 
         matchesStatementNode = nodeMatches;  ///
       }
@@ -49,13 +46,11 @@ export default class StatementForMetavariableSubstitution {
   static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
     let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
 
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(),
-          ruleName = STATEMENT_RULE_NAME;
+    const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
-    statementNode = bracketedNonTerminalChildNodeFromChildNodes(childNodes, ruleName);  ///
+    if (bracketedStatementChildNode !== null) {
+      const statementNode = bracketedStatementChildNode; ///
 
-    if (statementNode !== null) {
       statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
     }
 

package/src/substitution/termForVariable.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import matcher from "../matcher";
+
+export default class TermForVariableSubstitution {
+  constructor(variableName, termNode) {
+    this.variableName = variableName;
+    this.termNode = termNode;
+  }
+
+  getVariableName() {
+    return this.variableName;
+  }
+
+  getTermNode() {
+    return this.termNode;
+  }
+
+  matchTermNode(termNode) {
+    let matchesTermNode;
+
+    const nodeA = this.termNode,  ///
+          nodeB = termNode,
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    matchesTermNode = nodeMatches;  ///
+
+    return matchesTermNode;
+  }
+
+  static fromVariableNameAndTermNode(variableName, termNode) {
+    const termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
+
+    return termForVariableSubstitution;
+  }
+}

package/src/supposition.js

@@ -2,8 +2,8 @@
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { statementNodeFromStatementString } from "./utilities/string";
-import { suppositionStatementForVariableMatcher } from "./matcher/statementForVariable/supposition";
+import { statementNodeFromStatementString } from "./utilities/node";
+import { suppositionTermForVariableVerifier } from "./verifier/termForVariable/supposition";
 
 const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
@@ -40,7 +40,7 @@ export default class Supposition {
                                 const subproofStatementNode = subproofStatementNodes[index],
                                       nonTerminalNodeA = subproofAssertionStatementNode,  ///
                                       nonTerminalNodeB = subproofStatementNode, ///
-                                      nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                                      nonTerminalNodeMatches = suppositionTermForVariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
                                 if (nonTerminalNodeMatches) {
                                   return true;
@@ -55,7 +55,7 @@ export default class Supposition {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = suppositionStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeMatches = suppositionTermForVariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
           statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
@@ -71,10 +71,10 @@ export default class Supposition {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const { statement } = json,
           statementString = statement,  ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+          statementNode = statementNodeFromStatementString(statementString, lexer, parser),
           supposition = new Supposition(statementNode);
 
     return supposition;

package/src/theorem.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import AxiomLemmaTheorem from "./axiomLemmaTheorem";
+import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 
 import { THEOREM_KIND } from "./kinds";
 
-export default class Theorem extends AxiomLemmaTheorem {
+export default class Theorem extends AxiomLemmaTheoremConjecture {
   static kind = THEOREM_KIND;
 
-  static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Theorem, json, releaseContext); }
+  static fromJSON(json, lexer, parser) { return AxiomLemmaTheoremConjecture.fromJSON(Theorem, json, lexer, parser); }
 
-  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
+  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Theorem, labels, suppositions, consequence); }
 }

package/src/type.js

@@ -124,14 +124,14 @@ export default class Type {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     let type;
 
     let { superType } = json;
 
     const superTypeJSON = superType;  ///
 
-    superType = superTypeFromSuperTypeJSON(superTypeJSON, releaseContext);
+    superType = superTypeFromSuperTypeJSON(superTypeJSON, lexer, parser);
 
     const { name } = json;
 
@@ -181,12 +181,22 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSON(superTypeJSON, releaseContext) {
+function superTypeFromSuperTypeJSON(superTypeJSON, lexer, parser) {
+  let superType;
+
   const json = superTypeJSON, ///
-        { name } = json,
-        superType = (name === OBJECT_TYPE_NAME) ?
-          objectType :
-            Type.fromJSON(json, releaseContext);
+        { name } = json;
+
+  if (name === OBJECT_TYPE_NAME) {
+    superType = objectType; ///
+  } else {
+    const typeName = name,  ///
+          type = releaseContext.findTypeByTypeName(typeName);
+
+    superType = (type !== null) ?
+                  type :  ///
+                    Type.fromJSON(json, lexer, parser);  ///
+  }
 
   return superType;
 }