occam-verify-cli 1.0.122 → 1.0.124

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.122",
+  "version": "1.0.124",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,10 +12,10 @@
   "dependencies": {
     "argumentative": "^2.0.32",
     "necessary": "^14.3.2",
-    "occam-custom-grammars": "^5.0.1127",
-    "occam-entities": "^1.0.329",
-    "occam-file-system": "^6.0.347",
-    "occam-furtle": "^2.0.117",
+    "occam-custom-grammars": "^5.0.1130",
+    "occam-entities": "^1.0.330",
+    "occam-file-system": "^6.0.348",
+    "occam-furtle": "^2.0.119",
     "occam-grammar-utilities": "^8.0.278",
     "occam-lexers": "^23.0.47",
     "occam-parsers": "^23.0.83",

package/src/constants.js

@@ -6,8 +6,8 @@ export const MISSING = "missing";
 export const FUNCTION = "function";
 export const TYPE_TYPE = "type";
 export const UNDEFINED = "undefined";
-export const SATISFYING = "Satisfying";
 export const PROVISIONAL = "Provisional";
+export const SATISFIABLE = "Satisfiable";
 export const EMPTY_STRING = "";
 export const PROVISIONALLY = "provisionally";
 export const BRACKETED_TERM_DEPTH = 2;

package/src/dom/assertion/{satisfying.js → satisfies.js}

@@ -5,10 +5,10 @@ import dom from "../../dom";
 import { domAssigned } from "../../dom";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 
-const termNodesQuery = nodesQuery("/satisfyingAssertion/term"),
-      satisfyingAssertionNodeQuery = nodeQuery("/statement/satisfyingAssertion");
+const termNodesQuery = nodesQuery("/satisfiesAssertion/term"),
+      satisfiesAssertionNodeQuery = nodeQuery("/statement/satisfiesAssertion");
 
-export default domAssigned(class SatisfyingAssertion {
+export default domAssigned(class SatisfiesAssertion {
   constructor(string, node, tokens, terms, reference) {
     this.string = string;
     this.node = node;
@@ -42,16 +42,16 @@ export default domAssigned(class SatisfyingAssertion {
 
     const termsString = termsStringFromTerms(this.terms),
           substitutionsString = substitutions.asString(),
-          satisfyingAssertionString = this.string; ///
+          satisfiesAssertionString = this.string; ///
 
-    context.trace(`Matching the '${substitutionsString}' substitutions against the '${satisfyingAssertionString}' satisfying assertion's ${termsString} terms...`);
+    context.trace(`Matching the '${substitutionsString}' substitutions against the '${satisfiesAssertionString}' satisfies assertion's ${termsString} terms...`);
 
     const termsEquate = substitutions.matchTerms(this.terms);
 
     substitutionsMatch = termsEquate;  ///
 
     if (substitutionsMatch) {
-      context.debug(`...matched the '${substitutionsString}' substitutions against the '${satisfyingAssertionString}' satisfying assertion's ${termsString} terms.`);
+      context.debug(`...matched the '${substitutionsString}' substitutions against the '${satisfiesAssertionString}' satisfies assertion's ${termsString} terms.`);
     }
 
     return substitutionsMatch;
@@ -60,9 +60,9 @@ export default domAssigned(class SatisfyingAssertion {
   verify(assignments, stated, context) {
     let verified = false;
 
-    const satisfyingAssertionString = this.string; ///
+    const satisfiesAssertionString = this.string; ///
 
-    context.trace(`Verifying the '${satisfyingAssertionString}' satisfying assertion...`);
+    context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion...`);
 
     const termsVerified = this.verifyTerms(assignments, stated, context);
 
@@ -73,7 +73,7 @@ export default domAssigned(class SatisfyingAssertion {
     }
 
     if (verified) {
-      context.debug(`...verified the '${satisfyingAssertionString}' satisfying assertion.`);
+      context.debug(`...verified the '${satisfiesAssertionString}' satisfies assertion.`);
     }
 
     return verified;
@@ -83,9 +83,9 @@ export default domAssigned(class SatisfyingAssertion {
     let termsVerified;
 
     const termsString = termsStringFromTerms(this.terms),
-          satisfyingAssertionString = this.string; ///
+          satisfiesAssertionString = this.string; ///
 
-    context.trace(`Verifying the '${satisfyingAssertionString}' satisfying assertion's ${termsString} terms...`);
+    context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion's ${termsString} terms...`);
 
     termsVerified = this.terms.every((term) => {
       const termVerified = term.verify(context, () => {
@@ -98,7 +98,7 @@ export default domAssigned(class SatisfyingAssertion {
     });
 
     if (termsVerified) {
-      context.debug(`...verified the '${satisfyingAssertionString}' satisfying assertion's ${termsString} terms.`);
+      context.debug(`...verified the '${satisfiesAssertionString}' satisfies assertion's ${termsString} terms.`);
     }
 
     return termsVerified;
@@ -108,46 +108,46 @@ export default domAssigned(class SatisfyingAssertion {
     let referenceVerified = false;
 
     const referenceString = this.reference.getString(),
-          satisfyingAssertionString = this.string; ///
+          satisfiesAssertionString = this.string; ///
 
-    context.trace(`Verifying the '${satisfyingAssertionString}' satisfying assertion's '${referenceString}' reference...`);
+    context.trace(`Verifying the '${satisfiesAssertionString}' satisfies assertion's '${referenceString}' reference...`);
 
     const axiom = context.findAxiomByReference(this.reference, context);
 
     if (axiom !== null) {
-      const axiomSatisfying = axiom.isSatisfying();
+      const axiomSatisfiable = axiom.isSatisfiable();
 
-      if (axiomSatisfying) {
+      if (axiomSatisfiable) {
         referenceVerified = true;
       }
     }
 
     if (referenceVerified) {
-      context.debug(`...verified the '${satisfyingAssertionString}' satisfying assertion's '${referenceString}' reference.`);
+      context.debug(`...verified the '${satisfiesAssertionString}' satisfies assertion's '${referenceString}' reference.`);
     }
 
     return referenceVerified;
   }
 
-  static name = "SatisfyingAssertion";
+  static name = "SatisfiesAssertion";
 
   static fromStatementNode(statementNode, context) {
-    let satisfyingAssertion = null;
+    let satisfiesAssertion = null;
 
-    const satisfyingAssertionNode = satisfyingAssertionNodeQuery(statementNode);
+    const satisfiesAssertionNode = satisfiesAssertionNodeQuery(statementNode);
 
-    if (satisfyingAssertionNode !== null) {
+    if (satisfiesAssertionNode !== null) {
       const { Reference } = dom,
-            node = satisfyingAssertionNode,  ///
+            node = satisfiesAssertionNode,  ///
             string = context.nodeAsString(node),
             tokens = context.nodeAsTokens(node),
-            terms = termsFromSatisfyingAssertionNode(satisfyingAssertionNode, context),
-            reference = Reference.fromSatisfyingAssertionNode(satisfyingAssertionNode, context);
+            terms = termsFromSatisfiesAssertionNode(satisfiesAssertionNode, context),
+            reference = Reference.fromSatisfiesAssertionNode(satisfiesAssertionNode, context);
 
-      satisfyingAssertion = new SatisfyingAssertion(string, node, tokens, terms, reference);
+      satisfiesAssertion = new SatisfiesAssertion(string, node, tokens, terms, reference);
     }
 
-    return satisfyingAssertion;
+    return satisfiesAssertion;
   }
 });
 
@@ -165,8 +165,8 @@ function termsStringFromTerms(terms) {
   return termsString;
 }
 
-function termsFromSatisfyingAssertionNode(satisfyingAssertionNode, context) {
-  const termNodes = termNodesQuery(satisfyingAssertionNode),
+function termsFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
+  const termNodes = termNodesQuery(satisfiesAssertionNode),
         terms = termNodes.map((termNode) => {
           const { Term } = dom,
                 term = Term.fromTermNode(termNode, context);

package/src/dom/axiom.js

@@ -5,16 +5,16 @@ import { arrayUtilities } from "necessary";
 import TopLevelAssertion  from "./topLevelAssertion";
 
 import { nodeQuery } from "../utilities/query";
-import { SATISFYING } from "../constants";
+import { SATISFIABLE } from "../constants";
 import { domAssigned } from "../dom";
 import { labelsFromJSON,
          deductionFromJSON,
-         satisfyingFromJSON,
+         satisfiableFromJSON,
          labelsToLabelsJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
-import { satisfyingAssertionFromStatement } from "../utilities/context";
+import { satisfiesAssertionFromStatement } from "../utilities/context";
 import { proofFromNode, labelsFromNode, deductionFromNode, suppositionsFromNode, stringFromLabelsAndDeduction } from "./topLevelAssertion";
 
 const { match, backwardsSome } = arrayUtilities;
@@ -22,14 +22,14 @@ const { match, backwardsSome } = arrayUtilities;
 const firstPrimaryKeywordTerminalNodeQuery = nodeQuery("/axiom/@primary-keyword[0]");
 
 export default domAssigned(class Axiom extends TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof, satisfying) {
+  constructor(fileContext, string, labels, suppositions, deduction, proof, satisfiable) {
     super(fileContext, string, labels, suppositions, deduction, proof);
 
-    this.satisfying = satisfying;
+    this.satisfiable = satisfiable;
   }
 
-  isSatisfying() {
-    return this.satisfying;
+  isSatisfiable() {
+    return this.satisfiable;
   }
 
   verify() {
@@ -163,17 +163,17 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     statementAndStepsOrSubproofsUnified = super.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
 
     if (statementAndStepsOrSubproofsUnified) {
-      if (this.satisfying) {
+      if (this.satisfiable) {
         const substitutionsMatch = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
           const stepSubstep = stepOrSubproof.isStep();
 
           if (stepSubstep) {
             const step = stepOrSubproof,  ///
                   statement = step.getStatement(),
-                  satisfyingAssertion = satisfyingAssertionFromStatement(statement, context);
+                  satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
 
-            if (satisfyingAssertion !== null) {
-              const substitutionsMatch = satisfyingAssertion.matchSubstitutions(substitutions, context);
+            if (satisfiesAssertion !== null) {
+              const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
 
               if (substitutionsMatch) {
                 return true;
@@ -202,12 +202,12 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     deduction = deductionJSON;  ///
     suppositions = suppositionsJSON;  ///
 
-    const satisfying = this.satisfying,
+    const satisfiable = this.satisfiable,
           json = {
             labels,
             deduction,
             suppositions,
-            satisfying
+            satisfiable
           };
 
     return json;
@@ -220,9 +220,9 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
           suppositions = suppositionsFromJSON(json, fileContext),
           deduction = deductionFromJSON(json, fileContext),
           proof = null,
-          satisfying = satisfyingFromJSON(json, fileContext),
+          satisfiable = satisfiableFromJSON(json, fileContext),
           string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfying);
+          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
 
     return topLevelAssertion;
   }
@@ -233,20 +233,20 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
           suppositions = suppositionsFromNode(node, fileContext),
           deduction = deductionFromNode(node, fileContext),
           proof = proofFromNode(node, fileContext),
-          satisfying = satisfyingFromNode(node, fileContext),
+          satisfiable = satisfiableFromNode(node, fileContext),
           string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfying);
+          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
 
     return topLevelAssertion;
   }
 });
 
-function satisfyingFromNode(node, fileContext) {
+function satisfiableFromNode(node, fileContext) {
   const firstPrimaryKeywordTerminalNode = firstPrimaryKeywordTerminalNodeQuery(node),
         content = firstPrimaryKeywordTerminalNode.getContent(),
-        contentSatisfying = (content === SATISFYING),
-        satisfying = contentSatisfying; ///
+        contentSatisfiable = (content === SATISFIABLE),
+        satisfiable = contentSatisfiable; ///
 
-  return satisfying;
+  return satisfiable;
 }
 

package/src/dom/reference.js

@@ -13,7 +13,7 @@ import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utiliti
 const stepReferenceNodeQuery = nodeQuery("/step/reference"),
       procedureCallReferenceNodeQuery = nodeQuery("/procedureCall/reference"),
       declarationMetavariableNodeQuery = nodeQuery("/declaration/metavariable"),
-      satisfyingAssertionMetavariableNodeQuery = nodeQuery("/satisfyingAssertion/metavariable");
+      satisfiesAssertionMetavariableNodeQuery = nodeQuery("/satisfiesAssertion/metavariable");
 
 export default domAssigned(class Reference {
   constructor(metavariable) {
@@ -228,9 +228,9 @@ export default domAssigned(class Reference {
     return reference;
   }
 
-  static fromSatisfyingAssertionNode(satisfyingAssertionNode, fileContext) {
-    const satisfyingAssertionMetavariableNode = satisfyingAssertionMetavariableNodeQuery(satisfyingAssertionNode),
-          metavariableNode = satisfyingAssertionMetavariableNode, ///
+  static fromSatisfiesAssertionNode(satisfiesAssertionNode, fileContext) {
+    const satisfiesAssertionMetavariableNode = satisfiesAssertionMetavariableNodeQuery(satisfiesAssertionNode),
+          metavariableNode = satisfiesAssertionMetavariableNode, ///
           reference = referenceFromMetavariableNode(metavariableNode, fileContext);
 
     return reference;

package/src/index.js

@@ -41,7 +41,7 @@ import PropertyRelation from "./dom/relation/property";
 import SubproofAssertion from "./dom/assertion/subproof";
 import PropertyAssertion from "./dom/assertion/property";
 import ContainedAssertion from "./dom/assertion/contained";
-import SatisfyingAssertion from "./dom/assertion/satisfying";
+import SatisfiesAssertion from "./dom/assertion/satisfies";
 import VariableDeclaration from "./dom/declaration/variable";
 import BracketedCombinator from "./dom/combinator/bracketed";
 import BracketedConstructor from "./dom/constructor/bracketed";

package/src/mixins/statement/verify.js

@@ -10,7 +10,7 @@ import { equalityFromStatement,
          propertyAssertionFromStatement,
          subproofAssertionFromStatement,
          containedAssertionFromStatement,
-         satisfyingAssertionFromStatement } from "../../utilities/context";
+         satisfiesAssertionFromStatement } from "../../utilities/context";
 
 function unifyWithBracketedCombinator(statement, assignments, stated, context) {
   stated = true;  ///
@@ -217,26 +217,26 @@ function verifyAsContainedAssertion(statement, assignments, stated, context) {
   return verifiedAsContainedAssertion;
 }
 
-function verifyAsSatisfyingAssertion(statement, assignments, stated, context) {
-  let verifiedAsSatisfyingAssertion = false;
+function verifyAsSatisfiesAssertion(statement, assignments, stated, context) {
+  let verifiedAsSatisfiesAssertion = false;
 
-  const satisfyingAssertion = satisfyingAssertionFromStatement(statement, context);
+  const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
 
-  if (satisfyingAssertion !== null) {
+  if (satisfiesAssertion !== null) {
     const statementString = statement.getString();
 
-    context.trace(`Verifying the '${statementString}' statement as a satisfying assertion...`);
+    context.trace(`Verifying the '${statementString}' statement as a satisfies assertion...`);
 
-    const satisfyingAssertionVerified = satisfyingAssertion.verify(assignments, stated, context);
+    const satisfiesAssertionVerified = satisfiesAssertion.verify(assignments, stated, context);
 
-    verifiedAsSatisfyingAssertion = satisfyingAssertionVerified; ///
+    verifiedAsSatisfiesAssertion = satisfiesAssertionVerified; ///
 
-    if (verifiedAsSatisfyingAssertion) {
-      context.debug(`...verified the '${statementString}' statement as a satisfying assertion.`);
+    if (verifiedAsSatisfiesAssertion) {
+      context.debug(`...verified the '${statementString}' statement as a satisfies assertion.`);
     }
   }
 
-  return verifiedAsSatisfyingAssertion;
+  return verifiedAsSatisfiesAssertion;
 }
 
 const verifyMixins = [
@@ -250,7 +250,7 @@ const verifyMixins = [
   verifyAsPropertyAssertion,
   verifyAsSubproofAssertion,
   verifyAsContainedAssertion,
-  verifyAsSatisfyingAssertion
+  verifyAsSatisfiesAssertion
 ];
 
 export default verifyMixins;

package/src/mixins/step/unify.js

@@ -7,7 +7,7 @@ import { equalityFromStatement,
          judgementFromStatement,
          typeAssertionFromStatement,
          propertyAssertionFromStatement,
-         satisfyingAssertionFromStatement } from "../../utilities/context";
+         satisfiesAssertionFromStatement } from "../../utilities/context";
 
 function unifyAWithRule(statement, reference, substitutions, context) {
   let unifiedWithRule = false;
@@ -65,40 +65,40 @@ function unifyAWithReference(statement, reference, substitutions, context) {
   return unifiedWithReference;
 }
 
-function unifyAsSatisfyingAssertion(statement, reference, substitutions, context) {
-  let unifiedAsSatisfyingAssertion = false;
+function unifyAsSatisfiesAssertion(statement, reference, substitutions, context) {
+  let unifiedAsSatisfiesAssertion = false;
 
   if (reference !== null) {
-    const satisfyingAssertion = satisfyingAssertionFromStatement(statement, context);
+    const satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
 
-    if (satisfyingAssertion !== null) {
+    if (satisfiesAssertion !== null) {
       const statementString = statement.getString();
 
-      context.trace(`Unifying the '${statementString}' statement as a satisfying assertion...`);
+      context.trace(`Unifying the '${statementString}' statement as a satisfies assertion...`);
 
       const axiomLemmaTheoremConjecture = context.findAxiomLemmaTheoremConjectureByReference(reference);
 
       if (axiomLemmaTheoremConjecture !== null) {
-        reference = satisfyingAssertion.getReference();
+        reference = satisfiesAssertion.getReference();
 
         const axiom = context.findAxiomByReference(reference),
               substitutions = Substitutions.fromNothing(),
               axiomLemmaTheoremConjectureUnified = axiom.unifyAxiomLemmaTheoremConjecture(axiomLemmaTheoremConjecture, substitutions, context);
 
         if (axiomLemmaTheoremConjectureUnified) {
-          const substitutionsMatch = satisfyingAssertion.matchSubstitutions(substitutions, context);
+          const substitutionsMatch = satisfiesAssertion.matchSubstitutions(substitutions, context);
 
-          unifiedAsSatisfyingAssertion = substitutionsMatch;  ///
+          unifiedAsSatisfiesAssertion = substitutionsMatch;  ///
         }
       }
 
-      if (unifiedAsSatisfyingAssertion) {
-        context.debug(`...unified the '${statementString}' statement as a satisfying assertion.`);
+      if (unifiedAsSatisfiesAssertion) {
+        context.debug(`...unified the '${statementString}' statement as a satisfies assertion.`);
       }
     }
   }
 
-  return unifiedAsSatisfyingAssertion;
+  return unifiedAsSatisfiesAssertion;
 }
 
 function unifyAWithAxiomLemmaTheoremOrConjecture(statement, reference, substitutions, context) {
@@ -253,7 +253,7 @@ function unifyWithStepsOrSubproofs(statement, reference, substitutions, context)
 const unifyMixins = [
   unifyAWithRule,
   unifyAWithReference,
-  unifyAsSatisfyingAssertion,
+  unifyAsSatisfiesAssertion,
   unifyAWithAxiomLemmaTheoremOrConjecture,
   unifyAsEquality,
   unifyAsJudgement,

package/src/utilities/context.js

@@ -93,14 +93,14 @@ export function containedAssertionFromStatement(statement, context) {
   return containedAssertion;
 }
 
-export function satisfyingAssertionFromStatement(statement, context) {
+export function satisfiesAssertionFromStatement(statement, context) {
   context = contextFromStatement(statement, context); ///
 
-  const { SatisfyingAssertion } = dom,
+  const { SatisfiesAssertion } = dom,
         statementNode = statement.getNode(),
-        satisfyingAssertion = SatisfyingAssertion.fromStatementNode(statementNode, context);
+        satisfiesAssertion = SatisfiesAssertion.fromStatementNode(statementNode, context);
 
-  return satisfyingAssertion;
+  return satisfiesAssertion;
 }
 
 function contextFromFrame(frame, context) {

package/src/utilities/json.js

@@ -84,10 +84,10 @@ export function deductionFromJSON(json, fileContext) {
   return deduction;
 }
 
-export function satisfyingFromJSON(json, fileContext) {
-  const { satisfying } = json;
+export function satisfiableFromJSON(json, fileContext) {
+  const { satisfiable } = json;
 
-  return satisfying;
+  return satisfiable;
 }
 
 export function conclusionFromJSON(json, fileContext) {