Abstract 1 Introduction 2 Proof ideas 3 Background 4 A query-efficient tester for the linear isomorphism problem 5 A lower bound for testing linear isomorphism 6 Conclusion References

Spectral Norm, Economical Sieve, and Linear Invariance Testing of Boolean Functions

Swarnalipa Datta ORCID Indian Statistical Institute, Kolkata, India Arijit Ghosh ORCID Indian Statistical Institute, Kolkata, India Chandrima Kayal ORCID Université Paris Cité, CNRS, IRIF, France Manaswi Paraashar ORCID University of Copenhagen, Denmark Manmatha Roy ORCID Indian Statistical Institute, Kolkata, India
Abstract

Given Boolean functions f,g:𝔽2n{1,+1}, we say they are linearly isomorphic if there exists AGLn(𝔽2) such that f(x)=g(Ax) for all x. We study this problem in the tolerant property testing framework under the known–unknown model, where g is given explicitly and f is accessible only via oracle queries, meaning the algorithm may adaptively request the value of f(x) for inputs x𝔽2n of its choice. Given parameters ϵ0 and ω>0, the goal is to distinguish whether there exists AGLn(𝔽2) such that the normalized Hamming distance between f and g(Ax) is at most ϵ, or whether for every AGLn(𝔽2) the distance is at least ϵ+ω.

Our main result is a tolerant tester making O~((m/ω)4) queries to f, where m is an upper bound on the spectral norm of g, improving the previous O~((m/ω)24) bound of Wimmer and Yoshida. We complement this with a nearly matching lower bound of Ω(m2) for constant ω (for example, ω=1/4), improving the prior Ω(logm) lower bound of Grigorescu, Wimmer and Xie. A key technical ingredient on the algorithmic side is a query-efficient local list corrector. For the lower bound, we give a reduction from communication complexity using a novel subclass of Maiorana–McFarland functions from symmetric-key cryptography.

Keywords and phrases:
Boolean Function, Isomorphism of Boolean Function, Fourier Analysis, Sublinear Algorithm, Property Testing
Funding:
Arijit Ghosh: Arijit Ghosh acknowledges partial support from the Science and Engineering Research Board (SERB), Government of India, through the MATRICS grant MTR/2023/001527, and from the Department of Science and Technology (DST), Government of India, through grant TPN-104427.
Chandrima Kayal: Chandrima Kayal is supported by French PEPR integrated project EPiQ (ANR-22-PETQ-0007).
Manmatha Roy: Manmatha Roy acknowledges support from the ISEA Phase-III initiative of the Ministry of Electronics and Information Technology (MeitY), Govt of India, through Grant No L-14017/1/2022-HRD.
Copyright and License:
[Uncaptioned image] © Swarnalipa Datta, Arijit Ghosh, Chandrima Kayal, Manaswi Paraashar,
and Manmatha Roy; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Boolean function learning
Related Version:
Full Version: https://arxiv.org/abs/2308.02662
Editors:
Meena Mahajan, Florin Manea, Annabelle McIver, and Nguyễn Kim Thắng

1 Introduction

A Boolean function f:𝔽2n{1,+1} is said to be linearly isomorphic to g:𝔽2n{1,+1} if there exists AGLn(𝔽2) such that f(x)=g(Ax) for all x𝔽2n. The linear isomorphism is a fundamental notion with applications in coding theory, circuit complexity, and cryptography [16, 6, 38, 18, 21, 27, 17, 20]. A notable example is given by Reed–Muller codes, which are affine-invariant and whose decoding algorithms crucially exploit this symmetry [1]. Closely related isomorphism problems also arise in cryptography, such as the Isomorphism of Polynomials problem [22].

From an algorithmic standpoint, this problem has been extensively studied. Determining whether two Boolean functions are linearly isomorphic is computationally intractable even under the strong restriction that the linear transformation is a permutation matrix. The problem is known to be coNP-hard (when the functions are given in DNF form) and lies in Σ2p, but it is not known to be in coNP. Agrawal and Thierauf further showed that, unless the polynomial hierarchy collapses to Σ3p, the problem is not Σ2p-complete [2]. The best known algorithm reduces the task to the Hypergraph Isomorphism Problem and runs in 2O(n) time [29].

In this work, we study linear isomorphism of Boolean functions in the property testing framework, where the goal is to decide whether an object has a given property or is far from having it, using only a small number of queries. We work in the stronger tolerant testing model, which requires distinguishing objects that are close to the property from those that are far. We now formally define the problem of testing linear isomorphism in this setting.

Definition 1 ((ϵ,ω)-Tolerant Linear Isomorphism Testing).

Let ϵ0 and ω>0. An algorithm is given full access to a known function g:𝔽2n{1,+1} and oracle access to an unknown function f:𝔽2n{1,+1}, meaning that for any input x𝔽2n the algorithm may query the oracle to obtain f(x). It must distinguish, with probability at least 2/3, between the following cases:

  • (Yes) There exists AGLn(𝔽2) such that δ(fA,g)ϵ.

  • (No) For all AGLn(𝔽2), δ(fA,g)ϵ+ω.

Here δ(f,g) denotes the fraction of inputs on which f and g differ, that is, δ(f,g):=Prx𝔽2n[f(x)g(x)].

We now review prior work on the isomorphism testing problem, covering both algorithmic upper bounds and lower bounds.

1.1 Related Works

Wimmer and Yoshida [37] were the first to study linear isomorphism testing in the tolerant setting. They gave an algorithm for the (ω,3ω)-tolerant problem with query complexity O~((m/ω)24), where m is an upper bound on the spectral norm of the known function g. They also proved an adaptive lower bound of Ω(m) queries in a certain subconstant regime of ω (see Remark 4). In addition, Chakraborty et al. [14] showed an Ω(k) lower bound for testing linear isomorphism, when the known function is a k-Junta, which implies an Ω(logm) lower bound in terms of the spectral norm of the known function. Grigorescu, Wimmer, and Xie [25] further proved an adaptive lower bound of Ω(n2) queries when the known function g is the inner-product function on n bits. Since the spectral norm of the inner-product function is at most 2n/2, this also yields an Ω(logm) lower bound in terms of m.

Linear isomorphism is an affine-invariant property, and testing affine-invariant properties of Boolean functions has been widely studied; see, e.g., [28, 8, 7, 26]. In particular, the regularity framework of Hatami and Lovett [26] yields tolerant testers for a broad class of affine-invariant properties, including linear isomorphism to a fixed function. However, a major limitation of these general frameworks is that the resulting query complexity grows as a tower-type function of the relevant complexity parameter.

Characterizing which properties admit constant-query testers is a central question in property testing. In graph property testing, a landmark result is the characterization of all testable properties via Szemerédi’s regularity lemma [5]. In our setting, Wimmer and Yoshida [37] gave an analogous characterization for linear isomorphism testing, showing that functions with small spectral norm are exactly those for which linear isomorphism can be tested with a constant number of queries.

A closely related and more restricted problem is testing isomorphism under permutations of variables, which has also been extensively studied [11, 3, 15, 14, 12, 10]. Alon et al. [4] showed that testing permutation isomorphism for arbitrary Boolean functions requires Ω(n) queries and can be done with O(nlogn) queries. They also proved that testing permutation isomorphism to a k-junta requires Ω(k) queries, and also gave a nearly matching O(klogk)-query algorithm.

1.2 Our Contribution

Prior work exhibits a large gap between the known upper and lower bounds, even for Boolean functions with small spectral norm, which form the only class admitting constant-query testers. In this work, we nearly close this gap by presenting a non-adaptive randomized tester with substantially improved query complexity for all ϵ0 and ω>0.

Theorem 2.

Let ϵ0 and ω>0. There exists a non-adaptive randomized algorithm (see Algorithm 1) that solves the (ϵ,ω)-Tolerant Linear Isomorphism Testing problem for a known function g:𝔽2n{1,+1} with spectral norm at most m and an unknown function f:𝔽2n{1,+1}, using O~((m/ω)4) queries to f, and succeeding with probability at least 2/3. Here, the O~() notation hides polynomial factors in logm and log(1/ω).

We complement this upper bound with the following nearly matching lower bound.

Theorem 3.

For any m>0, there exists a Boolean function h:𝔽2n{1,+1} with spectral norm at most m such that every adaptive algorithm for the (0,1/4)-Tolerant Linear Isomorphism Testing problem with respect to h requires Ω(m2) queries to the unknown function.

 Remark 4.

Wimmer and Yoshida [37] proved an Ω(m) lower bound for the (0,ω)-tolerant linear isomorphism testing problem. However, to the best of our understanding, their proof applies only to the special case ω=1/m. Even if their argument could be extended to general ω, our lower bound is quadratically stronger and is based on a different approach, which we believe may be of independent interest.

2 Proof ideas

2.1 Proof idea of Theorem 2

At a high level, we follow the paradigm of testing by implicit learning introduced by Diakonikolas et al. [19], and build on the approach of Gopalan et al. [24] for testing induced membership in subclasses of Boolean functions with small spectral norm, which was also used by Wimmer and Yoshida [37] for linear isomorphism testing. Our main contribution is a refinement of this approach that yields a tester with significantly improved query complexity, comapred to Wimmer and Yoshida [37]. In the process, we introduce an efficient list-correction framework, which we call the Economical Sieve, and which we believe may be of independent interest in the analysis of Boolean functions. We now outline the overall proof strategy.

We first recall that if two Boolean functions are approximately related by a linear transformation, then their Fourier spectra are strongly correlated. Formally, for f,g:𝔽2n{1,1}, if there exists an invertible matrix AGLn(𝔽2) such that δ(f,gA)ϵ, then

β𝔽2nf^(β)gA^(β) 12ϵ,

and the converse also holds. Moreover, when the known function g has small spectral norm, this implies that it suffices to focus on the heavy Fourier coefficients of the unknown function f. The main challenge is to locate and estimate these coefficients using only oracle access to f, with a number of queries independent of n. At first glance, this seems difficult, since even identifying a linear function requires Ω(n) queries; see, e.g., [32, Exercise 1.27].

We construct an approximation f of the unknown function f such that there exists (yet unknown to the algorithm) AGLn(𝔽2) such that ffA22ϵ, using poly(m,1/ϵ) queries to f, where m is the spectral norm of the known function g. The crucial observation is that, for testing linear isomorphism, it suffices to learn f only up to an unknown nonsingular linear transformation.

The key tool enabling this is a local list-correction algorithm. Intuitively, given a threshold parameter θ, oracle access to f, and a point x𝔽2n, the algorithm identifies all heavy Fourier coefficients of f and returns a list Lx={χβ(x):|f^(β)|θ}. The algorithm is not required to output the Fourier characters β themselves, but only their evaluations at the given point x. Its query complexity depends only on θ and is independent of the dimension n. For our purposes, this weaker guarantee is sufficient. By accessing Lx at many random inputs x (polynomially many in 1/θ), we show how one can (i) approximate the heavy Fourier coefficients of f, and (ii) recover a basis for them, thereby identifying the coefficients up to a linear transformation. This yields a function that approximates f up to linear isomorphism, which is adequate for our setting, since linear isomorphism is itself a linear-invariant property. Thus, it suffices to check over all possible linear transformations to determine whether a suitable one exists. This can be carried out offline and does not require any further queries to the unknown function f. It remains to describe the local list-correction algorithm, which we refer to as the Economical Sieve.

The Economical Sieve can be viewed as a query-efficient refinement of the implicit learning framework known as the Implicit Sieve, introduced by Wimmer and Yoshida [37]. Our improved query complexity is achieved through a more refined analysis of the coset hashing process. Specifically, we revisit coset hashing process and establish new concentration bounds (Claim 12 and 14) for the 1- and 2-norms of the projected Fourier spectrum. These results show that, within any coset, the norm of the Fourier projection is dominated by the contribution of heavy coefficients. Our analysis is inspired by techniques for heavy-hitter detection in the streaming literature: 2-concentration plays a role analogous to the Count–Min Sketch, while 1-concentration corresponds to the Count Sketch. Below we provide a brief sketch of the overall approach.

  • Heavy Fourier Coefficient Detection. We begin by projecting the Fourier spectrum of f onto cosets of a random subspace H𝔽2n of dimension logO(1/θ8). This induces a pairwise-independent hashing of the Fourier coefficients of f into O(1/θ8) cosets of H. The key ingredient is Claim 12, which shows that the 2-norm of the Fourier projection in each coset is dominated by its heaviest coefficient. Thus, given sufficiently accurate 2-estimates for the cosets, we can identify all cosets containing a heavy Fourier coefficient. Unlike prior work [37, 24], which relied on estimating the Fourier 4-norm of coset buckets in order to detect cosets containing heavy Fourier coefficients, our method relies solely on these new concentration results. Consequently, we avoid the 4-estimation step, which is inherently query-intensive.

  • Heavy Fourier Coefficient Evaluation. Once the heavy cosets have been identified, we proceed to evaluate the corresponding heavy Fourier characters. This step relies on Claim 14, which shows that the 1-norm of the projected Fourier spectrum within each coset is dominated by its largest coefficient. Consequently, for any x𝔽2n, the projection can be well approximated by the evaluation of the heaviest Fourier coefficient at x. However, since we use much smaller coset structures than in [37], the probability that this approximation is sufficiently accurate for a fixed x is only constant. As our algorithm requires many such evaluations, we apply an amplification step in the spirit of the Goldreich–Levin algorithm [23].

2.2 Proof idea of Theorem 3

We prove our lower bound for linear isomorphism testing via a reduction from the Approximate Matrix Rank problem in the public-coin randomized communication complexity model. Our reduction follows the general communication-based framework for proving lower bounds in function property testing introduced by Blais, Brody and Matulef [9]. A key ingredient in our approach is the structural relationship between the sparsity of a Boolean function’s Fourier support and the dimension of its linear span, known as the Fourier dimension. A fundamental result of Sanyal [34] shows that the Fourier dimension is at most the square root of the Fourier sparsity, up to constant factors.

To exploit this relationship, we construct a class of Boolean functions based on the Maiorana–McFarland construction, which is widely used in symmetric-key cryptography due to its rich algebraic structure and well-understood spectral properties. By composing these functions with linear maps of varying rank, we obtain a family of functions whose Fourier sparsity and Fourier dimension can be carefully controlled, while preserving the quadratic relationship established in [34]. Depending on the rank of the applied linear transformation, functions from this family are either linearly isomorphic to one another or far from any such isomorphism. This enables a reduction from the Approximate Matrix Rank problem to testing linear isomorphism of Boolean functions.

In this reduction, Alice and Bob are given matrices A and B, respectively, and must decide whether the rank of their sum C=A+B is exactly r, or significantly smaller, using limited communication and shared public randomness. We encode these matrices into Boolean functions from our constructed family such that:

  • if A+B has full rank, the resulting joint function is a yes-instance of the linear isomorphism testing problem;

  • if A+B is far from full rank (by a constant factor), the resulting joint function is a no-instance.

To complete the reduction, we use a result of Sherstov and Storozhenko [36], which proves an Ω(r2) lower bound on the randomized communication complexity of distinguishing whether a matrix has rank r or at most cr, for a constant c<1. This lower bound translates directly into a nearly matching query lower bound for linear isomorphism testing in our construction.

3 Background

In this section, we recall standard notions from the analysis of Boolean functions and communication complexity that will be used throughout the paper.

For α,β𝔽2n, α,β denotes the 𝔽2-inner product. For a function f:𝔽2n, we write

𝔼x𝔽2n[f(x)]:=12nx𝔽2nf(x).

For a function f:𝔽2n, its Fourier coefficient at α𝔽2n is

f^(α):=𝔼x𝔽2n[f(x)χα(x)],where χα(x):=(1)α,x.

All expectations and probabilities over 𝔽2n are with respect to the uniform distribution. Every such function admits the Fourier expansion

f(x)=α𝔽2nf^(α)χα(x).
Fact 5 (Plancherel and Parseval Identities, see [32, Chapter 1]).

For any functions f,g:𝔽2n,

𝔼x𝔽2n[f(x)g(x)]=α𝔽2nf^(α)g^(α).

In particular,

𝔼x𝔽2n[f(x)2]=α𝔽2nf^(α)2,

which equals 1 when f:𝔽2n{1,1}.

The Fourier support of f is supp(f^):={α𝔽2n:f^(α)0}, and its size is called the Fourier sparsity. We say that f is s-Fourier sparse if |supp(f^)|s. We also use the spectral norm of f, defined as f^1:=α|f^(α)|.

For Boolean functions f,g:𝔽2n{1,1}, we measure distance by

δ(f,g):=Prx𝔽2n[f(x)g(x)].

The Linear Isomorphism Distance is

δ(f,g):=minAGLn(𝔽2)δ(fA,g),

where GLn(𝔽2) denotes the group of invertible linear maps over 𝔽2. Both δ and δ satisfy the triangle inequality.

Fact 6 (Self-Correction, see [32, Proposition 1.31]).

Suppose f:𝔽2n{1,1} is ϵ-close to the linear function χα. Then, for every x𝔽2n,

Pry𝔽2n[χα(x)=f(y)f(x+y)]12ϵ.

For the lower bound, we rely on a communication complexity result for the Approximate Matrix Rank problem. In this problem, Alice receives a matrix A𝔽2r×r and Bob receives B𝔽2r×r; their goal is to distinguish whether rank(A+B)=r or rank(A+B)r/4. We use the following fundamental result of Sherstov and Storozhenko [36].

Fact 7 (Approximate Matrix Rank Problem [36, Theorem 1.1]).

Alice receives a matrix A𝔽2r×r, and Bob receives a matrix B𝔽2r×r. Their task is to determine, for C=A+B, whether

rank(C)=rorrank(C)r4,

while exchanging as few bits of communication as possible. The public-coin randomized communication complexity of this problem is Ω(r2).

4 A query-efficient tester for the linear isomorphism problem

We begin with the local list correction framework, which plays a fundamental role in our algorithm.

Lemma 8 (Economical Sieve).

There exists an algorithm, Economical Sieve, that takes parameters θ and λ as input, makes O~(max(1θ4,λθ2)) queries to the truth table of a Boolean function f:𝔽2n{1,1}, and, with probability at least 910, outputs:

  • A matrix Q{1,+1}λ×k, where the (i,j)-th entry is χαj(xi);

  • A column vector F{1,1}λ, where F(i)=f(xi) for each i[λ],

where each xi𝔽2n is drawn independently and uniformly at random, and each αj𝔽2n belongs to a set 𝒮={α1,,αk} satisfying:

  • For every α𝔽2n such that |f^(α)|θ, we have α𝒮;

  • For all α𝒮, it holds that |f^(α)|θ/2.

For now, we assume Lemma 8 and proceed to prove Theorem 2. The proof of Lemma 8, which establishes the correctness and performance guarantees of the Economical Sieve, will be presented later.

4.1 Proof of Theorem 2

We begin by restating Theorem 2 for the sake of reader’s convenience.

Theorem 2. [Restated, see original statement.]

Let ϵ0 and ω>0. There exists a non-adaptive randomized algorithm (see Algorithm 1) that solves the (ϵ,ω)-Tolerant Linear Isomorphism Testing problem for a known function g:𝔽2n{1,+1} with spectral norm at most m and an unknown function f:𝔽2n{1,+1}, using O~((m/ω)4) queries to f, and succeeding with probability at least 2/3. Here, the O~() notation hides polynomial factors in logm and log(1/ω).

Proof.

We prove the theorem by presenting an explicit algorithm, LinearIsoTester (Algorithm 1), and analyzing its theoretical guarantees to show that it satisfies the requirements of Theorem 2. Consider Algorithm 1. We assume that, for the parameter settings

θ=ω10mandλ=100θ2log100θ2,

Lemma 8 holds and the Economical Sieve correctly returns the pair (Q,F). We now analyze the subsequent steps of Algorithm 1. Recall that each invocation of the Economical Sieve implicitly returns a set 𝒮={α1,,αk}𝔽2n satisfying:

  • For every α𝔽2n such that |f^(α)|θ, we have α𝒮;

  • For all α𝒮, it holds that |f^(α)|θ/2.

Having access to evaluations of χαi(x) for many inputs x, we can identify the characters in 𝒮 up to a linear transformation. Let 𝒯 be a subset of 𝒮. Note that if αi𝒯αi=𝟎n, then for all x𝔽2n,

αi𝒯χαi(x)=αi𝒯(1)αi,x=(1)αi𝒯αi,x=1.

Thus, the product of the corresponding columns of Q, denoted Π𝒯, always equals 𝟏λ. On the other hand, if 𝒮 consists of linearly independent vectors, then the probability that αiχαi(x)=1 for all x is small.

Claim 9.

The probability that all entries of αiχαi(xj) are equal to 1 is at most 2λ. Moreover, for any fixed , the probability that this product equals 1 for any subset of is at most 1/100.

Proof.

Since the vectors αi are linearly independent and the points x1,,xλ are sampled uniformly at random from 𝔽2n, we have Pr[αiχαi(xj)=1]=1/2 for each independent sample xj. Hence, the probability that this holds across all λ independent trials is at most 2λ. Furthermore, the number of possible subsets of is at most 2||=2O(1/θ2). By applying the union bound, the probability that αi𝒟χαi(xj)=1 occurs for any subset 𝒟 is at most 2λ2O(1/θ2)<o(1), provided that λ=Ω((1/θ2)log(1/θ)).

Having identified all the heavy Fourier coefficients of f (up to a linear transformation), we now estimate their corresponding Fourier magnitudes using the sample set (Q,F). This is formalized in the following claim.

Claim 10.

Using random examples (Q,F), one can estimate all heavy Fourier coefficients of f within ±θ/10, except with probability at most 1/25.

Proof.

For each Bi{B1,B2,,Bk}, the algorithm uses the random examples (Q,F) to estimate f^(Bi) within an additive error of ±θ/10, achieving confidence 1θ2/100. Let f^~(Bi) denote this estimate. A sample size of λ=(100/θ2)log(100/θ2) suffices to achieve this accuracy and confidence. Applying the union bound over all heavy fourier coefficients, the probability that at least one estimate fails to meet the required accuracy is at most 1/25.

Algorithm 1 LinearIsoTester.

Finally, the algorithm constructs the real-valued function f(x)=Bif^~(Bi)χBi(x). The following claim shows that this approximation suffices for testing linear isomorphism, as the property is linear-invariant and f preserves the spectral structure of f up to a linear transformation.

Claim 11.

Suppose f and g are ϵ-close to being linearly isomorphic. Then there exists a nonsingular transformation A such that βf^(β)gA^(β)12ϵω/100. Conversely, if there exists a nonsingular transformation A satisfying βf^(β)gA^(β)12ϵω/100, then f and g are ϵ+ω/100-close to being linearly isomorphic.

Proof.

Since f and g are ϵ-close to being linearly isomorphic, there exists an invertible linear transformation A such that Prx𝔽2n[f(x)gA(x)]ϵ. Using the fact that f,g{+1,1}, we have:

β𝔽2nf^(β)gA^(β)=𝔼x𝔽2n[f(x)gA(x)]=12Prx𝔽2n[f(x)gA(x)]12ϵ.

Since each Fourier coefficient of f approximates that of f within an additive error of at most θ/10, we have:

β𝔽2nf^(β)gA^(β)12ϵθ10g^112ϵω100,

where the last inequality follows from θ=ω10m and g^1m.

For the other direction, note that by assumption, the algorithm finds a transformation A such that

β𝔽2nf^(β)gA^(β)12ϵω100.

Since each estimated Fourier coefficient in f is within θ10 of the true value in f^, it follows that:

β𝔽2nf^(β)gA^(β)12ϵω100θ10g^112ϵ2ω100.

Using Parseval’s identity, we have,

β𝔽2n(f^(β)gA^(β))2 =βf^2(β)2βf^(β)gA^(β)+βgA^2(β)
=22βf^(β)gA^(β)
22(12ϵ2ω100)
=4ϵ+4ω100.

Further,

Prx𝔽2n[f(x)gA(x)]=14𝔼x𝔽2n[(f(x)gA(x))2]14(4ϵ+4ω100)=ϵ+ω100.

Thus, f and g are ϵ+ω100-close to being linearly isomorphic, as claimed.

Finally, the overall failure probability of Algorithm 1 is at most 1/10 (Step 1) + o(1) (Step 2) + 1/25 (Step 3), which sums to at most 1/3. Regarding the query complexity, note that the only queries to the unknown function f occur in Step 1 via the Economical Sieve. By Lemma 8, for the chosen parameters θ and λ, the total query complexity is O~(m4/ω4). This completes the proof.

4.2 Proof of Lemma 8

The primary tool we use here is the projection of the Fourier coefficients of f onto a random coset structure and analyzing the concentration of these coefficients within the cosets. Below, we briefly outline the concept of random coset decomposition and then proceed to the main proof.

Specifically, we project the Fourier spectrum of f onto a collection of cosets 𝒞, obtained from a randomly permuted coset decomposition of a subspace of codimension

t=log(232θ8).

To construct this decomposition, we sample t independent uniform vectors β1,,βt𝔽2n and define

H=span{β1,,βt},

the subspace of vectors orthogonal to all βi. Each coset of H is indexed by a vector b𝔽2t and defined as

D(b):={α𝔽2n:α,βi=bi for all i[t]}.

To randomize the coset labels, we further sample a uniform shift z𝔽2t and relabel each coset D(b) as D(b+z), yielding a randomly permuted coset structure. As shown by Gopalan et al. [24], this construction induces a pairwise independent hash family over 𝔽2n. We will rely heavily on this property throughout the proof. We now proceed to give the proof of Theorem 8 by analyzing Algorithm 2. Throughout the proof, we will use the notations listed in Table 1.

Table 1: Notations.
Notation Description
𝒞 A random coset decomposition of 𝔽2n
C Individual cosets of 𝒞
𝒞 Set of cosets of 𝒞 that contains a heavy Fourier coefficient of f
αC The Fourier coefficient in C with the highest absolute value αC:=argmaxβC|f^(β)|
𝒲C Total Fourier weight of coset C e.g. βCf^(β)2
𝒲C f^2(αC), weight of the heaviest Fourier coefficient in C
𝒫C(z) βCf^(β)χβ(z), projection of f(z) into coset C
𝒫C(z) f^(αC)χαC(z), projection of f(z) onto the heaviest Fourier coefficient of C

Proof of Lemma 8 (Economical Sieve).

In Step 1, we project the Fourier spectrum of f onto a random coset structure 𝒞 of codimension log232θ8. In Step 2, we estimate the Fourier weight of f of each coset of 𝒞 within ±θ24 accuracy. Given the parameter settings in the algorithm, we demonstrate that at the end of Step 3 of Algorithm 2, we successfully identify a set of cosets 𝒞𝒞 that collectively contain all heavy Fourier coefficients while ensuring that its size remains bounded. One may observe a resemblance of this guarantee to the celebrated Goldreich-Levin theorem [23]. This resemblance is not coincidental; in fact, the this part of this algorithm can be viewed as an implicit version of the Goldreich-Levin algorithm. We now formally state and prove the following claim.

Claim 12.

Let 𝒞 be a randomly permuted coset structure of codimension log232θ8. Then, except with probability at most 120, after Step 3 the algorithm outputs a set of cosets 𝒞𝒞 such that:

  1. (i)

    Every Fourier coefficient α with |f^(α)|θ264 is mapped to a distinct coset. Consequently for any C𝒞

    maxβC{αc}|f^(β)|<θ264 where αC:=argmaxβC|f^(β)|
  2. (ii)

    For any C𝒞, if |f^(αC)|θ, then C𝒞.

  3. (iii)

    For every C𝒞, |f^(αC)|θ2.

  4. (iv)

    For every C𝒞, its Fourier weight 𝒲C=βCf^(β)2 is highly concentrated around weight of its dominant fourier coefficient

    βC{αC}f^(β)2<θ4212

Proof.

We begin by defining the following events.

Event E1:

All Fourier coefficients α with |f^(α)|θ264 are mapped to distinct cosets of 𝒞.

Event E2:

For every coset C whose dominant Fourier coefficient αC satisfies |f^(αC)|<θ264,

𝒲C<θ216.
Event E3:

For every coset C whose dominant coefficient satisfies |f^(αC)|θ264,

𝒲Cf^(αC)2+θ4212.
Event E4:

For every coset C𝒞, the estimate 𝒲~C produced in Step 3 satisfies

|𝒲~C𝒲C|θ2/4.

Condition on the event E:=E1E2E3E4. we show that the conclusion of the claim follows deterministically.

(i) Distinctness of heavy coefficients.

Since θ>θ264, event E1 immediately implies that all Fourier coefficients of magnitude at least θ are mapped to distinct cosets, establishing the first item of the claim.

(ii) All Cosets with heavy coefficients are selected.

Let C be a coset whose dominant coefficient αC satisfies |f^(αC)|θ. Then 𝒲Cf^(αC)2θ2. By event E4, 𝒲~C𝒲Cθ243θ24. Hence, C is selected into 𝒞.

(iii) No coset with small dominant coefficient is selected.

Let C be a coset whose dominant coefficient satisfies |f^(αC)|θ/2.

Case 1: |f^(αC)|θ264.

By event E2, 𝒲C<θ216. Using event E4, 𝒲~C𝒲C+θ24<3θ24, and hence C is not selected.

Case 2: θ264|f^(αC)|θ/2.

By event E3, 𝒲Cf^(αC)2+θ4212<5θ216. Again using event E4, 𝒲~C𝒲C+θ24<3θ24, and C is not selected.

(iv) Fourier weight of the cosets is highly concentrated around the weight of the heaviest part.

This follows directly from Event E3.

It remains to show that

PrH,b[¬E]=PrH,b[¬E1¬E2¬E3¬E4]<110,

When the Fourier spectrum of f is projected onto a randomly permuted coset structure by choosing a subspace H𝔽2n uniformly at random of codimension t=log212100θ8, and an independent uniformly random shift b𝔽2t, and considering the restriction of f to the cosets b+H. We analyze the events E1,E2,E3,E4 individually and bound the probability that each of them fails.

Event 𝑬𝟏 (Isolation of heavy coefficients).

First we show that since the coset structure is induced by a uniformly random subspace of codimension t, any fixed vector lies in a given coset with probability 2t. To see why, fix α𝔽2n and b𝔽2t. By definition, the event αD(b+z) is equivalent to

i[t],α,βi=bi+zi.

Each zi is an independent uniformly random bit, and hence

Pr[αD(b+z)]=i=1tPr[zi=α,βibi]=2t.

Now consider two distinct vectors α,α𝔽2n. They lie in the same coset if and only if

αα,βi=0i[t].

Since αα0, each constraint holds independently with probability 1/2, and thus the collision probability is 2t.

Now, fix two distinct Fourier coefficients α,βS. By the above, the probability that they collide into the same coset is 2t. Applying the union bound over all (|S|2) pairs, the total collision probability is at most

(|S|2)2t|S|22t(212θ4)2θ8232<1100,

where we used t=log(232/θ8). Therefore, with probability at least 0.99, all coefficients in S are isolated into distinct cosets.

Event 𝑬𝟐 (Fourier Weight Concentration for Heavy cosets).

Fix a coset C containing a unique coefficient αCS. Write

𝒲C=f^(αC)2+βαCf^(β)2Iβ,

where Iβ is the indicator that β hashes to C.

For each βαC, 𝔼H,b[Iβ]=2t. Therefore,

𝔼H,b[𝒲Cf^(αC)2]=βαCf^(β)2𝔼H,b[Iβ]=2tβαCf^(β)2.2tθ8/232.

Applying Markov’s inequality,

PrH,b[𝒲Cf^(αC)2θ4212]θ8/232θ4/212=θ4/220.

Since there are at most |S|212/θ4 such cosets, a union bound gives overall failure probability at most 1/100.

Event 𝑬𝟑 (Bounding Fourier Weights of Light cosets).

Let C be a coset such that |f^(β)|<θ2/64 for all βC. Then

𝔼H,b[𝒲C]=βf^(β)2𝔼H,b[Iβ]=2tβf^(β)22tθ8/s32.

Using pairwise independence,

VarH,b(𝒲C)=βf^(β)4VarH,b(Iβ)βf^(β)4𝔼H,b[Iβ]=2tβf^(β)4.

Since |f^(β)|<θ2/64 implies f^(β)4θ4212f^(β)2,

βf^(β)4θ4212βf^(β)2=θ4212

Thus VarH,b(𝒲C)2tθ4212θ12244. Applying Chebyshev’s inequality,

PrH,b[𝒲C𝔼H,b[𝒲C]θ216](θ12/244)(θ4/162)=θ8/236.

There are at most 2t232/θ8 cosets, so by a union bound the total failure probability is at most 1/16.

Event 𝑬𝟒 (Fourier weight estimation are correct upto ±𝜽𝟐/𝟒).

We assume that it happens with probability at least 1o(1). See Claim 15 further details.

Combining the failure probabilities, we get PrH,b[¬E1¬E2¬E3¬E4]<110.

Algorithm 2 Economical Sieve.

Having implicitly identified all the heavy cosets associated with heavy Fourier coefficients, the next step is to evaluate χαc(x) at a uniformly sampled point x𝔽2n, for each coset C𝒞. Importantly, while each survived coset C is known to contain a unique dominant Fourier character αc, the identity of αc itself remains unknown. From a coding-theoretic viewpoint, this task can be interpreted as a local list-correction problem for the first-order Reed–Muller code. Given oracle access to a corrupted codeword (represented here by the Boolean function f), the goal is to recover the value of all nearby codewords at a queried position without explicitly decoding them. To this end, for any coset C, define

𝒫C(z):=βCf^(β)χβ(z).

The following claim shows that a noisy variant of the standard self-correction procedure succeeds simultaneously for all survived cosets.

Claim 13.

Let 𝒞 be the set of survived cosets. Then for any fixed x𝔽2n,

Pry𝔽2n[C𝒞,𝗌𝗂𝗀𝗇(𝒫C(x+y))𝗌𝗂𝗀𝗇(𝒫C(y))=χαc(x)]78.

Proof.

Before proceeding the proof of Claim 13, we show that for every coset C, for uniformly sampled z, 𝒫C(z)=βCf^(β)χβ(z), the projection of f(z) onto a coset C is highly concentrated around 𝒫C(z)=f^(αc)χαc(z). More formally, we establish the following concentration result.

Claim 14.

Suppose f:𝔽2n{1,+1}, and let C𝒞 be a coset with dominant Fourier coefficient αC such that

βC{αC}f^(β)2<θ4212,|f^(αC)|>θ2.andmaxβC{αc}|f^(β)|<θ264.

Then

Prz𝔽2n[|𝒫C(z)𝒫C(z)|θ264+τ]θ4212τ2.

Proof.

To establish this, we first recall that Fourier characters act as pairwise independent hash functions χα:𝔽2n{1,+1}. Indeed, when z is uniformly sampled from 𝔽2n, each bit zi is independent and uniformly distributed in {0,1}. For any nonzero α𝔽2n, we have:

𝔼z𝔽2n[χα(z)]=𝔼z𝔽2n[(1)α,z]=12(1)+12(1)=0.

Moreover, for distinct α1,α2𝔽2n, we have:

𝔼z𝔽2n[χα1(z)χα2(z)]=𝔼z𝔽2n[(1)α1+α2,z]=0=𝔼z𝔽2n[χα1(z)]𝔼z𝔽2n[χα2(z)],

establishing pairwise independence. Next, we show that the expectation of (𝒫C(z)𝒫C(z)) is small, analyzing two distinct cases separately depending on whether 𝟎C or not, where C={Cαc}.

Case I: When 𝑪 does not contain 𝟎 or 𝟎 is the leader of the coset 𝑪.

𝔼z𝔽2n[𝒫C(z)𝒫C(z)]=𝔼z𝔽2n[βCf^(β)χβ(z)]=βCf^(β)𝔼z𝔽2n[χβ(z)]=βCf^(β)0=0.

Case II: When 𝑪 contains 𝟎 and 𝟎 is not the leader of the coset 𝑪.

𝔼z𝔽2n[𝒫C(z)𝒫C(z)]=𝔼z𝔽2n[βf^(β)χβ(z)]+f^(0)=βf^(β)𝔼z𝔽2n[χβ(z)]+f^(0)f^(0)=θ264.

Next, we show that the variance of (𝒫C(z)𝒫C(z)) is also small:

Varz𝔽2n[βf^(β)χβ(z)]=βCVarz𝔽2n[f^(β)χβ(z)]βC𝔼z𝔽2n[(f^(β)χβ(z))2]=βCf^(β)2=θ4212

Applying Chebyshev’s inequality,

Prz𝔽2n[|𝒫C(z)𝒫C(z)|>θ264+τ]Varz𝔽2n[𝒫C(z)𝒫C(z)]τ2θ4212τ2

This completes the proof.

For our algorithm, we set τ=θ8. Substituting this value yields

Prz𝔽2n[|𝒫C(z)𝒫C(z)|>θ4]θ264.

Next, observe that since f:𝔽2n{1,+1}, the number of Fourier coefficients of magnitude at least θ/2 is at most 4/θ2. As each survived coset contains a unique dominant Fourier coefficient of magnitude at least θ/2, it follows that |𝒞|4θ2. Applying a union bound over all survived cosets, we obtain

Prz𝔽2n[C𝒞,|𝒫C(z)𝒫C(z)|θ4]116.

Combining this event with the fact that |f^(αC)|θ2 for every surviving coset C, and using that for any x𝔽2n the sum x+y is uniformly distributed over 𝔽2n when y is chosen uniformly at random from 𝔽2n, we conclude that

Prz𝔽2n[C𝒞,𝗌𝗂𝗀𝗇(𝒫C(x+y))𝗌𝗂𝗀𝗇(𝒫C(y))=χαc(x)]78.

However, the algorithm does not have access to the exact value of 𝒫C(z); it can only estimate it with reasonable accuracy. In our setting, if the estimated value 𝒫~C(z) lies within ±θ8 of the true value, the preceding argument still holds.

Moreover, to construct the pair (Q,F) under the given parameter settings of λ and α, it is necessary to evaluate χαc(x) for a sufficiently large number of inputs x, for all cosets C𝒞. This requires enhancing the reliability of the self-correction procedure. To achieve this, we apply the standard median trick for error reduction: for each fixed input x, we perform multiple independent trials using different random choices of y, and report the median of the obtained outcomes. By a direct application of the Chernoff bound, taking O(log(1/θ)) independent samples suffices to amplify the success probability to at least 11/poly(1/θ), which is sufficient to apply a union bound over all surviving cosets and all inputs x.

Claim 15.

In Algorithm 2, the total number of queries made by the algorithm is bounded by O~(max(λ/θ2,1/θ4)).

Proof.

The unknown function f is queried primarily in the following two steps of Algorithm 2:

Step 2:

In this step, the algorithm estimates the weight of each of the O(1θ8) cosets with accuracy ±θ24 and failure probability at most O(θ8). Then, the total number of queries required to estimate the weights of all cosets with the specified accuracy and confidence is O~(1θ4).. Note that for any x𝔽2n, the weight of a coset r+H can be estimated via

𝒲r+H=𝔼x𝔽2n,zH[χr(z)f(x)f(x+z)].

Moreover, a single batch of samples can be reused simultaneously to estimate the weight of all cosets.

Step 4:

In this step, the algorithm samples λ many x’s, and for each, runs O~(log(1/θ2)) independent trials. In each trial, for each coset, the projections

𝒫r+Hf(x)=𝔼yH[χr(y)f(x+y)]

are estimated within ±θ8 accuracy with failure probability at most O(θ2). For any fixed x, the same batch of samples can simultaneously estimate the projections for all cosets. Then, the total number of queries in this step is also bounded by O~(λ/θ2).

So, the overall query complexity of Algorithm 2 is O~(max(λ/θ2,1/θ4)).

This completes the analysis of Economical Sieve (proof of Lemma 8).

5 A lower bound for testing linear isomorphism

We begin by defining a class of Boolean functions known as the Maiorana–McFarland functions. These functions have a long history of applications in theoretical computer science, particularly in proving lower bounds. Notable examples include circuit lower bounds [33, 13] and studies on the structural properties of Boolean functions relevant to complexity theory [31, 34]. Beyond complexity theory, they play a fundamental role in symmetric-key cryptography, especially in the design of stream ciphers, where they serve as building blocks for achieving good confusion (captured by the Fourier or Walsh spectrum) and diffusion (captured by the autocorrelation spectrum); see [35] for further details. We now formally define Maiorana–McFarland functions.

Definition 16.

Given positive integers n and r with rn, the family of Maiorana–McFarland functions (originally introduced in [30]), denoted MMr,n, consists of n-variable Boolean functions f:𝔽2n{1,+1} of the form

g(x,y)=(1)x,φ(y),(x,y)𝔽2r×𝔽2nr,

where φ:𝔽2nr𝔽2r is an arbitrary mapping.

A key property of Maiorana–McFarland functions that we exploit is that, when composed with suitable linear transformations, their Fourier sparsity is governed by the rank of the underlying transformation. We state this property formally below.

Claim 17.

Let n=r+logr, and let φ:𝔽2nr𝔽2r be a mapping whose image has cardinality r, with the image set linearly independent in 𝔽2r and L is a linear transformation in 𝔽2r×r. Let

gL(x,y)=(1)Lx,φ(y),

Then the Fourier sparsity of gL is at most rank(L)×r.

Proof.

For (u,v)𝔽2r×𝔽2nr, the Fourier coefficient of gL is

gL^(u,v)=𝔼x𝔽2r,y𝔽2nr[(1)Lx,φ(y)+u,x+v,y].

Reordering the expectation yields

gL^(u,v)=𝔼y𝔽2nr[(1)v,y𝔼x𝔽2r(1)LTφ(y)+u,x].

Now

𝔼x𝔽2r[(1)LTφ(y)+u,x]={1if u=LTφ(y),0otherwise.

Hence

gL^(u,v)=12nry𝔽2nrLTφ(y)=u(1)v,y.

Therefore (u,v) can be in the Fourier support only if uIm(LTφ). Since φ has r distinct outputs that are linearly independent in 𝔽2r, the set {LTφ(y):y𝔽2nr} spans a subspace of dimension at most rank(L). Thus there are at most rank(L) distinct u values that can occur. For each such u, there are 2nr=r possible choices of v. Hence the total number of possible nonzero Fourier coefficients is at most rank(L)r, establishing the claimed sparsity bound.

Proof of Theorem 3

In this section, we prove Theorem 3, establishing a lower bound that is quadratically stronger than the previously known result from [24].

Theorem 3. [Restated, see original statement.]

For any m>0, there exists a Boolean function h:𝔽2n{1,+1} with spectral norm at most m such that every adaptive algorithm for the (0,1/4)-Tolerant Linear Isomorphism Testing problem with respect to h requires Ω(m2) queries to the unknown function.

Proof.

We establish the lower bound via a reduction from the Approximate Matrix Rank problem in randomized communication complexity (Theorem 7). Alice receives A𝔽2r×r, Bob receives B𝔽2r×r, and it is promised that rank(C) for C=A+B is either r or r/4. Their goal is to determine rank(C) with minimal communication and shared randomness.

Let g=gI denote the reference function defined in Claim 17, where I is the r×r identity matrix. Alice constructs a function fA from A, Bob constructs fB from B, and together they define f=fC=fA+B. By Claim 17, if rank(C)=r, then supp(f^)=r2 and if rank(C)=r/4, then supp(f^)r2/4. Moreover, if rank(C)=r, then f is linearly isomorphic to g. On the other hand, the following Claim shows that when rank(C)=r/4, the function f is far from every such isomorphism.

Claim 18.

If rank(C)=r, then f is 14-far from any Boolean function with Fourier sparsity at most r2/4.

Proof.

Let h:𝔽2n{1,+1} be a r24-Fourier sparse function. Then,

Prx𝔽2n[h(x)f(x)] =Prx𝔽2n[h(x)f(x)] (1)
=12+12𝔼x𝔽2n[h(x)f(x)]
=12+12α𝔽2nh^(α)f^(α)
=12+12αsupp(h)h^(α)f^(α). (2)

Recall that for Boolean function f:𝔽2n{±1}, supp(f^):={α𝔽2n:f^(α)0}. Now applying Cauchy-Schwarz inequality, we get

|αsupp(h)h^(α)f^(α)| αsupp(h^)h^2(α)αsupp(h^)f^2(α)=αsupp(h^)f^2(α) (3)

Note that h is a r24-Fourier sparse Boolean function, that is, |supp(h^)|r24. Observe that, by the construction of function f (see Corollary 17), the absolute values of any two non-zero Fourier coefficients are equal and the Fourier support supp(f^)=r2. Using the fact that α𝔽2nf^(α)2=1 (Parseval’s identity), we get

αsupp(h^)f^2(α)12 (4)

Finally, plugging the bound from Equation (4) into Equation (1), we conclude that

Prx𝔽2n[h(x)f(x)]12+12(12)=14.

Thus, distinguishing between the two rank cases reduces to distinguishing whether f is isomorphic to g or 14-far from every isomorphism of g. Suppose there exists a tester 𝕋 for linear isomorphism with respect to a function of spectral norm m, with query complexity q(m,14). In our case, the reference function is g with m=O(r). To simulate a query (x,y)𝔽2n, Alice computes fA(x,y), Bob computes fB(x,y), and they exchange one bit each. Since

fC(x,y)=(1)(A+B)x,φ(y)=fA(x,y)fB(x,y),

they can compute f(x,y) with two bits of communication per query. Hence, simulating 𝕋 requires at most 2q(m,14) bits. However, by Fact 7, solving the promised rank problem requires Ω(r2) bits. Therefore, q(m,14)=Ω(r2). Since m=O(r) for g, we conclude that testing linear isomorphism with respect to g requires Ω(m2) queries.

6 Conclusion

A Boolean function f:𝔽2n{1,1} is said to be affinely isomorphic to another function g:𝔽2n{1,1} if there exist an invertible matrix AGLn(𝔽2) and a vector b𝔽2n such that for all x𝔽2n,

g(Ax+b)=f(x).

By adapting the techniques from the proofs of Theorem 2 and Theorem 3, we can establish analogous results for testing affine isomorphism between a known function and an unknown function given oracle access to its truth table.

References

  • [1] Emmanuel Abbe, Amir Shpilka, and Min Ye. Reed-Muller Codes: Theory and Algorithms. IEEE Transactions on Information Theory, 67(6):3251–3277, 2021. doi:10.1109/TIT.2020.3004749.
  • [2] Manindra Agrawal and Thomas Thierauf. The Formula Isomorphism Problem. SIAM Journal on Computing, 30(3):990–1009, 2000. doi:10.1137/S0097539798343647.
  • [3] Noga Alon and Eric Blais. Testing Boolean Function Isomorphism. In Proceedings of the 10th International Workshop on Randomization and Computation (RANDOM), pages 394–405, 2010. doi:10.1007/978-3-642-15369-3_30.
  • [4] Noga Alon, Eric Blais, Sourav Chakraborty, David García-Soriano, and Arie Matsliah. Nearly Tight Bounds for Testing Function Isomorphism. SIAM Journal on Computing, 42(2):459–493, 2013. doi:10.1137/110832677.
  • [5] Noga Alon, Eldar Fischer, Ilan Newman, and Asaf Shapira. A Combinatorial Characterization of the Testable Graph Properties: It’s All About Regularity. In Proceedings of the 38th Annual ACM Symposium on Theory of Computing (STOC), pages 251–260, 2006. doi:10.1145/1132516.1132555.
  • [6] Alberto Bemporad. Efficient Conversion of Mixed Logical Dynamical Systems Into an Equivalent Piecewise Affine Form. IEEE Transactions on Automatic Control, 49(5):832–838, 2004. doi:10.1109/TAC.2004.828315.
  • [7] Arnab Bhattacharyya, Eldar Fischer, Hamed Hatami, Pooya Hatami, and Shachar Lovett. Every Locally Characterized Affine-Invariant Property is Testable. In Proceedings of the 45th ACM Symposium on Theory of Computing (STOC), pages 429–436, 2013. doi:10.1145/2488608.2488662.
  • [8] Arnab Bhattacharyya, Elena Grigorescu, and Asaf Shapira. A Unified Framework for Testing Linear-Invariant Properties. Random Structures & Algorithms, 46(2):232–260, 2015. A preliminary version of this work appeared as an extended abstract in the proceedings of FOCS 2010. doi:10.1002/RSA.20507.
  • [9] Eric Blais, Joshua Brody, and Kevin Matulef. Property Testing Lower Bounds via Communication Complexity. Computational Complexity, 21(2):311–358, 2012. A preliminary version of this work appeared as an extended abstract in the proceedings of CCC 2011. doi:10.1007/S00037-012-0040-X.
  • [10] Eric Blais, Clément L. Canonne, Talya Eden, Amit Levi, and Dana Ron. Tolerant Junta Testing and the Connection to Submodular Optimization and Function Isomorphism. ACM Transactions on Computation Theory, 11(4):24:1–24:33, 2019. A preliminary version of this work appeared as an extended abstract in the proceedings of SODA 2019. doi:10.1145/3337789.
  • [11] Eric Blais and Ryan O’Donnell. Lower Bounds for Testing Function Isomorphism. In Proceedings of the 25th Annual IEEE Conference on Computational Complexity (CCC), pages 235–246, 2010. doi:10.1109/CCC.2010.30.
  • [12] Eric Blais, Amit Weinstein, and Yuichi Yoshida. Partially symmetric functions are efficiently isomorphism testable. SIAM Journal on Computing, 44(2):411–432, 2015. A preliminary version of this work appeared as an extended abstract in the proceedings of FOCS 2012. doi:10.1137/140971877.
  • [13] N. Blum. A Boolean function requiring 3n network size. Theoretical Computer Science, 28:337–345, 1984. doi:10.1016/0304-3975(83)90029-4.
  • [14] Sourav Chakraborty, Eldar Fischer, David García-Soriano, and Arie Matsliah. Junto-Symmetric Functions, Hypergraph Isomorphism and Crunching. In Proceedings of the 27th Conference on Computational Complexity (CCC), pages 148–158, 2012. doi:10.1109/CCC.2012.28.
  • [15] Sourav Chakraborty, David García-Soriano, and Arie Matsliah. Nearly Tight Bounds for Testing Function Isomorphism. In Proceedings of the 22nd Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 1683–1702, 2011. doi:10.1137/1.9781611973082.130.
  • [16] Valentina Ciriani. Synthesis of SPP three-level logic networks using affine spaces. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 22(10):1310–1323, 2003. doi:10.1109/TCAD.2003.818121.
  • [17] Lingguo Cui and Yuanda Cao. A new S-box structure named Affine-Power-Affine. International Journal of Innovative Computing, Information and Control, 3(3):751–759, 2007.
  • [18] Stanisa Dautovic and Ladislav A. Novak. A comment on "Boolean functions classification via fixed polarity Reed-Muller form". IEEE Transactions on Computers, 55(8):1067–1069, 2006. doi:10.1109/TC.2006.114.
  • [19] Ilias Diakonikolas, Homin K Lee, Kevin Matulef, Krzysztof Onak, Ronitt Rubinfeld, Rocco A Servedio, and Andrew Wan. Testing for Concise Representations. In Proceedings of the 48th Annual IEEE Symposium on Foundations of Computer Science, FOCS, pages 549–558, 2007. doi:10.1109/FOCS.2007.32.
  • [20] Orr Dunkelman, Nathan Keller, and Adi Shamir. Minimalism in Cryptography: The Even-Mansour Scheme Revisited. In Proceedings of the 31st Annual International Conference on the Theory and Applications of Cryptographic Techniques (EUROCRYPT), pages 336–354, 2012. doi:10.1007/978-3-642-29011-4_21.
  • [21] Iwan M. Duursma, Carlos Rentería-Márquez, and Horacio Tapia-Recillas. Reed-Muller Codes on Complete Intersections. Applicable Algebra in Engineering, Communication and Computing, 11(6):455–462, 2001. doi:10.1007/S002000000047.
  • [22] Jean-Charles Faugère and Ludovic Perret. Polynomial Equivalence Problems: Algorithmic and Theoretical Aspects. In Proceedings of the 24th Annual International Conference on the Theory and Applications of Cryptographic Techniques (EUROCRYPT), pages 30–47, 2006. doi:10.1007/11761679_3.
  • [23] Oded Goldreich and Leonid A. Levin. A Hard-Core Predicate for all One-Way Functions. In Proceedings of the 21st Annual ACM Symposium on Theory of Computing (STOC), pages 25–32, 1989. doi:10.1145/73007.73010.
  • [24] Parikshit Gopalan, Ryan O’Donnell, Rocco A Servedio, Amir Shpilka, and Karl Wimmer. Testing fourier dimensionality and sparsity. SIAM Journal on Computing, 40(4):1075–1100, 2011. doi:10.1137/100785429.
  • [25] Elena Grigorescu, Karl Wimmer, and Ning Xie. Tight Lower Bounds for Testing Linear Isomorphism. In Proceedings of the 17th International Workshop on Randomization and Computation (RANDOM), pages 559–574, 2013. doi:10.1007/978-3-642-40328-6_39.
  • [26] Hamed Hatami and Shachar Lovett. Estimating the Distance from Testable Affine-Invariant Properties. In Proceedings of the 54th Annual IEEE Symposium on Foundations of Computer Science (FOCS), pages 237–242, 2013. doi:10.1109/FOCS.2013.33.
  • [27] Xiang-Dong Hou. Classification of cosets of the Reed-Muller code R(m3,m). Discrete Mathematics, 128(1):203–224, 1994. doi:10.1016/0012-365X(94)90113-9.
  • [28] Tali Kaufman and Madhu Sudan. Algebraic Property Testing: The Role of Invariance. In Proceedings of the 40th Annual ACM Symposium on Theory of Computing (STOC), pages 403–412, 2008. doi:10.1145/1374376.1374434.
  • [29] Eugene M. Luks. Hypergraph Isomorphism and Structural Equivalence of Boolean Functions. In Proceedings of the 31st Annual ACM Symposium on Theory of Computing (STOC), pages 652–658, 1999. doi:10.1145/301250.301427.
  • [30] R. L. McFarland. A Family of Noncyclic Difference Sets. Journal of Combinatorial Theory, Series A, 15:1–10, 1973.
  • [31] Noam Nisan and Mario Szegedy. On the degree of boolean functions as real polynomials. Computational Complexity, 4:301–313, 1994. A preliminary version of this work appeared as an extended abstract in the proceedings of STOC 1992. doi:10.1007/BF01263419.
  • [32] Ryan O’Donnell. Analysis of Boolean Functions. Cambridge University Press, 2014.
  • [33] Wolfgang J. Paul. A 2.5N-Lower Bound on the Combinational Complexity of Boolean Functions. SIAM Journal on Computing, 6(3):427–443, 1977. A preliminary version of this work appeared as an extended abstract in the proceedings of the STOC 1975. doi:10.1137/0206030.
  • [34] Swagato Sanyal. Fourier Sparsity and Dimension. Theory of Computing, 15(11):1–13, 2019. doi:10.4086/TOC.2019.V015A011.
  • [35] Palash Sarkar and Subhamoy Maitra. Construction of nonlinear boolean functions with important cryptographic properties. In Bart Preneel, editor, Advances in Cryptology - EUROCRYPT 2000, Proceeding, volume 1807 of Lecture Notes in Computer Science, pages 485–506. Springer, 2000. doi:10.1007/3-540-45539-6_35.
  • [36] Alexander A. Sherstov and Andrey A. Storozhenko. The Communication Complexity of Approximating Matrix Rank. In Proceedings of the IEEE 65th Annual Symposium on Foundations of Computer Science (FOCS), pages 433–462, 2024. doi:10.1109/FOCS61266.2024.00035.
  • [37] Karl Wimmer and Yuichi Yoshida. Testing Linear-Invariant Function Isomorphism. In Proceedings of the 40th International Colloquium on Automata, Languages and Programming (ICALP), pages 840–850, 2013. doi:10.1007/978-3-642-39206-1_71.
  • [38] Boyan Yordanov, Jana Tumova, Ivana Cerna, Jiří Barnat, and Calin Belta. Temporal Logic Control of Discrete-Time Piecewise Affine Systems. IEEE Transactions on Automatic Control, 57(6):1491–1504, 2012. doi:10.1109/TAC.2011.2178328.