HartreeFock and UCCSD num qubit param removal.

CHANGELOG.md

@@ -95,6 +95,10 @@ Changed
     in addition to the existing Operators (#852).
 -   The `BaseOperator` was renamed `LegacyBaseOperator` to avoid confusion with the new
     Operator flow `OperatorBase` (#852).
+-   HartreeFock initial state and UCCSD variational form `num_qubits` parameter removed as it was
+    only value checked against that computed internally from the other parameters. UCCSD `depth`
+    parameter renamed to `reps` and moved in order so it can default to 1. (#939)
+
 
 Removed
 -------

README.md

@@ -216,7 +216,7 @@ optimizer = L_BFGS_B()
 
 # setup the initial state for the variational form
 from qiskit.chemistry.components.initial_states import HartreeFock
-init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles)
+init_state = HartreeFock(num_spin_orbitals, num_particles)
 
 # setup the variational form for VQE
 from qiskit.circuit.library import TwoLocal

qiskit/chemistry/applications/molecular_ground_state_energy.py

@@ -146,14 +146,12 @@ def get_default_solver(quantum_instance: Union[QuantumInstance, BaseBackend]) ->
         Returns:
             Default solver callback
         """
-        # TODO num_qubits should be removed since they should be updated by VQE when operator is set
         def cb_default_solver(num_particles, num_orbitals,
                               qubit_mapping, two_qubit_reduction, z2_symmetries):
             """ Default solver """
-            initial_state = HartreeFock(2, num_orbitals, num_particles, qubit_mapping,
+            initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping,
                                         two_qubit_reduction, z2_symmetries.sq_list)
-            var_form = UCCSD(2, depth=1,
-                             num_orbitals=num_orbitals,
+            var_form = UCCSD(num_orbitals=num_orbitals,
                              num_particles=num_particles,
                              initial_state=initial_state,
                              qubit_mapping=qubit_mapping,

qiskit/chemistry/components/initial_states/hartree_fock.py

@@ -27,16 +27,14 @@
 class HartreeFock(InitialState):
     """A Hartree-Fock initial state."""
 
-    def __init__(self, num_qubits: int,
+    def __init__(self,
                  num_orbitals: int,
                  num_particles: Union[List[int], int],
                  qubit_mapping: str = 'parity',
                  two_qubit_reduction: bool = True,
                  sq_list: Optional[List[int]] = None) -> None:
-        """Constructor.
-
+        """
         Args:
-            num_qubits: number of qubits, has a min. value of 1.
             num_orbitals: number of spin orbitals, has a min. value of 1.
             num_particles: number of particles, if it is a list, the first number
                             is alpha and the second number if beta.
@@ -49,7 +47,6 @@ def __init__(self, num_qubits: int,
             ValueError: wrong setting in num_particles and num_orbitals.
             ValueError: wrong setting for computed num_qubits and supplied num_qubits.
         """
-        validate_min('num_qubits', num_qubits, 1)
         validate_min('num_orbitals', num_orbitals, 1)
         if isinstance(num_particles, list) and len(num_particles) != 2:
             raise ValueError('Num particles value {}. Number of values allowed is 2'.format(
@@ -85,9 +82,6 @@ def __init__(self, num_qubits: int,
         self._num_qubits = num_orbitals - 2 if self._two_qubit_reduction else self._num_orbitals
         self._num_qubits = self._num_qubits \
             if not self._qubit_tapering else self._num_qubits - len(sq_list)
-        if self._num_qubits != num_qubits:
-            raise ValueError("Computed num qubits {} does not match "
-                             "actual {}".format(self._num_qubits, num_qubits))
 
         self._bitstr = None
 

qiskit/chemistry/components/variational_forms/uccsd.py

@@ -48,10 +48,10 @@ class UCCSD(VariationalForm):
     And for the singlet q-UCCD (full) and pair q-UCCD) see: https://arxiv.org/abs/1911.10864
     """
 
-    def __init__(self, num_qubits: int,
-                 depth: int,
+    def __init__(self,
                  num_orbitals: int,
                  num_particles: Union[List[int], int],
+                 reps: int = 1,
                  active_occupied: Optional[List[int]] = None,
                  active_unoccupied: Optional[List[int]] = None,
                  initial_state: Optional[InitialState] = None,
@@ -68,11 +68,10 @@ def __init__(self, num_qubits: int,
         """Constructor.
 
         Args:
-            num_qubits: number of qubits, has a min. value of 1.
-            depth: number of replica of basic module, has a min. value of 1.
             num_orbitals: number of spin orbitals, has a min. value of 1.
             num_particles: number of particles, if it is a list,
                             the first number is alpha and the second number if beta.
+            reps: number of repetitions of basic module, has a min. value of 1.
             active_occupied: list of occupied orbitals to consider as active space.
             active_unoccupied: list of unoccupied orbitals to consider as active space.
             initial_state: An initial state object.
@@ -98,14 +97,13 @@ def __init__(self, num_qubits: int,
 
 
          Raises:
-             ValueError: Computed qubits do not match actual value
+             ValueError: Num particles list is not 2 entries
         """
-        validate_min('num_qubits', num_qubits, 1)
-        validate_min('depth', depth, 1)
         validate_min('num_orbitals', num_orbitals, 1)
         if isinstance(num_particles, list) and len(num_particles) != 2:
             raise ValueError('Num particles value {}. Number of values allowed is 2'.format(
                 num_particles))
+        validate_min('reps', reps, 1)
         validate_in_set('qubit_mapping', qubit_mapping,
                         {'jordan_wigner', 'parity', 'bravyi_kitaev'})
         validate_min('num_time_slices', num_time_slices, 1)
@@ -120,10 +118,7 @@ def __init__(self, num_qubits: int,
         self._num_qubits = num_orbitals if not two_qubit_reduction else num_orbitals - 2
         self._num_qubits = self._num_qubits if self._z2_symmetries.is_empty() \
             else self._num_qubits - len(self._z2_symmetries.sq_list)
-        if self._num_qubits != num_qubits:
-            raise ValueError('Computed num qubits {} does not match actual {}'
-                             .format(self._num_qubits, num_qubits))
-        self._depth = depth
+        self._reps = reps
         self._num_orbitals = num_orbitals
         if isinstance(num_particles, list):
             self._num_alpha = num_particles[0]
@@ -266,7 +261,7 @@ def _build_hopping_operators(self):
         self._single_excitations = s_e_list
         self._double_excitations = d_e_list
 
-        num_parameters = len(hopping_ops) * self._depth
+        num_parameters = len(hopping_ops) * self._reps
         return hopping_ops, num_parameters
 
     @staticmethod
@@ -339,14 +334,14 @@ def manage_hopping_operators(self):
         self._excitation_pool = self._hopping_ops.copy()
 
         # check depth parameter
-        if self._depth != 1:
-            logger.warning('The depth of the variational form was not 1 but %i which does not work \
+        if self._reps != 1:
+            logger.warning('The reps of the variational form was not 1 but %i which does not work \
                     in the adaptive VQE algorithm. Thus, it has been reset to 1.')
-            self._depth = 1
+            self._reps = 1
 
         # reset internal excitation list to be empty
         self._hopping_ops = []
-        self._num_parameters = len(self._hopping_ops) * self._depth
+        self._num_parameters = len(self._hopping_ops) * self._reps
         self._bounds = [(-np.pi, np.pi) for _ in range(self._num_parameters)]
 
     def push_hopping_operator(self, excitation):
@@ -357,15 +352,15 @@ def push_hopping_operator(self, excitation):
             excitation (WeightedPauliOperator): the new hopping operator to be added
         """
         self._hopping_ops.append(excitation)
-        self._num_parameters = len(self._hopping_ops) * self._depth
+        self._num_parameters = len(self._hopping_ops) * self._reps
         self._bounds = [(-np.pi, np.pi) for _ in range(self._num_parameters)]
 
     def pop_hopping_operator(self):
         """
         Pops the hopping operator that was added last.
         """
         self._hopping_ops.pop()
-        self._num_parameters = len(self._hopping_ops) * self._depth
+        self._num_parameters = len(self._hopping_ops) * self._reps
         self._bounds = [(-np.pi, np.pi) for _ in range(self._num_parameters)]
 
     def construct_circuit(self, parameters, q=None):
@@ -402,11 +397,11 @@ def construct_circuit(self, parameters, q=None):
         if not self.uccd_singlet:
             list_excitation_operators = [
                 (self._hopping_ops[index % num_excitations], parameters[index])
-                for index in range(self._depth * num_excitations)]
+                for index in range(self._reps * num_excitations)]
         else:
             list_excitation_operators = []
             counter = 0
-            for i in range(int(self._depth * self.num_groups)):
+            for i in range(int(self._reps * self.num_groups)):
                 for _ in range(len(self._double_excitations_grouped[i % self.num_groups])):
                     list_excitation_operators.append((self._hopping_ops[counter],
                                                       parameters[i]))

qiskit/chemistry/core/hamiltonian.py

@@ -300,8 +300,7 @@ def _process_z2symmetry_reduction(self, qubit_op, aux_ops):
                     aux_ops[i] = None  # Discard since no meaningful measurement can be done
 
             if self._z2symmetry_reduction == 'auto':
-                hf_state = HartreeFock(num_qubits=qubit_op.num_qubits,
-                                       num_orbitals=self._molecule_info[self.INFO_NUM_ORBITALS],
+                hf_state = HartreeFock(num_orbitals=self._molecule_info[self.INFO_NUM_ORBITALS],
                                        qubit_mapping=self._qubit_mapping,
                                        two_qubit_reduction=self._two_qubit_reduction,
                                        num_particles=self._molecule_info[self.INFO_NUM_PARTICLES])

test/chemistry/test_app_mgse.py

@@ -99,7 +99,7 @@ def test_mgse_callback_ipqe(self):
 
         def cb_create_solver(num_particles, num_orbitals,
                              qubit_mapping, two_qubit_reduction, z2_symmetries):
-            state_in = HartreeFock(2, num_orbitals, num_particles, qubit_mapping,
+            state_in = HartreeFock(num_orbitals, num_particles, qubit_mapping,
                                    two_qubit_reduction, z2_symmetries.sq_list)
             iqpe = IQPE(None, state_in, num_time_slices=1, num_iterations=6,
                         expansion_mode='suzuki', expansion_order=2,
@@ -117,10 +117,9 @@ def test_mgse_callback_vqe_uccsd(self):
 
         def cb_create_solver(num_particles, num_orbitals,
                              qubit_mapping, two_qubit_reduction, z2_symmetries):
-            initial_state = HartreeFock(2, num_orbitals, num_particles, qubit_mapping,
+            initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping,
                                         two_qubit_reduction, z2_symmetries.sq_list)
-            var_form = UCCSD(2, depth=1,
-                             num_orbitals=num_orbitals,
+            var_form = UCCSD(num_orbitals=num_orbitals,
                              num_particles=num_particles,
                              initial_state=initial_state,
                              qubit_mapping=qubit_mapping,
@@ -161,10 +160,9 @@ def test_mgse_callback_vqe_uccsd_z2(self):
 
         def cb_create_solver(num_particles, num_orbitals,
                              qubit_mapping, two_qubit_reduction, z2_symmetries):
-            initial_state = HartreeFock(6, num_orbitals, num_particles, qubit_mapping,
+            initial_state = HartreeFock(num_orbitals, num_particles, qubit_mapping,
                                         two_qubit_reduction, z2_symmetries.sq_list)
-            var_form = UCCSD(6, depth=1,
-                             num_orbitals=num_orbitals,
+            var_form = UCCSD(num_orbitals=num_orbitals,
                              num_particles=num_particles,
                              initial_state=initial_state,
                              qubit_mapping=qubit_mapping,

test/chemistry/test_core_hamiltonian_symmetries.py

@@ -194,10 +194,9 @@ def test_vqe_auto_symmetry_freeze_core(self):
         qubit_mapping = 'jordan_wigner'
         two_qubit_reduction = core.molecule_info[core.INFO_TWO_QUBIT_REDUCTION]
         z2_symmetries = core.molecule_info[core.INFO_Z2SYMMETRIES]
-        initial_state = HartreeFock(qubit_op.num_qubits, num_orbitals, num_particles,
+        initial_state = HartreeFock(num_orbitals, num_particles,
                                     qubit_mapping, two_qubit_reduction, z2_symmetries.sq_list)
-        var_form = UCCSD(qubit_op.num_qubits, depth=1,
-                         num_orbitals=num_orbitals,
+        var_form = UCCSD(num_orbitals=num_orbitals,
                          num_particles=num_particles,
                          initial_state=initial_state,
                          qubit_mapping=qubit_mapping,

test/chemistry/test_end2end_with_iqpe.py

@@ -68,8 +68,7 @@ def test_iqpe(self, distance):
 
         num_time_slices = 1
         num_iterations = 6
-        state_in = HartreeFock(qubit_op.num_qubits, num_orbitals,
-                               num_particles, qubit_mapping, two_qubit_reduction)
+        state_in = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction)
         iqpe = IQPE(qubit_op, state_in, num_time_slices, num_iterations,
                     expansion_mode='suzuki', expansion_order=2,
                     shallow_circuit_concat=True)

test/chemistry/test_end2end_with_qpe.py

@@ -81,8 +81,7 @@ def test_qpe(self, distance, use_circuit_library):
         num_time_slices = 1
         n_ancillae = 6
 
-        state_in = HartreeFock(qubit_op.num_qubits, num_orbitals,
-                               num_particles, qubit_mapping, two_qubit_reduction)
+        state_in = HartreeFock(num_orbitals, num_particles, qubit_mapping, two_qubit_reduction)
         if use_circuit_library:
             iqft = QFT(n_ancillae).inverse()
         else:

test/chemistry/test_initial_state_hartree_fock.py

@@ -31,49 +31,49 @@ class TestInitialStateHartreeFock(QiskitChemistryTestCase):
 
     def test_qubits_4_jw_h2(self):
         """ qubits 4 jw h2 test """
-        hrfo = HartreeFock(4, 4, [1, 1], 'jordan_wigner', False)
+        hrfo = HartreeFock(4, [1, 1], 'jordan_wigner', False)
         cct = hrfo.construct_circuit('vector')
         np.testing.assert_array_equal(cct, [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0,
                                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
 
     def test_qubits_4_py_h2(self):
         """ qubits 4 py h2 test """
-        hrfo = HartreeFock(4, 4, [1, 1], 'parity', False)
+        hrfo = HartreeFock(4, [1, 1], 'parity', False)
         cct = hrfo.construct_circuit('vector')
         np.testing.assert_array_equal(cct, [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
                                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
 
     def test_qubits_4_bk_h2(self):
         """ qubits 4 bk h2 test """
-        hrfo = HartreeFock(4, 4, [1, 1], 'bravyi_kitaev', False)
+        hrfo = HartreeFock(4, [1, 1], 'bravyi_kitaev', False)
         cct = hrfo.construct_circuit('vector')
         np.testing.assert_array_equal(cct, [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0,
                                             0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
 
     def test_qubits_2_py_h2(self):
         """ qubits 2 py h2 test """
-        hrfo = HartreeFock(2, 4, 2, 'parity', True)
+        hrfo = HartreeFock(4, 2, 'parity', True)
         cct = hrfo.construct_circuit('vector')
         np.testing.assert_array_equal(cct, [0.0, 1.0, 0.0, 0.0])
 
     def test_qubits_2_py_h2_cct(self):
         """ qubits 2 py h2 cct test """
-        hrfo = HartreeFock(2, 4, [1, 1], 'parity', True)
+        hrfo = HartreeFock(4, [1, 1], 'parity', True)
         cct = hrfo.construct_circuit('circuit')
         self.assertEqual(cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n'
                                      'u3(pi,0,pi) q[0];\n')
 
     def test_qubits_6_py_lih_cct(self):
         """ qubits 6 py lih cct test """
-        hrfo = HartreeFock(6, 10, [1, 1], 'parity', True, [1, 2])
+        hrfo = HartreeFock(10, [1, 1], 'parity', True, [1, 2])
         cct = hrfo.construct_circuit('circuit')
         self.assertEqual(cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[6];\n'
                                      'u3(pi,0,pi) q[0];\n'
                                      'u3(pi,0,pi) q[1];\n')
 
     def test_qubits_10_bk_lih_bitstr(self):
         """ qubits 10 bk lih bitstr test """
-        hrfo = HartreeFock(10, 10, [1, 1], 'bravyi_kitaev', False)
+        hrfo = HartreeFock(10, [1, 1], 'bravyi_kitaev', False)
         bitstr = hrfo.bitstr
         np.testing.assert_array_equal(bitstr,
                                       [False, False, False, False, True,
@@ -104,7 +104,7 @@ def test_hf_value(self, mapping):
 
         qubit_op, _ = core.run(qmolecule)
         qubit_op = op_converter.to_matrix_operator(qubit_op)
-        hrfo = HartreeFock(qubit_op.num_qubits, core.molecule_info['num_orbitals'],
+        hrfo = HartreeFock(core.molecule_info['num_orbitals'],
                            core.molecule_info['num_particles'], mapping.value, False)
         qc = hrfo.construct_circuit('vector')
         hf_energy = qubit_op.evaluate_with_statevector(qc)[0].real + core._nuclear_repulsion_energy

test/chemistry/test_qeom_vqe.py

@@ -71,10 +71,10 @@ def test_h2_two_qubits_statevector(self):
         num_orbitals = core.molecule_info['num_orbitals']
         num_particles = core.molecule_info['num_particles']
 
-        initial_state = HartreeFock(qubit_op.num_qubits, num_orbitals=num_orbitals,
+        initial_state = HartreeFock(num_orbitals=num_orbitals,
                                     num_particles=num_particles, qubit_mapping=qubit_mapping,
                                     two_qubit_reduction=two_qubit_reduction)
-        var_form = UCCSD(num_qubits=qubit_op.num_qubits, depth=1, num_orbitals=num_orbitals,
+        var_form = UCCSD(num_orbitals=num_orbitals,
                          num_particles=num_particles,
                          initial_state=initial_state,
                          qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction)
@@ -108,11 +108,11 @@ def test_h2_one_qubit_statevector(self):
         # know the sector
         tapered_op = z2_symmetries.taper(qubit_op)[1]
 
-        initial_state = HartreeFock(tapered_op.num_qubits, num_orbitals=num_orbitals,
+        initial_state = HartreeFock(num_orbitals=num_orbitals,
                                     num_particles=num_particles, qubit_mapping=qubit_mapping,
                                     two_qubit_reduction=two_qubit_reduction,
                                     sq_list=tapered_op.z2_symmetries.sq_list)
-        var_form = UCCSD(num_qubits=tapered_op.num_qubits, depth=1, num_orbitals=num_orbitals,
+        var_form = UCCSD(num_orbitals=num_orbitals,
                          num_particles=num_particles, initial_state=initial_state,
                          qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction,
                          z2_symmetries=tapered_op.z2_symmetries)

test/chemistry/test_readme_sample.py

@@ -82,7 +82,7 @@ def print(*args):
 
         # setup the initial state for the variational form
         from qiskit.chemistry.components.initial_states import HartreeFock
-        init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles)
+        init_state = HartreeFock(num_spin_orbitals, num_particles)
 
         # setup the variational form for VQE
         from qiskit.circuit.library import TwoLocal

test/chemistry/test_swaprz.py

@@ -54,8 +54,7 @@ def test_swaprz(self, mode):
         qubit_op, _ = operator.run(qmolecule)
 
         optimizer = SLSQP(maxiter=100)
-        initial_state = HartreeFock(qubit_op.num_qubits,
-                                    operator.molecule_info['num_orbitals'],
+        initial_state = HartreeFock(operator.molecule_info['num_orbitals'],
                                     operator.molecule_info['num_particles'],
                                     qubit_mapping=operator._qubit_mapping,
                                     two_qubit_reduction=operator._two_qubit_reduction)