Can Large Language Models Handle High-Precision PPP-AR Development? A Practical Test Review

    Large language models can generate code that compiles and produces plausible output, but PPP-AR software demands much more: consistent handling of observations, time and coordinate systems, precise orbit and clock products, antenna corrections, error modeling, parameter estimation, ambiguity resolution, and independent validation. This article examines why PPP-AR is a demanding benchmark for LLM engineering capability, proposes reproducible accuracy metrics and staged development workflows, reviews common failure modes such as hidden unit and sign errors, and explains how to judge whether a seemingly successful result is credible and generalizable.

    In professional domains, one of the most dangerous ways to misjudge a large language model is to focus on whether the code compiles, the program runs, or the output looks reasonable. For precise point positioning, especially PPP with carrier-phase ambiguity resolution (PPP-AR), the gap between “runs” and “usable” becomes much wider. A usable system must not only understand positioning principles; it must correctly handle observation data, time systems, coordinate systems, satellite orbits, clock offsets, antenna corrections, error modeling, parameter estimation, and result validation.

    Therefore, evaluating whether an LLM is suitable for developing such software cannot rely on the length of generated code or a single successful run. It requires a reproducible, quantifiable test system that can locate the source of problems.

    1. Why PPP-AR Is a Suitable High-Difficulty Benchmark

    PPP-AR has clear inputs, outputs, and accuracy targets, which makes it well suited to an engineering capability test.

    A relatively complete test task usually includes the following requirements:

    1. Download or read real observation data from a monitoring station;
    2. Read broadcast ephemerides and auxiliary products such as precise orbit and precise clock files;
    3. Process dual-frequency or multi-frequency carrier-phase observations;
    4. Support at least several major satellite navigation systems;
    5. Implement an ionosphere-free combination or an uncombined observation model;
    6. Support both static and kinematic positioning;
    7. Estimate receiver coordinates, clock offsets, tropospheric parameters, and carrier-phase ambiguities;
    8. Support float solutions and further implement ambiguity fixing;
    9. Use an independent high-precision coordinate file as the validation reference;
    10. Output positioning results in a unified format for automated evaluation.

    The difficulty is that a systematic error in any one link can degrade the final result to meter-level accuracy or worse. For example, a reversed sign in satellite clock correction, mixed time scales, inconsistent antenna phase-center handling, unit conversion errors, or unhandled integer biases can all make the filter appear to “converge” while never reaching centimeter-level accuracy.

    In other words, PPP-AR is not merely a code-generation task. It is a comprehensive task covering algorithms, engineering implementation, and scientific validation.

    2. How to Set Reasonable Accuracy Metrics

    When evaluating the program, “it runs” and “it meets the requirements” should be separated. At least three layers of metrics are recommended.

    2.1 Pseudo-Kinematic or Rapid-Convergence Metrics

    In a simulated kinematic scenario or an epoch-by-epoch update scenario, observe how position error changes over time. After reasonable convergence, the root mean square error in the horizontal and vertical directions should reach decimeter level, and it should not occur only occasionally at isolated epochs.

    Key checks include:

    • Whether convergence time is stable;
    • Whether there is obvious bias in the east, north, and up components;
    • Whether periodic jumps occur;
    • Whether the solution can re-converge after satellite rise/set events or cycle slips;
    • Whether the filter diverges because of abnormal observations.

    2.2 Static Final Coordinate Metrics

    In static mode, the program can use a longer data span to estimate the coordinates of a fixed station. The final result should reach centimeter level and remain stable across different time periods, stations, and satellite combinations.

    Do not report only a single final coordinate. Also provide:

    • Mean and standard deviation for each direction;
    • Horizontal and vertical errors;
    • Convergence curves;
    • Number of valid observations;
    • Number of cycle slips and outliers;
    • Differences between float and fixed solutions.

    2.3 Ambiguity-Fixing Metrics

    A fixed solution is not simply the result of rounding float ambiguities. True ambiguity fixing should consider at least:

    • Ambiguity covariance;
    • Integer candidate search;
    • Integer consistency tests;
    • Ratio tests or other reliability checks;
    • Selection of inter-satellite references;
    • Cycle slips and satellite switching;
    • Fallback mechanisms after fixing failure.

    If the fixed solution appears only occasionally, or if position error becomes larger after fixing, then the function has not been truly implemented.

    3. Common Problems When LLMs Attempt Such Tasks

    3.1 Structurally Complete but Key Formulas Wrong

    Many models can quickly generate an engineering framework, including data reading, parameter configuration, filter classes, logging modules, and result output. However, accuracy is often determined by a few dozen lines of observation equations and correction models.

    Common errors include:

    • Using inconsistent units for pseudorange and carrier phase;
    • Treating observations in units of cycles as meters;
    • Ignoring the sign convention of carrier-phase observations;
    • Reversing the direction of satellite clock correction;
    • Failing to distinguish the time units of receiver clocks and satellite clocks;
    • Mixing Earth-fixed coordinates with inertial coordinates;
    • Using incorrect time interpolation for orbit positions;
    • Failing to handle phase wind-up and cycle slips correctly;
    • Incorrectly merging ambiguity parameters from different frequencies.

    These problems usually do not crash the program, but they produce stable, hidden systematic errors. As a result, they are harder to find than syntax errors.

    3.2 Masking Root Errors Through “Ablation Experiments”

    When positioning results are unsatisfactory, a common LLM behavior is to keep removing features: first ambiguity fixing, then tropospheric estimation, then some satellite systems, and finally only pseudorange positioning. This may make the program easier to run, but it does not explain the original problem.

    A correct debugging order should be:

    1. Verify that input data is parsed correctly;
    2. Verify geometric range and clock correction for a single satellite;
    3. Verify single-epoch least-squares results;
    4. Verify multi-epoch float filtering;
    5. Verify observation residuals and parameter covariance;
    6. Only then verify ambiguity fixing.

    If the model cannot explain layer by layer where the error comes from and instead keeps deleting modules, it has not truly completed debugging.

    3.3 Inability to Identify Differences from a Correct Implementation

    Providing a model with a validated reference implementation does not guarantee that it can find errors. The reason is that LLMs are often good at explaining the surface structure of code, but they do not necessarily establish the correspondence among formula, variable, unit, coordinate frame, and error propagation.

    For example, two code sections may use the same function names, but one uses seconds while the other uses nanoseconds; one outputs meters while the other outputs cycles; one uses the receiver-to-satellite direction vector while the other uses the opposite direction. Comparing variable names and control flow alone can easily lead to incorrect conclusions.

    Therefore, code comparison should be upgraded to a “semantic-level review.” At minimum, each key variable should be annotated with:

    • Physical meaning;
    • Units;
    • Coordinate frame;
    • Time reference;
    • Sign convention;
    • Source data;
    • Which observation equation it enters;
    • Which state parameter it affects.

    4. How to Design More Reliable Prompts

    A high-quality task description should not simply say “implement a high-precision positioning program.” It should specify constraints and acceptance methods.

    It is recommended to split the prompt into five parts.

    4.1 Data Scope

    State that real observation files, real orbit products, and real clock products must be used, and that simulated data must not be passed off as results. Also specify the observation file formats, compression formats, and auxiliary product types that must be supported.

    4.2 Algorithm Boundaries

    List the components that must be implemented independently, such as:

    • Observation data parsing;
    • Coordinate transformation;
    • Satellite position calculation;
    • Earth rotation correction;
    • Tropospheric model;
    • Ionospheric combination;
    • Kalman filtering;
    • Ambiguity covariance handling;
    • Integer search and fix validation.

    Also state which general mathematical libraries may be used, to avoid ambiguity about dependency boundaries.

    4.3 Configuration and Engineering Requirements

    Require configuration files to select the station, time period, satellite systems, frequency combination, and static or kinematic mode. Separate downloading, parsing, solving, and output modules. This prevents the model from piling all logic into a single source file.

    4.4 Acceptance Criteria

    Clearly define:

    • Error range after pseudo-kinematic convergence;
    • Static final coordinate error range;
    • Reliability requirements for fixed solutions;
    • Allowed failure rate;
    • Output file format;
    • Diagnostic information that must be recorded in logs.

    Without acceptance criteria, a model can easily mistake “the program runs” for “the task is complete.”

    4.5 Validation Workflow

    Require the model to generate test scripts at the same time, including unit tests, single-satellite computation tests, coordinate transformation tests, residual statistics, and final accuracy evaluation. Test code should be independent of the main program and should not rely on the main program to “prove itself correct.”

    Directly asking a model to generate a complete PPP-AR system in one pass usually has a low success rate. A more reliable approach is to proceed in stages.

    Stage 1: Data and Basic Mathematics

    First implement and validate:

    • Conversion between geodetic coordinates and Earth-centered Earth-fixed coordinates;
    • Satellite position interpolation;
    • Time system conversion;
    • Geometric range between receiver and satellite;
    • Earth rotation correction;
    • Basic residual calculation.

    Do not add ambiguity fixing at this stage.

    Stage 2: Pseudorange Single-Point Positioning

    Use pseudorange observations to complete single-point positioning and check whether the results reach a reasonable order of magnitude. If this stage is still clearly incorrect, adding carrier phase will only amplify the problem.

    Stage 3: Float PPP

    Add carrier phase, combination observations, tropospheric parameters, and ambiguity states. At this stage, focus on residuals, covariance, and convergence curves rather than rushing toward a fixed solution.

    Stage 4: Cycle Slips and Outlier Handling

    Implement cycle-slip detection, satellite loss-of-lock handling, observation rejection, and state reset. The stability of a precise positioning program often depends on these engineering details.

    Stage 5: Ambiguity Fixing

    After the float solution is stable, add integer search and fix decisions. Before fixing, check whether the ambiguities have sufficient observability, and retain the float solution when fixing fails.

    Stage 6: Multi-Station Cross-Validation

    Test with at least multiple public stations, multiple time periods, and different satellite visibility conditions. Success at a single station does not prove that the algorithm is generally applicable.

    6. How to Judge Whether a “Success” Is Credible

    A centimeter-level result is not enough to prove that a model has reliable development capability. Several questions still need to be answered:

    • Does it remain valid after changing the station?
    • Does it remain valid after changing the observation time?
    • Does it run stably after removing a satellite system?
    • Can it recover after a cycle slip?
    • Has the fixed solution been independently validated?
    • Does the result depend on a special data file?
    • Are there hidden hard-coded coordinates or parameters?
    • Is the reported fixing rate consistent with the actual error?

    Be especially wary of special judgments added just to pass one test. For example, a program may load preset coordinates based on a station name or adjust biases according to a known result. Such implementations may look highly accurate, but they lack generalization capability.

    7. An Objective Assessment of LLM Capabilities

    This type of task shows that LLMs usually have clear advantages in the following areas:

    • Rapidly building engineering frameworks;
    • Generating configuration and logging modules;
    • Explaining common algorithms;
    • Writing data structures and interface code;
    • Adding routine handling based on error messages;
    • Helping organize test workflows.

    However, human experts still need to strictly review the following areas:

    • Physical correctness of observation equations;
    • Consistency of units and signs;
    • Coordinate, time, and reference-frame transformations;
    • Semantic identification of precise products;
    • Covariance and error propagation;
    • Reliability determination for integer ambiguities;
    • Handling of anomalies in real data.

    Therefore, an LLM is better suited to being a “high-efficiency engineering collaborator” than an algorithm expert that requires no verification. In fields such as high-precision positioning, financial computing, industrial control, and scientific computing, code review must return to formulas, data, and independent experiments.

    Conclusion

    Evaluating whether an LLM can complete complex technical tasks should not stop at surface indicators such as whether its answers are fluent, whether the code is complete, or whether the program compiles. For a high-barrier problem such as PPP-AR, a meaningful evaluation should cover algorithm correctness, engineering completeness, debugging capability, result stability, and cross-data generalization.

    If a model can generate a large amount of code but cannot explain the source of errors, cannot identify unit and sign problems, and cannot complete positioning even with the help of a reference implementation, then it is more like a code-draft generator than a reliable professional development assistant. Conversely, only when a model can work according to a layered validation workflow and provide reproducible evidence for every key result does it qualify for use in the development of high-precision scientific computing software.