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())