Decomposition.hpp

Go to the documentation of this file.

// Copyright Quantinuum
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#pragma once
 
#include "Transform.hpp"
#include "tket/Architecture/Architecture.hpp"
 
namespace tket {
 
namespace Transforms {
 
Transform decompose_multi_qubits_TK2();
 
Transform decompose_multi_qubits_CX();
 
Transform decompose_single_qubits_TK1();
 
Transform decompose_ZYZ_to_TK1();
 
Transform decompose_ZXZ_to_TK1();
 
// converts all single-qubit gates into Rz and Rx gates
// Expects: any gates
// Produces: Rz, Rx and any multi-qubit gates
Transform decompose_ZX();
 
// converts all single-qubit gates into Rz and Ry gates
// Expects: any gates
// Produces: Rz, Ry and any multi-qubit gates
Transform decompose_ZY();
 
// converts all single-qubit gates into Rx and Ry gates
// Expects: any gates
// Produces: Rx, Ry and any multi-qubit gates
Transform decompose_XY();
 
// converts all TK1-gates into rzrx gates
// Expects: TK1-gates and any multi-qubit gates
// Produces: Rz, Rx and any multi-qubit gates
Transform decompose_tk1_to_rzrx();
 
// replaces CXs with ZZMax
// Expects: CX and any single-qubit gates
// Produces: ZZMax and any single-qubit gates
Transform decompose_CX_to_HQS2();
 
// replaces Rz-Rx-Rz triples with Rz-PhasedX pairs
// Expects: Rz, Rx, and any multi-qubit gates
// Produces: Rz, PhasedX, and any multi-qubit gates
Transform decompose_ZX_to_HQS1();
 
// converts all CX gates into Molmer-Sorensen gates by recognising exp(-i XX *
// angle * pi/2) and converting rest to exp(-i XX * pi/4) Expects: CX, Rx, and
// other single-qubit gates Produces: Molmer-Sorensen, U2, and other
// single-qubit gates
Transform decompose_MolmerSorensen();
 
Transform decompose_TK2(const TwoQbFidelities& fid, bool allow_swaps = true);
Transform decompose_TK2(bool allow_swaps = true);
 
Transform decompose_ZZPhase();
 
Transform decompose_cliffords_std(bool tk2_to_cx = true);
 
Transform decompose_ZX_to_cliffords();
 
// converts all valid CX-Rz-CX strings and CX-Rx-CX strings to 2qb
// PhaseGadgets Expects: CX, Rz, Rx and any other single-qubit gates Produces:
// PhaseGadgets, and any other gates
Transform decompose_PhaseGadgets();
 
Transform decomp_boxes(
    const std::unordered_set<OpType>& excluded_types = {},
    const std::unordered_set<std::string>& excluded_opgroups = {},
    const std::optional<std::unordered_set<OpType>>& included_types =
        std::nullopt,
    const std::optional<std::unordered_set<std::string>>& included_opgroups =
        std::nullopt);
 
Transform compose_phase_poly_boxes(unsigned min_size = 0);
 
// converts all SWAP gates to given replacement circuit (not checked to
// preserve unitary) Expects: SWAP gates, replacement circuit Produces:
// Instances of the replacement circuit,
Transform decompose_SWAP(const Circuit& replacement_circuit);
 
// converts all SWAP gates to 3 CX gates
// providing an Architecture will prefer an orientation that reduces H
// redirection cost -X-    -C-X-C-   -X-C-X-
//  |   =  | | |  =  | | |
// -X-    -X-C-X-   -C-X-C-
// Expects: SWAP gates
// Produces: CX gates
Transform decompose_SWAP_to_CX(const Architecture& arc = Architecture());
 
// converts all BRIDGE (distance 2 CX) gates to 4 CX gates
// -B-   -C-   -C---C---   ---C---C-
//  R     |     |   |         |   |
// -I- = --- = -X-C-X-C- = -C-X-C-X-
//  D     |       |   |     |   |
// -G-   -X-   ---X---X-   -X---X---
//  E
// Expects: BRIDGE gates
// Produces: CX gates
Transform decompose_BRIDGE_to_CX();
 
// converts -C- gates to -H-X-H- depending on direction of Architecture edges
//           |              |
//          -X-          -H-C-H-
// Expects: CX gates
// Produces CX and H gates
Transform decompose_CX_directed(const Architecture& arc);
 
Transform decompose_NPhasedX();
 
// does not use ancillae
// Expects: CCX + any other gates
// returns CX, H, T, Tdg + any previous gates
Transform decomp_CCX();
 
// converts arbitrarily controlled Ry gates. It does not use ancillae, so it
// is not very depth-efficient Expects: CRys and any other gates returns Ry,
// CX, H, T, Tdg + whatever other gates were there before
Transform decomp_controlled_Rys();
 
// does not use ancillae
// Expects: CCX, CnX, CnY, CnZ, CnRy, CnRx, CnRz, and any other gates
// returns CX and single-qubit gate + any previous gates
Transform decomp_arbitrary_controlled_gates();
 
// For every two CnX gates, we try to reorder their control qubits
// and adjust the direction of their decomposition (i.e. CnX = CnX.dagger)
// to improve the chance of gate cancellation. This method will not improve
// the decomposition when the CnX gates are scattered; but it works the best
// when CnX gates are very close to each other.
Transform cnx_pairwise_decomposition();
 
}  // namespace Transforms
 
}  // namespace tket