def test_phase_damping_error_canonical(self): """Test phase damping error with canonical kraus""" p_phase = 0.3 error = phase_damping_error(p_phase, canonical_kraus=True) # The canonical form of this channel should be a mixed # unitary dephasing channel targets = [qi.Pauli("I").to_matrix(), qi.Pauli("Z").to_matrix()] self.assertEqual(error.size, 1) circ, p = error.error_term(0) self.assertEqual(p, 1, msg="Kraus probability") self.assertEqual(circ[0][1], [circ.qubits[0]]) for actual, expected in zip(circ[0][0].params, targets): self.assertTrue(np.allclose(actual/actual[0][0], expected), msg="Incorrect kraus matrix")
def test_save_expval_var_cptp_pauli(self, pauli): """Test Pauli expval_var for stabilizer circuit""" SUPPORTED_METHODS = [ 'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust' ] SEED = 5832 opts = self.BACKEND_OPTS.copy() if opts.get('method') in SUPPORTED_METHODS: oper = qi.Pauli(pauli) # CPTP channel test circuit channel = qi.random_quantum_channel(4, seed=SEED) state_circ = QuantumCircuit(2) state_circ.append(channel, range(2)) state = qi.DensityMatrix(state_circ) expval = state.expectation_value(oper).real variance = state.expectation_value(oper**2).real - expval**2 target = [expval, variance] # Snapshot circuit circ = transpile(state_circ, self.SIMULATOR) circ.save_expectation_value_variance(oper, [0, 1], label='expval') qobj = assemble(circ) result = self.SIMULATOR.run(qobj, **opts).result() self.assertTrue(result.success) value = result.data(0)['expval'] self.assertTrue(allclose(value, target))
def test_save_expval_nonstabilizer_pauli(self, pauli): """Test Pauli expval for non-stabilizer circuit""" SUPPORTED_METHODS = [ 'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust', 'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust', 'matrix_product_state' ] SEED = 7382 # Stabilizer test circuit state_circ = QuantumVolume(2, 1, seed=SEED) oper = qi.Pauli(pauli) state = qi.Statevector(state_circ) target = state.expectation_value(oper).real.round(10) # Snapshot circuit opts = self.BACKEND_OPTS.copy() method = opts.get('method', 'automatic') circ = transpile(state_circ, basis_gates=['u1', 'u2', 'u3', 'cx', 'swap']) circ.save_expectation_value('expval', oper, [0, 1]) qobj = assemble(circ) result = self.SIMULATOR.run(qobj, **opts).result() if method not in SUPPORTED_METHODS: self.assertFalse(result.success) else: self.assertTrue(result.success) value = result.data(0)['expval'] self.assertAlmostEqual(value, target)
def test_save_expval_var_stabilizer_pauli(self, pauli): """Test Pauli expval_var for stabilizer circuit""" SUPPORTED_METHODS = [ 'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust', 'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust', 'matrix_product_state', 'stabilizer' ] SEED = 5832 # Stabilizer test circuit state_circ = qi.random_clifford(2, seed=SEED).to_circuit() oper = qi.Pauli(pauli) state = qi.Statevector(state_circ) expval = state.expectation_value(oper).real variance = state.expectation_value(oper ** 2).real - expval ** 2 target = [expval, variance] # Snapshot circuit opts = self.BACKEND_OPTS.copy() method = opts.get('method', 'automatic') circ = transpile(state_circ, basis_gates=[ 'id', 'x', 'y', 'z', 'h', 's', 'sdg', 'cx', 'cz', 'swap']) circ.save_expectation_value_variance('expval', oper, [0, 1]) qobj = assemble(circ) result = self.SIMULATOR.run(qobj, **opts).result() if method not in SUPPORTED_METHODS: self.assertFalse(result.success) else: self.assertTrue(result.success) value = result.data(0)['expval'] self.assertTrue(allclose(value, target))
def test_save_expval_var_nonstabilizer_pauli(self, pauli): """Test Pauli expval_var for non-stabilizer circuit""" SUPPORTED_METHODS = [ 'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust', 'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust', 'matrix_product_state', 'extended_stabilizer' ] SEED = 7382 # Stabilizer test circuit state_circ = QuantumVolume(2, 1, seed=SEED) oper = qi.Operator(qi.Pauli(pauli)) state = qi.Statevector(state_circ) expval = state.expectation_value(oper).real variance = state.expectation_value(oper**2).real - expval**2 target = [expval, variance] # Snapshot circuit opts = self.BACKEND_OPTS.copy() method = opts.get('method', 'automatic') circ = transpile(state_circ, basis_gates=['u1', 'u2', 'u3', 'cx', 'swap']) circ.save_expectation_value_variance(oper, [0, 1], label='expval') qobj = assemble(circ) result = self.SIMULATOR.run(qobj, **opts).result() if method not in SUPPORTED_METHODS: self.assertFalse(result.success) else: self.assertTrue(result.success) value = result.data(0)['expval'] self.assertTrue(allclose(value, target))
def test_save_expval_stabilizer_pauli(self, pauli): """Test Pauli expval for stabilizer circuit""" SUPPORTED_METHODS = [ 'automatic', 'statevector', 'statevector_gpu', 'statevector_thrust', 'density_matrix', 'density_matrix_gpu', 'density_matrix_thrust', 'matrix_product_state', 'stabilizer' ] SEED = 5832 # Stabilizer test circuit state = qi.random_clifford(2, seed=SEED).to_circuit() oper = qi.Pauli(pauli) target = qi.Statevector(state).expectation_value(oper).real.round(10) # Snapshot circuit opts = self.BACKEND_OPTS.copy() circ = transpile(state, self.SIMULATOR) circ.save_expectation_value('expval', oper, [0, 1]) qobj = assemble(circ) result = self.SIMULATOR.run(qobj, **opts).result() method = opts.get('method', 'automatic') if method not in SUPPORTED_METHODS: self.assertFalse(result.success) else: self.assertTrue(result.success) value = result.data(0)['expval'] self.assertAlmostEqual(value, target)
def test_pauli_error_2q_unitary_from_pauli(self): """Test two-qubit pauli error as unitary qobj from Pauli obj""" from qiskit.extensions import UnitaryGate paulis = [qi.Pauli(s) for s in ['XY', 'YZ', 'ZX']] probs = [0.5, 0.3, 0.2] with self.assertWarns(DeprecationWarning): actual = pauli_error(zip(paulis, probs), standard_gates=False) X = qi.Pauli("X").to_matrix() Y = qi.Pauli("Y").to_matrix() Z = qi.Pauli("Z").to_matrix() target_unitaries = [np.kron(X, Y), np.kron(Y, Z), np.kron(Z, X)] expected = QuantumError([(UnitaryGate(mat), p) for mat, p in zip(target_unitaries, probs)]) for i in range(actual.size): circ, prob = actual.error_term(i) expected_circ, expected_prob = expected.error_term(i) self.assertEqual(circ, expected_circ) self.assertAlmostEqual(prob, expected_prob)
def test_pauli_error_1q_unitary_from_pauli(self): """Test single-qubit pauli error as unitary qobj from Pauli obj""" from qiskit.extensions import UnitaryGate paulis = [qi.Pauli(s) for s in ['I', 'X', 'Y', 'Z']] probs = [0.4, 0.3, 0.2, 0.1] with self.assertWarns(DeprecationWarning): actual = pauli_error(zip(paulis, probs), standard_gates=False) target_unitaries = [qi.Pauli("I").to_matrix(), qi.Pauli("X").to_matrix(), qi.Pauli("Y").to_matrix(), qi.Pauli("Z").to_matrix()] expected = QuantumError([(UnitaryGate(mat), p) for mat, p in zip(target_unitaries, probs)]) for i in range(actual.size): circ, prob = actual.error_term(i) expected_circ, expected_prob = expected.error_term(i) self.assertEqual(circ, expected_circ) self.assertAlmostEqual(prob, expected_prob)
def test_pauli_error_1q_gate_from_pauli(self): """Test single-qubit pauli error as gate qobj from Pauli obj""" paulis = [qi.Pauli(s) for s in ['I', 'X', 'Y', 'Z']] probs = [0.4, 0.3, 0.2, 0.1] actual = pauli_error(zip(paulis, probs)) expected = QuantumError([(IGate(), 0.4), (XGate(), 0.3), (YGate(), 0.2), (ZGate(), 0.1)]) for i in range(actual.size): circ, prob = actual.error_term(i) expected_circ, expected_prob = expected.error_term(i) self.assertEqual(circ, expected_circ, msg=f"Incorrect {i}-th circuit") self.assertAlmostEqual(prob, expected_prob, msg=f"Incorrect {i}-th probability")
def test_save_expval_var_stabilizer_pauli(self, method, device, pauli): """Test Pauli expval_var for stabilizer circuit""" SEED = 5832 circ = qi.random_clifford(2, seed=SEED).to_circuit() oper = qi.Operator(qi.Pauli(pauli)) qubits = [0, 1] self._test_save_expval(circ, oper, qubits, True, method=method, device=device)
def test_save_expval_var_nonstabilizer_pauli(self, method, device, pauli): """Test Pauli expval_var for non-stabilizer circuit""" SEED = 7382 circ = QuantumVolume(2, 1, seed=SEED) oper = qi.Operator(qi.Pauli(pauli)) qubits = [0, 1] self._test_save_expval(circ, oper, qubits, True, method=method, device=device)
def test_save_expval_bell_pauli(self, method, device, pauli): """Test Pauli expval for Bell state circuit""" circ = QuantumCircuit(2) circ.h(0) circ.cx(0, 1) oper = qi.Pauli(pauli) qubits = [0, 1] self._test_save_expval(circ, oper, qubits, False, method=method, device=device)
def test_save_expval_var_cptp_pauli(self, method, device, pauli): """Test Pauli expval_var for stabilizer circuit""" SEED = 5832 oper = qi.Operator(qi.Operator(qi.Pauli(pauli))) channel = qi.random_quantum_channel(4, seed=SEED) circ = QuantumCircuit(2) circ.append(channel, range(2)) qubits = [0, 1] self._test_save_expval(circ, oper, qubits, True, method=method, device=device)
def test_pauli_error_2q_gate_from_pauli(self): """Test two-qubit pauli error as gate qobj from Pauli obj""" paulis = [qi.Pauli(s) for s in ['XZ', 'YX', 'ZY']] probs = [0.5, 0.3, 0.2] actual = pauli_error(zip(paulis, probs)) expected = QuantumError( [(PauliGate("XZ"), 0.5), (PauliGate("YX"), 0.3), (PauliGate("ZY"), 0.2)] ) for i in range(actual.size): circ, prob = actual.error_term(i) expected_circ, expected_prob = expected.error_term(i) self.assertEqual(circ, expected_circ, msg=f"Incorrect {i}-th circuit") self.assertAlmostEqual(prob, expected_prob, msg=f"Incorrect {i}-th probability")
def test_save_expval_stabilizer_pauli_cache_blocking( self, method, device, pauli): """Test Pauli expval for stabilizer circuit""" SEED = 5832 circ = qi.random_clifford(2, seed=SEED).to_circuit() oper = qi.Operator(qi.Pauli(pauli)) qubits = [0, 1] self._test_save_expval(circ, oper, qubits, False, method=method, device=device, blocking_qubits=2, max_parallel_threads=1)
def OTOCoutcome(circ): """ OTOC measurement via expval of Pauli Y on the ancilla qubit Args: circ (Circuit): valid quantum circuit Returns: Float: expectation value of Pauli Y, in [-1,1] """ # Noisy simulator definition simulator = Aer.get_backend("qasm_simulator") otocCirc = transpile(circ, simulator) # Operator to take expectation value of qubitM = qi.Pauli("Y") qubitT = [0] otocCirc.save_expectation_value(qubitM, qubitT) result = simulator.run(otocCirc).result() exp = result.data()["expectation_value"] return exp
def test_pauli_gate(self, method, device, pauli): """Test multi-qubit Pauli gate.""" pauli = qi.Pauli(pauli) circuit = QuantumCircuit(pauli.num_qubits) circuit.append(pauli, range(pauli.num_qubits)) backend = self.backend(method=method, device=device) label = 'final' if method == 'density_matrix': target = qi.DensityMatrix(circuit) circuit.save_density_matrix(label=label) state_fn = qi.DensityMatrix fidelity_fn = qi.state_fidelity elif method == 'stabilizer': target = qi.Clifford(circuit) circuit.save_stabilizer(label=label) state_fn = qi.Clifford.from_dict fidelity_fn = qi.process_fidelity elif method == 'unitary': target = qi.Operator(circuit) circuit.save_unitary(label=label) state_fn = qi.Operator fidelity_fn = qi.process_fidelity elif method == 'superop': target = qi.SuperOp(circuit) circuit.save_superop(label=label) state_fn = qi.SuperOp fidelity_fn = qi.process_fidelity else: target = qi.Statevector(circuit) circuit.save_statevector(label=label) state_fn = qi.Statevector fidelity_fn = qi.state_fidelity result = backend.run(transpile(circuit, backend, optimization_level=0), shots=1).result() # Check results success = getattr(result, 'success', False) self.assertTrue(success) data = result.data(0) self.assertIn(label, data) value = state_fn(data[label]) fidelity = fidelity_fn(target, value) self.assertGreater(fidelity, 0.9999)
def test_pauli_error_2q_gate_from_pauli(self): """Test two-qubit pauli error as gate qobj from Pauli obj""" paulis = [qi.Pauli(s) for s in ['XZ', 'YX', 'ZY']] probs = [0.5, 0.3, 0.2] with self.assertWarns(DeprecationWarning): actual = pauli_error(zip(paulis, probs), standard_gates=True) target_circs = [[{"name": "z", "qubits": [0]}, {"name": "x", "qubits": [1]}], [{"name": "x", "qubits": [0]}, {"name": "y", "qubits": [1]}], [{"name": "y", "qubits": [0]}, {"name": "z", "qubits": [1]}]] with self.assertWarns(DeprecationWarning): expected = QuantumError(zip(target_circs, probs), standard_gates=True) for i in range(actual.size): circ, prob = actual.error_term(i) expected_circ, expected_prob = expected.error_term(i) self.assertEqual(circ, expected_circ) self.assertAlmostEqual(prob, expected_prob)