June 23rd, 2024

Group Actions and Hashing Unordered Multisets

Group actions are used to analyze hash functions for unordered sets and multisets, ensuring order-agnostic hashing. By leveraging group theory, particularly abelian groups, hash functions' structure is explored, emphasizing efficient and order-independent hashing techniques.

Read original articleLink Icon
Group Actions and Hashing Unordered Multisets

The article discusses the use of group actions to analyze hash functions for unordered sets and multisets. It presents a method to hash these collections without depending on the order of elements added. By utilizing group theory concepts, particularly abelian groups, the structure of hash functions is explored. The article explains how hash functions can be incrementally updated as elements are added, ensuring order-agnostic hashing. It delves into the commutativity and invertibility properties required for well-defined hash functions on multisets. The discussion highlights the emergence of a group action on the set of hashes, characterized by an abelian group structure. Through a homomorphism, the article demonstrates how hash accumulation operations define this group action, leading to a structured approach for hashing unordered collections. The analysis showcases the application of group theory in practical computer programming beyond cryptographic contexts, offering insights into efficient and order-independent hashing techniques.

Related

Everyday is a Birthday A Journey to a classic problem through Math and Rust

Everyday is a Birthday A Journey to a classic problem through Math and Rust

This article explores the classic probability problem of ensuring every day of the year is represented by a birthday in a group of people, using mathematical concepts like the Coupon Collector Problem and Inclusion-Exclusion Principle. It calculates needing around 2364 students, adjusting to 2669 with leap days, and discusses the gamma function for probability calculation.

Asynchronous Consensus Without Trusted Setup or Public-Key Cryptography

Asynchronous Consensus Without Trusted Setup or Public-Key Cryptography

Researchers propose an Asynchronous Common Subset (ACS) protocol for Byzantine consensus without trusted setup or public-key cryptography. The protocol uses hash functions, offers post-quantum security, and introduces new primitives. Efficiently evaluated in a geo-distributed setting.

New JavaScript Set Methods

New JavaScript Set Methods

New JavaScript Set methods introduced in major browsers like Firefox 127 offer efficient set operations without polyfills. These methods simplify tasks like finding intersections, unions, and subsets, enhancing working with unique collections.

Atomic Operations Composition in Go

Atomic Operations Composition in Go

The article discusses atomic operations composition in Go, crucial for predictable results in concurrent programming without locks. Examples show both reliable and unpredictable outcomes, cautioning about atomics' limitations compared to mutexes.

A brief introduction to interval arithmetic

A brief introduction to interval arithmetic

Interval arithmetic deals with uncertainties by using intervals instead of exact numbers. It offers accuracy in calculations but faces challenges like complexities and overestimation. Despite evolving, it finds applications in diverse fields.

Link Icon 3 comments
By @contravariant - 4 months
Interesting, not often you see a non-associative variant of commutativity. It confused me for a bit that 'h' itself is not commutative, but summing arbitrary sequences is order independent provided you start with the same seed and sum from left to right.

Edit: Not sure the definition of phi is right though, once you have h(a, h*(T + S)) you're pretty much stuck since the commutativity doesn't allow you to rearrange things from that point. I think I understand the gist, you want to start accumulating from a different seed, except that h(a, h*(T)) is not the hash of T if you replace the seed with a. You'd need something like:

    h_s*({}) = s
    h_s*(T + {x}) = h_s*(h_s(T), h(x))
    phi(T) = (a => h_a*(T))
then commutativity could be written

    h_(h_s*({a}))({b}) = h_(h_s*({b}))({a})
which is slightly more symmetric, but maybe not better.
By @rjeli - 4 months
There’s a nice writeup on group hashes here: https://cronokirby.com/posts/2021/07/on_multi_set_hashing/

In particular, if you choose a group where discrete log is hard (such as prime order elliptic curves), multiset hashing falls out for free

By @ihm - 4 months
I think there are a few errors here. First there is afaict no reason the image of phi has to break up into power-of-two cyclic groups.

Second and more importantly, it seems very difficult to start with the decomposition into cyclic groups and then choose a map from the multiset group into the permutation group that corresponds to the given decomposition in a good way.

Relatedly, the isomorphism between the image of phi (i.e., the action of accumulating hashes) and the decomposition into cyclic groups may be difficult to compute, which can make finding collisions infeasible for an attacker when they could do it easily if given the explicit representation.

So overall the conclusion that “you might as well make this forced structure explicit, and just pick the block structure you want to use in advance” seems incorrect.

The blog post someone linked on multiset hashing with elliptic curves proves the foregoing points. The cyclic groups do not have power-of-two orders and the group action is very complicated even though the description in terms of elliptic curve addition is quite simple.