def test_chop_real_only(self): paulis = ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY'] coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op = Operator(paulis=[]) for coeff, pauli in zip(coeffs, paulis): pauli_term = [coeff, Pauli.from_label(pauli)] op += Operator(paulis=[pauli_term]) op1 = copy.deepcopy(op) op1.chop(threshold=0.4) self.assertEqual(len(op1.paulis), 4, "\n{}".format(op1.print_operators())) gt_op1 = Operator(paulis=[]) for i in range(1, 3): pauli_term = [coeffs[i], Pauli.from_label(paulis[i])] gt_op1 += Operator(paulis=[pauli_term]) pauli_term = [coeffs[i+3], Pauli.from_label(paulis[i+3])] gt_op1 += Operator(paulis=[pauli_term]) self.assertEqual(op1, gt_op1) op2 = copy.deepcopy(op) op2.chop(threshold=0.7) self.assertEqual(len(op2.paulis), 2, "\n{}".format(op2.print_operators())) gt_op2 = Operator(paulis=[]) for i in range(2, 3): pauli_term = [coeffs[i], Pauli.from_label(paulis[i])] gt_op2 += Operator(paulis=[pauli_term]) pauli_term = [coeffs[i+3], Pauli.from_label(paulis[i+3])] gt_op2 += Operator(paulis=[pauli_term]) self.assertEqual(op2, gt_op2) op3 = copy.deepcopy(op) op3.chop(threshold=0.9) self.assertEqual(len(op3.paulis), 0, "\n{}".format(op3.print_operators())) gt_op3 = Operator(paulis=[]) for i in range(3, 3): pauli_term = [coeffs[i], Pauli.from_label(paulis[i])] gt_op3 += Operator(paulis=[pauli_term]) pauli_term = [coeffs[i+3], Pauli.from_label(paulis[i+3])] gt_op3 += Operator(paulis=[pauli_term]) self.assertEqual(op3, gt_op3)
def construct_circuit(self, x, qr=None, inverse=False): """ Construct the second order expansion based on given data. Args: x (numpy.ndarray): 1-D to-be-transformed data. qr (QauntumRegister, optional): the QuantumRegister object for the circuit, if None, generate new registers with name q. inverse (bool, optional): whether or not inverse the circuit Returns: QuantumCircuit: a quantum circuit transform data x. Raises: TypeError: invalid input ValueError: invalid input """ if not isinstance(x, np.ndarray): raise TypeError("x must be numpy array.") if x.ndim != 1: raise ValueError("x must be 1-D array.") if x.shape[0] != self._num_qubits: raise ValueError("number of qubits and data dimension must be the same.") if qr is None: qr = QuantumRegister(self._num_qubits, name='q') qc = QuantumCircuit(qr) for _ in range(self._depth): for i in range(self._num_qubits): qc.u2(0, pi, qr[i]) for pauli in self._pauli_strings: coeff = self._data_map_func(self._extract_data_for_rotation(pauli, x)) p = Pauli.from_label(pauli) inst = evolution_instruction([[coeff, p]], 1, 1) qc.append(inst, qr) qc = qc.decompose() return qc
def test_group_paulis_2(self): """ Test with normal grouping approach """ num_qubits = 4 pauli_term = [] for pauli_label in itertools.product('IXYZ', repeat=num_qubits): coeff = np.random.random(1)[0] pauli_term.append([coeff, Pauli.from_label(''.join(pauli_label))]) op = Operator(paulis=pauli_term) op.coloring = None paulis = copy.deepcopy(op.paulis) op.to_grouped_paulis() flattened_grouped_paulis = [pauli for group in op.grouped_paulis for pauli in group[1:]] for gp in flattened_grouped_paulis: passed = False for p in paulis: if p[1] == gp[1]: passed = p[0] == gp[0] break self.assertTrue(passed, "non-existed paulis in grouped_paulis: {}".format(gp[1].to_label()))
def test_chop_real(self): """ chop real test """ paulis = [ Pauli.from_label(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY'] ] coeffs = [0.2, 0.6, 0.8, -0.2, -0.6, -0.8] op = WeightedPauliOperator.from_list(paulis, coeffs) ori_op = op.copy() for threshold, num_paulis in zip([0.4, 0.7, 0.9], [4, 2, 0]): op = ori_op.copy() op1 = op.chop(threshold=threshold, copy=True) self.assertEqual(len(op.paulis), 6, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details())) op1 = op.chop(threshold=threshold, copy=False) self.assertEqual(len(op.paulis), num_paulis, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details()))
def test_sorted_grouping(self): """Test with color grouping approach.""" num_qubits = 2 paulis = [Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=num_qubits)] weights = aqua_globals.random.random_sample(len(paulis)) op = WeightedPauliOperator.from_list(paulis, weights) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.sorted_grouping) # check all paulis are still existed. for g_p in grouped_op.paulis: passed = False for pauli in op.paulis: if pauli[1] == g_p[1]: passed = pauli[0] == g_p[0] break self.assertTrue(passed, "non-existed paulis in grouped_paulis: {}".format(g_p[1].to_label())) # check the number of basis of grouped # one should be less than and equal to the original one. self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def qubitop_to_qiskitpauli( qubit_operator: QubitOperator) -> WeightedPauliOperator: """Convert a OpenFermion QubitOperator to a WeightedPauliOperator. Args: qubit_operator: OpenFermion QubitOperator to convert Returns: WeightedPauliOperator representing the qubit operator """ if not isinstance(qubit_operator, QubitOperator): raise TypeError( "qubit_operator must be an OpenFermion QubitOperator object") terms = [] for qubit_terms, coefficient in qubit_operator.terms.items(): string_term = "I" * count_qubits(qubit_operator) for i, (term_qubit, term_pauli) in enumerate(qubit_terms): string_term = (string_term[:term_qubit] + term_pauli + string_term[term_qubit + 1:]) terms.append([coefficient, Pauli.from_label(string_term)]) return WeightedPauliOperator(terms)
def paul(n_qubits: int, index: int, axis: Union[int, str]): """Return a Pauli string with a single non-trivial element. Parameters ---------- n_qubits : int Number of qubits. index : int Index of non-trivial term. axis : Union[int, str] Axis for Pauli string. Either a string, or an int, e.g. `'X'` or `'1'`. Returns ------- WeightedPauliOperator($0) Resulting Pauli operator. """ label = ['I'] * n_qubits pauli_dict = {0: 'I', 1: 'X', 2: 'Y', 3: 'Z'} if isinstance(axis, str): if not axis in list(pauli_dict.values()): raise ValueError('Invalid axis provided') label[index] = axis elif isinstance(axis, int): label[index] = pauli_dict[axis] return WeightedPauliOperator(paulis=[[1.0, Pauli.from_label(label)]])
def test_unsorted_grouping(self): """Test with normal grouping approach.""" num_qubits = 4 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=num_qubits) ] weights = aqua_globals.random.random(len(paulis)) op = WeightedPauliOperator.from_list(paulis, weights) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.unsorted_grouping) for g_p in grouped_op.paulis: passed = False for pauli in op.paulis: if pauli[1] == g_p[1]: passed = pauli[0] == g_p[0] break self.assertTrue( passed, "non-existed paulis in grouped_paulis: {}".format( g_p[1].to_label())) self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_chop_complex(self): paulis = [ Pauli.from_label(x) for x in ['IXYZ', 'XXZY', 'IIZZ', 'XXYY', 'ZZXX', 'YYYY'] ] coeffs = [ 0.2 + -0.5j, 0.6 - 0.3j, 0.8 - 0.6j, -0.5 + -0.2j, -0.3 + 0.6j, -0.6 + 0.8j ] op = WeightedPauliOperator.from_list(paulis, coeffs) ori_op = op.copy() for threshold, num_paulis in zip([0.4, 0.7, 0.9], [6, 2, 0]): op = ori_op.copy() op1 = op.chop(threshold=threshold, copy=True) self.assertEqual(len(op.paulis), 6, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details())) op1 = op.chop(threshold=threshold, copy=False) self.assertEqual(len(op.paulis), num_paulis, "\n{}".format(op.print_details())) self.assertEqual(len(op1.paulis), num_paulis, "\n{}".format(op1.print_details()))
def setUp(self): super().setUp() seed = 0 aqua_globals.random_seed = seed self.num_qubits = 3 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=self.num_qubits) ] weights = aqua_globals.random.random_sample(len(paulis)) self.qubit_op = WeightedPauliOperator.from_list(paulis, weights) self.var_form = RYRZ(self.qubit_op.num_qubits, 1) qasm_simulator = BasicAer.get_backend('qasm_simulator') self.quantum_instance_qasm = QuantumInstance(qasm_simulator, shots=65536, seed_simulator=seed, seed_transpiler=seed) statevector_simulator = BasicAer.get_backend('statevector_simulator') self.quantum_instance_statevector = \ QuantumInstance(statevector_simulator, shots=1, seed_simulator=seed, seed_transpiler=seed)
def test_chop(self): """ chop test """ paulis = [Pauli.from_label(x) for x in ['IIXX', 'ZZXX', 'ZZZZ', 'XXZZ', 'XXXX', 'IXXX']] coeffs = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7] op = WeightedPauliOperator.from_list(paulis, coeffs) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.sorted_grouping) original_num_basis = len(grouped_op.basis) chopped_grouped_op = grouped_op.chop(0.35, copy=True) self.assertLessEqual(len(chopped_grouped_op.basis), 3) self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis) # ZZXX group is remove for b, _ in chopped_grouped_op.basis: self.assertFalse(b.to_label() == 'ZZXX') chopped_grouped_op = grouped_op.chop(0.55, copy=True) self.assertLessEqual(len(chopped_grouped_op.basis), 1) self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis) for b, _ in chopped_grouped_op.basis: self.assertFalse(b.to_label() == 'ZZXX') self.assertFalse(b.to_label() == 'ZZZZ') self.assertFalse(b.to_label() == 'XXZZ')
def qubitop_to_pauliop(n_qubits, qubit_operator): """Convert an openfermion QubitOperator to a qiskit WeightedPauliOperator. Args: qubit_operator ("QubitOperator"): Openfermion QubitOperator to convert to a qiskit.WeightedPauliOperator. Returns: paulis ("WeightedPauliOperator"): Qiskit WeightedPauliOperator. """ if not isinstance(qubit_operator, QubitOperator): raise TypeError("qubit_operator must be an openFermion QubitOperator object.") paulis = [] for qubit_terms, coefficient in qubit_operator.terms.items(): count=0 pauli_label = ['I' for _ in range(n_qubits)] coeff = coefficient for tensor_term in qubit_terms: pauli_label[tensor_term[0]] = tensor_term[1] paulis.append([coeff, Pauli.from_label(pauli_label)]) pauliOp = WeightedPauliOperator(paulis) return pauliOp
def test_create_from_paulis_0(self): """Test with single paulis.""" num_qubits = 4 for pauli_label in itertools.product('IXYZ', repeat=num_qubits): coeff = np.random.random(1)[0] pauli_term = [coeff, Pauli.from_label(pauli_label)] op = Operator(paulis=[pauli_term]) depth = 1 var_form = RYRZ(op.num_qubits, depth) circuit = var_form.construct_circuit( np.array(np.random.randn(var_form.num_parameters))) run_config = {'shots': 1} backend = Aer.get_backend('statevector_simulator') non_matrix_mode = op.eval('paulis', circuit, backend, run_config=run_config)[0] matrix_mode = op.eval('matrix', circuit, backend, run_config=run_config)[0] self.assertAlmostEqual(matrix_mode, non_matrix_mode, 6)
def calculate_cik(self): # ! ---------------------------------- # ! Check if this needs to be refersed ? # ! ---------------------------------- ham_terms_circ = [ ug(Pauli.from_label(i).to_operator(), label=" (" + i + ")").control(1) for i in list(self.ham_pauli.keys()) ] coeff = list(self.ham_pauli.values()) if self.verbose: iterations = tqdm(range(self.num_parameters), desc="Calculating C_ij parameterized circuits\n") else: iterations = range(self.num_parameters) for i in iterations: for j in range(len(ham_terms_circ)): self.make_cik_circ(ik=[i, j], h_pauli=ham_terms_circ, coeff=coeff) self.circuit_cik_a_values[i][j] = np.abs(-1j / 2 * coeff[j])
def test_bksf_edge_op_aij(self): """Test bksf mapping, edge operator aij""" edge_matrix = np.triu(np.ones((4, 4))) edge_list = np.array( np.nonzero(np.triu(edge_matrix) - np.diag(np.diag(edge_matrix)))) qterm_a01 = edge_operator_aij(edge_list, 0, 1) qterm_a02 = edge_operator_aij(edge_list, 0, 2) qterm_a03 = edge_operator_aij(edge_list, 0, 3) qterm_a12 = edge_operator_aij(edge_list, 1, 2) qterm_a13 = edge_operator_aij(edge_list, 1, 3) qterm_a23 = edge_operator_aij(edge_list, 2, 3) ref_qterm_a01 = Operator(paulis=[[1.0, Pauli.from_label('IIIIIX')]]) ref_qterm_a02 = Operator(paulis=[[1.0, Pauli.from_label('IIIIXZ')]]) ref_qterm_a03 = Operator(paulis=[[1.0, Pauli.from_label('IIIXZZ')]]) ref_qterm_a12 = Operator(paulis=[[1.0, Pauli.from_label('IIXIZZ')]]) ref_qterm_a13 = Operator(paulis=[[1.0, Pauli.from_label('IXZZIZ')]]) ref_qterm_a23 = Operator(paulis=[[1.0, Pauli.from_label('XZZZZI')]]) self.assertEqual( qterm_a01, ref_qterm_a01, "\n{} vs \n{}".format(qterm_a01.print_operators(), ref_qterm_a01.print_operators())) self.assertEqual( qterm_a02, ref_qterm_a02, "\n{} vs \n{}".format(qterm_a02.print_operators(), ref_qterm_a02.print_operators())) self.assertEqual( qterm_a03, ref_qterm_a03, "\n{} vs \n{}".format(qterm_a03.print_operators(), ref_qterm_a03.print_operators())) self.assertEqual( qterm_a12, ref_qterm_a12, "\n{} vs \n{}".format(qterm_a12.print_operators(), ref_qterm_a12.print_operators())) self.assertEqual( qterm_a13, ref_qterm_a13, "\n{} vs \n{}".format(qterm_a13.print_operators(), ref_qterm_a13.print_operators())) self.assertEqual( qterm_a23, ref_qterm_a23, "\n{} vs \n{}".format(qterm_a23.print_operators(), ref_qterm_a23.print_operators()))
class FermionicOperator(object): r""" A set of functions to map fermionic Hamiltonians to qubit Hamiltonians. References: - E. Wigner and P. Jordan., Über das Paulische Äguivalenzverbot, \ Z. Phys., 47:631 (1928). \ - S. Bravyi and A. Kitaev. Fermionic quantum computation, \ Ann. of Phys., 298(1):210–226 (2002). \ - A. Tranter, S. Sofia, J. Seeley, M. Kaicher, J. McClean, R. Babbush, \ P. Coveney, F. Mintert, F. Wilhelm, and P. Love. The Bravyi–Kitaev \ transformation: Properties and applications. Int. Journal of Quantum \ Chemistry, 115(19):1431–1441 (2015). \ - S. Bravyi, J. M. Gambetta, A. Mezzacapo, and K. Temme, \ arXiv e-print arXiv:1701.08213 (2017). \ - K. Setia, J. D. Whitfield, arXiv:1712.00446 (2017) """ def __init__(self, h1, h2=None, ph_trans_shift=None): """Constructor. This class requires the integrals stored in the 'chemist' notation h2(i,j,k,l) --> adag_i adag_k a_l a_j There is another popular notation is the 'physicist' notation h2(i,j,k,l) --> adag_i adag_j a_k a_l If you are using the 'physicist' notation, you need to convert it to the 'chemist' notation first. E.g., h2 = numpy.einsum('ikmj->ijkm', h2) Args: h1 (numpy.ndarray): second-quantized fermionic one-body operator, a 2-D (NxN) tensor h2 (numpy.ndarray): second-quantized fermionic two-body operator, a 4-D (NxNxNxN) tensor ph_trans_shift (float): energy shift caused by particle hole transformation """ self._h1 = h1 if h2 is None: h2 = np.zeros((h1.shape[0], h1.shape[0], h1.shape[0], h1.shape[0]), dtype=h1.dtype) self._h2 = h2 self._ph_trans_shift = ph_trans_shift self._modes = self._h1.shape[0] self._map_type = None @property def modes(self): """Getter of modes.""" return self._modes @property def h1(self): """Getter of one body integral tensor.""" return self._h1 @h1.setter def h1(self, new_h1): """Setter of one body integral tensor.""" self._h1 = new_h1 @property def h2(self): """Getter of two body integral tensor.""" return self._h2 @h2.setter def h2(self, new_h2): """Setter of two body integral tensor.""" self._h2 = new_h2 def __eq__(self, other): """Overload == .""" ret = np.all(self._h1 == other._h1) if not ret: return ret ret = np.all(self._h2 == other._h2) return ret def __ne__(self, other): """Overload != .""" return not self.__eq__(other) def transform(self, unitary_matrix): """Transform the one and two body term based on unitary_matrix.""" self._h1_transform(unitary_matrix) self._h2_transform(unitary_matrix) def _h1_transform(self, unitary_matrix): """ Transform h1 based on unitry matrix, and overwrite original property. Args: unitary_matrix (numpy.ndarray): A 2-D unitary matrix for h1 transformation. """ self._h1 = unitary_matrix.T.conj().dot(self._h1.dot(unitary_matrix)) def _h2_transform(self, unitary_matrix): """ Transform h2 to get fermionic hamiltonian, and overwrite original property. Args: unitary_matrix (numpy.ndarray): A 2-D unitary matrix for h1 transformation. """ num_modes = unitary_matrix.shape[0] temp_ret = np.zeros((num_modes, num_modes, num_modes, num_modes), dtype=unitary_matrix.dtype) unitary_matrix_dagger = np.conjugate(unitary_matrix) # option 3: temp1 is a 3-D tensor, temp2 and temp3 are 2-D tensors for a in range(num_modes): temp1 = np.einsum('i,i...->...', unitary_matrix_dagger[:, a], self._h2) for b in range(num_modes): temp2 = np.einsum('j,j...->...', unitary_matrix[:, b], temp1) temp3 = np.einsum('kc,k...->...c', unitary_matrix_dagger, temp2) temp_ret[a, b, :, :] = np.einsum('ld,l...c->...cd', unitary_matrix, temp3) self._h2 = temp_ret def _jordan_wigner_mode(self, n): """ Jordan_Wigner mode. Each Fermionic Operator is mapped to 2 Pauli Operators, added together with the appropriate phase, i.e.: a_i^\\dagger = Z^i (X + iY) I^(n-i-1) = (Z^i X I^(n-i-1)) + i (Z^i Y I^(n-i-1)) a_i = Z^i (X - iY) I^(n-i-1) This is implemented by creating an array of tuples, each including two operators. The phase between two elements in a tuple is implicitly assumed, and added calculated at the appropriate time (see for example _one_body_mapping). Args: n (int): number of modes """ a = [] for i in range(n): a_z = np.asarray([1] * i + [0] + [0] * (n - i - 1), dtype=np.bool) a_x = np.asarray([0] * i + [1] + [0] * (n - i - 1), dtype=np.bool) b_z = np.asarray([1] * i + [1] + [0] * (n - i - 1), dtype=np.bool) b_x = np.asarray([0] * i + [1] + [0] * (n - i - 1), dtype=np.bool) a.append((Pauli(a_z, a_x), Pauli(b_z, b_x))) return a def _parity_mode(self, n): """ Parity mode. Args: n (int): number of modes """ a = [] for i in range(n): a_z = [0] * (i - 1) + [1] if i > 0 else [] a_x = [0] * (i - 1) + [0] if i > 0 else [] b_z = [0] * (i - 1) + [0] if i > 0 else [] b_x = [0] * (i - 1) + [0] if i > 0 else [] a_z = np.asarray(a_z + [0] + [0] * (n - i - 1), dtype=np.bool) a_x = np.asarray(a_x + [1] + [1] * (n - i - 1), dtype=np.bool) b_z = np.asarray(b_z + [1] + [0] * (n - i - 1), dtype=np.bool) b_x = np.asarray(b_x + [1] + [1] * (n - i - 1), dtype=np.bool) a.append((Pauli(a_z, a_x), Pauli(b_z, b_x))) return a def _bravyi_kitaev_mode(self, n): """ Bravyi-Kitaev mode. Args: n (int): number of modes """ def parity_set(j, n): """Computes the parity set of the j-th orbital in n modes. Args: j (int) : the orbital index n (int) : the total number of modes Returns: numpy.ndarray: Array of mode indexes """ indexes = np.array([]) if n % 2 != 0: return indexes if j < n / 2: indexes = np.append(indexes, parity_set(j, n / 2)) else: indexes = np.append(indexes, np.append( parity_set(j - n / 2, n / 2) + n / 2, n / 2 - 1)) return indexes def update_set(j, n): """Computes the update set of the j-th orbital in n modes. Args: j (int) : the orbital index n (int) : the total number of modes Returns: numpy.ndarray: Array of mode indexes """ indexes = np.array([]) if n % 2 != 0: return indexes if j < n / 2: indexes = np.append(indexes, np.append( n - 1, update_set(j, n / 2))) else: indexes = np.append(indexes, update_set(j - n / 2, n / 2) + n / 2) return indexes def flip_set(j, n): """Computes the flip set of the j-th orbital in n modes. Args: j (int) : the orbital index n (int) : the total number of modes Returns: numpy.ndarray: Array of mode indexes """ indexes = np.array([]) if n % 2 != 0: return indexes if j < n / 2: indexes = np.append(indexes, flip_set(j, n / 2)) elif j >= n / 2 and j < n - 1: indexes = np.append(indexes, flip_set(j - n / 2, n / 2) + n / 2) else: indexes = np.append(np.append(indexes, flip_set( j - n / 2, n / 2) + n / 2), n / 2 - 1) return indexes a = [] # FIND BINARY SUPERSET SIZE bin_sup = 1 while n > np.power(2, bin_sup): bin_sup += 1 # DEFINE INDEX SETS FOR EVERY FERMIONIC MODE update_sets = [] update_pauli = [] parity_sets = [] parity_pauli = [] flip_sets = [] remainder_sets = [] remainder_pauli = [] for j in range(n): update_sets.append(update_set(j, np.power(2, bin_sup))) update_sets[j] = update_sets[j][update_sets[j] < n] parity_sets.append(parity_set(j, np.power(2, bin_sup))) parity_sets[j] = parity_sets[j][parity_sets[j] < n] flip_sets.append(flip_set(j, np.power(2, bin_sup))) flip_sets[j] = flip_sets[j][flip_sets[j] < n] remainder_sets.append(np.setdiff1d(parity_sets[j], flip_sets[j])) update_pauli.append(Pauli(np.zeros(n, dtype=np.bool), np.zeros(n, dtype=np.bool))) parity_pauli.append(Pauli(np.zeros(n, dtype=np.bool), np.zeros(n, dtype=np.bool))) remainder_pauli.append(Pauli(np.zeros(n, dtype=np.bool), np.zeros(n, dtype=np.bool))) for k in range(n): if np.in1d(k, update_sets[j]): update_pauli[j].update_x(True, k) if np.in1d(k, parity_sets[j]): parity_pauli[j].update_z(True, k) if np.in1d(k, remainder_sets[j]): remainder_pauli[j].update_z(True, k) x_j = Pauli(np.zeros(n, dtype=np.bool), np.zeros(n, dtype=np.bool)) x_j.update_x(True, j) y_j = Pauli(np.zeros(n, dtype=np.bool), np.zeros(n, dtype=np.bool)) y_j.update_z(True, j) y_j.update_x(True, j) a.append((update_pauli[j] * x_j * parity_pauli[j], update_pauli[j] * y_j * remainder_pauli[j])) return a def mapping(self, map_type, threshold=0.00000001): """Map fermionic operator to qubit operator. Using multiprocess to speedup the mapping, the improvement can be observed when h2 is a non-sparse matrix. Args: map_type (str): case-insensitive mapping type. "jordan_wigner", "parity", "bravyi_kitaev", "bksf" threshold (float): threshold for Pauli simplification Returns: WeightedPauliOperator: create an Operator object in Paulis form. Raises: QiskitChemistryError: if the `map_type` can not be recognized. """ """ #################################################################### ############ DEFINING MAPPED FERMIONIC OPERATORS ############## #################################################################### """ self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a = self._jordan_wigner_mode(n) elif map_type == 'parity': a = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError('Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') """ #################################################################### ############ BUILDING THE MAPPED HAMILTONIAN ################ #################################################################### """ pauli_list = WeightedPauliOperator(paulis=[]) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping one-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._one_body_mapping, [(self._h1[i, j], a[i], a[j]) for i, j in itertools.product(range(n), repeat=2) if self._h1[i, j] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping two-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._two_body_mapping, [(self._h2[i, j, k, m], a[i], a[j], a[k], a[m]) for i, j, k, m in itertools.product(range(n), repeat=4) if self._h2[i, j, k, m] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [self._ph_trans_shift, Pauli.from_label('I' * self._modes)] pauli_list += WeightedPauliOperator(paulis=[pauli_term]) return pauli_list @staticmethod def _one_body_mapping(h1_ij_aij, threshold): """ Subroutine for one body mapping. Args: h1_ij_aij (tuple): value of h1 at index (i,j), pauli at index i, pauli at index j threshold: (float): threshold to remove a pauli Returns: WeightedPauliOperator: Operator for those paulis """ h1_ij, a_i, a_j = h1_ij_aij pauli_list = [] for alpha in range(2): for beta in range(2): pauli_prod = Pauli.sgn_prod(a_i[alpha], a_j[beta]) coeff = h1_ij / 4 * pauli_prod[1] * np.power(-1j, alpha) * np.power(1j, beta) pauli_term = [coeff, pauli_prod[0]] if np.absolute(pauli_term[0]) > threshold: pauli_list.append(pauli_term) return WeightedPauliOperator(paulis=pauli_list) @staticmethod def _two_body_mapping(h2_ijkm_a_ijkm, threshold): """ Subroutine for two body mapping. We use the chemists notation for the two-body term, h2(i,j,k,m) adag_i adag_k a_m a_j. Args: h2_ijkm_aijkm (tuple): value of h2 at index (i,j,k,m), pauli at index i, pauli at index j, pauli at index k, pauli at index m threshold: (float): threshold to remove a pauli Returns: WeightedPauliOperator: Operator for those paulis """ h2_ijkm, a_i, a_j, a_k, a_m = h2_ijkm_a_ijkm pauli_list = [] for alpha in range(2): for beta in range(2): for gamma in range(2): for delta in range(2): pauli_prod_1 = Pauli.sgn_prod(a_i[alpha], a_k[beta]) pauli_prod_2 = Pauli.sgn_prod(pauli_prod_1[0], a_m[gamma]) pauli_prod_3 = Pauli.sgn_prod(pauli_prod_2[0], a_j[delta]) phase1 = pauli_prod_1[1] * pauli_prod_2[1] * pauli_prod_3[1] phase2 = np.power(-1j, alpha + beta) * np.power(1j, gamma + delta) pauli_term = [h2_ijkm / 16 * phase1 * phase2, pauli_prod_3[0]] if np.absolute(pauli_term[0]) > threshold: pauli_list.append(pauli_term) return WeightedPauliOperator(paulis=pauli_list) @staticmethod def _n_body_mapping(h_a, threshold): h = h_a[0] a = [] for i in range(0,len(h_a[1:]),2): a.append(h_a[1+i]) for i in range(1,len(h_a[1:]),2)[::-1]: a.append(h_a[1+i]) n = int(len(a)/2) a_lst = [] for i in range(n): a_lst.append(WeightedPauliOperator([[1,a[i][0]]])+WeightedPauliOperator([[-1j,a[i][1]]])) for i in range(n): a_lst.append(WeightedPauliOperator([[1, a[n+i][0]]])+WeightedPauliOperator([[1j, a[n+i][1]]])) product = a_lst[0] for element in a_lst[1:]: product = product*element product = (h/(2**(n*2))) * product return product def mapping_new(self, map_type, threshold=0.00000001): """Map fermionic operator to qubit operator. Using multiprocess to speedup the mapping, the improvement can be observed when h2 is a non-sparse matrix. Args: map_type (str): case-insensitive mapping type. "jordan_wigner", "parity", "bravyi_kitaev", "bksf" threshold (float): threshold for Pauli simplification Returns: WeightedPauliOperator: create an Operator object in Paulis form. Raises: QiskitChemistryError: if the `map_type` can not be recognized. """ # ################################################################### # ########### DEFINING MAPPED FERMIONIC OPERATORS ############## # ################################################################### self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a_list = self._jordan_wigner_mode(n) elif map_type == 'parity': a_list = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a_list = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError('Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') # ################################################################### # ########### BUILDING THE MAPPED HAMILTONIAN ################ # ################################################################### pauli_list = WeightedPauliOperator(paulis=[]) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping one-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._n_body_mapping, [(self._h1[i, j], a_list[i], a_list[j]) for i, j in itertools.product(range(n), repeat=2) if self._h1[i, j] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping two-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._n_body_mapping, [(self._h2[i, j, k, m], a_list[i], a_list[j], a_list[k], a_list[m]) for i, j, k, m in itertools.product(range(n), repeat=4) if self._h2[i, j, k, m] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [self._ph_trans_shift, Pauli.from_label('I' * self._modes)] pauli_list += WeightedPauliOperator(paulis=[pauli_term]) return pauli_list
def _conversion(basis, matrix): pauli = Pauli.from_label(''.join(basis)) trace_value = np.sum(matrix.dot(pauli.to_spmatrix()).diagonal()) return trace_value, pauli
def find_symmetry_ops(r_matrices): """ Args: r_matrices (list[numpy.ndarray]): a list of rotation matrices. Returns: numpy.ndarray: the V matrix list[Operator]: symmetry paulis list[Operator]: cliffords, composed of symmetries and single-qubit op list[int]: position of the single-qubit operators that anticommute with the cliffords """ modes = r_matrices[0].shape[0] g_matrices = [] for r_matrix in r_matrices: g_matrix = -1j * scila.logm(r_matrix) g_matrices.append(g_matrix) sim_dia = [] for g_matrix in g_matrices: sim_dia.append(qt.Qobj(g_matrix)) d_v = qt.simdiag(sim_dia) d_matrices = d_v[0] v_matrix = np.hstack([d_v[1][i].data.toarray() for i in range(modes)]) # check the build d_matrix for eig in d_matrices.flatten(): print(eig) if not (np.isclose(eig, 0.0) or np.isclose(eig, np.pi)): # print(np.where(d_matrices.flatten()==eig)) raise ValueError('The specified R matrix is invalid. \ Eigenvalues of G includes: {}'.format( eig)) single_qubit_list = [] cliffords = [] pauli_symmetries = [] existed_pi_locs = [] # pdb.set_trace() for d_idx in range(len(d_matrices)): pi_index = np.where(np.isclose(d_matrices[d_idx], np.pi))[0] single_qubit_pauli = ['I'] * modes pi_loc = 0 for i in pi_index: if i not in existed_pi_locs: pi_loc = i existed_pi_locs.extend(pi_index.tolist()) break single_qubit_pauli[pi_loc] = 'X' single_qubit_pauli = ''.join(single_qubit_pauli) single_qubit_op = Operator( paulis=[[1.0, Pauli.from_label(single_qubit_pauli[::-1])]]) single_qubit_list.append(pi_loc) symmetries_pauli_label = '' for i in range(modes): symmetries_pauli_label += 'I' if i not in pi_index else 'Z' sym_pauli = Pauli.from_label(symmetries_pauli_label[::-1]) pauli_symmetries.append(sym_pauli) symmetries_op = Operator(paulis=[[1.0, sym_pauli]]) clifford_op = single_qubit_op + symmetries_op clifford_op.scaling_coeff(1.0 / np.sqrt(2)) cliffords.append(clifford_op) return v_matrix, pauli_symmetries, cliffords, single_qubit_list
def mapping(self, map_type, threshold=0.00000001): """Map fermionic operator to qubit operator. Using multiprocess to speedup the mapping, the improvement can be observed when h2 is a non-sparse matrix. Args: map_type (str): case-insensitive mapping type. "jordan_wigner", "parity", "bravyi_kitaev", "bksf" threshold (float): threshold for Pauli simplification Returns: WeightedPauliOperator: create an Operator object in Paulis form. Raises: QiskitChemistryError: if the `map_type` can not be recognized. """ """ #################################################################### ############ DEFINING MAPPED FERMIONIC OPERATORS ############## #################################################################### """ self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a = self._jordan_wigner_mode(n) elif map_type == 'parity': a = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError('Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') """ #################################################################### ############ BUILDING THE MAPPED HAMILTONIAN ################ #################################################################### """ pauli_list = WeightedPauliOperator(paulis=[]) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping one-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._one_body_mapping, [(self._h1[i, j], a[i], a[j]) for i, j in itertools.product(range(n), repeat=2) if self._h1[i, j] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping two-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._two_body_mapping, [(self._h2[i, j, k, m], a[i], a[j], a[k], a[m]) for i, j, k, m in itertools.product(range(n), repeat=4) if self._h2[i, j, k, m] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [self._ph_trans_shift, Pauli.from_label('I' * self._modes)] pauli_list += WeightedPauliOperator(paulis=[pauli_term]) return pauli_list
def test_evaluate_single_pauli_statevector(self): """ evaluate single pauli statevector test """ # X op = WeightedPauliOperator.from_list([Pauli.from_label('X')]) qr = QuantumRegister(1, name='q') wave_function = QuantumCircuit(qr) # + 1 eigenstate wave_function.h(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(1.0, actual_value[0].real, places=5) # - 1 eigenstate wave_function = QuantumCircuit(qr) wave_function.x(qr[0]) wave_function.h(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(-1.0, actual_value[0].real, places=5) # Y op = WeightedPauliOperator.from_list([Pauli.from_label('Y')]) qr = QuantumRegister(1, name='q') wave_function = QuantumCircuit(qr) # + 1 eigenstate wave_function.h(qr[0]) wave_function.s(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(1.0, actual_value[0].real, places=5) # - 1 eigenstate wave_function = QuantumCircuit(qr) wave_function.x(qr[0]) wave_function.h(qr[0]) wave_function.s(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(-1.0, actual_value[0].real, places=5) # Z op = WeightedPauliOperator.from_list([Pauli.from_label('Z')]) qr = QuantumRegister(1, name='q') wave_function = QuantumCircuit(qr) # + 1 eigenstate circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(1.0, actual_value[0].real, places=5) # - 1 eigenstate wave_function = QuantumCircuit(qr) wave_function.x(qr[0]) circuits = op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=True) result = self.quantum_instance_statevector.execute(circuits) actual_value = op.evaluate_with_result(result=result, statevector_mode=True) self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
def convert_to_wpauli_list(term, args): if term[0] == complex(0): separated_ham = 0*WeightedPauliOperator.from_list(paulis = [Pauli.from_label('I'*num_qubits)]) else: separated_ham = WeightedPauliOperator.from_list([term[1]],[term[0]])
def __init__(self, operator, optimizer, var_form=None, max_evals_grouped=1, aux_operators=None, callback=None, auto_conversion=True, initial_point=None, ham_list=None, operator_list=None, nonzero_terms=None, starting_point=False, expecs=None, expec_mode=False, dir_to_bracket=False, ham_term_list=None, ham_energy_list=None, base_3_list=None, param_list=None): super().__init__(operator=operator, var_form=var_form, optimizer=optimizer, initial_point=initial_point, max_evals_grouped=max_evals_grouped, aux_operators=aux_operators, callback=callback, auto_conversion=auto_conversion) self.num_qubits = operator.num_qubits if expecs == None and expec_mode == True: expecs = pd.read_csv( '{}_qubit_pauli_values.csv'.format(self.num_qubits) ) #this file is required unless you pass in the expecation values (in order) manually expecs = expecs.to_dict() if expec_mode == True: self.expecs = expecs else: self.expecs = [] if operator_list is not None: self.op_list = operator_list else: self.op_list = var_form.operator_pool.pool if initial_point is not None: self.param_list = initial_point elif param_list is not None: self.param_list = param_list else: self.param_list = [0] * len(self.op_list) self.starting_point = starting_point if starting_point: self.ham_list = ham_list self.nonzero_terms = nonzero_terms self.zero_term = 0 * WeightedPauliOperator.from_list( paulis=[Pauli.from_label('I' * self.num_qubits)]) self.empt_term = self.zero_term - self.zero_term self.dir_to_bracket = dir_to_bracket self.ham_term_list = ham_term_list self.ham_energy_list = ham_energy_list self.base_3_list = base_3_list self.constants = []
# Immutable convenience objects def make_immutable(obj): """ Delete the __setattr__ property to make the object mostly immutable. """ # TODO figure out how to get correct error message # def throw_immutability_exception(self, *args): # raise AquaError('Operator convenience globals are immutable.') obj.__setattr__ = None return obj # 1-Qubit Paulis X = make_immutable(PrimitiveOp(Pauli.from_label('X'))) Y = make_immutable(PrimitiveOp(Pauli.from_label('Y'))) Z = make_immutable(PrimitiveOp(Pauli.from_label('Z'))) I = make_immutable(PrimitiveOp(Pauli.from_label('I'))) # Clifford+T, and some other common non-parameterized gates CX = make_immutable(PrimitiveOp(CXGate())) S = make_immutable(PrimitiveOp(SGate())) H = make_immutable(PrimitiveOp(HGate())) T = make_immutable(PrimitiveOp(TGate())) Swap = make_immutable(PrimitiveOp(SwapGate())) CZ = make_immutable(PrimitiveOp(CZGate())) # 1-Qubit Paulis Zero = make_immutable(StateFn('0')) One = make_immutable(StateFn('1'))
def mapping(self, map_type, threshold=0.00000001, num_workers=4): """Map fermionic operator to qubit operator. Using multiprocess to speedup the mapping, the improvement can be observed when h2 is a non-sparse matrix. Args: map_type (str): case-insensitive mapping type. "jordan_wigner", "parity", "bravyi_kitaev", "bksf" threshold (float): threshold for Pauli simplification num_workers (int): number of processes used to map. Returns: Operator: create an Operator object in Paulis form. Raises: QiskitChemistryError: if the `map_type` can not be recognized. """ """ #################################################################### ############ DEFINING MAPPED FERMIONIC OPERATORS ############## #################################################################### """ self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a = self._jordan_wigner_mode(n) elif map_type == 'parity': a = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError( 'Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') """ #################################################################### ############ BUILDING THE MAPPED HAMILTONIAN ################ #################################################################### """ max_workers = min(num_workers, multiprocessing.cpu_count()) pauli_list = Operator(paulis=[]) with concurrent.futures.ProcessPoolExecutor( max_workers=max_workers) as executor: # One-body futures = [ executor.submit(FermionicOperator._one_body_mapping, self._h1[i, j], a[i], a[j], threshold) for i, j in itertools.product(range(n), repeat=2) if self._h1[i, j] != 0 ] for future in futures: result = future.result() pauli_list += result pauli_list.chop(threshold=threshold) # Two-body futures = [ executor.submit(FermionicOperator._two_body_mapping, self._h2[i, j, k, m], a[i], a[j], a[k], a[m], threshold) for i, j, k, m in itertools.product(range(n), repeat=4) if self._h2[i, j, k, m] != 0 ] for future in futures: result = future.result() pauli_list += result pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [ self._ph_trans_shift, Pauli.from_label('I' * self._modes) ] pauli_list += Operator(paulis=[pauli_term]) return pauli_list
'9': [], '10': [] } for i in range(0, 1): k = 0 runtime_sum = 0 exact_time_sum = 0 vqeruntime_sum = 0 num_qubits = 4 print('num_qubits', num_qubits) while k < runs: initial_state = Zero(num_qubits) op_list = [] wop = 0 * WeightedPauliOperator.from_list( paulis=[Pauli.from_label('I' * num_qubits)], weights=[1.0]) #mat = np.random.uniform(0, 1, size=(2**num_qubits, 2**num_qubits)) + 1j * np.random.uniform(0, 1, size=(2**num_qubits, 2**num_qubits)) #mat = np.conjugate(np.transpose(mat)) + mat #ham = to_weighted_pauli_operator(MatrixOperator(mat)) #creates random hamiltonian from random matrix "mat" #ham = get_h_4_hamiltonian(0.5, 2, "jw") ham = retrieve_ham(k) op_list = retrieve_op_list(k, rev=True) #op_list = [WeightedPauliOperator.from_list([Pauli.from_label('YYZZ')],[1.0]), # WeightedPauliOperator.from_list([Pauli.from_label('XXXY')], [1.0]), # WeightedPauliOperator.from_list([Pauli.from_label('IIYZ')], [1.0])] print(ham.print_details()) #ham = Gen_rand_rand_ham(k+1, num_qubits) qubitOp = ham num_qubits = qubitOp.num_qubits print('iteration: ', k + 1)
exact_dict = {'2': [], '3': [], '4': [], '5': [], '6': [], '7': [], '8': [], '9': [], '10': []} num_qubits = 4 #test = random_diagonal_hermitian(2) #print(test.print_details()) #mat = to_matrix_operator(test) #print(mat.print_details()) for i in range(0,1): k = 0 runtime_sum = 0 exact_time_sum = 0 vqeruntime_sum = 0 print('num_qubits', num_qubits) while k < runs: initial_state = Zero(num_qubits) op_list = [] wop = 0*WeightedPauliOperator.from_list(paulis=[Pauli.from_label('I'*num_qubits)], weights=[1.0]) #mat = np.random.uniform(0, 1, size=(2**num_qubits, 2**num_qubits)) + 1j * np.random.uniform(0, 1, size=(2**num_qubits, 2**num_qubits)) #mat = np.conjugate(np.transpose(mat)) + mat #ham = to_weighted_pauli_operator(MatrixOperator(mat)) #creates random hamiltonian from random matrix "mat" ham = get_h_4_hamiltonian(0.25, 2, "jw") #ham = retrieve_ham(0, num_qubits = num_qubits) print('old_ham', ham.print_details()) #ham = get_h_4_hamiltonian(0.5,2,'jw') #op_list = retrieve_op_list(0, rev = True, num_qubits = num_qubits) #for op in op_list: # print(op.print_details()) op_list = [WeightedPauliOperator.from_list([Pauli.from_label('IIXX')]), WeightedPauliOperator.from_list([Pauli.from_label('XXXY')])] #op_list = [WeightedPauliOperator.from_list([Pauli.from_label('YYZZ')],[1.0]), # WeightedPauliOperator.from_list([Pauli.from_label('XXXY')], [1.0]), # WeightedPauliOperator.from_list([Pauli.from_label('IIYZ')], [1.0])]