occam-verify-cli 0.0.915 → 0.0.917

package/lib/verify/statementAsDefinedAssertion.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyStatementAsDefinedAssertion;
+    }
+});
+var _term = /*#__PURE__*/ _interop_require_default(require("./term"));
+var _metaLevel = /*#__PURE__*/ _interop_require_default(require("../verifier/node/metaLevel"));
+var _array = require("../utilities/array");
+var _query = require("../utilities/query");
+var _verify = require("../utilities/verify");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var termNodeQuery = (0, _query.nodeQuery)("/statement/term!"), variableNodeQuery = (0, _query.nodeQuery)("/statement/term/variable!");
+function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+    var statementVerifiedAsDefinedAssertion;
+    var statementString = localContext.nodeAsString(statementNode);
+    localContext.trace("Verifying the '".concat(statementString, "' statement as a defined assertion..."), statementNode);
+    var definedAssertionFunctions = [
+        verifyDerivedStatementAsDefinedAssertion,
+        verifyStatedStatementAsDefinedAssertion
+    ];
+    statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some(function(definedAssertionFunction) {
+        var statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);
+        if (statementVerifiedAsDefinedAssertion) {
+            return true;
+        }
+    });
+    if (statementVerifiedAsDefinedAssertion) {
+        localContext.debug("...verified the '".concat(statementString, "' statement as a defined assertion."), statementNode);
+    }
+    return statementVerifiedAsDefinedAssertion;
+}
+function verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+    var derivedStatementVerifiedAsDefeindAssertion = false;
+    if (derived) {
+        var statementString = localContext.nodeAsString(statementNode);
+        localContext.trace("Verifying the derived '".concat(statementString, "' statement as a defined assertion..."), statementNode);
+        var statementNegated = (0, _verify.isStatementNegated)(statementNode), variableNode = variableNodeQuery(statementNode), termNode = termNodeQuery(statementNode);
+        if (false) {
+        ///
+        } else if (variableNode !== null) {
+            var variable = localContext.findVariableByVariableNode(variableNode);
+            if (variable !== null) {
+                var variableDefined = localContext.isVariableDefined(variable);
+                if (!statementNegated) {
+                    if (variableDefined) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+                if (statementNegated) {
+                    if (!variableDefined) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+            }
+        } else if (termNode !== null) {
+            var terms = [], termVerified = (0, _term.default)(termNode, terms, localContext, function() {
+                var verifiedAhead = true;
+                return verifiedAhead;
+            });
+            if (termVerified) {
+                var firstTerm = (0, _array.first)(terms), term = firstTerm, termGrounded = localContext.isTermGrounded(term);
+                if (!statementNegated) {
+                    if (termGrounded) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+                if (statementNegated) {
+                    if (!termGrounded) {
+                        derivedStatementVerifiedAsDefeindAssertion = true;
+                    }
+                }
+            }
+        }
+        if (derivedStatementVerifiedAsDefeindAssertion) {
+            localContext.debug("...verified the derived '".concat(statementString, "' statement as a defined assertion."), statementNode);
+        }
+    }
+    return derivedStatementVerifiedAsDefeindAssertion;
+}
+function verifyStatedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {
+    var statedStatementVerifiedAsDefinedAssertion = false;
+    if (!derived) {
+        var statementString = localContext.nodeAsString(statementNode);
+        localContext.trace("Verifying the stated '".concat(statementString, "' statement as a defined assertion..."), statementNode);
+        var intrinsicLevel = localContext.isIntrinsicLevel();
+        if (intrinsicLevel) {
+            localContext.debug("The stated '".concat(statementString, "' statement as a defined assertion cannot be verified at intrinsic level."), statementNode);
+        } else {
+            var nonTerminalNode = statementNode, nonTerminalNodeVerified = _metaLevel.default.verifyNonTerminalNode(nonTerminalNode, localContext, function() {
+                var verifiedAhead = true;
+                return verifiedAhead;
+            });
+            statedStatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///
+        }
+        if (statedStatementVerifiedAsDefinedAssertion) {
+            localContext.debug("...verified the stated '".concat(statementString, "' statement as a defined assertion."), statementNode);
+        }
+    }
+    return statedStatementVerifiedAsDefinedAssertion;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/statementAsDefinedAssertion.js"],"sourcesContent":["\"use strict\";\n\nimport verifyTerm from \"./term\";\nimport metaLevelNodeVerifier from \"../verifier/node/metaLevel\";\n\nimport { first } from \"../utilities/array\";\nimport { nodeQuery } from \"../utilities/query\";\nimport { isStatementNegated } from \"../utilities/verify\";\n\nconst termNodeQuery = nodeQuery(\"/statement/term!\"),\n      variableNodeQuery = nodeQuery(\"/statement/term/variable!\");\n\nexport default function verifyStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {\n  let statementVerifiedAsDefinedAssertion;\n\n  const statementString = localContext.nodeAsString(statementNode);\n\n  localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);\n\n  const definedAssertionFunctions = [\n    verifyDerivedStatementAsDefinedAssertion,\n    verifyStatedStatementAsDefinedAssertion\n  ];\n\n  statementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {\n    const statementVerifiedAsDefinedAssertion = definedAssertionFunction(statementNode, assignments, derived, localContext);\n\n    if (statementVerifiedAsDefinedAssertion) {\n      return true;\n    }\n  });\n\n  if (statementVerifiedAsDefinedAssertion) {\n    localContext.debug(`...verified the '${statementString}' statement as a defined assertion.`, statementNode);\n  }\n\n  return statementVerifiedAsDefinedAssertion;\n}\n\nfunction verifyDerivedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {\n  let derivedStatementVerifiedAsDefeindAssertion = false;\n\n  if (derived) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.trace(`Verifying the derived '${statementString}' statement as a defined assertion...`, statementNode);\n\n    const statementNegated = isStatementNegated(statementNode),\n          variableNode = variableNodeQuery(statementNode),\n          termNode = termNodeQuery(statementNode);\n\n    if (false) {\n      ///\n    } else if (variableNode !== null) {\n      const variable = localContext.findVariableByVariableNode(variableNode);\n\n      if (variable !== null) {\n        const variableDefined = localContext.isVariableDefined(variable);\n\n        if (!statementNegated) {\n          if (variableDefined) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n\n        if (statementNegated) {\n          if (!variableDefined) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n      }\n    } else if (termNode !== null) {\n      const terms = [],\n            termVerified = verifyTerm(termNode, terms, localContext, () => {\n              const verifiedAhead = true;\n\n              return verifiedAhead;\n            });\n\n      if (termVerified) {\n        const firstTerm = first(terms),\n              term = firstTerm, ///\n              termGrounded = localContext.isTermGrounded(term);\n\n        if (!statementNegated) {\n          if (termGrounded) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n\n        if (statementNegated) {\n          if (!termGrounded) {\n            derivedStatementVerifiedAsDefeindAssertion = true;\n          }\n        }\n      }\n    }\n\n    if (derivedStatementVerifiedAsDefeindAssertion) {\n      localContext.debug(`...verified the derived '${statementString}' statement as a defined assertion.`, statementNode);\n    }\n  }\n\n  return derivedStatementVerifiedAsDefeindAssertion;\n}\n\nfunction verifyStatedStatementAsDefinedAssertion(statementNode, assignments, derived, localContext) {\n  let statedStatementVerifiedAsDefinedAssertion = false;\n\n  if (!derived) {\n    const statementString = localContext.nodeAsString(statementNode);\n\n    localContext.trace(`Verifying the stated '${statementString}' statement as a defined assertion...`, statementNode);\n\n    const intrinsicLevel = localContext.isIntrinsicLevel();\n\n    if (intrinsicLevel) {\n      localContext.debug(`The stated '${statementString}' statement as a defined assertion cannot be verified at intrinsic level.`, statementNode);\n    } else {\n      const nonTerminalNode = statementNode, ///\n            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {\n              const verifiedAhead = true;\n\n              return verifiedAhead;\n            });\n\n      statedStatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///\n    }\n\n    if (statedStatementVerifiedAsDefinedAssertion) {\n      localContext.debug(`...verified the stated '${statementString}' statement as a defined assertion.`, statementNode);\n    }\n  }\n\n  return statedStatementVerifiedAsDefinedAssertion;\n}\n"],"names":["verifyStatementAsDefinedAssertion","termNodeQuery","nodeQuery","variableNodeQuery","statementNode","assignments","derived","localContext","statementVerifiedAsDefinedAssertion","statementString","nodeAsString","trace","definedAssertionFunctions","verifyDerivedStatementAsDefinedAssertion","verifyStatedStatementAsDefinedAssertion","some","definedAssertionFunction","debug","derivedStatementVerifiedAsDefeindAssertion","statementNegated","isStatementNegated","variableNode","termNode","variable","findVariableByVariableNode","variableDefined","isVariableDefined","terms","termVerified","verifyTerm","verifiedAhead","firstTerm","first","term","termGrounded","isTermGrounded","statedStatementVerifiedAsDefinedAssertion","intrinsicLevel","isIntrinsicLevel","nonTerminalNode","nonTerminalNodeVerified","metaLevelNodeVerifier","verifyNonTerminalNode"],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.915",
+  "version": "0.0.917",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,7 +12,7 @@
   "dependencies": {
     "argumentative": "^2.0.28",
     "necessary": "^14.0.1",
-    "occam-custom-grammars": "^5.0.816",
+    "occam-custom-grammars": "^5.0.820",
     "occam-entities": "^1.0.147",
     "occam-file-system": "^6.0.188",
     "occam-grammar-utilities": "^8.0.207",

package/src/assignment/judgement.js

@@ -0,0 +1,30 @@
+"use strict";
+
+export default class JudgementAssignment {
+  constructor(judgement) {
+    this.judgement = judgement;
+  }
+
+  getJudgement() {
+    return this.judgement;
+  }
+
+  assign(localContext) {
+    const judgementAdded = localContext.addJudgement(this.judgement),
+          judgementNode = this.judgement.getNode(),
+          judgementString = localContext.nodeAsString(judgementNode),
+          judgementAssigned = judgementAdded; ///
+
+    judgementAssigned ?
+      localContext.trace(`Assigned the '${judgementString}' judgement.`, judgementNode) :
+        localContext.debug(`Unable to assign the '${judgementString}' judgement.`, judgementNode);
+
+    return judgementAssigned;
+  }
+
+  static fromJudgement(judgement) {
+    const judgementAssignment = new JudgementAssignment(judgement);
+
+    return judgementAssignment;
+  }
+}

package/src/constants.js

@@ -2,6 +2,8 @@
 
 export const NOT = 'not';
 export const COMMA = ',';
+export const DEFINED = ',';
+export const CONTAINED = ',';
 export const EMPTY_STRING = "";
 export const BRACKETED_STATEMENT_DEPTH = 2;
 export const BRACKETED_METASTATEMENT_DEPTH = 1;

package/src/context/file.js

@@ -82,10 +82,10 @@ export default class FileContext {
     return metaproofSteps;
   }
 
-  getFrameAssertions() {
-    const frameAssertionss = [];
+  getJudgements() {
+    const judgements = [];
 
-    return frameAssertionss;
+    return judgements;
   }
 
   getLabels(includeRelease = true) {

package/src/context/local/metaLevel.js

@@ -5,12 +5,23 @@ import IntrinsicLevelLocalContext from "../../context/local/intrinsicLevel";
 import { last, reverse } from "../../utilities/array";
 
 class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
-  constructor(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions) {
+  constructor(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps) {
     super(context, variables, proofSteps, equivalences);
 
+    this.judgements = judgements;
     this.metavariables = metavariables;
     this.metaproofSteps = metaproofSteps;
-    this.frameAssertions = frameAssertions;
+  }
+
+  getJudgements() {
+    let judgements = this.context.getJudgements();
+
+    judgements = [ ///
+      ...this.judgements,
+      ...judgements
+    ]
+
+    return judgements;
   }
 
   getMetavariables() {
@@ -35,17 +46,6 @@ class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
     return metaproofSteps;
   }
 
-  getFrameAssertions() {
-    let frameAssertions = this.context.getFrameAssertions();
-
-    frameAssertions = [ ///
-      ...this.frameAssertions,
-      ...frameAssertions
-    ]
-
-    return frameAssertions;
-  }
-
   isIntrinsicLevel() {
     const intrinsicLevel = false;
 
@@ -64,19 +64,19 @@ class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
     return lastMetaproofStep;
   }
 
-  addFrameAssertion(frameAssertion) {
-    let frameAssertionAdded = false;
+  addJudgement(judgement) {
+    let judgementAdded = false;
 
-    const metavariableNode = frameAssertion.getMetavariableNode(),
-          frameAssertionPresent = this.isFrameAssertionPresentByMetavariableNode(metavariableNode);
+    const metavariableNode = judgement.getMetavariableNode(),
+          judgementPresent = this.isJudgementPresentByMetavariableNode(metavariableNode);
 
-    if (!frameAssertionPresent) {
-      this.frameAssertions.push(frameAssertion);
+    if (!judgementPresent) {
+      this.judgements.push(judgement);
 
-      frameAssertionAdded = true;
+      judgementAdded = true;
     }
 
-    return frameAssertionAdded;
+    return judgementAdded;
   }
 
   addMetavariable(metavariable) {
@@ -134,17 +134,17 @@ class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
     return metavariable;
   }
 
-  findFrameAssertionByMetavariableNode(metavariableNode) {
-    const frameAssertions = this.getFrameAssertions(),
-          frameAssertion = frameAssertions.find((frameAssertion) => {
-            const frameAssertionMatchesMetavariableNode = frameAssertion.matchMetavariableNode(metavariableNode);
+  findJudgementByMetavariableNode(metavariableNode) {
+    const judgements = this.getJudgements(),
+          judgement = judgements.find((judgement) => {
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
 
-            if (frameAssertionMatchesMetavariableNode) {
+            if (judgementMatchesMetavariableNode) {
               return true;
             }
           }) || null;
 
-    return frameAssertion;
+    return judgement;
   }
 
   isMetavariablePresentByMetavariableNode(metavariableNode, metaLevelLocalContext) {
@@ -154,11 +154,11 @@ class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
     return metavariablePresent;
   }
 
-  isFrameAssertionPresentByMetavariableNode(metavariableNode) {
-    const frameAssertion = this.findFrameAssertionByMetavariableNode(metavariableNode),
-          frameAssertionPresent = (frameAssertion !== null);
+  isJudgementPresentByMetavariableNode(metavariableNode) {
+    const judgement = this.findJudgementByMetavariableNode(metavariableNode),
+          judgementPresent = (judgement !== null);
 
-    return frameAssertionPresent;
+    return judgementPresent;
   }
 
   static fromFileContext(fileContext) {
@@ -166,10 +166,10 @@ class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
           variables = [],
           proofSteps = [],
           equivalences = [],
+          judgements = [],
           metavariables = [],
           metaproofSteps = [],
-          frameAssertions = [],
-          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);
+          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);
 
     return metaLevelLocalContext;
   }
@@ -179,10 +179,10 @@ class MetaLevelLocalContext extends IntrinsicLevelLocalContext {
           variables = [],
           proofSteps = [],
           equivalences = [],
+          judgements = [],
           metavariables = [],
           metaproofSteps = [],
-          frameAssertions = [],
-          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions);  ///
+          metaLevelLocalContext = new MetaLevelLocalContext(context, variables, proofSteps, equivalences, judgements, metavariables, metaproofSteps);  ///
 
     return metaLevelLocalContext;
   }

package/src/{frameAssertion.js → judgement.js}

@@ -1,6 +1,6 @@
 "use strict";
 
-export default class FrameAssertion {
+export default class Judgement {
   constructor(node, frame, metavariableNode) {
     this.node = node;
     this.frame = frame;
@@ -29,10 +29,10 @@ export default class FrameAssertion {
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) { return this.frame.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem); }
 
-  static fromFrameAssertionNodeFrameAndMetavariableNode(frameAssertionNode, frame, metavariableNode) {
-    const node = frameAssertionNode,
-          frameAssertion = new FrameAssertion(node, frame, metavariableNode);
+  static fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode) {
+    const node = judgementNode,
+          judgement = new Judgement(node, frame, metavariableNode);
 
-    return frameAssertion;
+    return judgement;
   }
 }

package/src/utilities/verify.js

@@ -3,12 +3,12 @@
 import { NOT } from "../constants";
 import { nodeQuery } from "../utilities/query";
 
-const secondOperatorTerminalNodeQuery = nodeQuery("/*/@operator[1]");
+const secondOperatorTerminalNodeQuery = nodeQuery("/statement/@operator[1]");
 
-export function isAssertionNegated(assertionNode) {
-  const secondOperatorTerminalNode = secondOperatorTerminalNodeQuery(assertionNode),
+export function isStatementNegated(statementNode) {
+  const secondOperatorTerminalNode = secondOperatorTerminalNodeQuery(statementNode),
         content = secondOperatorTerminalNode.getContent(),
-        assertionNegated = (content === NOT);
+        statementNegated = (content === NOT);
 
-  return assertionNegated;
+  return statementNegated;
 }

package/src/verify/frame.js

@@ -62,16 +62,16 @@ function verifyMetavariable(metavariableNode, declarations, localContext) {
     const metaType = metavariable.getMetaType();
 
     if (metaType === frameMetaType) {
-      const frameAssertion = localContext.findFrameAssertionByMetavariableNode(metavariableNode);
+      const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
-      if (frameAssertion !== null) {
-        const frameAssertionDeclarations = frameAssertion.getDeclarations();
+      if (judgement !== null) {
+        const judgementDeclarations = judgement.getDeclarations();
 
-        push(declarations, frameAssertionDeclarations);
+        push(declarations, judgementDeclarations);
 
         metavariableVerified = true;
       } else {
-        localContext.debug(`There is no frame assertion for the '${metavariableString}' metavariable.`, metavariableNode);
+        localContext.debug(`There is no judgement for the '${metavariableString}' metavariable.`, metavariableNode);
       }
     } else {
       const frameMetaTypeName = frameMetaType.getName(),

package/src/verify/{frameAssertion.js → judgement.js}

@@ -1,60 +1,60 @@
 "use strict";
 
+import Judgement from "../judgement";
 import verifyFrame from "../verify/frame";
 import frameMetaType from "../metaType/frame";
-import FrameAssertion from "../frameAssertion";
-import FrameAssertionAssignment from "../assignment/frameAssertion";
+import JudgementAssignment from "../assignment/judgement";
 
 import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
 
-const frameNodeQuery = nodeQuery("/frameAssertion/frame!"),
-      metavariableNodeQuery = nodeQuery("/frameAssertion/metavariable!");
+const frameNodeQuery = nodeQuery("/judgement/frame!"),
+      metavariableNodeQuery = nodeQuery("/judgement/metavariable!");
 
-export default function verifyFrameAssertion(frameAssertionNode, assignments, derived, localContext) {
-  let frameAssertionVerified;
+export default function verifyJudgement(judgementNode, assignments, derived, localContext) {
+  let judgementVerified;
 
-  const frameAssertionString = localContext.nodeAsString(frameAssertionNode);
+  const judgementString = localContext.nodeAsString(judgementNode);
 
-  localContext.trace(`Verifying the '${frameAssertionString}' frame assertion...`, frameAssertionNode);
+  localContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
 
-  const verifyFrameAssertionFunctions = [
-    verifyDerivedFrameAssertion,
-    verifyStatedFrameAssertion
+  const verifyJudgementFunctions = [
+    verifyDerivedJudgement,
+    verifyStatedJudgement
   ];
 
-  frameAssertionVerified = verifyFrameAssertionFunctions.some((verifyFrameAssertionFunction) => {
-    const frameAssertionVerified = verifyFrameAssertionFunction(frameAssertionNode, assignments, derived, localContext);
+  judgementVerified = verifyJudgementFunctions.some((verifyJudgementFunction) => {
+    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, derived, localContext);
 
-    if (frameAssertionVerified) {
+    if (judgementVerified) {
       return true;
     }
   });
 
-  if (frameAssertionVerified) {
-    localContext.debug(`...verified the '${frameAssertionString}' frame assertion.`, frameAssertionNode);
+  if (judgementVerified) {
+    localContext.debug(`...verified the '${judgementString}' judgement.`, judgementNode);
   }
 
-  return frameAssertionVerified;
+  return judgementVerified;
 }
 
-function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, localContext) {
-  let derivedFrameAssertionVerified = false;
+function verifyDerivedJudgement(judgementNode, assignments, derived, localContext) {
+  let derivedJudgementVerified = false;
 
   if (derived) {
-    const frameAssertionString = localContext.nodeAsString(frameAssertionNode);
+    const judgementString = localContext.nodeAsString(judgementNode);
 
-    localContext.trace(`Verifying the '${frameAssertionString}' derived frame assertion...`, frameAssertionNode);
+    localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(frameAssertionNode),
+    const metavariableNode = metavariableNodeQuery(judgementNode),
           metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
     if (metavariableVerified) {
-      const frameAssertion = localContext.findFrameAssertionByMetavariableNode(metavariableNode);
+      const judgement = localContext.findJudgementByMetavariableNode(metavariableNode);
 
-      if (frameAssertion !== null) {
+      if (judgement !== null) {
         const frames = [],
-              frameNode = frameNodeQuery(frameAssertionNode),
+              frameNode = frameNodeQuery(judgementNode),
               frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
 
         if (frameVerified) {
@@ -71,70 +71,70 @@ function verifyDerivedFrameAssertion(frameAssertionNode, assignments, derived, l
 
             if (metaLemmaMetatheorem !== null) {
               const declarationMatchesMetaLemmaMetatheorem = declaration.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                    frameAssertionMatchesMetaLemmaMetatheorem = frameAssertion.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+                    judgementMatchesMetaLemmaMetatheorem = judgement.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
 
-              derivedFrameAssertionVerified = (declarationMatchesMetaLemmaMetatheorem && frameAssertionMatchesMetaLemmaMetatheorem);
+              derivedJudgementVerified = (declarationMatchesMetaLemmaMetatheorem && judgementMatchesMetaLemmaMetatheorem);
             } else {
               const metavariableString = localContext.nodeAsString(metavariableNode);
 
-              localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, frameAssertionNode);
+              localContext.debug(`There are no meta-lemmas or metatheorems corresponding to the '${metavariableString}' metavariable.`, judgementNode);
             }
           } else {
             const frameString = localContext.nodeAsString(frameNode);
 
-            localContext.debug(`The '${frameString}' is not singular.`, frameAssertionNode);
+            localContext.debug(`The '${frameString}' is not singular.`, judgementNode);
           }
         }
       } else {
         const metavariableString = localContext.nodeAsString(metavariableNode);
 
-        localContext.debug(`There is no frameAssertion present for the '${metavariableString}' metavariable.`, frameAssertionNode);
+        localContext.debug(`There is no judgement present for the '${metavariableString}' metavariable.`, judgementNode);
       }
     }
 
-    if (derivedFrameAssertionVerified) {
-      localContext.debug(`...verified the '${frameAssertionString}' derived frame assertion.`, frameAssertionNode);
+    if (derivedJudgementVerified) {
+      localContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
     }
   }
 
-  return derivedFrameAssertionVerified;
+  return derivedJudgementVerified;
 }
 
-function verifyStatedFrameAssertion(frameAssertionNode, assignments, derived, localContext) {
-  let statedFrameAssertionVerified = false;
+function verifyStatedJudgement(judgementNode, assignments, derived, localContext) {
+  let statedJudgementVerified = false;
 
   if (!derived) {
-    const frameAssertionString = localContext.nodeAsString(frameAssertionNode);
+    const judgementString = localContext.nodeAsString(judgementNode);
 
-    localContext.trace(`Verifying the '${frameAssertionString}' stated frame assertion...`, frameAssertionNode);
+    localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
 
-    const metavariableNode = metavariableNodeQuery(frameAssertionNode),
+    const metavariableNode = metavariableNodeQuery(judgementNode),
           metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
     if (metavariableVerified) {
       const frames = [],
-            frameNode = frameNodeQuery(frameAssertionNode),
+            frameNode = frameNodeQuery(judgementNode),
             frameVerified = verifyFrame(frameNode, frames, assignments, derived, localContext);
 
       if (frameVerified) {
         const firstFrame = first(frames),
               frame = firstFrame, ///
-              frameAssertion = FrameAssertion.fromFrameAssertionNodeFrameAndMetavariableNode(frameAssertionNode, frame, metavariableNode),
-              frameAssertionAssignment = FrameAssertionAssignment.fromFrameAssertion(frameAssertion),
-              assignment = frameAssertionAssignment;
+              judgement = Judgement.fromJudgementNodeFrameAndMetavariableNode(judgementNode, frame, metavariableNode),
+              judgementAssignment = JudgementAssignment.fromJudgement(judgement),
+              assignment = judgementAssignment;
 
         assignments.push(assignment);
 
-        statedFrameAssertionVerified = true;
+        statedJudgementVerified = true;
       }
     }
 
-    if (statedFrameAssertionVerified) {
-      localContext.debug(`...verified the '${frameAssertionString}' stated frame assertion.`, frameAssertionNode);
+    if (statedJudgementVerified) {
+      localContext.debug(`...verified the '${judgementString}' stated judgement.`, judgementNode);
     }
   }
 
-  return statedFrameAssertionVerified;
+  return statedJudgementVerified;
 }
 
 function verifyMetavariable(metavariableNode, localContext) {