Author-Disjoint Splits in NP-Complete Sets

• Author-disjoint splits are a method to partition an NP-complete set into two disjoint NP languages that remain in NP\P and are not NP-hard.
• They employ coordinated team and delayed diagonalization to ensure each subset evades universal NP-hardness under polynomial-time Turing reductions.
• This approach refines our understanding of NP structure by revealing that even complete problems can be decomposed into strictly easier, non-NP-hard components.

An author-disjoint split is a construct, under the assumption P ≠ NP, that partitions any NP-complete language $S \subseteq \{0,1\}^*$ into two disjoint NP languages $A$ and $B$ such that both $A, B \in \mathrm{NP} \setminus \mathrm{P}$, $A \cap B = \emptyset$, $A \cup B = S$, and neither $A$ nor $B$ is NP-hard, even under polynomial-time Turing reductions. This result establishes that NP-completeness, while robust at the level of the full set, can be destroyed completely by dividing the set into carefully constructed, individually "easier" pieces. The construction uses coordinated (team) delayed diagonalization, extending Ladner's classical approach for building intermediate NP problems.

1. Foundational Theorem and Definitions

Let $S$ be any fixed NP-complete set under polynomial-time many-one reductions. The main theorem states:

If P ≠ NP, there exists a polynomial-time computable function $r: \mathbb{N} \rightarrow \mathbb{N}$ such that:

• $A = \{ x \in S \mid r(|x|) \text{ is even} \}$,
• $B = \{ x \in S \mid r(|x|) \text{ is odd} \}$,

satisfy:

1. $A, B \in \mathrm{NP} \setminus \mathrm{P}$,
2. $A \cap B = \emptyset$, $A \cup B = S$,
3. Neither $A$ nor $B$ is NP-hard (even under Turing reductions).

Key definitions:

• NP-complete: $L$ is NP-complete if $L \in \mathrm{NP}$ and every $A \in \mathrm{NP}$ is polynomial-time many-one reducible to $L$.
• Delayed diagonalization: Building an $L \in \mathrm{NP}$ by diagonalizing against an enumeration of polynomial-time machines at selective input lengths, ensuring $L \notin \mathrm{P}$ but $L \in \mathrm{NP}$.
• Team (tag-team) diagonalization: Multiple NP sets (typically $A$ and $B$) coordinate their diagonalizations so that each candidate polynomial-time oracle machine fails on at least one set.

2. Team Diagonalization Construction

The approach begins by fixing a standard enumeration $M_1, M_2, \ldots$ of deterministic polynomial-time Turing machines with an oracle interface. A universal clocked machine $U$ simulates $M_j^X(x)$ in $O(|x|^c + j)$ time.

A nondecreasing function $r: \mathbb{N} \to \mathbb{N}$, computable in polynomial time, orchestrates the diagonalization across $A$ and $B$, effectively designating at each input length which set performs a diagonalization attempt against $M_{\lfloor r(i)/2 \rfloor}$. At each stage $i$, if $r(i)$ is even, $B$ is active; if odd, $A$ is active.

The recurrence for $r$:

• If $$2 \cdot (\log\log i) \cdot (\lfloor r(i)/2 \rfloor + 1) > i$$, then $r(i+1) := r(i)$; diagonalization is delayed.
• Otherwise, check if $M_j$ ($j=\lfloor r(i)/2\rfloor$) can be diagonalized against the currently active set via finding $y$ ($|y| \le \log\log i$) where $M_j^A(y) \neq \text{SAT}(y)$ or $M_j^B(y) \neq \text{SAT}(y)$ accordingly.
  • If such $y$ exists, $r(i+1) := r(i) + 1$; else, $r(i+1) := r(i)$.

Defining $A$ and $B$ using $r$ yields: $A = \{ x \in S \mid r(|x|) \text{ is even} \}$, $B = \{ x \in S \mid r(|x|) \text{ is odd} \}$.

3. Properties and Proof Outline

Membership in NP: $A$ and $B$ are in NP, as $r(n)$ is computable in polynomial time and $S \in \mathrm{NP}$.

Disjointness and Coverage: $A \cap B = \emptyset$ and $A \cup B = S$ are immediate from their definitions based on the parity of $r(|x|)$.

Neither in P: If $A \in \mathrm{P}$ (or $B$), then via $S = A \cup B$, $SAT \leq_T^p A$, contradicting the diagonalization that ensures some oracle machine fails for every instance.

Neither NP-hard: The construction ensures that every deterministic polynomial-time oracle machine with access to $A$ (or $B$) will, by scheduling through $r$, eventually be diagonalized against, making it impossible for any such oracle to decide all NP problems.

Eventual Diagonalization: The incrementing and non-decreasing nature of $r$ guarantee that each $M_j$ receives attention infinitely often, as otherwise $r(i)$ would become constant, resulting in a contradiction with P ≠ NP.

4. Generalizations and Extensions

The method generalizes to $k \geq 2$ disjoint NP$\setminus$P subsets: by letting $r(n)$ range mod $k$, $S$ splits into $k$ disjoint, strictly easier subsets, each in NP$\setminus$P and none NP-hard.

Furthermore, the construction holds analogously in other complexity classes (e.g., PSPACE, EXP, EEXP), provided an appropriate enumeration and diagonalization process exists. This indicates the robustness of the splitting phenomenon beyond NP.

A related functional consequence is that, as a corollary, one can split SAT into two non-NP-Turing-hard functions $f$ and $g$ in OptP, such that $g \circ f$ is NP-hard, yet neither function alone is NP-hard ("Team Diagonalization" Theorem 5.1, (Hemaspaandra et al., 2018)). This demonstrates that composition can recover NP-hardness from non-NP-hard components.

5. Significance in Structural Complexity

Author-disjoint splits highlight the fine-grained structure of NP-complete sets: even though $S$ is NP-complete, and thus “as hard as any problem in NP,” the set can be decomposed into disjoint NP languages that are individually strictly less than NP-complete in hardness. This result, building on Ladner’s splitting theorem and refined by Hemaspaandra & Spakowski, refutes any intuition that every large fragment of an NP-complete language must retain NP-hardness, or that the union of “easy” NP sets cannot be hard.

Further, the result applies to any NP-complete language, not just canonical cases like SAT. The essential role of team diagonalization is to ensure coordinated, mutually aware diagonalization, so that completeness is fully avoided in both pieces while covering all possible polynomial-time reductions.

6. Implications and Variants

The principal implication is that, under P ≠ NP, NP-complete sets possess internal structure allowing them to be split, via computable parity-based criteria, into arbitrarily many disjoint NP$\setminus$P subsets, each of minimal hardness.

In extended settings, this phenomenon recurs for higher complexity classes and for functional analogs involving OptP and composition. A plausible implication is an increased granularity in understanding the boundaries between hard and intermediate problems, supporting the exploration of nontrivial subclasses within NP and beyond.

7. Summary Table: Author-Disjoint Split Properties

Property	Set $A$	Set $B$
Membership	$A \in \mathrm{NP} \setminus \mathrm{P}$	$B \in \mathrm{NP} \setminus \mathrm{P}$
Disjointness	$A \cap B = \emptyset$	$A \cap B = \emptyset$
Union	$A \cup B = S$	$A \cup B = S$
NP-hardness	Not NP-hard (even under Turing reductions)	Not NP-hard (even under Turing reductions)

This construction, via coordinated delayed diagonalization, conclusively demonstrates that, assuming P ≠ NP, every NP-complete language is partitionable into strictly easier NP sets, each evading NP-completeness and revealing unexpected internal structure in the landscape of computational hardness (Hemaspaandra et al., 2018).