Skip to content

oscillator

Oscillator gates.

Amp_Damp(N, err_prob, max_l)

Amplitude damping channel.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
err_prob

Error probability.

 required
max_l

Maximum number of photons lost.

 required

Returns:

Type Description

Amplitude damping channel.
Source code in jaxquantum/circuits/library/oscillator.py 
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
def Amp_Damp(N, err_prob, max_l):
    """Amplitude damping channel.

    Args:
        N: Hilbert space dimension.
        err_prob: Error probability.
        max_l: Maximum number of photons lost.

    Returns:
        Amplitude damping channel.
    """
    kmap = lambda params: Qarray.from_list(
        [_Ph_Loss_Kraus_Op(N, err_prob, l) for l in range(max_l + 1)]
    )
    return Gate.create(
        N,
        name="Amp_Damp",
        params={"err_prob": err_prob, "max_l": max_l},
        gen_KM=kmap,
        num_modes=1,
    )

Amp_Gain(N, err_prob, max_l)

Amplitude gain channel.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
err_prob

Error probability.

 required
max_l

Maximum number of photons gained.

 required

Returns:

Type Description

Amplitude gain channel.
Source code in jaxquantum/circuits/library/oscillator.py 
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
def Amp_Gain(N, err_prob, max_l):
    """Amplitude gain channel.

    Args:
        N: Hilbert space dimension.
        err_prob: Error probability.
        max_l: Maximum number of photons gained.

    Returns:
        Amplitude gain channel.
    """
    kmap = lambda params: Qarray.from_list(
        [_Ph_Gain_Kraus_Op(N, err_prob, l) for l in range(max_l + 1)]
    )
    return Gate.create(
        N,
        name="Amp_Gain",
        params={"err_prob": err_prob, "max_l": max_l},
        gen_KM=kmap,
        num_modes=1,
    )

CD(N, beta, ts=None)

Conditional displacement gate.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
beta

Conditional displacement amplitude.

 required
ts

Optional time sequence for hamiltonian simulation.

 None

Returns:

Type Description

Conditional displacement gate.
Source code in jaxquantum/circuits/library/oscillator.py 
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
def CD(N, beta, ts=None):
    """Conditional displacement gate.

    Args:
        N: Hilbert space dimension.
        beta: Conditional displacement amplitude.
        ts: Optional time sequence for hamiltonian simulation.

    Returns:
        Conditional displacement gate.
    """
    g = basis(2, 0)
    e = basis(2, 1)

    gg = g @ g.dag()
    ee = e @ e.dag()

    gen_Ht = None
    if ts is not None:
        delta_t = ts[-1] - ts[0]
        amp = 1j * beta / delta_t / 2
        a = destroy(N)
        gen_Ht = lambda params: lambda t: (
            gg
            ^ (jnp.conj(amp) * a + amp * a.dag()) + ee
            ^ (jnp.conj(-amp) * a + (-amp) * a.dag())
        )

    return Gate.create(
        [2, N],
        name="CD",
        params={"beta": beta},
        gen_U=lambda params: (gg ^ displace(N, params["beta"] / 2))
        + (ee ^ displace(N, -params["beta"] / 2)),
        gen_Ht=gen_Ht,
        ts=ts,
        num_modes=2,
    )

CR(N, theta)

Conditional rotation gate.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
theta

Conditional rotation angle.

 required

Returns:

Type Description

Conditional rotation gate.
Source code in jaxquantum/circuits/library/oscillator.py 
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
def CR(N, theta):
    """Conditional rotation gate.

    Args:
        N: Hilbert space dimension.
        theta: Conditional rotation angle.

    Returns:
        Conditional rotation gate.
    """
    g = basis(2, 0)
    e = basis(2, 1)

    gg = g @ g.dag()
    ee = e @ e.dag()


    return Gate.create(
        [2, N],
        name="CR",
        params={"theta": theta},
        gen_U=lambda params: (gg ^ (-1.j*theta/2*create(N)@destroy(N)).expm())
        + (ee ^ (1.j*theta/2*create(N)@destroy(N)).expm()),
        num_modes=2,
    )

D(N, alpha, ts=None, c_ops=None)

Displacement gate.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
alpha

Displacement amplitude.

 required
ts

Optional time array for hamiltonian simulation.

 None
c_ops

Optional collapse operators.

 None

Returns:

Type Description

Displacement gate.
Source code in jaxquantum/circuits/library/oscillator.py 
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
def D(N, alpha, ts=None, c_ops=None):
    """Displacement gate.

    Args:
        N: Hilbert space dimension.
        alpha: Displacement amplitude.
        ts: Optional time array for hamiltonian simulation.
        c_ops: Optional collapse operators.

    Returns:
        Displacement gate.
    """
    gen_Ht = None
    if ts is not None:
        delta_t = ts[-1] - ts[0]
        amp = 1j * alpha / delta_t
        a = destroy(N)
        gen_Ht = lambda params: (lambda t: jnp.conj(amp) * a + amp * a.dag())

    return Gate.create(
        N,
        name="D",
        params={"alpha": alpha},
        gen_U=lambda params: displace(N, params["alpha"]),
        gen_Ht=gen_Ht,
        ts=ts,
        gen_c_ops=lambda params: Qarray.from_list([]) if c_ops is None else c_ops,
        num_modes=1,
    )

Dephasing_Ch(N, err_prob, max_l)

Dephasing channel.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
err_prob

Error probability.

 required
max_l

Maximum number of kraus operators.

 required

Returns:

Type Description

Dephasing channel.
Source code in jaxquantum/circuits/library/oscillator.py 
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
def Dephasing_Ch(N, err_prob, max_l):
    """Dephasing channel.

    Args:
        N: Hilbert space dimension.
        err_prob: Error probability.
        max_l: Maximum number of kraus operators.

    Returns:
        Dephasing channel.
    """

    xs, ws = hermgauss(max_l)
    phis = jnp.sqrt(2*err_prob)*xs
    ws = 1/jnp.sqrt(jnp.pi)*ws

    kmap = lambda params: Qarray.from_list(
        [_Dephasing_Kraus_Op(N, w, phi) for (w, phi) in zip(ws, phis)]
    )
    return Gate.create(
        N,
        name="Amp_Gain",
        params={"err_prob": err_prob, "max_l": max_l},
        gen_KM=kmap,
        num_modes=1,
    )

Dephasing_Reset(N, p, t_rst, chi, max_l)

Dephasing due to imperfect reset between a qubit and a resonator.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
p

Reset error probability.

 required
t_rst

Reset time.

 required
chi

Dephasing strength.

 required
max_l

Maximum number of operators.

 required

Returns:

Type Description

Dephasing due to reset channel.
Source code in jaxquantum/circuits/library/oscillator.py 
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
def Dephasing_Reset(N, p, t_rst, chi, max_l):
    """Dephasing due to imperfect reset between a qubit and a resonator.

    Args:
        N: Hilbert space dimension.
        p: Reset error probability.
        t_rst: Reset time.
        chi: Dephasing strength.
        max_l: Maximum number of operators.

    Returns:
        Dephasing due to reset channel.
    """

    kmap = lambda params: Qarray.from_list(
        [_Reset_Deph_Kraus_Op(N, p, t_rst, chi, l, max_l) for l in
         range(max_l)]
    )
    return Gate.create(
        [2, N],
        name="Dephasing_Reset",
        params={"p": p, "t_rst": t_rst, "chi": chi, "max_l": max_l},
        gen_KM=kmap,
        num_modes=2,
    )

ECD(N, beta, ts=None)

Echoed conditional displacement gate.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
beta

Conditional displacement amplitude.

 required
ts

Optional time sequence for hamiltonian simulation.

 None

Returns:

Type Description

Echoed conditional displacement gate.
Source code in jaxquantum/circuits/library/oscillator.py 
 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
def ECD(N, beta, ts=None):
    """Echoed conditional displacement gate.

    Args:
        N: Hilbert space dimension.
        beta: Conditional displacement amplitude.
        ts: Optional time sequence for hamiltonian simulation.

    Returns:
        Echoed conditional displacement gate.
    """
    g = basis(2, 0)
    e = basis(2, 1)

    eg = e @ g.dag()
    ge = g @ e.dag()

    # gen_Ht = None
    # if ts is not None:
    #     delta_t = ts[-1] - ts[0]
    #     amp = 1j * beta / delta_t / 2
    #     a = destroy(N)
    #     gen_Ht = lambda params: lambda t: (
    #         eg
    #         ^ (jnp.conj(amp) * a + amp * a.dag()) + ge
    #         ^ (jnp.conj(-amp) * a + (-amp) * a.dag())
    #     )

    return Gate.create(
        [2, N],
        name="ECD",
        params={"beta": beta},
        gen_U=lambda params: (eg ^ displace(N, params["beta"] / 2))
        + (ge ^ displace(N, -params["beta"] / 2)),
        gen_Ht=None,
        ts=ts,
        num_modes=2,
    )

Thermal_Ch(N, err_prob, n_bar, max_l)

Thermal channel.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
err_prob

Error probability.

 required
n_bar

Average photon number.

 required
max_l

Maximum number of photons gained/lost.

 required

Returns:

Type Description

Thermal channel.
Source code in jaxquantum/circuits/library/oscillator.py 
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
def Thermal_Ch(N, err_prob, n_bar, max_l):
    """Thermal channel.

    Args:
        N: Hilbert space dimension.
        err_prob: Error probability.
        n_bar: Average photon number.
        max_l: Maximum number of photons gained/lost.

    Returns:
        Thermal channel.
    """
    kmap = lambda params: Qarray.from_list(
        [
            _Thermal_Kraus_Op(N, err_prob, n_bar, l, k)
            for l in range(max_l + 1)
            for k in range(max_l + 1)
        ]
    )
    return Gate.create(
        N,
        name="Thermal_Ch",
        params={"err_prob": err_prob, "n_bar": n_bar, "max_l": max_l},
        gen_KM=kmap,
        num_modes=1,
    )

selfKerr(N, K)

Self-Kerr interaction gate.

Parameters:

Name Type Description Default
N

Hilbert space dimension.

 required
K

Kerr coefficient.

 required

Returns:

Type Description

Self-Kerr gate.
Source code in jaxquantum/circuits/library/oscillator.py 
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
def selfKerr(N, K):
    """Self-Kerr interaction gate.

    Args:
        N: Hilbert space dimension.
        K: Kerr coefficient.

    Returns:
        Self-Kerr gate.
    """
    a = destroy(N)
    return Gate.create(
        N,
        name="selfKerr",
        params={"Kerr": K},
        gen_U=lambda params: (-1.0j * K / 2 * (a.dag() @ a.dag() @ a @ a)).expm(),
        num_modes=1,
    )