def test_ground_state_particle_nonconserving(self): """Test getting the ground state of a Hamiltonian that does not conserve particle number.""" for n_qubits in self.n_qubits_range: # Initialize a non-particle-number-conserving Hamiltonian quadratic_hamiltonian = random_quadratic_hamiltonian( n_qubits, False) # Compute the true ground state sparse_operator = get_sparse_operator(quadratic_hamiltonian) ground_energy, ground_state = get_ground_state(sparse_operator) # Compute the ground state using the circuit circuit_energy, circuit_state = ( jw_get_gaussian_state(quadratic_hamiltonian)) # Check that the energies match self.assertAlmostEqual(ground_energy, circuit_energy) # Check that the state obtained using the circuit is a ground state difference = (sparse_operator * circuit_state - ground_energy * circuit_state) discrepancy = 0. if difference.nnz: discrepancy = max(abs(difference.data)) self.assertTrue(discrepancy < EQ_TOLERANCE)
def test_excited_state_particle_nonconserving(self): """Test getting an excited state of a Hamiltonian that conserves particle number.""" for n_qubits in self.n_qubits_range: # Initialize a non-particle-number-conserving Hamiltonian quadratic_hamiltonian = random_quadratic_hamiltonian( n_qubits, False) # Pick some orbitals to occupy num_occupied_orbitals = numpy.random.randint(1, n_qubits + 1) occupied_orbitals = numpy.random.choice( range(n_qubits), num_occupied_orbitals, False) # Compute the Gaussian state circuit_energy, gaussian_state = jw_get_gaussian_state( quadratic_hamiltonian, occupied_orbitals) # Compute the true energy orbital_energies, constant = ( quadratic_hamiltonian.orbital_energies()) energy = numpy.sum(orbital_energies[occupied_orbitals]) + constant # Check that the energies match self.assertAlmostEqual(energy, circuit_energy) # Check that the state obtained using the circuit is an eigenstate # with the correct eigenvalue sparse_operator = get_sparse_operator(quadratic_hamiltonian) difference = (sparse_operator * gaussian_state - energy * gaussian_state) discrepancy = 0. if difference.nnz: discrepancy = max(abs(difference.data)) self.assertTrue(discrepancy < EQ_TOLERANCE)
def do_rotate_basis_quadratic_hamiltonian(self, real): """Test diagonalizing a quadratic Hamiltonian that conserves particle number.""" n_qubits = 5 # Initialize a particle-number-conserving quadratic Hamiltonian # and compute its orbital energies quad_ham = random_quadratic_hamiltonian(n_qubits, True, real=real) orbital_energies, constant = quad_ham.orbital_energies() # Rotate a basis where the Hamiltonian is diagonal _, diagonalizing_unitary, _ = ( quad_ham.diagonalizing_bogoliubov_transform()) quad_ham.rotate_basis(diagonalizing_unitary.T) # Check that the rotated Hamiltonian is diagonal with the correct # orbital energies D = numpy.zeros((n_qubits, n_qubits), dtype=complex) D[numpy.diag_indices(n_qubits)] = orbital_energies self.assertTrue(numpy.allclose(quad_ham.combined_hermitian_part, D)) # Check that the new Hamiltonian still conserves particle number self.assertTrue(quad_ham.conserves_particle_number) # Check that the orbital energies and constant are the same new_orbital_energies, new_constant = quad_ham.orbital_energies() self.assertTrue(numpy.allclose(orbital_energies, new_orbital_energies)) self.assertAlmostEqual(constant, new_constant)
def test_ground_state_particle_conserving(self): """Test getting the ground state of a Hamiltonian that conserves particle number.""" for n_qubits in self.n_qubits_range: # Initialize a particle-number-conserving Hamiltonian quadratic_hamiltonian = random_quadratic_hamiltonian( n_qubits, True) # Compute the true ground state sparse_operator = get_sparse_operator(quadratic_hamiltonian) ground_energy, ground_state = get_ground_state(sparse_operator) # Compute the ground state using the circuit circuit_energy, circuit_state = jw_get_gaussian_state( quadratic_hamiltonian) # Check that the energies match self.assertAlmostEqual(ground_energy, circuit_energy) # Check that the state obtained using the circuit is a ground state difference = (sparse_operator * circuit_state - ground_energy * circuit_state) discrepancy = numpy.amax(numpy.abs(difference)) self.assertAlmostEqual(discrepancy, 0)