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

//! Module for richer circuit representation and operations.
//! This module provides three extensions: modifiers, global phase, and safe drop.
//!
//! ## Modifiers
//! Modifiers are functions that takes circuits and return modified circuits
//! by applying modifiers: control, dagger, or power.
//!
//! ## Global Phase
//! Global phase is an operation that applies some global phase to a circuit.
//! It is implemented as a side-effect that takes a rotation angle as an input.

use hugr::{
    HugrView, core::HugrNode, extension::simple_op::MakeExtensionOp, hugr::hugrmut::HugrMut,
    ops::ExtensionOp,
};

use crate::extension::modifier::Modifier;
pub mod control;
pub mod dagger;
pub mod modifier_resolver;
pub mod power;

use crate::metadata;

/// An accumulated modifier that combines control, dagger, and power modifiers.
#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
pub struct CombinedModifier {
    // Number of all control qubits
    control: usize,
    // Control arrays applied so far
    // The sum is supposed to be equal to `control`.
    accum_ctrl: Vec<usize>,
    /// Whether the dagger modifier has been applied.
    dagger: bool,
    /// Whether the power modifier has been applied.
    power: bool,
}

impl CombinedModifier {
    /// Add a modifier
    pub fn push(&mut self, ext_op: &ExtensionOp) {
        match Modifier::from_extension_op(ext_op) {
            Ok(Modifier::ControlModifier) => {
                let ctrl = ext_op.args()[0].as_nat().unwrap() as usize;
                self.control += ctrl;
                self.accum_ctrl.push(ctrl);
            }
            Ok(Modifier::DaggerModifier) => self.dagger = !self.dagger,
            Ok(Modifier::PowerModifier) => self.power = !self.power,
            Err(_) => {}
        }
    }
}

/// Flags for each modifier.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct ModifierFlags {
    control: bool,
    dagger: bool,
    power: bool,
}

impl ModifierFlags {
    fn from_metadata<N: HugrNode>(h: &impl HugrView<Node = N>, n: N) -> Option<Self> {
        h.get_metadata::<metadata::Unitary>(n)
            .map(|num| ModifierFlags {
                dagger: (num & 1) != 0,
                control: (num & 2) != 0,
                power: (num & 4) != 0,
            })
    }

    fn set_metadata<N: HugrNode>(&self, h: &mut impl HugrMut<Node = N>, n: N) {
        let mut num = 0;
        if self.dagger {
            num |= 1;
        }
        if self.control {
            num |= 2;
        }
        if self.power {
            num |= 4;
        }
        h.set_metadata::<metadata::Unitary>(n, num);
    }

    fn satisfies(&self, combined: &CombinedModifier) -> bool {
        (combined.control == 0 || self.control)
            && (!combined.dagger || self.dagger)
            && (!combined.power || self.power)
    }

    fn from_combined(combined: &CombinedModifier) -> Self {
        ModifierFlags {
            control: combined.control > 0,
            dagger: combined.dagger,
            power: combined.power,
        }
    }

    fn or(self, other: &Option<Self>) -> Self {
        match other {
            None => self,
            Some(other) => ModifierFlags {
                control: self.control || other.control,
                dagger: self.dagger || other.dagger,
                power: self.power || other.power,
            },
        }
    }
}