Attention Mechanism [5] originated from research on the human visual system. When observing things, humans do not focus equally on all information; instead, they selectively concentrate on interesting or important parts, quickly capturing key information while ignoring irrelevant details. This mechanism was introduced into deep learning to improve the efficiency and accuracy of models when processing complex data. The attention mechanism includes self-attention, cross-attention, and multi-head attention.

Transformers are constructed by stacking self-attention and cross-attention modules, enabling effective modeling of global dependencies and feature correspondences. The self-attention mechanism computes attention weights over the same set of points to capture internal feature interactions, whereas cross-attention identifies correspondences between two different point sets. Formally, given a query Q, key K, and value V, the attention can be computed as:(2)Attention(Q,K,V)=softmax(QKTdk)Vwhere dk is the dimensionality of K. According to Eq. (2), the computational complexity of the Transformer architecture is quadratic, i.e., 𝒪(n2dk).

Most existing PCR networks are based on a single training session. In contrast, iterative models undergo multiple training rounds. Specifically, a training count k is preset; during each training round, the model learns from the overlapping regions of the previous pre-existing model, and this process is repeated k times to obtain the final model.

The currently most effective iterative model is AMR [10]. Formally, taking AMR as an example, let 𝒳={R,t}, meaning that 𝒳 is a combination of a rigid transformation. The iterative registration framework ℱ={fk(𝒳,⋅)∣k=1,⋯,K} updates the model as:(3)𝒳k=fk(𝒳k−1,𝒫,𝒬)which means that each model learns from the overlapping prior knowledge contained in the rigid transformation of the previous model. Eq. (3) follows the adaptive refinement paradigm established in [10], treating registration as a progressive residual update 𝒳k=Δ𝒳k∘𝒳k−1. By estimating a residual Δ𝒳k that naturally decays toward the identity matrix I as alignment improves, the iterative process functions as a contraction mapping. This property theoretically ensures monotonic convergence and prevents the accumulation of registration errors across stages.

For iterative models, the registration accuracy varies at each step. Therefore, to train models for different steps separately, a transition function 𝒯={ε(𝒳,τ)} is introduced into the model, where τ∈{1,⋯,T} represents the accuracy level: the higher the value, the greater the accuracy, and when τ=T, it corresponds to the ground-truth. For each step index k, ε(𝒳,k) produces a rigid transformation 𝒳~k−1 and further trains the registration network. Finally, the iterative model yields the final estimate 𝒳^. The transition function 𝒯={ε(𝒳,τ)} divides the transition state from the prior to the ground truth into [1,⋯,T], where each time step τ∈[1,⋯,T] corresponds to a rotation matrix Rτ and a translation vector tτ.

Since rotation matrices are nonlinear, the spherical interpolation function is used:(4)qτ=Slerp⁡(qprior,qgt;ατ)=sin⁡((1−ατ)Ω)sin⁡(Ω)qprior+sin⁡(ατΩ)sin⁡(Ω)qgtwhere qτ, qprior and qgt are quaternions of Rτ, Rprior and Rgt, Ω=arccos⁡(qprior⋅qgt) and ατ=τT. Then, convert qτ into Rτ.

Linear interpolation is employed for the translation vectors:(5)tτ=(1−ατ)⋅tprior+ατ⋅tgt

SSM consists of two equations: the state equation and the observation equation:(6){x˙(t)=Ax(t)+Bx(t)y(t)=Cx(t)+Dx(t)where x(t)∈RL is system input, L is input dimension and y(t)∈RN is hidden state, N is state dimension, A∈RN×N is state matrix, B∈RN×L is input matrix, C∈RL×N is output matrix and D∈RL×L is feed-through matrix.

Computers are adept at processing discrete signals, and in modern control theory, the zero-order hold (ZOH) is used to convert them into discrete-time state space models. Denote the sampling period as Δt, then the state matrix and the hidden matrix are converted to:(7){A¯=eAΔtB¯=∫0ΔteAτdτ⋅B=(eAΔt−I)(AΔt)−1Δt⋅B

Therefore, the discrete-time state space model can be expressed as:(8){xk=A¯xk−1+B¯xkyk=C¯hk+D¯xkwhere k is the discrete time step.

Mamba model, proposed in [12] and inspired by SSMs, extends them into selective state space models (Selective SSMs). In Mamba, the parameters A,B,C,Δt, originally defined over the core dimensions of state size N and sequence length L, are augmented with the batch size B and model dimension D, resulting in the parameter set A~,B~,C~,T~ in Mamba, and these parameters are adaptively adjusted based on the input xk. To address the parallelization challenge of the single linear model, Mamba employs a global convolution expansion:(9){K=(C~B~¯,C~A~B~¯,…,C~A~¯L−1B~¯)y=x∗Kwhere K is global convolution kernel. In this way, Mamba achieves a linear complexity, addressing the computational bottleneck of the quadratic complexity from the Transformer architecture.

As shown in Fig. 1, the iteration backbone of AMBIR consists of feature extraction, hybrid coarse registration, and sparse-to-dense fine registration in sequence.

Feature Extraction. Feature extraction is the process of deriving low-dimensional representations with discriminability, invariance, and compactness from raw point clouds. Herein, FA-KPConv [24] is utilized to encode the input point clouds into multi-scale feature representations. Let the feature map of the original point clouds be denoted as F={F𝒫,F𝒬}, where F𝒫 and F𝒬 are the feature maps of the original point clouds 𝒫 and 𝒬, respectively. For sampling levels k=0,1,2,⋯, the corresponding decoded sampled feature map is F1/k={F𝒫1/k,F𝒬1/k}. In particular, F1/4 is called semi-dense feature and F1/8 is called coarse feature. The down-sampled key points at the topmost level are referred to as superpoints, which serve as anchor points for subsequent stages.

Hybrid Coarse Registration. First, to enhance the semi-dense feature, a linear cross-attention [25] is adopted before subsequent modules. Both semi-dense feature and coarse feature superpoints need to be serialized for subsequent processing. Thus, Prior-Informed Co-aligned Serialization (PICOS) is applied to bridge the gap between unordered point clouds and sequential models. Utilizing the transformation estimate 𝒳k−1 from the previous iteration as a structural prior, the source and target point clouds are projected into semantically aligned 1-D sequences via a shared Hilbert curve, ensuring that geometrically corresponding points are mapped to proximate indices. Then, coarse feature and semi-dense feature are processed differently in the network, but can be fused [26] to enhanced semi-dense feature further:(10)F^1/4=F1/4+MLP(Nearest Up-sampling(F1/8))F^1/8=F1/8+MLP(Interpolated Down-sampling(F1/4))

For coarse feature, these synchronized sequences are passed through an encoder composed of H stacked Mamba blocks to extract hierarchical geometric features. Each block consists of layer normalization (LN), a selective state space model (SelectiveSSM) [12], depth-wise separable convolutions (DW) [27], and residual connections. The architecture is illustrated in Fig. 2, and the h-th block of H Mamba blocks can be described as:(11)Fh−1′=LN(Fh−1)Fh′=σ(DW(Linear(Fh−1′)))Fh′′=σ(Linear(Fh−1′))Fh=Linear(SelectiveSSM(Fh′)⊙Fh′′)+Fh−1where σ represents the SiLU activation function [28].

For semi-dense features, sequences are fed into the Consistency-Aware Mamba Encoder (CAME). As a lightweight alternative to the computationally expensive self-attention mechanism, CAME employs a bi-directional SSM to aggregate global geometric context with linear complexity. Crucially, an overlap-driven soft-gating mechanism is integrated to implicitly suppress features from non-overlapping regions, enhancing robustness against outliers. Finally, the enhanced semi-dense features F^𝒫∈RM′×D and F^𝒬∈RN′×D are reverted to their original spatial order and forwarded to the Spot-Guided Cross-Attention module inherited from CAST [8]. This module performs explicit feature interaction by restricting attention computations to local consistent regions, aka spots, thereby generating a reliable similarity matrix S=F^𝒫F^𝒬T. Furthermore, F^𝒫 and F^𝒬 are fed into a point-wise multilayer perceptron to calculate overlap scores by:(12)Pij=o^i𝒫o^j𝒬⋅softmaxk∈{1,⋯,M′}(Skj)i⋅softmaxk∈{1,⋯,N′}(Sik)jwhere o^i𝒫 and o^j𝒬 are overlap scores of the i-th node of and the j-th node of semi-dense feature, respectively.

Sparse-to-Dense Fine Registration. Inspired by the hierarchical strategy [8], the fine registration module employs a lightweight sparse-to-dense mechanism to achieve precise alignment without computational bottlenecks. Distinct keypoints are extracted from local patches centered at semi-dense nodes of X1/4, and their virtual correspondences y^i are predicted by aggregating features from corresponding patches in Y1/4 via a single-head attention layer. To ensure geometric robustness, a compatibility graph constructs spatial consistency constraints, enabling graph embedding layers to predict confidence weights for these sparse matches and yield an initial alignment via the weighted Kabsch algorithm. Subsequently, dense point-to-point correspondences are established between X1/2 and Y1/2 through local attention within a dynamic radius relative to the initial alignment, allowing the final incremental transformation Δ𝒳k to be solved analytically over the joint set of weighted sparse and dense correspondences.

Notably, although the sparse-to-dense fine registration introduces local attention and matching costs, it computes only within local neighborhoods or on dynamically down-sampled point sets. As a result, they effectively avoid the time complexity introduced by global attention.

As shown in Fig. 3, the registration pipeline is structured as a cascade of K adaptive refinement stages, where each stage employs an identical network architecture based on the proposed backbone but possesses independent trainable parameters tailored to specific noise distributions. To foster adaptivity, synthetic prior transformations spanning T discrete accuracy levels are generated and linearly partitioned into K groups (K < T), with the specific model index k for a given accuracy level τ assigned via k=⌈(τ/T)∗K⌉, where ⌈⋅⌉ denotes the ceiling function. During the inference phase, iterative optimization begins with an initial rigid transformation 𝒳0, which can be derived from vanilla CAST [8] rather than a random initialization. The permutation-invariance of CAST enables it to provide a reliable initial transformation without serialization, effectively avoiding problems caused by poor initialization. Then, 𝒳0 proceeds recursively, where the transformation estimation 𝒳k output by the current stage functions as the structural prior for the subsequent stage, culminating in the final high-precision alignment 𝒳K produced by the last refinement model.

To resolve this bottleneck, the strategy decouples the spatial ordering from the feature representation. The transformation estimate 𝒳k−1 from the previous iteration is utilized as a structural prior to synchronize the scanning order of the two point clouds.

Formally, the process begins by constructing a proxy point cloud 𝒫′:(13)pi′=Rk−1pi+tk−1,∀pi∈𝒫

It is crucial to note that 𝒫′ is used solely to calculate the sorting keys. The actual input features F𝒫 remain associated with the original local coordinates to prevent label leakage and ensure that the network learns the residual update Δ𝒳k.

Next, a shared canonical space Ω is established, defined as a discretized 3-D grid bounding the union of 𝒫′ and 𝒬. A Hilbert mapping function ℋ:R3→Z is defined to project 3-D coordinates to 1-D integers. The sorting keys for both clouds are computed within this unified frame:(14)κi𝒫=ℋ(pi′),κj𝒬=ℋ(qj)

Because 𝒫′ is coarsely aligned with 𝒬 by the prior, spatially overlapping regions are guaranteed to occupy identical or adjacent cells in Ω, resulting in synchronized Hilbert keys.

Finally, obtain the permutation indices π𝒫 and π𝒬 by sorting the keys κ𝒫 and κ𝒬 in ascending order:(15)π𝒫=argsort({κi𝒫∣i=1,⋯,N}),π𝒬=argsort({κj𝒬∣j=1,⋯,M})

It is worth noting that while the argsort operation introduces a theoretical time complexity of 𝒪(nlog⁡n), sorting linear arrays is highly parallelizable and heavily optimized on modern GPUs. This serialization step acts as a lightweight geometric proxy, explicitly avoiding the 𝒪(n2) bottleneck typically associated with dense compatibility graph construction.

The input features F𝒫 and F𝒬 are reordered according to π𝒫 and π𝒬 before being fed into the Mamba encoder. This operation is formally expressed as:(16)F𝒫seq=Gather(F𝒫,π𝒫),pseq=Gather(p,π𝒫)F𝒬seq=Gather(F𝒬,π𝒬),qseq=Gather(q,π𝒬)where Gather(F,π) means rearranging the rows, also features in F according to the order specified by the permutation index π.

Eq. (16) creates a siamese sequence pair where the n-th token in the source sequence and the n-th token in the target sequence likely represent geometrically neighboring regions.

In summary, PICOS enables the full selective scanning capability of the Mamba architecture to focus on comparing local features rather than learning global rotation invariance in so(3), thereby significantly improving feature-extraction accuracy. This is a property not possessed by Hilbert and Z-order curves. The pre-alignment mechanism can leverage GPU parallelism to achieve better registration performance with only a modest increase in computational overhead. In addition, in low-overlap scenarios, the shared projection ensures that the non-overlapping segments are clustered together in the sequence. This clustering enables the subsequent soft-gating mechanism to efficiently identify and suppress these segments as contiguous noise blocks, rather than scattered outliers.

Although the input features are ordered via the Hilbert curve, the standard Mamba architecture processes sequences based strictly on relative positions within the 1-D array, lacking explicit awareness of the underlying 3-D metric space. To compensate for this loss of metric information during serialization, geometric embedding is injected prior to feature aggregation.

Let F𝒫seq,F𝒬seq∈RN×C denote the feature sequence ordered by the permutation π, and pseq,qseq∈RN×3 denote the corresponding coordinate sequence. A position-encoding multi-layer perceptron MLPpos maps the physical coordinates into the high-dimensional feature space. This embedding is added to the semantic features via a residual connection:(17)F𝒫in=F𝒫seq+MLPpos(pseq)F𝒬in=F𝒬seq+MLPpos(qseq)

This operation ensures that the SSM implicit states can leverage both the sequential context and the absolute spatial distribution, facilitating the learning of distance-dependent geometric dependencies.

To emulate the outlier-rejection capability of graph-based sampling without incurring quadratic computational costs, a soft gating mechanism is introduced. This mechanism dynamically modulates the information flow into the SSM based on the estimated reliability of each point.

Let o^𝒫,o^𝒬∈RN represent the point-wise overlap scores predicted by the segmentation head. These scores are first reordered according to the serialization index π to obtain o𝒫seq,o𝒬seq. A learnable consistency gate G∈RN×C is then generated via a linear projection followed by a Sigmoid activation:(18)G𝒫=σ(o𝒫seq⋅W𝒫g+b𝒫g)G𝒬=σ(o𝒬seq⋅W𝒬g+b𝒬g)where W𝒫g,W𝒬g and b𝒫g,b𝒬g are trainable parameters. The input features are modulated via element-wise multiplication:(19)F~𝒫in=F𝒫in⊙G𝒫F~𝒬in=F𝒬in⊙G𝒬

For theoretical insight, the core recurrence of an SSM is governed by the state equation xk=A¯xk−1+B¯xk. By modulating the input xk with the gate G, here xk is F~in, the magnitude of feature vectors corresponding to non-overlapping regions, where G≈0 is suppressed. Consequently, the hidden state xk is updated primarily by features from consistent, high-overlap regions, effectively preventing background noise from propagating into the long-range global context.

Space-filling curves impose a fixed traversal direction, which introduces a directional bias in information propagation. To capture the full geometric context and ensure isotropic feature learning, a Bi-directional Mamba strategy is employed. The gated sequences F~𝒫in,F~𝒬in are each processed by two independent SSM blocks scanning in opposite directions:(20)Υ𝒫fwd=SSMfwd(F~𝒫in),Υ𝒬fwd=SSMfwd(F~𝒬in)Υ𝒫bwd=flip(SSMbwd(flip(F~𝒫in))),Υ𝒬bwd=flip(SSMbwd(flip(F~𝒬in)))here, flip(⋅) denotes the operation of reversing the sequence order. The forward scan captures dependencies from the start of the Hilbert curve, while the backward scan aggregates context from the end, ensuring that every point receives global information.

The context-enriched features from both directions are fused via element-wise addition. To facilitate gradient flow and preserve original semantic information, a residual connection with the pre-gated input is applied, followed by normalization:(21)F𝒫out=LayerNorm(F𝒫in+Linear(Υ𝒫fwd+Υ𝒫bwd))F𝒬out=LayerNorm(F𝒬in+Linear(Υ𝒬fwd+Υ𝒬bwd))

Finally, to maintain compatibility with downstream modules that rely on the original point cloud indexing (such as the explicit cross-attention module), the output sequences F𝒫out,F𝒬out are mapped back to the original spatial order using the inverse permutation π−1. This restoration step renders the CAME module structurally transparent to the rest of the network, functioning as a highly efficient, plug-and-play module that achieves comparable global routing to sparse self-attention without the quadratic cost.

In summary, the overall effective theoretical complexity of AMBIR across multiple iterations can be rigorously expressed as 𝒪(K⋅(nlog⁡n+local attention+matching)). In existing iterative frameworks, global feature aggregation typically introduces a complexity of 𝒪(K⋅n2). By contrast, the 𝒪(n) complexity of the Mamba backbone mitigates this issue, allowing AMBIR to maintain low time complexity even over multiple iterative rounds.

Inspired by Usip [29], define the loss function of keypoint detection as:(23)ℒkd=1N∑i=1N(log⁡σ~i+|pi−qj∗(i)|σ~i)+1M∑j=1M(log⁡σ~j+|qj−pi∗(j)|σ~j)where pi∈R3 and qj∈R3 are the key points from the source point cloud 𝒫 and the target point cloud 𝒬, respectively. The indices j∗(i)=arg⁡minj‖pi−qj‖ and i∗(j)=arg⁡mini‖qj−pi‖ denote the nearest neighbors. The weight term σ~ for perceptual uncertainty is calculated as the average predicted variance of two matched key points, i.e., σ~i=12(σp,i+σq,j∗(i)) and σ~j=12(σq,j+σp,i∗(j)). This loss aligns the predicted key points of the source and target point clouds in space while accounting for uncertainty.

This component supervises the hybrid coarse registration module, ensuring both the validity of the Mamba encoder and the accuracy of the Transformer interaction. It consists of spot matching loss and coarse matching loss.

Spot Matching Loss ℒs. To supervise the layer-wise coarse matching scores P(l),l∈{1,⋯,L}, the spot matching loss is adopted:(24)ℒs=−1L∑l=1L1∑(i,j)∈𝒞oij∑(i,j)∈𝒞oijlog⁡Pij(l)where 𝒞 is the ground-truth coarse correspondence set with an overlap ratio oij for each correspondence (i,j)∈𝒞.

Furthermore, when the patch centered at point x∈R3 is a spherical neighborhood of radius r, the overlapping ratio oij of the patches centered at piS∈𝒫S and qjS∈𝒬S with ground-truth rotation R∈so(3) and translation t can be calculated as:(25)oij=2π∫D/2r(r2−h2)dh4πr3/3=1−3D4r+D316r3where D=max{‖RpiS+t−qjS‖,2r}.

Coarse Matching Loss ℒc. To supervise the final coarse matching scores P, the coarse matching loss can be calculated as:(26)ℒc=−1∑(i,j)∈𝒞oij∑(i,j)∈𝒞oijlog⁡Pij−1|𝒩𝒫|∑k∈𝒩𝒫log⁡(1−o^k𝒫)−1|𝒩𝒬|∑k∈𝒩𝒬log⁡(1−o^k𝒬)where 𝒩𝒫 and 𝒩𝒬 are sets of semi-dense nodes in point clouds 𝒫 and 𝒬 without correspondences.

The total coarse matching loss is defined as ℒcm=λsℒs+λcℒc.

Three losses are employed to supervise similarity calculation, correspondence prediction, and consistency filtering, respectively.

Similarity Calculation Loss ℒsc. The InfoNCE loss [30] is adopted to maximize the similarity between the descriptors dk and dkgt of the true correspondence (k,kgt), while minimizing the similarity between the descriptors dk and dkerr of the false correspondence (k,kerr):(27)ℒsc=−E[log⁡edkTWdkgtedkTWdkgt+∑kerr∈CerredkTWdkerr]where E refers to mathematical expectation, Cerr is a negative sample constraint set defined within the spatial range of the local patch Clocal, i.e., Cerr⊂Cinclude.

Correspondence Prediction Loss ℒcp. The L2 loss supervises the predicted correspondence q^ by minimizing the following expression:(28)ℒcp=E(p,q^)‖Rp+t−q^‖2

Consistency Filtering Loss ℒcf. A binary ground-truth label is defined based on whether the distance is less than the threshold, deciding whether it is an inlier Rf>0, and binary cross-entropy is used to supervise the inlier confidence:(29)ℒcf=BCE(score,inlier~ label)where inlier label=1 when ‖Rp+t−q^‖2<Rf.

The total keypoint matching loss is ℒkm=λscℒsc+λcpℒcp+λcfℒcf.

The dense registration module is supervised using the translation loss ℒtr and rotation loss ℒrt:(30)ℒtr=‖t^−t‖2 (31)ℒrt=‖R^TR−I‖Fwhere F means Frobenius norm.

The total dense registration loss is defined as ℒdr=λtrℒtr+λrtℒrt.

To evaluate the performance of AMBIR and its advantages over other state-of-the-art methods, the experiments adopt two types of datasets: the indoor point cloud dataset 3DMatch [31], the indoor low-overlap point cloud dataset 3DLoMatch [32], as well as the large-scale outdoor point cloud datasets KITTI [33].

For the indoor datasets 3DMatch and low-overlap 3DLoMatch, the experiments adopt the evaluation metrics as follows:

Registration Recall (RR): Measures the percentage of point cloud pairs successfully aligned within a specified Root Mean Square Error (RMSE < 0.2 m);

For the outdoor large-scale datasets KITTI, the experiments also adopt the evaluation metrics from Predator [32], namely:

Relative Rotation Error (RRE): The geodesic distance between the estimated and ground-truth rotation matrices;

For a fair comparison, all models involved in the experiments were executed in the same environment, which was equipped with a 14-core Intel Xeon (R) Platinum 8362 CPU and a single NVIDIA RTX 3090 GPU with 24 GB of VRAM. All code was compiled on the Linux Ubuntu 22.04 operating system with 32 GB of RAM allocated.

AMBIR is trained using the Muon [34] optimizer with a batch size of 1, an initial learning rate of 1×10−4, and a weight decay of 1×10−4. The learning rate scheduler reduces the learning rate to 90% of its previous value every 5 steps. During backpropagation, the gradient norm is clipped to 0.5. The training loss function requires only a single step. Train the model for 5, 5, and 40 epochs on the 3DMatch, 3DLoMatch, and KITTI datasets, respectively. For 3DMatch and 3DLoMatch, the hyperparameters are set to λs=0.1,λc=1, λsc=1,λcp=10,λcf=1,λtr=5 and λrt=20. For KITTI, the hyperparameters are set to λs=0.1, λc=0.2,λsc=1,λcp=1,λcf=1,λtr=5 and λrt=20. To enhance robustness, RANSAC [35] is employed as a post-processing step to estimate transformations. K is set to 5 uniformly, resulting in 5 training steps.

As shown in Table 1, 5000, 2500, 1000, 500, and 250 points are sampled from the 3DMatch and 3DLoMatch datasets. Among them, 5000 and 2500 are categorized as dense point clouds, 1000 as medium-density, and 500 and 250 as sparse.

In the 3DMatch dataset, AMBIR achieves state-of-the-art (sota) performance in both RR and IR across various sampling numbers, while remaining on par with sota levels for FMR. Fig. 6 shows the qualitative registration results on 3DMatch dataset. Compared with the two best open-source SOTA methods, AMR and CAST, both methods exhibit local matching due to similar positions within the red-boxed region, leading to overall misalignment. In contrast, AMBIR does not suffer from this issue.

As shown in Table 2, in the 3DLoMatch dataset, the RR and IR of AMBIR significantly outperform current non-iterative models and achieve performance comparable to the AMR [10] iterative model across most sampling numbers. Regarding FMR, it ranks second only to the leading RoITr [14] model and maintains performance similar to other SOTA models. These results indicate the effectiveness of AMBIR in handling challenging low-overlap registration scenarios.

As shown in Table 3, AMBIR achieves a 100% RR on KITTI, matching the SOTA performance of recent years. In terms of RTE and RRE, AMBIR outperforms both iterative models-PEAL [9] and AMR [10]-while simultaneously reaching SOTA levels. This demonstrates that AMBIR delivers exceptional performance on large-scale point clouds while remaining highly effective in low-overlap scenarios. Fig. 7 shows the qualitative registration results of AMBIR on the KITTI dataset, where it can be seen that the performance of AMBIR is very close to the ground truth.

Benefiting from the linear attention mechanism of Mamba, as shown in Table 4, AMBIR achieves the shortest average runtime, the lowest VRAM consumption, and a reduced number of FLOPs among all compared methods. It is worth emphasizing that although AMBIR is an iterative approach, the linearization provided by Mamba enables it to achieve, or even surpass, SOTA registration performance while maintaining a relatively small resource footprint. Consequently, by leveraging Mamba modules to minimize computational overhead for large-scale PCR, AMBIR simultaneously remains highly effective for low-overlap registration tasks through its iterative framework.

K is set to 5 in Section 4.2.2. To verify the rationality of this value, a sensitivity and stability analysis of the hyperparameter K is added in this section, investigating the influence of K∈{3,4,5,6,7} on various registration metrics. As shown in Table 5, as the number of iterations K increases, both the RR and IR show an upward trend, while the average inference time of the model also rises accordingly. It can be observed that when K increases from 3 to 5, RR and IR improve significantly without incurring significant time overhead. However, when K>5, further increasing K only brings marginal improvements to RR and IR, accompanied by a substantial growth in computational cost, so the practical value of such gains is limited. Therefore, K=5 is a reasonable choice.

To verify the registration robustness of AMBIR under imperfect conditions, tests with point cloud noise and unequal point cloud density are conducted. As shown in Table 6, the integral smoothing property of the Mamba encoder acts as a spatial low-pass filter that suppresses high-frequency noise [36], and the soft-gating mechanism of CAME dynamically assigns low confidence to regions with mismatched geometric densities, preventing sparse artifacts from contaminating global feature aggregation [37]. These mechanisms enable AMBIR to maintain favorable RR values even under severe noise and density variations, providing protection against vulnerabilities under adversarial or noisy conditions.

As shown in Table 7, “w/o” indicates “without,” referring to the ablated model lacking the respective module. AMBIR consists of four essential modules: PICOS, Vanilla Mamba, CAME, and Iteration. When evaluating the RR, Average Runtime, and VRAM usage on the 3DMatch, and the RTE, RRE, RR, Average Runtime, and VRAM usage on the KITTI dataset (all with 1000 sampled points). Results show that removing any module degrades the RTE, RRE, and RR metrics. Although removing PICOS saves only a negligible amount of VRAM, it severely compromises registration performance, which is not worthwhile. Notably, while removing the iteration reduces ART and VRAM usage, it is essential for learning overlap priors in low-overlap scenarios, and its removal causes a drastic drop in registration accuracy under such conditions. The above demonstrates that each component is indispensable to the complete AMBIR registration network.

For comparative analysis between indoor and outdoor datasets, the differences in the action mechanisms of each core module under varying scale and scene conditions are elaborated. PICOS ensures consistent semantic alignment across scales. The iterative framework uncovers hidden overlaps in occluded indoor scenes and progressively reduces large translational errors in outdoor scenes. Additionally, the soft-gating of CAME dynamically suppresses repetitive indoor clutter and filters vast featureless outdoor backgrounds. Crucially, the linear 𝒪(n) Mamba backbone prevents the catastrophic memory explosion of 𝒪(n2) Transformers in large-scale outdoor tasks, while also moderately improving indoor efficiency.

To compare the impact of different serialization strategies on registration performance, the AMBIR serialization strategy is replaced, and the effectiveness of various strategies is evaluated on the 3DMatch Dataset, as shown in Table 8. It can be observed that, due to the absence of pre-alignment provided by PICOS, both the Hilbert and Z-order curve methods consume substantial network capacity when learning global rigid invariance from extremely long sequences, which severely degrades RR. The pre-alignment mechanism can leverage GPU parallel computing, requiring only a modest increase in runtime and FLOPs.