Introduction

Deep residual networks  represent a paradigm shift in neural network design, enabling the stable training of models with unprecedented depth. Their core mechanism, the identity shortcut connection, reformulates layers to learn a residual function $`\Fb(\Xb)`$ with respect to their input $`\Xb`$. In its canonical form, the residual update is an element-wise addition:

\begin{equation}
\label{eq:standard_res}
\Xb_{l+1} = \Xb_l + \Fb(\Xb_l)
\end{equation}

You can view this as a forward Euler step (step size $`1`$) for the ODE $`\dot{\Xb} = \Fb(\Xb)`$. This viewpoint ties deep networks to dynamical systems . The strictly additive update also puts a strong translation bias on the learned dynamics. The shortcut path keeps a fixed Jacobian equal to the identity operator.

This rigidity limits what state transitions the network can represent. Recent work points to the need for more flexible transitions, including ones that realize negative eigenvalues, when modeling patterns like oscillations or oppositional behavior .

To overcome this limitation, we propose a principled generalization of the residual connection rooted in geometric linear algebra. We introduce Deep Delta Learning (DDL), featuring a novel residual block that applies a learnable, rank-1 transformation to the hidden state matrix $`\Xb \in \RR^{d \times d_v}`$. This formulation aligns the network depth with memory-augmented architectures, effectively treating the hidden state as a dynamic value matrix. This block utilizes a single learned scalar gate $`\beta(\Xb)`$ to smoothly interpolate between a standard residual connection, an orthogonal projection operator, and a full geometric reflection. Our contributions are:

1. We propose the Delta Residual Block, a multi-branch architecture that learns to apply a generalized Householder operator to the matrix-valued shortcut connection, parameterized by a learned direction $`\kb(\Xb)`$ and a learned gate $`\beta(\Xb)`$, which is illustrated in Figure 1.

2. We give a spectral analysis of the Delta Operator. We derive its complete eigensystem, and show how $`\beta(\Xb)`$ controls the transformation by shaping its spectrum.

3. We unify identity mapping, projection, and reflection in one continuously differentiable module. We also show DDL recovers the Delta Rule update, with the gate $`\beta`$ acting like a depth-wise step size.

The Delta Residual Block

We build our method upon the mathematical foundation of the Householder reflection, which we generalize into a learnable, state-dependent operator.

Preliminaries: The Householder Transformation

\begin{equation}
\Hb_{\kb} = \Ib - 2 \frac{\kb \kb^{\top}}{\|\kb\|_2^2}
\end{equation}

The Householder matrix is a cornerstone of numerical linear algebra and possesses several key properties: it is symmetric ($`\Hb_{\kb} = \Hb_{\kb}^{\top}`$), orthogonal ($`\Hb_{\kb}^{\top} \Hb_{\kb} = \Ib`$), and involutory ($`\Hb_{\kb}^2 = \Ib`$). Its spectrum consists of a single eigenvalue of $`-1`$ (eigenvector $`\kb`$) and $`d-1`$ eigenvalues of $`1`$ (the eigenspace $`\kb^{\perp}`$).

Formulation of the Delta Operator

We generalize the Householder matrix by replacing the constant factor of $`2`$ with a learnable, data-dependent scalar gate, $`\beta(\Xb)`$. This leads to the Delta Residual (Delta-Res) block. Let the hidden state be a matrix $`\Xb \in \RR^{d \times d_v}`$, where $`d`$ is the feature dimension and $`d_v`$ denotes the number of value channels. We modify the additive residual to be a rank-1 update aligned with the reflection vector $`\kb`$. The block output is computed as:

\begin{equation}
\label{eq:gated_hres_out}
\Xb_{l+1} = \Ab(\Xb_l)\Xb_l + \beta(\Xb_l)\kb(\Xb_l)\vb(\Xb_l)^{\top}
\end{equation}

where $`\vb \in \RR^{d_v}`$ is the residual value vector generated by the branch $`\Fb: \RR^{d \times d_v} \to \RR^{d_v}`$. Here, the outer product $`\kb\vb^\top`$ constitutes the additive update. Crucially, we apply the gate $`\beta(\Xb)`$ to this constructive term as well, linking the erasure and write operations. The term $`\Ab(\Xb)`$ is the Delta Operator acting spatially on the feature dimension $`d`$:

\begin{equation}
\label{eq:gated_matrix}
\Ab(\Xb) = \Ib - \beta(\Xb) \frac{\kb(\Xb) \kb(\Xb)^{\top}}{\kb(\Xb)^{\top} \kb(\Xb) + \epsilon}
\end{equation}

The architecture learns the reflection direction $`\kb(\Xb) \in \RR^d`$, the value vector $`\vb(\Xb) \in \RR^{d_v}`$, and the reflection intensity $`\beta(\Xb) \in \RR`$ through separate, lightweight neural network branches. The constant $`\epsilon > 0`$ ensures numerical stability. For the theoretical analysis, we assume $`\kb`$ is strictly normalized such that $`\kb^{\top}\kb=1`$ (see Appendix 7 for implementation details). Under this condition ($`\epsilon \to 0`$), the operator simplifies to:

\begin{equation}
\Ab(\Xb) = \Ib - \beta(\Xb) \kb(\Xb)\kb(\Xb)^{\top}
\end{equation}

Since $`\Xb`$ is a matrix, the operator $`\Ab(\Xb)`$ broadcasts across the value dimension $`d_v`$, applying the geometric transformation simultaneously to every column of the hidden state.

Under the same unit-norm assumption, substituting $`\Ab(\Xb)=\Ib-\beta(\Xb)\kb(\Xb)\kb(\Xb)^\top`$ into Eq. [eq:gated_hres_out] yields an equivalent additive, rank-1 Delta form:

\begin{equation}
\label{eq:ddl_additive}
\Xb_{l+1} = \Xb_l + \beta(\Xb_l)\,\kb(\Xb_l)\Big(\vb(\Xb_l)^{\top} - \kb(\Xb_l)^{\top}\Xb_l\Big),
\end{equation}

which makes explicit that the same scalar $`\beta`$ modulates both the erasure term $`\kb^\top\Xb`$ and the write term $`\vb^\top`$.

The gating function $`\beta(\Xb)`$ is parameterized to lie in the range $`[0, 2]`$ via a projection of the state features followed by a sigmoid function:

\begin{equation}
\label{eq:beta_param}
\beta(\Xb) = 2 \cdot \sigma(\operatorname{Linear}(\mathcal{G}(\Xb)))
\end{equation}

where $`\mathcal{G}(\cdot)`$ is a pooling, convolution, or flattening operation. This specific range is chosen for its rich geometric interpretations, which we analyze next.

Analysis

The expressive power of the Delta-Res block comes from the spectral properties of the operator $`\Ab(\Xb)`$, which are controlled by the learned gate $`\beta(\Xb)`$.

Spectral Decomposition of the Delta Operator

\begin{equation}
\sigma(\Ab) = \{ \underbrace{1, 1, \dots, 1}_{d-1 \text{ times}}, 1-\beta \}
\end{equation}

\begin{equation}
\Ab\ub = (\Ib - \beta \kb\kb^{\top})\ub = \Ib\ub - \beta \kb(\kb^{\top}\ub) = \ub - \beta \kb(0) = \ub = 1 \cdot \ub
\end{equation}

\begin{equation}
\Ab\kb = (\Ib - \beta \kb\kb^{\top})\kb = \Ib\kb - \beta \kb(\kb^{\top}\kb) = \kb - \beta \kb(1) = (1-\beta)\kb
\end{equation}

This theorem provides a clear and powerful interpretation of the gate $`\beta(\Xb)`$. By learning a single scalar, the network can dynamically control the geometry of the residual transformation across all $`d_v`$ columns of the state matrix simultaneously.

Lifting to matrix-valued states.

The spectral statements above are spatial: they describe the linear map $`\ub\mapsto \Ab\ub`$ on $`\RR^d`$. Since our hidden state is a matrix $`\Xb\in\RR^{d\times d_v}`$ and the shortcut acts by left-multiplication, each of the $`d_v`$ columns is transformed independently by the same $`\Ab`$. Equivalently, under vectorization, the induced linear operator is $`\Ib_{d_v}\otimes \Ab`$. Thus the spectrum of the lifted map consists of the eigenvalues of $`\Ab`$ repeated $`d_v`$ times, and its determinant equals $`\det(\Ab)^{d_v}`$.

Orthogonality condition.

Because $`\Ab`$ is symmetric, its singular values coincide with the absolute values of its eigenvalues. In particular, $`\Ab`$ is orthogonal if and only if $`|1-\beta|=1`$, i.e., $`\beta\in\{0,2\}`$ under the unit-norm assumption. For $`\beta\in(0,2)`$, $`\Ab`$ performs an anisotropic contraction along $`\kb`$ (and flips sign along $`\kb`$ when $`\beta>1`$).

\begin{equation}
\det(\Ab(\Xb)) = \prod_{i=1}^{d} \lambda_i = 1^{d-1} \cdot (1-\beta(\Xb)) = 1-\beta(\Xb)
\end{equation}

Since the shortcut broadcasts across the $`d_v`$ value columns, the induced determinant on the full matrix state space $`\RR^{d\times d_v}`$ (equivalently, on $`\mathrm{vec}(\Xb)\in\RR^{d d_v}`$) is $`\det(\Ab(\Xb))^{d_v}=(1-\beta(\Xb))^{d_v}`$. Thus $`\beta(\Xb)`$ controls the signed volume change along the spatial direction $`\kb(\Xb)`$; in particular, $`\beta(\Xb)>1`$ introduces a negative spatial eigenvalue (a reflection along $`\kb`$), while the global orientation of the lifted state space flips if and only if $`d_v`$ is odd.

Unification of Geometric Operations

Theorem [thm:spectrum] reveals that the range $`[0, 2]`$ for $`\beta(\Xb)`$ allows the operator to interpolate between three fundamental linear transformations.

• Identity Mapping ($`\beta(\Xb) \to 0`$): As $`\beta \to 0`$, the eigenvalue $`1-\beta \to 1`$. All eigenvalues of $`\Ab(\Xb)`$ become $`1`$, so $`\Ab(\Xb) \to \Ib`$. Since $`\beta`$ also modulates the injection term $`\beta \kb \vb^\top`$, the entire update vanishes, meaning $`\Xb_{l+1} \approx \Xb_l`$. This identity behavior is crucial for preserving signal propagation in very deep networks.

• Orthogonal Projection ($`\beta(\Xb) \to 1`$): As $`\beta \to 1`$, the eigenvalue $`1-\beta \to 0`$. The operator $`\Ab(\Xb)`$ becomes $`\Ib - \kb\kb^\top`$, an orthogonal projector (rank $`d-1`$) onto the hyperplane $`\kb^\perp`$. The component of each column of the input state $`\Xb`$ parallel to $`\kb`$ is explicitly removed (“forgotten”) before the residual is added. The operator becomes singular, and $`\det(\Ab) \to 0`$. In terms of the full block (Eq. [eq:ddl_additive]), this regime can be interpreted as replace-along-$`\kb`$: the shortcut removes the $`\kb`$-component, and the rank-1 write injects a new component along $`\kb`$ specified by $`\vb^\top`$.

• Full Reflection ($`\beta(\Xb) \to 2`$): As $`\beta \to 2`$, the eigenvalue $`1-\beta \to -1`$. The operator $`\Ab(\Xb)`$ becomes $`\Ib - 2\kb\kb^\top`$, a standard Householder matrix. This performs a perfect reflection of each column of $`\Xb`$ across $`\kb^\perp`$. This is the only case in this range where the transformation is guaranteed to be orthogonal and spatially volume-preserving, with $`\det(\Ab) \to -1`$. The negative spatial determinant signifies a change in orientation (a reflection) of the basis. Together with the identity case ($`\beta=0`$), this is the only setting in $`[0,2]`$ for which the shortcut operator $`\Ab`$ is orthogonal. The full block additionally applies the synchronized rank-1 write term, yielding a reflection of the incoming state followed by a write aligned with $`\kb`$.

Special Case: Gated Residual Learning

A critical property of Deep Delta Learning is its behavior in the limit of the gating scalar. When the gate vanishes ($`\beta(\Xb) \to 0`$), the Delta Operator converges to the identity matrix ($`\Ab(\Xb) \to \Ib`$), and the constructive term vanishes. Consequently, the update rule in Equation [eq:gated_hres_out] simplifies to:

\begin{equation}
\Xb_{l+1} = \Xb_l
\end{equation}

This recovers the identity mapping, effectively allowing the layer to be skipped entirely. This behavior is consistent with the zero-initialization strategy often required for training very deep networks. Conversely, when $`\beta \approx 1`$, the layer functions as a Gated Rank-1 Matrix ResNet, where $`\beta`$ acts as a learned step size governing the magnitude of the update. This demonstrates that DDL generalizes residual learning by introducing a multiplicative, geometric modulation that is coupled synchronously with the value injection.

Diagonal Feature Matrices Case

To better understand the mixing properties of the Delta Operator, consider the special case where the input state $`\Xb \in \RR^{d \times d}`$ is a square diagonal matrix, $`\Xb = \text{diag}(\lambda_1, \dots, \lambda_d)`$. This represents a state where features are perfectly decoupled across the value dimensions. The application of $`\Ab`$ yields:

\begin{equation}
(\Ab\Xb)_{ij} = (\Xb - \beta \kb \kb^\top \Xb)_{ij} = \lambda_i \delta_{ij} - \beta \lambda_j k_i k_j
\end{equation}

Specifically, the off-diagonal element ($`i \neq j`$) becomes $`-\beta \lambda_j k_i k_j`$, while the diagonal element ($`i=j`$) is scaled to $`\lambda_i (1 - \beta k_i^2)`$. This implies that the output feature $`i`$ is now dependent on the magnitude of the input feature $`j`$, scaled by the geometric coherence $`k_i k_j`$. This result elucidates a critical function of the Delta block: it induces controlled feature coupling. Even if the incoming features are independent, a non-zero $`\beta`$ forces an interaction between the $`i`$-th and $`j`$-th modes proportional to the projection of the reflection vector $`\kb`$.

If $`\beta \to 1`$ (projection), the shortcut removes the component of each column along $`\kb`$, mapping the state into $`\kb^\perp`$ before the write term reinstates a new $`\kb`$-component specified by $`\vb^\top`$. If $`\beta \to 0`$, the diagonal structure is preserved.

Vector Hidden State Dynamics

While DDL operates on matrix-valued states $`\Xb \in \RR^{d \times d_v}`$, it naturally encapsulates standard vector-based deep learning as a specific limit. We identify two distinct regimes:

The Scalar Value Limit ($`d_v=1`$).

When the value dimension is reduced to unity, the hidden state degenerates to a standard feature vector $`\xb \in \RR^d`$. In this limit, the value update $`\vb`$ becomes a scalar $`v \in \RR`$. The Delta update rule Eq. [eq:gated_hres_out] simplifies to:

\begin{equation}
\xb_{l+1} = \xb_l + \beta_l \underbrace{(v_l - \kb_l^\top \xb_l)}_{\gamma_l} \kb_l
\end{equation}

Here, the geometric transformation collapses into a dynamic scalar gating mechanism. The term $`\gamma_l`$ acts as a data-dependent coefficient that couples the update magnitude to the discrepancy between the proposed write value $`v_l`$ and the current projection $`\kb_l^\top \xb_l`$.

The Independent Feature Limit.

Alternatively, one may view the diagonal case in Section 3.4 as a representation of a vector state embedded in a matrix diagonal. As shown in the diagonal analysis, the Delta Operator introduces feature coupling via the term $`\beta k_i k_j`$. To recover the behavior of standard element-wise vector updates (where features do not mix spatially), the reflection vector $`\kb`$ must be aligned with the canonical basis (i.e., one-hot). In this regime, the Delta Operator acts as an element-wise gating function, strictly preserving the independence of the feature dimensions.

Connections to Optimization and Delta Architectures

The terminology Deep Delta Learning reflects a structural homology with the Delta Rule, a fundamental update mechanism recently popularized in efficient sequence modeling, e.g., DeltaNet .

The Delta Rule for Residual Learning

The standard residual connection, $`\Xb_{l+1} = \Xb_l + \Fb(\Xb_l)`$, imposes a strictly additive inductive bias. Information, once generated by $`\Fb`$, is simply accumulated. This can lead to “residual accumulation”, where noisy or interfering features persist across layers because the network lacks an explicit mechanism to selectively filter the hidden state.

Deep Delta Learning addresses this by incorporating the Delta Rule structure into the depth dimension. Expanding the Delta Residual update in Equation [eq:gated_hres_out] using the rank-1 residual definition:

\begin{equation}
\label{eq:delta_expansion}
\Xb_{l+1} = \Xb_l + \beta_l \kb_l \left( \underbrace{\vb_l^\top}_{\text{Write}} - \underbrace{\kb_l^\top \Xb_l}_{\text{Erase}} \right)
\end{equation}

This formulation exactly recovers the Delta Rule update utilized in fast associative memories and linear attention. The term $`\kb_l^\top \Xb_l`$ represents the current projection of the state onto the reflection vector (the “error” or “old memory”). The term $`(\vb_l^\top - \kb_l^\top \Xb_l)`$ acts as the correction signal.

Since $`\Xb_l \in \RR^{d \times d_v}`$ is a matrix, the term $`\kb_l^\top \Xb_l`$ yields a row vector in $`\RR^{1 \times d_v}`$, representing the projection of every value column onto $`\kb_l`$. The update rigidly aligns both the erasure (destructive) and injection (constructive) operations along the geometric direction defined by the projector $`\kb_l`$, modulated by the step size $`\beta_l`$.

When $`\beta(\Xb_l) \approx 1`$, this subtractive term acts as an orthogonal projection, effectively erasing the component of the incoming state $`\Xb_l`$ parallel to $`\kb(\Xb_l)`$ (forgetting). When $`\beta(\Xb_l) \approx 2`$, the term subtracts twice the projection, resulting in a sign inversion (reflection). This provides the network with a flexible mechanism to selectively clean or reorient specific feature subspaces layer-by-layer, preventing the accumulation of interference.

Relation to DeltaNets and Householder Products

Our work shares a theoretical link with the DeltaNet architecture , which replaces the additive accumulation of Linear Transformers with a Delta Rule for memory updates.

We demonstrate that Deep Delta Learning is the depth-wise isomorphism of the DeltaNet recurrence. In DeltaNet, the hidden state (memory) $`\Sbb_t`$ evolves over time $`t`$. To unify notation with our depth-wise formulation, we present the DeltaNet update using left-multiplication semantics, where the memory state is $`\Sbb_t \in \RR^{d_k \times d_v}`$:

\begin{equation}
\label{eq:deltanet_eq}
\Sbb_t = (\Ib - \beta_t \kb_t \kb_t^\top)\Sbb_{t-1} + \beta_t \kb_t \vb_t^\top
\end{equation}

Here, the operator acts on the key dimension $`d_k`$, which is analogous to the feature dimension $`d`$ in DDL. Comparing this to our Deep Delta Layer update Equation [eq:gated_hres_out] acting over depth $`l`$:

\begin{equation}
\label{eq:ddl_eq}
\Xb_{l+1} = (\Ib - \beta_l \kb_l \kb_l^\top) \Xb_l + \beta_l \kb_l \vb_l^\top
\end{equation}

where $`\vb_l`$ is the vector output of the value branch.

This reveals a direct structural correspondence:

• The memory state $`\Sbb_t`$ (dimension $`d_k \times d_v`$) in DeltaNet corresponds to the feature activation $`\Xb_l`$ (dimension $`d \times d_v`$) in DDL.

• Both architectures employ the rank-1 Householder operator to selectively reflect or erase subspace components. DeltaNet applies this over time steps $`t`$, whereas DDL applies it over network depth $`l`$.

• Our modified residual update $`\beta_l \kb_l \vb_l^\top`$ aligns perfectly with the DeltaNet write operation. By incorporating $`\beta_l`$ into the constructive term, we interpret $`\beta_l`$ as a layer-wise step size for the depth-wise ODE. This ensures that both the erasure and injection components are modulated synchronously, ensuring the update represents a coherent geometric transformation of the state $`\Xb`$.

Thus, DDL can be interpreted as applying the Delta Rule to layer-wise feature evolution, enabling the network to forget or rewrite features from shallow layers as they propagate deeper.

Related Work

Our work builds upon several key research themes in deep learning.

Gated and Invertible Architectures.

Highway Networks  introduced data-dependent gating to residual networks, but their gates interpolate between the identity path and the function path, rather than modifying the transformation itself. Invertible Residual Networks (i-ResNets)  constrain the Lipschitz constant of $`\Fb`$ to ensure invertibility, which is useful for applications like normalizing flows. Our Delta shortcut operator is invertible whenever $`1-\beta\neq 0`$ (in the $`\epsilon\to 0`$ analysis), and becomes an orthogonal involution at $`\beta=2`$ (a Householder reflection). DDL does not enforce invertibility globally; instead, it allows the network to learn when a near-invertible transition is beneficial versus when an intentionally singular (projective) transition is useful for controlled forgetting.

Orthogonal and Unitary Networks.

A significant body of work has focused on constraining network weights to be orthogonal or unitary to improve gradient stability and preserve geometric structure . Householder reflections are a classic method for parameterizing orthogonal matrices. These methods enforce orthogonality as a strict constraint. In contrast, our Delta Residual Network learns to deviate from identity and orthogonality via the gate $`\beta(\xb)`$, providing a soft, adaptive constraint that can be relaxed to pure projection or reflection.

Neural Ordinary Differential Equations.

Neural ODEs  model the continuous evolution of features. The standard ResNet Eq. [eq:standard_res] is a discretization of the simple ODE $`\dot{\Xb} = \Fb(\Xb)`$. Our proposed architecture alters the underlying dynamics to $`\dot{\Xb} = \beta(\Xb) \kb(\Xb) (\vb(\Xb)^\top - \kb(\Xb)^\top \Xb)`$, introducing a state-dependent projection term applied to the matrix state. This allows for a much richer family of learnable dynamical systems that can exhibit contractive or oscillatory behavior across multiple value dimensions.

Conclusion

We have introduced Deep Delta Learning, a novel architecture built upon an adaptive, geometric residual connection. Through analysis, we have demonstrated that its core component, the Delta Operator, unifies identity mapping, projection, and reflection into a single, continuously differentiable module. This unification is controlled by a simple learned scalar gate, which dynamically shapes the spectrum of the layer-to-layer transition operator. By empowering the network to learn transformations with negative eigenvalues in a data-dependent fashion, DDL offers a significant and principled increase in expressive power while retaining the foundational benefits of the residual learning paradigm.

Implementation and Parameterization Details

The Deep Delta Learning (DDL) framework relies on the efficient estimation of the reflection direction $`\kb(\Xb)`$, the scalar gate $`\beta(\Xb)`$, and the residual value $`\vb(\Xb)`$. While the theoretical results hold regardless of the specific topology used to approximate these functions, we outline two primary architectural instantiations for the generator functions: MLP-based and Attention-based parameterizations.

Let the hidden state be $`\Xb \in \RR^{d \times d_v}`$. We denote the generator branch for the reflection vector as a function $`\phi_k: \RR^{d \times d_v} \to \RR^d`$.

Parameterization of the Reflection Direction $`\kb(\Xb)`$

The geometric orientation of the Delta Operator is determined by $`\kb`$. We propose two distinct mechanisms for $`\phi_k`$, allowing for different inductive biases regarding feature interaction.

Option 1: MLP Parameterization.

For architectures prioritizing global feature mixing with low computational overhead, we parameterize $`\kb`$ using a Multi-Layer Perceptron (MLP) acting on aggregated statistics of the state matrix.

\begin{equation}
    \tilde{\kb}_{\text{MLP}} = \text{MLP}\!\left( \text{Pool}(\Xb) \right), \quad
    \kb_{\text{MLP}} = \frac{\tilde{\kb}_{\text{MLP}}}{\|\tilde{\kb}_{\text{MLP}}\|_2 + \epsilon_k}
\end{equation}

Here, $`\text{Pool}(\cdot)`$ is any aggregation that produces a fixed-size vector representation of $`\Xb`$, e.g., column-wise averaging ($`\RR^{d\times d_v}\to\RR^{d}`$) or flattening ($`\RR^{d\times d_v}\to\RR^{d \cdot d_v}`$), followed by an MLP that outputs $`\RR^{d}`$. We enforce $`L_2`$ normalization (with a small $`\epsilon_k>0`$ for numerical stability) to satisfy the spectral assumptions in Theorem [thm:spectrum].

Option 2: Attention-based Parameterization.

To capture more granular dependencies within the value dimension, we can employ attention mechanism.

Parameterization of the Gate $`\beta(\Xb)`$ and Value $`\vb(\Xb)`$

The Gating Branch.

The scalar gate $`\beta`$ requires a bounded output in $`[0, 2]`$. We maintain a lightweight design for this estimator:

\begin{equation}
    \beta(\Xb) = 2 \cdot \sigma\left( \mathbf{w}_\beta^\top \tanh(\mathbf{W}_{\text{in}} \text{Pool}(\Xb)) \right)
\end{equation}

where $`\sigma`$ is the sigmoid function, ensuring smooth interpolation between identity, projection, and reflection.

The Value Branch.

The residual value vector $`\vb \in \RR^{d_v}`$ represents the content update. This branch, $`\Fb: \RR^{d \times d_v} \to \RR^{d_v}`$, allows for flexible design choices. In our experiments, we utilize the same architecture chosen for the main backbone (e.g., if DDL is applied in a Transformer, $`\Fb`$ mirrors the Feed-Forward Network or Multi-Head Attention block structure) to ensure capacity alignment.