Regenerate Qiskit 1.1.0rc1 (Qiskit#1338)

This brings in the revamp of the header hierarchy + adding a missing
module to the index page.

docs/api/qiskit/dev/assembler.mdx

@@ -18,7 +18,7 @@ python_api_name: qiskit.assembler
 
 `qiskit.assembler`
 
-## Circuit Assembler
+## Functions
 
 ### assemble\_circuits
 
@@ -61,8 +61,6 @@ python_api_name: qiskit.assembler
   ```
 </Function>
 
-## Schedule Assembler
-
 ### assemble\_schedules
 
 <Function id="qiskit.assembler.assemble_schedules" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/assembler/assemble_schedules.py#L27-L103" signature="qiskit.assembler.assemble_schedules(schedules, qobj_id, qobj_header, run_config)">
@@ -125,8 +123,6 @@ python_api_name: qiskit.assembler
   ```
 </Function>
 
-## Disassembler
-
 ### disassemble
 
 <Function id="qiskit.assembler.disassemble" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/assembler/disassemble.py#L40-L83" signature="qiskit.assembler.disassemble(qobj)">
@@ -172,7 +168,7 @@ python_api_name: qiskit.assembler
   ```
 </Function>
 
-## RunConfig
+## Classes
 
 |                                                                                                                |                              |
 | -------------------------------------------------------------------------------------------------------------- | ---------------------------- |

docs/api/qiskit/dev/circuit.mdx

@@ -147,11 +147,7 @@ When mapping to hardware, virtual qubits must be assigned to *hardware qubits*.
 
 <span id="circuit-module-api" />
 
-## API overview of
-
-<span id="module-qiskit.circuit" />
-
-`qiskit.circuit`
+## API overview of qiskit.circuit
 
 All objects here are described in more detail, and in their greater context in the following sections. This section provides an overview of the API elements documented here.
 

docs/api/qiskit/dev/circuit_classical.mdx

@@ -943,15 +943,15 @@ Note that [`Uint`](#qiskit.circuit.classical.types.Uint "qiskit.circuit.classica
 
 ### Working with types
 
-There are some functions on these types exposed here as well. These are mostly expected to be used only in manipulations of the expression tree; users who are building expressions using the [user-facing construction interface](#circuit-classical-expressions-expr-construction) should not need to use these.
+There are some additional functions on these types documented in the subsequent sections. These are mostly expected to be used only in manipulations of the expression tree; users who are building expressions using the [user-facing construction interface](#circuit-classical-expressions-expr-construction) should not need to use these.
 
-#### Partial ordering of types
+### Partial ordering of types
 
 The type system is equipped with a partial ordering, where $a < b$ is interpreted as “$a$ is a strict subtype of $b$”. Note that the partial ordering is a subset of the directed graph that describes the allowed explicit casting operations between types. The partial ordering defines when one type may be lossless directly interpreted as another.
 
 The low-level interface to querying the subtyping relationship is the [`order()`](#qiskit.circuit.classical.types.order "qiskit.circuit.classical.types.order") function.
 
-##### order
+#### order
 
 <Function id="qiskit.circuit.classical.types.order" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classical/types/ordering.py#L76-L93" signature="qiskit.circuit.classical.types.order(left, right, /)">
   Get the ordering relationship between the two types as an enumeration value.
@@ -980,7 +980,7 @@ The low-level interface to querying the subtyping relationship is the [`order()`
 
 The return value is an enumeration [`Ordering`](#qiskit.circuit.classical.types.Ordering "qiskit.circuit.classical.types.Ordering") that describes what, if any, subtyping relationship exists between the two types.
 
-##### Ordering
+#### Ordering
 
 <Class id="qiskit.circuit.classical.types.Ordering" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classical/types/ordering.py#L38-L55" signature="qiskit.circuit.classical.types.Ordering(value)">
   Enumeration listing the possible relations between two types. Types only have a partial ordering, so it’s possible for two types to have no sub-typing relationship.
@@ -990,7 +990,7 @@ The return value is an enumeration [`Ordering`](#qiskit.circuit.classical.types.
 
 Some helper methods are then defined in terms of this low-level [`order()`](#qiskit.circuit.classical.types.order "qiskit.circuit.classical.types.order") primitive:
 
-##### is\_subtype
+#### is\_subtype
 
 <Function id="qiskit.circuit.classical.types.is_subtype" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classical/types/ordering.py#L96-L116" signature="qiskit.circuit.classical.types.is_subtype(left, right, /, strict=False)">
   Does the relation $\text{left} \le \text{right}$ hold? If there is no ordering relation between the two types, then this returns `False`. If `strict`, then the equality is also forbidden.
@@ -1019,7 +1019,7 @@ Some helper methods are then defined in terms of this low-level [`order()`](#qis
   [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")
 </Function>
 
-##### is\_supertype
+#### is\_supertype
 
 <Function id="qiskit.circuit.classical.types.is_supertype" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classical/types/ordering.py#L119-L139" signature="qiskit.circuit.classical.types.is_supertype(left, right, /, strict=False)">
   Does the relation $\text{left} \ge \text{right}$ hold? If there is no ordering relation between the two types, then this returns `False`. If `strict`, then the equality is also forbidden.
@@ -1048,7 +1048,7 @@ Some helper methods are then defined in terms of this low-level [`order()`](#qis
   [bool](https://docs.python.org/3/library/functions.html#bool "(in Python v3.12)")
 </Function>
 
-##### greater
+#### greater
 
 <Function id="qiskit.circuit.classical.types.greater" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classical/types/ordering.py#L142-L165" signature="qiskit.circuit.classical.types.greater(left, right, /)">
   Get the greater of the two types, assuming that there is an ordering relation between them. Technically, this is a slightly restricted version of the concept of the ‘meet’ of the two types in that the return value must be one of the inputs. In practice in the type system there is no concept of a ‘sum’ type, so the ‘meet’ exists if and only if there is an ordering between the two types, and is equal to the greater of the two types.
@@ -1076,11 +1076,11 @@ Some helper methods are then defined in terms of this low-level [`order()`](#qis
   ```
 </Function>
 
-#### Casting between types
+### Casting between types
 
 It is common to need to cast values of one type to another type. The casting rules for this are embedded into the [`types`](https://docs.python.org/3/library/types.html#module-types "(in Python v3.12)") module. You can query the casting kinds using [`cast_kind()`](#qiskit.circuit.classical.types.cast_kind "qiskit.circuit.classical.types.cast_kind"):
 
-##### cast\_kind
+#### cast\_kind
 
 <Function id="qiskit.circuit.classical.types.cast_kind" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classical/types/ordering.py#L203-L222" signature="qiskit.circuit.classical.types.cast_kind(from_, to_, /)">
   Determine the sort of cast that is required to move from the left type to the right type.
@@ -1106,7 +1106,7 @@ It is common to need to cast values of one type to another type. The casting rul
 
 The return values from this function are an enumeration explaining the types of cast that are allowed from the left type to the right type.
 
-##### CastKind
+#### CastKind
 
 <Class id="qiskit.circuit.classical.types.CastKind" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classical/types/ordering.py#L168-L184" signature="qiskit.circuit.classical.types.CastKind(value)">
   A return value indicating the type of cast that can occur from one type to another.

docs/api/qiskit/dev/circuit_library.mdx

@@ -122,18 +122,14 @@ print(gate.control(1).to_matrix())  # CX (controlled X) gate
 
 Directives are operations to the quantum stack that are meant to be interpreted by the backend or the transpiler. In general, the transpiler or backend might optionally ignore them if there is no implementation for them.
 
-|                                  |                                                                                                                                                          |
-| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Barrier`(num\_qubits\[, label]) | A directive for circuit compilation to separate pieces of a circuit so that any optimizations or re-writes are constrained to only act between barriers. |
+*   [`qiskit.circuit.Barrier`](circuit#qiskit.circuit.Barrier "qiskit.circuit.Barrier")
 
 ## Standard Operations
 
 Operations are non-reversible changes in the quantum state of the circuit.
 
-|                                        |                                                           |
-| -------------------------------------- | --------------------------------------------------------- |
-| `Measure`(\*args\[, \_force\_mutable]) | Quantum measurement in the computational basis.           |
-| `Reset`(\*args\[, \_force\_mutable])   | Incoherently reset a qubit to the $\lvert0\rangle$ state. |
+*   [`qiskit.circuit.Measure`](circuit#qiskit.circuit.Measure "qiskit.circuit.Measure")
+*   [`qiskit.circuit.Reset`](circuit#qiskit.circuit.Reset "qiskit.circuit.Reset")
 
 ## Generalized Gates
 

docs/api/qiskit/dev/classicalfunction.mdx

@@ -67,6 +67,24 @@ The type `Int1` means the classical function will only operate at bit level.
 
 Decorator for a classical function that returns a ClassicalFunction object.
 
+#### classical\_function
+
+<Function id="qiskit.circuit.classicalfunction.classical_function" github="https://github.com/Qiskit/qiskit/tree/stable/1.1/qiskit/circuit/classicalfunction/__init__.py#L116-L132" signature="qiskit.circuit.classicalfunction.classical_function(func)">
+  Parses and type checks the callable `func` to compile it into an `ClassicalFunction` that can be synthesized into a `QuantumCircuit`.
+
+  **Parameters**
+
+  **func** (*callable*) – A callable (with type hints) to compile into an `ClassicalFunction`.
+
+  **Returns**
+
+  An object that can synthesis into a QuantumCircuit (via `synth()` method).
+
+  **Return type**
+
+  [ClassicalFunction](qiskit.circuit.classicalfunction.ClassicalFunction "qiskit.circuit.classicalfunction.ClassicalFunction")
+</Function>
+
 ### ClassicalFunction
 
 |                                                                                                                                                                 |                                                       |