diff --git a/crates/accelerate/src/commutation_checker.rs b/crates/accelerate/src/commutation_checker.rs
index b6e61fcf3f6d..f6c50ca89824 100644
--- a/crates/accelerate/src/commutation_checker.rs
+++ b/crates/accelerate/src/commutation_checker.rs
@@ -377,7 +377,7 @@ impl CommutationChecker {
             first_qargs
                 .iter()
                 .enumerate()
-                .map(|(i, q)| (q, Qubit(i as u32))),
+                .map(|(i, q)| (q, Qubit::new(i))),
         );
         let mut num_qubits = first_qargs.len() as u32;
         for q in second_qargs {
@@ -574,7 +574,7 @@ fn get_relative_placement(
 ) -> SmallVec<[Option<Qubit>; 2]> {
     let mut qubits_g2: HashMap<&Qubit, Qubit> = HashMap::with_capacity(second_qargs.len());
     second_qargs.iter().enumerate().for_each(|(i_g1, q_g1)| {
-        qubits_g2.insert_unique_unchecked(q_g1, Qubit(i_g1 as u32));
+        qubits_g2.insert_unique_unchecked(q_g1, Qubit::new(i_g1));
     });
 
     first_qargs
diff --git a/crates/accelerate/src/elide_permutations.rs b/crates/accelerate/src/elide_permutations.rs
index 6860b782669e..81dc0ba24027 100644
--- a/crates/accelerate/src/elide_permutations.rs
+++ b/crates/accelerate/src/elide_permutations.rs
@@ -79,9 +79,7 @@ fn run(py: Python, dag: &mut DAGCircuit) -> PyResult<Option<(DAGCircuit, Vec<usi
                     let cargs = dag.get_cargs(inst.clbits);
                     let mapped_qargs: Vec<Qubit> = qargs
                         .iter()
-                        .map(|q| q.index())
-                        .map(|q| mapping[q])
-                        .map(|q| Qubit(q.try_into().unwrap()))
+                        .map(|q| Qubit::new(mapping[q.index()]))
                         .collect();
 
                     new_dag.apply_operation_back(
@@ -92,7 +90,7 @@ fn run(py: Python, dag: &mut DAGCircuit) -> PyResult<Option<(DAGCircuit, Vec<usi
                         inst.params.as_deref().cloned(),
                         inst.extra_attrs.clone(),
                         #[cfg(feature = "cache_pygates")]
-                        None,
+                        inst.py_op.get().map(|x| x.clone_ref(py)),
                     )?;
                 }
             }
diff --git a/crates/accelerate/src/gates_in_basis.rs b/crates/accelerate/src/gates_in_basis.rs
index 69f656c724c9..81dc5cd0284a 100644
--- a/crates/accelerate/src/gates_in_basis.rs
+++ b/crates/accelerate/src/gates_in_basis.rs
@@ -42,7 +42,7 @@ fn any_gate_missing_from_target(dag: &DAGCircuit, target: &Target) -> PyResult<b
 
         if gate.op.control_flow() {
             for block in gate.op.blocks() {
-                let block_qubits = (0..block.num_qubits()).map(|i| Qubit(i.try_into().unwrap()));
+                let block_qubits = (0..block.num_qubits()).map(Qubit::new);
                 let inner_wire_map = qargs
                     .iter()
                     .zip(block_qubits)
@@ -74,13 +74,9 @@ fn any_gate_missing_from_target(dag: &DAGCircuit, target: &Target) -> PyResult<b
     }
 
     // In the outer DAG, virtual and physical bits are the same thing.
-    let wire_map: HashMap<Qubit, PhysicalQubit> =
-        HashMap::from_iter((0..dag.num_qubits()).map(|i| {
-            (
-                Qubit(i.try_into().unwrap()),
-                PhysicalQubit::new(i.try_into().unwrap()),
-            )
-        }));
+    let wire_map: HashMap<Qubit, PhysicalQubit> = HashMap::from_iter(
+        (0..dag.num_qubits()).map(|i| (Qubit::new(i), PhysicalQubit::new(i.try_into().unwrap()))),
+    );
 
     // Process the DAG.
     for gate in dag.op_nodes(true) {
diff --git a/crates/accelerate/src/synthesis/clifford/bm_synthesis.rs b/crates/accelerate/src/synthesis/clifford/bm_synthesis.rs
index d54afe64f68c..cf0a0200fc00 100644
--- a/crates/accelerate/src/synthesis/clifford/bm_synthesis.rs
+++ b/crates/accelerate/src/synthesis/clifford/bm_synthesis.rs
@@ -173,52 +173,52 @@ fn reduce_cost(
                         gates.push((
                             StandardGate::SGate,
                             smallvec![],
-                            smallvec![Qubit(qubit0 as u32)],
+                            smallvec![Qubit::new(qubit0)],
                         ));
                         gates.push((
                             StandardGate::HGate,
                             smallvec![],
-                            smallvec![Qubit(qubit0 as u32)],
+                            smallvec![Qubit::new(qubit0)],
                         ));
                     } else if n0 == 2 {
                         gates.push((
                             StandardGate::HGate,
                             smallvec![],
-                            smallvec![Qubit(qubit0 as u32)],
+                            smallvec![Qubit::new(qubit0)],
                         ));
                         gates.push((
                             StandardGate::SdgGate,
                             smallvec![],
-                            smallvec![Qubit(qubit0 as u32)],
+                            smallvec![Qubit::new(qubit0)],
                         ));
                     }
                     if n1 == 1 {
                         gates.push((
                             StandardGate::SGate,
                             smallvec![],
-                            smallvec![Qubit(qubit1 as u32)],
+                            smallvec![Qubit::new(qubit1)],
                         ));
                         gates.push((
                             StandardGate::HGate,
                             smallvec![],
-                            smallvec![Qubit(qubit1 as u32)],
+                            smallvec![Qubit::new(qubit1)],
                         ));
                     } else if n1 == 2 {
                         gates.push((
                             StandardGate::HGate,
                             smallvec![],
-                            smallvec![Qubit(qubit1 as u32)],
+                            smallvec![Qubit::new(qubit1)],
                         ));
                         gates.push((
                             StandardGate::SdgGate,
                             smallvec![],
-                            smallvec![Qubit(qubit1 as u32)],
+                            smallvec![Qubit::new(qubit1)],
                         ));
                     }
                     gates.push((
                         StandardGate::CXGate,
                         smallvec![],
-                        smallvec![Qubit(qubit0 as u32), Qubit(qubit1 as u32)],
+                        smallvec![Qubit::new(qubit0), Qubit::new(qubit1)],
                     ));
 
                     return Ok((reduced_cliff, new_cost));
@@ -242,19 +242,19 @@ fn decompose_clifford_1q(cliff: &Clifford, gates: &mut CliffordGatesVec, output_
         gates.push((
             StandardGate::ZGate,
             smallvec![],
-            smallvec![Qubit(output_qubit as u32)],
+            smallvec![Qubit::new(output_qubit)],
         ));
     } else if !destab_phase && stab_phase {
         gates.push((
             StandardGate::XGate,
             smallvec![],
-            smallvec![Qubit(output_qubit as u32)],
+            smallvec![Qubit::new(output_qubit)],
         ));
     } else if destab_phase && stab_phase {
         gates.push((
             StandardGate::YGate,
             smallvec![],
-            smallvec![Qubit(output_qubit as u32)],
+            smallvec![Qubit::new(output_qubit)],
         ));
     }
 
@@ -268,7 +268,7 @@ fn decompose_clifford_1q(cliff: &Clifford, gates: &mut CliffordGatesVec, output_
             gates.push((
                 StandardGate::SGate,
                 smallvec![],
-                smallvec![Qubit(output_qubit as u32)],
+                smallvec![Qubit::new(output_qubit)],
             ));
         }
     } else if !stab_z && stab_x {
@@ -276,31 +276,31 @@ fn decompose_clifford_1q(cliff: &Clifford, gates: &mut CliffordGatesVec, output_
             gates.push((
                 StandardGate::SdgGate,
                 smallvec![],
-                smallvec![Qubit(output_qubit as u32)],
+                smallvec![Qubit::new(output_qubit)],
             ));
         }
         gates.push((
             StandardGate::HGate,
             smallvec![],
-            smallvec![Qubit(output_qubit as u32)],
+            smallvec![Qubit::new(output_qubit)],
         ));
     } else {
         if !destab_z {
             gates.push((
                 StandardGate::SGate,
                 smallvec![],
-                smallvec![Qubit(output_qubit as u32)],
+                smallvec![Qubit::new(output_qubit)],
             ));
         }
         gates.push((
             StandardGate::HGate,
             smallvec![],
-            smallvec![Qubit(output_qubit as u32)],
+            smallvec![Qubit::new(output_qubit)],
         ));
         gates.push((
             StandardGate::SGate,
             smallvec![],
-            smallvec![Qubit(output_qubit as u32)],
+            smallvec![Qubit::new(output_qubit)],
         ));
     }
 }
diff --git a/crates/accelerate/src/synthesis/clifford/greedy_synthesis.rs b/crates/accelerate/src/synthesis/clifford/greedy_synthesis.rs
index 81ddfb1d6503..eca0b78951fd 100644
--- a/crates/accelerate/src/synthesis/clifford/greedy_synthesis.rs
+++ b/crates/accelerate/src/synthesis/clifford/greedy_synthesis.rs
@@ -214,7 +214,7 @@ impl GreedyCliffordSynthesis<'_> {
                     gate_seq.push((
                         StandardGate::SGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     self.symplectic_matrix.prepend_s(*qubit);
                 }
@@ -222,7 +222,7 @@ impl GreedyCliffordSynthesis<'_> {
                     gate_seq.push((
                         StandardGate::HGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     self.symplectic_matrix.prepend_h(*qubit);
                 }
@@ -230,12 +230,12 @@ impl GreedyCliffordSynthesis<'_> {
                     gate_seq.push((
                         StandardGate::SGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     gate_seq.push((
                         StandardGate::HGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     self.symplectic_matrix.prepend_s(*qubit);
                     self.symplectic_matrix.prepend_h(*qubit);
@@ -244,12 +244,12 @@ impl GreedyCliffordSynthesis<'_> {
                     gate_seq.push((
                         StandardGate::HGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     gate_seq.push((
                         StandardGate::SGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     self.symplectic_matrix.prepend_h(*qubit);
                     self.symplectic_matrix.prepend_s(*qubit);
@@ -258,17 +258,17 @@ impl GreedyCliffordSynthesis<'_> {
                     gate_seq.push((
                         StandardGate::SGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     gate_seq.push((
                         StandardGate::HGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     gate_seq.push((
                         StandardGate::SGate,
                         smallvec![],
-                        smallvec![Qubit(*qubit as u32)],
+                        smallvec![Qubit::new(*qubit)],
                     ));
                     self.symplectic_matrix.prepend_s(*qubit);
                     self.symplectic_matrix.prepend_h(*qubit);
@@ -304,7 +304,7 @@ impl GreedyCliffordSynthesis<'_> {
             gate_seq.push((
                 StandardGate::SwapGate,
                 smallvec![],
-                smallvec![Qubit(min_qubit as u32), Qubit(qubit_a as u32)],
+                smallvec![Qubit::new(min_qubit), Qubit::new(qubit_a)],
             ));
             self.symplectic_matrix.prepend_swap(min_qubit, qubit_a);
 
@@ -327,7 +327,7 @@ impl GreedyCliffordSynthesis<'_> {
             gate_seq.push((
                 StandardGate::CXGate,
                 smallvec![],
-                smallvec![Qubit(min_qubit as u32), Qubit(qubit as u32)],
+                smallvec![Qubit::new(min_qubit), Qubit::new(qubit)],
             ));
             self.symplectic_matrix.prepend_cx(min_qubit, qubit);
         }
@@ -336,7 +336,7 @@ impl GreedyCliffordSynthesis<'_> {
             gate_seq.push((
                 StandardGate::CXGate,
                 smallvec![],
-                smallvec![Qubit(qubit as u32), Qubit(min_qubit as u32)],
+                smallvec![Qubit::new(qubit), Qubit::new(min_qubit)],
             ));
             self.symplectic_matrix.prepend_cx(qubit, min_qubit);
         }
@@ -347,7 +347,7 @@ impl GreedyCliffordSynthesis<'_> {
                 gate_seq.push((
                     StandardGate::CXGate,
                     smallvec![],
-                    smallvec![Qubit(qubit_b as u32), Qubit(*qubit as u32)],
+                    smallvec![Qubit::new(qubit_b), Qubit::new(*qubit)],
                 ));
                 self.symplectic_matrix.prepend_cx(qubit_b, *qubit);
             }
@@ -358,21 +358,21 @@ impl GreedyCliffordSynthesis<'_> {
             gate_seq.push((
                 StandardGate::CXGate,
                 smallvec![],
-                smallvec![Qubit(min_qubit as u32), Qubit(qubit_b as u32)],
+                smallvec![Qubit::new(min_qubit), Qubit::new(qubit_b)],
             ));
             self.symplectic_matrix.prepend_cx(min_qubit, qubit_b);
 
             gate_seq.push((
                 StandardGate::HGate,
                 smallvec![],
-                smallvec![Qubit(qubit_b as u32)],
+                smallvec![Qubit::new(qubit_b)],
             ));
             self.symplectic_matrix.prepend_h(qubit_b);
 
             gate_seq.push((
                 StandardGate::CXGate,
                 smallvec![],
-                smallvec![Qubit(qubit_b as u32), Qubit(min_qubit as u32)],
+                smallvec![Qubit::new(qubit_b), Qubit::new(min_qubit)],
             ));
             self.symplectic_matrix.prepend_cx(qubit_b, min_qubit);
         }
@@ -387,8 +387,8 @@ impl GreedyCliffordSynthesis<'_> {
                 StandardGate::CXGate,
                 smallvec![],
                 smallvec![
-                    Qubit(a_qubits[2 * qubit + 1] as u32),
-                    Qubit(a_qubits[2 * qubit] as u32)
+                    Qubit::new(a_qubits[2 * qubit + 1]),
+                    Qubit::new(a_qubits[2 * qubit])
                 ],
             ));
             self.symplectic_matrix
@@ -397,7 +397,7 @@ impl GreedyCliffordSynthesis<'_> {
             gate_seq.push((
                 StandardGate::CXGate,
                 smallvec![],
-                smallvec![Qubit(a_qubits[2 * qubit] as u32), Qubit(min_qubit as u32)],
+                smallvec![Qubit::new(a_qubits[2 * qubit]), Qubit::new(min_qubit)],
             ));
             self.symplectic_matrix
                 .prepend_cx(a_qubits[2 * qubit], min_qubit);
@@ -405,10 +405,7 @@ impl GreedyCliffordSynthesis<'_> {
             gate_seq.push((
                 StandardGate::CXGate,
                 smallvec![],
-                smallvec![
-                    Qubit(min_qubit as u32),
-                    Qubit(a_qubits[2 * qubit + 1] as u32)
-                ],
+                smallvec![Qubit::new(min_qubit), Qubit::new(a_qubits[2 * qubit + 1])],
             ));
             self.symplectic_matrix
                 .prepend_cx(min_qubit, a_qubits[2 * qubit + 1]);
diff --git a/crates/accelerate/src/synthesis/clifford/utils.rs b/crates/accelerate/src/synthesis/clifford/utils.rs
index d7230dcdd48f..fa2e33561a46 100644
--- a/crates/accelerate/src/synthesis/clifford/utils.rs
+++ b/crates/accelerate/src/synthesis/clifford/utils.rs
@@ -287,21 +287,21 @@ pub fn adjust_final_pauli_gates(
             gate_seq.push((
                 StandardGate::YGate,
                 smallvec![],
-                smallvec![Qubit(qubit as u32)],
+                smallvec![Qubit::new(qubit)],
             ));
         } else if delta_phase_pre[qubit] {
             // println!("=> Adding Z-gate on {}", qubit);
             gate_seq.push((
                 StandardGate::ZGate,
                 smallvec![],
-                smallvec![Qubit(qubit as u32)],
+                smallvec![Qubit::new(qubit)],
             ));
         } else if delta_phase_pre[qubit + num_qubits] {
             // println!("=> Adding X-gate on {}", qubit);
             gate_seq.push((
                 StandardGate::XGate,
                 smallvec![],
-                smallvec![Qubit(qubit as u32)],
+                smallvec![Qubit::new(qubit)],
             ));
         }
     }
diff --git a/crates/accelerate/src/synthesis/multi_controlled/mcmt.rs b/crates/accelerate/src/synthesis/multi_controlled/mcmt.rs
index 3b30c3f53fe2..7569740768a1 100644
--- a/crates/accelerate/src/synthesis/multi_controlled/mcmt.rs
+++ b/crates/accelerate/src/synthesis/multi_controlled/mcmt.rs
@@ -26,15 +26,15 @@ use crate::QiskitError;
 /// For example, for 4 controls we require 3 auxiliaries and create the circuit
 ///
 ///     control_0: ──■──────────────
-///                  │              
+///                  │
 ///     control_1: ──■──────────────
-///                  │              
+///                  │
 ///     control_2: ──┼────■─────────
-///                  │    │         
+///                  │    │
 ///     control_3: ──┼────┼────■────
-///                ┌─┴─┐  │    │    
+///                ┌─┴─┐  │    │
 ///         aux_0: ┤ X ├──■────┼────
-///                └───┘┌─┴─┐  │    
+///                └───┘┌─┴─┐  │
 ///         aux_1: ─────┤ X ├──■────
 ///                     └───┘┌─┴─┐         "master control" qubit: controlling on this
 ///         aux_2: ──────────┤ X ├──  <--  implements a controlled operation on all qubits
@@ -57,11 +57,7 @@ fn ccx_chain<'a>(
             Ok((
                 StandardGate::CCXGate.into(),
                 smallvec![],
-                vec![
-                    Qubit(ctrl1 as u32),
-                    Qubit(ctrl2 as u32),
-                    Qubit(target as u32),
-                ],
+                vec![Qubit::new(ctrl1), Qubit::new(ctrl2), Qubit::new(target)],
                 vec![],
             ))
         })
@@ -123,7 +119,7 @@ pub fn mcmt_v_chain(
             Ok((
                 PackedOperation::from_standard(StandardGate::XGate),
                 smallvec![] as SmallVec<[Param; 3]>,
-                vec![Qubit(index as u32)],
+                vec![Qubit::new(index)],
                 vec![] as Vec<Clbit>,
             ))
         });
@@ -140,10 +136,7 @@ pub fn mcmt_v_chain(
         Ok((
             packed_controlled_gate.clone(),
             smallvec![] as SmallVec<[Param; 3]>,
-            vec![
-                Qubit(master_control as u32),
-                Qubit((num_ctrl_qubits + i) as u32),
-            ],
+            vec![Qubit::new(master_control), Qubit::new(num_ctrl_qubits + i)],
             vec![] as Vec<Clbit>,
         ))
     });
diff --git a/crates/accelerate/src/synthesis/permutation/mod.rs b/crates/accelerate/src/synthesis/permutation/mod.rs
index 2f84776cb5fd..2cc0b02f2c66 100644
--- a/crates/accelerate/src/synthesis/permutation/mod.rs
+++ b/crates/accelerate/src/synthesis/permutation/mod.rs
@@ -54,7 +54,7 @@ pub fn _synth_permutation_basic(py: Python, pattern: PyArrayLike1<i64>) -> PyRes
             (
                 StandardGate::SwapGate,
                 smallvec![],
-                smallvec![Qubit(*i as u32), Qubit(*j as u32)],
+                smallvec![Qubit::new(*i), Qubit::new(*j)],
             )
         }),
         Param::Float(0.0),
@@ -77,7 +77,7 @@ fn _synth_permutation_acg(py: Python, pattern: PyArrayLike1<i64>) -> PyResult<Ci
             (
                 StandardGate::SwapGate,
                 smallvec![],
-                smallvec![Qubit(*i as u32), Qubit(*j as u32)],
+                smallvec![Qubit::new(*i), Qubit::new(*j)],
             )
         }),
         Param::Float(0.0),
@@ -109,7 +109,7 @@ pub fn _synth_permutation_depth_lnn_kms(
             (
                 StandardGate::SwapGate,
                 smallvec![],
-                smallvec![Qubit(*i as u32), Qubit(*j as u32)],
+                smallvec![Qubit::new(*i), Qubit::new(*j)],
             )
         }),
         Param::Float(0.0),
@@ -122,7 +122,7 @@ pub(crate) fn _append_cx_stage1(gates: &mut LnnGatesVec, n: usize) {
         gates.push((
             StandardGate::CXGate,
             smallvec![],
-            smallvec![Qubit((2 * i) as u32), Qubit((2 * i + 1) as u32)],
+            smallvec![Qubit::new(2 * i), Qubit::new(2 * i + 1)],
         ))
     }
 
@@ -130,7 +130,7 @@ pub(crate) fn _append_cx_stage1(gates: &mut LnnGatesVec, n: usize) {
         gates.push((
             StandardGate::CXGate,
             smallvec![],
-            smallvec![Qubit((2 * i + 2) as u32), Qubit((2 * i + 1) as u32)],
+            smallvec![Qubit::new(2 * i + 2), Qubit::new(2 * i + 1)],
         ))
     }
 }
@@ -141,7 +141,7 @@ pub(crate) fn _append_cx_stage2(gates: &mut LnnGatesVec, n: usize) {
         gates.push((
             StandardGate::CXGate,
             smallvec![],
-            smallvec![Qubit((2 * i + 1) as u32), Qubit((2 * i) as u32)],
+            smallvec![Qubit::new(2 * i + 1), Qubit::new(2 * i)],
         ))
     }
 
@@ -149,7 +149,7 @@ pub(crate) fn _append_cx_stage2(gates: &mut LnnGatesVec, n: usize) {
         gates.push((
             StandardGate::CXGate,
             smallvec![],
-            smallvec![Qubit((2 * i + 1) as u32), Qubit((2 * i + 2) as u32)],
+            smallvec![Qubit::new(2 * i + 1), Qubit::new(2 * i + 2)],
         ))
     }
 }
diff --git a/crates/circuit/src/dag_circuit.rs b/crates/circuit/src/dag_circuit.rs
index 2301b8659428..167cc8923896 100644
--- a/crates/circuit/src/dag_circuit.rs
+++ b/crates/circuit/src/dag_circuit.rs
@@ -462,7 +462,7 @@ impl DAGCircuit {
             .qubit_io_map
             .iter()
             .enumerate()
-            .map(|(idx, indices)| (Qubit(idx as u32), indices))
+            .map(|(idx, indices)| (Qubit::new(idx), indices))
         {
             out_dict.set_item(
                 self.qubits.get(qubit).unwrap().clone_ref(py),
@@ -473,7 +473,7 @@ impl DAGCircuit {
             .clbit_io_map
             .iter()
             .enumerate()
-            .map(|(idx, indices)| (Clbit(idx as u32), indices))
+            .map(|(idx, indices)| (Clbit::new(idx), indices))
         {
             out_dict.set_item(
                 self.clbits.get(clbit).unwrap().clone_ref(py),
@@ -496,7 +496,7 @@ impl DAGCircuit {
             .qubit_io_map
             .iter()
             .enumerate()
-            .map(|(idx, indices)| (Qubit(idx as u32), indices))
+            .map(|(idx, indices)| (Qubit::new(idx), indices))
         {
             out_dict.set_item(
                 self.qubits.get(qubit).unwrap().clone_ref(py),
@@ -507,7 +507,7 @@ impl DAGCircuit {
             .clbit_io_map
             .iter()
             .enumerate()
-            .map(|(idx, indices)| (Clbit(idx as u32), indices))
+            .map(|(idx, indices)| (Clbit::new(idx), indices))
         {
             out_dict.set_item(
                 self.clbits.get(clbit).unwrap().clone_ref(py),
@@ -1191,13 +1191,13 @@ def _format(operand):
             .drain(..)
             .enumerate()
             .filter_map(|(k, v)| {
-                let clbit = Clbit(k as u32);
+                let clbit = Clbit::new(k);
                 if clbits.contains(&clbit) {
                     None
                 } else {
                     Some((
                         self.clbits
-                            .find(old_clbits.get(Clbit(k as u32)).unwrap().bind(py))
+                            .find(old_clbits.get(Clbit::new(k)).unwrap().bind(py))
                             .unwrap(),
                         v,
                     ))
@@ -1207,7 +1207,7 @@ def _format(operand):
 
         self.clbit_io_map = (0..io_mapping.len())
             .map(|idx| {
-                let clbit = Clbit(idx as u32);
+                let clbit = Clbit::new(idx);
                 io_mapping[&clbit]
             })
             .collect();
@@ -1399,7 +1399,7 @@ def _format(operand):
             .drain(..)
             .enumerate()
             .filter_map(|(k, v)| {
-                let qubit = Qubit(k as u32);
+                let qubit = Qubit::new(k);
                 if qubits.contains(&qubit) {
                     None
                 } else {
@@ -1415,7 +1415,7 @@ def _format(operand):
 
         self.qubit_io_map = (0..io_mapping.len())
             .map(|idx| {
-                let qubit = Qubit(idx as u32);
+                let qubit = Qubit::new(idx);
                 io_mapping[&qubit]
             })
             .collect();
@@ -2105,8 +2105,8 @@ def _format(operand):
     fn idle_wires(&self, py: Python, ignore: Option<&Bound<PyList>>) -> PyResult<Py<PyIterator>> {
         let mut result: Vec<PyObject> = Vec::new();
         let wires = (0..self.qubit_io_map.len())
-            .map(|idx| Wire::Qubit(Qubit(idx as u32)))
-            .chain((0..self.clbit_io_map.len()).map(|idx| Wire::Clbit(Clbit(idx as u32))))
+            .map(|idx| Wire::Qubit(Qubit::new(idx)))
+            .chain((0..self.clbit_io_map.len()).map(|idx| Wire::Clbit(Clbit::new(idx))))
             .chain(self.var_input_map.keys(py).map(Wire::Var));
         match ignore {
             Some(ignore) => {
@@ -3606,7 +3606,7 @@ def _format(operand):
                 .qubit_io_map
                 .iter()
                 .enumerate()
-                .map(|(idx, indices)| (Qubit(idx as u32), indices))
+                .map(|(idx, indices)| (Qubit::new(idx), indices))
             {
                 if new_dag.dag.edges(*in_node).next().is_none() {
                     new_dag
@@ -3618,7 +3618,7 @@ def _format(operand):
                 .clbit_io_map
                 .iter()
                 .enumerate()
-                .map(|(idx, indices)| (Clbit(idx as u32), indices))
+                .map(|(idx, indices)| (Clbit::new(idx), indices))
             {
                 if new_dag.dag.edges(*in_node).next().is_none() {
                     new_dag
diff --git a/crates/circuit/src/lib.rs b/crates/circuit/src/lib.rs
index eb1448282d56..92c52de91a2f 100644
--- a/crates/circuit/src/lib.rs
+++ b/crates/circuit/src/lib.rs
@@ -37,7 +37,8 @@ pub type BitType = u32;
 pub struct Qubit(pub BitType);
 
 impl Qubit {
-    /// Construct a new Qubit object from a usize
+    /// Construct a new Qubit object from a usize, if you have a u32 you can
+    /// create a `Qubit` object directly with `Qubit(0u32)`.
     #[inline(always)]
     pub fn new(index: usize) -> Self {
         Qubit(index as BitType)
@@ -54,7 +55,8 @@ impl Qubit {
 pub struct Clbit(pub BitType);
 
 impl Clbit {
-    /// Construct a new Clbit object from a usize
+    /// Construct a new Clbit object from a usize. if you have a u32 you can
+    /// create a `Clbit` object directly with `Clbit(0u32)`.
     #[inline(always)]
     pub fn new(index: usize) -> Self {
         Clbit(index as BitType)