def test_multiple_inputs(self): qr = QuantumRegister(1, 'qr') circuit1 = QuantumCircuit(qr) circuit1.x(qr[0]) circuit2 = QuantumCircuit(qr) circuit2.y(qr[0]) circuits_list = [circuit1, circuit2] circuits_tuple = (circuit1, circuit2) noise_model = NoiseModel() error_x = pauli_error([('Y', 0.25), ('I', 0.75)]) error_y = pauli_error([('X', 0.35), ('Z', 0.65)]) noise_model.add_all_qubit_quantum_error(error_x, 'x') noise_model.add_all_qubit_quantum_error(error_y, 'y') target_circuit1 = QuantumCircuit(qr) target_circuit1.x(qr[0]) target_circuit1.append(error_x.to_instruction(), [qr[0]]) target_circuit2 = QuantumCircuit(qr) target_circuit2.y(qr[0]) target_circuit2.append(error_y.to_instruction(), [qr[0]]) target_circuits = [target_circuit1, target_circuit2] result_circuits = insert_noise(circuits_list, noise_model) self.assertEqual(target_circuits, result_circuits) targets = [SuperOp(i) for i in [target_circuit1, target_circuit2]] results = [ SuperOp(i) for i in insert_noise(circuits_tuple, noise_model) ] self.assertEqual(targets, results)
def set_superop(self, state): """Set the superop state of the simulator. Args: state (QuantumChannel): A CPTP quantum channel. Returns: QuantumCircuit: with attached instruction. Raises: ExtensionError: If the state is the incorrect size for the current circuit. ExtensionError: if the input QuantumChannel is not CPTP. .. note: This instruction is always defined across all qubits in a circuit. """ qubits = default_qubits(self) if not isinstance(state, SuperOp): state = SuperOp(state) if not state.num_qubits or state.num_qubits != len(qubits): raise ExtensionError( "The size of the quantum channel for the set_superop" " instruction must be equal to the number of qubits" f" in the circuit (state.num_qubits ({state.num_qubits})" f" != QuantumCircuit.num_qubits ({self.num_qubits})).") return self.append(SetSuperOp(state), qubits)
def initial_state_converter( obj: Any, return_class: bool = False) -> Union[Array, Tuple[Array, Type]]: """Convert initial state object to an Array. Args: obj: An initial state. return_class: Optional. If True return the class to use for converting the output y Array. Returns: Array: the converted initial state if ``return_class=False``. tuple: (Array, class) if ``return_class=True``. """ # pylint: disable=invalid-name y0_cls = None if isinstance(obj, Array): y0, y0_cls = obj, None if isinstance(obj, QuantumState): y0, y0_cls = Array(obj.data), obj.__class__ elif isinstance(obj, QuantumChannel): y0, y0_cls = Array(SuperOp(obj).data), SuperOp elif isinstance(obj, (BaseOperator, Gate, QuantumCircuit)): y0, y0_cls = Array(Operator(obj.data)), Operator else: y0, y0_cls = Array(obj), None if return_class: return y0, y0_cls return y0
def test_no_noise(self): qr = QuantumRegister(3, 'qr') circuit = QuantumCircuit(qr) circuit.x(qr[0]) circuit.y(qr[1]) circuit.z(qr[2]) target_circuit = QuantumCircuit(qr) target_circuit.x(qr[0]) target_circuit.y(qr[1]) target_circuit.z(qr[2]) noise_model = NoiseModel() #empty result_circuit = insert_noise(circuit, noise_model) self.assertEqual(SuperOp(target_circuit), SuperOp(result_circuit))
def test_nonlocal_quantum_errors(self): qr = QuantumRegister(3, 'qr') circuit = QuantumCircuit(qr) circuit.x(qr[0]) circuit.x(qr[2]) error_x = pauli_error([('Y', 0.25), ('I', 0.75)]) noise_model = NoiseModel() with self.assertWarns(DeprecationWarning): noise_model.add_nonlocal_quantum_error(error_x, 'x', [0], [1]) target_circuit = QuantumCircuit(qr) target_circuit.x(qr[0]) target_circuit.append(error_x.to_instruction(), [qr[1]]) target_circuit.x(qr[2]) result_circuit = insert_noise(circuit, noise_model) self.assertEqual(SuperOp(target_circuit), SuperOp(result_circuit))
def __init__(self, state): """Create new instruction to set the superop simulator state. Args: state (QuantumChannel): A CPTP quantum channel. Raises: ExtensionError: if the input QuantumChannel is not CPTP. .. note:: This set instruction must always be performed on the full width of qubits in a circuit, otherwise an exception will be raised during simulation. """ if not isinstance(state, SuperOp): state = SuperOp(state) if not state.num_qubits or not state.is_cptp(): raise ExtensionError("The input quantum channel is not CPTP") super().__init__('set_superop', state.num_qubits, 0, [state.data])
def test_local_quantum_errors(self): qr = QuantumRegister(3, 'qr') circuit = QuantumCircuit(qr) circuit.x(qr[0]) circuit.x(qr[1]) circuit.y(qr[2]) error_x = pauli_error([('Y', 0.25), ('I', 0.75)]) error_y = pauli_error([('X', 0.35), ('Z', 0.65)]) noise_model = NoiseModel() noise_model.add_quantum_error(error_x, 'x', [0]) noise_model.add_quantum_error(error_y, 'y', [2]) target_circuit = QuantumCircuit(qr) target_circuit.x(qr[0]) target_circuit.append(error_x.to_instruction(), [qr[0]]) target_circuit.x(qr[1]) target_circuit.y(qr[2]) target_circuit.append(error_y.to_instruction(), [qr[2]]) result_circuit = insert_noise(circuit, noise_model) self.assertEqual(SuperOp(target_circuit), SuperOp(result_circuit))
def test_transpiling(self): qr = QuantumRegister(3, 'qr') circuit = QuantumCircuit(qr) circuit.x(qr[0]) circuit.y(qr[1]) circuit.z(qr[2]) error_x = pauli_error([('Y', 0.25), ('I', 0.75)]) error_y = pauli_error([('X', 0.35), ('Z', 0.65)]) noise_model = NoiseModel() noise_model.add_all_qubit_quantum_error(error_x, 'x') noise_model.add_all_qubit_quantum_error(error_y, 'y') target_circuit = QuantumCircuit(qr) target_circuit.x(qr[0]) target_circuit.append(error_x.to_instruction(), [qr[0]]) target_circuit.y(qr[1]) target_circuit.append(error_y.to_instruction(), [qr[1]]) target_circuit.z(qr[2]) target_basis = ['kraus'] + noise_model.basis_gates target_circuit = transpile(target_circuit, basis_gates=target_basis) result_circuit = insert_noise(circuit, noise_model, transpile=True) self.assertEqual(SuperOp(target_circuit), SuperOp(result_circuit))
def _format_povms(povms: Sequence[any]) -> Tuple[Tuple[np.ndarray, ...], ...]: """Format sequence of basis POVMs""" formatted_povms = [] # Convert from operator/channel to POVM effects for povm in povms: if isinstance(povm, (list, tuple)): # POVM is already an effect formatted_povms.append(povm) continue # Convert POVM to operator of quantum channel try: chan = Operator(povm) except QiskitError: chan = SuperOp(povm) adjoint = chan.adjoint() dims = adjoint.input_dims() dim = np.prod(dims) effects = tuple(DensityMatrix.from_int(i, dims).evolve(adjoint) for i in range(dim)) formatted_povms.append(effects) # Format POVM effects to density matrix matrices return tuple(tuple(DensityMatrix(effect).data for effect in povm) for povm in formatted_povms)
nwqsim = NWQSimProvider('NWQSim') print(nwqsim.backends) backend = nwqsim.backends['dmsim_cpu'] backend.set_n_cpus(4) #Bell State circuit = QuantumCircuit(2, 2) circuit.h(0) circuit.cx(0, 1) circuit.measure([0, 1], [0, 1]) noise_model = NoiseModel() #Add amplitude and phase damping error for 1-qubit param_amplitude_damping = 0.05 param_phase_damping = 0.03 amplitude_error = amplitude_damping_error(param_amplitude_damping) phase_error = phase_damping_error(param_phase_damping) qerror_q1 = phase_error.compose(amplitude_error) #Add depolarizing error for 2-qubit param_q2 = 0.08 qerror_q2 = depolarizing_error(param_q2, 2) q1_superop = SuperOp(qerror_q1) q2_superop = SuperOp(qerror_q2) backend.set_noise_1q_sop(q1_superop) backend.set_noise_2q_sop(q2_superop) result = execute(circuit, backend, seed_transpiler=111).result() print(result.get_counts(circuit)) print(result.get_statevector())