def _define(self): definition = [] qr = QuantumRegister(self.num_qubits) oracle_qr = [qr[i] for i in self.oracle_qubits] # Prepare the auxiliary qubit into the Hadamard minus state. definition.append((HGate(), [qr[-1]], [])) definition.append((ZGate(), [qr[-1]], [])) # Add the boolean oracle whose behavior is # determined by the auxiliary qubit. definition.append((BooleanOracleGate(self.classical_boolean_oracle), oracle_qr + [qr[-1]], [])) # Add the inverse of the quantum algorithm. definition.append((self.quantum_algorithm.inverse(), qr[:-1], [])) # Add the 'inversion around the mean' operator as a # special boolean oracle that behaves as a phase oracle # because of how was set the auxiliary qubit. definition.append( (BooleanOracleGate([1] + [0] * (2**(self.num_qubits - 1) - 1)), qr[:], [])) # Add the quantum algorithm. definition.append((self.quantum_algorithm, qr[:-1], [])) # Revert the auxiliary qubit to zero. definition.append((ZGate(), [qr[-1]], [])) definition.append((HGate(), [qr[-1]], [])) self.definition = definition
def _rzx_dag(parameter): _rzx_dag = DAGCircuit() qr = QuantumRegister(2) _rzx_dag.add_qreg(qr) _rzx_dag.apply_operation_back(HGate(), [qr[0]], []) _rzx_dag.apply_operation_back(HGate(), [qr[1]], []) _rzx_dag.apply_operation_back(RZXGate(parameter), [qr[1], qr[0]], []) _rzx_dag.apply_operation_back(HGate(), [qr[0]], []) _rzx_dag.apply_operation_back(HGate(), [qr[1]], []) return _rzx_dag
def _reverse_echo_rzx_dag(theta): reverse_rzx_dag = DAGCircuit() qr = QuantumRegister(2) reverse_rzx_dag.add_qreg(qr) reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], []) reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], []) reverse_rzx_dag.apply_operation_back(RZXGate(theta / 2), [qr[1], qr[0]], []) reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], []) reverse_rzx_dag.apply_operation_back(RZXGate(-theta / 2), [qr[1], qr[0]], []) reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], []) reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], []) reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], []) return reverse_rzx_dag
def test_clifford_circuit_noise(self, method, device): """Test simulation with mixed Clifford quantum errors in circuit.""" backend = self.backend(method=method, device=device) shots = 1000 error1 = noise.QuantumError([ ([(IGate(), [0])], 0.8), ([(Reset(), [0])], 0.1), ([(HGate(), [0])], 0.1)]) error2 = noise.QuantumError([ ([(IGate(), [0])], 0.75), ([(Reset(), [0])], 0.1), ([(Reset(), [1])], 0.1), ([(Reset(), [0]), (Reset(), [1])], 0.05)]) qc = QuantumCircuit(2) qc.h(0) qc.append(error1, [0]) qc.cx(0, 1) qc.append(error2, [0, 1]) target_probs = qi.DensityMatrix(qc).probabilities_dict() # Add measurement qc.measure_all() result = backend.run(qc, shots=shots).result() self.assertSuccess(result) probs = {key: val / shots for key, val in result.get_counts(0).items()} self.assertDictAlmostEqual(target_probs, probs, delta=0.1)
def setUp(self): super().setUp() self.ops = { 'X': XGate(), 'Y': YGate(), 'Z': ZGate(), 'H': HGate(), 'S': SGate() }
def from_label(cls, label): """Return a tensor product of single-qubit operators. Args: label (string): single-qubit operator string. Returns: Operator: The N-qubit operator. Raises: QiskitError: if the label contains invalid characters, or the length of the label is larger than an explicitly specified num_qubits. Additional Information: The labels correspond to the single-qubit matrices: 'I': [[1, 0], [0, 1]] 'X': [[0, 1], [1, 0]] 'Y': [[0, -1j], [1j, 0]] 'Z': [[1, 0], [0, -1]] 'H': [[1, 1], [1, -1]] / sqrt(2) 'S': [[1, 0], [0 , 1j]] 'T': [[1, 0], [0, (1+1j) / sqrt(2)]] '0': [[1, 0], [0, 0]] '1': [[0, 0], [0, 1]] '+': [[0.5, 0.5], [0.5 , 0.5]] '-': [[0.5, -0.5], [-0.5 , 0.5]] 'r': [[0.5, -0.5j], [0.5j , 0.5]] 'l': [[0.5, 0.5j], [-0.5j , 0.5]] """ # Check label is valid label_mats = { 'I': IGate().to_matrix(), 'X': XGate().to_matrix(), 'Y': YGate().to_matrix(), 'Z': ZGate().to_matrix(), 'H': HGate().to_matrix(), 'S': SGate().to_matrix(), 'T': TGate().to_matrix(), '0': np.array([[1, 0], [0, 0]], dtype=complex), '1': np.array([[0, 0], [0, 1]], dtype=complex), '+': np.array([[0.5, 0.5], [0.5, 0.5]], dtype=complex), '-': np.array([[0.5, -0.5], [-0.5, 0.5]], dtype=complex), 'r': np.array([[0.5, -0.5j], [0.5j, 0.5]], dtype=complex), 'l': np.array([[0.5, 0.5j], [-0.5j, 0.5]], dtype=complex), } if re.match(r'^[IXYZHST01rl\-+]+$', label) is None: raise QiskitError('Label contains invalid characters.') # Initialize an identity matrix and apply each gate num_qubits = len(label) op = Operator(np.eye(2 ** num_qubits, dtype=complex)) for qubit, char in enumerate(reversed(label)): if char != 'I': op = op.compose(label_mats[char], qargs=[qubit]) return op
def from_label(label): """Return a tensor product of single-qubit Clifford gates. Args: label (string): single-qubit operator string. Returns: Clifford: The N-qubit Clifford operator. Raises: QiskitError: if the label contains invalid characters. Additional Information: The labels correspond to the single-qubit Cliffords are * - Label - Stabilizer - Destabilizer * - ``"I"`` - +Z - +X * - ``"X"`` - -Z - +X * - ``"Y"`` - -Z - -X * - ``"Z"`` - +Z - -X * - ``"H"`` - +X - +Z * - ``"S"`` - +Z - +Y """ # Check label is valid label_gates = { 'I': IGate(), 'X': XGate(), 'Y': YGate(), 'Z': ZGate(), 'H': HGate(), 'S': SGate() } if re.match(r'^[IXYZHS\-+]+$', label) is None: raise QiskitError('Label contains invalid characters.') # Initialize an identity matrix and apply each gate num_qubits = len(label) op = Clifford(np.eye(2 * num_qubits, dtype=np.bool)) for qubit, char in enumerate(reversed(label)): _append_circuit(op, label_gates[char], qargs=[qubit]) return op
def __init__(self, coupling_map, target=None): """GateDirection pass. Args: coupling_map (CouplingMap): Directed graph represented a coupling map. target (Target): The backend target to use for this pass. If this is specified it will be used instead of the coupling map """ super().__init__() self.coupling_map = coupling_map self.target = target # Create the replacement dag and associated register. self._cx_dag = DAGCircuit() qr = QuantumRegister(2) self._cx_dag.add_qreg(qr) self._cx_dag.apply_operation_back(HGate(), [qr[0]], []) self._cx_dag.apply_operation_back(HGate(), [qr[1]], []) self._cx_dag.apply_operation_back(CXGate(), [qr[1], qr[0]], []) self._cx_dag.apply_operation_back(HGate(), [qr[0]], []) self._cx_dag.apply_operation_back(HGate(), [qr[1]], []) self._ecr_dag = DAGCircuit() qr = QuantumRegister(2) self._ecr_dag.add_qreg(qr) self._ecr_dag.apply_operation_back(RYGate(-pi / 2), [qr[0]], []) self._ecr_dag.apply_operation_back(RYGate(pi / 2), [qr[1]], []) self._ecr_dag.apply_operation_back(ECRGate(), [qr[1], qr[0]], []) self._ecr_dag.apply_operation_back(HGate(), [qr[0]], []) self._ecr_dag.apply_operation_back(HGate(), [qr[1]], [])
def __init__(self, coupling_map): """GateDirection pass. Args: coupling_map (CouplingMap): Directed graph represented a coupling map. """ super().__init__() self.coupling_map = coupling_map # Create the replacement dag and associated register. self._cx_dag = DAGCircuit() qr = QuantumRegister(2) self._cx_dag.add_qreg(qr) self._cx_dag.apply_operation_back(HGate(), [qr[0]], []) self._cx_dag.apply_operation_back(HGate(), [qr[1]], []) self._cx_dag.apply_operation_back(CXGate(), [qr[1], qr[0]], []) self._cx_dag.apply_operation_back(HGate(), [qr[0]], []) self._cx_dag.apply_operation_back(HGate(), [qr[1]], []) self._ecr_dag = DAGCircuit() qr = QuantumRegister(2) self._ecr_dag.add_qreg(qr) self._ecr_dag.apply_operation_back(RYGate(-pi / 2), [qr[0]], []) self._ecr_dag.apply_operation_back(RYGate(pi / 2), [qr[1]], []) self._ecr_dag.apply_operation_back(ECRGate(), [qr[1], qr[0]], []) self._ecr_dag.apply_operation_back(HGate(), [qr[0]], []) self._ecr_dag.apply_operation_back(HGate(), [qr[1]], [])
def _reverse_echo_rzx_dag(theta): """Return the following circuit .. parsed-literal:: ┌───┐┌───────────────┐ ┌────────────────┐┌───┐ q_0: ┤ H ├┤1 ├─────┤1 ├┤ H ├───── ├───┤│ Rzx(theta/2) │┌───┐│ Rzx(-theta/2) │├───┤┌───┐ q_1: ┤ H ├┤0 ├┤ X ├┤0 ├┤ X ├┤ H ├ └───┘└───────────────┘└───┘└────────────────┘└───┘└───┘ """ reverse_rzx_dag = DAGCircuit() qr = QuantumRegister(2) reverse_rzx_dag.add_qreg(qr) reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], []) reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], []) reverse_rzx_dag.apply_operation_back(RZXGate(theta / 2), [qr[1], qr[0]], []) reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], []) reverse_rzx_dag.apply_operation_back(RZXGate(-theta / 2), [qr[1], qr[0]], []) reverse_rzx_dag.apply_operation_back(XGate(), [qr[1]], []) reverse_rzx_dag.apply_operation_back(HGate(), [qr[0]], []) reverse_rzx_dag.apply_operation_back(HGate(), [qr[1]], []) return reverse_rzx_dag
def _define(self): definition = [] qr = QuantumRegister(self.num_qubits) for i in reversed(range(self.num_qubits)): definition.append((HGate(), [qr[i]], [])) for j in range(i): definition.append( (CU1Gate(np.pi / 2.0**(i - j)), [qr[j], qr[i]], [])) if self.do_swaps: for i in range(self.num_qubits // 2): definition.append( (SwapGate(), [qr[i], qr[self.num_qubits - 1 - i]], [])) self.definition = definition
def _define(self): definition = [] # qr[:self.num_phase_qubits]: phase qubits # qr[self.num_phase_qubits:]: state qubits qr = QuantumRegister(self.num_qubits) # Loop over the phase qubits. for i in range(self.num_phase_qubits): definition.append((HGate(), [qr[i]], [])) for _ in range(2**i): definition.append( (self.unitary_gate.control(num_ctrl_qubits=1), [qr[i]] + qr[self.num_phase_qubits:], [])) definition.append((QFTGate(self.num_phase_qubits).inverse(), qr[:self.num_phase_qubits], [])) self.definition = definition
def __init__( self, feature_dimension: Optional[int] = None, reps: int = 2, entanglement: Union[str, List[List[int]], Callable[[int], List[int]]] = "full", alpha: float = 2.0, paulis: Optional[List[str]] = None, data_map_func: Optional[Callable[[np.ndarray], float]] = None, parameter_prefix: str = "x", insert_barriers: bool = False, name: str = "PauliFeatureMap", ) -> None: """Create a new Pauli expansion circuit. Args: feature_dimension: Number of qubits in the circuit. reps: The number of repeated circuits. entanglement: Specifies the entanglement structure. Refer to :class:`~qiskit.circuit.library.NLocal` for detail. alpha: The Pauli rotation factor, multiplicative to the pauli rotations paulis: A list of strings for to-be-used paulis. If None are provided, ``['Z', 'ZZ']`` will be used. data_map_func: A mapping function for data x which can be supplied to override the default mapping from :meth:`self_product`. parameter_prefix: The prefix used if default parameters are generated. insert_barriers: If True, barriers are inserted in between the evolution instructions and hadamard layers. """ super().__init__( num_qubits=feature_dimension, reps=reps, rotation_blocks=HGate(), entanglement=entanglement, parameter_prefix=parameter_prefix, insert_barriers=insert_barriers, skip_final_rotation_layer=True, name=name, ) self._data_map_func = data_map_func or self_product self._paulis = paulis or ["Z", "ZZ"] self._alpha = alpha
def get_subcircuit_instance(subcircuit_idx, subcircuit, combinations): circ_dict = {} for combination_ctr, combination in enumerate(combinations): # print('combination %d/%d :'%(combination_ctr,len(combinations)),combination) subcircuit_dag = circuit_to_dag(subcircuit) inits, meas = combination for i, x in enumerate(inits): q = subcircuit.qubits[i] if x == 'zero': continue elif x == 'one': subcircuit_dag.apply_operation_front(op=XGate(), qargs=[q], cargs=[]) elif x == 'plus': subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) elif x == 'minus': subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=XGate(), qargs=[q], cargs=[]) elif x == 'plusI': subcircuit_dag.apply_operation_front(op=SGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) elif x == 'minusI': subcircuit_dag.apply_operation_front(op=SGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=XGate(), qargs=[q], cargs=[]) else: raise Exception('Illegal initialization : ', x) for i, x in enumerate(meas): q = subcircuit.qubits[i] if x == 'I' or x == 'comp': continue elif x == 'X': subcircuit_dag.apply_operation_back(op=HGate(), qargs=[q], cargs=[]) elif x == 'Y': subcircuit_dag.apply_operation_back(op=SdgGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_back(op=HGate(), qargs=[q], cargs=[]) else: raise Exception('Illegal measurement basis:', x) subcircuit_inst = dag_to_circuit(subcircuit_dag) # NOTE: Adjust subcircuit shots here num_shots = max(8192, int(2**subcircuit_inst.num_qubits)) num_shots = min(8192 * 10, num_shots) circ_dict[(subcircuit_idx, tuple(inits), tuple(meas))] = { 'circuit': subcircuit_inst, 'shots': num_shots } return circ_dict
eq_lib = EquivalenceLibrary() theta = Parameter('theta') phi = Parameter('phi') lamda = Parameter('lamda') u3 = U3Gate(theta, phi, lamda) u2 = U2Gate(theta, phi) u1 = U1Gate(theta) ccx = CCXGate() q = QuantumRegister(1, 'q') equiv_u3 = QuantumCircuit(q) equiv_u3.append(RZGate(phi+(pi/2)), [q[0]], []) equiv_u3.append(HGate(),[q[0]], [] ) equiv_u3.append(RZGate(theta),[q[0]], []) equiv_u3.append(HGate(), [q[0]], []) equiv_u3.append(RZGate(lamda-(pi/2)),[q[0]], 0) eq_lib.add_equivalence(u3, equiv_u3) q = QuantumRegister(1, 'q') equiv_u2 = QuantumCircuit(q) equiv_u2.append(RZGate(theta+(pi/2)), [q[0]], []) equiv_u2.append(HGate(),[q[0]], [] ) equiv_u2.append(RZGate(pi/2),[q[0]], []) equiv_u2.append(HGate(), [q[0]], []) equiv_u2.append(RZGate(phi-(pi/2)),[q[0]], 0) eq_lib.add_equivalence(u2, equiv_u2)
def func(op, qubits): if tuple(qubits) == (1, ): return HGate() return None
def func(op, qubits): # return H for qubit 1 and None for the other qubits if tuple(qubits) == (1, ): return HGate() return None
def modify_subcircuit_instance(subcircuit, init, meas): """ Modify the different init, meas for a given subcircuit Returns: Modified subcircuit_instance List of mutated measurements """ subcircuit_dag = circuit_to_dag(subcircuit) subcircuit_instance_dag = copy.deepcopy(subcircuit_dag) for i, x in enumerate(init): q = subcircuit.qubits[i] if x == "zero": continue elif x == "one": subcircuit_instance_dag.apply_operation_front( op=XGate(), qargs=[q], cargs=[] ) elif x == "plus": subcircuit_instance_dag.apply_operation_front( op=HGate(), qargs=[q], cargs=[] ) elif x == "minus": subcircuit_instance_dag.apply_operation_front( op=HGate(), qargs=[q], cargs=[] ) subcircuit_instance_dag.apply_operation_front( op=XGate(), qargs=[q], cargs=[] ) elif x == "plusI": subcircuit_instance_dag.apply_operation_front( op=SGate(), qargs=[q], cargs=[] ) subcircuit_instance_dag.apply_operation_front( op=HGate(), qargs=[q], cargs=[] ) elif x == "minusI": subcircuit_instance_dag.apply_operation_front( op=SGate(), qargs=[q], cargs=[] ) subcircuit_instance_dag.apply_operation_front( op=HGate(), qargs=[q], cargs=[] ) subcircuit_instance_dag.apply_operation_front( op=XGate(), qargs=[q], cargs=[] ) else: raise Exception("Illegal initialization :", x) for i, x in enumerate(meas): q = subcircuit.qubits[i] if x == "I" or x == "comp": continue elif x == "X": subcircuit_instance_dag.apply_operation_back( op=HGate(), qargs=[q], cargs=[] ) elif x == "Y": subcircuit_instance_dag.apply_operation_back( op=SdgGate(), qargs=[q], cargs=[] ) subcircuit_instance_dag.apply_operation_back( op=HGate(), qargs=[q], cargs=[] ) else: raise Exception("Illegal measurement basis:", x) subcircuit_instance_circuit = dag_to_circuit(subcircuit_instance_dag) return subcircuit_instance_circuit
def get_one_subcircuit_instances(subcircuit, combinations): ''' Modify the different init, meas for a given subcircuit Returns: subcircuit_instances[subcircuit_instance_idx] = circuit, init, meas, shots subcircuit_instances_idx[init,meas] = subcircuit_instance_idx ''' subcircuit_instances = {} subcircuit_instances_idx = {} for combination_ctr, combination in enumerate(combinations): # print('combination %d/%d :'%(combination_ctr+1,len(combinations)),combination) subcircuit_dag = circuit_to_dag(subcircuit) inits, meas = combination for i, x in enumerate(inits): q = subcircuit.qubits[i] if x == 'zero': continue elif x == 'one': subcircuit_dag.apply_operation_front(op=XGate(), qargs=[q], cargs=[]) elif x == 'plus': subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) elif x == 'minus': subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=XGate(), qargs=[q], cargs=[]) elif x == 'plusI': subcircuit_dag.apply_operation_front(op=SGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) elif x == 'minusI': subcircuit_dag.apply_operation_front(op=SGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=HGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_front(op=XGate(), qargs=[q], cargs=[]) else: raise Exception('Illegal initialization : ', x) for i, x in enumerate(meas): q = subcircuit.qubits[i] if x == 'I' or x == 'comp': continue elif x == 'X': subcircuit_dag.apply_operation_back(op=HGate(), qargs=[q], cargs=[]) elif x == 'Y': subcircuit_dag.apply_operation_back(op=SdgGate(), qargs=[q], cargs=[]) subcircuit_dag.apply_operation_back(op=HGate(), qargs=[q], cargs=[]) else: raise Exception('Illegal measurement basis:', x) subcircuit_inst = dag_to_circuit(subcircuit_dag) num_shots = max(8192, int(2**subcircuit_inst.num_qubits)) num_shots = min(8192 * 10, num_shots) mutated_meas = mutate_measurement_basis(meas) for idx, meas in enumerate(mutated_meas): subcircuit_instance_idx = len(subcircuit_instances) if idx == 0: parent_subcircuit_instance_idx = subcircuit_instance_idx shots = num_shots else: shots = 0 subcircuit_instances[subcircuit_instance_idx] = { 'circuit': subcircuit_inst, 'init': tuple(inits), 'meas': tuple(meas), 'shots': shots, 'parent': parent_subcircuit_instance_idx } subcircuit_instances_idx[(tuple(inits), tuple(meas))] = subcircuit_instance_idx return subcircuit_instances, subcircuit_instances_idx
def _standard_gate_instruction(instruction, ignore_phase=True): """Temporary function to create Instruction objects from a json string, which is necessary for creating a new QuantumError object from deprecated json-based input. Note that the type of returned object is different from the deprecated standard_gate_instruction. TODO: to be removed after deprecation period. Args: instruction (dict): A qobj instruction. ignore_phase (bool): Ignore global phase on unitary matrix in comparison to canonical unitary. Returns: list: a list of (instructions, qubits) equivalent to in input instruction. """ gate = { "id": IGate(), "x": XGate(), "y": YGate(), "z": ZGate(), "h": HGate(), "s": SGate(), "sdg": SdgGate(), "t": TGate(), "tdg": TdgGate(), "cx": CXGate(), "cz": CZGate(), "swap": SwapGate() } name = instruction.get("name", None) qubits = instruction["qubits"] if name in gate: return [(gate[name], qubits)] if name not in ["mat", "unitary", "kraus"]: return [instruction] params = instruction["params"] with warnings.catch_warnings(): warnings.filterwarnings("ignore", category=DeprecationWarning, module="qiskit.providers.aer.noise.errors.errorutils") # Check for single-qubit reset Kraus if name == "kraus": if len(qubits) == 1: superop = SuperOp(Kraus(params)) # Check if reset to |0> reset0 = reset_superop(1) if superop == reset0: return [(Reset(), [0])] # Check if reset to |1> reset1 = reset0.compose(Operator(standard_gate_unitary('x'))) if superop == reset1: return [(Reset(), [0]), (XGate(), [0])] return [instruction] # Check single qubit gates mat = params[0] if len(qubits) == 1: # Check clifford gates for j in range(24): if matrix_equal( mat, single_qubit_clifford_matrix(j), ignore_phase=ignore_phase): return [(gate, [0]) for gate in _CLIFFORD_GATES[j]] # Check t gates for name in ["t", "tdg"]: if matrix_equal( mat, standard_gate_unitary(name), ignore_phase=ignore_phase): return [(gate[name], qubits)] # TODO: u1,u2,u3 decomposition # Check two qubit gates if len(qubits) == 2: for name in ["cx", "cz", "swap"]: if matrix_equal( mat, standard_gate_unitary(name), ignore_phase=ignore_phase): return [(gate[name], qubits)] # Check reversed CX if matrix_equal( mat, standard_gate_unitary("cx_10"), ignore_phase=ignore_phase): return [(CXGate(), [qubits[1], qubits[0]])] # Check 2-qubit Pauli's paulis = ["id", "x", "y", "z"] for pauli0 in paulis: for pauli1 in paulis: pmat = np.kron( standard_gate_unitary(pauli1), standard_gate_unitary(pauli0)) if matrix_equal(mat, pmat, ignore_phase=ignore_phase): if pauli0 == "id": return [(gate[pauli1], [qubits[1]])] elif pauli1 == "id": return [(gate[pauli0], [qubits[0]])] else: return [(gate[pauli0], [qubits[0]]), (gate[pauli1], [qubits[1]])] # Check three qubit toffoli if len(qubits) == 3: if matrix_equal( mat, standard_gate_unitary("ccx_012"), ignore_phase=ignore_phase): return [(CCXGate(), qubits)] if matrix_equal( mat, standard_gate_unitary("ccx_021"), ignore_phase=ignore_phase): return [(CCXGate(), [qubits[0], qubits[2], qubits[1]])] if matrix_equal( mat, standard_gate_unitary("ccx_120"), ignore_phase=ignore_phase): return [(CCXGate(), [qubits[1], qubits[2], qubits[0]])] # Else return input in return [instruction]
( 'x', ), ('y', ), ('s', 'x'), ('sdg', 'x') ] return labels[j] _CLIFFORD_GATES = [ (IGate(), ), (SGate(), ), (SdgGate(), ), (ZGate(), ), # u2 gates (HGate(), ), (HGate(), ZGate()), (ZGate(), HGate()), (HGate(), SGate()), (SGate(), HGate()), (HGate(), SdgGate()), (SdgGate(), HGate()), (SGate(), HGate(), SGate()), (SdgGate(), HGate(), SGate()), (ZGate(), HGate(), SGate()), (SGate(), HGate(), SdgGate()), (SdgGate(), HGate(), SdgGate()), (ZGate(), HGate(), SdgGate()), (SGate(), HGate(), ZGate()), (SdgGate(), HGate(), ZGate()), (ZGate(), HGate(), ZGate()),