{"id":"0233e745-6467-459d-8823-7151bd3a6613","arxiv_id":"2502.07060","paper_version":2,"verdict":"ACCEPT","confidence":"HIGH","novelty_score":7.0,"correctness_risk":"low","formal_verification":"none","parameter_count":0,"one_line_summary":"A publicly available GPU implementation of Berends-Giele recursion computes pure gluon amplitudes in arbitrary spacetime dimensions over finite fields.","lead":"The authors implemented a GPU-accelerated version of the Berends-Giele recursion for pure gluon scattering amplitudes that works in any spacetime dimension and over finite fields. It is the first such public code, aimed at speeding up loop-amplitude calculations that rely on many tree-level evaluations in d dimensions.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Arbitrary-d claim rests on unproved generalization of the polarization basis in Eq. (17); completeness is only tested through d=10. If it fails for some d, amplitudes in that dimension would be incorrect, so the central claim is not yet fully secured.","rationale":"The reader's weakest assumption matches the concern here: the polarization vectors for d > 6 are not proved to satisfy the completeness and orthogonality conditions for all d. The paper has substantial independent support: public code, CI tests, Ward identity checks, Parke-Taylor and NMHV comparisons in four dimensions, a cross-check against Caravel in higher dimensions, and finite-field GPU kernels that are tested on CPU and GPU. The benchmarks demonstrate event-level parallelization and a comparison with BlockGen, so the absence of a same-code CPU baseline is not a fatal issue. No internal inconsistency in the recursion or implementation was found. The remaining gap is narrow but real: the headline claims arbitrary space-time dimensions, and Eq. (17) is the only dimension-dependent ingredient not verified beyond d=10. If a general proof or additional high-dimensional tests close that gap, the paper fully supports the claim; until then, acceptance should be conditional on that verification. This is not a rejection: all available evidence is consistent with the construction being correct, and the recommended condition is a modest, well-defined addition.","tokens_in":13550,"tokens_out":10413,"duration_ms":99605,"concrete_test":"Take d = 13, 17, and 23 over F_p with p = 2^31 − 19, generate random massless momenta with the code's phase-space routine, construct the d−2 states from Eq. (17), and evaluate the residual R^{μν} = sum_{i=1}^{d−2} ε_i^μ ε_i^{*ν} + g^{μν} − (k^μ η^ν + k^ν η^μ)/(k·η) for a generic reference vector η. If R^{μν} is nonzero for any such d, the arbitrary-dimension claim fails; if R^{μν} = 0 and the Gram matrix (ε_i, ε_j) equals diag(−1, ..., −1) for several random points and several d values, the concern is resolved. A fully general symbolic derivation of completeness from Eq. (17) would also settle the question analytically.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central claim is that the implementation computes pure-gluon amplitudes in an arbitrary number of dimensions over finite fields. The recursion itself is standard; the dimension-dependent input that must be exactly right is the set of d−2 polarization vectors. For d≤6 these are explicit, and the paper validates completeness and orthogonality for d=4,...,10 (Section 3.1, test_states.py). For d>6 the states are defined by Eq. (17), with the statement that the expressions can be obtained by requiring that the completeness relation and orthogonality conditions are satisfied, but no general proof or derivation is given. The completeness relation is used implicitly in the state sum and in the recursion, so any dimension in which Eq. (17) fails would silently produce incorrect amplitudes. The construction is plausible and passes all tested cases, but the paper's 'arbitrary d' assertion is exactly as strong as this unproved generalization. This is load-bearing because it is the only part of the pipeline whose correctness for unvalidated d is not established either by the reported checks or by an external cross-check; the Caravel comparison covers specific finite d and does not extend to all d. The missing same-code CPU baseline, by contrast, is a benchmarking weakness, not a correctness threat.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents a GPU-accelerated implementation of the Berends-Giele recursion for pure-gluon tree amplitudes, with support for arbitrary spacetime dimension d and for finite-field arithmetic, and releases the code as a public package. The implementation is validated by internal consistency checks (Ward identity, metric and vertex tests, completeness of polarization states in d=4,...,10), by comparison with Parke-Taylor and NMHV analytic results, and by a one-to-one comparison with the external library Caravel in higher dimensions. Benchmarks show the expected exponential scaling in the number of legs, approximately constant time in the number of events up to a GPU threshold, and a comparison with BlockGen that is one order of magnitude slower in the finite-field mode. The stated goal is a proof of concept for GPU-accelerated computation of tree amplitudes relevant for loop integrands via numerical unitarity.","tokens_in":13774,"tokens_out":12803,"duration_ms":105481,"significance":"If the arbitrary-dimension construction is correct, this is a useful proof of concept: it is, to the best of the paper's claim, the first GPU implementation of Berends-Giele recursion over finite fields in arbitrary dimensions, and it directly targets a bottleneck in numerical unitarity and finite-field reconstruction. The manuscript's strengths are its public code, continuous-integration tests, and validation against independent analytic and external-library results; the Caravel comparison in particular is a strong external check. The main weakness is that the 'arbitrary d' part of the central claim rests on an unproved and, as printed, internally inconsistent formula for the polarization states, so the claim is stronger than the evidence currently provided.","major_comments":[{"comment":"The construction of the d-2 polarization states is asserted rather than proved. The completeness and orthogonality checks in Section 3.1 are limited to d = 4,...,10, and the Caravel comparison is for specific dimensions (e.g., 8), so the 'arbitrary number of space-time dimensions' claim is exactly as strong as an unproved generalization. This is load-bearing because any dimension for which Eq. (17) fails would silently produce incorrect amplitudes. Please provide a general proof (or an induction construction) for the completeness relation for all d, or explicitly restrict the claim to the tested range.","section":"Section 2.3, Eq. (17)"},{"comment":"As printed, the formula for the state labeled x = 5 gives a vector with non-zero entries only in coordinates 4 and 5, with -mu_6^2 at coordinate 5. Under the mostly-negative metric used in the paper, this vector is not transverse to a massless k with k_6 != 0: one obtains k . epsilon_5 = k_5 (mu_6^2 - k_4^2)/(mu_6 mu_7) = k_5^3/(mu_6 mu_7), which is generically non-zero. This appears to be an indexing or sign typo (the state should presumably involve the new coordinate 6 and have the -mu_6^2 entry at coordinate 6). Because the code passes the reported tests, I expect the implementation differs from the printed formula; nevertheless, the paper must be corrected or the notation clarified so that the arbitrary-d construction is self-consistent.","section":"Section 2.3, Eqs. (16) and (17)"},{"comment":"The benchmarks do not include a CPU run of the same code for the same finite-field and higher-dimensional configurations. The comparisons to Caravel and BlockGen conflate differences in hardware, implementation language, numeric type, and algorithmic scope, so the abstract's claim that the work 'demonstrates the advantages of hardware acceleration' for finite fields and d > 4 is not directly established by the presented data. A same-code CPU baseline (even for a subset of the points) would make the hardware-acceleration part of the central claim load-bearing rather than illustrative.","section":"Section 3.2, Figures 1-4"}],"minor_comments":[{"comment":"The denominator notation P_{Gamma'}/P_{Gamma'} appears to be a typo for the set difference P_{Gamma'} \\ P_{Gamma}; please correct it.","section":"Section 2.1, Eq. (4)"},{"comment":"The project name is written as 'Cara vel' in several places; it should be 'Caravel' consistently (the reference [32] uses the latter).","section":"Throughout"},{"comment":"There is a typo 'quantumchromodynamics' in the full-text abstract; it should read 'quantum chromodynamics'.","section":"Abstract and page 1"},{"comment":"The captions do not state the numeric mode (finite field vs. double-precision complex) used in each benchmark; please state this explicitly since the comparison in Fig. 4 depends on it.","section":"Figure captions, Figs. 1 and 3"},{"comment":"The comparison with BlockGen is labelled as illustrative, but the text should also state whether the same helicity configuration, phase-space generation, and event count are used for both codes; this would help readers interpret the reported factor of ten.","section":"Section 3.2, Fig. 4"}],"recommendation":"major_revision","confidential_remarks":"The novelty claim 'first GPU implementation in arbitrary dimensions over finite fields' is plausible, since BlockGen/Pepper target four-dimensional double precision and the cited HELAS GPU work is also four-dimensional. The main technical risk is the polarization-state construction: if Eq. (17) is only a typographical error, the paper is close to acceptable after a rewrite; if the printed formula reflects the implementation, the central arbitrary-d claim would be unsupported. The absence of a same-code CPU baseline is a lesser issue but worth requesting in revision. I would not reject based on the current evidence, because the external Caravel validation and the CI tests strongly suggest the implementation itself is sound."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this paper does what it says—first GPU implementation of Berends-Giele recursion for gluons in arbitrary spacetime dimensions over finite fields, with public code and serious validation. The central novelty is real: BlockGen and HELAS are 4d floating-point; here you get d-dimensional finite fields, which is exactly what numerical unitarity needs for loop integrands. The checks are credible: Ward identity, Parke-Taylor, NMHV, and a one-to-one comparison against Caravel. The code and CI tests are public, and the authors are honest about flexibility-over-performance and about the BlockGen comparison being apples-to-oranges.\n\nThe soft spot is the polarization construction. For d≤6 the states are explicit, and the paper verifies completeness/orthogonality for d=4,...,10. But for d>6, Eq. (17) is stated with the remark that it can be obtained by requiring completeness and orthogonality—no derivation is shown, and no check beyond d=10. That is exactly the input that makes the 'arbitrary d' claim true. It's a legitimate request to either prove the general pattern or soften the claim to 'validated for d≤10.' The pattern is regular and the tests pass, so I expect it's correct, but the paper as written asks readers to take it on faith past d=10. The missing same-code CPU baseline is a smaller issue: you see GPU scaling and a Caravel comparison, but not your own CPU-vs-GPU speed-up.\n\nWho should read it: amplitude people and anyone thinking about GPU acceleration of higher-order calculations. It deserves a serious referee; the polarization proof is a revision request, not a rejection. I'd send it out.","headline":"A genuinely useful proof-of-concept for GPU-accelerated finite-field amplitudes in d dimensions, but the 'arbitrary d' claim needs a proof of the polarization basis beyond d=6 to be fully secured.","tokens_in":14288,"tokens_out":3506,"would_cite":true,"duration_ms":31983,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper shows that Berends-Giele recursion for gluon amplitudes can run on GPUs in arbitrary dimensions over finite fields.","keywords":["Berends-Giele recursion","gluon amplitudes","GPU acceleration","finite fields","arbitrary dimensions","tree-level amplitudes","numerical unitarity","QCD"],"falsifier":"Compute the polarisation vectors of Eq. (17) in a dimension such as d = 11 or d = 12 for a generic massless momentum, evaluate the left- and right-hand sides of the completeness relation (13), and check whether their difference vanishes; a nonzero difference would mean the construction fails in that dimension and the amplitudes computed with it would be wrong.","tokens_in":13347,"feed_emoji":"⚛️","tokens_out":9628,"duration_ms":80861,"temperature":0.7,"pith_summary":"The paper aims to establish that the Berends-Giele recursion can be accelerated on GPUs while computing in arbitrary space-time dimensions over finite fields, not just in four dimensions over complex numbers. This is a proof of concept for using hardware acceleration in the tree-amplitude stage of higher-order calculations, where numerical unitarity needs many d-dimensional finite-field tree amplitudes to build loop integrands. The authors implement a public program, validate it against analytic MHV and NMHV results and against an external CPU framework, and benchmark its scaling in legs, events, dimension, and GPU model. If correct, the work opens the way to GPU-accelerated loop-level predictions.","feed_headline":"Gluon amplitudes run on GPUs in any dimension over finite fields","feed_subtitle":"A proof-of-concept GPU code targets the d-dimensional finite-field trees that loop calculations need.","key_machinery":"The machinery is the off-shell current of Berends-Giele, defined recursively in Eq. (6): a current with n legs is built from smaller currents via the three- and four-gluon vertices, divided by the total momentum squared, and the on-shell amplitude is obtained by removing the last propagator and contracting with a polarisation vector. The d-dimensional part rests on the explicit polarisation vectors of Eqs. (11), (16), and (17), constructed to satisfy the completeness relation (13) and orthogonality (12) without square roots, which would require field extensions in finite fields. The finite-field layer performs all arithmetic in 64-bit integers modulo a prime p < $2^{31}$, with custom kernels for the batched tensor contractions and for division via the extended Euclidean algorithm.","core_discovery":"The central claim is that the Berends-Giele recursion for pure-gluon tree amplitudes can be ported to GPUs while preserving the ability to work in any number of space-time dimensions d and over finite fields, and that this is the first such GPU implementation. The recursion builds n-gluon amplitudes from off-shell currents via Eq. (6); the implementation parallelises strictly over phase-space points, prepares the recursion and the d-dimensional polarisation states on the host, and uses custom GPU kernels for batched tensor contractions and finite-field division modulo a prime. The authors validate the code through internal consistency checks, the Ward identity, the MHV and NMHV analytic formulas, and a comparison with an external framework for d-dimensional amplitudes, and they report benchmarks showing flat scaling with event count until GPU capacity is reached, then linear growth.","pith_inferences":["A proof of the completeness relation (13) for the polarisation vectors of Eq. (17) in all dimensions would remove the main residual risk of the construction; until then, users should verify the relation beyond d = 10 before trusting amplitudes in higher dimensions.","The same custom finite-field kernels could serve other exact-arithmetic workloads, such as machine-learning pipelines requiring exact gradients or large-scale modular linear algebra.","Comparing against a CPU implementation of the same recursion with the same finite-field type would isolate the hardware gain from the overhead of the flexible high-level wrapper, and would tell whether the reported factor-of-ten gap to a specialised four-dimensional code is inherent or an artefact of the design choices."],"forward_implications":["The exponential scaling in the number of external legs is preserved on GPU, so the gain is higher throughput over phase-space points rather than a change in asymptotic complexity.","A runtime that is roughly constant as the number of events grows up to a hardware threshold means large batches of phase-space points can be processed with little additional cost, which suits the many-evaluation workloads of numerical unitarity.","Because finite-field d-dimensional trees are the ingredient needed for loop integrands, this proof of concept points toward GPU-accelerated fixed-order QCD predictions beyond leading order.","The modular separation of the finite-field tensor layer from the recursion makes the code portable to other hardware and extendable beyond gluons to quarks and electroweak states."],"supporting_citations":[{"why":"Supplies the Berends-Giele recursion that the whole implementation accelerates.","marker":"[23]"},{"why":"Provides the d-dimensional polarisation conventions and completeness relation the implementation extends.","marker":"[53]"},{"why":"Provides the external CPU framework used to validate d-dimensional results and an example of the numerical unitarity use case.","marker":"[32]"},{"why":"Supplies the analytic MHV amplitude formula used as a validation check.","marker":"[62]"},{"why":"Provides the existing GPU Berends-Giele implementation against which the paper benchmarks its own code.","marker":"[13]"},{"why":"Supplies the finite-field reconstruction technique that motivates computing amplitudes over finite fields.","marker":"[34]"}],"fun_headline_variants":["GPU Berends-Giele: gluon amplitudes in any dimension over finite fields","Gluon amplitudes on GPUs: arbitrary dimensions and finite fields","Berends-Giele recursion on GPUs: gluons in any dimension, finite fields","GPU code accelerates gluon amplitudes in any dimension over finite fields","Gluon amplitudes via Berends-Giele on GPUs for any d and finite fields"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that the explicit polarisation vectors constructed for d > 6 in Eq. (17) satisfy the completeness and orthogonality relations in every dimension; the paper verifies this numerically only up to d = 10 and gives no general proof.","fun_headline_variants_meta":{"raw":{"variants":["GPU Berends-Giele: gluon amplitudes in any dimension over finite fields","Gluon amplitudes on GPUs: arbitrary dimensions and finite fields","Berends-Giele recursion on GPUs: gluons in any dimension, finite fields","GPU code accelerates gluon amplitudes in any dimension over finite fields","Gluon amplitudes via Berends-Giele on GPUs for any d and finite fields"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000905,"raw_usage":{"total_tokens":3823,"prompt_tokens":808,"completion_tokens":3015,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":424,"completion_tokens_details":{"reasoning_tokens":2914}},"tokens_in":424,"tokens_out":3015,"duration_ms":17340,"temperature":1.0,"reasoning_tokens":2914,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-08T13:54:06.514848+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Compute the polarisation vectors of Eq. (17) in a dimension such as d = 11 or d = 12 for a generic massless momentum, evaluate the left- and right-hand sides of the completeness relation (13), and check whether their difference vanishes; a nonzero difference would mean the construction fails in that dimension and the amplitudes computed with it would be wrong.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the Berends-Giele recursion that the whole implementation accelerates."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Supplies the analytic MHV amplitude formula used as a validation check."}],"review_version":1}