Papers for

complexity theorists

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Differential privacy achieves better algorithms using parameter tractability

Differential Privacy Meets Fixed Parameter Tractability: Algorithms and Lower Bounds

Abstract: We study combinatorial optimization problems under the constraint of $ε$-differential privacy ($ε$-DP). Given the strong lower bounds for explicitly outputting solutions, we work within the implicit representation framework of Gupta et al. (SODA 2010), where a private polynomial-time randomized "encoder" generates a representation of a solution, and a "decoder" uses this representation along with the input to extract a valid final solution. In this work, we generalize this framework by allowing the encoder to run in fixed-parameter tractable time. This circumvents approximation barriers inherent to polynomial-time algorithms and obtains improved guarantees for many fundamental combinatorial optimization problems. Finally, we establish the first representation-independent lower bounds for our framework. Assuming a non-uniform variant of the Gap Exponential Time Hypothesis, for sufficiently small $ε> 0$, we prove that no $ε$-DP encoder-decoder pair can achieve certain approximation guarantees, if the decoder runs in subexponential time. We further provide representation-dependent lower bounds that hold even for larger $ε$.

Fri 11 SeptData Structures and AlgorithmsCryptography and Security
The gist
Many optimization problems need to keep data private, but doing this often makes finding good solutions very hard or slow. The authors show how allowing the privacy algorithm to run using a special way that focuses on certain parameters helps find better solutions more efficiently. They also prove limits on how well any such private method can work under reasonable assumptions, even if the method is very powerful. This gives clearer guidance on what is possible when combining privacy and complex problem solving.
Open 2609.12508v1

Information equivalence simplifies decision tree size and success rates

The Information Complexity of Decision Trees

Abstract: We define and study a measure of information complexity for randomized decision trees. We prove three main results about this complexity measure: Information equals amortized size complexity. We show that the information complexity of randomized decision tree is equal to the logarithm of the amortized worst-case randomized tree size complexity of computing a function f. That is, when computing f on n inputs, the logarithm of the randomized tree size is exactly equal to the amount of information needed to compute the function. Information allows for tree size compression. We show that even when computing f on a single input, the information complexity can be used to compress the size of a tree, if we allow a small loss in success probability. With the recent characterization of Chattopadhyay, Dahiya, Mande, Radhakrishnan, and Sanyal (2023), this result shows that the depth of AND-OR trees can also be compressed in terms of information complexity. Direct Product Theorems. We show that the success-conditioned variant of information complexity satisfies a perfect direct product theorem. This result gives an information complexity analogue of the direct product theorem for success-conditioned randomized query complexity by Ben-David and Blais (2025).

Thu 10 SeptComputational Complexity
The gist
Decision trees are a way computers make choices step-by-step. The authors studied how much information is really needed to make these decisions when randomness is involved. They found that the information needed matches exactly how big the tree must be when solving many problems at once. Their work also shows you can make decision trees smaller if you accept a small chance of error. Additionally, they proved a property that helps understand how solving many problems together affects information needs.
Open 2609.12164v1

Medvedev logic proven undecidable and extremely complex problem

Medvedev Logic is Not Decidable. It is π01 -complete. Who Would Have Guessed?

Abstract: This project began as an attempt to prove that Medvedev logic is decidable with the help of generative AI systems. The author (as well as the generative AI systems, or at least they claim to be since I have asked them) was surprised by its eventual conclusion. We prove that Medvedev logic ML, the intermediate logic of finite problems, is Pi-01-complete under computable many-one reductions. Consequently, ML is not recursively enumerable, a fortiori undecidable, and admits no recursively enumerable sound and complete proof calculus. The proof connects the periodic domino problem with intuitionistic formulas through a shared intermediate structure that we call a Wang-Medvedev pair. Such a pair consists of a finite partially ordered set of roles together with demands. Demands define the interaction between roles. A realization labels nonempty subsets of a finite set with these roles, respecting the order and satisfying the demands. We associate a pair with each finite Wang system and show that it has a realization iff the system tiles a finite torus. We then construct an intuitionistic formula that fails on some finite Medvedev frame iff the same pair is realizable. Realizability thus provides the link between periodic tilings and the countermodels.

Thu 10 SeptLogic in Computer Science
The gist
Medvedev logic is a type of logic used to understand finite computational problems. The authors found that this logic is undecidable, meaning no algorithm can fully determine its truths. They linked the logic’s complexity to a known hard mathematical tiling problem, showing it is deeply complex and cannot be simplified into a neat set of rules. This surprising discovery overturns previous hopes that Medvedev logic might be easier to decide using AI. The proof uses a new structure called a Wang-Medvedev pair to connect these concepts.
Open 2609.11576v1

Promise problem differences reshape quantum and classical oracle results

Promises should be taken seriously: On relativization with promise problems

Abstract: Relativization is concerned with comparing computational models with black-box access to an oracle. For promise problems, black-box access is not canonical due to inputs outside of the promise being unconstrained. We study two semantics for such access. Under robust queries, a machine must correctly answer regardless of the completion of the problem,, while loose access requires that the internal choices of a machine do not change based on off-promise queries. Our first result separates the language and promise settings. Namely, we construct an oracle $O$ such that $\mathsf{P}^O = \mathsf{BQP}^O = \mathsf{AWPP}^O$, but $\mathsf{PromiseBQP}^O\not\subseteq\mathsf{PromiseP}^O_{\mathsf{/poly}}$. In particular, $\mathsf{BPP}^O = \mathsf{BQP}^O$, but $\mathsf{PromiseBQP}^O \neq \mathsf{PromiseBPP}^O$, showing that results for languages need not transfer to promises. Next, we use loose queries to strengthen the upper bound on the Quantum-Classical Polynomial Hierarchy from $\mathsf{P}^{\mathsf{PP}^{\mathsf{PP}}}$ to $\mathsf{QCPH} \subseteq \mathsf{BP\cdot PP} \subseteq \mathsf{PromiseBPP}^{\mathsf{PP}}$. The same proof also shows $\mathsf{PP}^\mathsf{PromiseBQP} = \mathsf{PP}$. Additionally, we show that $\mathsf{PromiseBQP}$, even when given quantum advice, is self-low under robust queries. Finally, we exhibit an obstruction to transferring language-level counting results to promise classes. Although $\mathsf{AWPP}$ and $\mathsf{APP}$ are low for $\mathsf{PP}$, a corresponding promise analogue would collapse the counting hierarchy as $\mathsf{GapP} \subseteq \mathsf{FP}^{\mathsf{PromiseAWPP}}$. This motivates the introduction of $\mathsf{PromisePostBQP^*}$, which restricts $\mathsf{PostBQP}$ to input-indepencent postselection. By showing that it is low for \PP, we obtain $\mathsf{PP}^{\mathsf{PromiseYQP^*}} = \mathsf{PP}$.

Mon 7 SeptComputational Complexity
The gist
The paper explores how computational models behave differently when given access to special helper tools called oracles, especially for promise problems — cases where inputs outside a certain range are not considered. The authors find that results proven for normal decision problems don't always hold for promise problems, which is important for understanding quantum versus classical computations. They also propose new ways to think about oracle access to better capture promise problem behavior and show that certain complexity classes behave unexpectedly under these assumptions. This helps clarify the boundaries of quantum computing power and related complexity theories.
Open 2609.07945v1

Quantum circuits solve 2-fold Forrelation faster than classical AC0 circuits

2-Fold Forrelation is in QAC$^0$

Abstract: We show that 2-fold Forrelation with inverse-polylogarithmic promise gap can be solved, with bounded error, by polynomial-size QAC$^0$ circuits. Unlike the standard oracle-based Forrelation algorithm, our circuits receive the input explicitly, in the same form as the AC$^0$ circuits against which Forrelation is known to be hard. At constant gap, this yields a natural promise-problem separation between QAC$^0$ and AC$^0$.

Mon 7 SeptComputational Complexity
The gist
Some problems are very hard for simple classical computers to solve quickly. The authors show that a certain quantum problem called 2-fold Forrelation can be solved efficiently by very basic quantum circuits, even when the problem's input is given directly rather than as a mysterious oracle. This shows a clear difference in what quantum and classical circuits can efficiently do on this problem. Their result points to a natural way to separate simple quantum and classical computation models.
Open 2609.07060v1