De Groote Equivalence: Tensors & Concurrency

• De Groote equivalence is a relation that identifies matrix multiplication tensor decompositions or behavioural models as equivalent if they differ only by permutation, scaling, and trace (or coordinate) transformations.
• In the tensor setting, it underpins classical results such as the uniqueness of Strassen’s rank-7 algorithm, while in concurrency it informs efficient algorithms for stuttering equivalence and branching bisimulation.
• Decision procedures leverage linearization and permutation pruning to test equivalence, illustrating practical methods to separate algorithmic invariance from presentation-dependent variations.

Searching arXiv for papers relevant to “de Groote equivalence,” covering both matrix multiplication tensor equivalence and Groote-style behavioural equivalences. de Groote equivalence denotes, in modern tensor language, the equivalence relation on polyadic decompositions of matrix multiplication tensors generated by permutation transformations, scaling transformations, and trace transformations; two bilinear algorithms are regarded as the same when they differ only by these invariance operations. The available literature also uses closely related Groote-associated terminology in concurrency theory for divergence-blind stuttering equivalence on Kripke structures and branching bisimulation on labelled transition systems, together with the partition-refinement procedures used to decide them. The common theme is the identification of representations that are “essentially equivalent,” but the tensor-algebraic and behavioural settings are mathematically distinct (Berger et al., 2019, Jansen et al., 2016).

1. Terminological scope

In the tensor-algebraic setting, de Groote equivalence is the equivalence relation attached to bilinear algorithms for matrix multiplication. Berger, Gesmundo, and de la Cruz make this explicit for matrix multiplication tensors and treat it as an orbit relation under natural symmetries of a polyadic decomposition (Berger et al., 2019).

In the concurrency-theoretic setting, the phrase can refer more loosely to Groote-style behavioural equivalences and their decision procedures. The relevant notions are divergence-blind stuttering equivalence on Kripke structures and branching bisimulation on labelled transition systems, as defined and algorithmically treated in work by Groote–Vaandrager and Groote–Wijs. In that context, the emphasis is not on a named algebraic orbit relation, but on standard weak behavioural equivalences and on how to compute them efficiently (Jansen et al., 2016).

This suggests a useful disambiguation. In tensor theory, de Groote equivalence is an explicit equivalence relation on decompositions. In model checking and concurrency, Groote’s name is attached primarily to equivalence notions and refinement algorithms rather than to a single standardized term.

2. Matrix multiplication tensors and the equivalence relation

Let $F$ be a field, and let

$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$

denote multiplication of an $m\times p$ matrix by a $p\times n$ matrix. Berger et al. identify $\Phi_{m,p,n}$ with the matrix multiplication tensor of format $(m,p,n)$ (Berger et al., 2019).

A rank-1 bilinear map has the form

$\Phi(u,v) = f(u)\, g(v)\, w$

with $f\in U^*$, $g\in V^*$, and $w\in W$. An $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$0-term polyadic decomposition of a bilinear map is

$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$1

For matrix multiplication, the dual functionals can be represented by matrices $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$2 and $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$3 through the trace pairing, and the output factors by matrices $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$4, yielding

$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$5

Each term corresponds to one active multiplication $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$6; the bilinear rank is the smallest $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$7 admitting such a decomposition, hence the minimal number of active multiplications in any bilinear algorithm (Berger et al., 2019).

The defining invariance transformations are the following.

Permutation transformations: for $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$8,

$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$9

Scaling transformations: for scalars $m\times p$0 with

$m\times p$1

define

$m\times p$2

Trace transformations: for

$m\times p$3

define

$m\times p$4

Two $m\times p$5-term polyadic decompositions of $m\times p$6 are equivalent if one can be transformed into the other by a finite sequence of these operations. In tensor language, this is the natural orbit relation induced by the symmetric group on the summands, termwise rescaling, and compatible base changes in the three tensor factors (Berger et al., 2019).

3. Structural meaning and classical uniqueness results

The significance of de Groote equivalence is that it separates essential algorithmic content from presentation-dependent choices. Reordering multiplication steps does not change an algorithm. Termwise rescaling changes the normalization of intermediate linear forms but not the computed bilinear map. Trace transformations implement simultaneous coordinate changes compatible with matrix multiplication itself (Berger et al., 2019).

For two decompositions

$m\times p$7

equivalence is characterized by the existence of a permutation $m\times p$8, invertible matrices $m\times p$9, and scalars $p\times n$0 satisfying $p\times n$1 such that, for all $p\times n$2,

$p\times n$3

This is the concrete form of de Groote equivalence used algorithmically in the tensor literature (Berger et al., 2019).

Its classical importance is illustrated by the $p\times n$4 case. De Groote proved that for multiplication of $p\times n$5 matrices with $p\times n$6 active multiplications, all algorithms are essentially equivalent to Strassen’s algorithm. In the language above, optimal rank-$p\times n$7 decompositions of $p\times n$8 form a single de Groote equivalence class (Berger et al., 2019).

The situation changes for larger formats. Berger et al. report that for multiplication of larger matrices, including $p\times n$9 by $\Phi_{m,p,n}$0 and $\Phi_{m,p,n}$1 by $\Phi_{m,p,n}$2, two decompositions are very likely to be essentially different. This aligns with earlier work showing inequivalent $\Phi_{m,p,n}$3-multiplication algorithms for $\Phi_{m,p,n}$4 multiplication (Berger et al., 2019).

4. Decision procedures for tensor decompositions

Berger et al. give an algorithm for deciding whether two polyadic decompositions of a given matrix multiplication tensor are equivalent. The naive approach would enumerate all $\Phi_{m,p,n}$5 permutations and solve the nonlinear system defined by the equivalence conditions; the paper replaces this by a combination of linearization and permutation pruning (Berger et al., 2019).

For a fixed permutation $\Phi_{m,p,n}$6, the first step is to test whether the decompositions are $\Phi_{m,p,n}$7-equivalent. Writing

$\Phi_{m,p,n}$8

and similarly $\Phi_{m,p,n}$9 and $(m,p,n)$0, the transformation

$(m,p,n)$1

becomes, after vectorization,

$(m,p,n)$2

Hence the $(m,p,n)$3-factor equations can be written as

$(m,p,n)$4

which is linear in the entries of $(m,p,n)$5 and the $(m,p,n)$6. Analogous linear systems are solved for the $(m,p,n)$7- and $(m,p,n)$8-factors. The paper uses the clustering number $(m,p,n)$9 to control the solution space dimension; under the stated assumption that at least one of $\Phi(u,v) = f(u)\, g(v)\, w$0 and its primed counterpart has clustering number $\Phi(u,v) = f(u)\, g(v)\, w$1, the relevant solution space is one-dimensional up to scalar (Berger et al., 2019).

The permutation search is pruned through simultaneous similarity invariants. For each $\Phi(u,v) = f(u)\, g(v)\, w$2, define

$\Phi(u,v) = f(u)\, g(v)\, w$3

If the decompositions are equivalent, then after the correct permutation,

$\Phi(u,v) = f(u)\, g(v)\, w$4

Thus the two ordered families must be simultaneously similar. The recursive search builds a partial permutation and rejects branches by comparing eigenvalues of random linear combinations of the corresponding $\Phi(u,v) = f(u)\, g(v)\, w$5 and $\Phi(u,v) = f(u)\, g(v)\, w$6; if the spectra differ, the branch cannot extend to a valid equivalence (Berger et al., 2019).

The worst-case complexity is bounded by

$\Phi(u,v) = f(u)\, g(v)\, w$7

but the reported empirical behavior is substantially better. In the experiments, the recursion depth never exceeded $\Phi(u,v) = f(u)\, g(v)\, w$8 even for $\Phi(u,v) = f(u)\, g(v)\, w$9, the expensive scaling-and-trace check was typically called only once per pair of decompositions, and the average time to test equivalence of two decompositions was at most about $f\in U^*$0 seconds in all cases tested (Berger et al., 2019).

5. Equivalence classes and discretizability

Berger et al. use the decision algorithm to study how many essentially different decompositions occur for several small matrix multiplication tensors. They generated $f\in U^*$1 decompositions for each case and tested $f\in U^*$2 random pairs for equivalence (Berger et al., 2019).

Format $f\in U^*$3	$f\in U^*$4	Equivalent random pairs
$f\in U^*$5	2	100%
$f\in U^*$6	4	0%
$f\in U^*$7	7	100%
$f\in U^*$8	11	0%
$f\in U^*$9	15	0%
$g\in V^*$0	23	0%

These data confirm the exceptional status of the $g\in V^*$1 rank-$g\in V^*$2 case and suggest that for larger tensors, randomly obtained decompositions almost surely lie in different de Groote equivalence classes (Berger et al., 2019).

The same paper also studies whether a decomposition is equivalent to one with coefficients in a discrete set. A decomposition is called discrete if there exists $g\in V^*$3 such that all entries of all factor matrices lie in $g\in V^*$4. It is discretizable if it is equivalent, via scaling and trace transformations, to some discrete decomposition. Strassen’s $g\in V^*$5-term algorithm and Laderman’s $g\in V^*$6-term algorithm are cited as discrete with entries in $g\in V^*$7 (Berger et al., 2019).

A necessary criterion for discretizability is obtained from the matrices

$g\in V^*$8

If a decomposition is discretizable with parameter $g\in V^*$9, then for every integer tuple $w\in W$0, the characteristic polynomial

$w\in W$1

must have integer coefficients. Failure of this condition proves that the decomposition is not equivalent to any discrete decomposition with entries in $w\in W$2 (Berger et al., 2019).

For $w\in W$3, the reported experiments show that $w\in W$4 of decompositions for $w\in W$5 and $w\in W$6 satisfy the criterion, whereas most decompositions for $w\in W$7, $w\in W$8, $w\in W$9, and $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$00 do not. A plausible implication is that discrete or few-valued decompositions, although prominent in the constructive literature, are not representative of generic decompositions in larger formats (Berger et al., 2019).

6. Groote-style behavioural equivalences in concurrency theory

In concurrency theory, the Groote-associated equivalence notions discussed in the literature are divergence-blind stuttering equivalence on Kripke structures and branching bisimulation on labelled transition systems. A finite Kripke structure is written

$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$01

where $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$02 is finite, $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$03 is total, and $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$04 assigns atomic propositions. The version of stuttering equivalence used in the algorithmic work is the divergence-blind variant associated with Browne–Clarke–Grünwald and with Groote–Vaandrager; it coincides with satisfaction of the same $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$05 formulas (Jansen et al., 2016).

The partition-refinement framework distinguishes inert transitions, which remain inside the same current block, from non-inert transitions, which leave the block. Writing $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$06 for the inert outgoing transitions of $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$07, a bottom state of a block $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$08 is characterized by

$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$09

The global invariant maintained by the algorithm is stability with respect to constellations: all states in a block can reach the same constellations through a weak transition (Jansen et al., 2016).

Groote–Wijs claimed that stuttering equivalence, and via standard encoding also branching bisimulation, could be computed in

$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$10

improving on the earlier $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$11 algorithm of Groote–Vaandrager. The high-level method uses constellations, splitter blocks $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$12 with $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$13, and a red/blue refinement routine TrySplit that attempts to process only the smaller half of each split (Jansen et al., 2016).

The 2016 analysis shows, however, that the original Groote–Wijs description does not always meet the claimed complexity. Two counterexamples establish $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$14 behavior, where $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$15 is maximal out-degree: $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$16 One counterexample targets TrySplit', where full scans of outgoing transitions are triggered repeatedly; the other targets PostprocessNewBottom, where large lists $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$17 are repeatedly walked after splits. A third example shows that even a first-level fix to bottom-state postprocessing is not sufficient unless newly discovered bottom states are handled with additional care (Jansen et al., 2016).

The corrective modifications preserve the underlying partition-refinement structure but change the cost accounting. In TrySplit', the expensive test of whether a state still has a transition to the relevant constellation is deferred until the point at which its inert successors have all become blue, so that each such scan is charged only once within the amortized budget. In PostprocessNewBottom, work is localized to constellations reachable from the newly created block $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$18, rather than by globally scanning all $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$19 lists for the parent block. With these fixes, the paper concludes that stuttering equivalence on Kripke structures can indeed be computed in $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$20 time and $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$21 space, and the same bound then applies to branching bisimulation through the standard encoding (Jansen et al., 2016).

This concurrency-theoretic usage is not identical to tensor-theoretic de Groote equivalence, but it exhibits an analogous concern: identifying when two states or processes should count as behaviourally indistinguishable, and ensuring that the quotienting algorithm respects a tight complexity bound.

7. Conceptual synthesis

Across both settings, de Groote’s name is attached to mathematically natural quotient constructions. In matrix multiplication, the quotient is by explicit symmetries of a polyadic decomposition: permutation of rank-1 terms, termwise rescaling, and compatible base changes. The resulting equivalence classes capture when two bilinear algorithms are the same up to invariances that do not alter the underlying tensor (Berger et al., 2019).

In concurrency theory, Groote-associated equivalences identify states up to weak behavioural indistinguishability, either as divergence-blind stuttering equivalence on Kripke structures or as branching bisimulation on labelled transition systems. The associated algorithms are partition-refinement procedures based on inert transitions, bottom states, constellations, and smaller-half splitting (Jansen et al., 2016).

The two literatures therefore embody different formal notions but a comparable methodological principle: replace syntactic or representational variation by an invariant notion of sameness, then study the algebraic or algorithmic structure of the resulting quotient. In the tensor setting, this leads to orbit classification, uniqueness results such as the rank-$$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$22 $$\Phi_{m,p,n} \in \mathrm{Bil}(F^{m\times p}, F^{p\times n}; F^{m\times n})$$23 case, and practical equivalence testing. In the behavioural setting, it leads to refined minimization algorithms whose correctness and asymptotic complexity depend on careful control of refinement steps and data-structure updates (Berger et al., 2019, Jansen et al., 2016).