Hard properties with (very) short PCPPs and their applications

We show that there exist properties that are maximally hard for testing, while still admitting PCPPs with a proof size very close to linear. Specifically, for every fixed $\ell$, we construct a property $\mathcal{P}^{(\ell)}\subseteq{0,1}^n$ satisfying the following: Any testing algorithm for $\mathcal{P}^{(\ell)}$ requires $\Omega(n)$ many queries, and yet $\mathcal{P}^{(\ell)}$ has a constant query PCPP whose proof size is $O(n\cdot \log^{(\ell)}n)$, where $\log^{(\ell)}$ denotes the $\ell$ times iterated log function (e.g., $\log^{(2)}n = \log \log n$). The best previously known upper bound on the PCPP proof size for a maximally hard to test property was $O(n \cdot \mathrm{poly}\log{n})$. As an immediate application, we obtain stronger separations between the standard testing model and both the tolerant testing model and the erasure-resilient testing model: for every fixed $\ell$, we construct a property that has a constant-query tester, but requires $\Omega(n/\log^{(\ell)}(n))$ queries for every tolerant or erasure-resilient tester.

💡 Research Summary

The paper addresses a long‑standing gap between two seemingly opposing goals in the theory of property testing and probabilistically checkable proofs of proximity (PCPPs): constructing a property that is maximally hard to test (i.e., any tester needs Ω(n) queries) while simultaneously admitting a constant‑query PCPP whose proof length is almost linear in the input size. Prior work could only achieve proof lengths of O(n·polylog n) for such hard properties. The authors break this barrier by showing that for every fixed integer ℓ, there exists a property 𝒫^{(ℓ)}⊆{0,1}ⁿ such that:

• Any (standard) tester for 𝒫^{(ℓ)} requires Ω(n) queries.
• 𝒫^{(ℓ)} admits a constant‑query PCPP whose proof length is O(n·log^{(ℓ)} n), where log^{(ℓ)} denotes the ℓ‑times iterated logarithm (e.g., log^{(2)} n = log log n).

The construction is based on a layered encoding scheme that repeatedly applies a “Probabilistically Checkable Unveiling” (PCU) primitive. At the base level, the authors use low‑degree polynomials over a large finite field F. A random polynomial of degree about |F|/2 behaves indistinguishably from a truly random function when queried on fewer than |F|/2 points, yet its full description can be recovered only after reading essentially the whole truth table. Instead of exposing the polynomial’s values directly, the authors encode each value using a PCU scheme, which allows a verifier to check the correctness of the encoding with only a constant number of queries, provided a short PCU‑proof is supplied. By iterating this construction ℓ times—each iteration treating the previous PCU proof as the new “value” to be encoded—the overall proof length shrinks by a logarithmic factor at each level, yielding the final O(n·log^{(ℓ)} n) bound.

The hardness of testing follows from the same low‑degree polynomial property: without a proof, any algorithm must read almost the entire encoded string to distinguish a valid encoding from a random one, which forces Ω(n) queries. Yet with the proof, the verifier can confirm validity with constant queries, satisfying the definition of a constant‑query PCPP.

Beyond this core result, the paper leverages the construction to obtain stronger separations between the standard testing model and two more robust models:

1. Tolerant Testing – where the algorithm must distinguish inputs that are ε₀‑close to the property from those that are ε₁‑far. Using the short PCPP for 𝒫^{(ℓ)}, the authors build a property that admits a constant‑query standard tester but forces any (ε₀,ε₁)‑tolerant tester to make Ω(n/ log^{(ℓ)} n) queries. This improves upon earlier separations that only achieved Ω(n/ polylog n).

2. Erasure‑Resilient Testing – where an α‑fraction of the input may be erased. Again, the same property yields a constant‑query standard tester, while any α‑erasure‑resilient tester (for α = Ω(1/ log^{(ℓ)} n)) requires Ω(n/ log^{(ℓ)} n) queries.

Finally, the authors introduce a new secret‑sharing paradigm called Probabilistically Checkable Unveiling of a Shared Secret (PCUSS). By interpreting the low‑degree polynomial encoding as a secret‑sharing scheme (similar to Shamir’s), and then wrapping each share with a PCU proof, they obtain a system where any subset of o(n) parties learns nothing without the proof, yet each individual party can present a short proof that its share is consistent. This yields a secret‑sharing scheme with “PCPP‑like” verification properties.

The paper situates its contributions within the broader literature: early PCPP constructions (BGH+06) gave exponential‑in‑log‑log proof lengths; later works (BSS08, Din07) achieved quasi‑linear lengths with higher query complexity; the most recent linear‑length, constant‑query constructions (BCG+17) did not address tolerant or erasure‑resilient testing. By introducing the iterated PCU technique, the authors close the gap between proof length and testing hardness, and open new avenues for applying short PCPPs in robust testing and cryptographic protocols. The results are likely to influence future research on optimal trade‑offs between query complexity, proof size, and robustness in property testing and related areas.