Low Sets and Closure Properties of Counting Function Classes

A language L is low for a relativizable complexity class C, if C$^L$ = C. For the classes #P, GapP, and SpanP the exact low classes of languages are known: Low(#P) = UP $\cap$ coUP, Low(GapP) = SPP, and Low(SpanP) = NP $\cap$ coNP. In this paper, we prove that Low(TotP) = P, and give characterizations of low function classes for #P, GapP, TotP, and SpanP. In particular, we prove that Low$_f$(#P) = UPSV$_t$ and Low$_f$(SpanP) = NPSV$t$. We establish the inclusion relations between NPSV$t$, UPSV$t$, and the counting function classes by giving for each of these inclusions an equivalent inclusion between language classes. We also prove that SpanP $\subseteq$ GapP if and only if NP $\subseteq$ SPP, and the inclusion GapP$+$ $\subseteq$ SpanP implies PH = $Σ{2}^{P}$. For the class #P we prove that its closure under left composition with FP$+$ is equivalent to #P = UPSV$_t$, and for SpanP this closure is equivalent to SpanP = NPSV$t$. For the classes #P, GapP, TotP, and SpanP we summarize the known results and show that each of these classes is closed under left composition with FP$+$ if and only if it collapses to its low class of functions. We also prove that a NPTM with a #P oracle can always make at most one query to the oracle without changing the number of accepting paths.

💡 Research Summary

This paper presents a comprehensive analysis of “lowness” and closure properties for major counting complexity classes, namely #P, GapP, TotP, and SpanP.

The core concept explored is that a language L is “low” for a relativizable class C if using L as an oracle does not increase C’s power, i.e., C^L = C. While previous work established Low(#P) = UP ∩ coUP, Low(GapP) = SPP, and Low(SpanP) = NP ∩ coNP, this paper proves the new result that Low(TotP) = P.

The authors then introduce and characterize the novel notion of “low function classes” (Low_f), where a function g is low for C if C^g = C. Key findings include Low_f(#P) = UPSV_t and Low_f(SpanP) = NPSV_t. Here, UPSV_t and NPSV_t are classes of total functions computed by nondeterministic Turing machines with, respectively, exactly one accepting path (outputting the function value on that path) and at least one accepting path where all accepting paths output the same function value.

A significant portion of the paper investigates inclusion relationships between these function classes (NPSV_t, UPSV_t, #P, GapP_+, TotP, SpanP). It establishes that such inclusions are often equivalent to well-known inclusions between language classes. For example, UPSV_t ⊆ TotP if and only if P = UP ∩ coUP, and NPSV_t ⊆ #P if and only if UP ∩ coUP = NP ∩ coNP. Furthermore, it is shown that SpanP ⊆ GapP is equivalent to NP ⊆ SPP, and that the inclusion GapP_+ ⊆ SpanP would imply a collapse of the Polynomial Hierarchy to its second level (PH = Σ_2^P).

The paper also deeply analyzes closure under left composition with FP_+ (the class of nonnegative polynomial-time computable functions). It demonstrates that for each counting class, being closed under such composition is equivalent to the class collapsing to its corresponding low function class. Specifically:

• FP_+ ◦ #P ⊆ #P ⇔ #P = UPSV_t ⇔ PP = UP.
• FP_+ ◦ SpanP ⊆ SpanP ⇔ SpanP = NPSV_t ⇔ PP = NP. Analogous equivalences are summarized for GapP (related to PP = SPP) and TotP (related to PP = P). This creates a unifying perspective linking an algebraic property (closure), structural properties (low classes), and major complexity class collapses.

Finally, the paper includes important technical lemmas. One shows that composing with multiple counting functions is no more powerful than composing with a single one (e.g., FP ◦ (#P × … × #P) = FP ◦ #P). Another, more surprising result proves that a nondeterministic Turing machine with a #P oracle can always be modified to make at most one query to the oracle while preserving the exact number of accepting paths, i.e., #P^#P = #P^{#P