Dilated Sliding Windows

• Dilated sliding windows are window constructs that enlarge the effective receptive field using skipped or strided positions, contrasting with contiguous dense windows.
• They are applied across disciplines—from vision transformers and streaming algorithms to dynamic 3D Gaussian Splatting—to enhance efficiency and adaptivity.
• Research suggests that unifying dilated sliding window methods requires rethinking summary objects and growth analysis beyond classical contiguous-window models.

Dilated sliding windows denote sliding-window constructions in which the effective support of a window is enlarged, sparsified, or multiscaled by mechanisms such as skipped positions, strided access, atrous indexing, or sparse maintenance schedules. Across the surveyed literature, however, the term is usually clarified by contrast: many systems explicitly use dense overlapping neighborhoods, standard contiguous suffix windows, or adaptive but still contiguous temporal partitions, and they state that they do not employ dilation in the usual sense (Li et al., 2021, Ganardi et al., 2017, Wang et al., 2019, Shaw et al., 2023). The topic is therefore best understood as a family of possible window semantics that remains unevenly developed across research areas: explicit in some vision-language distinctions, largely absent in automata-theoretic and streaming formulations, and only indirectly approximated by sparse checkpointing or adaptive partitioning strategies.

1. Scope and terminological boundaries

In the vision-transformer setting, dilation is associated with an explicit dilation rate, sparse or atrous indexing, skipped positions inside a window, or a larger effective receptive field obtained without enumerating all interior positions. In the streaming and automata literature, by contrast, a sliding window usually means a contiguous active suffix or a count-based recent-history window with ordinary expiration, and non-contiguous semantics are excluded explicitly (Li et al., 2021, Ganardi et al., 2017, Basat et al., 2018, Shaw et al., 2023).

The surveyed works fall into four distinct regimes.

Setting	Actual window semantics	Relation to dilation
Vision transformers	Dense overlapping local windows on token lattices	Usually contrasted against dilation
Automata and streaming theory	Fixed-size or variable-size contiguous windows	Dilation excluded
Geometric and heavy-hitter summaries	Exact dense windows with sparse maintained summaries	Analogy only
Dynamic 3D Gaussian Splatting	Adaptive contiguous temporal windows with minimal overlap	Not dilated

This distribution matters because the same phrase, “sliding window,” spans substantially different objects. In SimViT, the window is a local token neighborhood on a 2D lattice. In automata theory, it is the current active suffix of a stream. In sliding-window coreset and heavy-hitter systems, it is an exact recent segment whose maintenance is sparsified. In dynamic 3D Gaussian Splatting, it is a contiguous temporal segment used as a local canonical region. A plausible implication is that “dilated sliding windows” is not yet a single standardized operator across fields; it is a comparative descriptor whose meaning depends on the geometry of the underlying domain.

2. Dense local windows in vision transformers

SimViT provides the clearest explicit negative example: it uses ordinary overlapping sliding windows, not dilated windows, and the paper is specific that there is no dilation rate, no sparse sampling pattern, no skipped positions inside a window, no shifted-window schedule like Swin, and no mechanism that enlarges the effective receptive field by subsampling positions (Li et al., 2021).

Architecturally, SimViT is a four-stage hierarchical vision transformer. The first three stages use Multi-head Central Self-Attention (MCSA), while the last stage uses global MSA. Tokenization itself is non-overlapping: the first-stage patch embedding uses non-overlapping $4\times 4\times 3$ patches, and later stages use non-overlapping $2\times 2\times C_{i-1}$ patches. The sliding windows are introduced after tokenization on the 2D token map

$x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$

The number of windows is

$$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$

with the implementation choice

$p=1,\qquad s=1,\qquad k=3.$

Hence the local attention window is a dense $3\times 3$ window with stride $1$ and zero padding, and

$H_i' = H_i,\qquad W_i' = W_i.$

Within each window, SimViT does not compute all-pairs attention. Instead, only the central token issues the query, while surrounding tokens provide keys and values. If a window contains $M=k^2$ tokens, standard local self-attention would form an $M\times M$ attention matrix, whereas CSA forms a $2\times 2\times C_{i-1}$0 attention vector. With $2\times 2\times C_{i-1}$1, each local neighborhood has $2\times 2\times C_{i-1}$2 tokens, but only one output token is produced per window. This yields attention cost on the order of

$2\times 2\times C_{i-1}$3

rather than global

$2\times 2\times C_{i-1}$4

The receptive field expands through overlap, depth, and the final global stage, not through dilation.

The paper is equally explicit in its comparison with Swin. Swin uses non-overlapping windows plus shifted-window alternation for cross-window communication; SimViT uses overlapping stride-1 windows centered at every location, with no shift schedule. The ablation evidence reinforces this local dense interpretation: for SimViT-Micro, $2\times 2\times C_{i-1}$5 windows without positional embedding achieve $2\times 2\times C_{i-1}$6 top-1 accuracy, whereas $2\times 2\times C_{i-1}$7 windows without positional embedding achieve $2\times 2\times C_{i-1}$8, and adding positional embedding to $2\times 2\times C_{i-1}$9 yields $x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$0. The authors attribute the lack of need for positional embedding to the spatial structure already preserved by sliding windows and to improved translation invariance.

The main misconception surrounding SimViT is therefore straightforward: its receptive-field growth is sometimes informally read as “dilated,” but the paper’s own account rejects that reading. Its windows are dense, contiguous, overlapping, stride-1, and zero-padded; any enlarged support arises from repeated local aggregation and the final global stage rather than atrous indexing.

3. Contiguous-window formalisms in automata and streaming

In formal language theory, streaming algorithms, and query-processing data structures, sliding windows are overwhelmingly defined as contiguous suffixes. The automata-theoretic formulation distinguishes a fixed-size model, where the active window is $x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$1, and a variable-size model, where the active window $x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$2 evolves by right-appends and left-expiration. The paper explicitly excludes dilated windows, strided or sparsified windows, time-decayed windows, sampling-based windows, and non-contiguous semantics (Ganardi et al., 2017).

Within that standard model, the structure of complexity can be unusually sharp. For regular languages, optimal sliding-window space is always either constant, logarithmic, or linear in the window length. More precisely, for regular languages,

$x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$3

and only trivial languages $x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$4 have constant space in the variable-size model (Ganardi et al., 2017). The canonical summary of a window in the variable-size setting is captured by

$x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$5

with exact complexity

$x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$6

This is a theory of ordinary contiguous windows, but it also indicates what a dilated theory would need: an analogous summary for the sampled positions induced by the dilation pattern.

The same contiguous semantics dominate streaming heavy hitters. In the sliding-window $x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$7-heavy-hitter setting, the active window $x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$8 is the last $x_i \in \mathbb{R}^{H_i \times W_i \times C_i}.$9 items, and the first polylogarithmic-memory solution works by maintaining a smooth histogram for $$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$0 and a CountSketch per bucket rather than by redefining the window geometry (Braverman et al., 2010). The target property is non-smooth, but the window remains an ordinary suffix. Similarly, approximate query processing over sliding windows generalizes fixed-window summation to query-time-specified suffix sums

$$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$1

returning the sum of the last $$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$2 elements, again with contiguous windows only (Basat et al., 2018).

Offline exact computation follows the same pattern. The sliding-window transform is defined as

$$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$3

so every window is a contiguous length-$$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$4 substring (Beame et al., 2013). In that model, $$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$5 is substantially easier than frequency moments: element distinctness admits a polylog-overhead lifting from the single-window case, while for $$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$6 with $$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$7 or $$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$8, and even for $$H_i'=\left\lfloor\frac{H_i+2p-k}{s}\right\rfloor+1,\qquad W_i'=\left\lfloor\frac{W_i+2p-k}{s}\right\rfloor+1,$$9, any randomized branching program must satisfy

$p=1,\qquad s=1,\qquad k=3.$0

These results depend on exact one-step contiguous overlap identities and do not establish analogous claims for dilated windows.

4. Sparse maintenance as the nearest operational analogue

Several systems do not use dilated window contents, but they do sparsify the maintenance of dense windows. This is the closest operational analogue to dilation in the surveyed literature. “Summary-axis dilation” (Editor’s term) is a useful shorthand for this pattern: the semantic window remains dense and exact, while only a sparse set of summaries, checkpoints, or expensive updates is maintained.

For minimum enclosing balls over sliding windows, the window itself is standard and count-based: $p=1,\qquad s=1,\qquad k=3.$1 The paper does not define dilation, strided contents, or non-contiguous semantics. Instead, SWMEB and SWMEB+ maintain a sparse set of start indices for append-only AOMEB instances (Wang et al., 2019). SWMEB uses partition-local checkpoints created when the radius grows by a factor $p=1,\qquad s=1,\qquad k=3.$2. SWMEB+ keeps a global sequence

$p=1,\qquad s=1,\qquad k=3.$3

pruning indices when

$p=1,\qquad s=1,\qquad k=3.$4

This yields $p=1,\qquad s=1,\qquad k=3.$5, update time $p=1,\qquad s=1,\qquad k=3.$6, and stored points $p=1,\qquad s=1,\qquad k=3.$7, all independent of the window size $p=1,\qquad s=1,\qquad k=3.$8. The paper explicitly interprets this as standard sliding windows with sparse checkpoints, not as dilation of the window contents.

An analogous separation between exact recency and sparse expensive updates appears in heavy-hitter monitoring. Memento preserves the exact last-$p=1,\qquad s=1,\qquad k=3.$9-packets semantics, but on each arriving packet it performs a Full update only with probability $3\times 3$0; otherwise it executes only a Window update that advances and expires the window state (Basat et al., 2018). The paper’s central warning is that naive sample-then-window would create a random-sized active window and therefore distort sliding-window semantics. Memento avoids that failure by keeping recency exact and sparsifying only the costly insertions into the summary. The underlying representation is also coarse-grained: frames of size $3\times 3$1 are partitioned into $3\times 3$2 equal-sized blocks, and the algorithm stores overflow events plus a partial-block remainder.

In both cases, the dense window is not replaced by a non-contiguous one. The system instead replaces exhaustive maintenance by sparse representatives. A plausible implication is that much of the practical appeal of “dilated” designs in streaming may come not from skipping interior positions, but from sparsifying the set of maintained boundaries or expensive state transitions while keeping exact recency semantics intact.

5. Adaptive contiguous windows in dynamic 3D Gaussian Splatting

SWinGS uses sliding windows as a representation and training strategy for dynamic 3D Gaussian Splatting, but its windows are again contiguous rather than dilated (Shaw et al., 2023). The sequence is partitioned into multiple short temporal windows, each with its own dynamic 3DGS model, canonical Gaussian set, and deformation MLP. Window sizes are adaptive, determined by a greedy heuristic based on RAFT optical-flow magnitudes over adjacent frame pairs and averaged across views. High-motion periods receive shorter windows; low-motion periods receive longer windows.

Adjacent windows have exactly one overlapping frame, so the stride is window length minus one, and the method uses neither frame skipping inside a window nor sparse temporal sampling of interior frames. The paper is explicit on this point: it has adaptive size, but no hierarchical multi-scale windows, no dilated windows, no sparse temporal sampling inside the window, and no long-range sparse links across non-adjacent windows.

The architectural motivation is temporal locality rather than dilation. Within each window, a canonical Gaussian representation is shared, and a deformation MLP predicts

$3\times 3$3

The first $3\times 3$4K iterations optimize only the central frame with frozen MLP weights; each window model is trained for $3\times 3$5K iterations; temporal consistency is then enforced by $3\times 3$6K sequential fine-tuning iterations per window with fixed MLP weights. The one-frame overlap is minimal, and this makes boundary inconsistency a real issue. Table 3 reports that temporal consistency tuning changes metrics from PSNR $3\times 3$7, SSIM $3\times 3$8, LPIPS $3\times 3$9, VQA $1$0 without temporal consistency to PSNR $1$1, SSIM $1$2, LPIPS $1$3, VQA $1$4 with temporal consistency.

The closest connection to dilated windows is therefore indirect. SWinGS implements adaptive temporal support, not sparse interior sampling. A plausible implication is that, for dynamic-scene modeling, locality may be governed more effectively by motion-adaptive contiguous partitioning than by generic dilation. The method suggests that if dilation were introduced, it would need to be motion-aware and likely confined to low-motion windows.

6. Misconceptions, distinctions, and likely research directions

Several misconceptions recur across the literature. First, overlap is not dilation. SimViT expands receptive fields through overlapping $1$5 stride-1 windows and depth, but the paper explicitly denies any dilation rate or sparse within-window sampling (Li et al., 2021). Second, adaptive window size is not equivalent to a dilated window. SWinGS changes temporal support length according to optical-flow magnitude, yet every window remains a contiguous frame block (Shaw et al., 2023). Third, sparse checkpoints are not sparse window contents. SWMEB+, SWMEB, and Memento all preserve the semantics of a dense recent-history window while sparsifying stored start positions or costly updates (Wang et al., 2019, Basat et al., 2018).

The clearest open direction emerges in the automata-theoretic setting. The formal identity

$1$6

shows that contiguous-window complexity is governed by the growth of a derived summary language. The same paper states directly that for dilated windows one would likely need “an analogous summary over the sampled positions induced by the dilation pattern,” and that the constant/logarithmic/linear trichotomy may fail or change because the derived summary language may no longer be regular (Ganardi et al., 2017). This suggests that a genuine theory of dilated sliding windows would require reworking both the summary object and the growth analysis, not merely transplanting contiguous-window results.

A second direction is systems-oriented rather than formal. Memento already separates exact window advancement from selective expensive state updates, and the paper proposes a natural adaptation in which older regions of the window receive more aggressive sparsification while recent regions remain dense (Basat et al., 2018). SWMEB+ suggests another route: keep summaries only at geometrically or radius-adaptively spaced left boundaries rather than for every possible start position (Wang et al., 2019). SWinGS suggests a third: combine local canonical windows with motion-dependent sparse supervision inside low-motion windows (Shaw et al., 2023). These are not established results for dilated windows, but they outline concrete design patterns for future work.

The present state of the literature is therefore asymmetrical. In formal streaming and automata models, “sliding window” almost always means a contiguous active suffix. In vision transformers, dilation is a well-understood contrast class, and the absence of dilation can be specified precisely. In approximate geometric summaries and heavy-hitter systems, the most productive analogy to dilation is sparse maintenance of exact windows rather than non-contiguous window semantics. Dilated sliding windows, as a unified technical object, remain more a research direction than a stabilized cross-domain methodology.