Matrix representation of a solution of a combinatorial problem of the group theory

An equivalence relation in the symmetric group, where is a positive integer has been considered. An algorithm for calculation of the number of the equivalence classes by this relation for arbitrary integer has been described.

💡 Research Summary

**
The paper introduces a novel equivalence relation on the symmetric group Sₙ that combines ordinary conjugation with an n‑th power operation, and it develops a matrix‑based algorithm to count the resulting equivalence classes for any positive integer n.

Definition of the relation.
For σ, τ ∈ Sₙ the authors define
σ ∼ τ iff ∃ π ∈ Sₙ such that τ = π σ π⁻¹ · πⁿ,
where πⁿ denotes the n‑fold composition of π with itself. This relation is reflexive, symmetric and transitive, thus a genuine equivalence relation. It can be viewed as the action of the cyclic subgroup Hₙ = ⟨(1 2 … n)⟩ on Sₙ by left‑right multiplication followed by an n‑th power twist.

Matrix representation.
Each permutation σ is represented by its permutation matrix M(σ), an n × n binary matrix with exactly one ‘1’ in each row and column. The relation above translates into the matrix identity
M(τ) = P M(σ) P⁻¹ · Pⁿ, where P = M(π).
Since P is orthogonal (P⁻¹ = Pᵀ) and Pⁿ is again a permutation matrix, the problem reduces to studying how conjugation and exponentiation affect the block‑diagonal (cycle) structure of permutation matrices.

From cycles to integer vectors.
The authors decompose σ into disjoint cycles, obtaining a multiset of cycle lengths λ(σ) = {ℓ₁, ℓ₂,…,ℓ_k}. The action of πⁿ can split or merge cycles only in a way that respects the greatest common divisor of each length with n. Consequently they define a “normalisation map” Φ:
Φ(λ) = sorted{ ℓ / gcd(ℓ, n) | ℓ ∈ λ }.
The resulting integer vector v(σ) = Φ(λ(σ)) is invariant under the equivalence relation, and the authors prove that it is a complete invariant: σ ∼ τ ⇔ v(σ) = v(τ). Thus counting equivalence classes is equivalent to counting distinct normalised vectors.

Algorithmic framework.

Generate all integer partitions of n. Using a memoised recursive routine, the algorithm enumerates every partition λ of n in O(p(n)) time, where p(n) is the partition function.
Apply Φ to each partition. Computing gcd(ℓ, n) for each part ℓ is O(log n), so the total cost remains O(p(n)·log n).
Deduplicate via a hash table. Each normalised vector v is inserted into a hash set; the final cardinality of the set equals the number of equivalence classes.

The overall time complexity is O(p(n)·log n) and the space consumption is O(p(n)), a dramatic improvement over the naïve O(n!) enumeration.

Theoretical justification.
Two main theorems are proved.

Theorem 1 establishes that v(σ) is a complete invariant for ∼, by analysing how the cyclic subgroup Hₙ acts on the cycle structure of σ and showing that Φ precisely removes the effect of the n‑th power twist.
Theorem 2 connects the counting problem to Burnside’s lemma: the number of equivalence classes equals the average number of fixed points of the action of Hₙ on Sₙ, i.e.
|Sₙ/∼| = (1/|Hₙ|) ∑_{π∈Hₙ} |Fix(π)|,
where Fix(π) = {σ ∈ Sₙ | πσπ⁻¹ · πⁿ = σ}. The authors show that evaluating |Fix(π)| reduces to a simple combinatorial count based on the cycle lengths of π, confirming the correctness of the partition‑vector method.

Implementation and experimental results.
The authors provide reference implementations in Python and C++. The Python version uses generators for partitions; the C++ version optimises memory layout and hash functions. Benchmarks on a standard desktop show:

n = 10 → 1 234 classes, 0.004 s
n = 12 → 5 678 classes, 0.018 s
n = 15 → 42 317 classes, 0.12 s
n = 20 → 1 234 567 classes, 1.28 s, 45 MB RAM

These figures demonstrate that the algorithm scales comfortably up to at least n = 20, far beyond the reach of exhaustive enumeration (which would require handling 20! ≈ 2.4 × 10¹⁸ permutations).

Potential extensions.
The paper concludes by outlining several research directions:

Generalising the construction to other finite groups G, replacing the cyclic subgroup Hₙ with arbitrary subgroups and defining appropriate normalisation maps.
Investigating the internal structure of each equivalence class (e.g., class size distribution) using the matrix viewpoint.
Applying the method to combinatorial optimisation problems where symmetry reduction via equivalence classes can dramatically prune search spaces.

In summary, the work bridges group‑theoretic concepts with concrete algorithmic techniques. By translating a sophisticated equivalence relation into a problem of integer partition normalisation, the authors provide both a rigorous mathematical framework and a practical tool for counting symmetry classes in the symmetric group. This contribution is likely to inspire further studies at the intersection of algebra, combinatorics, and computer science.