Skip to content

gates

Gates.

Gate

Source code in jaxquantum/circuits/gates.py 
 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
149
150
151
152
153
154
155
156
157
158
159
160
161
@struct.dataclass
class Gate:
    dims: List[int] = struct.field(pytree_node=False)
    _U: Optional[Array] # Unitary
    _Ht: Optional[Array] # Hamiltonian
    _KM: Optional[Qarray] # Kraus map
    _c_ops: Optional[Qarray]
    _params: Dict[str, Any]
    _ts: Array
    _name: str = struct.field(pytree_node=False)
    num_modes: int = struct.field(pytree_node=False)

    @classmethod
    def create(
        cls,
        dims: Union[int, List[int]],
        name: str = "Gate",
        params: Optional[Dict[str, Any]] = None,
        ts: Optional[Array] = None,
        gen_U: Optional[Callable[[Dict[str, Any]], Qarray]] = None,
        gen_Ht: Optional[Callable[[Dict[str, Any]], Qarray]] = None,
        gen_c_ops: Optional[Callable[[Dict[str, Any]], Qarray]] = None,
        gen_KM: Optional[Callable[[Dict[str, Any]], List[Qarray]]] = None,
        num_modes: int = 1,
    ):
        """Create a gate.

        Args:
            dims: Dimensions of the gate.
            name: Name of the gate.
            params: Parameters of the gate.
            ts: Times of the gate.
            gen_U: Function to generate the unitary of the gate.
            gen_Ht: Function to generate a function Ht(t) that takes in a time t and outputs a Hamiltonian Qarray.
            gen_KM: Function to generate the Kraus map of the gate.
            num_modes: Number of modes of the gate.
        """

        # TODO: add params to device?

        if isinstance(dims, int):
            dims = [dims]

        assert len(dims) == num_modes, (
            "Number of dimensions must match number of modes."
        )

        # Unitary
        _U = gen_U(params) if gen_U is not None else None 
        _Ht = gen_Ht(params) if gen_Ht is not None else None 
        _c_ops = gen_c_ops(params) if gen_c_ops is not None else Qarray.from_list([])

        if gen_KM is not None:
            _KM = gen_KM(params)
        elif _U is not None:
            _KM = Qarray.from_list([_U])

        return Gate(
            dims = dims,
            _U = _U,
            _Ht = _Ht,
            _KM = _KM,
            _c_ops = _c_ops,
            _params = params if params is not None else {},
            _ts=ts if ts is not None else jnp.array([]),
            _name=name,
            num_modes=num_modes,
        )

    def __str__(self):
        return self._name

    def __repr__(self):
        return self._name

    @property
    def name(self):
        return self._name

    @property
    def U(self):
        return self._U

    @property
    def Ht(self):
        return self._Ht

    @property
    def KM(self):
        return self._KM

    @property
    def c_ops(self):
        return self._c_ops

    @property
    def params(self):
        return self._params

    @property
    def ts(self):
        return self._ts

    def add_Ht(self, Ht: Callable[[float], Qarray]):
        """Add a Hamiltonian function to the gate."""
        def new_Ht(t):
            return Ht(t) + self.Ht(t) if self.Ht is not None else Ht(t)

        return Gate(
            dims = self.dims,
            _U = self.U,
            _Ht = new_Ht,
            _KM = self.KM,
            _c_ops = self.c_ops,
            _params = self.params,
            _ts = self.ts,
            _name = self.name,
            num_modes = self.num_modes,
        )

    def add_c_ops(self, c_ops: Qarray):
        """Add a c_ops to the gate."""
        return Gate(
            dims = self.dims,
            _U = self.U,
            _Ht = self.Ht,
            _KM = self.KM,
            _c_ops = concatenate([self.c_ops, c_ops]),
            _params = self.params,
            _ts = self.ts,
            _name = self.name,
            num_modes = self.num_modes,
        )

    def copy(self):
        """Return a copy of the gate."""
        return Gate(
            dims = deepcopy(self.dims),
            _U = self.U,
            _Ht = deepcopy(self.Ht),
            _KM = self.KM,
            _c_ops = self.c_ops,
            _params = deepcopy(self.params),
            _ts = self.ts,
            _name = self.name,
            num_modes = self.num_modes,
        )

add_Ht(Ht)

Add a Hamiltonian function to the gate.

Source code in jaxquantum/circuits/gates.py 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
def add_Ht(self, Ht: Callable[[float], Qarray]):
    """Add a Hamiltonian function to the gate."""
    def new_Ht(t):
        return Ht(t) + self.Ht(t) if self.Ht is not None else Ht(t)

    return Gate(
        dims = self.dims,
        _U = self.U,
        _Ht = new_Ht,
        _KM = self.KM,
        _c_ops = self.c_ops,
        _params = self.params,
        _ts = self.ts,
        _name = self.name,
        num_modes = self.num_modes,
    )

add_c_ops(c_ops)

Add a c_ops to the gate.

Source code in jaxquantum/circuits/gates.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
def add_c_ops(self, c_ops: Qarray):
    """Add a c_ops to the gate."""
    return Gate(
        dims = self.dims,
        _U = self.U,
        _Ht = self.Ht,
        _KM = self.KM,
        _c_ops = concatenate([self.c_ops, c_ops]),
        _params = self.params,
        _ts = self.ts,
        _name = self.name,
        num_modes = self.num_modes,
    )

copy()

Return a copy of the gate.

Source code in jaxquantum/circuits/gates.py 
149
150
151
152
153
154
155
156
157
158
159
160
161
def copy(self):
    """Return a copy of the gate."""
    return Gate(
        dims = deepcopy(self.dims),
        _U = self.U,
        _Ht = deepcopy(self.Ht),
        _KM = self.KM,
        _c_ops = self.c_ops,
        _params = deepcopy(self.params),
        _ts = self.ts,
        _name = self.name,
        num_modes = self.num_modes,
    )

create(dims, name='Gate', params=None, ts=None, gen_U=None, gen_Ht=None, gen_c_ops=None, gen_KM=None, num_modes=1) classmethod

Create a gate.

Parameters:

Name Type Description Default
dims Union[int, List[int]]

Dimensions of the gate.

 required
name str

Name of the gate.

 'Gate'
params Optional[Dict[str, Any]]

Parameters of the gate.

 None
ts Optional[Array]

Times of the gate.

 None
gen_U Optional[Callable[[Dict[str, Any]], Qarray]]

Function to generate the unitary of the gate.

 None
gen_Ht Optional[Callable[[Dict[str, Any]], Qarray]]

Function to generate a function Ht(t) that takes in a time t and outputs a Hamiltonian Qarray.

 None
gen_KM Optional[Callable[[Dict[str, Any]], List[Qarray]]]

Function to generate the Kraus map of the gate.

 None
num_modes int

Number of modes of the gate.

 1
Source code in jaxquantum/circuits/gates.py 
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
@classmethod
def create(
    cls,
    dims: Union[int, List[int]],
    name: str = "Gate",
    params: Optional[Dict[str, Any]] = None,
    ts: Optional[Array] = None,
    gen_U: Optional[Callable[[Dict[str, Any]], Qarray]] = None,
    gen_Ht: Optional[Callable[[Dict[str, Any]], Qarray]] = None,
    gen_c_ops: Optional[Callable[[Dict[str, Any]], Qarray]] = None,
    gen_KM: Optional[Callable[[Dict[str, Any]], List[Qarray]]] = None,
    num_modes: int = 1,
):
    """Create a gate.

    Args:
        dims: Dimensions of the gate.
        name: Name of the gate.
        params: Parameters of the gate.
        ts: Times of the gate.
        gen_U: Function to generate the unitary of the gate.
        gen_Ht: Function to generate a function Ht(t) that takes in a time t and outputs a Hamiltonian Qarray.
        gen_KM: Function to generate the Kraus map of the gate.
        num_modes: Number of modes of the gate.
    """

    # TODO: add params to device?

    if isinstance(dims, int):
        dims = [dims]

    assert len(dims) == num_modes, (
        "Number of dimensions must match number of modes."
    )

    # Unitary
    _U = gen_U(params) if gen_U is not None else None 
    _Ht = gen_Ht(params) if gen_Ht is not None else None 
    _c_ops = gen_c_ops(params) if gen_c_ops is not None else Qarray.from_list([])

    if gen_KM is not None:
        _KM = gen_KM(params)
    elif _U is not None:
        _KM = Qarray.from_list([_U])

    return Gate(
        dims = dims,
        _U = _U,
        _Ht = _Ht,
        _KM = _KM,
        _c_ops = _c_ops,
        _params = params if params is not None else {},
        _ts=ts if ts is not None else jnp.array([]),
        _name=name,
        num_modes=num_modes,
    )