feat: Clean Up by Deleting Unconnected Nodes after Modifier Solve

test_files/guppy_examples/modifiers.py

@@ -1,7 +1,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "guppylang ==0.21.13",
+#     "guppylang @ git+https://github.com/Quantinuum/guppylang.git@main#subdirectory=guppylang",
 # ]
 # ///
 """A simple controlled gate using modifiers"""

test_files/modifier_examples/classical_function1.py

@@ -0,0 +1,42 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.13",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle
+from guppylang.std.quantum import rx
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def fuu(i: int) -> int:
+    return i + 1
+
+
+@guppy
+def main() -> None:
+    q = qubit()
+    with dagger:
+        rx(q, angle(1 / fuu(2)))
+
+    state_result("r", q)
+    discard(q)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/classical_function2.py

@@ -0,0 +1,51 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang @ git+https://github.com/Quantinuum/guppylang.git@main#subdirectory=guppylang",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import control, dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle, measure
+from guppylang.std.quantum import h, rx, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def fuu(i: int) -> int:
+    q = qubit()
+    x(q)
+    if measure(q):
+        i = i + 1
+    return i
+
+
+@guppy
+def main() -> None:
+    t = qubit()
+    c1 = qubit()
+    h(c1)
+    with control(c1):
+        d = fuu(2)
+        with dagger:
+            rx(t, angle(1 / d))
+
+    state_result("r", c1, t)
+    discard(c1)
+    discard(t)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/classical_function3.py

@@ -0,0 +1,55 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang @ git+https://github.com/Quantinuum/guppylang.git@main#subdirectory=guppylang",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import control, dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle, measure
+from guppylang.std.quantum import h, rx, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def fuu(i: int) -> int:
+    q = qubit()
+    x(q)
+    if measure(q):
+        i = i + 1
+    return i
+
+
+@guppy
+def main() -> None:
+    t = qubit()
+    c1 = qubit()
+    c2 = qubit()
+    h(c1)
+    h(c2)
+    with control(c1):
+        d = fuu(2)
+        with control(c2):
+            with dagger:
+                rx(t, angle(1 / d))
+
+    state_result("r", c1, c2, t)
+    discard(c1)
+    discard(c2)
+    discard(t)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/ctrl_array_controller.py

@@ -0,0 +1,50 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.13",
+# ]
+# ///
+"""A controlled gate where the controller is an array of qubits"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import array, control
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, discard_array, qubit
+from guppylang.std.quantum import h, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy(unitary=True)
+def bar(q: qubit) -> None:
+    x(q)
+
+
+@guppy
+def main() -> None:
+    controllers: array[qubit, 3] = array(qubit(), qubit(), qubit())
+    t = qubit()
+
+    h(controllers[0])
+    h(controllers[1])
+    h(controllers[2])
+
+    with control(controllers):
+        bar(t)
+
+    state_result("r", controllers[0], controllers[1], controllers[2], t)
+
+    discard_array(controllers)
+    discard(t)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/ctrl_on_call1.py

@@ -0,0 +1,45 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.13",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import control
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit
+from guppylang.std.quantum import h, x
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy(unitary=True)
+def bar(q: qubit) -> None:
+    x(q)
+
+
+@guppy
+def main() -> None:
+    q1 = qubit()
+    q2 = qubit()
+    h(q1)
+    with control(q1):
+        bar(q2)
+
+    state_result("r", q1, q2)
+    discard(q1)
+    discard(q2)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/double_modifier.py

@@ -0,0 +1,41 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang @ git+https://github.com/Quantinuum/guppylang.git@main#subdirectory=guppylang",
+# ]
+# ///
+"""A simple controlled gate using modifiers"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import control, dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle
+from guppylang.std.quantum import h, rx
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy
+def main() -> None:
+    c1 = qubit()
+    t = qubit()
+    h(c1)
+    with control(c1):
+        with dagger:
+            rx(t, angle(1 / 3))
+
+    state_result("r", c1, t)
+    discard(c1)
+    discard(t)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())

test_files/modifier_examples/multiple_dagger.py

@@ -0,0 +1,47 @@
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "guppylang ==0.21.13",
+# ]
+# ///
+"""An example with an even number of daggers, which should cancel out"""
+
+from pathlib import Path
+from sys import argv
+import sys
+
+from guppylang import guppy
+from guppylang.std.builtins import dagger
+from guppylang.std.debug import state_result
+from guppylang.std.quantum import discard, qubit, angle
+from guppylang.std.quantum import rx
+
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+from guppylang.experimental import enable_experimental_features
+
+enable_experimental_features()
+
+
+@guppy(unitary=True)
+def rotation(q: qubit) -> None:
+    rx(q, angle(1 / 4))
+
+
+@guppy
+def main() -> None:
+    t = qubit()
+
+    with dagger:
+        with dagger:
+            rotation(t)
+
+    with dagger, dagger, dagger:
+        rotation(t)
+
+    state_result("r", t)
+    discard(t)
+
+
+program = main.compile()
+Path(argv[0]).with_suffix(".hugr").write_bytes(program.to_bytes())