Oxidize `UnitarySynthesis` pass #13141

ElePT · 2024-09-12T10:05:09Z

Summary

Closes #12210. This is an initial effort to port UnitarySynthesis to Rust, currently limited to the target + default plugin path (custom plugins will run in Python).

Details and comments

TODO:

Add unit tests for qsd path and 1q synthesis path
Address drawer issue after calling dag_to_circuit (not reflected in unit tests)
Clean up comments
Review use of dag.push_back and see if it can be done with the new dag.apply_operation_back method

coveralls · 2024-09-12T12:12:15Z

Pull Request Test Coverage Report for Build 11409692028

Warning: This coverage report may be inaccurate.

This pull request's base commit is no longer the HEAD commit of its target branch. This means it includes changes from outside the original pull request, including, potentially, unrelated coverage changes.

For more information on this, see Tracking coverage changes with pull request builds.
To avoid this issue with future PRs, see these Recommended CI Configurations.
For a quick fix, rebase this PR at GitHub. Your next report should be accurate.

Details

784 of 849 (92.34%) changed or added relevant lines in 5 files are covered.
856 unchanged lines in 37 files lost coverage.
Overall coverage decreased (-0.3%) to 88.535%

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
crates/accelerate/src/two_qubit_decompose.rs	14	15	93.33%
crates/accelerate/src/unitary_synthesis.rs	761	825	92.24%

Files with Coverage Reduction	New Missed Lines	%
qiskit/circuit/library/standard_gates/u.py	1	93.0%
crates/qasm2/src/expr.rs	1	94.02%
crates/accelerate/src/elide_permutations.rs	1	97.06%
crates/accelerate/src/error_map.rs	1	85.42%
crates/accelerate/src/circuit_library/quantum_volume.rs	1	96.69%
qiskit/circuit/library/standard_gates/rz.py	2	95.83%
qiskit/circuit/library/quantum_volume.py	2	95.45%
crates/circuit/src/lib.rs	2	96.15%
qiskit/synthesis/stabilizer/stabilizer_decompose.py	2	96.77%
crates/circuit/src/bit_data.rs	2	94.62%

Totals
Change from base Build 11241264267:	-0.3%
Covered Lines:	73846
Relevant Lines:	83409

💛 - Coveralls

…unitary-synthesis

ElePT · 2024-09-13T14:18:05Z

Performance is starting to look promising:

Benchmarks that have improved:

| Change   | Before [2fa6dd65] <main>   | After [739a5c84] <oxidize-unitary-synthesis-benchmarking-3>   |   Ratio | Benchmark (Parameter)                                              |
|----------|----------------------------|---------------------------------------------------------------|---------|--------------------------------------------------------------------|
| -        | 1.30±0.04s                 | 1.17±0.02s                                                    |    0.9  | utility_scale.UtilityScaleBenchmarks.time_qaoa('ecr')              |
| -        | 483±60ms                   | 375±2ms                                                       |    0.78 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg('cx')  |
| -        | 695±90ms                   | 476±20ms                                                      |    0.69 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg('cz')  |
| -        | 705±100ms                  | 481±10ms                                                      |    0.68 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg('ecr') |

SOME BENCHMARKS HAVE CHANGED SIGNIFICANTLY.
PERFORMANCE INCREASED.

crates/accelerate/src/unitary_synthesis.rs

ElePT · 2024-09-16T13:35:42Z

Benchmarking status as of eb815d1 (more benchmarks show improvement but the improvement looks slightly smaller).

| Change   | Before [2fa6dd65] <unitary-test>   | After [266a22f0] <oxidize-unitary-synthesis>   |   Ratio | Benchmark (Parameter)                                              |
|----------|------------------------------------|------------------------------------------------|---------|--------------------------------------------------------------------|
| -        | 1.38±0.04s                         | 1.21±0.03s                                     |    0.87 | utility_scale.UtilityScaleBenchmarks.time_qaoa('cz')               |
| -        | 425±8ms                            | 361±8ms                                        |    0.85 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg('cx')  |
| -        | 566±10ms                           | 467±10ms                                       |    0.83 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg('cz')  |
| -        | 3.94±0.2s                          | 3.04±0.02s                                     |    0.77 | utility_scale.UtilityScaleBenchmarks.time_qv('ecr')                |
| -        | 4.21±0.1s                          | 3.15±0.04s                                     |    0.75 | utility_scale.UtilityScaleBenchmarks.time_qv('cz')                 |
| -        | 626±40ms                           | 456±4ms                                        |    0.73 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg('ecr') |

qiskit-bot · 2024-09-16T16:06:21Z

One or more of the following people are relevant to this code:

@Qiskit/terra-core
@kevinhartman
@levbishop
@mtreinish

mtreinish

I took a first pass through this, thanks for doing this @ElePT! I left some inline comments. The two high level ones that stuck out the most to me from my first pass is that this PR seems to make a lot of things public, some of them make sense like the dagcircuit methods, but others I'm skeptical we need to be reusing or accessing outside of their definition. Some of the internal attributes of structures for example.

The other thing that I think is potentially a bigger issue especially for performance is around some of the typing choices and how that leads to a lot of conversions. The most concrete example is things are normalized on DAGCircuit between all the different decomposer, but this leads to creating an expensive object to be constructed when it'd be far more efficient to iterate over the synthesized sequence directly and add the gates directly to the dag.

crates/accelerate/src/target_transpiler/nullable_index_map.rs

crates/accelerate/src/two_qubit_decompose.rs

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

mtreinish · 2024-09-16T17:35:55Z

crates/accelerate/src/unitary_synthesis.rs

+    let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
+    let dag_to_circuit = imports::DAG_TO_CIRCUIT.get_bound(py);


These exist in rust now, see: https://github.com/Qiskit/qiskit/blob/main/crates/circuit/src/converters.rs so I'd suggest calling them directly. Especially if you're doing circuit_to_dag you can call the inner DAGCircuit constructor and avoid the python overhead when you've built a CircuitData directly in rust (not that I think that's the case here).

Any updates on when we will start using these here? I understand that you may not want to use dag_to_circuit in rust to avoid using CircuitData but circuit_to_dag takes a QuantumCircuit instance, and should work the same way.

I updated the code to use circuit_to_dag from the new converters crate in a912248. I am hesitant with dag_to_circuit because to use it I'd have to add a few extra conversion steps.

crates/accelerate/src/unitary_synthesis.rs

crates/circuit/src/dag_circuit.rs

crates/accelerate/src/unitary_synthesis.rs

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

…unitary-synthesis

ElePT · 2024-10-09T15:50:59Z

This is the latest benchmarking output after pulling from main, again a smaller number of tests improve but the improvement seems better.

| Change   | Before [90e92a46] <oxidize-unitary-synthesis^2>   | After [9cacf6fc] <oxidize-unitary-synthesis>   |   Ratio | Benchmark (Parameter)                                              |
|----------|---------------------------------------------------|------------------------------------------------|---------|--------------------------------------------------------------------|
| +        | 14.7±0.6ms                                        | 18.5±1ms                                       |    1.25 | utility_scale.UtilityScaleBenchmarks.time_parse_qaoa_n100(‘cx’)    |
| -        | 512±100ms                                         | 363±9ms                                        |    0.71 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg(‘cx’)  |
| -        | 841±100ms                                         | 444±30ms                                       |    0.53 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg(‘cz’)  |
| -        | 858±70ms                                          | 446±30ms                                       |    0.52 | utility_scale.UtilityScaleBenchmarks.time_square_heisenberg(‘ecr’) |

ElePT · 2024-10-14T09:56:11Z

I also ran the transpiler benchmarks for QV, which might give a better idea of the speedup than the utility scale ones, and got the following numbers on the tests that use the rust path (the rust path is only followed if transpile is called with a target, and some of these tests give coupling map/basis gates directly). I added a rust-path test for the 50x20 example to have more data to look at.

| Change   | Before [90e92a46] <oxidize-unitary-synthesis^2>   | After [9cacf6fc] <oxidize-unitary-synthesis>   |   Ratio | Benchmark (Parameter)                                                                       |
|----------|---------------------------------------------------|------------------------------------------------|---------|---------------------------------------------------------------------------------------------|
| -        | 138±0.8ms                                         | 121±2ms                                        |    0.88 | transpiler_levels.TranspilerLevelBenchmarks.time_transpile_qv_14_x_14(3)                    |
| -        | 691±20ms                                          | 600±30ms                                       |    0.87 | transpiler_levels.TranspilerLevelBenchmarks.time_quantum_volume_transpile_50_x_20_target(2) |
| -        | 100±1ms                                           | 87.4±4ms                                       |    0.87 | transpiler_levels.TranspilerLevelBenchmarks.time_transpile_qv_14_x_14(2)                    |
| -        | 62.4±0.8ms                                        | 52.8±4ms                                       |    0.85 | transpiler_levels.TranspilerLevelBenchmarks.time_transpile_qv_14_x_14(1)                    |
| -        | 321±3ms                                           | 262±10ms                                       |    0.82 | transpiler_levels.TranspilerLevelBenchmarks.time_quantum_volume_transpile_50_x_20_target(0) |
| -        | 62.0±1ms                                          | 44.9±0.5ms                                     |    0.72 | transpiler_levels.TranspilerLevelBenchmarks.time_transpile_qv_14_x_14(0)                    |

raynelfss

I think this is about ready in my opinion. We'll see about the panicking and errror handling on the synth_sequences based on the comments I just left. I'd appreciate if @ShellyGarion or @alexanderivrii can take a look at the arithmetic, or a second look from the team.

raynelfss · 2024-10-14T16:59:43Z

crates/accelerate/src/unitary_synthesis.rs

+        ));
+    }
+
+    let target_basis_set = get_target_basis_set(target, qubits[0]);


Should something like this be part of #13308? Since we're moving towards a more Target centric transpiler, being able to extract the basis gates automatically. I see this being done in many transpiler passes whenever basis gates are not provided.

Yes, absolutely, I would include this.

raynelfss · 2024-10-14T17:03:45Z

crates/accelerate/src/unitary_synthesis.rs

+            let mut embodiment =
+                xx_embodiments.get_item(op.to_object(py).getattr(py, "base_class")?)?;
+
+            if embodiment.getattr("parameters")?.len()? == 1 {


I see, I wanted to ask since CircuitData has a version of assign_parameters that can be worked entirely through rust.

raynelfss · 2024-10-14T17:18:29Z

crates/accelerate/src/unitary_synthesis.rs

+    let synth = if let DecomposerType::TwoQubitBasisDecomposer(decomp) = &decomposer_2q.decomposer {
+        decomp.call_inner(su4_mat.view(), None, is_approximate, None)?
+    } else {
+        panic!("synth_su4_sequence should only be called for TwoQubitBasisDecomposer.")


If it's unreachable code you should use unreachable!(), the only downside is that these exceptions cannot really be caught from Python code. However, I think it is better for debugging purposes.

ShellyGarion · 2024-10-15T12:24:15Z

I think this is about ready in my opinion. We'll see about the panicking and errror handling on the synth_sequences based on the comments I just left. I'd appreciate if @ShellyGarion or @alexanderivrii can take a look at the arithmetic, or a second look from the team.

The general framework looks good to me.
For a 1-qubit unitary we use euler_one_qubit_decomposer.
For a 2-qubit unitary we use the TwoQubitBasisDecomposer (default for the basis gates 'cx', 'cz' or 'ecr') or the XXDecomposer.
Later, we also plan to add the TwoQubitControlledUDecomposer (which should be default for gates like 'rzz' with an arbitrary angle), see #13139 and #13320.
For a larger unitary, we use the qs_decomposition.

mtreinish

I haven't made it through all of the rust code yet, but from what I seen this is looking good enough to merge (once the build failure is fixed). I think there are some potential optimizations and improvements we'll want to make down the road but this is large enough we could nitpick forever on particular pieces of it and never merge it when we can make incremental improvements after it merges. So if I don't circle back to this in a timely manner don't let that stop someone else from feeling empowered to approve and merge it.

crates/accelerate/src/unitary_synthesis.rs

mtreinish · 2024-10-17T11:47:29Z

crates/accelerate/src/unitary_synthesis.rs

+// no need to bother trying the XXDecomposer.
+static GOODBYE_SET: [&str; 3] = ["cx", "cz", "ecr"];
+
+fn get_target_basis_set(target: &Target, qubit: PhysicalQubit) -> EulerBasisSet {


I wonder if there is value in eventually consolidating this with the similar logic in euler_one_qubit_decomposer. It's different enough that it's not worth it right now, but I think there is a path to unifying the functions probably in a follow up PR.

crates/accelerate/src/unitary_synthesis.rs

mtreinish · 2024-10-17T11:54:58Z

crates/accelerate/src/unitary_synthesis.rs

+    target: &Target,
+) -> f64 {
+    let mut gate_fidelities = Vec::new();
+    let mut score_instruction =


Just curious why did you end up going for a closure here? I probably would have just put this in the loop body directly. It doesn't really matter so no reason to change it, I was just wondering.

I think I was originally inlining it in the code, switched a couple of times between that and the function, and it ended up like this, but no proper reason for it.

mtreinish · 2024-10-17T11:58:08Z

crates/accelerate/src/unitary_synthesis.rs

+    let node_ids: Vec<NodeIndex> = dag.op_nodes(false).collect();
+    for node in node_ids {


Is it necessary to do this as a separate loop over all the nodes? I feel like we should be able to integrate this into the main loop over the nodes in topological order below and reduce the need to iterate over the dag twice.

If not we can do a simple check up front and call dag.has_control_flow() to check if we have any control flow in the dag at all and if not we don't have to bother iterating.

mtreinish · 2024-10-17T13:04:53Z

crates/accelerate/src/unitary_synthesis.rs

+            let new_ids = dag.get_qargs(inst.qubits).iter().map(|qarg| {
+                qubit_indices
+                    .get_item(qarg.0 as usize)
+                    .expect("Unexpected index error in DAG")
+            });


Is there a reason we need to be using a PyList for this? I feel like using a vec here makes more sense. There is a conversion cost coming from python but if we're calling this function recursively from rust or repeatedly accessing it optimizing for that will end up being a lot more efficient.

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

raynelfss · 2024-10-18T16:30:16Z

Currently reviewing... Any small changes I'll commit myself and merge

raynelfss

LGTM! Thank you for your hard work on this. Hopefully, we can make the interners private again in the future (hopefully #13335 is sufficient). I am excited about all the speedups this PR introduces :)

crates/accelerate/src/unitary_synthesis.rs

raynelfss · 2024-10-18T18:45:41Z

crates/accelerate/src/unitary_synthesis.rs

+                let res = py_run_main_loop(
+                    py,
+                    &mut circuit_to_dag(
+                        py,
+                        QuantumCircuitData::extract_bound(&raw_block?)?,
+                        false,
+                        None,
+                        None,
+                    )?,
+                    new_ids,
+                    min_qubits,
+                    target,
+                    coupling_edges,
+                    approximation_degree,
+                    natural_direction,
+                )?;
+                new_blocks.push(dag_to_circuit.call1((res,))?);
+            }


We can do this in a follow-up but we should consider adding a variant of this that also works with QuantumCircuit or CircuitData preferably. And so we avoid these two conversions.

raynelfss · 2024-10-18T18:48:05Z

crates/accelerate/src/unitary_synthesis.rs

+                            out_dag.apply_operation_back(
+                                py,
+                                gate.into(),
+                                &[qubit],
+                                &[],
+                                Some(new_params),
+                                ExtraInstructionAttributes::default(),
+                                #[cfg(feature = "cache_pygates")]
+                                None,
+                            )?;


For the follow-up we should consider using the stuff that will be added by #13335

crates/accelerate/src/unitary_synthesis.rs

- Leverage usage of new methods in `UnitarySynthesis` after Qiskit#13141 merged.

This commit fixes a performance regression that was introduced in PR Qiskit#13141. When the pass is looking up the preferred synthesis direction for a unitary based on the connectvity constraints the connectivity was being provided as a PyList. To look up the edge in connectivity set this meant we needed to iterate over the list and then create a set that rust could lookup if it contains an edge or it's reverse. This has significant overhead because its iterating via python and also iterating per decomposition. This commit addresses this by changing the input type to be a HashSet from Python so Pyo3 will convert a pyset directly to a HashSet once at call time and that's used by reference for lookups directly instead of needing to iterate over the list each time.

* Fix performance regression in UnitarySynthesis This commit fixes a performance regression that was introduced in PR #13141. When the pass is looking up the preferred synthesis direction for a unitary based on the connectvity constraints the connectivity was being provided as a PyList. To look up the edge in connectivity set this meant we needed to iterate over the list and then create a set that rust could lookup if it contains an edge or it's reverse. This has significant overhead because its iterating via python and also iterating per decomposition. This commit addresses this by changing the input type to be a HashSet from Python so Pyo3 will convert a pyset directly to a HashSet once at call time and that's used by reference for lookups directly instead of needing to iterate over the list each time. * Avoid constructing plugin data views with default plugin If we're using the default plugin the execution will happen in rust and we don't need to build the plugin data views that are defined in the plugin interface. Profiling the benchpress test using the hamlib hamiltonian: ham_graph-2D-grid-nonpbc-qubitnodes_Lx-5_Ly-186_h-0.5-all-to-all that caught this originally regression was showing an inordinate amount of time being spent in the construction of `_build_gate_lengths_by_qubit` and `_build_gate_errors_by_qubit` which isn't being used because this happens internally in rust now. To mitigate this overhead this commit migrates the sections computing these values to the code branch that uses them and not the default plugin branch that uses rust.

ElePT force-pushed the oxidize-unitary-synthesis branch from 479fbe0 to e4ec3ff Compare September 12, 2024 10:20

mtreinish added performance Rust This PR or issue is related to Rust code in the repository mod: transpiler Issues and PRs related to Transpiler labels Sep 12, 2024

ElePT force-pushed the oxidize-unitary-synthesis branch from 8de52b5 to e11ffe6 Compare September 12, 2024 10:55

mtreinish added this to the 1.3.0 milestone Sep 12, 2024

ElePT added 2 commits September 12, 2024 13:47

Inital attempt at oxidizing unitary synthesis.

7528db9

Add cacache pygates feature to accelerate

1296234

ElePT force-pushed the oxidize-unitary-synthesis branch from e11ffe6 to 1296234 Compare September 12, 2024 11:48

ElePT added 4 commits September 13, 2024 12:22

Use sabre target to speed up preferred_direction

4456b36

Merge branch 'main' of https://github.com/Qiskit/qiskit into oxidize-…

b2b202c

…unitary-synthesis

Adapt code to changes in PackedInstruction

c49acc1

Use target in preferred_direction

739a5c8

Some cleanup

f527018

ElePT commented Sep 16, 2024

View reviewed changes

crates/accelerate/src/unitary_synthesis.rs Outdated Show resolved Hide resolved

More cleanup

eb815d1

ElePT marked this pull request as ready for review September 16, 2024 16:06

ElePT requested review from alexanderivrii, ShellyGarion and a team as code owners September 16, 2024 16:06

ElePT changed the title ~~[WIP] Oxidize UnitarySynthesis pass~~ Oxidize UnitarySynthesis pass Sep 16, 2024

mtreinish reviewed Sep 16, 2024

View reviewed changes

Apply inline suggestions from Matt's code review

7498419

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

ElePT force-pushed the oxidize-unitary-synthesis branch 2 times, most recently from e560bf8 to 7498419 Compare September 18, 2024 10:08

Merge branch 'main' of https://github.com/Qiskit/qiskit into oxidize-…

594a697

…unitary-synthesis

ElePT force-pushed the oxidize-unitary-synthesis branch from f2673eb to 9cacf6f Compare October 9, 2024 15:49

ShellyGarion mentioned this pull request Oct 14, 2024

Add TwoQubitControlledUDecomposer to the UnitarySynthesis tranpiler pass #13320

Open

raynelfss reviewed Oct 14, 2024

View reviewed changes

ElePT added 2 commits October 15, 2024 17:29

Replace panics with unreachable

3c23470

Format

228f470

mtreinish reviewed Oct 17, 2024

View reviewed changes

ElePT and others added 3 commits October 18, 2024 15:59

Apply suggestions from Matt's code review

e21d0d7

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

Fix suggestions from Matt's code review

7f5eb02

Apply remaining suggestions

5deb7f5

raynelfss reviewed Oct 18, 2024

View reviewed changes

raynelfss added 2 commits October 18, 2024 15:08

Apply final suggestions from code review

40314f3

Lint: Use unwrap_or_default().

0bbf16a

raynelfss approved these changes Oct 18, 2024

View reviewed changes

raynelfss enabled auto-merge October 18, 2024 19:18

raynelfss linked an issue Oct 18, 2024 that may be closed by this pull request

Investigate porting unitary synthesis to rust #8774

Open

raynelfss removed a link to an issue Oct 18, 2024

Investigate porting unitary synthesis to rust #8774

Open

raynelfss added this pull request to the merge queue Oct 18, 2024

Merged via the queue into Qiskit:main with commit a9b8f4a Oct 18, 2024
15 checks passed

raynelfss added a commit to raynelfss/qiskit that referenced this pull request Oct 18, 2024

Add: Optional qargs/cargs in apply_operation_back

2776bd4

- Leverage usage of new methods in `UnitarySynthesis` after Qiskit#13141 merged.

mtreinish mentioned this pull request Oct 28, 2024

Fix performance regression in UnitarySynthesis #13375

Merged

raynelfss mentioned this pull request Oct 29, 2024

[Oxidize BasisTranslator]: Move the rest of the BasisTranslator to Rust. #13237

Merged

1 task

ShellyGarion added the Changelog: None Do not include in changelog label Nov 5, 2024

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Oxidize `UnitarySynthesis` pass #13141

Oxidize `UnitarySynthesis` pass #13141

ElePT commented Sep 12, 2024 •

edited

Loading

coveralls commented Sep 12, 2024 •

edited

Loading

ElePT commented Sep 13, 2024

ElePT commented Sep 16, 2024

qiskit-bot commented Sep 16, 2024

mtreinish left a comment

mtreinish Sep 16, 2024

raynelfss Oct 2, 2024

ElePT Oct 3, 2024

ElePT commented Oct 9, 2024

ElePT commented Oct 14, 2024 •

edited

Loading

raynelfss left a comment

raynelfss Oct 14, 2024

ElePT Oct 15, 2024

raynelfss Oct 14, 2024

raynelfss Oct 14, 2024

ShellyGarion commented Oct 15, 2024

mtreinish left a comment

mtreinish Oct 17, 2024

mtreinish Oct 17, 2024

ElePT Oct 18, 2024

mtreinish Oct 17, 2024

mtreinish Oct 17, 2024

raynelfss commented Oct 18, 2024

raynelfss left a comment

raynelfss Oct 18, 2024

raynelfss Oct 18, 2024

		let circuit_to_dag = imports::CIRCUIT_TO_DAG.get_bound(py);
		let dag_to_circuit = imports::DAG_TO_CIRCUIT.get_bound(py);

		let node_ids: Vec<NodeIndex> = dag.op_nodes(false).collect();
		for node in node_ids {

Oxidize UnitarySynthesis pass #13141

Oxidize UnitarySynthesis pass #13141

Conversation

ElePT commented Sep 12, 2024 • edited Loading

Summary

Details and comments

coveralls commented Sep 12, 2024 • edited Loading

Pull Request Test Coverage Report for Build 11409692028

Warning: This coverage report may be inaccurate.

Details

💛 - Coveralls

ElePT commented Sep 13, 2024

ElePT commented Sep 16, 2024

qiskit-bot commented Sep 16, 2024

mtreinish left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ElePT commented Oct 9, 2024

ElePT commented Oct 14, 2024 • edited Loading

raynelfss left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ShellyGarion commented Oct 15, 2024

mtreinish left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

raynelfss commented Oct 18, 2024

raynelfss left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Oxidize `UnitarySynthesis` pass #13141

Oxidize `UnitarySynthesis` pass #13141

ElePT commented Sep 12, 2024 •

edited

Loading

coveralls commented Sep 12, 2024 •

edited

Loading

ElePT commented Oct 14, 2024 •

edited

Loading