Symplectic Pooling Layer in Hamiltonian CNNs

• Symplectic pooling is a downsampling operator for Hamiltonian data that preserves the canonical symplectic form by coupling position and momentum channels.
• It uses a shared max-pooling Jacobian to achieve a symplectic projection, ensuring that the geometric structure is maintained during dimensionality reduction.
• Integrated within symplectic autoencoders, the layer improves reconstruction accuracy and supports stable long-term dynamics by retaining phase-space fidelity.

Searching arXiv for the specified paper to ground the response. A symplectic pooling layer is a downsampling operator for Hamiltonian data representations in a symplectic convolutional neural network (CNN). In the formulation introduced in "Symplectic convolutional neural networks" (Yıldız et al., 27 Aug 2025), the layer acts on a full input $x=[q;p]\in\mathbb{R}^{2N}$, where $q,p\in\mathbb{R}^N$ are the “position” and “momentum” channels in a Hamiltonian splitting, and reduces the spatial dimension by a factor $k$ while preserving the canonical symplectic form $\Omega$ on $\mathbb{R}^{2N}$. The construction is designed for symplectic autoencoders, where pooling must not destroy the geometric structure required for long-term modeling of Hamiltonian dynamics.

1. Conceptual role in symplectic neural architectures

Within the cited architecture, the symplectic pooling layer is introduced to construct a complete autoencoder in which not only convolutional layers but also the downsampling step remain compatible with symplectic structure (Yıldız et al., 27 Aug 2025). The motivating setting is a symplectic CNN built by combining symplectic neural networks, proper symplectic decomposition, and tensor techniques. In this context, pooling is not treated as a generic dimensionality-reduction primitive; it is treated as a structure-preserving map between phase-space representations.

The relevant phase space is split into paired channels, $q$ and $p$, corresponding to canonical coordinates. The layer therefore differs conceptually from conventional CNN pooling, which acts on feature maps without reference to a Poisson structure or canonical two-form. Here, the downsampling must preserve the canonical symplectic form

$\Omega((q,p),(q',p')) = q^T p' - p^T q',$

equivalently the standard Poisson matrix $J_{2N}$.

This placement within Hamiltonian learning is significant because the pooling layer is not an isolated component. It is part of an end-to-end encoder–decoder design in which each stage is expected to remain symplectic. A plausible implication is that the layer is best understood not as an adaptation of standard max-pooling alone, but as a geometric operator that mediates between multiscale representation learning and exact symplectic constraints.

2. Mathematical construction from max-pooling Jacobians

The construction begins with standard max-pooling on a single channel. For stride $k$ equal to kernel size $q,p\in\mathbb{R}^N$0, with $q,p\in\mathbb{R}^N$1, the map

$q,p\in\mathbb{R}^N$2

is defined componentwise by

$q,p\in\mathbb{R}^N$3

Its Jacobian at $q,p\in\mathbb{R}^N$4, denoted $q,p\in\mathbb{R}^N$5, has exactly one “1” per row, located at the arg max index, and zeros elsewhere. By construction,

$q,p\in\mathbb{R}^N$6

This property is the algebraic basis for the symplectic extension (Yıldız et al., 27 Aug 2025).

The paper lifts this single-channel operation to the two-channel Hamiltonian split by defining two modules:

$q,p\in\mathbb{R}^N$7

and

$q,p\in\mathbb{R}^N$8

In each case, the Jacobian is a $q,p\in\mathbb{R}^N$9 block diagonal matrix:

$k$0

and analogously for $k$1.

The essential point is that the same selection matrix is applied to both canonical channels. The layer does not independently pool $k$2 and $k$3 using unrelated arg max patterns in the same module. This design is what permits the induced map to preserve the canonical structure. A common misconception would be to equate “symplectic pooling” with ordinary pooling applied separately to each channel; the cited formulation instead couples the channels through a shared Jacobian pattern derived from either $k$4 or $k$5.

3. Symplecticity, projection, and lifting

The theoretical justification is stated as a proposition: if $k$6 is the max-pool Jacobian such that $k$7, then the block matrix

$k$8

satisfies

$k$9

Hence $\Omega$0 is a symplectic projection, and its transpose $\Omega$1 is a symplectic lifting (Yıldız et al., 27 Aug 2025).

The proof is described as a block-wise computation using the $\Omega$2 block structure of $\Omega$3, the identity $\Omega$4, and vanishing cross-terms. In geometric terms, the pooling operator is not merely norm-preserving or index-preserving; it preserves the canonical bilinear form that defines the phase-space geometry. That is why the paper refers to $\Omega$5 and $\Omega$6 as symplectic projections and to their transposes as symplectic liftings.

This characterization clarifies the role of the layer in the decoder. Unpooling is not described as an ad hoc inverse to max-pooling. Rather, the transpose of the projection serves as a symplectic lifting, using the stored pooling indices. This suggests that the encoder–decoder pair is organized around a projection/lifting duality compatible with the symplectic form.

4. Relation to standard pooling and implementation details

The implementation recipe is explicit. For an input tensor of shape $\Omega$7, one splits the tensor into two $\Omega$8-vectors $\Omega$9 and $\mathbb{R}^{2N}$0, finds the arg max index $\mathbb{R}^{2N}$1 for each window of size $\mathbb{R}^{2N}$2 in $\mathbb{R}^{2N}$3, assembles $\mathbb{R}^{2N}$4 as an $\mathbb{R}^{2N}$5 sparse matrix with ones at $\mathbb{R}^{2N}$6, computes

$\mathbb{R}^{2N}$7

and outputs

$\mathbb{R}^{2N}$8

with $\mathbb{R}^{2N}$9 defined analogously using $q$0 (Yıldız et al., 27 Aug 2025).

In practice, the sparse matrix is not formed explicitly. Instead, the implementation uses indices returned by a standard max-pool operation, with PyTorch’s max_pool1d and return_indices=True given as the concrete example, in order to scatter values into the downsampled tensor and record indices for unpooling.

The paper also states three distinctions from standard alternatives. First, no learnable weights are introduced by the symplectic pooling layer itself, unlike strided-convolution or learned “attention” pooling. Second, the key difference to plain max-pool is that one keeps track of the Jacobian $q$1 and arranges it in a $q$2 block so as to preserve the symplectic form. Third, the layer’s “nonlinearity” is exactly max-pool, but enriched by packaging the Jacobian into the autoencoder’s symplectic coordinate split.

These statements delimit what the layer is and is not. It is not a learned pooling mechanism. It is not a replacement for max-pooling’s selection rule. It is a structured reuse of max-pool’s Jacobian within a canonical two-channel representation.

5. Placement in the symplectic autoencoder pipeline

The paper situates the layer inside a specific encoder–decoder sequence. In the encoder, a typical block is

$q$3

After several convolutional and activation sub-blocks, the network has shape $q$4. A symplectic pooling module reduces this to $q$5. A subsequent PSD-like layer

$q$6

with $q$7, further projects into the $q$8-dimensional latent Hamiltonian coordinates (Yıldız et al., 27 Aug 2025).

In the decoder, the process is reversed:

$q$9

The use of stored indices during symplectic unpooling is part of this reversal.

The architectural significance is that pooling is not an auxiliary preprocessing step. It is positioned between symplectic convolutional processing and PSD-like latent projection. This suggests that the pooling layer mediates between local symplectic feature extraction and global latent Hamiltonian compression, rather than serving merely as a heuristic for reducing feature-map size.

6. Empirical behavior and interpretive significance

The reported numerical tests cover the wave equation, the nonlinear Schrödinger (NLS) equation, and the sine-Gordon equation. For the linear wave equation at latent dimension $p$0, the paper reports a PSD autoencoder error of approximately $p$1 and a symplectic CNN autoencoder error of approximately $p$2 (Yıldız et al., 27 Aug 2025). The paper further states that, in numerical tests on 1D wave, 1D NLS, and 2D sine–Gordon, replacing plain max-pool with symplectic pooling inside a symplectic CNN autoencoder gave dramatically lower reconstruction errors at very low latent dimension $p$3.

The same experiments are described as showing that, for NLS and sine-Gordon, symplectic pooling enabled stable long-term Hamiltonian predictions in conjunction with a SympNet time-integrator and outperformed linear PSD. The paper interprets these results as illustrating that enforcing exact symplecticity in each layer, including pooling, is crucial for capturing and extrapolating Hamiltonian dynamics.

The empirical evidence therefore connects the layer’s algebraic construction to concrete reduced-order modeling behavior. A plausible implication is that the benefit of symplectic pooling is most visible in aggressively compressed regimes, where geometric inconsistency in a single downsampling stage can dominate the quality of latent dynamics and long-horizon reconstruction. The reported comparisons do not imply that pooling alone accounts for all gains, since the layer is evaluated within a full symplectic CNN autoencoder, but they do isolate pooling as a consequential component when exact symplecticity is imposed throughout the network.