Move class documentation to class docstrings (#2525)

* move class init docstrings to class docstring

* remove redundant line

docs/source/apidoc.md

@@ -133,7 +133,6 @@ See Ref. {cite}`Czarnik_2021_Quantum` for more details on these methods.
  :members:
 ```
 
-
 #### Learning-based PEC
 
 ```{eval-rst}
@@ -383,6 +382,7 @@ See Ref. {cite}`Czarnik_2021_Quantum` for more details on these methods.
 .. automodule:: mitiq.interface.mitiq_pyquil.conversions
  :members:
 ```
+
 #### Qibo Conversions
 
 ```{eval-rst}

mitiq/executor/executor.py

@@ -57,22 +57,20 @@
 class Executor:
  """Tool for efficiently scheduling/executing quantum programs and storing
  the results.
+
+ Args:
+ executor: A function which inputs a program and outputs a
+ ``mitiq.QuantumResult``, or inputs a sequence of programs and
+ outputs a sequence of ``mitiq.QuantumResult`` s.
+ max_batch_size: Maximum number of programs that can be sent in a
+ single batch (if the executor is batched).
  """
 
  def __init__(
  self,
  executor: Callable[[Union[QPROGRAM, Sequence[QPROGRAM]]], Any],
  max_batch_size: int = 75,
  ) -> None:
- """Initializes an Executor.
-
- Args:
- executor: A function which inputs a program and outputs a
- ``mitiq.QuantumResult``, or inputs a sequence of programs and
- outputs a sequence of ``mitiq.QuantumResult`` s.
- max_batch_size: Maximum number of programs that can be sent in a
- single batch (if the executor is batched).
- """
  self._executor = executor
 
  executor_annotation = inspect.getfullargspec(executor).annotations

mitiq/interface/mitiq_qiskit/transpiler.py

@@ -37,14 +37,12 @@ class ApplyMitiqLayout(TransformationPass): # type: ignore
  qubits by applying the Layout given in `property_set`.
  Requires either of passes to set/select Layout, e.g. `SetLayout`,
  `TrivialLayout`. Assumes the Layout has full physical qubits.
+
+ Args:
+ new_qregs: The new quantum registers for the circuit.
  """
 
  def __init__(self, new_qregs: List[QuantumRegister]) -> None:
- """ApplyMitiqLayout constructor.
-
- Args:
- new_qregs: The new quantum registers for the circuit.
- """
  super().__init__()
  self._new_qregs = new_qregs
 
@@ -104,7 +102,6 @@ class ClearLayout(TransformationPass): # type: ignore
  """Clears the layout of the DAGCircuit"""
 
  def __init__(self) -> None:
- """ClearLayout"""
  super().__init__()
 
  def run(self, dag: DAGCircuit) -> None:

mitiq/observable/observable.py

@@ -20,15 +20,11 @@ class Observable:
  """A quantum observable typically used to compute its mitigated expectation
  value.
 
+ Args:
+ paulis: PauliStrings used to define the observable.
  """
 
  def __init__(self, *paulis: PauliString) -> None:
- """Initializes an `Observable` with :class:`.PauliString` objects.
-
- Args:
- paulis: PauliStrings used to define the observable.
-
- """
  self._paulis = _combine_duplicate_pauli_strings(paulis)
  self._groups: List[PauliStringCollection]
  self._ngroups: int

mitiq/observable/pauli.py

@@ -18,9 +18,21 @@
 
 
 class PauliString:
- """A `PauliString` is a (tensor) product of single-qubit Pauli gates I, X,
- Y, and Z, with a leading (real or complex) coefficient. `PauliString`s can
- be measured in any `mitiq.QPROGRAM`.
+ """A ``PauliString`` is a (tensor) product of single-qubit Pauli gates
+ :math:`I, X, Y`, and :math:`Z`, with a leading (real or complex)
+ coefficient. ``PauliString`` objects can be measured in any
+ ``mitiq.QPROGRAM``.
+
+ Args:
+ spec: String specifier of the PauliString. Should only contain
+ characters 'I', 'X', 'Y', and 'Z'.
+ coeff: Coefficient of the PauliString.
+ support: Qubits the ``spec`` acts on, if provided.
+
+ Examples:
+ >>> PauliString(spec="IXY") # X(1)*Y(2)
+ >>> PauliString(spec="ZZ", coeff=-0.5) # -0.5*Z(0)*Z(1)
+ >>> PauliString(spec="XZ", support=(10, 17)) # X(10)*Z(17)
  """
 
  _string_to_gate_map = {"I": cirq.I, "X": cirq.X, "Y": cirq.Y, "Z": cirq.Z}
@@ -31,19 +43,6 @@ def __init__(
  coeff: complex = 1.0,
  support: Optional[Sequence[int]] = None,
  ) -> None:
- """Initialize a PauliString.
-
- Args:
- spec: String specifier of the PauliString. Should only contain
- characters 'I', 'X', 'Y', and 'Z'.
- coeff: Coefficient of the PauliString.
- support: Qubits the ``spec`` acts on, if provided.
-
- Examples:
- >>> PauliString(spec="IXY") # X(1)*Y(2)
- >>> PauliString(spec="ZZ", coeff=-0.5) # -0.5*Z(0)*Z(1)
- >>> PauliString(spec="XZ", support=(10, 17)) # X(10)*Z(17)
- """
  if not set(spec).issubset(set(self._string_to_gate_map.keys())):
  raise ValueError(
  f"One or more invalid characters in spec {spec}. Valid "
@@ -181,34 +180,32 @@ def __repr__(self) -> str:
 class PauliStringCollection:
  """A collection of PauliStrings that qubit-wise commute and so can be
  measured with a single circuit.
+
+ Args:
+ paulis: PauliStrings to add to the collection.
+ check_precondition: If True, raises an error if some of the
+ ``PauliString`` objects do not qubit-wise commute.
+
+ Example:
+ >>> pcol = PauliStringCollection(
+ >>> PauliString(spec="X"),
+ >>> PauliString(spec="IZ", coeff=-2.2)
+ >>> )
+ >>> print(pcol) # X(0) + (-2.2+0j)*Z(1)
+ >>> print(pcol.support()) # {0, 1}
+ >>>
+ >>> # XZ qubit-wise commutes with X(0) and Z(1), so can be added.
+ >>> print(pcol.can_add(PauliString(spec="XZ"))) # True.
+ >>> pcol.add(PauliString(spec="XZ"))
+ >>> print(pcol) # X(0) + (-2.2+0j)*Z(1) + X(0)*Z(1)
+ >>>
+ >>> # Z(0) doesn't qubit-wise commute with X(0), so can't be added.
+ >>> print(pcol.can_add(PauliString(spec="Z"))) # False.
  """
 
  def __init__(
  self, *paulis: PauliString, check_precondition: bool = True
  ) -> None:
- """Initializes a `PauliStringCollection`.
-
- Args:
- paulis: PauliStrings to add to the collection.
- check_precondition: If True, raises an error if some of the
- `PauliString`s do not qubit-wise commute.
-
- Example:
- >>> pcol = PauliStringCollection(
- >>> PauliString(spec="X"),
- >>> PauliString(spec="IZ", coeff=-2.2)
- >>> )
- >>> print(pcol) # X(0) + (-2.2+0j)*Z(1)
- >>> print(pcol.support()) # {0, 1}
- >>>
- >>> # XZ qubit-wise commutes with X(0) and Z(1), so can be added.
- >>> print(pcol.can_add(PauliString(spec="XZ"))) # True.
- >>> pcol.add(PauliString(spec="XZ"))
- >>> print(pcol) # X(0) + (-2.2+0j)*Z(1) + X(0)*Z(1)
- >>>
- >>> # Z(0) doesn't qubit-wise commute with X(0), so can't be added.
- >>> print(pcol.can_add(PauliString(spec="Z"))) # False.
- """
  self._paulis_by_weight: Dict[int, TCounter[PauliString]] = dict()
  self.add(*paulis, check_precondition=check_precondition)
 

mitiq/pec/types/types.py

@@ -24,27 +24,25 @@
 
 class NoisyOperation:
  """An operation (or sequence of operations) which a noisy quantum computer
- can actually implement.p
+ can actually implement.
+
+ Args:
+ circuit: A short circuit which, when executed on a given noisy
+ quantum computer, generates a noisy channel. It typically
+ contains a single-gate or a short sequence of gates.
+ channel_matrix: Superoperator representation of the noisy channel
+ which is generated when executing the input ``circuit`` on the
+ noisy quantum computer.
+
+ Raises:
+ TypeError: If ``ideal`` is not a ``QPROGRAM``.
  """
 
  def __init__(
  self,
  circuit: QPROGRAM,
  channel_matrix: Optional[npt.NDArray[np.complex64]] = None,
  ) -> None:
- """Initializes a NoisyOperation.
-
- Args:
- circuit: A short circuit which, when executed on a given noisy
- quantum computer, generates a noisy channel. It typically
- contains a single-gate or a short sequence of gates.
- channel_matrix: Superoperator representation of the noisy channel
- which is generated when executing the input ``circuit`` on the
- noisy quantum computer.
-
- Raises:
- TypeError: If ``ideal`` is not a ``QPROGRAM``.
- """
  self._native_circuit = deepcopy(circuit)
 
  try:
@@ -135,6 +133,20 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
 class OperationRepresentation:
  """A decomposition (basis expansion) of an operation or sequence of
  operations in a basis of noisy, implementable operations.
+
+ Args:
+ ideal: The ideal operation desired to be implemented.
+ basis_expansion: Representation of the ideal operation in a basis
+ of ``NoisyOperation`` objects.
+ is_qubit_dependent: If True, the representation
+ corresponds to the operation on the specific qubits defined in
+ ``ideal``. If False, the representation is valid for the same
+ gate even if acting on different qubits from those specified in
+ ``ideal``.
+
+ Raises:
+ TypeError: If all keys of ``basis_expansion`` are not instances of
+ ``NoisyOperation`` objects.
  """
 
  def __init__(
@@ -144,22 +156,6 @@ def __init__(
  coeffs: List[float],
  is_qubit_dependent: bool = True,
  ) -> None:
- """Initializes an OperationRepresentation.
-
- Args:
- ideal: The ideal operation desired to be implemented.
- basis_expansion: Representation of the ideal operation in a basis
- of `NoisyOperation`s.
- is_qubit_dependent: If True, the representation
- corresponds to the operation on the specific qubits defined in
- `ideal`. If False, the representation is valid for the same
- gate even if acting on different qubits from those specified in
- `ideal`.
-
- Raises:
- TypeError: If all keys of `basis_expansion` are not instances of
- `NoisyOperation`s.
- """
  if not all(isinstance(o, NoisyOperation) for o in noisy_operations):
  raise TypeError(
  "All elements of `noisy_operations` must be "

mitiq/zne/inference.py

@@ -420,28 +420,26 @@ class BatchedFactory(Factory, ABC):
 
  Specific (non-adaptive) extrapolation algorithms are derived from this
  class by defining the `reduce` method.
+
+ Args:
+ scale_factors: Sequence of noise scale factors at which expectation
+ values should be measured.
+ shot_list: Optional sequence of integers corresponding to the
+ number of samples taken for each expectation value. If this
+ argument is explicitly passed to the factory, it must have the
+ same length of scale_factors and the executor function must
+ accept "shots" as a valid keyword argument.
+
+ Raises:
+ ValueError: If the number of scale factors is less than 2.
+ TypeError: If shot_list is provided and has any non-integer values.
  """
 
  def __init__(
  self,
  scale_factors: Sequence[float],
  shot_list: Optional[List[int]] = None,
  ) -> None:
- """Constructs a BatchedFactory.
-
- Args:
- scale_factors: Sequence of noise scale factors at which expectation
- values should be measured.
- shot_list: Optional sequence of integers corresponding to the
- number of samples taken for each expectation value. If this
- argument is explicitly passed to the factory, it must have the
- same length of scale_factors and the executor function must
- accept "shots" as a valid keyword argument.
-
- Raises:
- ValueError: If the number of scale factors is less than 2.
- TypeError: If shot_list is provided and has any non-integer values.
- """
  if len(scale_factors) < 2:
  raise ValueError("At least 2 scale factors are necessary.")
 
@@ -805,7 +803,6 @@ def __init__(
  order: int,
  shot_list: Optional[List[int]] = None,
  ) -> None:
- """Instantiates a new object of this Factory class."""
  if order > len(scale_factors) - 1:
  raise ValueError(
  "The extrapolation order cannot exceed len(scale_factors) - 1."
@@ -1127,7 +1124,6 @@ def __init__(
  avoid_log: bool = False,
  shot_list: Optional[List[int]] = None,
  ) -> None:
- """Instantiate an new object of this Factory class."""
  super(ExpFactory, self).__init__(scale_factors, shot_list)
  if not (asymptote is None or isinstance(asymptote, float)):
  raise ValueError(
@@ -1247,7 +1243,6 @@ def __init__(
  avoid_log: bool = False,
  shot_list: Optional[List[int]] = None,
  ) -> None:
- """Instantiates a new object of this Factory class."""
  super(PolyExpFactory, self).__init__(scale_factors, shot_list)
  if not (asymptote is None or isinstance(asymptote, float)):
  raise ValueError(
@@ -1519,7 +1514,6 @@ def __init__(
  avoid_log: bool = False,
  max_scale_factor: float = 6.0,
  ) -> None:
- """Instantiate a new object of this Factory class."""
  super(AdaExpFactory, self).__init__()
  if not (asymptote is None or isinstance(asymptote, float)):
  raise ValueError(