Random Window Discriminators

• Random window discriminators are sliding-window branching programs (SWBPs) that use only the last t input bits to determine state transitions, ensuring memory-constrained computation.
• They support the construction of pseudorandom generators with near-optimal seed lengths by employing extractor-based and combinatorial rectangle techniques to balance seed length and error.
• Their design enables deterministic simulations of probabilistic models, such as cellular automata, thus advancing derandomization strategies in low-space algorithm design.

A random window discriminator, also known as a sliding-window branching program (SWBP), is a class of read-once branching program whose current state depends only on the last $t$ input bits seen, for a fixed window size $t$. The SWBP formalism provides a structure for modeling sliding-window algorithms operating under space constraints, particularly when analyzing the construction and derandomization of low-space randomized algorithms. Pseudorandom generators (PRGs) for SWBPs offer near-optimal seed lengths and error resilience, enabling efficient deterministic simulations of probabilistic models such as sublinear-time cellular automata. These results connect the structural properties of SWBPs, PRG construction techniques, and applications to derandomization in computational complexity (Modanese, 2023).

1. Formal Definition and Structural Properties

A sliding-window branching program $S$ of window size $t$, length $n$, and width $w$ is a read-once (unanimity) branching program where, at each layer $i$ $(1 \leq i \leq n)$, the transition function

$S_i : Q \times \{0,1\} \rightarrow Q$

depends only on the last $t$ inputs. More precisely, for $i \geq t$ and any states $q, q' \in Q$ and input history $y \in \{0,1\}^t$,

$S_i(q, y) = S_i(q', y),$

meaning any two runs reading the identical length-$t$ suffix will synchronize in their next transition regardless of the prior state.

Acceptance in an SWBP is defined by unanimity: the SWBP accepts an input if and only if every state visited (across all $n$ steps) is marked accepting.

Structurally, an SWBP can be characterized via de Bruijn graphs of order $t$. After layer $t$, the state progression is determined only by the last $t$ bits, and the number of possible states $w$ is at most $2^t$ (excluding dead states). The state at layer $i$ is a function

$\alpha_i(x_{i-t+1} \ldots x_i)$

for $i \geq t$ and $\alpha_i(x_1 \ldots x_i)$ for $i < t$ [(Modanese, 2023), Theorem 2.1].

2. Pseudorandom Generators for SWBPs: Construction and Analysis

Given a base PRG $$G_\mathrm{base} : \{0,1\}^{d_\mathrm{base}} \to \{0,1\}^t$$ that $\varepsilon_\mathrm{base}$-fools width-$w$, length-$t$ unanimity programs, the objective is to stretch this output to length $n \gg t$, preserving pseudorandomness against all width-$w$, length-$n$, window-$t$ SWBPs.

Construction $G_1$ (INW-style with extractor):

• Seed Length:

$$d_1 = 2 d_\mathrm{base} + O(\log(n/t) \log(1/\varepsilon_\mathrm{base}))$$

• Error:

$$\varepsilon_1 = \varepsilon_\mathrm{base} \cdot (n/t)^{O(1)}$$

• Technique: Shatters the SWBP computation into $m = n/t$ blocks of length $t$, separated by dedicated blocks, and uses an extractor (Goldreich–Wigderson) to re-seed the base PRG, allowing simultaneous fooling of $2m$ subprograms. Interleaved construction ensures global sliding-window property.

Construction $G_2$ (Combinatorial-rectangle PRG):

• Seed Length:

$$d_2 = O(d_\mathrm{base} + \log(n/t) + (\log(1/\varepsilon_\mathrm{base}))^{3/2})$$

• Error:

$\varepsilon_2 = O(\varepsilon_\mathrm{base} n/t)$

• Technique: Concatenates $r = n/t$ independent outputs of the base PRG, using a combinatorial-rectangle PRG (e.g., Lu–Potukuchi or Gopalan–Yehudayoff) to reduce the cumulative seed length while controlling the error blowup.

A further optimized variant of $G_2$ using the Gopalan–Yehudayoff rectangle-PRG achieves

$$d'_2 = O\left((d_\mathrm{base} + \log\log(n/t) + \log(1/\varepsilon_\mathrm{base})) \log(d_\mathrm{base} + \log(1/\varepsilon_\mathrm{base}))\right)$$

with $\varepsilon_2 = O(\varepsilon_\mathrm{base} n/t)$.

The table below summarizes the key differences between $G_1$ and $G_2$:

Generator	Seed Length	Error
$G_1$ (INW + extractor)	$$2 d_\mathrm{base} + O(\log(n/t) \log(1/\varepsilon_\mathrm{base}))$$	$\varepsilon_\mathrm{base} (n/t)^{O(1)}$
$G_2$ (Rectangle-PRG)	$$O(d_\mathrm{base} + \log(n/t) + (\log(1/\varepsilon_\mathrm{base}))^{3/2})$$	$O(\varepsilon_\mathrm{base} n/t)$

3. SWBP Derandomization Techniques

The construction of PRGs for SWBPs leverages two techniques:

• Interleaving plus Extractor: Block-splits the program, enables low entropy loss via extractor-based re-seeding, and utilizes interleaving to match the sliding-window dependency.
• Combinatorial Rectangle PRGs: Allows for compact multi-seeding of the base PRG across program blocks, employing combinatorial-rectangle generators to minimize seed length while maintaining error control.

A key lemma supporting the extractor-based approach states that, given a PRG that $m$-simultaneously $\varepsilon$-fools $t$-block subprograms, extension to $2m$ via extractor-split seeds can $3\varepsilon$-fool $2m$ blocks with marginal additional seed overhead.

Rectangle-PRG techniques asymptotically optimize the seed at the expense of a linear blowup in error by the number of subprograms, which is later controlled by parameter selection.

4. Applications to Probabilistic Cellular Automata

A probabilistic cellular automaton (PACA) is a one-dimensional automaton on $n$ cells, each updated stochastically at each timestep using two local rules $\delta_0, \delta_1$. Each cell, per step, selects a rule based on a fair coin and applies it to its 3-neighborhood. The system accepts if, within $T$ steps, all cells reach an accepting state.

Any $T$-step PACA can be simulated by a randomized sliding-window algorithm of window size $O(T^2)$ and space $O(T \log|Q|)$, where $|Q|$ is the cell alphabet size. This simulation, composed with an SWBP PRG, yields deterministic deciders for the PACA's accepted language.

• One-sided error PACA (analogous to $\mathsf{RP}$): Any such process of runtime $T(n) \geq (\log n)^{1.01}$ is deterministically decidable in space $O(T)$.
• Two-sided error PACA (analogous to $\mathsf{BPP}$): For any $T$, deterministic decision is possible in space $\widetilde{O}(T) + O(\log n)$. This improves prior bounds for $T \ll \sqrt{\log n}$ relative to Armoni-PRG approaches.

Both results are achieved by exhaustive enumeration of PRG seeds, with total simulation space proportional to the requisite seed length.

5. Trade-offs and Implications

The two PRG constructions for SWBPs present trade-offs:

• $G_1$ yields superior dependence on $\log(1/\varepsilon)$ in the seed length but incurs worse dependence in $\log(n/t)$.
• $G_2$ achieves better scaling in $\log(n/t)$ but linearly inflates the error by $n/t$.

Seed lengths are nearly optimal in $\log w$, $\log (1/\varepsilon)$, and $\log t$, outperforming general branching-program PRGs when $t \ll n$.

A plausible implication is that, for randomized low-space algorithms with strong sliding-window locality, these PRG constructions provide more efficient deterministic simulation strategies than previously possible for general branching programs. This suggests sliding-window constraints can be exploited to surpass traditional derandomization resource bounds for suitable computational classes (Modanese, 2023).

6. Connections to Broader Complexity Theory

Random window discriminators (SWBPs) embody structured memory-limited computation analogous to a class of sliding-window algorithms, allowing direct mapping to models such as probabilistic cellular automata. The overlay of PRGs with optimal seed complexity for SWBPs enables sublinear-space deterministic computation for problems previously tractable only via randomness under tight space budgets.

The explicit connection to de Bruijn graphs highlights the fundamental role of local-historical dependency in state-space growth and influences the analysis of algorithmic complexity within the sliding-window model.

The SWBP framework, as developed by Modanese, expands the toolbox for derandomization in streaming and automata contexts, with consequences for understanding the boundaries between probabilistic and deterministic small-space computation (Modanese, 2023).