Comparative Analysis of Factor Graph Models for Carrier Phase-Based Precision Navigation ^†

Abstract

Factor graph optimization (FGO) has emerged as a powerful alternative to Kalman filtering for high-precision GNSS positioning, particularly under challenging conditions. Its modular structure allows for the seamless integration of motion constraints, ambiguity modeling, and multi-sensor data across diverse platforms and environments. This study reviews recent FGO architectures for high-precision GNSS methodologies (PPP, RTK), comparing ambiguity management strategies, measurement factor designs, and robust optimization techniques. We compare strategies for modeling ambiguities within the graph and evaluate how they interact with measurement factor design, cycle slip detection, and integer ambiguity resolution (IAR). Trade-offs in ambiguity management and optimization techniques are discussed to guide future design choices.

1. Introduction

Carrier phase-based Global Navigation Satellite System (GNSS) techniques—such as Precise Point Positioning (PPP) and Real-Time Kinematic (RTK)—enable high-accuracy positioning and are widely used in autonomous systems. Traditionally, these rely on Kalman filters (KFs), including the extended KF (EKF), due to their recursive formulation, computational efficiency, and ability to model GNSS observations with Gaussian errors [1]. However, in environments with multipath, signal blockages, or intermittent measurements—common in urban or forested areas—KF-based estimators degrade significantly.

EKF assumes a first-order Markov process and Gaussian noise, but real-world GNSS data often exhibit non-Gaussian, time-correlated characteristics [2,3]. Outliers may be misclassified due to EKF’s single-step Jacobian evaluations and limited uncertainty modeling. For applications requiring fast, robust, and accurate positioning—such as Unmanned Aerial Vehicle (UAV) navigation or autonomous driving—these limitations, combined with the slow convergence of PPP, are critical. One way to enhance robustness is by augmenting the state with previous epochs, but a blind, multi-epoch EKF generalization increases state size and slows convergence [4].

In parallel, the robotics and autonomy communities have increasingly adopted factor graph optimization (FGO) for nonlinear state estimation problems. FGO frames estimation as a probabilistic graphical model, with measurements as factors and estimated states as variable nodes. This structure enables robust optimization and fusion of heterogeneous sensor modalities [5]. Factor graphs have been highly effective in simultaneous localization and mapping (SLAM), visual-inertial odometry, and motion planning [6], thanks to their modularity, scalability, and use of sparse sensor constraints.

Despite this success, FGO adoption in GNSS remains limited—especially for high-precision, carrier phase-based positioning. Most GNSS-FGO work targets coarse positioning or multi-sensor fusion. Fewer studies model raw carrier phase measurements directly or incorporate integer ambiguity resolution (IAR), a key enabler for fast, reliable, high-precision GNSS, within the factor graph framework.

This paper addresses these gaps through the following contributions:

• A comparative analysis of FGO architectures tailored for PPP and RTK.
• Investigation of ambiguity handling strategies and their impact on robustness and computational cost.
• Comparison of FGO-based implementations against traditional KF approaches across varied scenarios, including light and deep urban settings.

In summary, factor graph methods offer a robust, scalable alternative to Kalman filtering, supporting high-precision GNSS navigation in complex environments.

2. Factor Graph Optimization for GNSS

Here, we introduce the FGO formulation for GNSS, outlining how system dynamics, measurements, and priors are encoded to enable efficient probabilistic inference.

2.1. GNSS State Estimation

2.1.1. What Is a Factor Graph?

A factor graph is a bipartite undirected graph and can be used as a general tool to model factorizations of large functions with many variables into smaller local subsets. Factor graphs contain two node types: factor nodes and variable nodes. Factor nodes represent measurements and system dynamics (i.e., probabilistic evolution constraints). Variable nodes, or hidden variables, represent variables that are to be estimated. While in most cases these variables are discrete state variables, they can also approximate the continuous-time system state, e.g., using spline or Gaussian process regression [7].

In the context of GNSS-based localization, variable nodes represent the unknown vehicle state x(k), while factor nodes encode measurements z(k) as well as the relations between variable nodes (e.g., via a state transition model). The discrete dynamic system can be described as in [8], using a dynamics function h^DYN that maps the system state at time k to k + 1 based on control inputs u(k), and a measurement function h that maps the system state to expected observations. The Jacobians F_k and H_k are the gradients of f and h with respect to x(k), respectively. A prior belief over the initial state x(0) is encoded by γ. Sources of uncertainty are modeled as white noise: process noise $\mathit{v}~N\left(\mathbf{0},{\mathit{Q}}_k\right)$, measurement noise $\mathit{\eta }~N\left(\mathbf{0},{\mathit{R}}_k\right)$, and prior uncertainty $\mathit{\xi }~N\left(\mathbf{0},{\mathit{\Xi }}_{\mathbf{0}}\right)$.

2.1.2. Graph Optimization

Since factor graph edges connect each factor to the hidden variables influencing it, the maximum likelihood problem becomes

$$\widehat{\mathsf{\chi }}=\arg \underset{\mathsf{\chi }}{\max }\prod _{f\in \mathcal{F}}P\left(f∣\mathcal{N}\left(f\right)\right),$$

(1)

where $\mathcal{F}$ is the set of factors, and $\mathcal{N}\left(\mathrm{f}\right)\subseteq \mathsf{\chi }$ are the neighboring nodes. Assuming Gaussian factors and omitting the normalizing constants, taking the negative logarithm transforms Equation (1) into a weighted least-squares problem with Mahalanobis-weighted terms:

$$\widehat{\mathsf{\chi }}=\arg \underset{\mathsf{\chi }}{\min }{\displaystyle \frac{1}{2}}{\parallel \mathit{x}\left(0\right)-\mathsf{\gamma }\parallel }_{{\mathit{\Xi }}_0}^2+{\displaystyle \frac{1}{2}}\sum _{k=0}^{N-1}\parallel \mathit{x}\left(k+1\right)-h^{\mathrm{D}\mathrm{Y}\mathrm{N}}\left(\mathit{x}\left(k\right),\mathit{u}\left(k\right)\right){\parallel }_{{\mathit{Q}}_k}^2+{\displaystyle \frac{1}{2}}\sum _{k=0}^N{\parallel \mathit{z}\left(k\right)-h\left(\mathit{x}\left(k\right)\right)\parallel }_{{\mathit{R}}_k}^2.$$

(2)

The factor graph structure yields sparse Jacobians. At each nonlinear iteration of Gauss–Newton or Levenberg–Marquardt, linearization produces normal equations whose sparsity pattern can be exploited via careful variable reordering.

GNSS factor graphs may be solved via batch, incremental, batch fixed-lag (FL), or incremental FL methods. Batch optimization processes the full graph and is suitable for post-processing [9]. Incremental methods, such as iSAM2 [10], update the solution as new data arrives, maintaining sparsity via incremental variable reordering and Bayes tree updates. FL smoothing maintains a sliding window, pruning older states to bound computational cost while preserving temporal correlations via marginalization. Incremental FL combines both methods, balancing memory usage and latency, with only a modest sacrifice in accuracy compared to full batch smoothing.

In SLAM or GNSS positioning, where state connectivity is sparse, FGO can scale close to O(N) (N = graph size) with incremental solvers like iSAM2 or conjugate gradient [5,8]. Poor variable ordering can increase the effective density of the system, leading to more expensive computations and, in extreme cases, O(N³) scaling.

2.2. Measurement Factors in GNSS

Factor graph formulations for GNSS estimation typically include factors for measurements or constraints such as pseudorange, Doppler velocity, range rate (differential), carrier phase, ambiguity resolution, and motion models. Single differenced (SD) and double differenced (DD) factors can be constructed for pseudorange, carrier phase, or ambiguities. Motion model factors may also incorporate data from IMU, wheel odometry, speed sensor, vision, or Light Detection and Ranging (LiDAR).

2.2.1. Pseudorange

The measurement factor for a pseudorange observation on carrier frequency q depends on the measurement model, which can be expressed as

$$h_{i,P_q}^j\left(k\right)={\rho }_i^j\left(k\right)+\mathrm{c}\left(t_i\left(k\right)-t^j\left(k\right)\right)+m_i^j\left(k\right)T_i\left(k\right)+{\mu }_q^2{I}_i^j\left(k\right)+l_{i,P_q}^j\left(k\right)+{\epsilon }_{i,P_q}^j\left(k\right).$$

(3)

The first term ${\rho }_i^j\left(k\right)=\parallel {\mathit{p}}^j\left(k\right)-{\mathit{p}}_i\left(k\right)\parallel$ denotes the Euclidean geometric range between satellite j and user i. The second term captures clock biases between the satellite clock at transmission time $t^j\left(k\right)$ and the receiver clock at reception time $t_i\left(k\right)$. The third term models tropospheric delays using the zenith delay $T_i\left(k\right)$ and a standard mapping function $m_i^j\left(k\right).$ In the fourth term, the slant ionospheric delay on the reference GPS L1 signal is denoted by $I_i^j\left(k\right)$, and the frequency-dependent coefficient is ${\mu }_q^2={\left(f_1/f_q\right)}^2$. The term $l_{i,P_q}^j$ includes modeled corrections (e.g., satellite DCBs), while ${\epsilon }_{i,P_q}^j\left(k\right)$ captures unmodeled errors, such as Non-Line-of-Sight (NLOS), multipath, and receiver noise.

Given the measurement model, the pseudorange error function can be written as

$${\parallel e_{i,P_q}^j\left(k\right)\parallel }_{\sum _{i,P_q}^j\left(k\right)}^2={\parallel P_{i,q}^j\left(k\right)-h_{i,P_q}^j\left(k\right)\parallel }_{\sum _{i,P_q}^j\left(k\right)}^2,$$

(4)

where $\sum _{i,P_q}^j\left(k\right)$ is the corresponding covariance (1 × 1 matrix), and $P_{i,q}^j\left(k\right)$ are the raw pseudorange measurements. Urban GNSS suffers from multipath and NLOS errors, violating Gaussian noise assumptions. Beyond robust loss functions (e.g., Huber, Cauchy), switchable constraints (SCs) help by attaching a switch function $\omega \left(k\right)=\Phi \left(s\left(k\right)\right)$ to each measurement, encouraging downweighting of inconsistent data rather than hard rejection [11]. This approach is especially effective in tree-lined or urban environments where EKFs often misclassify non-Gaussian errors. For pseudoranges, the switched error term reads

$${\parallel e_{i,S{P}_q}^j\left(k\right)\parallel }_{\sum _{i,P_q}^j\left(k\right)}^2=\parallel \Phi \left(s_{i,q}^j\left(k\right)\right)(P_{i,q}^j\left(k\right)-h_{i,P_q}^j\left(k\right)){\parallel }_{\sum _{i,P_q}^j\left(k\right)}^2$$

(5)

To avoid rejecting all observations, a switch prior anchors s(k) near 1, where the prior covariance influences overall robustness. Since GNSS measurements from the same satellite are temporally correlated, switch states often persist across epochs—a property that can be captured using switch transition factors.

2.2.2. Carrier Phase

Many FGO-PPP implementations adopt the undifferenced (UD), uncombined (UC) approach, where raw carrier phase observations $L_{i,q}^j\left(k\right)$ contribute factors of the form

$${\parallel e_{i,L_q}^j\left(k\right)\parallel }_{\sum _{i,L_q}^j\left(k\right)}^2=\parallel L_{i,q}^j\left(k\right)-h_{i,L_q}^j\left(k\right){\parallel }_{\sum _{i,L_q}^j\left(k\right)}^2.$$

(6)

Here, $\sum _{i,L_q}^j\left(k\right)$ is the covariance, and $h_{i,L_q}^j\left(k\right)$ is constructed analogously to Equation (3) [1].

2.2.3. DD Pseudorange and DD Carrier Phase

RTK relies on a DD technique for pseudoranges and carrier phase observables between a base station b and a rover i. For a given satellite j, DDs denote the difference between SDs of a reference satellite rs and another satellite j on a frequency band q:

$$\mathrm{D}\mathrm{D}=\Delta \nabla ={{\left(\mathrm{\ast }\right)}^j}_{\mathrm{i},\mathrm{q}}-{{\left(\mathrm{\ast }\right)}^j}_{\mathrm{b},\mathrm{q}}-\left[{{\left(\mathrm{\ast }\right)}^{rs}}_{\mathrm{i},\mathrm{q}}-{{\left(\mathrm{\ast }\right)}^{rs}}_{\mathrm{b},\mathrm{q}}\right],$$

(7)

where the symbol “$\mathrm{\ast }$” is a placeholder for the pseudorange or carrier phase. The DD pseudorange factor has an error term of the form

$${\parallel e_{i,\Delta \nabla P_q}^j\left(k\right)\parallel }_{\sum _{i,\Delta \nabla P_q}^j\left(k\right)}^2=\parallel {\Delta \nabla P}_{i,q}^j\left(k\right)-{\Delta \nabla h}_{i,P_q}^j\left(k\right){\parallel }_{\sum _{i,{\Delta \nabla P}_q}^j\left(k\right)}^2,$$

(8)

The DD covariance is denoted by $\sum _{i,\Delta \nabla P_q}^j\left(k\right)$, and the DD pseudorange measurements are denoted by ${\Delta \nabla P}_{i,q}^j\left(k\right)$. The DD carrier phase factor is derived correspondingly.

2.2.4. Dynamics Model

The dynamics or motion model factor encodes state evolution and regularizes the solution. A typical state transition is given by

$${\mathit{x}}_i\left(k+1\right)=h^{\mathrm{D}\mathrm{Y}\mathrm{N}}\left({\mathit{x}}_i\left(k\right)\right)+N\left(0,{\mathsf{\Sigma }}_{\mathrm{i},\mathrm{D}\mathrm{Y}\mathrm{N}}\left(k\right)\right),$$

(9)

where ${\mathsf{\Sigma }}_{\mathrm{i},\mathrm{D}\mathrm{Y}\mathrm{N}}\left(k\right)$ is the covariance. The function $h^{\mathrm{D}\mathrm{Y}\mathrm{N}}$ depends on the sensors used and design choices. Without aiding sensors, kinematic models like constant velocity (a.k.a. random walk on velocity) or position models can evolve the vehicle state, depending on typical operational conditions.

2.3. Code-Based Factor Graph Formulations

For FGO code-based GNSS formulations, only pseudorange and motion model factors are used (see Section 2.2.1 and Section 2.2.4). Accuracy improvements over Kalman filtering are well-documented, especially under challenging conditions, with Root Mean Square Error (RMSE) reductions of 20–30%, and up to 50% in some cases [10,12,13]. Gains stem from improved outlier rejection, temporal correlation capture, and better handling of complex priors and dynamic models, boosting robustness to intermittent GNSS visibility.

3. Factor Graph Formulations for High-Precision GNSS Positioning

This section extends FGO to high-precision GNSS—RTK, PPP, and PPP-RTK—focusing on architecture and ambiguity handling. Systems integrating vision or LiDAR-based INS, which involve distinct design choices, are beyond our scope.

3.1. Factor Graph Architectures for RTK

Despite improvements in robustness and temporal consistency, code-based methods remain limited by the low accuracy of pseudorange observations. This motivates the integration of high-precision carrier phase data into FGO frameworks. The underlying structure of factor graph architectures for RTK can be illustrated schematically, as shown in Figure 1 (right panel). The DD pseudorange (see Section 2.2.3), switch prior, and switch transition factors (see Section 2.2.1) are depicted as colored squares, while the vehicle state and switch variables are represented by circles. On top of the code-based architectural components, for RTK FGO, the state vector is augmented by DD ambiguities, which are constrained by corresponding DD carrier phase factors (see Section 2.2.3).

Common approaches to addressing the integer ambiguity problem in RTK FGO are summarized in

Table 1. Comparison of carrier phase float ambiguity-handling strategies in RTK-FGO across key characteristics. In the second column, the approaches are grouped into either node-handling methods that explicitly model the temporal evolution of ambiguity states or factor-level constraints. Often, a combination of multiple strategies is employed to balance accuracy, robustness, and computational efficiency.

Strategy	Type of Approach	Per-Epoch Node Required	Response to Cycle Slips	Implementation Complexity	Float Ambiguity Accuracy	Computational Cost
Random Walk	Node Evolution	Yes	Reinitialize Node	Low	Low	Medium
Random Constant Variable	Node Evolution	No	Add New Node	High (indexing, etc.)	Medium	Low
SD Ambiguity Factor	Factor Constraint	Yes	SD Constraint Still Applied	Medium	Medium	Medium
DD Ambiguity Factor	Factor Constraint	Yes	No DD Constraint Across Slip	Medium	Medium	Medium
IAR Factor	Factor Constraint	No	No IAR Constraint Across Slip	Medium	High	High (if iterative)

and compared across key characteristics, such as response to cycle slips and float ambiguity accuracy. Node-handling techniques model ambiguities directly in the state vector and manage their evolution across time. A random walk assumption, as is common for the receiver clock bias, treats ambiguities like time-varying states, leading to a new ambiguity node at every epoch. Modeling ambiguities as random constant variables better reflects the reality that ambiguities are constant within a continuous arc, leading to only one ambiguity state per satellite per arc and more sparsely populated Jacobians [14]. When a cycle slip is detected, the state is reinitialized. Some frameworks apply comprehensive ambiguity propagation across a sliding window with four operations—adding, merging, separating, and sliding—and use marginalization to propagate ambiguity priors efficiently [15]. This enables reduced window sizes (from 10 to 4 epochs) with over 50% optimization speed-up.

Factor-level constraints offer an alternative approach when ambiguities are estimated on a per-epoch basis. SD ambiguity factors anchor rank-deficient DD ambiguities, while DD ambiguity factors enforce epoch-to-epoch consistency when slips are absent [16,17]. These improve accuracy and IAR fix rates compared with EKF-RTK [17], contingent on the reinitialization of ambiguity nodes following cycle slip detection. Efficient cycle slip detection methods include statistical testing (e.g., solution separation [16]) to segment arcs or remove carrier phase outliers. Although not a factor graph method, Contemplative Real Time (CRT) [2] shares the same batch-processing foundation and constructs integer-free phase constraints by likewise grouping measurements into phase tracks.

Finally, once the float ambiguities are estimated in the graph, they can be resolved to integers in external modules using methods such as Least-squares AMBiguity Decorrelation Adjustment (LAMBDA) [15,18]. While this can improve 3D RMSE by over 60% even without cycle slip detection, the lack of graph integration and temporal propagation limits robustness in degraded signal environments. To address this, hard integer constraints after successful IAR can be directly incorporated into the factor graph in subsequent optimizations. Some approaches perform a single re-optimization [17], while others propose an iterative GNSS-only graph update requiring just 2–3 iterations on average [19]. Despite the iterative nature, real-time performance at 1 Hz can be maintained. Both achieve improved consistency and robustness, with reported improvements exceeding 80% in 2D RMSE over standard EKF-based RTK in urban settings. IAR factors can also be inserted dynamically without any re-runs [20]. We thus list IAR factors in Table 1 as a float ambiguity handling strategy and visualize them in Figure 1 (see Section 3.2 for PPP).

Two related but distinct strategies include time-relative RTK (TR-RTK) and cycle slip-aware RTK. TR-RTK approaches [21,22] require no base station and no additional sensor, only time-relative DD carrier phase estimates over a time difference $\Delta t$, which can be as large as two minutes. If the TR DD integer ambiguities are resolved via LAMBDA, a loop closure constraint is generated between two vehicle states. While effective in benign environments, TR-RTK is less flexible in handling dynamics or re-initialization events associated with cycle slips. Meanwhile, cycle slip-aware RTK estimates cumulative cycle slips directly, leveraging TDCP factors to maintain relative position [23]. Both are well suited for relative navigation, rather than absolute high-precision positioning.

3.2. Factor Graph Architectures for PPP and PPP-RTK

While classical PPP relies on precise satellite orbit and clock products, it often suffers from long convergence times and limited robustness in urban environments. Recent work integrates PPP and PPP-RTK within FGO frameworks to improve both convergence and accuracy, especially by leveraging ambiguity resolution and additional constraints.

A factor graph schematic for UD, UC PPP, is shown in Figure 1 (left panel). In contrast to RTK-FGO, which incorporates DD ambiguities alongside DD pseudoranges and carrier phases (see Section 3.1), the PPP factor graph employs UD ambiguities in the state vector, with (switched) pseudorange and carrier phase factors (see Section 2.2.2) defining the architecture. PPP-RTK implementations offer significantly faster convergence but also require constructing tropospheric and ionospheric factors using data from a network of reference stations.

Table 2 provides a comparative overview of recent FGO-based PPP(-RTK) implementations across various applications (low-cost vs. high-end) and environments (open sky, light urban, and deep urban). It highlights key differences in observable models (e.g., ionosphere-free (IF) vs. UC), factor graph design, robustness strategies, optimization modes, computational cost, and positioning performance. Apart from the substitution of SD and DD ambiguity factors by UD ambiguity factors, the strategies to deal with carrier phase ambiguities encountered for RTK-FGO in Table 1 remain valid for PPP(-RTK) FGOs.

The majority of FGO works for PPP(-RTK) employ the random constant variable assumption and use the ambiguity propagation operations, adding, merging, separating, and sliding [9,24,25,26,27]. Inserting hard integer constraints after successful IAR is also a common approach, for both UC PPP [24] and IF PPP [9], using either dynamic graph updates or multi-stage optimization schemes. It is important to note that the random constant variable assumption can be used in combination with inserting explicit IAR factors [9,24], as also visualized in Figure 1.

Faster convergence to a steady state has been observed for graph-based optimizers compared to EKF-based approaches [25]. This effect of reduced convergence is expected to be more pronounced when leveraging multi-constellation and multi-frequency GNSS data, which enhance satellite geometry and measurement redundancy, thereby strengthening the multi-epoch constraints within the optimization framework. Similar to RTK-FGO implementations [17], recent work reports improved IAR fix rates for FGO-based PPP-RTK compared to its EKF-based counterpart [26].

Table 2. Comparison of FGO-based PPP and PPP-RTK implementations. Ambiguity-handling strategies are described in Table 1. and associated text; Xin et al. (2023) [28] implement a loosely coupled PPP-B2b/INS model without measurement-level float ambiguity handling. Runtime denotes per-update compute time at 1 Hz sampling rate. Robust optimization strategies include switch constraints, robust loss functions and max-mixtures; Xin et al. (2024) [26] employ the Cauchy M-estimator. Relative accuracy reflects 2D or 3D RMSE gains over equivalent EKF-based implementations. Accuracy stars: ★ = meter-level, ★★ = sub-meter, ★★★★ = centimeter-level. Abbreviations: PR = pseudorange, CP = carrier phase, RCV = random constant variable, AF = atmospheric factor, IFAF = ionosphere-free ambiguity factor.

Paper	Sensors	PPP Variant	Ambiguity Handling	FGO Factors	Robust Method	Mode	Runtime [ms]	Accuracy, Environment	Relative Accuracy
Watson & Gross [25]	GNSS	IF, PPP	RCV	PR, CP, Dynamics	No	Incremental	N/A	★★ Open Sky	+74% 3D
Xin et al. (2024) [26]	GNSS	UC, PPP-RTK	RCV	PR, CP, AFs Doppler	Yes	Batch FL	100–1000	★ Deep Urban	+40% 2D
Li et al. (2024) [24]	GNSS	UC, PPP-RTK	RCV, IAR Factor	PR, CP, TDCP, IAR, AFs	No	Batch FL	130	★★★★ Light Urban	+43% 3D
Xiao et al. (2024) [9]	GNSS	IF, PPP	RCV, IAR Factor	PR, CP, IAR	No	Batch	N/A	★★★★ Open Sky	−10% 3D
Xin et al. (2023) [28]	GNSS, IMU	IF, PPP-B2b	N/A	Position, IMU	No	Batch FL	90–100	★★ Deep Urban	+21% 3D
Zhang et al. (2024) [27]	GNSS, IMU	IF, PPP	Ambiguity Factor	PR, CP, IMU, Doppler, IFAF	No	Batch FL	N/A	★ Deep Urban	+19% 3D

Table 2. Comparison of FGO-based PPP and PPP-RTK implementations. Ambiguity-handling strategies are described in Table 1. and associated text; Xin et al. (2023) [28] implement a loosely coupled PPP-B2b/INS model without measurement-level float ambiguity handling. Runtime denotes per-update compute time at 1 Hz sampling rate. Robust optimization strategies include switch constraints, robust loss functions and max-mixtures; Xin et al. (2024) [26] employ the Cauchy M-estimator. Relative accuracy reflects 2D or 3D RMSE gains over equivalent EKF-based implementations. Accuracy stars: ★ = meter-level, ★★ = sub-meter, ★★★★ = centimeter-level. Abbreviations: PR = pseudorange, CP = carrier phase, RCV = random constant variable, AF = atmospheric factor, IFAF = ionosphere-free ambiguity factor.

Paper	Sensors	PPP Variant	Ambiguity Handling	FGO Factors	Robust Method	Mode	Runtime [ms]	Accuracy, Environment	Relative Accuracy
Watson & Gross [25]	GNSS	IF, PPP	RCV	PR, CP, Dynamics	No	Incremental	N/A	★★ Open Sky	+74% 3D
Xin et al. (2024) [26]	GNSS	UC, PPP-RTK	RCV	PR, CP, AFs Doppler	Yes	Batch FL	100–1000	★ Deep Urban	+40% 2D
Li et al. (2024) [24]	GNSS	UC, PPP-RTK	RCV, IAR Factor	PR, CP, TDCP, IAR, AFs	No	Batch FL	130	★★★★ Light Urban	+43% 3D
Xiao et al. (2024) [9]	GNSS	IF, PPP	RCV, IAR Factor	PR, CP, IAR	No	Batch	N/A	★★★★ Open Sky	−10% 3D
Xin et al. (2023) [28]	GNSS, IMU	IF, PPP-B2b	N/A	Position, IMU	No	Batch FL	90–100	★★ Deep Urban	+21% 3D
Zhang et al. (2024) [27]	GNSS, IMU	IF, PPP	Ambiguity Factor	PR, CP, IMU, Doppler, IFAF	No	Batch FL	N/A	★ Deep Urban	+19% 3D

4. Discussion and Recommendations

Overall, FGO strategies for carrier phase-based high-precision GNSS positioning show that integrating ambiguity modeling, motion constraints, and multi-sensor data can substantially enhance positioning quality, increase IAR fix rates, and reduce PPP convergence time while maintaining real-time viability. Our review of recent architectures shows that the performance gains of FGO stem from its ability to achieve the following:

• Explicitly capture temporal correlations across epochs;
• Flexibly constrain ambiguity states and propagate resolved ambiguities;
• Incorporate robust loss functions and switch constraints for outlier mitigation;
• Integrate diverse sensor modalities, including IMU, visual, and LiDAR data.

To reduce computational burden and maintain real-time viability, modern solvers often use a fixed-lag approach and/or incremental techniques (e.g., iSAM2) that scale efficiently with graph size. However, robust performance still depends on careful outlier mitigation and ambiguity management, particularly in challenging signal conditions.

Several strategies for ambiguity management were reviewed. Both the random constant variable approach and ambiguity factor modeling naturally respond to detected cycle slips. If cycle slip detection is not available, resolving ambiguities independently at each epoch post-optimization can still yield over 60% improvement in 3D RMSE compared to EKF. Finally, adding hard integer constraints from IAR directly into the factor graph can lead to 3D RMSE gains of more than 80% over EKF, and iterative GNSS-only graph update methods may still align with 1 Hz GNSS real-time capability. The design trade-offs between computational cost and robustness must be carefully weighed depending on application constraints, and factor graph optimization offers a flexible and extensible framework for navigating this design space.