Message Passing

Message passing describes the Topology of a Backbone: where latent states live, which states communicate, how messages are aggregated and used to update those states, and how their dependencies change with network depth.

As established in Atomistic Graph, every individual message-passing update is local: it acts on a center and a finite neighborhood selected by the graph. This local form is the same for finite and periodic systems. We therefore use the generic edge notation \((i,j)\) throughout this document and leave its image-resolved periodic interpretation implicit, following the convention established there.

The primary organizing question is the Target: is the predicted physical quantity attached to a node or an edge? Most models use semi-local message passing, in which already aggregated environments are passed between neighboring centers and the receptive field consequently grows with depth. A smaller family is strictly local: every layer enriches the same fixed environment.

This gives the following overview:

Within each family, models may still differ in which hidden states live on nodes or edges, when those states are updated, and whether higher-order correlations are formed explicitly. These are message-passing design choices, not additional classification axes.

The equations below use \(g_{ij}\) for the fixed geometric information attached to the directed relation \(i\to j\).

1. Semi-local Message Passing: Node-Targeted Models

A node-targeted model constructs a prediction associated with a single atom \(i\):

Examples include atomic energies in machine-learning force fields and atom-centered electron-density coefficients. A structure-level energy may be formed from atomic contributions,

and forces may subsequently be obtained by differentiating that energy. The underlying prediction is still node-targeted.

In semi-local message passing, node-targeted models repeatedly update atomic features with information from neighboring centers. Different models differ in whether neighbors are combined only through aggregation or are further combined through explicit higher-order correlations.

1.1 Two-body message passing

In two-body message passing, each neighbor first produces a message independently:

The messages are then aggregated and used to update the center node:

NequIP, eSCN, and the Equiformer series (V1, V2, and V3) follow this message-passing pattern. Their Geometry differs, but their states have the same graph-level dependencies. E2Former reorganizes computations within each message to reduce edge-wise intermediates while retaining the same message-passing structure.

1.2 Many-body message passing

MACE first aggregates contributions from all neighbors into a center-local density:

It then constructs structured higher-order correlations at the center:

and uses them to update the node state:

The message-passing pattern is therefore

The key difference from two-body message passing is what happens after aggregation: MACE explicitly constructs higher-order correlations before updating the center state.

2. Semi-local Message Passing: Edge-Targeted Models

An edge-targeted model constructs a two-center prediction associated with an atomic pair:

Hamiltonian, density-matrix, and overlap blocks are typical edge-targeted quantities. Features must be constructed for every target edge. In semi-local message passing, models differ in whether edge states only read node states or also contribute to subsequent node updates.

2.1 Unidirectional node-to-edge message passing

In unidirectional node-to-edge message passing, node states build atomic environments independently:

Edge states read the endpoint node states,

but do not contribute to subsequent node updates. Edge updates can begin at different stages of the network.

Late node-to-edge message passing. This pattern first constructs mature node environments and then forms the edge features:

HamGNN performs a one-shot edge interaction after its main node updates. QHNet similarly constructs node environments first, then accumulates an edge-output state through a short branch near the end of the network. In both cases, the edge state does not contribute to node message passing.

Layerwise node-to-edge message passing. This pattern introduces a persistent edge state earlier. Each round of node message passing can then contribute to the corresponding edge state:

QHNetV2 and MACE-H follow this pattern. QHNetV2 uses two-body message passing to construct node features, whereas MACE-H combines many-body message passing on nodes with layerwise node-to-edge message passing. In both models, messages pass from nodes to edges but not from edges back to nodes.

2.2 Bidirectional node-edge message passing

In bidirectional node-edge message passing, node and edge states are both part of the main hidden features. The node update reads incident edge states,

and the updated node states then update the edges:

DeepH-E3 and LEM (DeePTB-E3) represent this family. Their node and edge states repeatedly participate in each other's updates.

3. Strictly Local Message Passing

Allegro and SLEM (DeePTB-E3) form a smaller family whose internal organization differs from semi-local message passing. Their updates are centered on a fixed neighborhood \(\mathcal N(i)\): states associated with that center may be recombined repeatedly, but an already aggregated environment from a neighboring center is never propagated back into it. Depth therefore builds richer correlations without introducing neighbors of neighbors.

Both models use center-conditioned edge states to represent a local environment. Their main difference is the Target: Allegro aggregates local edge contributions into a node prediction, whereas SLEM combines the two fixed endpoint environments into an edge prediction.

3.1 Allegro: node-targeted

Allegro maintains a hidden state \(z_{ij}^{(q)}\) for every directed center-neighbor edge \(i\to j\). Each layer aggregates the edge states sharing the same center,

then uses the resulting local environment to update each edge:

The final edge contributions are aggregated into an atomic output:

Although its hidden states live on directed edges, Allegro is node-targeted because those states ultimately form an atomic prediction. It is strictly local because \(z_{ij}^{(q)}\) only reads states associated with the fixed neighborhood \(\mathcal N(i)\).

3.2 SLEM: edge-targeted

SLEM maintains a center-local node environment \(n_i^{(q)}\), center-conditioned edge states \(V_{ij}^{(q)}\), and an output edge state \(e_{ij}^{(q)}\).

The node and center-conditioned edge states perform repeated message passing within \(\mathcal N(i)\), while the output edge combines the fixed local environments of its two endpoints. Their dependencies remain

The update centered at \(i\) never reads an already aggregated environment from \(j\). Increasing depth therefore enriches the two fixed endpoint environments without extending the receptive field to their neighbors' neighborhoods.

3.3 Allegro and SLEM

Hidden-state placement therefore does not determine the Target. Allegro uses edge states to produce a node prediction, while SLEM uses both node and edge states to produce an edge prediction. What unifies them is the fixed spatial dependency of their center-local updates.