OneAdapt: Resource-Adaptive Compilation of Measurement-Based Quantum Computing for Photonic Hardware

Review Form:

Reviewer: The Guardian (Adversarial Skeptic)

Summary

The authors propose OneAdapt, a compilation framework for measurement-based quantum computing (MBQC) on photonic hardware. The work introduces a new intermediate representation (IR) that extends the prior FlexLattice IR by (1) enforcing a bound on the length of temporal edges and (2) allowing "skewed" temporal edges between nodes at nearby 2D locations on different layers. The compiler includes two main optimization passes: a "dynamic refresh" mechanism to manage node lifetime and a "2D-bounded temporal routing" algorithm to leverage the new skewed edges. The authors claim significant reductions in execution time (1D depth) compared to both a modified version of the OnePerc compiler and a more rigid cluster-state-based approach. The framework's adaptability to various hardware constraints is evaluated, along with a preliminary extension to fault-tolerant quantum computing (FTQC) using surface codes.

Strengths

1. Problem Motivation: The paper correctly identifies a critical gap in existing MBQC compilers for photonic systems. The tension between the rigidity of cluster states and the potentially unbounded resource requirements of the more flexible FlexLattice IR is a well-articulated and important problem.
2. IR Design: The proposed IR features—bounded-length and skewed temporal edges—are well-grounded in the physical realities and capabilities of fusion-based photonic architectures. Capturing these hardware characteristics at the IR level is a sound design choice.
3. Core Algorithm Concept: The central idea of "dynamic refresh" (Section 4.3) is a logical and more granular alternative to the "periodic refresh" strategy from prior work. Performing refreshes on an as-needed basis, prioritized by computational relevance, has clear potential to avoid the overhead of dedicated refresh layers.

Weaknesses

My primary concerns with this paper relate to the justification for key claims, the strength of the experimental baselines, and the oversimplification of critical hardware effects.

1. Unsupported Claims Regarding Skewed Edge Implementation: The paper makes the strong claim that skewed edges can be implemented with "a slight algorithm modification, without requiring additional hardware capabilities" (Section 3.1, page 5) and that the associated overheads are "negligible" (Section 4.5, page 9). This is insufficiently substantiated.

   • PL Ratio: The analysis in Section 5.5 (Figure 12) assesses the Physical-to-Logical (PL) ratio overhead by randomly selecting skewed edges. This is not representative of a real compilation scenario where structured algorithms create deterministic and potentially conflicting routing patterns (i.e., routing hotspots). The conclusion that the overhead is negligible is therefore unconvincing.
   • Fidelity: The authors acknowledge that skewed edges may require longer fusion paths, which degrades fidelity. They then hand-wave this concern away by arguing that the reduction in 1D depth reduces the total edge count, thus "improving the overall fidelity" (Section 4.5, page 9). This is a qualitative argument without any quantitative backing. A paper focused on hardware-adaptive compilation must include a concrete fidelity model to properly evaluate such trade-offs. The absence of one is a major flaw.

2. Potentially Weak or Unfair Baselines: The impressive performance gains reported (e.g., 3.48x in Table 1) are questionable due to the construction of the baselines.

   • Baseline 1 (OnePerc): The authors modify OnePerc by forcing it to perform periodic refreshes and restricting its scheduling (Section 5.1, page 9) to make it "more comparable." This appears to be a post-hoc modification that forces the baseline into a regime it was not designed for, potentially crippling its performance. The data in Table 1 (page 10) shows OnePerc's compiled temporal edge length (Df (compiled)) far exceeds the target Df = 20, while OneAdapt meets it. This does not demonstrate that OneAdapt is 3.48x faster; it demonstrates that OneAdapt can satisfy a constraint that the authors' modified version of OnePerc cannot. This is a much weaker claim.
   • Baseline 2 (Qiskit to Cluster State): Compiling a circuit to a rigid 3D cluster state is a known-to-be-inefficient method that flexible compilers like OnePerc and OneAdapt are explicitly designed to outperform. While useful as a sanity check, the large 6.7x improvement over this baseline is expected and does not constitute a strong result on its own.

3. Over-reliance on Empirically Tuned Heuristics: The compiler's performance hinges on several heuristics. The refresh prioritization scheme (Section 4.3, page 7) is reasonable but not deeply analyzed for failure modes. More critically, the "Refresh Percentage Tuning" (Equation 1, page 8) relies on a parameter p, which is empirically set to 0.4 based on the data in Table 3 (page 12). This suggests the system is sensitive and has been tuned for the specific benchmarks tested, raising questions about its generalizability.

4. Superficial FTQC Analysis: The extension to FTQC (Section 5.6, page 12) is underdeveloped. The baseline is a "static strategy that interleaves QEC patches uniformly." This appears to be a strawman. The field of FTQC compilation has more sophisticated resource management schemes. Without comparing against a stronger, state-of-the-art dynamic scheduling baseline, the claimed 3.33x improvement is not credible.

Questions to Address In Rebuttal

1. On Skewed Edges: Please provide a quantitative analysis of the physical overheads of skewed edges.

   • a) Re-evaluate the PL ratio using the specific, deterministic routing patterns generated for the benchmark circuits in your evaluation, not random sampling.
   • b) Introduce a simple, explicit fidelity model (e.g., constant depolarizing error per fusion) and show how the final logical fidelity is affected by the trade-off between longer paths for skewed edges and a lower total 1D depth.

2. On Baselines: Please provide a stronger justification for your choice and modification of the OnePerc baseline. Is it not possible to configure OnePerc in a different manner to more effectively handle temporal edge constraints, even if not explicitly bounded? A fair comparison requires demonstrating that you are comparing against the baseline operating in a reasonable, if not optimal, configuration.

3. On Heuristics: With respect to the refresh percentage bound p, how sensitive is the compiler's performance to this parameter? Please provide data showing how the performance improvements hold up across a wider range of p values and justify why p=0.4 is a robust choice and not simply an artifact of overfitting to the selected benchmarks.

4. On FTQC: Please provide citations and justification that your "static strategy" baseline for FTQC scheduling is representative of a state-of-the-art approach. If it is not, please explain why a more advanced dynamic scheduling algorithm was not used for comparison.

---

Review Form

Reviewer: The Synthesizer (Contextual Analyst)

Summary

This paper introduces OneAdapt, a resource-adaptive compiler for Measurement-Based Quantum Computing (MBQC) specifically tailored for photonic hardware. The work identifies critical limitations in prior Intermediate Representations (IRs), such as the FlexLattice IR, which lack adaptivity to realistic hardware constraints. The core contribution is a novel, more hardware-aware IR and two associated optimization passes designed to bridge this gap.

The new IR extends FlexLattice in two significant ways:

1. It enforces a bound on the length of temporal edges, directly modeling the physical constraint of finite photon delay lines.
2. It introduces skewed temporal edges, which connect nodes at nearby but different 2D spatial locations across time steps, exploiting a latent capability of fusion-based architectures.

To manage and leverage this new IR, the authors propose two key compiler optimizations:

1. Dynamic Refreshing: An intelligent, on-demand node refresh mechanism that prevents temporal edge lengths from exceeding the hardware-imposed limit, in contrast to less efficient periodic refresh schemes.
2. 2D-Bounded Temporal Routing: A routing algorithm that utilizes the new skewed edges to achieve more efficient mappings, reducing both the required 2D hardware area and the 1D temporal depth of the computation.

The paper evaluates OneAdapt against both the state-of-the-art photonic compiler (OnePerc) and a circuit-model-based compiler (Qiskit), demonstrating significant improvements in execution depth while respecting hardware constraints. The framework is also extended to the fault-tolerant setting, showing substantial depth reduction for surface code implementations.

Strengths

The primary strength of this paper is its thoughtful and pragmatic approach to co-designing a quantum compiler IR with the realities of a promising hardware platform. It successfully moves the compilation stack for photonic MBQC from a realm of idealized assumptions toward practical implementation.

1. Clear Context and Problem Formulation: The paper does an outstanding job of contextualizing its contribution. Figure 1 (page 2) is particularly effective, providing a concise visual history of MBQC IRs and clearly positioning this work as the next logical step in balancing expressive power with hardware feasibility. The motivation is compelling and grounded in real physical limitations (finite delay lines) and opportunities (underutilized fusion pathways).

2. Significant Technical Contributions: The two core ideas are both novel and impactful.

   • The concept of dynamic refresh is an elegant solution to the bounded-delay problem. By refreshing nodes based on their individual "time-to-live" in a delay line rather than through rigid, periodic cycles, the compiler can minimize the overhead associated with maintaining quantum states over time.
   • The introduction and exploitation of skewed edges is a keen architectural insight. Recognizing that the underlying fusion-based hardware can support these connections without modification and then building a compiler pass to leverage them for routing is a prime example of effective hardware/software co-design. It unlocks a new dimension for optimization that was previously ignored.

3. Demonstrated Resource Adaptivity: The paper's central claim of "resource-adaptivity" is well-supported by the evaluation (Section 5, starting page 9). The experiments showing trade-offs between 2D hardware size and the available delay line length (varying Df in Figure 10, page 11) are crucial. This capability elevates the compiler from a mere translator to a vital tool for architects exploring the vast design space of future photonic systems.

4. Forward-Looking Scope (FTQC): The inclusion of a study on fault-tolerant quantum computing (FTQC) using surface codes (Section 5.6, page 12) is a significant strength. It demonstrates that the proposed techniques are not limited to the NISQ era but provide a scalable path toward fault tolerance, which is the ultimate goal. The reported 3.33x depth reduction in this context is highly promising.

Weaknesses

The weaknesses of the paper are primarily related to the scope of its analysis and potential missed connections, rather than fundamental flaws in the core ideas.

1. Hardware Model Fidelity: The paper's model of the photonic hardware, while more realistic than its predecessors, is still an abstraction. The crucial PL Ratio (Physical-to-Logical layer ratio) is treated as a fixed parameter based on prior simulations. However, the effectiveness of the proposed routing strategies, especially for skewed edges, likely depends heavily on the actual connectivity of the physical layer after probabilistic fusions. A discussion on how the compiler's performance degrades as the fusion success rate drops (and the physical graph becomes sparser) would add significant depth and realism. Section 5.5 touches on this but could be more integrated with the main results.

2. Narrow Focus on Fusion-Based MBQC: The work is situated entirely within the fusion-based MBQC paradigm. While this is a leading approach for photonics (e.g., PsiQuantum), it is not the only one. Other paradigms, such as continuous-variable (CV) cluster state generation or direct circuit-model implementations on different photonic architectures, exist. A brief acknowledgment of these alternatives in the introduction or related work would help to better delineate the specific domain of the paper's contribution and strengthen its overall positioning within the broader landscape of photonic quantum computing.

3. Fidelity vs. Resource Costs: The evaluation focuses exclusively on architectural metrics: 1D depth, 2D size, and temporal edge length. However, the introduction of skewed edges, as the authors briefly note in Section 4.5 (page 9), may require longer physical fusion paths, potentially leading to lower fidelity per logical edge. The paper lacks a quantitative analysis or even a qualitative discussion of this critical trade-off. A 3x reduction in depth is less compelling if it comes at the cost of a 10x increase in the logical error rate.

Questions to Address In Rebuttal

1. The effectiveness of 2D-bounded temporal routing relies on finding connected paths in the physical substrate. How sensitive are the reported depth and size improvements to the fusion success rate? Is there a percolation threshold below which the advantage of skewed edges diminishes because the required skewed paths are rarely available?

2. The dynamic refresh mechanism is governed by a refreshing bound br, which is tuned by the parameter p (Equation 1, page 8). The paper identifies p=0.4 as a "sweet spot." Could the authors elaborate on the methodology used to determine this value? Furthermore, how sensitive are the results to variations in p, and could an adaptive scheme that dynamically tunes p based on program characteristics yield even better performance?

3. Regarding the implementation of skewed edges (Section 4.5), the paper argues that they can lead to longer fusion paths and fidelity degradation. Can the authors provide a more concrete analysis of this trade-off? For instance, for a given reduction in 1D depth, what is the estimated increase in the total number of physical fusions required, which could serve as a proxy for fidelity cost? This would provide a more holistic view of the optimization's overall benefit.

---

Review Form

Reviewer: The Innovator (Novelty Specialist)

Summary

This paper presents OneAdapt, a compiler for Measurement-Based Quantum Computing (MBQC) targeting photonic hardware. The core contribution is twofold: 1) an extension of the Intermediate Representation (IR) from prior work, and 2) two new compilation passes designed to leverage this extended IR. Specifically, the authors extend the FlexLattice IR, introduced in OnePerc [74], by incorporating two new features: a hard constraint on the length of temporal edges and the allowance of "skewed" temporal edges that connect nodes at nearby, but not identical, 2D locations on different time-like layers. The new compilation passes, "Dynamic Refreshing" and "2D-bounded Temporal Routing," are designed to enforce the length constraint and exploit the skewed edges, respectively. The authors claim this new framework leads to significant reductions in program depth and hardware requirements compared to prior art.

Strengths

The paper's primary strength lies in its clearly articulated and well-justified novelty. The contributions are not presented in a vacuum but as a direct and intelligent evolution of a specific, state-of-the-art predecessor (OnePerc [74]).

1. Novelty of the IR Extension: The introduction of "skewed edges" is a genuinely novel concept in the context of MBQC compilation for photonic systems. While routing is a general concept, embedding this specific form of spatially-offset temporal connectivity directly into the IR is a clever architectural insight. It correctly identifies a latent capability in the underlying fusion-based hardware model—that path-finding between resource states is not strictly limited to a vertical "stack"—and proposes a formal IR feature to exploit it. This is a significant conceptual leap beyond the strictly columnar temporal connections in the original FlexLattice IR.

2. Algorithmic Novelty: The proposed "Dynamic Refreshing" mechanism (Section 3.2, page 6) is a substantial improvement over the "periodic refreshing" from OnePerc. The latter is a brute-force, synchronous method, whereas the proposed dynamic approach is an asynchronous, needs-based, and more granular scheduling algorithm. The use of a feedback mechanism based on the number of constraint-driven refreshes (Section 4.4, page 8, equation 1) to tune the refresh-to-computation ratio is a sophisticated and novel heuristic in this domain. This represents a significant increase in the algorithmic elegance for managing a critical resource constraint (photon storage time).

3. Synergistic Design: The two primary novelties (the extended IR and the new passes) are not independent but work in synergy. The skewed edges are not merely an addition; they are the feature that enables the more powerful 2D-bounded temporal routing. This tight coupling between the IR design and the compiler optimizations demonstrates a mature co-design approach, which itself is a valuable contribution. The resulting performance gains are not marginal; a 3.48x average depth reduction over OnePerc (Table 1, page 10) is substantial and directly validates the benefit of the novel ideas presented.

Weaknesses

My concerns are not with the existence of novelty, but with the rigor used to justify the practicality and scope of the novel claims.

1. Under-substantiated Feasibility of Skewed Edges: The entire premise of the skewed edge novelty rests on the claim that its implementation requires minimal overhead. Section 4.5 (page 9) states that a skewed IR edge "can be formed easily by a skewed fusion path" and that the only required change is "to allow path searching between qubits corresponding to IR nodes at nearby 2D locations." This assertion is the lynchpin for the paper's most innovative feature, yet it is treated with surprising brevity. Allowing paths to deviate from a straight column could significantly increase the complexity and runtime of the (2+1)-D path searching algorithm used for renormalization. It could also increase the likelihood of routing conflicts between different logical edges, potentially increasing the physical-to-logical layer ratio (PL Ratio). While the paper claims in Section 5.5 (page 11) that this effect is "negligible" for a skew distance of 1, this feels more like an empirical observation than a rigorous justification. The novelty is strong, but its practical foundation feels shaky.

2. Arbitrary Limitation on Novelty: The skewed edges are restricted to a Hamming distance of 1. While this is a practical choice that delivers good results, the paper does not explore the reasoning behind this specific limit. Is this a fundamental constraint imposed by the physics or connectivity of the hardware, or is it merely the first parameter value the authors tried? The novelty of the skewed edge concept would be significantly strengthened by a characterization of the design space. An analysis of the trade-offs (e.g., impact on PL Ratio, path-finding complexity, potential for 1D depth reduction) for a skew distance > 1 would provide a much deeper understanding of this new IR feature. As it stands, the innovation feels like a single point-solution rather than the introduction of a new, well-understood architectural knob.

Questions to Address In Rebuttal

1. The feasibility of skewed edges is central to this work. Can the authors elaborate on the algorithmic complexity of the modified (2+1)-D path searching? Does searching a larger volume for paths for each logical edge measurably increase the runtime of the renormalization step, which is a critical part of the real-time hardware operation? Can you provide stronger evidence that path congestion and the PL Ratio are not adversely affected in denser, more complex programs than those in the benchmark suite?

2. Regarding the scope of the skewed edge concept: Please justify the choice of a Hamming distance of 1. Is this limit based on a physical constraint in the fusion-based architecture model, or is it an empirical choice? A brief discussion on the projected overheads and potential benefits of allowing a larger skew distance would help establish the generality of this novel contribution.

3. The dynamic refresh algorithm is an interesting scheduling solution that prioritizes nodes based on their computational relevance and storage time. This bears a conceptual resemblance to deadline-driven scheduling in real-time systems or advanced cache/register management in classical compilers. Was this novel approach inspired by prior art in other domains of computer science? Placing this quantum compilation technique in a broader context could help clarify its fundamental contribution.