tket 0.18.0

Quantinuum's TKET Quantum Compiler
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Ad hoc implementation of array operations modification.
//! If dagger is applied, change `new_array` <-> `unpack`.
//! Other operations are not supported except for `swap`.
//! Also, some array conversion operations are supported
//! but only for known types of arrays.
//! These can be generated by Guppy compiler, so some support is
//! better than nothing. However, this remains ad-hoc and
//! incomplete implementation.
//!
//! We suppose that
//! ```python
//! q1, q2 = q2, q1  # swap
//! ```
//! is variable renaming, not quantum SWAP gate.
//! Therefore,
//! ```python
//! with control(q1):
//!     q1, q2 = q2, q1  # swap
//! ```
//! should also be classical swap, not controlled-SWAP gate.
//! The same is also applied to swap of arrays:
//! `array.swap()` called in a controlled context is still classical swap.
use super::{DirWire, ModifierResolver, ModifierResolverErrors};
use hugr::{
    builder::Dataflow,
    core::HugrNode,
    extension::simple_op::MakeExtensionOp,
    hugr::hugrmut::HugrMut,
    ops::OpType,
    std_extensions::collections::{
        array::{
            ArrayKind, ArrayOp, GenericArrayOp,
            GenericArrayOpDef::{self, *},
        },
        borrow_array::{BArrayFromArray, BArrayOp, BArrayToArray},
    },
};

impl<N: HugrNode> ModifierResolver<N> {
    /// Try to modify some known array operations.
    pub(super) fn modify_array_op(
        &mut self,
        h: &impl HugrMut<Node = N>,
        n: N,
        optype: &OpType,
        new_dfg: &mut impl Dataflow,
    ) -> Result<bool, ModifierResolverErrors<N>> {
        if let Some(op) = ArrayOp::from_optype(optype) {
            self.generic_modify_array_op(h, n, op, new_dfg)?;
        } else if let Some(op) = BArrayOp::from_optype(optype) {
            self.generic_modify_array_op(h, n, op, new_dfg)?;
        } else {
            return Ok(false);
        }

        Ok(true)
    }

    fn generic_modify_array_op<AK: ArrayKind>(
        &mut self,
        h: &impl HugrMut<Node = N>,
        n: N,
        op: GenericArrayOp<AK>,
        new_dfg: &mut impl Dataflow,
    ) -> Result<(), ModifierResolverErrors<N>> {
        let op_def = &op.def;
        if !self.modifiers().dagger {
            self.add_node_no_modification(h, n, op, new_dfg)?;
        } else {
            let new_op_def: GenericArrayOpDef<AK> = match op_def {
                swap => swap,
                new_array => unpack,
                unpack => new_array,
                _ => unimplemented!("Dagger for {op_def:?} is not implemented"),
            };
            let new_op = new_op_def.to_concrete(op.elem_ty, op.size);
            let node = new_dfg.add_child_node(new_op);
            for port in h.all_node_ports(n) {
                let wire = DirWire::new(node, port).reverse();
                self.map_insert(DirWire(n, port), wire)?;
            }
        }
        Ok(())
    }

    /// Try to modify some some known array conversion operations.
    /// The returned boolean indicates whether the operation is recognized
    /// as a known array conversion operation or not.
    /// If the returned value is true, the modification is done,
    /// otherwise modifier_resolver continues to try other modification methods.
    pub(super) fn try_array_convert(
        &mut self,
        h: &impl HugrMut<Node = N>,
        n: N,
        optype: &OpType,
        new_dfg: &mut impl Dataflow,
    ) -> Result<bool, ModifierResolverErrors<N>> {
        if !self.modifiers().dagger {
            self.add_node_no_modification(h, n, optype.clone(), new_dfg)?;
            return Ok(true);
        }

        let Some(op) = optype.as_extension_op() else {
            return Ok(false);
        };

        // try some general array convert
        let node = if let Ok(op) = BArrayToArray::from_extension_op(op) {
            new_dfg.add_child_node(BArrayFromArray::new(op.elem_ty, op.size))
        } else if let Ok(op) = BArrayFromArray::from_extension_op(op) {
            new_dfg.add_child_node(BArrayToArray::new(op.elem_ty, op.size))
        } else {
            return Ok(false);
        };

        for port in h.all_node_ports(n) {
            let wire = DirWire::new(node, port).reverse();
            self.map_insert(DirWire(n, port), wire)?;
        }

        Ok(true)
    }
}