occam-verify-cli 1.0.910 → 1.0.913

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/signature.js

@@ -5,8 +5,8 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { instantiateSignature } from "../process/instantiate";
-import { termsFromSignatureNode } from "../utilities/element";
-import { attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
+import { signatureFromSignatureNode } from "../utilities/element";
+import { attempt, reconcile, serialise, unserialise, instantiate, ablate } from "../utilities/context";
 
 const { match, compare, correlate } = arrayUtilities;
 
@@ -41,6 +41,22 @@ export default define(class Signature extends Element {
     return term;
   }
 
+  isEqualTo(signature) {
+    const signatureNode = signature.getNode(),
+          signatureNodeMatches = this.matchSignatureNode(signatureNode),
+          equalTo = signatureNodeMatches;  ///
+
+    return equalTo;
+  }
+
+  matchSignatureNode(signatureNode) {
+    const node = signatureNode, ///
+          nodeMatches = this.matchNode(node),
+          signatureNodeMatches = nodeMatches; ///
+
+    return signatureNodeMatches;
+  }
+
   findValidSignature(context) {
     const signatureNode = this.getSignatureNode(),
           signature = context.findSignatureBySignatureNode(signatureNode),
@@ -299,4 +315,30 @@ export default define(class Signature extends Element {
 
     return signature;
   }
+
+  static fromSignatureString(signatureString, context) {
+    let signature;
+
+    ablate((context) => {
+      instantiate((context) => {
+        const string = signatureString,  ///
+              signatureNode = instantiateSignature(string, context);
+
+        signature = signatureFromSignatureNode(signatureNode, context);
+      }, context);
+    }, context);
+
+    return signature;
+  }
 });
+
+function termsFromSignatureNode(signatureNode, context) {
+  const termNodes = signatureNode.getTermNodes(),
+        terms = termNodes.map((termNode) => {
+          const term = context.findTermByTermNode(termNode);
+
+          return term;
+        });
+
+  return terms;
+}

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

@@ -14,6 +14,7 @@ import { TERM_RULE_NAME,
          PARAMETER_RULE_NAME,
          STATEMENT_RULE_NAME,
          REFERENCE_RULE_NAME,
+         SIGNATURE_RULE_NAME,
          COMBINATOR_RULE_NAME,
          CONCLUSION_RULE_NAME,
          HYPOTHESIS_RULE_NAME,
@@ -33,7 +34,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";
@@ -51,6 +52,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       parameterPlaceholderRule = ruleFromRuleName(PARAMETER_RULE_NAME),
       statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
       referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
+      signaturePlaceholderRule = ruleFromRuleName(SIGNATURE_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
       conclusionPlaceholderRule = ruleFromRuleName(CONCLUSION_RULE_NAME),
       hypothesisPlaceholderRule = ruleFromRuleName(HYPOTHESIS_RULE_NAME),
@@ -70,7 +72,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);
@@ -125,6 +127,8 @@ export function instantiateStatement(string, context) { return instantiate(state
 
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
 
+export function instantiateSignature(string, context) { return instantiate(signaturePlaceholderRule, string, context); }
+
 export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
 
 export function instantiateHypothesis(string, context) { return instantiate(hypothesisPlaceholderRule, string, context); }
@@ -159,7 +163,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) {
@@ -1763,7 +1763,10 @@ export function signatureFromTopLevelAssertionNode(topLevelAsssertionNode, conte
   const signatureNode = topLevelAsssertionNode.getSignatureNode();
 
   if (signatureNode !== null) {
-    signature = signatureFromSignatureNode(signatureNode, context);
+    const { Signature } = elements,
+          signatureString = context.nodeAsString(signatureNode);
+
+    signature = Signature.fromSignatureString(signatureString, context);
   }
 
   return signature;
@@ -1835,16 +1838,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 +1864,17 @@ export function statementFromContainedAssertionNode(containedAssertionNode, cont
   return statement;
 }
 
-export function signatureFromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
-  const signatureNode = satisfiesAssertionNode.getSignatureNode(),
-        signature = signatureFromSignatureNode(signatureNode, context);
+export function signatureFromSignatureAssertionNode(signatureAssertionNode, context) {
+  const { Signature } = elements,
+        signatureNode = signatureAssertionNode.getSignatureNode(),
+        signatureString = context.nodeAsString(signatureNode),
+        signature = Signature.fromSignatureString(signatureString, 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,22 +1907,6 @@ export function statementFromBracketedCombinatorNode(bracketedCombinatorNode, co
   return statement;
 }
 
-export function signatureFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
-  const signatureNode = sasisfiesAssertionNode.getSignatureNode(),
-        signature = signatureFromSignatureNode(signatureNode, context);
-
-  return signature;
-}
-
-export function referenceFromJSatisfiesAssertionNode(sasisfiesAssertionNode, context) {
-  const { Reference } = elements,
-        referenceNode = sasisfiesAssertionNode.getReferenceNode(),
-        referenceString = context.nodeAsString(referenceNode),
-        reference = Reference.fromReferenceString(referenceString, context);
-
-  return reference;
-}
-
 export function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
         targetFrame = frameFromFrameNode(targetFrameNode, context);

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;