Allow QEC to encode multiple logical qubits (#1226)

This generalizes the `ErrorCorrection` trait to allow encoding multiple
logical qubits, thereby enabling the modeling of codes such as LDPC. The
change also lead to rename the `LogicalQubit` struct into `LogicalPatch`
to account the possibility of multiple logical qubits in the name of the
struct.

The system does not change, since all the planar codes modeled in it
encode one logical qubit.

Author: msoeken

resource_estimator/src/estimates.rs

@@ -13,5 +13,5 @@ pub use physical_estimation::{
 mod layout;
 mod logical_qubit;
 pub use layout::Overhead;
-pub use logical_qubit::LogicalQubit;
+pub use logical_qubit::LogicalPatch;
 pub mod optimization;

resource_estimator/src/estimates/error.rs

@@ -37,13 +37,20 @@ pub enum Error {
     #[error("No solution found for the provided maximum number of physical qubits.")]
     #[diagnostic(code("Qsc.Estimates.MaxPhysicalQubitsTooSmall"))]
     MaxPhysicalQubitsTooSmall,
-    /// The number of physical qubits per logical qubit cannot be computed.
+    /// The number of physical qubits required for a code cannot be computed.
     ///
     /// ✅ This does not contain user data and can be logged
     /// 🧑‍💻 This indicates a user error
-    #[error("The number of physical qubits per logical qubit cannot be computed: {0}")]
+    #[error("The number of physical qubits required for a code cannot be computed: {0}")]
     #[diagnostic(code("Qsc.Estimates.PhysicalQubitComputationFailed"))]
     PhysicalQubitComputationFailed(String),
+    /// The number of logical qubits provided by a code cannot be computed.
+    ///
+    /// ✅ This does not contain user data and can be logged
+    /// 🧑‍💻 This indicates a user error
+    #[error("The number of logical qubits provided by a code cannot be computed: {0}")]
+    #[diagnostic(code("Qsc.Estimates.LogicalQubitComputationFailed"))]
+    LogicalQubitComputationFailed(String),
     /// The logical cycle time cannot be computed.
     ///
     /// ✅ This does not contain user data and can be logged

resource_estimator/src/estimates/logical_qubit.rs

@@ -3,31 +3,32 @@
 
 use crate::estimates::{Error, ErrorCorrection};
 
-use std::{
-    fmt::{Debug, Display},
-    rc::Rc,
-};
+use std::rc::Rc;
 
-/// Logical qubit model.
+/// A logical patch from an error correction code
 ///
-/// A logical qubit is derived from a physical qubit and a fault-tolerance
-/// protocol.  Construction methods are provided that take as additional input
-/// the code distance, or alternatively the target error rate from which the
-/// code distance is computed.
-pub struct LogicalQubit<E: ErrorCorrection> {
+/// A logical patch is an instantiation of an error correcting code for some
+/// assignment to the code parameters.  It stores all computed information such
+/// as the number of physical and logical qubits, cycle time, and logical error
+/// rate.
+pub struct LogicalPatch<E: ErrorCorrection> {
     physical_qubit: Rc<E::Qubit>,
     code_parameter: E::Parameter,
     physical_qubits: u64,
+    logical_qubits: u64,
     logical_cycle_time: u64,
     logical_error_rate: f64,
 }
 
-impl<E: ErrorCorrection> LogicalQubit<E> {
+impl<E: ErrorCorrection> LogicalPatch<E> {
     pub fn new(ftp: &E, code_parameter: E::Parameter, qubit: Rc<E::Qubit>) -> Result<Self, Error> {
         // safe to convert here because we check for negative values before
         let physical_qubits = ftp
-            .physical_qubits_per_logical_qubit(&code_parameter)
+            .physical_qubits(&code_parameter)
             .map_err(Error::PhysicalQubitComputationFailed)?;
+        let logical_qubits = ftp
+            .logical_qubits(&code_parameter)
+            .map_err(Error::LogicalQubitComputationFailed)?;
         let logical_cycle_time = ftp
             .logical_cycle_time(&qubit, &code_parameter)
             .map_err(Error::LogicalCycleTimeComputationFailed)?;
@@ -39,6 +40,7 @@ impl<E: ErrorCorrection> LogicalQubit<E> {
             physical_qubit: qubit,
             code_parameter,
             physical_qubits,
+            logical_qubits,
             logical_cycle_time,
             logical_error_rate,
         })
@@ -49,11 +51,16 @@ impl<E: ErrorCorrection> LogicalQubit<E> {
         &self.physical_qubit
     }
 
-    /// Returns the code distance.
+    /// Returns the code parameter.
     pub fn code_parameter(&self) -> &E::Parameter {
         &self.code_parameter
     }
 
+    /// Returns the number of logical qubits in the patch.
+    pub fn logical_qubits(&self) -> u64 {
+        self.logical_qubits
+    }
+
     /// Returns the number of physical qubits to encode the logical qubit.
     pub fn physical_qubits(&self) -> u64 {
         self.physical_qubits
@@ -74,12 +81,3 @@ impl<E: ErrorCorrection> LogicalQubit<E> {
         1e9 / (self.logical_cycle_time as f64)
     }
 }
-
-impl<E: ErrorCorrection> Debug for LogicalQubit<E>
-where
-    E::Parameter: Display,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "LQubit(d={})", self.code_parameter())
-    }
-}