occam-verify-cli 0.0.921 → 0.0.923

package/src/substitution.js

@@ -24,10 +24,4 @@ export default class Substitution {
 
     return matchesMetavariableNode;
   }
-
-  matchMetastatementNode(metastatementNode) {
-    const matchesMetastatementNode = false;
-
-    return matchesMetastatementNode;
-  }
 }

package/src/supposition.js

@@ -1,9 +1,18 @@
 "use strict";
 
+import LocalContext from "./context/local";
+import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
+import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { statementNodeFromStatementString } from "./utilities/node";
+import {nodeQuery, nodesQuery} from "./utilities/query";
+
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Supposition {
   constructor(statementNode) {
@@ -29,6 +38,43 @@ export default class Supposition {
     return matchesStatementNode;
   }
 
+  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
+    let matchesSubproofNode = false;
+
+    if (this.statementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
+
+      if (subproofAssertionNode !== null) {
+        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+              subproofStatementNodes = [
+                ...subproofSuppositionStatementNodes,
+                subproofLastProofStepStatementNode
+              ],
+              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
+
+        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, ruleSubproofStatementNode) => {
+          const fileContextA = fileContext, ///
+                nonTerminalNodeA = subproofAssertionStatementNode,  ///
+                nonTerminalNodeB = ruleSubproofStatementNode, ///
+                localContextA = LocalContext.fromFileContext(fileContextA),  ///
+                localContextB = localContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
+
+          if (nonTerminalNodeVerified) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return matchesSubproofNode;
+  }
+
   toJSON(tokens) {
     const statementString = nodeAsString(this.statementNode, tokens),
           statement = statementString, ///

package/src/utilities/customGrammar.js

@@ -5,11 +5,10 @@ import { CustomGrammar, CombinedCustomGrammar } from "occam-custom-grammars";
 export function customGrammarFromNameAndEntries(name, entries) {
   const termBNF = entries.getTermBNF(),
         statementBNF = entries.getStatementBNF(),
-        metastatementBNF = entries.getMetastatementBNF(),
         typePattern = entries.getTypePattern(),
         symbolPattern = entries.getSymbolPattern(),
         operatorPattern = entries.getOperatorPattern(),
-        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFMetastatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
+        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, typePattern, symbolPattern, operatorPattern);
 
   return customGrammar;
 }

package/src/utilities/match.js

@@ -1,76 +1,42 @@
 "use strict";
 
 import bracketedStatementNode from "../node/statement/bracketed";
-import bracketedMetastatementNode from "../node/metastatement/bracketed";
 
 import { nodeQuery } from "../utilities/query";
-import { BRACKETED_STATEMENT_DEPTH, BRACKETED_METASTATEMENT_DEPTH } from "../constants";
+import { BRACKETED_STATEMENT_DEPTH } from "../constants";
 
-const bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument!/statement!"),
-      bracketedMetastatementChildNodeQuery = nodeQuery("/metastatement/metastatement!");
+const bracketedStatementChildNodeQuery = nodeQuery("/statement/statement!");
 
 export function matchStatementModuloBrackets(statementNodeA, statementNodeB) {
-  let statementMatchesModuloBrackets = false;
+  let statementMatches = false;
 
-  if (!statementMatchesModuloBrackets) {
-    const statementNodeAMatchesStatementNodeB = statementNodeA.match(statementNodeB);
+  if (!statementMatches) {
+    const statementNodeMatches = statementNodeA.match(statementNodeB);
 
-    statementMatchesModuloBrackets = statementNodeAMatchesStatementNodeB;  ///
+    statementMatches = statementNodeMatches;  ///
   }
 
-  if (!statementMatchesModuloBrackets) {
+  if (!statementMatches) {
     const bracketedStatementChildNodeA = bracketedStatementChildNodeFromStatementNode(statementNodeA);
 
     if (bracketedStatementChildNodeA !== null) {
-      const bracketedStatementChildNodeAMatchStatementNodeB = bracketedStatementChildNodeA.match(statementNodeB);
+      const bracketedStatementChildNodeAMatchesStatementNodeB = bracketedStatementChildNodeA.match(statementNodeB);
 
-      statementMatchesModuloBrackets = bracketedStatementChildNodeAMatchStatementNodeB; ///
+      statementMatches = bracketedStatementChildNodeAMatchesStatementNodeB; ///
     }
   }
 
-  if (!statementMatchesModuloBrackets) {
+  if (!statementMatches) {
     const bracketedStatementChildNodeB = bracketedStatementChildNodeFromStatementNode(statementNodeB);
 
     if (bracketedStatementChildNodeB !== null) {
-      const statementNodeAMatchBracketedStatementChildNodeB = statementNodeA.match(bracketedStatementChildNodeB);
+      const statementNodeAMatchesBracketedStatementChildNodeB = statementNodeA.match(bracketedStatementChildNodeB);
 
-      statementMatchesModuloBrackets = statementNodeAMatchBracketedStatementChildNodeB; ///
+      statementMatches = statementNodeAMatchesBracketedStatementChildNodeB; ///
     }
   }
 
-  return statementMatchesModuloBrackets;
-}
-
-export function matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB) {
-  let metastatementMatches = false;
-
-  if (!metastatementMatches) {
-    const metastatementNodeMatches = metastatementNodeA.match(metastatementNodeB);
-
-    metastatementMatches = metastatementNodeMatches;  ///
-  }
-
-  if (!metastatementMatches) {
-    const bracketedMetastatementChildNodeA = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeA);
-
-    if (bracketedMetastatementChildNodeA !== null) {
-      const bracketedMetastatementChildNodeAMatchesMetastatementNodeB = bracketedMetastatementChildNodeA.match(metastatementNodeB);
-
-      metastatementMatches = bracketedMetastatementChildNodeAMatchesMetastatementNodeB; ///
-    }
-  }
-
-  if (!metastatementMatches) {
-    const bracketedMetastatementChildNodeB = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeB);
-
-    if (bracketedMetastatementChildNodeB !== null) {
-      const metastatementNodeAMatchesBracketedMetastatementChildNodeB = metastatementNodeA.match(bracketedMetastatementChildNodeB);
-
-      metastatementMatches = metastatementNodeAMatchesBracketedMetastatementChildNodeB; ///
-    }
-  }
-
-  return metastatementMatches;
+  return statementMatches;
 }
 
 export function bracketedStatementChildNodeFromStatementNode(statementNode) {
@@ -85,16 +51,3 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
 
   return bracketedStatementChildNode;
 }
-
-export function bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode) {
-  let bracketedMetastatementChildNode = null;
-
-  const depth = BRACKETED_METASTATEMENT_DEPTH,
-        metastatementNodeMatchesBracketedMetastatementNode = metastatementNode.match(bracketedMetastatementNode, depth);
-
-  if (metastatementNodeMatchesBracketedMetastatementNode) {
-    bracketedMetastatementChildNode = bracketedMetastatementChildNodeQuery(metastatementNode);
-  }
-
-  return bracketedMetastatementChildNode;
-}

package/src/utilities/node.js

@@ -7,12 +7,10 @@ import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { METAVARIABLE_RULE_NAME,
          VARIABLE_DECLARATION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
-         CONSTRUCTOR_DECLARATION_RULE_NAME,
-         UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+         CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { metavariableTokensFromMetavariableString,
          variableDeclarationTokensFromVariableString,
-         unqualifiedStatementTokensFromStatementString,
-         unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
+         unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
@@ -21,8 +19,7 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
 export function variableNodeFromVariableString(variableString, lexer, parser) {
   const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
@@ -45,13 +42,6 @@ export function metavariableNodeFromMetavariableString(metavariableString, lexer
   return metavariableNode;
 }
 
-export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
-  const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
-        metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
-
-  return metastatementNode;
-}
-
 export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   let termNode = null;
 
@@ -88,18 +78,6 @@ export function variableNodeFromVariableVariableTDeclarationTokens(variableTDecl
   return variableNode;
 }
 
-export function metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
-  let metastatementNode = null;
-
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
-
-  if (unqualifiedMetastatementNode !== null) {
-    metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-  }
-
-  return metastatementNode;
-}
-
 export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {
   const ruleName = METAVARIABLE_RULE_NAME,
         metavariableNode = nodeFromTokensRuleNameAndParser(metavariableTokens, ruleName, parser);
@@ -128,13 +106,6 @@ export function constructorDeclarationNodeFromConstructorDeclarationTokens(const
   return constructorDeclarationNode;
 }
 
-export function unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
-  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
-        unqualifiedMetastatementNode = nodeFromTokensRuleNameAndParser(unqualifiedMetastatementTokens, ruleName, parser);
-
-  return unqualifiedMetastatementNode;
-}
-
 function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = florenceParser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],

package/src/utilities/tokens.js

@@ -40,14 +40,6 @@ export function unqualifiedStatementTokensFromStatementString(statementString, l
   return unqualifiedStatementTokens;
 }
 
-export function unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer) {
-  const unqualifiedMetastatementContent = `${metastatementString}
-`,
-        unqualifiedMetastatementTokens = tokensFromContentAndLexer(unqualifiedMetastatementContent, lexer);
-
-  return unqualifiedMetastatementTokens;
-}
-
 function tokensFromContentAndLexer(content, lexer = florenceLexer) {
   const tokens = lexer.tokenise(content);
 

package/src/utilities/verify.js

@@ -5,26 +5,10 @@ import { nodeQuery } from "../utilities/query";
 
 const secondOperatorTerminalNodeQuery = nodeQuery("/*/@operator[1]");
 
-export function isStatementNegated(statementNode) {
-  const node = statementNode, ///
-        negated = isNegated(node),
-        statementNegated = negated; ///
-
-  return statementNegated;
-}
-
-export function isMetastatementNegated(metastatementNode) {
-  const node = metastatementNode, ///
-        negated = isNegated(node),
-        statementNegated = negated; ///
-
-  return statementNegated;
-}
-
-function isNegated(node) {
-  const secondOperatorTerminalNode = secondOperatorTerminalNodeQuery(node),
+export function isAssertionNegated(assertionNode) {
+  const secondOperatorTerminalNode = secondOperatorTerminalNodeQuery(assertionNode),
         content = secondOperatorTerminalNode.getContent(),
-        negated = (content === NOT);
+        assertionNegated = (content === NOT);
 
-  return negated;
+  return assertionNegated;
 }

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -11,10 +11,9 @@ const termNodeQuery = nodeQuery("/term!"),
       statementNodeQuery = nodeQuery("/statement!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      metastatementNodeQuery = nodeQuery("/metastatement!"),
       metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
-      metastatementSubstitutionNodeQuery = nodeQuery("/metastatement/substitution");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
+      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution");
 
 class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
@@ -22,54 +21,54 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
 
     const nodeQueryMaps = [
       {
-        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryA: statementMetavariableNodeQuery,
         nodeQueryB: metaArgumentStatementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const metaArgumentStatementNodeB = nodeB,  ///
-                metastatementMetavariableNodeA = nodeA, ///
-                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
-                metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode =
+                statementMetavariableNodeA = nodeA, ///
+                statementSubstitutionNodeA = statementSubstitutionNodeQuery(nonTerminalNodeA),
+                statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode =
 
-                  this.verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyStatementMetavariableNodeAgainstMetaArgumentStatementNode(statementMetavariableNodeA, metaArgumentStatementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;  ///
+          nonTerminalNodeVerified = statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
       },
       {
-        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryA: statementMetavariableNodeQuery,
         nodeQueryB: statementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNodeB = nodeB,  ///
-                metastatementMetavariableNodeA = nodeA, ///
-                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
-                metastatementMetavariableNodeVerifiedAgainstStatementNode =
+                statementMetavariableNodeA = nodeA, ///
+                statementSubstitutionNodeA = statementSubstitutionNodeQuery(nonTerminalNodeA),
+                statementMetavariableNodeVerifiedAgainstStatementNode =
 
-                  this.verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstStatementNode;  ///
+          nonTerminalNodeVerified = statementMetavariableNodeVerifiedAgainstStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
       },
       {
-        nodeQueryA: metastatementNodeQuery,
+        nodeQueryA: statementNodeQuery,
         nodeQueryB: statementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const statementNodeB = nodeB,  ///
-                metastatementNodeA = nodeA, ///
-                metastatementNodeVerifiedAgainstStatementNode =
+                statementNodeA = nodeA, ///
+                statementNodeVerifiedAgainstStatementNode =
 
-                  this.verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyStatementNodeAgainstStatementNode(statementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementNodeVerifiedAgainstStatementNode;  ///
+          nonTerminalNodeVerified = statementNodeVerifiedAgainstStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
@@ -116,35 +115,35 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+  verifyStatementMetavariableNodeAgainstMetaArgumentStatementNode(statementMetavariableNodeA, metaArgumentStatementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
 
     const statementNodeB = metaArgumentStatementNodeB, ///
-          substitutionNode = metastatementSubstitutionNodeA,  ///
-          metavariableNodeA = metastatementMetavariableNodeA,  ///
+          substitutionNode = statementSubstitutionNodeA,  ///
+          metavariableNodeA = statementMetavariableNodeA,  ///
           metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
 
-    metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode = metavariableVerifiedAgainstStatement; ///
+    statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode = metavariableVerifiedAgainstStatement; ///
 
-    return metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+    return statementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
   }
 
-  verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementMetavariableNodeVerifiedAgainstStatementNode;
+  verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, statementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let statementMetavariableNodeVerifiedAgainstStatementNode;
 
-    const substitutionNode = metastatementSubstitutionNodeA,  ///
-          metavariableNodeA = metastatementMetavariableNodeA,  ///
+    const substitutionNode = statementSubstitutionNodeA,  ///
+          metavariableNodeA = statementMetavariableNodeA,  ///
           metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
 
-    metastatementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
+    statementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
 
-    return metastatementMetavariableNodeVerifiedAgainstStatementNode;
+    return statementMetavariableNodeVerifiedAgainstStatementNode;
   }
 
-  verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let metastatementNodeVerifiedAgainstStatementNode;
+  verifyStatementNodeAgainstStatementNode(statementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let statementNodeVerifiedAgainstStatementNode;
 
-    const nonTerminalNodeA = metastatementNodeA,  ///
+    const nonTerminalNodeA = statementNodeA,  ///
           nonTerminalNodeB = statementNodeB,  ///
           nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
           nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
@@ -152,9 +151,9 @@ class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
           childNodesB = nonTerminalNodeBChildNodes, ///
           childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB, verifyAhead);
 
-    metastatementNodeVerifiedAgainstStatementNode = childNodesVerified; ///
+    statementNodeVerifiedAgainstStatementNode = childNodesVerified; ///
 
-    return metastatementNodeVerifiedAgainstStatementNode;
+    return statementNodeVerifiedAgainstStatementNode;
   }
 
   verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {

package/src/verifier/nodes/metaLevel.js

@@ -2,16 +2,16 @@
 
 import NodesVerifier from "../../verifier/nodes";
 import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
-import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
+import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
 
 import { nodeQuery } from "../../utilities/query";
 import { verifyNodes } from "../../utilities/verifier";
 
 const termNodeQuery = nodeQuery("/term!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
+      statementNodeQuery = nodeQuery("/statement!"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      metastatementNodeQuery = nodeQuery("/metastatement!"),
-      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
@@ -19,18 +19,18 @@ class MetaLevelNodesVerifier extends NodesVerifier {
 
     const nodeQueryMaps = [
       {
-        nodeQueryA: metastatementMetavariableNodeQuery,
-        nodeQueryB: metastatementNodeQuery,
+        nodeQueryA: statementMetavariableNodeQuery,
+        nodeQueryB: statementNodeQuery,
         verifyNodes: (nodeA, nodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) => {
           let nonTerminalNodeVerified;
 
-          const metastatementNodeB = nodeB, ///
-                metastatementMetavariableNodeA = nodeA, ///
-                metastatementMetavariableNodeVerifiedAgainstMetastatementNode =
+          const statementNodeB = nodeB, ///
+                statementMetavariableNodeA = nodeA, ///
+                statementMetavariableNodeVerifiedAgainstStatementNode =
 
-                  this.verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
+                  this.verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementNode;  ///
+          nonTerminalNodeVerified = statementMetavariableNodeVerifiedAgainstStatementNode;  ///
 
           return nonTerminalNodeVerified;
         }
@@ -77,16 +77,16 @@ class MetaLevelNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
-    let metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
+  verifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementNodeB, substitutions, localMetaContextA, localMetaContextB, verifyAhead) {
+    let statementMetavariableNodeVerifiedAgainstStatementNode;
 
-    const metavariableNode = metastatementMetavariableNodeA, ///
-          metastatementNode = metastatementNodeB, ///
-          metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, verifyAhead);
+    const metavariableNode = statementMetavariableNodeA, ///
+          statementNode = statementNodeB, ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutions, verifyAhead);
 
-    metastatementMetavariableNodeVerifiedAgainstMetastatementNode = metavariableVerifiedAgainstMetastatement;  ///
+    statementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement;  ///
 
-    return metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
+    return statementMetavariableNodeVerifiedAgainstStatementNode;
   }
 
   verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {

package/src/verify/axiom.js

@@ -1,10 +1,10 @@
 "use strict";
 
 import Axiom from "../axiom";
+import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
-import IntrinsicLevelLocalContext from "../context/local/intrinsicLevel";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -16,10 +16,9 @@ const labelNodesQuery = nodesQuery("/axiom/label"),
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
-  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
-        labelNodes = labelNodesQuery(axiomNode),
+  const labelNodes = labelNodesQuery(axiomNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = intrinsicLevelLocalContext;  ///
+        localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 

package/src/verify/conclusion.js

@@ -1,15 +1,12 @@
 "use strict";
 
 import Conclusion from "../conclusion";
-import verifyUnqualifiedStatement from "./statement/unqualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
+      unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement!");
 
 export default function verifyConclusion(conclusionNode, conclusions, localContext) {
   let conclusionVerified = false;
@@ -18,8 +15,7 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
 
   localContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode);
 
   if (unqualifiedStatementNode !== null) {
     const derived = false,
@@ -29,12 +25,12 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
     conclusionVerified = unqualifiedStatementVerified; ///
   }
 
-  if (unqualifiedMetastatementNode !== null) {
+  if (unqualifiedStatementNode !== null) {
     const derived = false,
           assignments = [],
-          unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
+          unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
-    conclusionVerified = unqualifiedMetastatementVerified; ///
+    conclusionVerified = unqualifiedStatementVerified; ///
   }
 
   if (conclusionVerified) {
@@ -46,10 +42,10 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
       conclusion = Conclusion.fromStatementNode(statementNode);
     }
 
-    if (unqualifiedMetastatementNode !== null) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+    if (unqualifiedStatementNode !== null) {
+      const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
-      conclusion = Conclusion.fromMetastatementNode(metastatementNode);
+      conclusion = Conclusion.fromStatementNode(statementNode);
     }
 
     conclusions.push(conclusion);

package/src/verify/conjecture.js

@@ -3,9 +3,9 @@
 import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
+import LocalContext from "../context/local";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
-import IntrinsicLevelLocalContext from "../context/local/intrinsicLevel";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -18,10 +18,9 @@ const proofNodeQuery = nodeQuery("/conjecture/proof!"),
 export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
-  const intrinsicLevelLocalContext = IntrinsicLevelLocalContext.fromFileContext(fileContext),
-        labelNodes = labelNodesQuery(conjectureNode),
+  const labelNodes = labelNodesQuery(conjectureNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        localContext = intrinsicLevelLocalContext;  ///
+        localContext = LocalContext.fromFileContext(fileContext);  ///
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);