AI-Assisted Symbolic Computation: Reproducing a Hundred-Page Tensor Derivation in About Ten Hours

1. The Real Bottleneck Is Bookkeeping, Not Compute

High-order quantum gravity calculations are widely regarded as high-barrier work in theoretical physics. Take the one-loop effective action as an example. Researchers must enumerate all topologically inequivalent Feynman diagrams, write down the amplitudes, handle the tensor structure in curved spacetime, complete a large volume of index contractions and integral expansions, and then isolate the divergent terms and construct counterterms.

The difficulty comes from three problems stacking on top of each other:

• The number of diagrams grows exponentially with the number of vertices.
• The Lorentz indices carried by each amplitude produce a combinatorial number of intermediate terms during contraction.
• Curved spacetime lacks the translational symmetry of flat spacetime. Momentum handling therefore becomes more involved, and practitioners typically introduce dimensional regularization (for example, d = 4 − 2ε) together with a minimal-subtraction-type scheme.

At this scale, the main cost of manual calculation is not “failing to think of an approach.” It is bookkeeping: keeping sign conventions consistent across several hundred pages of derivation, making intermediate results reusable, and avoiding transcription errors.

A publicly described case illustrates exactly this point. A researcher handed the roughly 500-page derivation from his PhD work to an LLM-based AI coding tool for re-execution, and after about ten hours obtained the complete symbolic derivation along with dozens of reproducible numerical checks. The specific numbers should not be treated as an industry benchmark, but the structure of the workflow has broad reference value.

2. Why Sequence Models Are Good at Mechanical Derivation

Symbolic derivation is highly decomposable in structure. A large goal is broken into a chain of continuous applications of local transformation rules: expansion, reduction, contraction, reordering, and simplification identities. Large models have learned the patterns of these transformations from massive literature, so they are relatively strong at predicting “which transformation should be applied next.” The algebraic equivalence that genuinely requires deterministic guarantees can be handed off to a computer algebra system.

There is a key engineering division of labor here: the model proposes candidates and plans the path, while the deterministic engine executes and decides. Pinning reliability on probabilistic generation inevitably produces hallucinated formulas. Pinning reliability on an assertion chain instead turns the model into a high-quality “step proposer” whose mistakes are intercepted immediately.

3. A Reusable Four-Step Workflow

Step 1: Make the physics conventions explicit (spec first). Metric signature, dimensional conventions, subtraction scheme, action coefficients, gauge-fixing conditions, field definitions, and index summation ranges should all be written into a machine-readable specification file, with corresponding test cases generated from it. Unclear conventions are the root cause of undecidable results: two symbolic derivations may both be “correct” while answering different questions.

Step 2: Atomize the derivation. Each subtask is allowed only a single goal, a single output, and a single acceptance criterion. For example: amplitude enumeration → projector action → tensor reduction → integral reduction to standard master integrals → ε expansion → divergence separation → counterterm subtraction → organization of the finite part. Each intermediate result is written to disk as a structured file, supporting rollback and step-by-step diff comparison.

Step 3: Close the loop with two validation channels. The symbolic channel checks identities, symmetries, and dimensional consistency. The numerical channel substitutes concrete random values for the tensors in an expression, recomputes with high-precision arithmetic, and compares the result against the original path.

Effective numerical validation has four requirements:

• Randomize the parameters so that equality cannot happen by coincidence.
• Use high-precision floating point to cover the severe cancellation between divergent-term coefficients.
• Set a relative tolerance rather than an absolute tolerance.
• Cover limiting cases: mass tending to zero, dimension tending to 4, and external momenta approaching special configurations.

Step 4: Turn human review into a checklist. Dimensional consistency, symmetry, gauge invariance, trace identities, limit consistency, and regression comparison against known results in the literature should be fixed into a standing checklist rather than left to ad hoc subjective judgment.

4. Illustrative Engineering Implementation

# Illustrative pseudocode: split a derivation into auditable atomic tasks
spec = {
    "background":    "curved spacetime, metric g_{μν}, signature (-,+,+,+)",
    "regularization": "dimensional regularization d = 4 - 2ε",
    "subtraction":    "minimal-subtraction-type scheme",
    "goal":           "coefficient of the curvature-squared term in the one-loop effective action",
}
tasks = [
    {"id": "T1", "goal": "enumerate topologically inequivalent one-loop diagrams", "output": "amplitude_list"},
    {"id": "T2", "goal": "tensor reduction",                                    "output": "reduced_tensor"},
    {"id": "T3", "goal": "reduce integrals to standard master integrals",       "output": "master_integrals"},
    {"id": "T4", "goal": "expand in ε and separate divergences",                 "output": "pole_and_finite"},
    {"id": "T5", "goal": "construct counterterms and verify the finite part",    "output": "final_coeff"},
]
for t in tasks:
    draft = model.plan(t["goal"], context=[spec] + dependencies(t["id"]))
    for step in draft.steps:
        assert cas.is_identical(step.lhs, step.rhs)       # algebraic identity
        assert dimension_check(step.rhs, spec)            # dimensional consistency
        assert symmetry_check(step.rhs, spec)             # symmetry consistency
        assert numeric_spotcheck(step.rhs, rel_tol=1e-30) # numerical spot check

The engineering value lies in the fact that assertions exist before conclusions do. That makes first-pass rate, assertion failure rate, and number of human-edited lines measurable metrics, and it turns the derivation process from a black box into a traceable audit chain.

5. Cloud Hosting and Standardization

Once this kind of workflow is engineered properly, it is a natural fit for cloud hosting:

• The compute-intensive algebraic reductions and numerical checks run on a container platform with on-demand scaling.
• Long-running jobs are orchestrated asynchronously through a message queue, avoiding interactive waiting.
• Intermediate results, specification files, and final artifacts are written to object storage with versioning and immutable snapshots.
• End-to-end call records and assertion results flow into log services with monitoring and alerting, used to analyze failure patterns and time distribution.

On Baidu AI Cloud, these capabilities correspond to general-purpose categories rather than proprietary interfaces: a container platform carries the computation, object storage preserves the intermediate artifacts, and log services with monitoring and alerting track task status. That combination is enough to support a reproducible derivation pipeline.

6. Applicability Boundaries and a Risk Checklist

Suitable to delegate to AI: mechanical work with clear rules that can be validated automatically, including tensor contraction, integral expansion, divergence separation, formula entry and consistency checking, and rechecking numerical results reported in the literature.

Not suitable to rely on AI for: modeling choices that require physical intuition (why a particular effective field theory, whether the truncation is reasonable), experimental design, and judgments about originality. Errors in these areas are not caught by any assertion.

Main risks:

• Generated formulas that look plausible but are wrong.
• Systematic bias caused by inconsistent specification conventions.
• False passes caused by biased choices of numerical validation parameters.
• Intermediate conclusions with unstated assumptions being misused downstream.

Guiding principle: AI output is treated as “unverified” by default. Only the parts that pass both deterministic assertions and human review are allowed to enter the final conclusion.

7. Practical Recommendations

At the starting point, pick a small-scale derivation that already has a known correct answer and use it as a golden-standard regression set. Build up specification templates and an assertion library so that new tasks reuse them instead of rewriting them. Evaluate the payoff with three metrics: end-to-end duration, first-pass rate, and amount of human editing.

The real speedup does not come from “AI computing faster than people.” It comes from restructuring an unverifiable long derivation into short steps that can be asserted. That is the most transferable part of this case.