feat: Add guppy extension with drop operation (#962)

Closes #946

---------

Co-authored-by: Alan Lawrence <alan.lawrence@cambridgequantum.com>

Author: tatiana-s

tket2-exts/src/tket2_exts/__init__.py

@@ -21,6 +21,11 @@ def debug() -> Extension:
     return load_extension("tket2.debug")
 
 
+@functools.cache
+def guppy() -> Extension:
+    return load_extension("tket2.guppy")
+
+
 @functools.cache
 def rotation() -> Extension:
     return load_extension("tket2.rotation")

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

@@ -0,0 +1,31 @@
+{
+  "version": "0.1.0",
+  "name": "tket2.guppy",
+  "types": {},
+  "operations": {
+    "drop": {
+      "extension": "tket2.guppy",
+      "name": "drop",
+      "description": "Drop the input wire. Applicable to guppy affine types only.",
+      "signature": {
+        "params": [
+          {
+            "tp": "Type",
+            "b": "A"
+          }
+        ],
+        "body": {
+          "input": [
+            {
+              "t": "V",
+              "i": 0,
+              "b": "A"
+            }
+          ],
+          "output": []
+        }
+      },
+      "binary": false
+    }
+  }
+}

tket2-hseries/src/bin/tket2-hseries.rs

@@ -13,6 +13,7 @@ fn main() -> Result<()> {
                 tket2::extension::rotation::ROTATION_EXTENSION.to_owned(),
                 tket2::extension::bool::BOOL_EXTENSION.to_owned(),
                 tket2::extension::debug::DEBUG_EXTENSION.to_owned(),
+                tket2::extension::guppy::GUPPY_EXTENSION.to_owned(),
                 tket2_hseries::extension::qsystem::EXTENSION.to_owned(),
                 tket2_hseries::extension::futures::EXTENSION.to_owned(),
                 tket2_hseries::extension::random::EXTENSION.to_owned(),

tket2-py/test/test_exts.py

@@ -1,6 +1,7 @@
 from tket2.extensions import opaque_bool  # noqa: F401
 from tket2.extensions import debug  # noqa: F401
 from tket2.extensions import rotation  # noqa: F401
+from tket2.extensions import guppy  # noqa: F401
 from tket2.extensions import futures  # noqa: F401
 from tket2.extensions import qsystem  # noqa: F401
 from tket2.extensions import qsystem_random  # noqa: F401

tket2-py/tket2/extensions/__init__.py

@@ -1,6 +1,7 @@
 from tket2_exts import (
     opaque_bool,
     debug,
+    guppy,
     rotation,
     futures,
     qsystem,
@@ -15,6 +16,7 @@
 __all__ = [
     "debug",
     "opaque_bool",
+    "guppy",
     "rotation",
     "futures",
     "qsystem",

tket2/src/extension.rs

@@ -22,6 +22,8 @@ use smol_str::SmolStr;
 pub mod bool;
 /// Definition for debug ops.
 pub mod debug;
+/// Definition for ops used by Guppy.
+pub mod guppy;
 /// Definition for Angle ops and types.
 pub mod rotation;
 pub mod sympy;
@@ -64,6 +66,7 @@ pub(crate) static ref REGISTRY: ExtensionRegistry = ExtensionRegistry::new(
     TKET2_EXTENSION.to_owned(),
     bool::BOOL_EXTENSION.to_owned(),
     debug::DEBUG_EXTENSION.to_owned(),
+    guppy::GUPPY_EXTENSION.to_owned(),
     rotation::ROTATION_EXTENSION.to_owned()
 ]));
 

tket2/src/extension/guppy.rs

@@ -0,0 +1,64 @@
+//! This module defines a Hugr extension for operations to be used in Guppy.
+use std::sync::Arc;
+
+use hugr::{
+    extension::{ExtensionId, Version},
+    hugr::IdentList,
+    type_row,
+    types::{FuncValueType, PolyFuncTypeRV, Type, TypeBound},
+    Extension,
+};
+use lazy_static::lazy_static;
+use smol_str::SmolStr;
+
+/// The ID of the `tket2.guppy` extension.
+pub const GUPPY_EXTENSION_ID: ExtensionId = IdentList::new_unchecked("tket2.guppy");
+/// The "tket2.guppy" extension version.
+pub const GUPPY_EXTENSION_VERSION: Version = Version::new(0, 1, 0);
+
+/// The drop operation, used to handle affine types in Guppy.
+pub const DROP_OP_NAME: SmolStr = SmolStr::new_inline("drop");
+
+lazy_static! {
+    /// The "tket2.bool" extension.
+    pub static ref GUPPY_EXTENSION: Arc<Extension>  = {
+        Extension::new_arc(GUPPY_EXTENSION_ID, GUPPY_EXTENSION_VERSION, |ext, ext_ref| {
+            ext.add_op(DROP_OP_NAME,
+                "Drop the input wire. Applicable to guppy affine types only.".into(),
+                // drop<T: Any>(t: T) -> ()
+                PolyFuncTypeRV::new(
+                    [TypeBound::Linear.into()],
+                    FuncValueType::new(
+                        vec![Type::new_var_use(0, TypeBound::Linear)],
+                        type_row![],
+                    )
+            ),
+            ext_ref
+            ).unwrap();
+        })
+    };
+}
+
+#[cfg(test)]
+mod test {
+
+    use hugr::{
+        builder::{inout_sig, DFGBuilder, Dataflow, DataflowHugr},
+        extension::prelude::usize_t,
+        std_extensions::collections::array::array_type,
+    };
+
+    use super::*;
+
+    #[test]
+    fn test_drop() {
+        let arr_type = array_type(2, usize_t());
+        let drop_op = GUPPY_EXTENSION
+            .instantiate_extension_op(&DROP_OP_NAME, [arr_type.clone().into()])
+            .unwrap();
+        let mut b = DFGBuilder::new(inout_sig(vec![arr_type], type_row![])).unwrap();
+        let inp = b.input_wires();
+        b.add_dataflow_op(drop_op, inp).unwrap();
+        b.finish_hugr_with_outputs([]).unwrap();
+    }
+}