Block-Based Smart Aggregation (BBSA)

• Block-Based Smart Aggregation (BBSA) is a family of block-centric strategies that aggregate structured groups of variables to enhance inference, privacy, and robustness.
• Its implementations span CNN explanation via block-wise feature fusion, block sparse Bayesian learning for signal recovery, and symbol-aware multigrid for structured Toeplitz systems.
• BBSA techniques improve computational efficiency and fault tolerance, offering practical solutions for scalable data aggregation in high-dimensional and privacy-sensitive applications.

Block-Based Smart Aggregation (BBSA) denotes a family of block-centric aggregation strategies in which the operative unit is not an individual coefficient, pixel, coordinate, or participant, but a block: a structured group of variables, features, unknowns, or agents. In the available arXiv literature, the term maps most directly to the block-wise feature aggregation stage of SISE for CNN explanation, but closely related BBSA-style mechanisms also appear in block sparse Bayesian recovery, symbol-based multigrid for block Toeplitz systems, secure aggregation of block-sparse vectors, and fault-tolerant smart-meter aggregation (Sattarzadeh et al., 2020, Liu et al., 2012, Bolten et al., 2024, Asi et al., 14 Mar 2025, Eibl et al., 2021).

1. Scope and defining pattern

The literature suggests that BBSA is not a single canonical algorithm. Rather, it is an umbrella characterization for methods that aggregate information at block granularity and then use that aggregated structure to improve inference, coarsening, privacy, or robustness. In some settings the blocks are contiguous coordinates; in others they are convolutional blocks, groups of unknowns induced by a matrix symbol, or dynamically surviving participants in a communication graph (Sattarzadeh et al., 2020, Liu et al., 2012, Bolten et al., 2024, Asi et al., 14 Mar 2025, Eibl et al., 2021).

Setting	Block unit	Aggregation mechanism
CNN explanation	convolutional blocks	cascaded fusion of layer-wise visualization maps
Sparse recovery	coefficient blocks $\mathbf{x}_i$	block-by-block marginal-likelihood optimization
Multigrid	block unknowns	grid transfer $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$
Secure aggregation	contiguous vector blocks	hidden sampling and aggregation of $k$ blocks
Smart metering	surviving participant set	forward-only activation over $L_{rem}$ and $L_{act}$

A recurrent source of confusion is terminological. The CNN explanation paper explicitly aligns BBSA with “block-wise feature aggregation / fusion module.” The sparse recovery and multigrid papers are described as “BBSA-style” only in a broad sense, because their aggregation is implemented through Bayesian marginal likelihood or symbol-aware coarsening rather than through a dedicated heuristic named BBSA. The smart-meter paper is not BBSA by name, but it is presented as a precursor or generalization because it organizes aggregation over a structured surviving set rather than over fixed scalar interactions. This suggests that the common denominator is block-level decision making informed by structure rather than a single shared formalism.

2. Probabilistic block aggregation in sparse recovery

In sparse signal recovery, BBSA-like structure appears in the Block Sparse Bayesian Learning framework and, specifically, in the fast marginalized solver BSBL-FM. The signal is partitioned into blocks,

$$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$

where block $i$ has size $d_i$, only a few blocks are nonzero, and the measurements are

$\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$

with Gaussian noise $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$. The model exploits both block sparsity and intra-block correlation by assigning each block a Gaussian prior

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$0

where $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$1 is a block relevance parameter and $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$2 captures intra-block correlation (Liu et al., 2012).

The associated Type-II maximum-likelihood objective is

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$3

The posterior is Gaussian with

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$4

This gives a block-aware Bayesian aggregation mechanism: evidence is accumulated at the block level through $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$5, while correlation is learned through $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$6.

The fast marginalized algorithm decomposes the covariance as

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$7

defines

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$8

and separates the cost into a blockwise term

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$9

This permits block-by-block optimization. Setting the derivative with respect to $k$0 to zero yields

$k$1

followed by

$k$2

with $k$3.

The main practical instantiations are BSBL-FM(0), BSBL-FM(1), and BSBL-FM(2). BSBL-FM(0) uses the SIM model $k$4; BSBL-FM(1) uses an AR(1) model

$k$5

and BSBL-FM(2) shares the AR coefficient across blocks. Greedy selection updates only the block giving the deepest descent in

$k$6

and stops when the change in cost is below $k$7 in the experiments.

The empirical picture is specific. BSBL-FM and BSBL-BO show strong exact recovery performance in noiseless phase-transition experiments; BSBL-FM outperforms non-BSBL block methods such as Model-CoSaMP and Block-OMP; in noisy recovery with increasing $k$8, BSBL-FM has slightly worse NMSE than BSBL-BO and BSBL-$k$9, but is much faster; BSBL-FM(1) and BSBL-FM(2) outperform BSBL-FM(0), showing the benefit of modeling intra-block correlation; and in FECG telemonitoring, BSBL-FM reconstructs recordings with good enough fidelity for downstream ICA to recover clean fetal ECG and is substantially faster than BSBL-BO. The paper further notes that exploiting correlation can even make the recovered signal outperform an oracle that only knows the support but ignores correlation. In BBSA terms, the defining move is aggregation of evidence over blocks together with learned within-block covariance, rather than entrywise sparsity alone.

3. Symbol-aware aggregation for block Toeplitz multigrid

In multigrid for block Toeplitz linear systems, BBSA takes the form of aggregation-based grid transfer operators derived from the matrix-valued symbol. The problem is to solve

$L_{rem}$0

where $L_{rem}$1 is positive definite and, in the structured setting, is a block Toeplitz or block circulant matrix generated by a matrix-valued function

$L_{rem}$2

The block Toeplitz family is written

$L_{rem}$3

with Fourier coefficients

$L_{rem}$4

The block structure arises from discretizations such as $L_{rem}$5 Lagrangian FEM stiffness matrices and B-spline discretizations with non-maximal regularity (Bolten et al., 2024).

The central aggregation device is the prolongation/restriction

$L_{rem}$6

where $L_{rem}$7 is the normalized eigenvector corresponding to the unique vanishing eigenvalue of the symbol at the singular point $L_{rem}$8. Each block of $L_{rem}$9 unknowns is therefore aggregated into one coarse unknown by projection onto the troublesome eigenvector. With the Galerkin coarse operator

$L_{act}$0

the circulant case satisfies

$L_{act}$1

where the coarse symbol becomes scalar:

$L_{act}$2

A decisive theoretical result is that if the vanishing eigenvalue of $L_{act}$3 has a zero of order $L_{act}$4 at $L_{act}$5, then $L_{act}$6 vanishes at $L_{act}$7 with the same order $L_{act}$8, and nowhere else. This preserves the essential singular behavior while collapsing a matrix-valued symbol to a scalar-valued one. The coarse problem can then be treated with scalar Toeplitz multigrid theory.

The paper’s convergence analysis uses the standard Ruge–Stüben-type TGM theorem: pre-smoothing, post-smoothing, and approximation properties imply an $L_{act}$9-norm contraction bound for the TGM iteration matrix. In the block Toeplitz setting, the approximation property is proved for the aggregation operator $$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$0, and V-cycle convergence follows by combining finest-level block analysis with standard scalar Toeplitz transfers on coarser levels. The multilevel strategy is hybrid: level $$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$1 uses aggregation to obtain a scalar coarse system, while levels $$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$2 use standard scalar grid transfer operators.

The smoother analysis focuses on relaxed block Jacobi,

$$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$3

with $$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$4 the block diagonal of $$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$5. In the circulant setting,

$$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$6

A sufficient condition for smoothing is

$$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$7

For symbols of degree $$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$8 with rank-$$\mathbf{x} = [\mathbf{x}_1^T,\mathbf{x}_2^T,\ldots,\mathbf{x}_g^T]^T,$$9 off-diagonal Fourier coefficients, the paper gives an explicit eigenvalue formula and thus an explicit norm, allowing $i$0 to be computed from the symbol at negligible cost.

The numerical experiments report number of multigrid iterations, CPU time, setup time, and preconditioned CG iterations. The reported trends are that block Jacobi is substantially better than scalar Jacobi for larger block sizes, the aggregation-based method yields iteration counts essentially independent of the matrix size, the coarse symbol is simple enough that standard scalar multigrid can be used on coarser levels, and the aggregation-based approach has lower setup cost and is preferable as a preconditioner. In BBSA terms, the notable feature is not merely coarsening by groups, but symbol-aware aggregation that preserves the critical singular structure of the original block operator.

4. Block-wise feature aggregation in CNN explanation

The most direct use of BBSA appears in explainable AI, where it corresponds to the block-wise feature aggregation stage inside SISE (“Semantic Input Sampling for Explanation”). The motivating observation is that CAM-based methods typically use only the last convolutional layer, which is semantically strong but spatially coarse, whereas randomized perturbation methods such as RISE use random masks, which can be unstable and expensive. SISE addresses this by collecting visualization maps from multiple layers, selecting the last layer of each convolutional block, generating attribution-based input sampling masks, and aggregating the resulting visualization maps block by block (Sattarzadeh et al., 2020).

The layer-selection rule is explicit: the most useful and minimal set of layers to probe is the last layer of each convolutional block. The rationale given is that layers within a block generally preserve the same tensor dimensions, pooling or downsampling marks a semantic transition, and the last layer before that transition is the most representative. For a plain CNN block with layers $i$1, the block output is written as

$i$2

For residual-style networks, the paper uses an unraveled view

$i$3

Feature maps are scored by gradient attribution. For layer $i$4 with feature maps $i$5, the average gradient score is

$i$6

Only positive-gradient maps above threshold are retained:

$i$7

where

$i$8

and $i$9 defaults to $d_i$0. The operator $d_i$1 performs bilinear interpolation to input size and linear normalization to $d_i$2.

The explanation mechanism generalizes RISE from random binary masks to smooth attribution-based masks. With contribution term

$d_i$3

the layer-wise visualization map for each selected block layer $d_i$4 is

$d_i$5

The final BBSA fusion module is cascaded. Each fusion block adds two consecutive visualization maps and then masks that sum using a binary mask derived from the later visualization map by adaptive thresholding with Otsu’s method. The deeper map provides semantic certainty; the shallower map contributes spatial detail; the thresholded deeper map suppresses irrelevant regions.

The paper emphasizes that the final explanation map is not produced by one layer alone but by selecting the last layer of each block, computing a visualization map for each selected layer, and aggregating those maps block by block. This is the sense in which BBSA is the final fusion stage of SISE. The last convolutional block remains the most critical, but intermediate blocks improve resolution and completeness.

Empirically, the evaluation covers PASCAL VOC 2007, MS COCO 2014, and the Severstal defect dataset, using VGG16, ResNet-50, and ResNet-101. Ground-truth-based metrics are EBPG, mIoU, and Bbox; model-truth-based metrics are Drop% and Increase%. The reported qualitative outcomes are sharper object outlines, better handling of multiple objects, better class discrimination, less background clutter, and better localization for small objects. The quantitative trends are that SISE generally matches or outperforms prior methods on most metrics, especially on EBPG, mIoU, and Bbox, and is competitive or better on Drop% and Increase% depending on model. The paper also reports a mask-efficiency comparison: RISE uses around 8000 random masks, whereas SISE/BBSA uses about 1900 attribution masks on ResNet-50 after removing non-positive-gradient feature maps. SISE is significantly faster than RISE, much faster than Extremal Perturbation, and slower than one-pass gradient methods such as Grad-CAM, with the claimed benefit of better resolution and faithfulness. Within the current literature, this is the clearest instantiation of BBSA as a named block-wise aggregation mechanism.

5. Private and efficient aggregation of block-sparse vectors

In secure aggregation, BBSA appears as block-based sparse aggregation under cryptographic hiding of the support pattern. PREAMBLE is a two-server secure aggregation protocol, in the Prio model, tailored to high-dimensional vectors whose non-zero entries occur in a small number of blocks of consecutive coordinates. With block size $d_i$6 and number of blocks

$d_i$7

a vector is $d_i$8-block-sparse if at most $d_i$9 of these blocks are non-zero. The protocol is designed for the regime where $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$0 is very large, but the update is structured into a small number of active blocks (Asi et al., 14 Mar 2025).

The BBSA-style idea is explicit: clients randomly choose a small subset of blocks, rescale those blocks so that the resulting sparse vector is an unbiased estimator of the original dense vector, hide which blocks were sampled from each server, and aggregate only the sampled blocks. In the partitioned-subsampling version,

$\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$1

The informal protocol is: choose a set $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$2 of $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$3 block indices, form the sparse vector $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$4, use PREAMBLE to secret-share $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$5 to the two servers, let the servers reconstruct the sum of these sparse vectors, and then add Gaussian noise.

PREAMBLE extends distributed point functions to $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$6-block-sparse functions. The construction uses two PRGs,

$\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$7

and the core theorem states that the resulting $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$8 scheme is a $\mathbf{y} = \mathbf{\Phi}\mathbf{x} + \mathbf{n},$9-block-sparse DPF with correctness error $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$0 and key size

$\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$1

In $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$2 the number of invocations of $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$3 is at most $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$4, and of $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$5 at most $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$6; in $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$7 the number of invocations of $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$8 is at most $\mathbf{n}\sim\mathcal{N}(0,\beta^{-1}\mathbf{I})$9, and $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$00 is invoked once; full-vector evaluation requires $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$01 invocations of both $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$02 and $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$03 and $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$04 additional operations.

A major computational point is that PREAMBLE treats a whole block as the payload unit. Relative to repeated point-function secret sharing, index information is amortized over $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$05 entries. The paper compares Prio, Repeated DPFs, Blocked DPFs, and PREAMBLE, reporting $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$06 communication and computation for Prio, the same asymptotic communication as Blocked DPFs for PREAMBLE, and server compute reduced from $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$07 to $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$08 through cuckoo hashing. With two hash functions, the stated failure probability is $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$09.

The privacy and utility analysis links BBSA-style hidden block sampling to differential privacy. The utility theorem states that if each block has $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$10-norm at most $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$11, then for the noisy aggregate $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$12,

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$13

For partitioned subsampling, the asymptotic privacy theorem gives conditions under which the mechanism is $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$14-DP with

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$15

When $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$16, this asymptotically matches the Gaussian mechanism:

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$17

The paper’s concrete example states that, for a 64-bit field and an 8-million-dimensional gradient, PREAMBLE reduces communication from $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$18MB to about $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$19MB while increasing the noise standard deviation by only about $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$20 for $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$21-DP when aggregating $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$22 vectors. The significance, in BBSA terms, is that aggregation is moved from coordinate level to hidden block level, enabling privacy amplification by sampling while sharply reducing communication.

6. Fault-tolerant smart-meter aggregation as precursor and boundary case

In smart-meter aggregation, the relevant construction is AggFT, a lightweight and fault-tolerant protocol for privacy-preserving aggregation with proven termination. Although the paper does not use the term BBSA, it is described as a precursor or generalization of block-based smart aggregation because it reorganizes participants into a dynamically determined ordered structure derived from a graph of working links, allowing aggregation to proceed despite faults while preserving privacy (Eibl et al., 2021).

The setting is a Data Concentrator (DC) that collects one aggregate over a group of smart meters for time round $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$23. The protocol decouples the activation/data-flow structure from the privacy-preserving computation. Meters first send their measurement payloads to the DC; then a forward-only activation flow runs among the meters; the last active meter sends the final information back to the DC; and the DC computes the aggregate only if a minimum number of meters participate. The working network during a round is modeled as an undirected graph

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$24

with working edges $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$25. The DC is always on; links are bidirectional; and no ACK within timeout $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$26 signals that a link or node is off.

AggFT maintains two lists: $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$27, the meters that may still participate, and $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$28, the meters that actually become active. Only meters whose initial message to the DC succeeds remain in $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$29. The active meter then tries to contact the next meter in $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$30; if the contact succeeds, that meter becomes active; if not, the failed meter is removed from $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$31 and the active meter tries the next candidate. The theorem on termination, resilience, and correctness states that, under the per-round on/off failure model and with the DC always working, the aggregation scheme terminates properly despite these errors; smart meters are either never active or active only once except initialization; if less than $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$32 smart meters are available the DC cannot obtain the aggregate measurements; and the DC obtains the correct aggregate if the privacy-preserving computations are done using either masking or homomorphic encryption.

For masking, the protocol uses round-dependent pseudo-random values $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$33 instead of static shares. The relevant expressions are

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$34

and

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$35

For homomorphic encryption,

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$36

with additive homomorphic property

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$37

The privacy analysis is game-based:

$P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$38

For masking, the paper proves information-theoretic privacy against an adversary controlling $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$39 smart meters and computational privacy against an adversary controlling the DC, assuming PRG security; for homomorphic encryption, it proves privacy against $P^d_{n,k}=I_n\otimes q_{\bar{\jmath}(\theta_0)}$40 colluding smart meters assuming IND-CPA security and information-theoretic privacy against the DC. The paper also states that these collusion sets are maximal.

AggFT marks an important boundary case for BBSA. It does not partition data into fixed blocks, does not present a block hierarchy, and does not use block-wise parallel aggregation. Instead, it aggregates over a dynamically surviving structure obtained by pruning unusable nodes and links. This suggests that BBSA, in the broader literature, can extend beyond literal tensor or vector blocks to structured aggregates defined by graph connectivity and protocol state. A plausible implication is that the unifying principle is not the physical shape of the block, but the decision to compress, select, or route information at an intermediate structural granularity between scalar elements and the full system.