def noise_oracle(U, num_anc):
if num_anc == 0:
qc = QuantumCircuit(n_qubits)
if U.shape[0]==4 and np.linalg.norm(U-target_unitary) < 1e-8:
qc.swap(0,1)
else:
qc.unitary(U, list(range(n_qubits)))
qc = qiskit.compiler.transpile(qc, basis_gates=noise_model.basis_gates,
coupling_map=[[0,1]])
saved_circuits.append(qc)
qc_noisy = insert_noise(qc, noise_model)
return Choi(qc_noisy).data
elif num_anc == 1:
exp = channel_expand(n_qubits, num_anc)
tr = channel_trace(n_qubits, num_anc)
_,params = get_approx_circuit(U, n_qubits+num_anc, depth, full_connectivity)
qc = get_varform_circuit(params, n_qubits+num_anc, depth, full_connectivity)
coupling_map = [[0,1],[1,2],[0,2]] if full_connectivity else [[0,1],[1,2]]
qc = qiskit.compiler.transpile(qc, basis_gates=noise_model.basis_gates,
coupling_map=coupling_map)
saved_circuits.append(qc)
qc_noisy = insert_noise(qc, noise_model)
qc_noisy = SuperOp(qc_noisy)
return Choi( exp.compose(qc_noisy.compose(tr)) ).data
else: raise
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)
target_circuits = [target_circuit1, target_circuit2]
result_circuits = insert_noise(circuits_tuple, noise_model)
self.assertEqual(target_circuits, result_circuits)
def noisy_unitary(u, n_q=1):
qc = QuantumCircuit(n_q)
if u.shape[0]==4 and np.linalg.norm(u-target_unitary) < 1e-8:
qc.swap(0,1)
else:
qc.unitary(u, list(range(n_q)))
qc_noisy = insert_noise(qc, noise_model, transpile=True)
return Choi(qc_noisy)
def noise_oracle(U, num_anc):
exp = channel_expand(n_qubits, num_anc)
tr = channel_trace(n_qubits, num_anc)
qc = QuantumCircuit(num_anc + n_qubits)
qc.unitary(U, list(range(num_anc + n_qubits)))
qc_noisy = insert_noise(qc, noise_model, transpile=True)
qc_noisy = SuperOp(qc_noisy)
return Choi(exp.compose(qc_noisy.compose(tr))).data
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(target_circuit, 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()
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(target_circuit, 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, 'u1')
target_circuit = QuantumCircuit(qr)
target_circuit.x(qr[0])
target_circuit.append(error_x.to_instruction(), [qr[0]])
target_circuit.u3(pi, pi / 2, pi / 2, qr[1])
target_circuit.u1(pi, qr[2])
target_circuit.append(error_y.to_instruction(), [qr[2]])
result_circuit = insert_noise(circuit, noise_model, transpile=True)
self.assertEqual(target_circuit, 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))
counts = job.result().get_counts(qc)
if '1' not in counts: counts['1'] = 0
return counts['1'] / shots
U = random_unitary(2, seed=1234) # 1237
qc = QuantumCircuit(2, 1)
qc.unitary(U, [0])
qc.cx(0, 1)
probab_ref = get_probab(qc)
print(probab_ref)
# run circuits of different quasiprobability branches
probabs = list()
for qc in circuits:
qc_noisy = insert_noise(qc, noise_model)
if qc.num_qubits == 2:
qctot = QuantumCircuit(2, 1)
qctot.unitary(U, [0])
elif qc.num_qubits == 3:
qctot = QuantumCircuit(3, 1)
qctot.unitary(U, [0])
else:
raise
qctot += qc_noisy
probabs.append(get_probab(qctot))
#print(qctot)
probabs = np.array(probabs)
# check
print(np.sum(probabs * coeffs))
def noisy_unitary(u, n_q=1):
qc = QuantumCircuit(n_q)
qc.unitary(u, list(range(n_q)))
qc_noisy = insert_noise(qc, noise_model, transpile=True)
return Choi(qc_noisy)
sys.path.append("..")
from json_tools import *
from basis_ops import *
from decomposition import *
from diamond_norm import *
noise_model = NoiseModel.from_dict(json_from_file("2020_04_08.json"))
noise_model.add_quantum_error(noise_model._local_quantum_errors['cx']['2,3'], 'cx', [0,2])
noise_model.add_quantum_error(noise_model._local_quantum_errors['cx']['3,2'], 'cx', [2,0])
# target ops
qc = QuantumCircuit(1)
qc.ry(2.*np.arccos(np.sqrt(0.56789)), 0)
qc_noisy = insert_noise(qc, noise_model, transpile=True)
ry_unitary = Operator(qc).data
ry_choi = Choi(qc).data
ry_noisy = Choi(qc_noisy).data
qc = QuantumCircuit(2)
qc.cx(0,1)
qc_noisy = insert_noise(qc, noise_model, transpile=True)
cnot_unitary = Operator(qc).data
cnot_choi = Choi(qc).data
cnot_noisy = Choi(qc_noisy).data
qc = QuantumCircuit(2)
qc.swap(0,1)
qc_noisy = insert_noise(qc, noise_model, transpile=True)
