occam-verify-cli 1.0.910 → 1.0.911

package/src/element/proofAssertion/step.js

@@ -14,19 +14,19 @@ const { asyncSome } = asynchronousUtilities,
       { backwardsSome } = arrayUtilities;
 
 export default define(class Step extends ProofAssertion {
-  constructor(context, string, node, lineIndex, statement, reference, satisfiesAssertion) {
+  constructor(context, string, node, lineIndex, statement, reference, signatureAssertion) {
     super(context, string, node, lineIndex, statement);
 
     this.reference = reference;
-    this.satisfiesAssertion = satisfiesAssertion;
+    this.signatureAssertion = signatureAssertion;
   }
 
   getReference() {
     return this.reference;
   }
 
-  getSatisfiesAssertion() {
-    return this.satisfiesAssertion;
+  getSignatureAssertion() {
+    return this.signatureAssertion;
   }
 
   getStepNode() {
@@ -44,7 +44,7 @@ export default define(class Step extends ProofAssertion {
   }
 
   isSatisfied() {
-    const satisfied = (this.satisfiesAssertion !== null);
+    const satisfied = (this.signatureAssertion !== null);
 
     return satisfied;
   }
@@ -143,9 +143,9 @@ export default define(class Step extends ProofAssertion {
           const referenceValidates = this.validateReference(context);
 
           if (referenceValidates) {
-            const satisfiesAssertionValidates = this.validateSatisfiesAssertion(context);
+            const signatureAssertionValidates = this.validateSignatureAssertion(context);
 
-            if (satisfiesAssertionValidates) {
+            if (signatureAssertionValidates) {
               validates = true;
             }
           }
@@ -211,27 +211,27 @@ export default define(class Step extends ProofAssertion {
     return statementValidates;
   }
 
-  validateSatisfiesAssertion(context) {
-    let satisfiesAssertionValidates = true;  ///
+  validateSignatureAssertion(context) {
+    let signatureAssertionValidates = true;  ///
 
-    if (this.satisfiesAssertion !== null) {
+    if (this.signatureAssertion !== null) {
       const stepString = this.getString(),  ///
-            satisfiesAssertionString = this.satisfiesAssertion.getString();
+            signatureAssertionString = this.signatureAssertion.getString();
 
-      context.trace(`Validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion... `);
+      context.trace(`Validating the '${stepString}' step's '${signatureAssertionString}' signature assertion... `);
 
-      const satisfiesAssertion = this.satisfiesAssertion.validate(context);
+      const signatureAssertion = this.signatureAssertion.validate(context);
 
-      if (satisfiesAssertion === null) {
-        satisfiesAssertionValidates = false;
+      if (signatureAssertion === null) {
+        signatureAssertionValidates = false;
       }
 
-      if (satisfiesAssertionValidates) {
-        context.debug(`...validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion. `);
+      if (signatureAssertionValidates) {
+        context.debug(`...validating the '${stepString}' step's '${signatureAssertionString}' signature assertion. `);
       }
     }
 
-    return satisfiesAssertionValidates;
+    return signatureAssertionValidates;
   }
 
   async unify(context) {
@@ -264,15 +264,15 @@ export default define(class Step extends ProofAssertion {
     return unifies;
   }
 
-  unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
-    let unifiesWithSatisfiesAssertion = false;
+  unifyWithSignatureAssertion(signatureAssertion, context) {
+    let unifiesWithSignatureAssertion = false;
 
     const stepString = this.getString(), ///
-          satisfiesAssertionString = satisfiesAssertion.getString();
+          signatureAssertionString = signatureAssertion.getString();
 
-    context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`);
+    context.trace(`Unifying the '${stepString}' step with the '${signatureAssertionString}' signature assertion...`);
 
-    const reference = satisfiesAssertion.getReference(),
+    const reference = signatureAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
@@ -280,19 +280,19 @@ export default define(class Step extends ProofAssertion {
             stepUnifies = axiom.unifyStep(step, context);
 
       if (stepUnifies) {
-        const substitutionsCompare = satisfiesAssertion.compareSubstitutions(context);
+        const substitutionsCompare = signatureAssertion.compareSubstitutions(context);
 
         if (substitutionsCompare) {
-          unifiesWithSatisfiesAssertion = true;
+          unifiesWithSignatureAssertion = true;
         }
       }
     }
 
-    if (unifiesWithSatisfiesAssertion) {
-      context.debug(`...unified the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion.`);
+    if (unifiesWithSignatureAssertion) {
+      context.debug(`...unified the '${stepString}' step with the '${signatureAssertionString}' signature assertion.`);
     }
 
-    return unifiesWithSatisfiesAssertion;
+    return unifiesWithSignatureAssertion;
   }
 
   static name = "Step";

package/src/element/subproof.js

@@ -112,15 +112,15 @@ export default define(class Subproof extends Element {
     return subDerivationVerifies;
   }
 
-  unifyWithSatisfiesAssertion(satisfiesAssertion, context) {
-    let unifiesWithSatisfiesAssertion = false;
+  unifyWithSignatureAssertion(signatureAssertion, context) {
+    let unifiesWithSignatureAssertion = false;
 
     const subproofString = this.getString(), ///
-          satisfiesAssertionString = satisfiesAssertion.getString();
+          signatureAssertionString = signatureAssertion.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion...`)
+    context.trace(`Unifying the '${subproofString}' subproof with the '${signatureAssertionString}' signature assertion...`)
 
-    const reference = satisfiesAssertion.getReference(),
+    const reference = signatureAssertion.getReference(),
           axiom = context.findAxiomByReference(reference);
 
     if (axiom !== null) {
@@ -131,20 +131,20 @@ export default define(class Subproof extends Element {
               statementUnifies = axiom.unifySubproof(subproof, context);
 
         if (statementUnifies) {
-          const substitutionsCompare = satisfiesAssertion.compareSubstitutions(substitutions, context);
+          const substitutionsCompare = signatureAssertion.compareSubstitutions(substitutions, context);
 
           if (substitutionsCompare) {
-            unifiesWithSatisfiesAssertion = true;
+            unifiesWithSignatureAssertion = true;
           }
         }
       }
     }
 
-    if (unifiesWithSatisfiesAssertion) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${satisfiesAssertionString}' satisfies assertion.`)
+    if (unifiesWithSignatureAssertion) {
+      context.debug(`...unified the '${subproofString}' subproof with the '${signatureAssertionString}' signature assertion.`)
     }
 
-    return unifiesWithSatisfiesAssertion;
+    return unifiesWithSignatureAssertion;
   }
 
   static name = "Subproof";

package/src/node/assertion/{satisfies.js → signature.js}

@@ -4,7 +4,7 @@ import AssertionNode from "../../node/assertion";
 
 import { SIGNATURE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
-export default class SatisfiesAssertionNode extends AssertionNode {
+export default class SignatureAssertionNode extends AssertionNode {
   getSignatureNode() {
     const ruleName = SIGNATURE_RULE_NAME,
           signatureNode = this.getNodeByRuleName(ruleName);
@@ -19,5 +19,5 @@ export default class SatisfiesAssertionNode extends AssertionNode {
     return metavariableNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SatisfiesAssertionNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return AssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(SignatureAssertionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/qualification.js

@@ -2,7 +2,7 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { REFERENCE_RULE_NAME, SATISFIES_ASSERTION_RULE_NAME } from "../ruleNames";
+import { REFERENCE_RULE_NAME, SIGNATURE_ASSERTION_RULE_NAME } from "../ruleNames";
 
 export default class QualificationNode extends NonTerminalNode {
   getReferenceNode() {
@@ -13,7 +13,7 @@ export default class QualificationNode extends NonTerminalNode {
   }
 
   getSatisfiedAssertionNode() {
-    const ruleName = SATISFIES_ASSERTION_RULE_NAME,
+    const ruleName = SIGNATURE_ASSERTION_RULE_NAME,
           satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
 
     return satisfiedAssertionNode;

package/src/node/statement.js

@@ -14,7 +14,7 @@ import { TERM_RULE_NAME,
          PROPERTY_ASSERTION_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
-         SATISFIES_ASSERTION_RULE_NAME,
+         SIGNATURE_ASSERTION_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
@@ -136,7 +136,7 @@ export default class StatementNode extends NonTerminalNode {
   }
 
   getSatisfiedAssertionNode() {
-    const ruleName = SATISFIES_ASSERTION_RULE_NAME,
+    const ruleName = SIGNATURE_ASSERTION_RULE_NAME,
           satisfiedAssertionNode = this.getNodeByRuleName(ruleName);
 
     return satisfiedAssertionNode;

package/src/nonTerminalNodeMap.js

@@ -71,7 +71,7 @@ import FrameSubstitutionNode from "./node/substitution/frame";
 import ParenthesisedLabelNode from "./node/parenthesisedLabel";
 import ProcedureReferenceNode from "./node/procedureReference";
 import ContainedAssertionNode from "./node/assertion/contained";
-import SatisfiesAssertionNode from "./node/assertion/satisfies";
+import SignatureAssertionNode from "./node/assertion/signature";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import VariableDeclarationNode from "./node/declaration/variable";
@@ -156,7 +156,7 @@ import {
   FRAME_SUBSTITUTION_RULE_NAME,
   PROCEDURE_REFERENCE_RULE_NAME,
   CONTAINED_ASSERTION_RULE_NAME,
-  SATISFIES_ASSERTION_RULE_NAME,
+  SIGNATURE_ASSERTION_RULE_NAME,
   PARENTHESISED_LABEL_RULE_NAME,
   PARENTHESISED_LABELS_RULE_NAME,
   PROPERTY_DECLARATION_RULE_NAME,
@@ -242,7 +242,7 @@ const NonTerminalNodeMap = {
   [FRAME_SUBSTITUTION_RULE_NAME]: FrameSubstitutionNode,
   [PROCEDURE_REFERENCE_RULE_NAME]: ProcedureReferenceNode,
   [PARENTHESISED_LABEL_RULE_NAME]: ParenthesisedLabelNode,
-  [SATISFIES_ASSERTION_RULE_NAME]: SatisfiesAssertionNode,
+  [SIGNATURE_ASSERTION_RULE_NAME]: SignatureAssertionNode,
   [CONTAINED_ASSERTION_RULE_NAME]: ContainedAssertionNode,
   [PARENTHESISED_LABELS_RULE_NAME]: ParenthesisedLabelsNode,
   [VARIABLE_DECLARATION_RULE_NAME]: VariableDeclarationNode,

package/src/preamble.js

@@ -48,7 +48,7 @@ import SubproofAssertion from "./element/assertion/subproof";
 import PropertyAssertion from "./element/assertion/property";
 import ProcedureReference from "./element/procedureReference";
 import ContainedAssertion from "./element/assertion/contained";
-import SatisfiesAssertion from "./element/assertion/satisfies";
+import signatureAssertion from "./element/assertion/signature";
 import MetaLevelAssumption from "./element/assumption/metaLevel";
 import PropertyDeclaration from "./element/declaration/property";
 import VariableDeclaration from "./element/declaration/variable";

package/src/process/instantiate.js

@@ -33,7 +33,7 @@ import { TERM_RULE_NAME,
          FRAME_SUBSTITUTION_RULE_NAME,
          PROCEDURE_REFERENCE_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
-         SATISFIES_ASSERTION_RULE_NAME,
+         SIGNATURE_ASSERTION_RULE_NAME,
          META_LEVEL_ASSUMPTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
@@ -70,7 +70,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
       procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
-      satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
+      signatureAssertionPlaceholderRule = ruleFromRuleName(SIGNATURE_ASSERTION_RULE_NAME),
       metaLevelAssumptionPlaceholderRule = ruleFromRuleName(META_LEVEL_ASSUMPTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
@@ -159,7 +159,7 @@ export function instantiateProcedureReference(string, context) { return instanti
 
 export function instantiateContainedAssertion(string, context) { return instantiate(containedAssertionPlaceholderRule, string, context); }
 
-export function instantiateSatisfiesAssertion(string, context) { return instantiate(satisfiesAssertionPlaceholderRule, string, context); }
+export function instantiateSignatureAssertion(string, context) { return instantiate(signatureAssertionPlaceholderRule, string, context); }
 
 export function instantiateMetaLevelAssumption(string, context) { return instantiate(metaLevelAssumptionPlaceholderRule, string, context); }
 

package/src/ruleNames.js

@@ -71,7 +71,7 @@ export const FRAME_SUBSTITUTION_RULE_NAME = "frameSubstitution";
 export const PARENTHESISED_LABEL_RULE_NAME = "parenthesisedLabel";
 export const PROCEDURE_REFERENCE_RULE_NAME = "procedureReference";
 export const CONTAINED_ASSERTION_RULE_NAME = "containedAssertion";
-export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
+export const SIGNATURE_ASSERTION_RULE_NAME = "signatureAssertion";
 export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";

package/src/utilities/element.js

@@ -62,11 +62,11 @@ export function stepFromStepNode(stepNode, context) {
         lineIndex = null,
         statement = statementFromStepNode(stepNode, context),
         reference = referenceFromStepNode(stepNode, context),
-        satisfiesAssertion = satisfiesAssertionFromStepNode(stepNode, context);
+        signatureAssertion = signatureAssertionFromStepNode(stepNode, context);
 
   context = null;
 
-  const step = new Step(context, string, node, lineIndex, statement, reference, satisfiesAssertion);
+  const step = new Step(context, string, node, lineIndex, statement, reference, signatureAssertion);
 
   return step;
 }
@@ -743,19 +743,19 @@ export function containedAssertionFromContainedAssertionNode(containedAssertionN
   return containedAssertion;
 }
 
-export function satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const { SatisfiesAssertion } = elements,
-        node = satisfiesAssertionNode,  ///
+export function signatureAssertionFromSignatureAssertionNode(signatureAssertionNode, context) {
+  const { SignatureAssertion } = elements,
+        node = signatureAssertionNode,  ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        signature = signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context),
-        reference = referenceFromSatisfiesAssertionNode(satisfiesAssertionNode, context);
+        signature = signatureFromSignatureAssertionNode(signatureAssertionNode, context),
+        reference = referenceFromSignatureAssertionNode(signatureAssertionNode, context);
 
   context = null;
 
-  const satisfiesAssertion = new SatisfiesAssertion(context, string, node, lineIndex, signature, reference);
+  const signatureAssertion = new SignatureAssertion(context, string, node, lineIndex, signature, reference);
 
-  return satisfiesAssertion;
+  return signatureAssertion;
 }
 
 export function procedureReferenceFromProcedureReferenceNode(procedureReferenceNode, context) {
@@ -1553,16 +1553,16 @@ export function termFromPropertyAssertionNode(propertyAssertionNode, context) {
   return term;
 }
 
-export function satisfiesAssertionFromStepNode(stepNode, context) {
-  let satisfiesAssertion = null;
+export function signatureAssertionFromStepNode(stepNode, context) {
+  let signatureAssertion = null;
 
-  const satisfiesAssertionNode = stepNode.getSatisfiedAssertionNode();
+  const signatureAssertionNode = stepNode.getSatisfiedAssertionNode();
 
-  if (satisfiesAssertionNode !== null) {
-    satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);
+  if (signatureAssertionNode !== null) {
+    signatureAssertion = signatureAssertionFromSignatureAssertionNode(signatureAssertionNode, context);
   }
 
-  return satisfiesAssertion;
+  return signatureAssertion;
 }
 
 export function typeAssertionFromStatementNode(statementNode, context) {
@@ -1835,16 +1835,16 @@ export function containedAssertionFromStatementNode(statementNode, context) {0
   return containedAssertion;
 }
 
-export function satisfiesAssertionFromStatementNode(statementNode, context) {
-  let satisfiesAssertion = null;
+export function signatureAssertionFromStatementNode(statementNode, context) {
+  let signatureAssertion = null;
 
-  const satisfiesAssertionNode = statementNode.getSatisfiedAssertionNode();
+  const signatureAssertionNode = statementNode.getSatisfiedAssertionNode();
 
-  if (satisfiesAssertionNode !== null) {
-    satisfiesAssertion = satisfiesAssertionFromSatisfiesAssertionNode(satisfiesAssertionNode, context);
+  if (signatureAssertionNode !== null) {
+    signatureAssertion = signatureAssertionFromSignatureAssertionNode(signatureAssertionNode, context);
   }
 
-  return satisfiesAssertion;
+  return signatureAssertion;
 }
 
 export function statementsFromSubproofAssertionNode(subproofAssertionNode, context) {
@@ -1861,15 +1861,15 @@ export function statementFromContainedAssertionNode(containedAssertionNode, cont
   return statement;
 }
 
-export function signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const signatureNode = satisfiesAssertionNode.getSignatureNode(),
+export function signatureFromSignatureAssertionNode(signatureAssertionNode, context) {
+  const signatureNode = signatureAssertionNode.getSignatureNode(),
         signature = signatureFromSignatureNode(signatureNode, context);
 
   return signature;
 }
 
-export function referenceFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const metavariableNode = satisfiesAssertionNode.getMetavariableNode(),
+export function referenceFromSignatureAssertionNode(signatureAssertionNode, context) {
+  const metavariableNode = signatureAssertionNode.getMetavariableNode(),
         reference = referenceFromMetavariableNode(metavariableNode, context);
 
   return reference;
@@ -1902,14 +1902,14 @@ export function statementFromBracketedCombinatorNode(bracketedCombinatorNode, co
   return statement;
 }
 
-export function signatureFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
+export function signatureFromJSignatureAssertionNode(sasisfiesAssertionNode, context) {
   const signatureNode = sasisfiesAssertionNode.getSignatureNode(),
         signature = signatureFromSignatureNode(signatureNode, context);
 
   return signature;
 }
 
-export function referenceFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
+export function referenceFromJSignatureAssertionNode(sasisfiesAssertionNode, context) {
   const { Reference } = elements,
         referenceNode = sasisfiesAssertionNode.getReferenceNode(),
         referenceString = context.nodeAsString(referenceNode),

package/src/utilities/json.js

@@ -496,7 +496,7 @@ export function statementsFromJSON(json, context) {
 export function assertionsFromJSON(json, context) {
   let { assertions } = json;
 
-  const { TypeAssertion, DefinedAssertion, PropertyAssertion, SubproofAssertion, SatisfiesAssertion, ContainedAssertion } = elements,
+  const { TypeAssertion, DefinedAssertion, PropertyAssertion, SubproofAssertion, SignatureAssertion, ContainedAssertion } = elements,
         assertionsJSON = assertions; ///
 
   assertions = assertionsJSON.map((assertionJSON) => {
@@ -505,7 +505,7 @@ export function assertionsFromJSON(json, context) {
                        DefinedAssertion.fromJSON(json, context) ||
                        PropertyAssertion.fromJSON(json, context) ||
                        SubproofAssertion.fromJSON(json, context) ||
-                       SatisfiesAssertion.fromJSON(json, context) ||
+                       SignatureAssertion.fromJSON(json, context) ||
                        ContainedAssertion.fromJSON(json, context);
 
     return assertion;

package/src/utilities/unification.js

@@ -83,20 +83,20 @@ async function unifyStepWithReference(step, context) {
   return stepUnifiesWithReference;
 }
 
-async function unifyStepAsSatisfiesAssertion(step, context) {
-  let stepUnifiesAsSatisfiesAssertion = false;
+async function unifyStepAsSignatureAssertion(step, context) {
+  let stepUnifiesAsSignatureAssertion = false;
 
-  const { SatisfiesAssertion } = elements;
+  const { SignatureAssertion } = elements;
 
-  const satisfiesAssertion = SatisfiesAssertion.fromStep(step, context);
+  const signatureAssertion = SignatureAssertion.fromStep(step, context);
 
-  if (satisfiesAssertion !== null) {
+  if (signatureAssertion !== null) {
     const stepString = step.getString();
 
-    context.trace(`Unifying the '${stepString}' step as a satisfies assertion...`);
+    context.trace(`Unifying the '${stepString}' step as a signature assertion...`);
 
     descend((context) => {
-      satisfiesAssertion.verifySignature(context);
+      signatureAssertion.verifySignature(context);
     }, context);
 
     const unqualified = step.isUnqualified();
@@ -104,15 +104,15 @@ async function unifyStepAsSatisfiesAssertion(step, context) {
     if (unqualified) {
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
 
-      stepUnifiesAsSatisfiesAssertion = backwardsSome(subproofOrProofAssertions, (stepsOrSubproof) => {
-        const stepOrSubProofUnifiesWIthSatisfiesAssertion = stepsOrSubproof.unifyWithSatisfiesAssertion(satisfiesAssertion, context);
+      stepUnifiesAsSignatureAssertion = backwardsSome(subproofOrProofAssertions, (stepsOrSubproof) => {
+        const stepOrSubProofUnifiesWIthSignatureAssertion = stepsOrSubproof.unifyWithSignatureAssertion(signatureAssertion, context);
 
-        if (stepOrSubProofUnifiesWIthSatisfiesAssertion) {
+        if (stepOrSubProofUnifiesWIthSignatureAssertion) {
           return true;
         }
       });
     } else {
-      const reference = satisfiesAssertion.getReference(),
+      const reference = signatureAssertion.getReference(),
             topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
       if (topLevelAssertion !== null) {
@@ -125,10 +125,10 @@ async function unifyStepAsSatisfiesAssertion(step, context) {
             const topLevelAssertionUnifies = axiom.unifyTopLevelAssertion(topLevelAssertion, context);
 
             if (topLevelAssertionUnifies) {
-              const substitutionsCorrelates = satisfiesAssertion.correlateSubstitutions(substitutions, context);
+              const substitutionsCorrelates = signatureAssertion.correlateSubstitutions(substitutions, context);
 
               if (substitutionsCorrelates) {
-                stepUnifiesAsSatisfiesAssertion = true;
+                stepUnifiesAsSignatureAssertion = true;
               }
             }
           } else {
@@ -140,12 +140,12 @@ async function unifyStepAsSatisfiesAssertion(step, context) {
       }
     }
 
-    if (stepUnifiesAsSatisfiesAssertion) {
-      context.debug(`...unified the '${stepString}' step as a satisfies assertion.`);
+    if (stepUnifiesAsSignatureAssertion) {
+      context.debug(`...unified the '${stepString}' step as a signature assertion.`);
     }
   }
 
-  return stepUnifiesAsSatisfiesAssertion;
+  return stepUnifiesAsSignatureAssertion;
 }
 
 async function unifyStepWithTopLevelAssertion(step, context) {
@@ -301,30 +301,30 @@ async function unifyStepAsPropertyAssertion(step, context) {
   return stepUnifiesAsPropertyAssertion;
 }
 
-async function unifyStepWithSatisfiesAssertion(step, context) {
-  let stepUnifiesWithSatisfiesAssertion = false;
+async function unifyStepWithSignatureAssertion(step, context) {
+  let stepUnifiesWithSignatureAssertion = false;
 
-  const satisfiesAssertion = step.getSatisfiesAssertion();
+  const signatureAssertion = step.getSignatureAssertion();
 
-  if (satisfiesAssertion !== null) {
+  if (signatureAssertion !== null) {
     const stepString = step.getString(),
-          satisfiesAssertionString = satisfiesAssertion.getString();
+          signatureAssertionString = signatureAssertion.getString();
 
-    context.trace(`Unifying the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion...`);
+    context.trace(`Unifying the '${stepString}' step with the '${signatureAssertionString}' signature assertion...`);
 
     const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
-          stepUnifies = satisfiesAssertion.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
+          stepUnifies = signatureAssertion.unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context);
 
     if (stepUnifies) {
-      stepUnifiesWithSatisfiesAssertion = true;
+      stepUnifiesWithSignatureAssertion = true;
     }
 
-    if (stepUnifiesWithSatisfiesAssertion) {
-      context.debug(`...unified the '${stepString}' step with the '${satisfiesAssertionString}' satisfies assertion.`);
+    if (stepUnifiesWithSignatureAssertion) {
+      context.debug(`...unified the '${stepString}' step with the '${signatureAssertionString}' signature assertion.`);
     }
   }
 
-  return stepUnifiesWithSatisfiesAssertion;
+  return stepUnifiesWithSignatureAssertion;
 }
 
 async function compareStepWithSubproofOrProofAssertions(step, context) {
@@ -355,12 +355,12 @@ async function compareStepWithSubproofOrProofAssertions(step, context) {
 export const unifySteps = [
   unifyStepWithRule,
   unifyStepWithReference,
-  unifyStepAsSatisfiesAssertion,
+  unifyStepAsSignatureAssertion,
   unifyStepWithTopLevelAssertion,
   unifyStepAsEquality,
   unifyStepAsJudgement,
   unifyStepAsTypeAssertion,
   unifyStepAsPropertyAssertion,
-  unifyStepWithSatisfiesAssertion,
+  unifyStepWithSignatureAssertion,
   compareStepWithSubproofOrProofAssertions
 ];

package/src/utilities/validation.js

@@ -356,32 +356,32 @@ function validateStatementAsContainedAssertion(statement, context) {
   return validatesStatementAsContainedAssertion;
 }
 
-function validateStatementAsSatisfiesAssertion(statement, context) {
-  let validatesAStatementsSatisfiesAssertion = false;
+function validateStatementAsSignatureAssertion(statement, context) {
+  let validatesAStatementsSignatureAssertion = false;
 
-  const { SatisfiesAssertion } = elements;
+  const { SignatureAssertion } = elements;
 
-  let satisfiesAssertion;
+  let signatureAssertion;
 
-  satisfiesAssertion = SatisfiesAssertion.fromStatement(statement, context);
+  signatureAssertion = SignatureAssertion.fromStatement(statement, context);
 
-  if (satisfiesAssertion !== null) {
+  if (signatureAssertion !== null) {
     const statementString = statement.getString();
 
-    context.trace(`Validating the '${statementString}' statement as a satisfies assertion...`);
+    context.trace(`Validating the '${statementString}' statement as a signature assertion...`);
 
-    satisfiesAssertion = satisfiesAssertion.validate(context);  ///
+    signatureAssertion = signatureAssertion.validate(context);  ///
 
-    if (satisfiesAssertion !== null) {
-      validatesAStatementsSatisfiesAssertion = true;
+    if (signatureAssertion !== null) {
+      validatesAStatementsSignatureAssertion = true;
     }
 
-    if (validatesAStatementsSatisfiesAssertion) {
-      context.debug(`...validated the '${statementString}' statement as a satisfies assertion.`);
+    if (validatesAStatementsSignatureAssertion) {
+      context.debug(`...validated the '${statementString}' statement as a signature assertion.`);
     }
   }
 
-  return validatesAStatementsSatisfiesAssertion;
+  return validatesAStatementsSignatureAssertion;
 }
 
 export const validateTerms = [
@@ -401,5 +401,5 @@ export const validateStatements = [
   validateStatementAsPropertyAssertion,
   validateStatementAsSubproofAssertion,
   validateStatementAsContainedAssertion,
-  validateStatementAsSatisfiesAssertion
+  validateStatementAsSignatureAssertion
 ];