def hartree_fock_state_jellium(grid, n_electrons, spinless=True, plane_wave=False): """Give the Hartree-Fock state of jellium. Args: grid (Grid): The discretization to use. n_electrons (int): Number of electrons in the system. spinless (bool): Whether to use the spinless model or not. plane_wave (bool): Whether to return the Hartree-Fock state in the plane wave (True) or dual basis (False). Notes: The jellium model is built up by filling the lowest-energy single-particle states in the plane-wave Hamiltonian until n_electrons states are filled. """ from openfermion.hamiltonians import plane_wave_kinetic # Get the jellium Hamiltonian in the plane wave basis. # For determining the Hartree-Fock state in the PW basis, only the # kinetic energy terms matter. hamiltonian = plane_wave_kinetic(grid, spinless=spinless) hamiltonian = normal_ordered(hamiltonian) hamiltonian.compress() # The number of occupied single-particle states is the number of electrons. # Those states with the lowest single-particle energies are occupied first. occupied_states = lowest_single_particle_energy_states( hamiltonian, n_electrons) occupied_states = numpy.array(occupied_states) if plane_wave: # In the plane wave basis the HF state is a single determinant. hartree_fock_state_index = numpy.sum(2**occupied_states) hartree_fock_state = csr_matrix( ([1.0], ([hartree_fock_state_index], [0])), shape=(2**count_qubits(hamiltonian), 1)) else: # Inverse Fourier transform the creation operators for the state to get # to the dual basis state, then use that to get the dual basis state. hartree_fock_state_creation_operator = FermionOperator.identity() for state in occupied_states[::-1]: hartree_fock_state_creation_operator *= (FermionOperator( ((int(state), 1), ))) dual_basis_hf_creation_operator = inverse_fourier_transform( hartree_fock_state_creation_operator, grid, spinless) dual_basis_hf_creation = normal_ordered( dual_basis_hf_creation_operator) # Initialize the HF state as a sparse matrix. hartree_fock_state = dok_matrix((2**count_qubits(hamiltonian), 1), dtype=complex) # Populate the elements of the HF state in the dual basis. for term in dual_basis_hf_creation.terms: index = 0 for operator in term: index += 2**operator[0] hartree_fock_state[index, 0] = dual_basis_hf_creation.terms[term] hartree_fock_state = hartree_fock_state.tocsr() return hartree_fock_state
def test_quad_offsite_reversed(self): op = QuadOperator(((3, 'q'), (2, 'p'))) expected = QuadOperator(((2, 'p'), (3, 'q'))) self.assertTrue(expected == normal_ordered(op))
def simulation_ordered_grouped_low_depth_terms_with_info( hamiltonian, input_ordering=None, external_potential_at_end=False): """Give terms from the dual basis Hamiltonian in simulated order. Uses the simulation ordering, grouping terms into hopping (i^ j + j^ i) and number (i^j^ i j + c_i i^ i + c_j j^ j) operators. Pre-computes term information (indices each operator acts on, as well as whether each operator is a hopping operator. Args: hamiltonian (FermionOperator): The Hamiltonian. input_ordering (list): The initial Jordan-Wigner canonical order. If no input ordering is specified, defaults to [0..n_qubits] where n_qubits is the number of qubits in the Hamiltonian. external_potential_at_end (bool): Whether to include the rotations from the external potential at the end of the Trotter step, or intersperse them throughout it. Returns: A 3-tuple of terms from the Hamiltonian in order of simulation, the indices they act on, and whether they are hopping operators (both also in the same order). Notes: Follows the "stagger"-based simulation order discussed in Kivlichan et al., "Quantum Simulation of Electronic Structure with Linear Depth and Connectivity", arxiv:1711.04789; as such, the only permitted types of terms are hopping (i^ j + j^ i) and potential terms which are products of at most two number operators. """ n_qubits = count_qubits(hamiltonian) hamiltonian = normal_ordered(hamiltonian) ordered_terms = [] ordered_indices = [] ordered_is_hopping_operator = [] # If no input mode ordering is specified, default to range(n_qubits). try: input_ordering = list(input_ordering) except TypeError: input_ordering = list(range(n_qubits)) # Half a second-order Trotter step reverses the input ordering: this tells # us how much we need to include in the ordered list of terms. final_ordering = list(reversed(input_ordering)) # Follow odd-even transposition sort. In alternating steps, swap each even # qubits with the odd qubit to its right, and in the next step swap each # the odd qubits with the even qubit to its right. Do this until the input # ordering has been reversed. parity = 0 while input_ordering != final_ordering: results = stagger_with_info( hamiltonian, input_ordering, parity, external_potential_at_end) terms_in_layer, indices_in_layer, is_hopping_operator_in_layer = ( results) ordered_terms.extend(terms_in_layer) ordered_indices.extend(indices_in_layer) ordered_is_hopping_operator.extend(is_hopping_operator_in_layer) # Alternate even and odd steps of the reversal procedure. parity = 1 - parity # If all the rotations from the external potential are in the final layer, # i.e. we don't intersperse them throughout the Trotter step. if external_potential_at_end: terms_in_final_layer = [] indices_in_final_layer = [] is_hopping_operator_in_final_layer = [] for qubit in range(n_qubits): coeff = hamiltonian.terms.get(((qubit, 1), (qubit, 0)), 0.0) if coeff: terms_in_final_layer.append( FermionOperator(((qubit, 1), (qubit, 0)), coeff)) indices_in_final_layer.append(set((qubit,))) is_hopping_operator_in_final_layer.append(False) ordered_terms.extend(terms_in_final_layer) ordered_indices.extend(indices_in_final_layer) ordered_is_hopping_operator.extend(is_hopping_operator_in_final_layer) return (ordered_terms, ordered_indices, ordered_is_hopping_operator)
def test_fermion_double_create_separated(self): op = FermionOperator(((3, 1), (2, 0), (3, 1))) expected = FermionOperator((), 0.0) self.assertTrue(expected == normal_ordered(op))
def test_quad_two_term(self): op_b = QuadOperator('p0 q0 p3', 88.) normal_ordered_b = normal_ordered(op_b, hbar=2) expected = QuadOperator('p3', -88.*2j) + QuadOperator('q0 p0 p3', 88.0) self.assertTrue(normal_ordered_b == expected)
def test_fermion_number(self): number_op2 = FermionOperator(((2, 1), (2, 0))) self.assertTrue(number_op2 == normal_ordered(number_op2))
def test_fermion_offsite(self): op = FermionOperator(((3, 1), (2, 0))) self.assertTrue(op == normal_ordered(op))
def get_number_preserving_sparse_operator(fermion_op, num_qubits, num_electrons, spin_preserving=False, reference_determinant=None, excitation_level=None): """Initialize a Scipy sparse matrix in a specific symmetry sector. This method initializes a Scipy sparse matrix from a FermionOperator, explicitly working in a particular particle number sector. Optionally, it can also restrict the space to contain only states with a particular Sz. Finally, the Hilbert space can also be restricted to only those states which are reachable by excitations up to a fixed rank from an initial reference determinant. Args: fermion_op(FermionOperator): An instance of the FermionOperator class. It should not contain terms which do not preserve particle number. If spin_preserving is set to True it should also not contain terms which do not preserve the Sz (it is assumed that the ordering of the indices goes alpha, beta, alpha, beta, ...). num_qubits(int): The total number of qubits / spin-orbitals in the system. num_electrons(int): The number of particles in the desired Hilbert space. spin_preserving(bool): Whether or not the constructed operator should be defined in a space which has support only on states with the same Sz value as the reference_determinant. reference_determinant(list(bool)): A list, whose length is equal to num_qubits, which specifies which orbitals should be occupied in the reference state. If spin_preserving is set to True then the Sz value of this reference state determines the Sz value of the symmetry sector in which the generated operator acts. If a value for excitation_level is provided then the excitations are generated with respect to the reference state. In any case, the ordering of the states in the matrix representation of the operator depends on reference_determinant and the state corresponding to reference_determinant is the vector [1.0, 0.0, 0.0 ... 0.0]. Can be set to None in order to take the first num_electrons orbitals to be the occupied orbitals. excitation_level(int): The number of excitations from the reference state which should be included in the generated operator's matrix representation. Can be set to None to include all levels of excitation. Returns: sparse_op(scipy.sparse.csc_matrix): A sparse matrix representation of fermion_op in the basis set by the arguments. """ # We use the Hartree-Fock determinant as a reference if none is provided. if reference_determinant is None: reference_determinant = numpy.array( [i < num_electrons for i in range(num_qubits)]) else: reference_determinant = numpy.asarray(reference_determinant) if excitation_level is None: excitation_level = num_electrons state_array = numpy.asarray( list( _iterate_basis_(reference_determinant, excitation_level, spin_preserving))) # Create a 1d array with each determinant encoded as an integer for sorting purposes. int_state_array = state_array.dot( 1 << numpy.arange(state_array.shape[1])[::-1]) sorting_indices = numpy.argsort(int_state_array) space_size = state_array.shape[0] fermion_op = normal_ordered(fermion_op) sparse_op = scipy.sparse.csc_matrix((space_size, space_size), dtype=float) for term, coefficient in fermion_op.terms.items(): if len(term) == 0: constant = coefficient * scipy.sparse.identity( space_size, dtype=float, format='csc') sparse_op += constant else: term_op = _build_term_op_(term, state_array, int_state_array, sorting_indices) sparse_op += coefficient * term_op return sparse_op
def get_interaction_operator(fermion_operator, n_qubits=None): r"""Convert a 2-body fermionic operator to InteractionOperator. This function should only be called on fermionic operators which consist of only a_p^\dagger a_q and a_p^\dagger a_q^\dagger a_r a_s terms. The one-body terms are stored in a matrix, one_body[p, q], and the two-body terms are stored in a tensor, two_body[p, q, r, s]. Returns: interaction_operator: An instance of the InteractionOperator class. Raises: TypeError: Input must be a FermionOperator. TypeError: FermionOperator does not map to InteractionOperator. Warning: Even assuming that each creation or annihilation operator appears at most a constant number of times in the original operator, the runtime of this method is exponential in the number of qubits. """ if not isinstance(fermion_operator, FermionOperator): raise TypeError('Input must be a FermionOperator.') if n_qubits is None: n_qubits = count_qubits(fermion_operator) if n_qubits < count_qubits(fermion_operator): raise ValueError('Invalid number of qubits specified.') # Normal order the terms and initialize. fermion_operator = normal_ordered(fermion_operator) constant = 0. one_body = numpy.zeros((n_qubits, n_qubits), complex) two_body = numpy.zeros((n_qubits, n_qubits, n_qubits, n_qubits), complex) # Loop through terms and assign to matrix. for term in fermion_operator.terms: coefficient = fermion_operator.terms[term] # Ignore this term if the coefficient is zero if abs(coefficient) < EQ_TOLERANCE: continue # Handle constant shift. if len(term) == 0: constant = coefficient elif len(term) == 2: # Handle one-body terms. if [operator[1] for operator in term] == [1, 0]: p, q = [operator[0] for operator in term] one_body[p, q] = coefficient else: raise InteractionOperatorError('FermionOperator does not map ' 'to InteractionOperator.') elif len(term) == 4: # Handle two-body terms. if [operator[1] for operator in term] == [1, 1, 0, 0]: p, q, r, s = [operator[0] for operator in term] two_body[p, q, r, s] = coefficient else: raise InteractionOperatorError('FermionOperator does not map ' 'to InteractionOperator.') else: # Handle non-molecular Hamiltonian. raise InteractionOperatorError('FermionOperator does not map ' 'to InteractionOperator.') # Form InteractionOperator and return. interaction_operator = InteractionOperator(constant, one_body, two_body) return interaction_operator
def get_quadratic_hamiltonian(fermion_operator, chemical_potential=0., n_qubits=None, ignore_incompatible_terms=False): r"""Convert a quadratic fermionic operator to QuadraticHamiltonian. Args: fermion_operator(FermionOperator): The operator to convert. chemical_potential(float): A chemical potential to include in the returned operator n_qubits(int): Optionally specify the total number of qubits in the system ignore_incompatible_terms(bool): This flag determines the behavior of this method when it encounters terms that are not quadratic that is, terms that are not of the form a^\dagger_p a_q. If set to True, this method will simply ignore those terms. If False, then this method will raise an error if it encounters such a term. The default setting is False. Returns: quadratic_hamiltonian: An instance of the QuadraticHamiltonian class. Raises: TypeError: Input must be a FermionOperator. TypeError: FermionOperator does not map to QuadraticHamiltonian. Warning: Even assuming that each creation or annihilation operator appears at most a constant number of times in the original operator, the runtime of this method is exponential in the number of qubits. """ if not isinstance(fermion_operator, FermionOperator): raise TypeError('Input must be a FermionOperator.') if n_qubits is None: n_qubits = count_qubits(fermion_operator) if n_qubits < count_qubits(fermion_operator): raise ValueError('Invalid number of qubits specified.') # Normal order the terms and initialize. fermion_operator = normal_ordered(fermion_operator) constant = 0. combined_hermitian_part = numpy.zeros((n_qubits, n_qubits), complex) antisymmetric_part = numpy.zeros((n_qubits, n_qubits), complex) # Loop through terms and assign to matrix. for term in fermion_operator.terms: coefficient = fermion_operator.terms[term] # Ignore this term if the coefficient is zero if abs(coefficient) < EQ_TOLERANCE: continue if len(term) == 0: # Constant term constant = coefficient elif len(term) == 2: ladder_type = [operator[1] for operator in term] p, q = [operator[0] for operator in term] if ladder_type == [1, 0]: combined_hermitian_part[p, q] = coefficient elif ladder_type == [1, 1]: # Need to check that the corresponding [0, 0] term is present conjugate_term = ((p, 0), (q, 0)) if conjugate_term not in fermion_operator.terms: raise QuadraticHamiltonianError( 'FermionOperator does not map ' 'to QuadraticHamiltonian (not Hermitian).') else: matching_coefficient = -fermion_operator.terms[ conjugate_term].conjugate() discrepancy = abs(coefficient - matching_coefficient) if discrepancy > EQ_TOLERANCE: raise QuadraticHamiltonianError( 'FermionOperator does not map ' 'to QuadraticHamiltonian (not Hermitian).') antisymmetric_part[p, q] += .5 * coefficient antisymmetric_part[q, p] -= .5 * coefficient else: # ladder_type == [0, 0] # Need to check that the corresponding [1, 1] term is present conjugate_term = ((p, 1), (q, 1)) if conjugate_term not in fermion_operator.terms: raise QuadraticHamiltonianError( 'FermionOperator does not map ' 'to QuadraticHamiltonian (not Hermitian).') else: matching_coefficient = -fermion_operator.terms[ conjugate_term].conjugate() discrepancy = abs(coefficient - matching_coefficient) if discrepancy > EQ_TOLERANCE: raise QuadraticHamiltonianError( 'FermionOperator does not map ' 'to QuadraticHamiltonian (not Hermitian).') antisymmetric_part[p, q] -= .5 * coefficient.conjugate() antisymmetric_part[q, p] += .5 * coefficient.conjugate() elif not ignore_incompatible_terms: # Operator contains non-quadratic terms raise QuadraticHamiltonianError('FermionOperator does not map ' 'to QuadraticHamiltonian ' '(contains non-quadratic terms).') # Compute Hermitian part hermitian_part = (combined_hermitian_part + chemical_potential * numpy.eye(n_qubits)) # Check that the operator is Hermitian if not is_hermitian(hermitian_part): raise QuadraticHamiltonianError( 'FermionOperator does not map ' 'to QuadraticHamiltonian (not Hermitian).') # Form QuadraticHamiltonian and return. discrepancy = numpy.max(numpy.abs(antisymmetric_part)) if discrepancy < EQ_TOLERANCE: # Hamiltonian conserves particle number quadratic_hamiltonian = QuadraticHamiltonian( hermitian_part, constant=constant, chemical_potential=chemical_potential) else: # Hamiltonian does not conserve particle number quadratic_hamiltonian = QuadraticHamiltonian(hermitian_part, antisymmetric_part, constant, chemical_potential) return quadratic_hamiltonian
def get_diagonal_coulomb_hamiltonian(fermion_operator, n_qubits=None, ignore_incompatible_terms=False): r"""Convert a FermionOperator to a DiagonalCoulombHamiltonian. Args: fermion_operator(FermionOperator): The operator to convert. n_qubits(int): Optionally specify the total number of qubits in the system ignore_incompatible_terms(bool): This flag determines the behavior of this method when it encounters terms that are not represented by the DiagonalCoulombHamiltonian class, namely, terms that are not quadratic and not quartic of the form a^\dagger_p a_p a^\dagger_q a_q. If set to True, this method will simply ignore those terms. If False, then this method will raise an error if it encounters such a term. The default setting is False. """ if not isinstance(fermion_operator, FermionOperator): raise TypeError('Input must be a FermionOperator.') if n_qubits is None: n_qubits = count_qubits(fermion_operator) if n_qubits < count_qubits(fermion_operator): raise ValueError('Invalid number of qubits specified.') fermion_operator = normal_ordered(fermion_operator) constant = 0. one_body = numpy.zeros((n_qubits, n_qubits), complex) two_body = numpy.zeros((n_qubits, n_qubits), float) for term, coefficient in fermion_operator.terms.items(): # Ignore this term if the coefficient is zero if abs(coefficient) < EQ_TOLERANCE: continue if len(term) == 0: constant = coefficient else: actions = [operator[1] for operator in term] if actions == [1, 0]: p, q = [operator[0] for operator in term] one_body[p, q] = coefficient elif actions == [1, 1, 0, 0]: p, q, r, s = [operator[0] for operator in term] if p == r and q == s: if abs(numpy.imag(coefficient)) > EQ_TOLERANCE: raise ValueError( 'FermionOperator does not map to ' 'DiagonalCoulombHamiltonian (not Hermitian).') coefficient = numpy.real(coefficient) two_body[p, q] = -.5 * coefficient two_body[q, p] = -.5 * coefficient elif not ignore_incompatible_terms: raise ValueError('FermionOperator does not map to ' 'DiagonalCoulombHamiltonian ' '(contains terms with indices ' '{}).'.format((p, q, r, s))) elif not ignore_incompatible_terms: raise ValueError('FermionOperator does not map to ' 'DiagonalCoulombHamiltonian (contains terms ' 'with action {}.'.format(tuple(actions))) # Check that the operator is Hermitian if not is_hermitian(one_body): raise ValueError( 'FermionOperator does not map to DiagonalCoulombHamiltonian ' '(not Hermitian).') return DiagonalCoulombHamiltonian(one_body, two_body, constant)
def test_ucc_h2_singlet(self): geometry = [('H', (0., 0., 0.)), ('H', (0., 0., 0.7414))] basis = 'sto-3g' multiplicity = 1 filename = os.path.join(THIS_DIRECTORY, 'data', 'H2_sto-3g_singlet_0.7414') self.molecule = MolecularData( geometry, basis, multiplicity, filename=filename) self.molecule.load() # Get molecular Hamiltonian. self.molecular_hamiltonian = self.molecule.get_molecular_hamiltonian() # Get FCI RDM. self.fci_rdm = self.molecule.get_molecular_rdm(use_fci=1) # Get explicit coefficients. self.nuclear_repulsion = self.molecular_hamiltonian.constant self.one_body = self.molecular_hamiltonian.one_body_tensor self.two_body = self.molecular_hamiltonian.two_body_tensor # Get fermion Hamiltonian. self.fermion_hamiltonian = normal_ordered(get_fermion_operator( self.molecular_hamiltonian)) # Get qubit Hamiltonian. self.qubit_hamiltonian = jordan_wigner(self.fermion_hamiltonian) # Get the sparse matrix. self.hamiltonian_matrix = get_sparse_operator( self.molecular_hamiltonian) # Test UCCSD for accuracy against FCI using loaded t amplitudes. ucc_operator = uccsd_generator( self.molecule.ccsd_single_amps, self.molecule.ccsd_double_amps) hf_state = jw_hartree_fock_state( self.molecule.n_electrons, count_qubits(self.qubit_hamiltonian)) uccsd_sparse = jordan_wigner_sparse(ucc_operator) uccsd_state = scipy.sparse.linalg.expm_multiply(uccsd_sparse, hf_state) expected_uccsd_energy = expectation(self.hamiltonian_matrix, uccsd_state) self.assertAlmostEqual(expected_uccsd_energy, self.molecule.fci_energy, places=4) print("UCCSD ENERGY: {}".format(expected_uccsd_energy)) # Test CCSD singlet for precise match against FCI using loaded t # amplitudes packed_amplitudes = uccsd_singlet_get_packed_amplitudes( self.molecule.ccsd_single_amps, self.molecule.ccsd_double_amps, self.molecule.n_qubits, self.molecule.n_electrons) ccsd_operator = uccsd_singlet_generator( packed_amplitudes, self.molecule.n_qubits, self.molecule.n_electrons, anti_hermitian=False) ccsd_sparse_r = jordan_wigner_sparse(ccsd_operator) ccsd_sparse_l = jordan_wigner_sparse( -hermitian_conjugated(ccsd_operator)) ccsd_state_r = scipy.sparse.linalg.expm_multiply(ccsd_sparse_r, hf_state) ccsd_state_l = scipy.sparse.linalg.expm_multiply(ccsd_sparse_l, hf_state) expected_ccsd_energy = ccsd_state_l.conjugate().dot( self.hamiltonian_matrix.dot(ccsd_state_r)) self.assertAlmostEqual(expected_ccsd_energy, self.molecule.fci_energy)
def objective_function(self, amps=None): """ This function returns the Hamiltonian expectation value over the final circuit output state. If argument packed_amps is given, the circuit will run with those parameters. Otherwise, the initial angles will be used. :param [list(), numpy.ndarray] amps: list of circuit angles to run the objective function over. :return: energy estimate :rtype: float """ E = 0 t = time.time() if amps is None: packed_amps = self.initial_packed_amps elif isinstance(amps, np.ndarray): packed_amps = amps.tolist()[:] elif isinstance(amps, list): packed_amps = amps[:] else: raise TypeError('Please supply the circuit parameters' ' as a list or np.ndarray') self.term_es = {} if self.tomography: if (not self.parametric_way) and (self.strategy == 'UCCSD'): # modify hard-coded type ansatz circuit based # on packed_amps angles self.ansatz = uccsd_ansatz_circuit(packed_amps, self.molecule.n_orbitals, self.molecule.n_electrons, cq=self.custom_qubits) self.compile_tomo_expts() for experiment in self.experiment_list: term_es = experiment.run_experiment(self.qc, packed_amps) self.term_es.update(term_es) for term in self.pauli_list: key = term.operations_as_set() if len(key) > 0: E += term.coefficient * self.term_es[key] E += self.offset # add the offset energy to avoid doing superfluous # tomography over the identity operator. elif self.method == 'WFS': # In the direct WFS method without tomography, # direct access to wavefunction is allowed and expectation # value is exact each run. if self.parametric_way: E += WavefunctionSimulator().expectation( self.ref_state + self.ansatz, self.pauli_sum, { 'theta': packed_amps }).real # attach parametric angles here else: if packed_amps is not None: # modify hard-coded type ansatz circuit # based on packed_amps angles self.ansatz = uccsd_ansatz_circuit( packed_amps, self.molecule.n_orbitals, self.molecule.n_electrons, cq=self.custom_qubits) E += WavefunctionSimulator().expectation( self.ref_state + self.ansatz, self.pauli_sum).real elif self.method == 'Numpy': if self.parametric_way: raise ValueError('NumpyWavefunctionSimulator() backend' ' does not yet support parametric programs.') else: if packed_amps is not None: self.ansatz = uccsd_ansatz_circuit( packed_amps, self.molecule.n_orbitals, self.molecule.n_electrons, cq=self.custom_qubits) E += NumpyWavefunctionSimulator(n_qubits=self.n_qubits).\ do_program(self.ref_state+self.ansatz).\ expectation(self.pauli_sum).real elif self.method == 'linalg': # check if molecule has data sufficient to construct UCCSD ansatz # and propagate starting from HF state if self.molecule is not None: propagator = normal_ordered( uccsd_singlet_generator(packed_amps, 2 * self.molecule.n_orbitals, self.molecule.n_electrons, anti_hermitian=True)) qubit_propagator_matrix = get_sparse_operator( propagator, n_qubits=self.n_qubits) uccsd_state = expm_multiply(qubit_propagator_matrix, self.initial_psi) expected_uccsd_energy = expectation(self.hamiltonian_matrix, uccsd_state).real E += expected_uccsd_energy else: # apparently no molecule was supplied; # attempt to just propagate the ansatz from user-specified # initial state, using a circuit unitary # if supplied by the user, otherwise the initial state itself, # and then estimate over <H> if self.initial_psi is None: raise ValueError('Warning: no initial wavefunction set.' ' Please set using ' 'VQEexperiment().set_initial_state()') # attempt to propagate with a circuit unitary if self.circuit_unitary is None: psi = self.initial_psi else: psi = expm_multiply(self.circuit_unitary, self.initial_psi) E += expectation(self.hamiltonian_matrix, psi).real else: raise ValueError( 'Impossible method: please choose from method' ' = {WFS, Numpy, linalg} if Tomography is set' ' to False, or choose from method = ' '{QC, WFS, Numpy, linalg} if tomography is set to True') # energy should be real E = E.real if self.verbose: self.it_num += 1 print('black-box function call #' + str(self.it_num)) print('Energy estimate is now: ' + str(E)) print('at angles: ', packed_amps) print('and this took ' + '{0:.3f}'.format(time.time()-t) + \ ' seconds to evaluate') self.history.append(E) return E
def __init__(self, qc: Union[QuantumComputer, None] = None, hamiltonian: Union[PauliSum, List[PauliTerm], None] = None, molecule: MolecularData = None, method: str = 'Numpy', strategy: str = 'UCCSD', optimizer: str = 'BFGS', maxiter: int = 100000, shotN: int = 10000, active_reset: bool = True, tomography: bool = False, verbose: bool = False, parametric: bool = False, custom_qubits=None): """ VQE experiment class. Initialize an instance of this class to prepare a VQE experiment. One may instantiate this class either based on an OpenFermion MolecularData object (containing a chemistry problem Hamiltonian) or manually suggest a Hamiltonian. The VQE can run circuits on different virtual or real backends: currently, we support the Rigetti QPU backend, locally running QVM, a WavefunctionSimulator, a NumpyWavefunctionSimulator, a PyQVM. Alternatively, one may run the VQE ansatz unitary directly (not decomposed as a circuit) via direct exponentiation of the unitary ansatz, with the 'linalg' method. The different backends do not all support parametric gates (yet), and the user can specify whether or not to use it. Currently, we support two built-in ansatz strategies and the option of setting your own ansatz circuit. The built-in UCCSD and HF strategies are based on data from MolecularData object and thus require one. For finding the groundstate of a custom Hamiltonian, it is required to manually set an ansatz strategy. Currently, the only classical optimizer for the VQE is the scipy.optimize.minimize module. This may be straightforwardly extended in future releases, contributions are welcome. This class can be initialized with any algorithm in the scipy class, and the max number of iterations can be specified. For some QuantumComputer objects, the qubit lattice is not numbered 0..N-1 but has architecture-specific logical labels. These need to be manually read from the lattice topology and specified in the list custom_qubits. On the physical hardware QPU, actively resetting the qubits is supported to speed up the repetition time of VQE. To debug and during development, set verbose=True to print output details to the console. :param [QuantumComputer(),None] qc: object :param [PauliSum, list(PauliTerm)] hamiltonian: Hamiltonian which one would like to simulate :param MolecularData molecule: OpenFermion Molecule data object. If this is given, the VQE module assumes a chemistry experiment using OpenFermion :param str method: string describing the Backend solver method. current options: {Numpy, WFS, linalg, QC} :param str strategy: string describing circuit VQE strategy. current options: {UCCSD, HF, custom_program} :param str optimizer: classical optimization algorithm, choose from scipy.optimize.minimize options :param int maxiter: max number of iterations :param int shotN: number of shots in the Tomography experiments :param bool active_reset: whether or not to actively reset the qubits :param bool tomography: set to False for access to full wavefunction, set to True for just sampling from it :param bool verbose: set to True for verbose output to the console, for all methods in this class :param bool parametric: set to True to use parametric gate compilation, False to compile a new circuit for every iteration :param list() custom_qubits: list of qubits, i.e. [7,0,1,2] ordering the qubit IDs as they appear on the QPU lattice of the QuantumComputer() object. """ if isinstance(hamiltonian, PauliSum): if molecule is not None: raise TypeError('Please supply either a Hamiltonian object' ' or a Molecule object, but not both.') # Hamiltonian as a PauliSum, extracted to give a list instead self.pauli_list = hamiltonian.terms self.n_qubits = self.get_qubit_req() # assumes 0-(N-1) ordering and every pauli index is in use elif isinstance(hamiltonian, List): if molecule is not None: raise TypeError('Please supply either a Hamiltonian object' ' or a Molecule object, but not both.') if len(hamiltonian) > 0: if all([isinstance(term, PauliTerm) for term in hamiltonian]): self.pauli_list = hamiltonian self.n_qubits = self.get_qubit_req() else: raise TypeError('Hamiltonian as a list must ' 'contain only PauliTerm objects') else: print('Warning, empty hamiltonian passed, ' 'assuming identity Hamiltonian = 1') self.pauli_list = [ID()] # this is allowed in principle, # but won't make a lot of sense to use. elif hamiltonian is None: if molecule is None: raise TypeError('either feed a MolecularData object ' 'or a PyQuil Hamiltonian to this class') else: self.H = normal_ordered( get_fermion_operator(molecule.get_molecular_hamiltonian())) # store Fermionic # Hamiltonian in FermionOperator() instance self.qubitop = jordan_wigner(self.H) # Apply jordan_wigner transformation and store self.n_qubits = 2 * molecule.n_orbitals self.pauli_list = qubitop_to_pyquilpauli(self.qubitop).terms else: raise TypeError('hamiltonian must be a PauliSum ' 'or list of PauliTerms') # abstract QC. can refer to a qvm or qpu. # QC architecture and available gates decide the compilation of the # programs! if isinstance(qc, QuantumComputer): self.qc = qc elif qc is None: self.qc = None else: raise TypeError('qc must be a QuantumComputer object.' ' If you do not use a QC backend, omit, or supply ' 'qc=None') # number of shots in a tomography experiment if isinstance(shotN, int): self.shotN = shotN elif isinstance(shotN, float): self.shotN = int(shotN) else: raise TypeError('shotN must be an integer or float') # simulation method. Choose from methodoptions = ['WFS', 'linalg', 'QC', 'Numpy'] if method in methodoptions: self.method = method else: raise ValueError('choose a method from the following list: '\ + str(methodoptions) + '. If a QPU, QVM or PyQVM is passed to qc, select QC.') # circuit strategy. choose from UCCSD, HF, custom_program strategyoptions = ['UCCSD', 'HF', 'custom_program'] if strategy in strategyoptions: if (strategy in ['UCCSD', 'HF']) and molecule is None: raise ValueError( 'Strategy selected, UCCSD or HF, ' 'requires a MolecularData object from PySCF as input.') self.strategy = strategy else: raise ValueError('choose a circuit strategy from the' ' following list: ' + str(strategyoptions)) # classical optimizer classical_options = [ 'Nelder-Mead', 'Powell', 'CG', 'BFGS', 'Newton-CG', 'L-BFGS-B ', 'TNC', 'COBYLA', 'SLSQP', 'trust-constr', 'dogleg', 'trust-ncg', 'trust-exact', 'trust-krylov' ] if optimizer not in classical_options: raise ValueError('choose a classical optimizer from' ' the following list: ' + str(classical_options)) else: self.optimizer = optimizer # store the optimizer historical values self.history = [] # chemistry files. must be properly formatted # in order to use a UCCSD ansatz (see MolecularData) self.molecule = molecule # whether or not the qubits should be actively reset. # False will make the hardware wait for 3 coherence lengths # to go back to |0> self.active_reset = active_reset # max number of iterations for the classical optimizer self.maxiter = maxiter # vqe results, stores output of scipy.optimize.minimize, # a OptimizeResult object. initialize to None self.res = None # list of grouped experiments (only relevant to tomography) self.experiment_list = [] # whether to print debugging data to console self.verbose = verbose # real QPU has a custom qubit labeling self.custom_qubits = custom_qubits # i'th function call self.it_num = 0 # whether to perform parametric method self.parametric_way = parametric # whether to do tomography or just calculate the wavefunction self.tomography = tomography # initialize offset for pauli terms with identity. # this serves to avoid doing simulation for the identity # operator, which always yields unity times the coefficient # due to wavefunction normalization. self.set_offset() # set empty circuit unitary. # This is used for the direct linear algebraic methods. self.circuit_unitary = None if strategy not in ['UCCSD', 'HF', 'custom_program']: raise ValueError( 'please select a strategy from UCCSD,' ' HF, custom_program or modify this class with your ' 'own options') if strategy == 'UCCSD': # load UCCSD initial amps from the CCSD amps # in the MolecularData() object amps = uccsd_singlet_get_packed_amplitudes( self.molecule.ccsd_single_amps, self.molecule.ccsd_double_amps, n_qubits=self.molecule.n_orbitals * 2, n_electrons=self.molecule.n_electrons) self.initial_packed_amps = amps else: # allocate empty initial angles for the circuit. modify later. self.initial_packed_amps = [] if (strategy == 'UCCSD') and (method != 'linalg'): # UCCSD circuit strategy preparations self.ref_state = ref_state_preparation_circuit( molecule, ref_type='HF', cq=self.custom_qubits) if self.parametric_way: # in the parametric_way, # the circuit is built with free parameters self.ansatz = uccsd_ansatz_circuit_parametric( self.molecule.n_orbitals, self.molecule.n_electrons, cq=self.custom_qubits) else: # in the non-parametric_way, # the circuit has hard-coded angles for the gates. self.ansatz = uccsd_ansatz_circuit(self.initial_packed_amps, self.molecule.n_orbitals, self.molecule.n_electrons, cq=self.custom_qubits) elif strategy == 'HF': self.ref_state = ref_state_preparation_circuit( self.molecule, ref_type='HF', cq=self.custom_qubits) self.ansatz = Program() elif strategy == 'custom_program': self.parametric_way = True self.ref_state = Program() self.ansatz = Program() # prepare tomography experiment if necessary if self.tomography: if self.method == 'linalg': raise NotImplementedError( 'Tomography is not' ' yet implemented for the linalg method.') else: # avoid having to re-calculate the PauliSum object each time, # store it. self.pauli_sum = PauliSum(self.pauli_list) # perform miscellaneous method-specific preparations if self.method == 'QC': if qc is None: raise ValueError( 'Method is QC, please supply a valid ' 'QuantumComputer() object to the qc variable.') elif self.method == 'WFS': if (self.qc is not None) or (self.custom_qubits is not None): raise ValueError('The WFS method is not intended to be used' ' with a custom qubit lattice' ' or QuantumComputer object.') elif self.method == 'Numpy': if self.parametric_way: raise ValueError('NumpyWavefunctionSimulator() backend' ' does not yet support parametric programs.') if (self.qc is not None) or (self.custom_qubits is not None): raise ValueError('NumpyWavefunctionSimulator() backend is' ' not intended to be used with a ' 'QuantumComputer() object or custom lattice. ' 'Consider using PyQVM instead') elif self.method == 'linalg': if molecule is not None: # sparse initial state vector from the MolecularData() object self.initial_psi = jw_hartree_fock_state( self.molecule.n_electrons, 2 * self.molecule.n_orbitals) # sparse operator from the MolecularData() object self.hamiltonian_matrix = get_sparse_operator( self.H, n_qubits=self.n_qubits) else: self.hamiltonian_matrix = get_sparse_operator( pyquilpauli_to_qubitop(PauliSum(self.pauli_list))) self.initial_psi = None print('Please supply VQE initial state with method' ' VQEexperiment().set_initial_state()') else: raise ValueError('unknown method: please choose from method =' ' {linalg, WFS, tomography} for direct linear ' 'algebra, pyquil WavefunctionSimulator, ' 'or doing Tomography, respectively')
def test_boson_multi(self): op = BosonOperator(((2, 0), (1, 1), (2, 1))) expected = (BosonOperator(((2, 1), (1, 1), (2, 0))) + BosonOperator(((1, 1),))) self.assertTrue(expected == normal_ordered(op))
def test_ccr_offsite_even_cc(self): c2 = FermionOperator(((2, 1), )) c4 = FermionOperator(((4, 1), )) self.assertTrue(normal_ordered(c2 * c4) == normal_ordered(-c4 * c2)) self.assertTrue(jordan_wigner(c2 * c4) == jordan_wigner(-c4 * c2))
def test_fermion_two_term(self): op_b = FermionOperator(((2, 0), (4, 0), (2, 1)), -88.) normal_ordered_b = normal_ordered(op_b) expected = (FermionOperator(((4, 0),), 88.) + FermionOperator(((2, 1), (4, 0), (2, 0)), 88.)) self.assertTrue(normal_ordered_b == expected)
def test_ccr_offsite_odd_cc(self): c1 = FermionOperator(((1, 1), )) c4 = FermionOperator(((4, 1), )) self.assertTrue(normal_ordered(c1 * c4) == normal_ordered(-c4 * c1)) self.assertTrue(jordan_wigner(c1 * c4) == jordan_wigner(-c4 * c1))
def test_fermion_number_reversed(self): n_term_rev2 = FermionOperator(((2, 0), (2, 1))) number_op2 = number_operator(3, 2) expected = FermionOperator(()) - number_op2 self.assertTrue(normal_ordered(n_term_rev2) == expected)
def test_ccr_offsite_even_aa(self): a2 = FermionOperator(((2, 0), )) a4 = FermionOperator(((4, 0), )) self.assertTrue(normal_ordered(a2 * a4) == normal_ordered(-a4 * a2)) self.assertTrue(jordan_wigner(a2 * a4) == jordan_wigner(-a4 * a2))
def test_fermion_offsite_reversed(self): op = FermionOperator(((3, 0), (2, 1))) expected = -FermionOperator(((2, 1), (3, 0))) self.assertTrue(expected == normal_ordered(op))
def test_ccr_offsite_odd_aa(self): a1 = FermionOperator(((1, 0), )) a4 = FermionOperator(((4, 0), )) self.assertTrue(normal_ordered(a1 * a4) == normal_ordered(-a4 * a1)) self.assertTrue(jordan_wigner(a1 * a4) == jordan_wigner(-a4 * a1))
def test_fermion_multi(self): op = FermionOperator(((2, 0), (1, 1), (2, 1))) expected = (-FermionOperator(((2, 1), (1, 1), (2, 0))) - FermionOperator(((1, 1),))) self.assertTrue(expected == normal_ordered(op))
def test_commutator_hopping_with_single_number(self): com = commutator(FermionOperator('1^ 2', 1j), FermionOperator('1^ 1')) com = normal_ordered(com) self.assertEqual(com, -FermionOperator('1^ 2') * 1j)
def test_quad_offsite(self): op = QuadOperator(((3, 'p'), (2, 'q'))) self.assertTrue(op == normal_ordered(op))
def test_commutator_hopping_with_double_number_two_intersections(self): com = commutator(FermionOperator('2^ 3'), FermionOperator('3^ 2^ 3 2')) com = normal_ordered(com) self.assertEqual(com, FermionOperator.zero())
def test_exceptions(self): with self.assertRaises(TypeError): _ = normal_ordered(1)
def test_boson_number_reversed(self): n_term_rev2 = BosonOperator(((2, 0), (2, 1))) number_op2 = number_operator(3, 2, parity=1) expected = BosonOperator(()) + number_op2 self.assertTrue(normal_ordered(n_term_rev2) == expected)
def test_boson_single_term(self): op = BosonOperator('4 3 2 1') + BosonOperator('3 2') self.assertTrue(op == normal_ordered(op))
def simulation_ordered_grouped_hubbard_terms_with_info(hubbard_hamiltonian): """Give terms from the Fermi-Hubbard Hamiltonian in simulated order. Uses the simulation ordering, grouping terms into hopping (i^ j + j^ i) and on-site potential (i^j^ i j) operators. Pre-computes term information (indices each operator acts on, as well as whether each operator is a hopping operator). Args: hubbard_hamiltonian (FermionOperator): The Hamiltonian. original_ordering (list): The initial Jordan-Wigner canonical order. Returns: A 3-tuple of terms from the Hubbard Hamiltonian in order of simulation, the indices they act on, and whether they are hopping operators (both also in the same order). Notes: Assumes that the Hubbard model has spin and is on a 2D square aperiodic lattice. Uses the "stagger"-based Trotter step for the Hubbard model detailed in Kivlichan et al., "Quantum Simulation of Electronic Structure with Linear Depth and Connectivity", arxiv:1711.04789. """ hamiltonian = normal_ordered(hubbard_hamiltonian) n_qubits = count_qubits(hamiltonian) side_length = int(numpy.sqrt(n_qubits / 2.0)) ordered_terms = [] ordered_indices = [] ordered_is_hopping_operator = [] original_ordering = list(range(n_qubits)) for i in range(0, n_qubits - side_length, 2 * side_length): for j in range(2 * bool(i % (4 * side_length)), 2 * side_length, 4): original_ordering[i + j], original_ordering[i + j + 1] = ( original_ordering[i + j + 1], original_ordering[i + j]) input_ordering = list(original_ordering) # Follow odd-even transposition sort. In alternating steps, swap each even # qubits with the odd qubit to its right, and in the next step swap each # the odd qubits with the even qubit to its right. Do this until the input # ordering has been reversed. parities = [False, True] * int(side_length / 2 + 1) # int floors here for parity in parities: results = stagger_with_info(hubbard_hamiltonian, input_ordering, parity) terms_in_step, indices_in_step, is_hopping_operator_in_step = results ordered_terms.extend(terms_in_step) ordered_indices.extend(indices_in_step) ordered_is_hopping_operator.extend(is_hopping_operator_in_step) input_ordering = list(original_ordering) parities = [True] + [False, True] * int(side_length / 2) # int floors here for parity in parities: results = stagger_with_info(hubbard_hamiltonian, input_ordering, parity) terms_in_step, indices_in_step, is_hopping_operator_in_step = results ordered_terms.extend(terms_in_step) ordered_indices.extend(indices_in_step) ordered_is_hopping_operator.extend(is_hopping_operator_in_step) return (ordered_terms, ordered_indices, ordered_is_hopping_operator)