occam-nominal 1.0.307 → 1.0.310

package/src/element/statement.js

@@ -205,15 +205,17 @@ export default define(class Statement extends Element {
       return;
     }
 
-    let statement = this;
+    const statement = this;
 
     exists(validateStatements, statement, context, (statementValidates) => {
+      let statement = null;
+
       if (statementValidates) {
+        statement = this;
+
         context.addStatement(statement);
 
         context.debug(`...validated the '${statementString}' statement.`);
-      } else {
-        statement = null;
       }
 
       continuation(statement);
@@ -257,7 +259,7 @@ export default define(class Statement extends Element {
         context.debug(`...unified the '${specificStatementString}' statement with the '${generalStatementString}' statement.`);
       }
 
-      continuation(statementUnifies);
+      return continuation(statementUnifies);
     });
   }
 

package/src/element/subDerivation.js

@@ -35,7 +35,7 @@ export default define(class SubDerivation extends Element {
   }
 
   verify(context, continuation) {
-    every(this.subproofOrProofAssertions, (subproofOrProofAssertion, continuation) => {
+    return every(this.subproofOrProofAssertions, (subproofOrProofAssertion, continuation) => {
       subproofOrProofAssertion.verify(context, (subproofOrProofAssertionVerifies) => {
         if (subproofOrProofAssertionVerifies) {
           context.assignAssignments();
@@ -43,7 +43,7 @@ export default define(class SubDerivation extends Element {
           context.addSubproofOrProofAssertion(subproofOrProofAssertion);
         }
 
-        continuation(subproofOrProofAssertionVerifies);
+        return continuation(subproofOrProofAssertionVerifies);
       });
     }, continuation);
   }

package/src/element/subproof.js

@@ -94,7 +94,7 @@ export default define(class Subproof extends Element {
       const verifySuppositions = this.verifySuppositions.bind(this),
             verifySubDerivation = this.verifySubDerivation.bind(this);
 
-      all([
+      return all([
         verifySuppositions,
         verifySubDerivation
       ], context, continuation);
@@ -111,18 +111,18 @@ export default define(class Subproof extends Element {
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
       }
 
-      continuation(suppositionVerifies);
+      return continuation(suppositionVerifies);
     });
   }
 
   verifySuppositions(context, continuation) {
-    every(this.suppositions, (supposition, continuation) => {
-      this.verifySupposition(supposition, context, continuation);
+    return every(this.suppositions, (supposition, continuation) => {
+      return this.verifySupposition(supposition, context, continuation);
     }, continuation);
   }
 
   verifySubDerivation(context, continuation) {
-    this.subDerivation.verify(context, continuation);
+    return this.subDerivation.verify(context, continuation);
   }
 
   static name = "Subproof";

package/src/element/substitution/frame.js

@@ -9,7 +9,7 @@ import { define } from "../../elements";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
-import { elide, ablate, ablates, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
+import { elide, ablates, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
 
 const { breakPointFromJSON } = breakPointUtilities;
 
@@ -337,12 +337,10 @@ export default define(class FrameSubstitution extends Substitution {
     const frameSubstitutionNode = statement.getFrameSubstitutionNode();
 
     if (frameSubstitutionNode !== null) {
-      ablate((context) => {
-        const generalContext = context, ///
-              specificContext = context;  ///
+      const generalContext = context, ///
+            specificContext = context;  ///
 
-        frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
-      }, context);
+      frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, generalContext, specificContext);
     }
 
     return frameSubstitution;

package/src/element/substitution/term.js

@@ -10,7 +10,7 @@ import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
-import { elide, ablate, ablates, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
+import { elide, ablates, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
 
 const { breakPointFromJSON } = breakPointUtilities;
 
@@ -340,12 +340,10 @@ export default define(class TermSubstitution extends Substitution {
     const termSubstitutionNode = statement.getTermSubstitutionNode();
 
     if (termSubstitutionNode !== null) {
-      ablate((context) => {
-        const generalContext = context, ///
-              specificContext = context;  ///
+      const generalContext = context, ///
+            specificContext = context;  ///
 
-        termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, generalContext, specificContext);
-      }, context);
+      termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, generalContext, specificContext);
     }
 
     return termSubstitution;

package/src/element/term.js

@@ -212,53 +212,51 @@ export default define(class Term extends Element {
     });
   }
 
-  validateGivenType(type, strict, context) {
-    if (context === undefined) {
+  validateGivenType(type, strict, context, continuation) {
+    if (continuation === undefined) {
+      continuation = context; ///
+
       context = strict; ///
 
       strict = true;
     }
 
-    let term;
-
     const typeString = type.getString(),
           termString = this.getString();  ///
 
     context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
-    let validatesGivenType = false;
-
-    term = this.validate(context, (term, context) => {
-      let validatesForwards = false;
+    this.validate(context, (term, context) => {
+      let validatesGivenType = false;
 
-      const termType = term.getType(),
-            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+      if (term !== null) {
+        const termType = term.getType(),
+              termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
-      if (termTypeEqualToOrSubTypeOfType) {
-        validatesForwards = true;
+        if (termTypeEqualToOrSubTypeOfType) {
+          validatesGivenType = true;
 
-        if (strict) {
-          const typeEstablished = type.isEstablished(),
-                termProvisional = term.isProvisional();
+          if (strict) {
+            const typeEstablished = type.isEstablished(),
+                  termProvisional = term.isProvisional();
 
-          if (typeEstablished && termProvisional) {
-            validatesForwards = false;
+            if (typeEstablished && termProvisional) {
+              validatesGivenType = false;
+            }
           }
         }
       }
 
-      return validatesForwards;
-    });
-
-    if (term !== null) {
-      validatesGivenType = true;
-    }
+      if (!validatesGivenType) {
+        term = null;
+      }
 
-    if (validatesGivenType) {
-      context.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
-    }
+      if (validatesGivenType) {
+        context.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
+      }
 
-    return term;
+      return continuation(term);
+    });
   }
 
   validateAsProperty(context, validateForwards) {

package/src/element/topLevelAssertion.js

@@ -123,8 +123,8 @@ export default class TopLevelAssertion extends Element {
 
     context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's labels...`);
 
-    every(this.labels, (label, continuation) => {
-      this.verifyLabel(label, context, continuation);
+    return every(this.labels, (label, continuation) => {
+      return this.verifyLabel(label, context, continuation);
     }, (labelsVerify) => {
       if (labelsVerify) {
         context.debug(`...verified the '${topLevelAssertionString}' top level assertion's labels.`);
@@ -216,8 +216,8 @@ export default class TopLevelAssertion extends Element {
 
     context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's suppositions...`);
 
-    forwardsEvery(this.suppositions, (supposition, continuation) => {
-      this.verifySupposition(supposition, context, continuation);
+    return forwardsEvery(this.suppositions, (supposition, continuation) => {
+      return this.verifySupposition(supposition, context, continuation);
     }, (suppositionsVerify) => {
       if (suppositionsVerify) {
         context.debug(`...verified the '${topLevelAssertionString}' top level assertion's suppositions.`);

package/src/pass/continuationZip.js

@@ -8,6 +8,6 @@ export default class ContinuationZipPass extends ContinuationZipPassBase {
           generalChildNodes = generalNonTerminalNode.getChildNodes(), ///
           specificChildNodes = specificNonTerminalNode.getChildNodes(); ///
 
-    this.descend(generalChildNodes, specificChildNodes, ...remainingArguments, continuation);
+    return this.descend(generalChildNodes, specificChildNodes, ...remainingArguments, continuation);
   }
 }

package/src/process/unify.js

@@ -223,7 +223,6 @@ class MetaLevelPass extends ContinuationZipPassBase {
         metavariable.unifyFrame(frame, generalContext, specificContext, (frameUnifies) => {
           let success = false;
 
-
           if (frameUnifies) {
             success = true;
           }
@@ -489,14 +488,14 @@ export function unifyStatement(generalStatement, specificStatement, generalConte
         generalNode = generalStatementNode, ///
         specificNode = specificStatementNode;  ///
 
-  metaLevelPass.run(generalNode, specificNode, generalContext, specificContext, continuation);
+  return metaLevelPass.run(generalNode, specificNode, generalContext, specificContext, continuation);
 }
 
 export function unifyMetavariable(generalMetavariable, specificMetavariable, generalContext, specificContext, continuation) {
   const generalMetavariableNode = generalMetavariable.getNode(),
         specificMetavariableNode = specificMetavariable.getNode();
 
-  metavariablePass.run(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext, continuation);
+  return metavariablePass.run(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext, continuation);
 }
 
 export function unifyTermWithProperty(term, property, generalContext, specificContext, continuation) {
@@ -504,7 +503,7 @@ export function unifyTermWithProperty(term, property, generalContext, specificCo
         propertyTerm = property.getTerm(),
         propertyTermNode = propertyTerm.getNode();
 
-  propertyPass.run(propertyTermNode, termNode, generalContext, specificContext, continuation);
+  return propertyPass.run(propertyTermNode, termNode, generalContext, specificContext, continuation);
 }
 
 export function unifyTermWithGenerator(term, generator, generalContext, specificContext, continuation) {
@@ -512,7 +511,7 @@ export function unifyTermWithGenerator(term, generator, generalContext, specific
         generatorTerm = generator.getTerm(),
         generatorTermNode = generatorTerm.getNode();
 
-  generatorPass.run(generatorTermNode, termNode, generalContext, specificContext, continuation);
+  return generatorPass.run(generatorTermNode, termNode, generalContext, specificContext, continuation);
 }
 
 export function unifyTermWithConstructor(term, constructor, generalContext, specificContext, continuation) {
@@ -520,7 +519,7 @@ export function unifyTermWithConstructor(term, constructor, generalContext, spec
         constructorTerm = constructor.getTerm(),
         constructorTermNode = constructorTerm.getNode();
 
-  constructorPass.run(constructorTermNode, termNode, generalContext, specificContext, continuation);
+  return constructorPass.run(constructorTermNode, termNode, generalContext, specificContext, continuation);
 }
 
 export function unifyStatementWithCombinator(statement, combinator, generalContext, specificContext, continuation) {
@@ -528,7 +527,7 @@ export function unifyStatementWithCombinator(statement, combinator, generalConte
         combinatorStatement = combinator.getStatement(),
         combinatorStatementNode = combinatorStatement.getNode();
 
-  combinatorPass.run(combinatorStatementNode, statementNode, generalContext, specificContext, continuation);
+  return combinatorPass.run(combinatorStatementNode, statementNode, generalContext, specificContext, continuation);
 }
 
 export function unifyTermIntrinsically(generalTerm, specificTerm, generalContext, specificContext, continuation) {
@@ -537,7 +536,7 @@ export function unifyTermIntrinsically(generalTerm, specificTerm, generalContext
         generalNode = generalTermNode, ///
         specificNode = specificTermNode; ///
 
-  intrinsicTermPass.run(generalNode, specificNode, generalContext, specificContext, continuation);
+  return intrinsicTermPass.run(generalNode, specificNode, generalContext, specificContext, continuation);
 }
 
 export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext, continuation) {
@@ -546,5 +545,5 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
         generalNode = generalMetavariableNode, ///
         specificNode = specificMetavariableNode;
 
-  intrinsicMetavariablePass.run(generalNode, specificNode, generalContext, specificContext, continuation);
+  return intrinsicMetavariablePass.run(generalNode, specificNode, generalContext, specificContext, continuation);
 }

package/src/process/validate.js

@@ -17,7 +17,7 @@ class PropertyPass extends ContinuationPass {
     const nonTerminalNode = termNode,  ///
           childNodes = nonTerminalNode.getChildNodes();
 
-    this.descend(childNodes, context, continuation);
+    return this.descend(childNodes, context, continuation);
   }
 
   static maps = [
@@ -60,7 +60,7 @@ class GeneratorPass extends ContinuationPass {
     const nonTerminalNode = termNode,  ///
           childNodes = nonTerminalNode.getChildNodes();
 
-    this.descend(childNodes, context, continuation);
+    return this.descend(childNodes, context, continuation);
   }
 
   static maps = [
@@ -103,7 +103,7 @@ class CombinatorPass extends ContinuationPass {
     const nonTerminalNode = statementNode,  ///
           childNodes = nonTerminalNode.getChildNodes();
 
-    this.descend(childNodes, context, continuation);
+    return this.descend(childNodes, context, continuation);
   }
 
   static maps = [
@@ -164,7 +164,7 @@ class ConstructorPass extends ContinuationPass {
     const nonTerminalNode = termNode,  ///
           childNodes = nonTerminalNode.getChildNodes();
 
-    this.descend(childNodes, context, continuation);
+    return this.descend(childNodes, context, continuation);
   }
 
   static maps = [
@@ -210,23 +210,23 @@ const propertyPass = new PropertyPass(),
 export function validateTermAsProperty(term, context, continuation) {
   const termNode = term.getNode();
 
-  propertyPass.run(termNode, context, continuation);
+  return propertyPass.run(termNode, context, continuation);
 }
 
 export function validateTermAsGenerator(term, context, continuation) {
   const termNode = term.getNode();
 
-  generatorPass.run(termNode, context, continuation);
+  return generatorPass.run(termNode, context, continuation);
 }
 
 export function validateTermAsConstructor(term, context, continuation) {
   const termNode = term.getNode();
 
-  constructorPass.run(termNode, context, continuation);
+  return constructorPass.run(termNode, context, continuation);
 }
 
 export function validateStatementAsCombinator(statement, context, continuation) {
   const statementNode = statement.getNode();
 
-  combinatorPass.run(statementNode, context, continuation);
+  return combinatorPass.run(statementNode, context, continuation);
 }

package/src/process/validation.js

@@ -165,9 +165,9 @@ function validateStatementAsMetavariable(statement, context, continuation) {
 function unifyStatementWithCombinators(statement, context, continuation) {
   const combinators = context.getCombinators();
 
-  some(combinators, (combinator, continuation) => {
+  return some(combinators, (combinator, continuation) => {
     descend((context) => {
-      combinator.unifyStatement(statement, context, continuation);
+      return combinator.unifyStatement(statement, context, continuation);
     }, context);
   }, continuation);
 }
@@ -175,7 +175,7 @@ function unifyStatementWithCombinators(statement, context, continuation) {
 function unifyStatementWithBracketedCombinator(statement, context, continuation) {
   const bracketedCombinator = bracketedCombinatorFromNothing();
 
-  bracketedCombinator.unifyStatement(statement, context, continuation);
+  return bracketedCombinator.unifyStatement(statement, context, continuation);
 }
 
 function validateStatementAsEquality(statement, context, continuation) {
@@ -221,7 +221,7 @@ function validateStatementAsJudgement(statement, context, continuation) {
 
   context.trace(`Validating the '${statementString}' statement as a judgement...`);
 
-  judgement.validate(context, (jusgement) => {
+  judgement.validate(context, (judgement) => {
     let validatesStatementAsJudgement = false;
 
     if (judgement !== null) {

package/src/process/verify.js

@@ -46,7 +46,7 @@ class TopLevelPass extends ContinuationPass {
       run: (errorNode, context, continuation) => {
         const error = errorFromErrorNode(errorNode, context);
 
-        error.verify(context, continuation);
+        return error.verify(context, continuation);
       }
     },
     {
@@ -54,7 +54,7 @@ class TopLevelPass extends ContinuationPass {
       run: (ruleNode, context, continuation) => {
         const rule = ruleFromRuleNode(ruleNode, context);
 
-        rule.verify(context, continuation);
+        return rule.verify(context, continuation);
       }
     },
     {
@@ -62,7 +62,7 @@ class TopLevelPass extends ContinuationPass {
       run: (axiomNode, context, continuation) => {
         const axiom = axiomFromAxiomNode(axiomNode, context);
 
-        axiom.verify(context, continuation);
+        return axiom.verify(context, continuation);
       }
     },
     {
@@ -70,7 +70,7 @@ class TopLevelPass extends ContinuationPass {
       run: (lemmaNode, context, continuation) => {
         const lemma = lemmaFromLemmaNode(lemmaNode, context);
 
-        lemma.verify(context, continuation);
+        return lemma.verify(context, continuation);
       }
     },
     {
@@ -78,7 +78,7 @@ class TopLevelPass extends ContinuationPass {
       run: (schemaNode, context, continuation) => {
         const schema = schemaFromSchemaNode(schemaNode, context);
 
-        schema.verify(context, continuation);
+        return schema.verify(context, continuation);
       }
     },
     {
@@ -86,7 +86,7 @@ class TopLevelPass extends ContinuationPass {
       run: (sectionNode, context, continuation) => {
         const section = sectionFromSectionNode(sectionNode, context);
 
-        section.verify(context, continuation);
+        return section.verify(context, continuation);
       }
     },
     {
@@ -94,7 +94,7 @@ class TopLevelPass extends ContinuationPass {
       run: (theoremNode, context, continuation) => {
         const theorem = theoremFromTheoremNode(theoremNode, context);
 
-        theorem.verify(context, continuation);
+        return theorem.verify(context, continuation);
       }
     },
     {
@@ -102,7 +102,7 @@ class TopLevelPass extends ContinuationPass {
       run: (conjectureNode, context, continuation) => {
         const conjecture = conjectureFromConjectureNode(conjectureNode, context);
 
-        conjecture.verify(context, continuation);
+        return conjecture.verify(context, continuation);
       }
     },
     {
@@ -110,7 +110,7 @@ class TopLevelPass extends ContinuationPass {
       run: (typeDeclarationNode, context, continuation) => {
         const typeDeclaration = typeDeclarationFromTypeDeclarationNode(typeDeclarationNode, context);
 
-        typeDeclaration.verify(context, continuation);
+        return typeDeclaration.verify(context, continuation);
       }
     },
     {
@@ -118,7 +118,7 @@ class TopLevelPass extends ContinuationPass {
       run: (cotypeDeclarationNode, context, continuation) => {
         const cotypeDeclaration = cotypeDeclarationFromCotypeDeclarationNode(cotypeDeclarationNode, context);
 
-        cotypeDeclaration.verify(context, continuation);
+        return cotypeDeclaration.verify(context, continuation);
       }
     },
     {
@@ -126,7 +126,7 @@ class TopLevelPass extends ContinuationPass {
       run: (variableDeclarationNode, context, continuation) => {
         const variableDeclaration = variableDeclarationFromVariableDeclarationNode(variableDeclarationNode, context);
 
-        variableDeclaration.verify(context, continuation);
+        return variableDeclaration.verify(context, continuation);
       }
     },
     {
@@ -134,7 +134,7 @@ class TopLevelPass extends ContinuationPass {
       run: (generatorDeclarationNode, context, continuation) => {
         const generatorDeclaration = generatorDeclarationFromGeneratorDeclarationNode(generatorDeclarationNode, context);
 
-        generatorDeclaration.verify(context, continuation);
+        return generatorDeclaration.verify(context, continuation);
       }
     },
     {
@@ -142,7 +142,7 @@ class TopLevelPass extends ContinuationPass {
       run: (typePrefixDeclarationNode, context, continuation) => {
         const typePrefixDeclaration = typePrefixDeclarationFromTypePrefixDeclarationNode(typePrefixDeclarationNode, context);
 
-        typePrefixDeclaration.verify(context, continuation);
+        return typePrefixDeclaration.verify(context, continuation);
       }
     },
     {
@@ -150,7 +150,7 @@ class TopLevelPass extends ContinuationPass {
       run: (combinatorDeclarationNode, context, continuation) => {
         const combinatorDeclaration = combinatorDeclarationFromCombinatorDeclarationNode(combinatorDeclarationNode, context);
 
-        combinatorDeclaration.verify(context, continuation);
+        return combinatorDeclaration.verify(context, continuation);
       }
     },
     {
@@ -158,7 +158,7 @@ class TopLevelPass extends ContinuationPass {
       run: (constructorDeclarationNode, context, continuation) => {
         const constructorDeclaration = constructorDeclarationFromConstructorDeclarationNode(constructorDeclarationNode, context);
 
-        constructorDeclaration.verify(context, continuation);
+        return constructorDeclaration.verify(context, continuation);
       }
     },
     {
@@ -166,7 +166,7 @@ class TopLevelPass extends ContinuationPass {
       run: (metavariableDeclarationNode, context, continuation) => {
         const metavariableDeclaration = metavariableDeclarationFromMetavariableDeclarationNode(metavariableDeclarationNode, context);
 
-        metavariableDeclaration.verify(context, continuation);
+        return metavariableDeclaration.verify(context, continuation);
       }
     }
   ];
@@ -177,5 +177,5 @@ const topLevelPass = new TopLevelPass();
 export function verifyFile(fileNode, context, continuation) {
   const node = fileNode; ///
 
-  topLevelPass.run(node, context, continuation);
+  return topLevelPass.run(node, context, continuation);
 }

package/src/utilities/compression.js

@@ -0,0 +1,115 @@
+"use strict";
+
+import { arrayUtilities } from "necessary";
+
+const { compress } = arrayUtilities;
+
+export function compressTerms(terms) {
+  compress(terms, (termA, termB) => {
+    const termAEqualToTermB = termA.isEqualTo(termB);
+
+    if (!termAEqualToTermB) {
+      return true;
+    }
+  });
+}
+
+export function compressGoals(goals) {
+  compress(goals, (goalA, goalB) => {
+    const goalAEqualToGoalB = goalA.isEqualTo(goalB);
+
+    if (!goalAEqualToGoalB) {
+      return true;
+    }
+  });
+}
+
+export function compressFrames(frames) {
+  compress(frames, (frameA, frameB) => {
+    const frameAEqualToFrameB = frameA.isEqualTo(frameB);
+
+    if (!frameAEqualToFrameB) {
+      return true;
+    }
+  });
+}
+
+export function compressEqualities(equalities) {
+  compress(equalities, (equalityA, equalityB) => {
+    const equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
+
+    if (!equalityAEqualToEqualityB) {
+      return true;
+    }
+  });
+}
+
+export function compressJudgements(judgements) {
+  compress(judgements, (judgementA, judgementB) => {
+    const judgementAEqualToJudgementB = judgementA.isEqualTo(judgementB);
+
+    if (!judgementAEqualToJudgementB) {
+      return true;
+    }
+  });
+}
+
+export function compressAssertions(assertions) {
+  compress(assertions, (assertionA, assertionB) => {
+    const assertionAEqualToAssertionB = assertionA.isEqualTo(assertionB);
+
+    if (!assertionAEqualToAssertionB) {
+      return true;
+    }
+  });
+}
+
+export function compressStatements(statements) {
+  compress(statements, (statementA, statementB) => {
+    const statementAEqualToStatementB = statementA.isEqualTo(statementB);
+
+    if (!statementAEqualToStatementB) {
+      return true;
+    }
+  });
+}
+
+export function compressSignatures(signatures) {
+  compress(signatures, (signatureA, signatureB) => {
+    const signatureAEqualToSignatureB = signatureA.isEqualTo(signatureB);
+
+    if (!signatureAEqualToSignatureB) {
+      return true;
+    }
+  });
+}
+
+export function compressReferences(references) {
+  compress(references, (referenceA, referenceB) => {
+    const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);
+
+    if (!referenceAEqualToReferenceB) {
+      return true;
+    }
+  });
+}
+
+export function compressAssumptions(assumptions) {
+  compress(assumptions, (assumptionA, assumptionB) => {
+    const assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
+
+    if (!assumptionAEqualToAssumptionB) {
+      return true;
+    }
+  });
+}
+
+export function compressSubstitutions(substitutions) {
+  compress(substitutions, (substitutionA, substitutionB) => {
+    const substitutionAEqualToSubstitutionB = substitutionA.isEqualTo(substitutionB);
+
+    if (!substitutionAEqualToSubstitutionB) {
+      return true;
+    }
+  });
+}