BlockCIR: Versatile Block Circulant Methods

• BlockCIR is a unifying framework that leverages block circulant structures to enhance efficiency and scalability in explainable AI, coding theory, model compression, and blockchain architectures.
• It employs robust techniques such as invariant groupwise attribution, parallel erasure decoding, and FFT-based acceleration to achieve significant performance gains and computational savings.
• BlockCIR enables modular design in blockchain circuits, providing explicit safety-liveness trade-offs and provable resilience through compositional methods.

BlockCIR refers to several distinct yet structurally related methodologies in modern computational research, covering areas from explainable AI to coding theory, LLM compression, and compositional blockchain architectures. Each context exploits the block-circulant structural motif—matrices or topologies with inherent symmetry and overlap—for efficiency, scalability, or compositional guarantees. The term "BlockCIR" appears explicitly as a groupwise attribution score in XAI, a block-circulant code for decentralized systems, a block-circulant adapter for LLMs, and a compositional circuit methodology for overlay blockchains.

1. BlockCIR in Explainable AI: Correlation-Aware Groupwise Attribution

BlockCIR, introduced in “Correlation-Aware Feature Attribution Based Explainable AI,” generalizes the ExCIR (Explainability through Correlation Impact Ratio) method to sets of correlated features, addressing the instability and double-counting endemic to traditional attribution methods like SHAP and PFI. Whereas ExCIR scores single features by robustly centered, sign-aligned co-movement with the model output, BlockCIR aggregates this evidence across user-specified or data-driven feature groups. This is particularly crucial for sets exhibiting strong cross-feature dependence, such as gene clusters or synonym sets in text, where singleton attributions otherwise fragment or inflate importance.

Mathematically, given $X\in\mathbb{R}^{n\times d}$, a model $f:\mathbb{R}^d\to\mathbb{R}$, outputs $\bm y = f(X)$, and group $G\subseteq \{1,\dots,d\}$, the BlockCIR score is

$$\mathrm{BlockCIR}(G) = \begin{cases} \tfrac12\Bigl(1 + \frac{N_G}{D_G}\Bigr), & D_G>0\ \tfrac12, & D_G=0 \end{cases}$$

where $N_G = \sum_{i=1}^n p_{iG}$ and $D_G = \sum_{i=1}^n u_{iG}$, with $p_{iG} = \sum_{j\in G} \tilde x_{ij} \tilde y_i$ and $u_{iG} = \sum_{j\in G} |\tilde x_{ij} \tilde y_i|$, and the robust centering $\tilde x_{ij} = x_{ij} - m(\bm x_j)$ ($m$ is the mid-mean) and $\tilde y_i = y_i - m(\bm y)$.

BlockCIR's invariant, monotonic, and single-pass computation scales as $O(nd)$ regardless of group structure, with group assignments driven either by domain knowledge or high-correlation thresholding. Empirically, a lightweight transfer protocol—randomly subsampling $f \in [0.2,0.4]$ of rows—retains $\geq 90\%$ Top-$k$ agreement compared to full eval at $3$–$9\times$ runtime reduction. BlockCIR stabilizes global rankings under strong collinearity, assigning major credit only to blocks rather than dispersing or duplicating attribution as in singleton-based explainers and outperforming ExCIR in preserving the true global importance profile in correlated settings (Sengupta et al., 20 Nov 2025).

2. BlockCIR Codes: High-Rate Erasure Codes for Decentralized Systems

BlockCIR codes, as introduced in “Block Circulant Codes with Application to Decentralized Systems,” define a new family of erasure codes designed for scalable, distributed verification and high minimum distance at high rates. The defining topology $T_{[\mu,\lambda,\omega]}(\rho)$ is parameterized by the total number of blocks $\mu$, overlap factor $\lambda$, overlap width $\omega$, and number of local parities $\rho$. Each codeword of length $n = \mu(\rho+\omega)$ is partitioned into $\mu$ overlapping local blocks $A_i$, with intersections governed by $\lambda$ and $\omega$ to yield uniform overlap patterns.

Each $A_i$ is equipped with a $[\rho+\lambda\omega, \lambda\omega, \rho+1]$ Generalized Reed–Solomon (GRS) local code. The global code parameters are: $$n = \mu (\rho+\omega),\quad k = \mu \omega,\quad d = \lambda \rho + 1.$$ For $\lambda=2$, $d = 2\rho+1$ is always achieved, and a parallel, two-phase erasure decoder is provided. The decoder first resolves blocks with at most $\rho$ erasures using their local GRS decoder (ripple phase), then in Phase II corrects erasures confined to two overlapping blocks jointly.

BlockCIR codes offer considerable gains over 2D Reed–Solomon codes in the high-rate regime: given $k/n=1-\epsilon$ (small $\epsilon$), the fractional minimum distance of BlockCIR scales as $\lambda\epsilon$ vs. $\epsilon^2$ for 2D-RS codes—a gain of order $1/\epsilon$ when $\lambda>1$. For example, $[1444,1024,49]$ 2D-RS (distance fraction $3.4\%$) versus $[1416,1024,65]$ BlockCIR ($4.6\%$) demonstrates a $35\%$ improvement in $d/n$. Additionally, leveraging local GRS structure enables succinct KZG commitments, efficient per-symbol proofs, and local fraud proofs, reducing light-node protocol costs for blockchain data availability (Sasidharan et al., 18 Jun 2024).

3. BlockCIR Adapters: Block Circulant Matrices for LLM Compression

BlockCIR, in the context of parameter-efficient fine-tuning (PEFT) for LLMs, describes a block circulant adapter framework replacing the model update matrix $\Delta W$ with a block circulant $B$. Each block of size $p \times p$ is itself circulant, yielding substantial storage and computational savings. The full $n\times n$ adapter is specified by $n^2/p$ parameters.

Mathematically, $B$ is partitioned into $q^2$ blocks (with $n = p q$), each parameterized by its first column. Circulant matrices are diagonalized via the 1D DFT, allowing $B \mathbf{x}$ to be computed efficiently using FFT/IFFT: $$(B \mathbf{x})_i = \mathrm{IFFT}\left(\sum_{j=0}^{q-1} \mathrm{FFT}(\mathbf{c}_{i,j}) \circ \mathrm{FFT}(\mathbf{x}_j)\right)$$ for each block index $i$.

A critical finding is that gradient magnitudes with respect to block parameters scale as $p$ (block size), leading to instability at default learning rates. Empirical stability is restored by applying a learning-rate scaling heuristic: $\alpha \leftarrow \alpha / p$. This adjustment recovers convergence properties comparable to dense adapters.

BlockCIR achieves notable parameter and FLOP reductions: up to $16\times$ fewer parameters than LoRA, $14\times$ less than VeRA, and $32\times$ fewer FLOPs than FourierFT, while maintaining similar or superior downstream accuracy. This efficiency holds, e.g., for RoBERTa-Base/ Large and LLaMA2-7B on standard tasks. BlockCIR is restricted to mergeable, additive adapters on square matrices, and extremely large block sizes may still incur nontrivial FFT overhead (Ding et al., 1 May 2025).

4. BlockCIR in Blockchain Architecture: Circuits of Blockchains

BlockCIR also denotes a compositional methodology, “blockchain circuits,” for assembling overlay blockchains atop multiple underlay chains by analogy with switching circuits (Tas et al., 31 Jan 2024). Each underlay blockchain exposes safety (fork-free consistency) and liveness (unbounded transaction growth), viewed as a Boolean “switch.” BlockCIR composes blockchains using two primitive “gates”:

• Serial ($\circ$): Given $(S_1,L_1), (S_2,L_2)$, output $(S_1\vee S_2, L_1\wedge L_2)$. Overlay is safe if either underlay is safe, live only if both are live.
• Triangular/majority ($\Delta$): For three chains, output $$(S_1\wedge S_2\wedge S_3, [L_1L_2 + L_2L_3 + L_3L_1 \ge 1])$$. Overlay is safe iff all are safe, live if any two are live.

By assembling circuits of $\circ$ and $\Delta$ gates, BlockCIR achieves the full spectrum of optimal trade-offs between safety and liveness. The fundamental theorem specifies that for $k$ underlays, you can realize each tuple $(k,s,l)$ with $l\geq \lfloor k/2 \rfloor+1$ (liveness threshold) and $s\geq 2(k-l)+1$ (safety threshold), and no protocol can do better under partial synchrony. These constructions generalize to full synchrony by adding an interleaving ($\otimes$) gate that further tightens the achievable region.

This circuit-style approach produces scalable, modular overlay blockchains with explicit, provable resilience characteristics by construction, supporting arbitrarily complex compositions and safety-liveness trade-offs (Tas et al., 31 Jan 2024).

5. Applications and Empirical Performance

BlockCIR methodologies support various high-stakes tasks:

• XAI: BlockCIR delivers stable, groupwise global feature rankings in high-collinearity settings. On 29 datasets, the transfer protocol with $f\in [0.2,0.4]$ achieves Top-8 Jaccard $\geq 0.9$ and $3$–$9\times$ runtime reduction. Compared to SHAP/LIME, BlockCIR is $>100\times$ faster with similar ranking correlation (Kendall $\tau\approx 0.82\text{ vs. SHAP}$), and uniquely resolves block-level attribution (Sengupta et al., 20 Nov 2025).
• BlockCIR Codes: For blockchain data availability, BlockCIR codes allow succinct KZG proof aggregation, increase fractional distance by $20\%$–$30\%$ at the same rate as 2D RS, and reduce required symbol sampling rates for honest recovery and unavailability detection (Sasidharan et al., 18 Jun 2024).
• LLM Adapters: BlockCIR achieves $14$–$16\times$ parameter and $32\times$ FLOP reductions versus state of the art while matching accuracy on GLUE, Alpaca/MT-Bench, and GSM8K. Stable convergence is achieved across architectures by block-size-adaptive learning rate scaling (Ding et al., 1 May 2025).
• Composable Blockchains: BlockCIR “circuit” overlays offer modular, explicit construction of blockchains optimized for required safety–liveness profiles, supporting robust protocol design in multi-chain environments (Tas et al., 31 Jan 2024).

6. Limitations and Best Practices

• BlockCIR (XAI): BlockCIR measures association, not causation, and is not robust to nonlinear dependencies (e.g., sinusoidal relationships). Overlapping group assignments must be handled with care to prevent double counting. For extremely high-dimensional, low-sample regimes, convergence can be unstable and should be monitored via incremental subsampling (Sengupta et al., 20 Nov 2025).
• BlockCIR Codes: Performance relies on the independence of local coefficients and sufficient field size for GRS instantiation. Very high rate (small $\epsilon$) settings benefit most. Verification scalability depends on succinct cryptographic proofs (Sasidharan et al., 18 Jun 2024).
• LLM/adapters: Current applicability is limited to additive, mergeable adapters on square, single-projection layers. Expressivity and FFT overhead remain a trade-off as block size increases (Ding et al., 1 May 2025).
• Blockchain circuits: Assumptions rely on well-formed finalized ledgers and certificate machinery. The design is optimal in the presence of partial or full synchrony constraints specified, and cannot exceed the proven (s, l) bounds (Tas et al., 31 Jan 2024).

Best practices across settings emphasize exploiting structured block assignments (correlation clusters, overlap patterns, or projection symmetries), adapting learning rates or commit strategies to the block structure, and leveraging parallelizability and compositionality for scalability.

---

BlockCIR, despite sharing a unifying structural concept, demonstrates the versatility of block circulant constructs across modern signal processing, model interpretability, coding, and distributed ledger design. Each instantiation combines formal invariance, parameter/computation efficiency, and modularity, enabling tractable, scalable solutions to problems in explainability, reliability, compression, and protocol synthesis.