{"id":"70b0d607-a404-4fa2-a6b7-0455978567fa","arxiv_id":"2510.25561","paper_version":4,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"For any connected selection-rule graph, any single-qudit unitary decomposes into at most d(d−1)/2 allowed two-level pulses via a BFS-based QR-style algorithm.","lead":"This paper offers an algorithm to break any single-qudit quantum operation into the hardware-allowed pulses, using at most d(d−1)/2 two-level pulses for any connected set of allowed transitions. It could reduce pulse counts—and therefore errors—in trapped-ion and other qudit quantum computers.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Correctness proof of the d(d−1)/2 bound omits the zero-pivot case: Eq. (24) divides by the pivot element, so sparse unitaries (e.g., non-adjacent level swaps) are not covered as written.","rationale":"The paper's central claim is the guaranteed d(d−1)/2 pulse count for arbitrary single-qudit operations on any connected transition graph. The constructive proof rests on two implicit lemmas: (a) at each step a vertex can be removed while preserving connectivity, and (b) the prescribed BFS pivot sequence actually zeroes the target row for an arbitrary unitary. The Reader flagged (a). That lemma is real but standard: every connected graph with at least two vertices has at least two non-cut vertices, e.g., leaves of any spanning tree, so it is a minor omission rather than a threat. Lemma (b) is more substantive. The elimination formula in Eq. (24) assumes a nonzero pivot element. For arbitrary unitaries, including sparse unitaries that the abstract explicitly covers, pivot entries can be zero. A concrete example is a level permutation on a path: the row to be eliminated may have a single nonzero off-diagonal element, while all intermediate pivot entries along the BFS path are zero. The paper contains no rule for this case and no proof that a zero pivot can still be used. The theorem may still be true — a Givens rotation with θ=π moves the nonzero weight from the eliminated column to the pivot column, and the BFS tree then propagates all weight to the diagonal — but this argument is absent. Thus the written proof does not establish the 'arbitrary' claim. Because this is a proof gap rather than a demonstrated counterexample, and the Reader's CONDITIONAL verdict already accounts for addressable gaps, I recommend no change to the verdict.","tokens_in":23789,"tokens_out":23560,"duration_ms":225359,"concrete_test":"Take d=5 with a line transition graph (0–1–2–3–4) and the unitary SWAP_{0,4} that exchanges levels 0 and 4, leaving all other levels fixed. Run the static TAQR row-elimination procedure exactly as specified in Secs. IV–V, e.g., choosing row r=4 and BFS pivots p=3,2,1,0. Eq. (24) will encounter U_{4,1}=0 while eliminating U_{4,0} and fail (division by zero). Record whether the procedure crashes, or whether an undocumented θ=π branch succeeds in producing a valid decomposition. If it fails as specified, the paper's proof of 'arbitrary' requires an explicit zero-pivot elimination lemma or a modified algorithm; if it succeeds only via an unstated branch, the main theorem may still hold but the written proof is incomplete.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central theorem (Abstract; Secs. IV–V) asserts that any single-qudit unitary can be decomposed into at most d(d−1)/2 R-gates for any connected transition graph. The row-elimination step eliminates an element U_{r,z} using a pivot U_{r,p} via Eq. (24): θ = 2 arctan(|U_{r,z}|/|U_{r,p}|). This is undefined when the pivot vanishes. For generic Haar-random unitaries all entries are nonzero, so the proof works in the generic case; but the claim covers arbitrary unitaries, including sparse ones such as a level permutation swapping two non-adjacent levels. In such a row, the target element can be nonzero while the prescribed BFS pivot is zero. The paper only notes that θ can be 0 when the eliminated element is already zero; it never specifies what to do when the pivot is zero (e.g., θ = π, which moves nonzero weight into the pivot column and can be propagated along the BFS tree toward the diagonal). As written, a reader implementing Eq. (24) literally will fail on such sparse matrices. This is a proof gap in the load-bearing step, independent of the true-but-unstated non-cut-vertex lemma that the Reader identified.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes a constructive decomposition algorithm (TAQR) that realizes an arbitrary d-dimensional single-qudit unitary using two-level transition gates R_{ij} and phase gates P_k, where the allowed transitions are specified by an arbitrary connected undirected graph. The main claim is that for any such graph the decomposition uses at most d(d−1)/2 transition gates, matching the superconducting/line-graph count and improving on naive level-swap strategies for trapped-ion-like topologies. The algorithm works by eliminating rows in an order determined by repeatedly removing non-cut vertices from the transition graph; within each row, entries are eliminated from outer BFS layers inward, using a parent level as pivot. A static version fixes the scheme for a platform, while an adaptive version exploits zero entries to skip unnecessary gates. The paper benchmarks TAQR against BQSKit (QSearch, QSweep) and MQT.Qudits (LocQRPass, LocAdaPass) on line, star, and bipartite transition graphs, reporting transition counts and runtimes.","tokens_in":24101,"tokens_out":8998,"duration_ms":93530,"significance":"If the central claim is correct, the paper gives a clean, unifying solution to a practical qudit-compilation problem: any connected selection-rule graph supports decompositions with the parameter-count-optimal number of two-level pulses. The construction is genuinely graph-aware rather than platform-specific, and the BFS-based row-elimination scheme is transparent and easy to implement. The comparison with third-party synthesis tools is concrete, with code made available, and the authors distinguish static and adaptive modes in a useful way. The result is not circular or fitted: no constants are learned and no author-derived prior results are used as inputs. The main value is as a drop-in single-qudit transpilation routine for qudit hardware with nontrivial selection rules.","major_comments":[{"comment":"The row-elimination formula is derived under the assumption that the pivot entry is nonzero: Eq. (25) divides by |U_{r,p}|. The theorem claims arbitrary unitaries, including sparse ones such as a swap of two non-adjacent levels. For such a row, the target U_{r,z} can be nonzero while the BFS-chosen pivot U_{r,p} is zero. The text only notes that θ can be 0 when the eliminated element is already zero; it does not specify the zero-pivot case. A correct handling is to set θ = π when U_{r,p}=0 and U_{r,z}≠0, moving the amplitude into the pivot column, and one must prove this remains compatible with the BFS ordering (the pivot has not yet been eliminated). As written, the proof covers only dense matrices, so the 'arbitrary unitary' claim is not fully established.","section":"Sec. IV, Eqs. (23)–(26)"},{"comment":"The algorithm repeatedly selects a level whose removal from the transition graph preserves connectivity, doing this d−1 times. The paper does not prove that such a level always exists at every step. The fact is true — every finite connected graph with at least two vertices has at least two non-cut vertices — but it is load-bearing for the d(d−1)/2 bound and should be stated explicitly and either proved or cited. Without this lemma, the recursion could in principle stall, so the termination argument is incomplete.","section":"Sec. V, first algorithm bullet and Fig. 2a"}],"minor_comments":[{"comment":"The comparison reports only transition counts and runtimes, not any fidelity or distance to the target unitary. Since QSearch is a numerical optimizer, the reported lengths are only meaningful if the returned circuits approximate the target to a specified tolerance. Please add a verification metric (e.g., Hilbert–Schmidt distance or infidelity) for all reported decompositions.","section":"Sec. VI, Tables II–III"},{"comment":"The Conclusions call the decomposition 'optimal' and Sec. VI calls d(d−1)/2 'the theoretical upper bound.' The paper does not give the parameter-count argument that would justify optimality: each R gate carries two continuous parameters and the d phase gates supply the remaining degrees of freedom. Please include this reasoning or soften the optimality claim.","section":"Sec. VII and Sec. VI"},{"comment":"The comparison code is on GitHub, but the source of the developed method is 'available on reasonable request.' For reproducibility of the central algorithm, please publish the TAQR implementation itself, not only the benchmark harness.","section":"Data Availability Statement"}],"recommendation":"major_revision","confidential_remarks":"The zero-pivot gap and the missing non-cut-vertex lemma are both easily repairable and do not appear to invalidate the central construction. The intended recommendation is to give the authors a clear path: add the zero-pivot case, state the graph lemma, and verify numerical fidelity. If those additions are made, the paper would be a solid contribution to qudit compilation."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Quick take: this is a genuinely useful result — a BFS-based scheme that decomposes any single-qudit unitary into allowed two-level pulses on an arbitrary connected transition graph, with d(d-1)/2 as the worst-case count. The generic-case algebra is correct, and the adaptive sparsity-aware variant is a nice practical touch. You should know the bound proof is not complete as written.\n\nWhat's new: QSweep and Clements handle line and square topologies; star and bipartite cases for trapped-ion and neutral-atom qudits were previously handled by ad hoc swap tricks. The graph algorithm here — pick a removable level, BFS from it, eliminate from the leaves back — is simple and general, and the benchmark numbers beat MQT.Qudits and stay competitive with QSearch on line graphs. The paper also honestly notes the earlier similar graph idea in Brennen et al. [81], so the novelty claim is calibrated.\n\nSoft spots. First, the zero-pivot case is real. Equation (24) divides by the pivot |U_{r,p}|. The theorem claims any unitary, including sparse ones like a swap of non-adjacent levels. If the BFS-chosen pivot is zero while the target is nonzero, the formula is undefined. The paper only mentions θ = 0 when the target is already zero; it never says what to do with a zero pivot. An implementer following Eq. (24) literally will trip on non-generic matrices. This is fixable — pick a different pivot or use a π pulse to move weight — but as written it is a genuine gap in the load-bearing claim. Second, the bound depends on the graph staying connected after each row removal. The algorithm says 'select levels that, if removed, do not break connectivity' but never proves such a level always exists. That's a standard graph fact (every connected graph has at least two non-cut vertices), so it's an omitted lemma, not an error. The referee should ask to have it stated. Third, the benchmarks count pulses but never verify that the synthesized circuit actually equals the target unitary to numerical precision. For a decomposition paper that's a surprising omission, and the main implementation is 'available on reasonable request' while only the comparison harness is public — both hurt reproducibility. Finally, 'optimal' in the conclusions overstates what is shown; you show an upper bound, not minimality against all possible algorithms.\n\nThis paper is for anyone working on qudit transpilation or trapped-ion/neutral-atom control. It deserves a serious referee, but the referee should ask for the zero-pivot case to be handled, the graph lemma stated, and fidelity checks added to the benchmarks.","headline":"Genuinely useful new compiler pass for single-qudit gates with a provable pulse count; the proof of the d(d-1)/2 bound has two real, fixable gaps and the benchmarks skip numerical verification.","tokens_in":24592,"tokens_out":3097,"would_cite":true,"duration_ms":30010,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P68"],"pacs":["03.67.Lx"],"model":"deepseek-v4-flash","headline":"For any qudit hardware whose allowed transitions form a connected graph, the paper proves every single-qudit unitary can be decomposed into at most d(d−1)/2 two-level pulses, and gives an algorithm that finds the sequence.","keywords":["qudit","single-qudit gates","unitary decomposition","two-level pulses","selection rules","transition graph","quantum computation","pulse count bound"],"falsifier":"Run the static algorithm on a connected transition graph, for example a four-level cycle or a star, with a Haar-random unitary, and count the two-level rotations in the produced circuit. A single output circuit that requires more than d(d−1)/2 transitions, or a step where the chosen pivot was already eliminated, would falsify the bound.","tokens_in":23721,"feed_emoji":"⚛️","tokens_out":5164,"duration_ms":48549,"temperature":0.7,"pith_summary":"The paper addresses a practical bottleneck for qudit quantum computers: although a d-level system stores more information than a qubit, generic gates require pulses between specific pairs of levels, and not every platform allows every pair. The authors construct a decomposition algorithm that takes the platform's selection rules as a graph and produces a sequence of allowed two-level rotations and phase shifts. Their central result is a universal bound: any single-qudit unitary can be implemented with at most d(d−1)/2 two-level pulses, which is the number needed to carry the d² real parameters of a generic unitary. The same algorithm works for line, star, and bipartite transition graphs, and an adaptive variant exploits zero entries to shorten sequences for specific gates.","feed_headline":"Single-qudit gates need no more than d(d−1)/2 pulses","feed_subtitle":"Any d-level operation decomposes into at most d(d−1)/2 native pulses, regardless of allowed transitions.","key_machinery":"The central object is the transition graph G, whose vertices are qudit levels and edges are allowed two-level pulses. The elimination engine is a generalized row-elimination pattern: for each row r_k, choose a removable vertex, run breadth-first search to stratify the remaining graph into distance layers, and for every non-diagonal element z in the row pick a pivot p in the layer closer to r_k, so that z is eliminated without re-introducing previously eliminated elements. The fact that the chosen vertex is non-cut keeps the graph connected through the recursion, which the paper relies on for the d(d−1)/2 count.","core_discovery":"The central claim is that row-elimination QR-style decomposition can be made transition-aware: instead of requiring a fixed ladder of neighboring transition pulses, the algorithm eliminates entries row by row using pulses that correspond to edges of any connected graph of allowed transitions. At each elimination step it removes a level whose deletion keeps the graph connected, then orders the remaining levels by their distance from that level via breadth-first search so that each non-diagonal entry can be zeroed using a higher-distance level as a pivot. Repeating this d−1 times yields at most d(d−1)/2 transitions for an arbitrary unitary. The static version precomputes an index scheme per pl","pith_inferences":["This suggests the bound is worst-case optimal: d(d−1)/2 two-level rotations carry d(d−1) real parameters, and together with d phase gates they exhaust the d² parameters of a generic unitary, so no scheme can use fewer rotations in the worst case.","The algorithm's reliance on repeatedly removing non-cut vertices connects to a standard graph-theoretic fact (every connected graph has at least two non-cut vertices); making that step explicit would close the one unstated assumption in the proof of the bound.","The distance-layer pivot rule could likely be extended to weighted transition graphs where pulses have different error rates, since the paper already notes the freedom to pick the least noisy pivot at each step.","The same decomposition pattern might generalize to two-qudit entangling gates, which the paper frames as single-qudit operations embedded into a larger space."],"forward_implications":["Any single-qudit operation on any connected selection-rule graph can be executed with at most d(d−1)/2 native pulses, matching the number of pulses needed to parameter-count generic unitaries.","Static per-platform schemes can be computed once and reused for all unitaries, making transpilation fast (millisecond-scale for the tested dimensions up to 6).","For trapped-ion-style star and bipartite transition graphs, the algorithm matches or beats existing synthesis tools in pulse count and runtime.","Phase gates can be performed virtually on many platforms, so the pulse count is the dominant cost; fewer pulses means lower accumulated error.","The adaptive variant reduces pulse counts further for operations with zeros, such as level permutations and increment gates."],"fun_headline_variants":["Qudit gates: fewer pulses via transition-aware decomposition","Decompose any single-qudit gate in ≤ d(d−1)/2 pulses","Transition-aware splitting cuts pulse count to d(d−1)/2","Single-qudit operation: max d(d−1)/2 native pulses","Resource-lean qudit gate decomposition respects selection rules"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The algorithm relies on being able to find, at each of the d−1 elimination rounds, some level whose removal leaves the transition graph connected; if no such level existed for some allowed-transition graph, the pulse bound would not follow.","fun_headline_variants_meta":{"raw":{"variants":["Qudit gates: fewer pulses via transition-aware decomposition","Decompose any single-qudit gate in ≤ d(d−1)/2 pulses","Transition-aware splitting cuts pulse count to d(d−1)/2","Single-qudit operation: max d(d−1)/2 native pulses","Resource-lean qudit gate decomposition respects selection rules"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000229,"raw_usage":{"total_tokens":1340,"prompt_tokens":791,"completion_tokens":549,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":535,"completion_tokens_details":{"reasoning_tokens":458}},"tokens_in":535,"tokens_out":549,"duration_ms":4649,"temperature":1.0,"reasoning_tokens":458,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-04T07:26:38.757367+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the static algorithm on a connected transition graph, for example a four-level cycle or a star, with a Haar-random unitary, and count the two-level rotations in the produced circuit. A single output circuit that requires more than d(d−1)/2 transitions, or a step where the chosen pivot was already eliminated, would falsify the bound.","supporting_citations":[],"review_version":1}