Skip to content

canonical_gate

CanonicalAxis

Bases: BaseAxis

Source code in opensquirrel/ir/semantics/canonical_gate.py 
 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
class CanonicalAxis(BaseAxis):
    restrict: bool = True

    @staticmethod
    def in_weyl_chamber(tx: float, ty: float, tz: float) -> bool:
        """Checks if the canonical axis is in the Weyl chamber.

        Returns:
            True if the canonical axis is in the Weyl chamber, False otherwise.

        """
        return 1 / 2 >= tx >= ty >= tz >= 0 or 1 / 2 >= (1 - tx) >= ty >= tz > 0

    @staticmethod
    def parse(axis: AxisLike) -> NDArray[np.float64]:
        """Parse and validate an `AxisLike`.

        Checks if the axis can be cast to a 1DArray of length 3, raise an error otherwise.
        After casting to an array, the elements of the canonical axis are restricted to the Weyl chamber.

        Args:
            axis (AxisLike): Axis to validate and parse.

        Returns:
            Parsed axis to 1DArray of length 3.

        Raises:
            TypeError: If the axis cannot be cast to an ArrayLike.
            ValueError: If the axis cannot be flattened to length 3.

        """

        if isinstance(axis, CanonicalAxis):
            return axis.value

        try:
            axis = np.asarray(axis, dtype=float)
        except (ValueError, TypeError) as e:
            msg = "axis requires an ArrayLike"
            raise TypeError(msg) from e
        axis = axis.flatten()
        if len(axis) != 3:
            msg = f"axis has size {len(axis)!r}: requires an ArrayLike of length 3"
            raise ValueError(msg)
        if CanonicalAxis.restrict:
            return CanonicalAxis.restrict_to_weyl_chamber(axis)
        return axis

    @staticmethod
    def restrict_to_weyl_chamber(axis: NDArray[np.float64]) -> NDArray[np.float64]:
        """Restricts the given axis to the Weyl chamber.

        The six rules that are (implicitly) used are:

        1. The canonical parameters are periodic with a period of 2 (neglecting
            a global phase).
        2. $\\text{Can}(t_x, t_y, t_z)\\sim\\text{Can}(t_x - 1, t_y, t_z)$ (for any parameter)
        3. $\\text{Can}(t_x, t_y, t_z)\\sim\\text{Can}(t_x, -t_y, -t_z)$ (for any pair of parameters)
        4. $\\text{Can}(t_x, t_y, t_z)\\sim\\text{Can}(t_y, t_x, t_z)$ (for any pair of parameters)
        5. $\\text{Can}(t_x, t_y, 0)\\sim\\text{Can}(1 - t_x, t_y, 0)$
        6. $\\text{Can}(t_x, t_y, t_z) * \\text{Can}(t_x', t_y', t_z') =
        \\text{Can}(t_x + t_x', t_y + t_y', t_z + t_z')$

        Note:
            Based on the rules described in
            [Quantum Gates by G.E. Crooks (2024), Section 5](https://threeplusone.com/pubs/on_gates.pdf).

        Args:
            axis (NDArray[np.float64]): Axis to restrict to the Weyl chamber.

        Returns:
           Axis restricted to the Weyl chamber.

        """
        axis = (axis + 1) % 2 - 1

        if CanonicalAxis.in_weyl_chamber(*axis):
            return axis

        while (axis < 0).any():
            axis = np.where(axis < 0, axis - 1, axis)
            axis = (axis + 1) % 2 - 1

        axis = np.sort(axis)[::-1]
        match sum(t > 1 / 2 for t in axis):
            case 1:
                axis[0] = 1 - axis[0]
            case 2:
                axis[0], axis[2] = axis[2], axis[0]
                axis[1:] = 1 - axis[1:]
            case 3:
                axis = 1 - axis

        return np.sort(axis)[::-1]

    def accept(self, visitor: IRVisitor) -> Any:
        """Accepts visitor and processes this IR node."""
        return visitor.visit_canonical_axis(self)

accept 

accept(visitor: IRVisitor) -> Any

Accepts visitor and processes this IR node.

Source code in opensquirrel/ir/semantics/canonical_gate.py 
111
112
113
def accept(self, visitor: IRVisitor) -> Any:
    """Accepts visitor and processes this IR node."""
    return visitor.visit_canonical_axis(self)

in_weyl_chamber staticmethod 

in_weyl_chamber(tx: float, ty: float, tz: float) -> bool

Checks if the canonical axis is in the Weyl chamber.

Returns:

Type Description
bool

True if the canonical axis is in the Weyl chamber, False otherwise.
Source code in opensquirrel/ir/semantics/canonical_gate.py 
19
20
21
22
23
24
25
26
27
@staticmethod
def in_weyl_chamber(tx: float, ty: float, tz: float) -> bool:
    """Checks if the canonical axis is in the Weyl chamber.

    Returns:
        True if the canonical axis is in the Weyl chamber, False otherwise.

    """
    return 1 / 2 >= tx >= ty >= tz >= 0 or 1 / 2 >= (1 - tx) >= ty >= tz > 0

parse staticmethod 

parse(axis: AxisLike) -> NDArray[np.float64]

Parse and validate an AxisLike.

Checks if the axis can be cast to a 1DArray of length 3, raise an error otherwise. After casting to an array, the elements of the canonical axis are restricted to the Weyl chamber.

Parameters:

Name Type Description Default
axis AxisLike

Axis to validate and parse.

 required

Returns:

Type Description
NDArray[float64]

Parsed axis to 1DArray of length 3.

Raises:

Type Description
TypeError

If the axis cannot be cast to an ArrayLike.
ValueError

If the axis cannot be flattened to length 3.
Source code in opensquirrel/ir/semantics/canonical_gate.py 
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
@staticmethod
def parse(axis: AxisLike) -> NDArray[np.float64]:
    """Parse and validate an `AxisLike`.

    Checks if the axis can be cast to a 1DArray of length 3, raise an error otherwise.
    After casting to an array, the elements of the canonical axis are restricted to the Weyl chamber.

    Args:
        axis (AxisLike): Axis to validate and parse.

    Returns:
        Parsed axis to 1DArray of length 3.

    Raises:
        TypeError: If the axis cannot be cast to an ArrayLike.
        ValueError: If the axis cannot be flattened to length 3.

    """

    if isinstance(axis, CanonicalAxis):
        return axis.value

    try:
        axis = np.asarray(axis, dtype=float)
    except (ValueError, TypeError) as e:
        msg = "axis requires an ArrayLike"
        raise TypeError(msg) from e
    axis = axis.flatten()
    if len(axis) != 3:
        msg = f"axis has size {len(axis)!r}: requires an ArrayLike of length 3"
        raise ValueError(msg)
    if CanonicalAxis.restrict:
        return CanonicalAxis.restrict_to_weyl_chamber(axis)
    return axis

restrict_to_weyl_chamber staticmethod 

restrict_to_weyl_chamber(
    axis: NDArray[float64],
) -> NDArray[np.float64]

Restricts the given axis to the Weyl chamber.

The six rules that are (implicitly) used are:

  1. The canonical parameters are periodic with a period of 2 (neglecting a global phase).
  2. \(\text{Can}(t_x, t_y, t_z)\sim\text{Can}(t_x - 1, t_y, t_z)\) (for any parameter)
  3. \(\text{Can}(t_x, t_y, t_z)\sim\text{Can}(t_x, -t_y, -t_z)\) (for any pair of parameters)
  4. \(\text{Can}(t_x, t_y, t_z)\sim\text{Can}(t_y, t_x, t_z)\) (for any pair of parameters)
  5. \(\text{Can}(t_x, t_y, 0)\sim\text{Can}(1 - t_x, t_y, 0)\)
  6. \(\text{Can}(t_x, t_y, t_z) * \text{Can}(t_x', t_y', t_z') = \text{Can}(t_x + t_x', t_y + t_y', t_z + t_z')\)
Note

Based on the rules described in Quantum Gates by G.E. Crooks (2024), Section 5.

Parameters:

Name Type Description Default
axis NDArray[float64]

Axis to restrict to the Weyl chamber.

 required

Returns:

Type Description
NDArray[float64]

Axis restricted to the Weyl chamber.
Source code in opensquirrel/ir/semantics/canonical_gate.py 
 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
@staticmethod
def restrict_to_weyl_chamber(axis: NDArray[np.float64]) -> NDArray[np.float64]:
    """Restricts the given axis to the Weyl chamber.

    The six rules that are (implicitly) used are:

    1. The canonical parameters are periodic with a period of 2 (neglecting
        a global phase).
    2. $\\text{Can}(t_x, t_y, t_z)\\sim\\text{Can}(t_x - 1, t_y, t_z)$ (for any parameter)
    3. $\\text{Can}(t_x, t_y, t_z)\\sim\\text{Can}(t_x, -t_y, -t_z)$ (for any pair of parameters)
    4. $\\text{Can}(t_x, t_y, t_z)\\sim\\text{Can}(t_y, t_x, t_z)$ (for any pair of parameters)
    5. $\\text{Can}(t_x, t_y, 0)\\sim\\text{Can}(1 - t_x, t_y, 0)$
    6. $\\text{Can}(t_x, t_y, t_z) * \\text{Can}(t_x', t_y', t_z') =
    \\text{Can}(t_x + t_x', t_y + t_y', t_z + t_z')$

    Note:
        Based on the rules described in
        [Quantum Gates by G.E. Crooks (2024), Section 5](https://threeplusone.com/pubs/on_gates.pdf).

    Args:
        axis (NDArray[np.float64]): Axis to restrict to the Weyl chamber.

    Returns:
       Axis restricted to the Weyl chamber.

    """
    axis = (axis + 1) % 2 - 1

    if CanonicalAxis.in_weyl_chamber(*axis):
        return axis

    while (axis < 0).any():
        axis = np.where(axis < 0, axis - 1, axis)
        axis = (axis + 1) % 2 - 1

    axis = np.sort(axis)[::-1]
    match sum(t > 1 / 2 for t in axis):
        case 1:
            axis[0] = 1 - axis[0]
        case 2:
            axis[0], axis[2] = axis[2], axis[0]
            axis[1:] = 1 - axis[1:]
        case 3:
            axis = 1 - axis

    return np.sort(axis)[::-1]

CanonicalGateSemantic

Bases: GateSemantic

Source code in opensquirrel/ir/semantics/canonical_gate.py 
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
149
150
151
152
153
154
155
156
157
158
159
160
class CanonicalGateSemantic(GateSemantic):
    def __init__(self, axis: AxisLike, rotations: list[BlochSphereRotation] | None = None) -> None:
        self.axis = CanonicalAxis(axis)
        self.rotations = rotations
        if self.rotations and len(self.rotations) != 4:
            msg = f"invalid number of rotations, expected 4 but got {len(self.rotations)}"
            raise ValueError(msg)

    def accept(self, visitor: IRVisitor) -> Any:
        """Accepts visitor and processes this IR node."""
        return visitor.visit_canonical_gate_semantic(self)

    def is_identity(self) -> bool:
        """Checks if the canonical gate semantic represents an identity operation.

        Returns:
            True if the canonical gate semantic represents an identity operation, False otherwise.

        """
        if not self.rotations:
            return self.axis == CanonicalAxis((0, 0, 0))
        return self.axis == CanonicalAxis((0, 0, 0)) and all(rotation.is_identity() for rotation in self.rotations)

    def __eq__(self, other: Any) -> bool:
        """Checks if two CanonicalGateSemantic instances are equal.

        Returns:
            True if both have the same axis and rotations, False otherwise.

        """
        if not isinstance(other, CanonicalGateSemantic):
            return False
        if not self.axis == other.axis:
            return False
        if self.rotations is None and other.rotations is None:
            return True
        if self.rotations is None or other.rotations is None:
            return False
        return len(self.rotations) == len(other.rotations) and all(
            r1 == r2 for r1, r2 in zip(self.rotations, other.rotations, strict=False)
        )

    def __repr__(self) -> str:
        rotation_str = f", rotations={self.rotations}" if self.rotations else ""
        return f"CanonicalGateSemantic(axis={self.axis}{rotation_str})"

__eq__ 

__eq__(other: Any) -> bool

Checks if two CanonicalGateSemantic instances are equal.

Returns:

Type Description
bool

True if both have the same axis and rotations, False otherwise.
Source code in opensquirrel/ir/semantics/canonical_gate.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
def __eq__(self, other: Any) -> bool:
    """Checks if two CanonicalGateSemantic instances are equal.

    Returns:
        True if both have the same axis and rotations, False otherwise.

    """
    if not isinstance(other, CanonicalGateSemantic):
        return False
    if not self.axis == other.axis:
        return False
    if self.rotations is None and other.rotations is None:
        return True
    if self.rotations is None or other.rotations is None:
        return False
    return len(self.rotations) == len(other.rotations) and all(
        r1 == r2 for r1, r2 in zip(self.rotations, other.rotations, strict=False)
    )

accept 

accept(visitor: IRVisitor) -> Any

Accepts visitor and processes this IR node.

Source code in opensquirrel/ir/semantics/canonical_gate.py 
124
125
126
def accept(self, visitor: IRVisitor) -> Any:
    """Accepts visitor and processes this IR node."""
    return visitor.visit_canonical_gate_semantic(self)

is_identity 

is_identity() -> bool

Checks if the canonical gate semantic represents an identity operation.

Returns:

Type Description
bool

True if the canonical gate semantic represents an identity operation, False otherwise.
Source code in opensquirrel/ir/semantics/canonical_gate.py 
128
129
130
131
132
133
134
135
136
137
def is_identity(self) -> bool:
    """Checks if the canonical gate semantic represents an identity operation.

    Returns:
        True if the canonical gate semantic represents an identity operation, False otherwise.

    """
    if not self.rotations:
        return self.axis == CanonicalAxis((0, 0, 0))
    return self.axis == CanonicalAxis((0, 0, 0)) and all(rotation.is_identity() for rotation in self.rotations)