feat: small refinement of hashfusing article

Author: jclaggett

src/math/hashing/hashfusing.clj

@@ -23,21 +23,24 @@
 ;; sufficiently low entropy data is not uniquely represented by fusing hashes
 ;; together.
 
-;; The good news is that low entropy data is compressible and a practical
-;; fusing operator can throw an exception when fusing produces 'bad' hash
-;; values.
+;; The good news is that low entropy data may always be converted into high
+;; entropy data either via compression or injecting noise. A practical fusing
+;; operator can easily detect fuses of low entropy data and throw an exception
+;; when fusing produces those 'bad' hash values.
 
 ;; ## Introduction
 
 ;; I have begun working on implementing distributed immutable data structures
 ;; as a way to efficiently share structured data between multiple clients. One
 ;; of the key challenges in this area is being able to efficiently reference
-;; ordered collections of data. The usual approach is to use Merkle Trees. But,
-;; since I plan on using Finger Trees to represent ordered collections of data,
+;; ordered collections of data. The usual approach is to use Merkle Trees which
+;; have the limitation that they are non-associative and the shape of the tree
+;; determines the final hash value at the root of the tree. But, since I plan
+;; on using Finger Trees to efficiently represent ordered collections of data,
 ;; I need computed hashes that are insensitive to the tree shape. This means
 ;; that I need to be able to fuse hashes together in a way that is associative
-;; and not commutative. As a starting point, I have been reading the HP paper
-;; describing hash fusing via matrix multiplication:
+;; and also non-commutative. As a starting point, I have been reading the HP
+;; paper describing hash fusing via matrix multiplication:
 ;; [https://www.labs.hpe.com/techreports/2017/HPE-2017-08.pdf](https://www.labs.hpe.com/techreports/2017/HPE-2017-08.pdf)
 
 ;; ## Hash Fusing via Upper Triangular Matrix Multiplication
@@ -70,11 +73,11 @@
 (def c-hex (random-hex 32))
 ^:kindly/hide-code c-hex
 
-;; To fuse two hashes, we convert each hash to its corresponding upper
-;; triangular matrix and then multiply the two matrices together. The result is
-;; another upper triangular matrix which can be converted back to a hash by
-;; taking the elements above the main diagonal. The following several sections
-;; defines this mapping between hashes and upper triangular matrices. For the
+;; To fuse two hashes, we convert each hash to an upper triangular matrix and
+;; then multiply the two matrices together. The result is another upper
+;; triangular matrix which can be converted back to a hash by taking the
+;; elements above the main diagonal. The following several sections defines
+;; this mapping between hashes and upper triangular matrices. For the
 ;; experiments below four different bit sizes of cells and four corresponding
 ;; matrices are defined.
 
@@ -499,8 +502,8 @@
             ab*c (utm-multiply ab c)
             a*bc (utm-multiply a bc)]
         {:cell-size cell-size
-         :commutative? (= ab ba)
-         :associative? (= ab*c a*bc)}))
+         :associative? (= ab*c a*bc)
+         :commutative? (= ab ba)}))
     (kind/table))
 
 ;; ## Experiment 1: Random Fuses
@@ -693,15 +696,21 @@
                       {:a a-hex :b b-hex :fused (utm64->hex ab)}))
       (utm64->hex ab))))
 
+;; Example of high entropy data fusing successfully:
 (high-entropy-fuse a-hex b-hex)
 
+;; Example of low entropy data causing an error:
 (try
   (high-entropy-fuse zero-hex zero-hex)
   (catch Exception e
          (.getMessage e)))
 
 ;; ## Appendix: Why Low Entropy Data Fails (AI Explanation)
 
+;; _The following explanation was generated by Copilot in response to the
+;; question: "Why does low entropy data fail to be represented by hash fusing
+;; via upper triangular matrix multiplication?"_
+
 ;; The reason low entropy data fails to be represented by hash fusing is that
 ;; the multiplication of upper triangular matrices causes the lower bits of the
 ;; resulting matrix to rapidly approach zero when the same matrix is repeatedly