occam-verify-cli 1.0.906 → 1.0.911

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/process/unify.js

@@ -147,38 +147,6 @@ class StatementPass extends ZipPassBase {
   ];
 }
 
-class IntrinsicPass extends ZipPass {
-  static maps = [
-    {
-      generalNodeQuery: termVariableNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
-        let success = false;
-
-        const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode; ///
-
-        let context;
-
-        context = generalContext; ///
-
-        const variable = context.findVariableByVariableNode(variableNode);
-
-        context = specificContext;  ///
-
-        const term = context.findTermByTermNode(termNode),
-              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
-
-        if (termUnifies) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
 class CombinatorPass extends ZipPass {
   static maps = [
     {
@@ -402,12 +370,77 @@ class SubstitutionPass extends ZipPass {
   ];
 }
 
+class IntrinsicTermPass extends ZipPassBase {
+  static maps = [
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode; ///
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableNode(variableNode);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+class IntrinsicMetavariablePass extends ZipPass {
+  static maps = [
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode; ///
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableNode(variableNode);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
 const statementPass = new StatementPass(),
-      intrinsicPass = new IntrinsicPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
-      substitutionPass = new SubstitutionPass();
+      substitutionPass = new SubstitutionPass(),
+      intrinsicTermPass = new IntrinsicTermPass(),
+      intrinsicMetavariablePass = new IntrinsicMetavariablePass();
 
 export function unifyStatement(generalStatement, specificStatement, generalContext, specificContext) {
   let statementUnifies = false;
@@ -485,6 +518,22 @@ export function unifyStatementWithCombinator(statement, combinator, generalConte
   return statementUnifiesWithCombinator;
 }
 
+export function unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext) {
+  let termUnifiesIntrinsically = false;
+
+  const generalTermNode = generalTerm.getNode(),
+        specificTermNode = specificTerm.getNode(),
+        generalNode = generalTermNode, ///
+        specificNode = specificTermNode, ///
+        success = intrinsicTermPass.run(generalNode, specificNode, generalContext, specificContext);
+
+  if (success) {
+    termUnifiesIntrinsically = true;
+  }
+
+  return termUnifiesIntrinsically;
+}
+
 export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext) {
   let metavariableUnifiesIntrinsically = false;
 
@@ -492,7 +541,7 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
         specificMetavariableNode = specificMetavariable.getNode(),
         generalNode = generalMetavariableNode, ///
         specificNode = specificMetavariableNode, ///
-        success = intrinsicPass.run(generalNode, specificNode, generalContext, specificContext);
+        success = intrinsicMetavariablePass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     metavariableUnifiesIntrinsically = true;

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;
 }
@@ -331,11 +331,8 @@ export function signatureFromSignatureNode(signatureNode, context) {
         node = signatureNode, ///
         string = context.nodeAsString(node),
         lineIndex = null,
-        terms = termsFromSignatureNode(signatureNode, context);
-
-  context = null;
-
-  const signature = new Signature(context, string, node, lineIndex, terms);
+        terms = termsFromSignatureNode(signatureNode, context),
+        signature = new Signature(context, string, node, lineIndex, terms);
 
   return signature;
 }
@@ -402,20 +399,6 @@ export function parameterFromParameterNode(parameterNode, context) {
   return parameter;
 }
 
-export function signatureFromJSignatureNode(signatureNode, context) {
-  const { Signature } = elements,
-        node = signatureNode,
-        string = context.nodeAsString(node),
-        lineIndex = null,
-        terms = termsFromSignatureNode(signatureNode, context);
-
-  context = null;
-
-  const signature = new Signature(context, string, node, lineIndex, terms);
-
-  return signature;
-}
-
 export function hypothesisFromHypothesisNode(hypotheseNode, context) {
   const { Hypothsis } = elements,
         node = hypotheseNode, ///
@@ -760,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) {
@@ -1570,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) {
@@ -1852,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) {
@@ -1878,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;
@@ -1919,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 = signatureFromJSignatureNode(signatureNode, context);
+        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
 ];