Tolerant Isomorphism Testing

• Tolerant isomorphism testing is a property testing framework that decides if an unknown Boolean function is close to some automorphic transform of a reference function.
• It leverages Fourier analysis on finite Abelian groups, linking query complexity to parameters like the spectral norm and Fourier sparsity.
• The framework bridges algebraic symmetry with approximate decision-making, contrasting Fourier-analytic methods with junta-based approaches.

Searching arXiv for papers on tolerant isomorphism testing and closely related isomorphism-testing settings. Tolerant isomorphism testing is the property-testing problem of deciding whether an unknown object is close to some symmetry transform of a reference object, versus being far from every such transform, under a prescribed distance metric and a nonzero tolerance gap. In the setting developed most explicitly for Boolean functions over finite Abelian groups, the input consists of a fully known Boolean function $g$, query access to an unknown Boolean function $f$, and parameters $\epsilon\ge 0$ and $\tau>0$; the task is to determine whether there exists an automorphism $\sigma\in \mathrm{Aut}(\mathcal{G})$ such that $\delta(f\circ \sigma,g)\le \epsilon$, or whether every automorphic alignment has distance at least $\epsilon+\tau$ (Datta et al., 10 Jul 2025). More broadly, the term has also appeared in work on Boolean function isomorphism under variable permutations, where both functions are given by queries, and in structural settings where “tolerance” refers not to approximation in Hamming distance but to tolerance relations and quotient constructions on posets (Blais et al., 2016, Chajda et al., 2021). The dominant modern interpretation in theoretical computer science is the robust, gap-based testing formulation.

1. Formal problem and core model

For Boolean functions over a finite Abelian group $\mathcal{G}$, tolerant isomorphism testing asks whether

$$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$

or whether

$$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$

where $f$0 is fractional Hamming distance (Datta et al., 10 Jul 2025). The query model is asymmetric: $f$1 is fully known, while the tester has query access to $f$2, meaning that for any chosen $f$3 it can obtain the value $f$4 (Datta et al., 10 Jul 2025). This formulation is tolerant because it distinguishes $f$5-close inputs from $f$6-far inputs, rather than insisting on exact isomorphism.

The symmetry notion is determined by the ambient domain. For functions on a finite Abelian group, equivalence is defined by group automorphisms: $f$7 and $f$8 are considered equivalent if there exists $f$9 such that $\epsilon\ge 0$0 (Datta et al., 10 Jul 2025). In the earlier Boolean-cube formulation, the analogous notion is isomorphism under a permutation of variables. There, for $\epsilon\ge 0$1,

$\epsilon\ge 0$2

and the distance to isomorphism is

$\epsilon\ge 0$3

for $\epsilon\ge 0$4 (Blais et al., 2016).

The group-theoretic formulation in (Datta et al., 10 Jul 2025) generalizes earlier work for functions on the Boolean cube and vector spaces. The paper writes

$\epsilon\ge 0$5

with

$\epsilon\ge 0$6

and develops the tester in that general finite-Abelian setting (Datta et al., 10 Jul 2025). This places tolerant isomorphism testing within the broader program of tolerant property testing: deciding whether an unknown object is close to a structured model defined by symmetries, while allowing a gap $\epsilon\ge 0$7 between yes- and no-instances (Datta et al., 10 Jul 2025).

2. Query complexity and the role of Fourier complexity

The principal quantitative result for finite Abelian groups is that tolerant isomorphism testing is efficiently solvable with query complexity polynomial in the spectral norm of the known function $\epsilon\ge 0$8 and in $\epsilon\ge 0$9 (Datta et al., 10 Jul 2025). If

$\tau>0$0

then the tester uses

$\tau>0$1

queries, suppressing polylogarithmic factors in $\tau>0$2 and $\tau>0$3 and assuming $\tau>0$4 is constant in the stated bound (Datta et al., 10 Jul 2025). The theorem is also stated more abstractly as a $\tau>0$5 bound (Datta et al., 10 Jul 2025).

A stronger result holds when $\tau>0$6 is Fourier sparse. If the Fourier support size satisfies

$\tau>0$7

then the paper gives a faster tolerant tester with query complexity

$\tau>0$8

again up to lower-order logarithmic factors (Datta et al., 10 Jul 2025). The stated reason is that sparse functions have only $\tau>0$9 nonzero Fourier coefficients, so the implicit-sieve stage is simpler and does not require the more delicate $\sigma\in \mathrm{Aut}(\mathcal{G})$0 estimation used in the general spectral-norm case (Datta et al., 10 Jul 2025).

The dependence on Fourier complexity is not presented as merely analytic overhead. The paper explicitly notes a lower bound from Wimmer–Yoshida in the special case $\sigma\in \mathrm{Aut}(\mathcal{G})$1, namely an $\sigma\in \mathrm{Aut}(\mathcal{G})$2-type lower bound, so the spectral-norm dependence is not an artifact of the analysis (Datta et al., 10 Jul 2025). The guarantees are probabilistic, with success probability typically at least $\sigma\in \mathrm{Aut}(\mathcal{G})$3 overall after union bounds (Datta et al., 10 Jul 2025).

A related but different complexity landscape appears in the Boolean-cube junta-based framework of (Blais et al., 2016). There the tolerant isomorphism tester is instance-adaptive: its query complexity depends on the smallest junta size needed to approximate either input function. The paper defines, for a single function $\sigma\in \mathrm{Aut}(\mathcal{G})$4, the $\sigma\in \mathrm{Aut}(\mathcal{G})$5-junta degree

$\sigma\in \mathrm{Aut}(\mathcal{G})$6

and for a pair $\sigma\in \mathrm{Aut}(\mathcal{G})$7,

$\sigma\in \mathrm{Aut}(\mathcal{G})$8

(Blais et al., 2016). Its tolerant-isomorphism theorem gives query complexity

$\sigma\in \mathrm{Aut}(\mathcal{G})$9

where

$\delta(f\circ \sigma,g)\le \epsilon$0

and in the worst case

$\delta(f\circ \sigma,g)\le \epsilon$1

(Blais et al., 2016). This suggests two distinct parameterizations of tolerant isomorphism testing for Boolean functions: one by Fourier complexity of a known reference function, and one by latent junta dimension of either queried function.

3. Fourier-analytic and group-theoretic framework over finite Abelian groups

The technical foundation of the finite-Abelian-group result is Fourier analysis on $\delta(f\circ \sigma,g)\le \epsilon$2 together with group-theoretic substitutes for linear-algebraic notions that are available on vector spaces but not on arbitrary finite Abelian groups (Datta et al., 10 Jul 2025). The dual group $\delta(f\circ \sigma,g)\le \epsilon$3 consists of characters $\delta(f\circ \sigma,g)\le \epsilon$4, and Pontryagin duality gives $\delta(f\circ \sigma,g)\le \epsilon$5 (Datta et al., 10 Jul 2025). Fourier coefficients are defined by

$\delta(f\circ \sigma,g)\le \epsilon$6

with inversion and Parseval identities

$\delta(f\circ \sigma,g)\le \epsilon$7

(Datta et al., 10 Jul 2025). The spectral norm is

$\delta(f\circ \sigma,g)\le \epsilon$8

(Datta et al., 10 Jul 2025).

To emulate orthogonality and cosets of subspaces, the paper defines a pseudo inner-product on $\delta(f\circ \sigma,g)\le \epsilon$9: $\epsilon+\tau$0 for $\epsilon+\tau$1 and $\epsilon+\tau$2 (Datta et al., 10 Jul 2025). For a subgroup $\epsilon+\tau$3, the annihilator-like subgroup is then

$\epsilon+\tau$4

(Datta et al., 10 Jul 2025). The paper proves that this is a subgroup and establishes the key character-sum identity

$\epsilon+\tau$5

for $\epsilon+\tau$6, while the sum is $\epsilon+\tau$7 if $\epsilon+\tau$8 (Datta et al., 10 Jul 2025). It also proves

$\epsilon+\tau$9

(Datta et al., 10 Jul 2025).

These constructions replace familiar vector-space tools by finite-Abelian analogues. Pontryagin duality is also used to control the effect of automorphisms on Fourier coefficients: $\mathcal{G}$0 so automorphisms permute Fourier characters in a structured way (Datta et al., 10 Jul 2025). This compatibility is essential because the tester ultimately reasons in the frequency domain while the isomorphism relation is defined in the original domain.

A further notion introduced for this setting is pseudo-independence. A set $\mathcal{G}$1 is dependent if there exist $\mathcal{G}$2 with at least one unit coefficient such that

$\mathcal{G}$3

(Datta et al., 10 Jul 2025). This generalizes linear dependence and is used to identify a minimal generating subset among large Fourier characters, because the image of a dependent element under an automorphism is determined by the images of the others (Datta et al., 10 Jul 2025). That feature is precisely what the tester needs to reconstruct the action of an unknown automorphism from a small basis-like set of significant frequencies.

4. Bucketization, implicit sieving, and spectrum recovery

A central algorithmic idea is a randomized coset partition of the dual group into buckets (Datta et al., 10 Jul 2025). After choosing random $\mathcal{G}$4, the algorithm defines

$\mathcal{G}$5

and cosets

$\mathcal{G}$6

(Datta et al., 10 Jul 2025). For sufficiently large $\mathcal{G}$7, the large Fourier coefficients of $\mathcal{G}$8 land in distinct buckets with high probability, so each bucket is dominated by at most one large coefficient (Datta et al., 10 Jul 2025). This makes it possible to estimate one significant character per bucket without enumerating the entire Fourier spectrum.

The bucket weights are

$\mathcal{G}$9

(Datta et al., 10 Jul 2025). The paper derives formulas such as

$$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$0

together with a similar fourth-moment formula for $$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$1 (Datta et al., 10 Jul 2025). These identities allow the tester to estimate bucket weights from samples using Hoeffding and Chebyshev bounds, even though the significant coefficients are not known beforehand (Datta et al., 10 Jul 2025).

The key subroutine is the Generalized Implicit Sieve (Datta et al., 10 Jul 2025). It returns a matrix whose columns behave like evaluations of the large Fourier characters on random sample points,

$$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$2

where $$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$3 are surviving buckets and $$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$4 is the dominating character in each bucket (Datta et al., 10 Jul 2025). The algorithm filters buckets using $$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$5 and $$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$6, and uses the product

$$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$7

to recover the phase $$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$8, a necessary step because the relevant characters are complex-valued and there is no sign analogue as in $$\exists \sigma\in \mathrm{Aut}(\mathcal{G}) \text{ such that } \delta(f\circ \sigma,g)\le \epsilon,$$9 (Datta et al., 10 Jul 2025).

This part of the framework is the main novelty relative to the vector-space case. The paper explicitly characterizes the contribution as transplanting the Fourier-analytic and implicit-sieve machinery from vector spaces to arbitrary finite Abelian groups using annihilators, Pontryagin duality, pseudo-inner products, and pseudo-independence (Datta et al., 10 Jul 2025). A plausible implication is that these techniques are likely to be useful outside isomorphism testing, especially in property-testing problems where structural symmetries interact with Fourier concentration.

5. From recovered spectrum to tolerant decisions

The decision stage uses the Fourier characterization of agreement. For Boolean functions,

$$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$0

(Datta et al., 10 Jul 2025). After reconstructing an approximation $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$1 to the significant Fourier spectrum of $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$2, the tester checks whether there exists $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$3 such that

$$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$4

is at least $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$5, or at most $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$6 (Datta et al., 10 Jul 2025). The yes/no gap is therefore implemented through an estimated Fourier correlation threshold.

The earlier tolerant-isomorphism algorithm on the Boolean cube follows a different pipeline. It first discovers the relevant junta scale $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$7 by repeatedly running a tolerant junta tester on both $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$8 and $$\forall \sigma\in \mathrm{Aut}(\mathcal{G}),\quad \delta(f\circ \sigma,g)\ge \epsilon+\tau,$$9, and then reduces isomorphism testing to a robust comparison of $f$00-junta cores obtained through a noisy sampler (Blais et al., 2016). The tolerant junta theorem used there states that for any $f$01 and $f$02, there is an algorithm that accepts if $f$03 is $f$04-close to some $f$05-junta, rejects if $f$06 is far from every $f$07-junta, and uses

$f$08

queries (Blais et al., 2016). The search phase chooses

$f$09

and, with high probability, returns $f$10 satisfying

$f$11

(Blais et al., 2016).

The robust comparison phase samples noisy labeled cores

$f$12

and tests whether there exists a permutation $f$13 for which the number of violating pairs $f$14 is small (Blais et al., 2016). The test accepts if there exists $f$15 with

$f$16

where

$f$17

and the robust-isomorphism subroutine sets

$f$18

(Blais et al., 2016). This yields the characteristic $f$19 complexity of the core-comparison stage.

The contrast between (Datta et al., 10 Jul 2025) and (Blais et al., 2016) is methodologically informative. The former is spectral and group-theoretic, using a known reference function and controlled automorphisms of a finite Abelian group. The latter is combinatorial and instance-adaptive, using tolerant junta testing and noisy sampling when both functions are accessed only by queries. This suggests that tolerant isomorphism testing is not a single technique but a family of robust symmetry-testing paradigms whose tractability depends heavily on how the underlying symmetry acts on the object’s latent representation.

6. Scope, limitations, and adjacent meanings of “tolerance”

The finite-Abelian-group theorem gives a query upper bound, but does not claim optimality in general finite Abelian groups (Datta et al., 10 Jul 2025). Its explicit bounds assume $f$20 is treated as constant, and the guarantees are probabilistic rather than deterministic (Datta et al., 10 Jul 2025). The result is tolerant in the property-testing sense, but exact isomorphism is recovered only in the special case $f$21 (Datta et al., 10 Jul 2025). These limitations are important because they distinguish the result from full reconstruction or canonicalization algorithms.

In graph property testing, isomorphism testing appears in a different role. For bounded-degree planar graphs, testing isomorphism to a fixed graph is shown to require

$f$22

queries, matching the general $f$23 upper bound for all planar properties up to constant factors in the exponent (Basu et al., 2021). There the property $f$24 is exactly isomorphism to a fixed graph $f$25, and the paper argues that such isomorphism testing is essentially the hardest planar property in that model (Basu et al., 2021). This is not a tolerant-isomorphism result in the Boolean-function sense, but it provides complexity-theoretic context for how hard isomorphism-based property testing can be under other distance models and oracle types.

A different and potentially confusing use of the word “tolerance” appears in order theory. In posets, a tolerance is a reflexive, symmetric relation satisfying closure and compatibility conditions, and the associated theory studies blocks, quotient posets, and weakened analogues of isomorphism theorems (Chajda et al., 2021). The paper proves, for example, that every block of a non-trivial tolerance on a poset is directed and convex, that $f$26 is a quotient poset, and that a full isomorphism theorem fails in general even for congruences (Chajda et al., 2021). This usage is structurally unrelated to tolerant property testing, although the vocabulary overlaps.

Further afield, exact isomorphism testing for tuples of subspaces also illustrates a nearby but distinct landscape. Allowing permutations of the subspaces makes the problem GI-hard, whereas without permutations the paper develops several polynomial-time exact tests based on Bargmann invariants, canonical Gramians, $f$27-algebras, and quiver or cross-Gramian constructions (King et al., 2021). That work explicitly states that it does not formulate a formal tolerant-isomorphism algorithm, though its invariants may be useful for approximate comparison (King et al., 2021). The juxtaposition highlights a broader pattern: exact isomorphism can often be characterized algebraically, but tolerant isomorphism typically requires quantitative control of approximation, sampling, and noise propagation.

7. Conceptual significance and research trajectory

The central conceptual contribution of the finite-Abelian-group framework is to show that tolerant isomorphism testing over finite Abelian groups is feasible with query complexity governed by the Fourier complexity of the known function (Datta et al., 10 Jul 2025). Spectral norm $f$28 yields a $f$29 tester, and Fourier sparsity yields an even faster one (Datta et al., 10 Jul 2025). The underlying message is that robust symmetry testing can be driven by the compressibility of the reference object in an appropriate harmonic basis.

Historically, this extends earlier tolerant isomorphism testing for Boolean functions on the Boolean cube, where the governing structural parameter was approximate junta dimension rather than Fourier complexity over a general group (Blais et al., 2016). The methodological shift from variable-permutation symmetries to automorphisms of arbitrary finite Abelian groups required replacing vector-space linear algebra with annihilator subgroups, Pontryagin duality, pseudo-inner products, and pseudo-independence (Datta et al., 10 Jul 2025). This marks a transition from linear-invariant settings to genuinely group-theoretic ones.

The broader significance lies in tolerant property testing. The finite-Abelian-group paper explicitly places the result within the program of deciding whether an unknown object is close to a structured, symmetry-defined model while allowing a gap $f$30 between yes- and no-instances (Datta et al., 10 Jul 2025). A plausible implication is that similar harmonic-analytic approaches may be applicable whenever the symmetry group acts transparently on a sparse or low-norm spectral representation. Conversely, the graph and subspace examples suggest that once the symmetry class becomes too expressive—such as fixed-graph identity in planar property testing, or tuple isomorphism with permutations—the complexity can rise sharply or even become GI-hard (Basu et al., 2021, King et al., 2021).

Tolerant isomorphism testing therefore occupies an intermediate position between exact equivalence checking and generic property testing. It is exact enough to preserve the algebraic structure of the symmetry group, but approximate enough to require robust estimators, margin-based decisions, and explicit dependence on latent complexity parameters. In current work, its most developed realization is the Fourier-analytic tester for Boolean functions over finite Abelian groups (Datta et al., 10 Jul 2025), which generalizes the earlier junta-based tolerant isomorphism paradigm on the Boolean cube (Blais et al., 2016).