feat(tket2-hseries)!: Redefine QSystemOp::LazyMeasure and introduce QSystemOp::LazyMeasureReset (#741)

Done in the process of addressing #740 

BREAKING CHANGE: The signature of `QSystemOp::LazyMeasure` is changed to
consume its qubit.

Author: doug-q

tket2-exts/src/tket2_exts/data/tket2/qsystem.json

@@ -13,6 +13,41 @@
       "extension": "tket2.qsystem",
       "name": "LazyMeasure",
       "description": "Lazily measure a qubit and lose it.",
+      "signature": {
+        "params": [],
+        "body": {
+          "input": [
+            {
+              "t": "Q"
+            }
+          ],
+          "output": [
+            {
+              "t": "Opaque",
+              "extension": "tket2.futures",
+              "id": "Future",
+              "args": [
+                {
+                  "tya": "Type",
+                  "ty": {
+                    "t": "Sum",
+                    "s": "Unit",
+                    "size": 2
+                  }
+                }
+              ],
+              "bound": "A"
+            }
+          ],
+          "runtime_reqs": []
+        }
+      },
+      "binary": false
+    },
+    "LazyMeasureReset": {
+      "extension": "tket2.qsystem",
+      "name": "LazyMeasureReset",
+      "description": "Lazily measure a qubit and reset it to the Z |0> eigenstate.",
       "signature": {
         "params": [],
         "body": {

tket2-hseries/src/extension/qsystem.rs

@@ -82,6 +82,7 @@ lazy_static! {
 pub enum QSystemOp {
     Measure,
     LazyMeasure,
+    LazyMeasureReset,
     Rz,
     PhasedX,
     ZZMax,
@@ -98,7 +99,8 @@ impl MakeOpDef for QSystemOp {
         let one_qb_row = TypeRow::from(vec![qb_t()]);
         let two_qb_row = TypeRow::from(vec![qb_t(), qb_t()]);
         match self {
-            LazyMeasure => Signature::new(qb_t(), vec![qb_t(), future_type(bool_t())]),
+            LazyMeasure => Signature::new(qb_t(), future_type(bool_t())),
+            LazyMeasureReset => Signature::new(qb_t(), vec![qb_t(), future_type(bool_t())]),
             Reset => Signature::new(one_qb_row.clone(), one_qb_row),
             ZZMax => Signature::new(two_qb_row.clone(), two_qb_row),
             ZZPhase => Signature::new(vec![qb_t(), qb_t(), float64_type()], two_qb_row),
@@ -136,6 +138,9 @@ impl MakeOpDef for QSystemOp {
             QSystemOp::QFree => "Free a qubit (lose track of it).",
             QSystemOp::Reset => "Reset a qubit to the Z |0> eigenstate.",
             QSystemOp::MeasureReset => "Measure a qubit and reset it to the Z |0> eigenstate.",
+            QSystemOp::LazyMeasureReset => {
+                "Lazily measure a qubit and reset it to the Z |0> eigenstate."
+            }
         }
         .to_string()
     }
@@ -155,9 +160,16 @@ impl MakeRegisteredOp for QSystemOp {
 /// "tket2.qsystem" operations.
 pub trait QSystemOpBuilder: Dataflow + UnwrapBuilder {
     /// Add a "tket2.qsystem.LazyMeasure" op.
-    fn add_lazy_measure(&mut self, qb: Wire) -> Result<[Wire; 2], BuildError> {
+    fn add_lazy_measure(&mut self, qb: Wire) -> Result<Wire, BuildError> {
         Ok(self
             .add_dataflow_op(QSystemOp::LazyMeasure, [qb])?
+            .out_wire(0))
+    }
+
+    /// Add a "tket2.qsystem.LazyMeasureReset" op.
+    fn add_lazy_measure_reset(&mut self, qb: Wire) -> Result<[Wire; 2], BuildError> {
+        Ok(self
+            .add_dataflow_op(QSystemOp::LazyMeasureReset, [qb])?
             .outputs_arr())
     }
 
@@ -439,7 +451,7 @@ mod test {
                 FunctionBuilder::new("circuit", Signature::new(qb_t(), vec![qb_t(), bool_t()]))
                     .unwrap();
             let [qb] = func_builder.input_wires_arr();
-            let [qb, lazy_b] = func_builder.add_lazy_measure(qb).unwrap();
+            let [qb, lazy_b] = func_builder.add_lazy_measure_reset(qb).unwrap();
             let [b] = func_builder.add_read(lazy_b, bool_t()).unwrap();
             func_builder.finish_hugr_with_outputs([qb, b]).unwrap()
         };

tket2-hseries/src/lazify_measure.rs

@@ -101,7 +101,7 @@ lazy_static! {
     static ref MEASURE_READ_HUGR: Hugr = {
         let mut builder = DFGBuilder::new(Signature::new(qb_t(), vec![qb_t(), bool_t()])).unwrap();
         let [qb] = builder.input_wires_arr();
-        let [qb, lazy_r] = builder.add_lazy_measure(qb).unwrap();
+        let [qb, lazy_r] = builder.add_lazy_measure_reset(qb).unwrap();
         let [r] = builder.add_read(lazy_r, bool_t()).unwrap();
         builder.finish_hugr_with_outputs([qb, r]).unwrap()
     };
@@ -113,7 +113,7 @@ fn measure_replacement(num_dups: usize) -> Hugr {
     let num_out_types = out_types.len();
     let mut builder = DFGBuilder::new(Signature::new(qb_t(), out_types)).unwrap();
     let [qb] = builder.input_wires_arr();
-    let [qb, mut future_r] = builder.add_lazy_measure(qb).unwrap();
+    let [qb, mut future_r] = builder.add_lazy_measure_reset(qb).unwrap();
     let mut future_rs = vec![];
     if num_dups > 0 {
         for _ in 0..num_dups - 1 {
@@ -221,20 +221,20 @@ mod test {
         LazifyMeasurePass::default().run(&mut hugr).unwrap();
         assert!(hugr.validate_no_extensions().is_ok());
         let mut num_read = 0;
-        let mut num_lazy_measure = 0;
+        let mut num_lazy_measure_reset = 0;
         for n in hugr.nodes() {
             let ot = hugr.get_optype(n);
             if let Some(FutureOpDef::Read) = ot.cast() {
                 num_read += 1;
-            } else if let Some(QSystemOp::LazyMeasure) = ot.cast() {
-                num_lazy_measure += 1;
+            } else if let Some(QSystemOp::LazyMeasureReset) = ot.cast() {
+                num_lazy_measure_reset += 1;
             } else {
                 assert_eq!(ot.cast::<Tk2Op>(), None)
             }
         }
 
         assert_eq!(1, num_read);
-        assert_eq!(1, num_lazy_measure);
+        assert_eq!(1, num_lazy_measure_reset);
     }
 
     #[test]