code: def dipole_moment(mol, cutoff=1.0e-16, core=None, active=None):
      r"""Return a function that computes the qubit dipole moment observable.
  
      The dipole operator in the second-quantized form is
  
      .. math::
  
          \hat{D} = -\sum_{pq} d_{pq} [\hat{c}_{p\uparrow}^\dagger \hat{c}_{q\uparrow} +
          \hat{c}_{p\downarrow}^\dagger \hat{c}_{q\downarrow}] -
          \hat{D}_\mathrm{c} + \hat{D}_\mathrm{n},
  
      where the matrix elements :math:`d_{pq}` are given by the integral of the position operator
      :math:`\hat{{\bf r}}` over molecular orbitals :math:`\phi`
  
      .. math::
  
          d_{pq} = \int \phi_p^*(r) \hat{{\bf r}} \phi_q(r) dr,
  
      and :math:`\hat{c}^{\dagger}` and :math:`\hat{c}` are the creation and annihilation operators,
      respectively. The contribution of the core orbitals and nuclei are denoted by
      :math:`\hat{D}_\mathrm{c}` and :math:`\hat{D}_\mathrm{n}`, respectively, which are computed as
  
      .. math::
  
          \hat{D}_\mathrm{c} = 2 \sum_{i=1}^{N_\mathrm{core}} d_{ii},
  
      and
  
      .. math::
  
          \hat{D}_\mathrm{n} = \sum_{i=1}^{N_\mathrm{atoms}} Z_i {\bf R}_i,
  
      where :math:`Z_i` and :math:`{\bf R}_i` denote, respectively, the atomic number and the
      nuclear coordinates of the :math:`i`-th atom of the molecule.
  
      The fermonic dipole operator is then transformed to the qubit basis which gives
  
      .. math::
  
          \hat{D} = \sum_{j} c_j P_j,
  
      where :math:`c_j` is a numerical coefficient and :math:`P_j` is a ternsor product of
      single-qubit Pauli operators :math:`X, Y, Z, I`.
  
      Args:
          mol (~qchem.molecule.Molecule): the molecule object
          cutoff (float): cutoff value for discarding the negligible dipole moment integrals
          core (list[int]): indices of the core orbitals
          active (list[int]): indices of the active orbitals
  
      Returns:
          function: function that computes the qubit dipole moment observable
  
      **Example**
  
      >>> symbols  = ['H', 'H']
      >>> geometry = np.array([[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]], requires_grad = False)
      >>> alpha = np.array([[3.42525091, 0.62391373, 0.1688554],
      >>>                   [3.42525091, 0.62391373, 0.1688554]], requires_grad=True)
      >>> mol = qml.qchem.Molecule(symbols, geometry, alpha=alpha)
      >>> args = [alpha]
      >>> dipole_moment(mol)(*args)[2].ops
      [Identity(wires=[0]),
       PauliZ(wires=[0]),
       PauliY(wires=[0]) @ PauliZ(wires=[1]) @ PauliY(wires=[2]),
       PauliX(wires=[0]) @ PauliZ(wires=[1]) @ PauliX(wires=[2]),
       PauliZ(wires=[1]),
       PauliY(wires=[1]) @ PauliZ(wires=[2]) @ PauliY(wires=[3]),
       PauliX(wires=[1]) @ PauliZ(wires=[2]) @ PauliX(wires=[3]),
       PauliZ(wires=[2]),
       PauliZ(wires=[3])]
      """
  
      def _dipole(*args):
          r"""Compute the qubit dipole moment observable.
  
          Args:
              *args (array[array[float]]): initial values of the differentiable parameters
  
          Returns:
              (list[Hamiltonian]): x, y and z components of the dipole moment observable
          """
          d = []
          d_ferm = fermionic_dipole(mol, cutoff, core, active)(*args)
          for i in d_ferm:
              d.append(qubit_observable(i, cutoff=cutoff))
  
          return d
  
      return _dipole
  
file_path: pennylane/pennylane/qchem/dipole.py
imports: import pennylane
  from pennylane.fermi import FermiSentence, FermiWord
  from .basis_data import atomic_numbers
  from .hartree_fock import scf
  from .matrices import moment_matrix
  from .observable_hf import fermionic_observable, qubit_observable
label_desc: Use image node_id 3 for calling a global function with example usage: dipole_moment(mol, cutoff, core, active) and returns: _dipole, d