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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Passes to lower operations in a HUGR.

use hugr_core::{
    Hugr, Node,
    hugr::{hugrmut::HugrMut, views::SiblingSubgraph},
    ops::OpType,
};

use itertools::Itertools;
use thiserror::Error;

/// Replace all operations in a HUGR according to a mapping.
/// New operations must match the signature of the old operations.
///
/// Returns a list of the replaced nodes and their old operations.
pub fn replace_many_ops<S: Into<OpType>>(
    hugr: &mut impl HugrMut<Node = Node>,
    mapping: impl Fn(&OpType) -> Option<S>,
) -> Vec<(Node, OpType)> {
    let replacements = hugr
        .entry_descendants()
        .filter_map(|node| {
            let new_op = mapping(hugr.get_optype(node))?;
            Some((node, new_op))
        })
        .collect::<Vec<_>>();

    replacements
        .into_iter()
        .map(|(node, new_op)| {
            let old_op = hugr.replace_op(node, new_op);
            (node, old_op)
        })
        .collect()
}

/// Errors produced by the [`lower_ops`] function.
#[derive(Debug, Error)]
#[error(transparent)]
#[non_exhaustive]
pub enum LowerError {
    /// Invalid subgraph.
    #[error("Subgraph formed by node is invalid: {0}")]
    InvalidSubgraph(#[from] hugr_core::hugr::views::sibling_subgraph::InvalidSubgraph),
    /// Invalid replacement
    #[error("Lowered HUGR not a valid replacement: {0}")]
    InvalidReplacement(#[from] hugr_core::hugr::views::sibling_subgraph::InvalidReplacement),
    /// Rewrite error
    #[error("Rewrite error: {0}")]
    RewriteError(#[from] hugr_core::hugr::SimpleReplacementError),
}

/// Lower operations in a HUGR according to a mapping to a replacement HUGR.
///
/// # Errors
///
/// Returns a [`LowerError`] if the lowered HUGR is invalid or if any rewrite fails.
pub fn lower_ops(
    hugr: &mut impl HugrMut<Node = Node>,
    lowering: impl Fn(&OpType) -> Option<Hugr>,
) -> Result<Vec<(Node, OpType)>, LowerError> {
    let replacements = hugr
        .entry_descendants()
        .filter_map(|node| {
            let hugr = lowering(hugr.get_optype(node))?;
            Some((node, hugr))
        })
        .collect::<Vec<_>>();

    replacements
        .into_iter()
        .map(|(node, replacement)| {
            let subcirc = SiblingSubgraph::from_node(node, hugr);
            let rw = subcirc.create_simple_replacement(hugr, replacement)?;
            let removed_nodes = hugr.apply_patch(rw)?.removed_nodes;
            Ok(removed_nodes
                .into_iter()
                .exactly_one()
                .expect("removed exactly one node"))
        })
        .collect()
}

#[cfg(test)]
mod test {
    use hugr_core::{
        HugrView,
        builder::{DFGBuilder, Dataflow, DataflowHugr},
        extension::prelude::{Noop, bool_t},
        std_extensions::logic::LogicOp,
        types::Signature,
    };

    use super::*;
    use rstest::{fixture, rstest};

    #[fixture]
    fn noop_hugr() -> Hugr {
        let mut b = DFGBuilder::new(Signature::new_endo([bool_t()])).unwrap();
        let out = b
            .add_dataflow_op(Noop::new(bool_t()), [b.input_wires().next().unwrap()])
            .unwrap()
            .out_wire(0);
        b.finish_hugr_with_outputs([out]).unwrap()
    }

    #[fixture]
    fn identity_hugr() -> Hugr {
        let b = DFGBuilder::new(Signature::new_endo([bool_t()])).unwrap();
        let out = b.input_wires().next().unwrap();
        b.finish_hugr_with_outputs([out]).unwrap()
    }

    #[rstest]
    fn test_replace(noop_hugr: Hugr) {
        let mut h = noop_hugr;
        let mut replaced = replace_many_ops(&mut h, |op| {
            let noop = Noop::new(bool_t());
            if op.cast() == Some(noop) {
                Some(LogicOp::Not)
            } else {
                None
            }
        });

        assert_eq!(replaced.len(), 1);
        let (n, op) = replaced.remove(0);
        assert_eq!(op, Noop::new(bool_t()).into());
        assert_eq!(h.get_optype(n), &LogicOp::Not.into());
    }

    #[rstest]
    fn test_lower(noop_hugr: Hugr, identity_hugr: Hugr) {
        let mut h = noop_hugr;

        let lowered = lower_ops(&mut h, |op| {
            let noop = Noop::new(bool_t());
            if op.cast() == Some(noop) {
                Some(identity_hugr.clone())
            } else {
                None
            }
        });

        assert_eq!(lowered.unwrap().len(), 1);
        assert_eq!(h.entry_descendants().count(), 3); // DFG, input, output
    }
}