dq.create

create(*dims: int, layout: Layout | None = None) -> QArray | tuple[QArray, ...]

Returns a bosonic creation operator, or a tuple of creation operators for a multi-mode system.

If multiple dimensions are provided $\mathtt{dims}=(n_1,\dots,n_N)$, it returns a tuple with len(dims) operators $(A_1^\dag,\dots,A_N^\dag)$, where $A_k^\dag$ is the creation operator acting on the $k$-th subsystem within the composite Hilbert space of dimension $n=\prod n_k$: $$A_k^\dag = I_{n_1} \otimes\dots\otimes a_{n_k}^\dag \otimes\dots\otimes I_{n_N}.$$

Parameters

• *dims –

  Hilbert space dimension of each mode.

• layout –

  Matrix layout (dq.dense, dq.dia or None).

Returns

(qarray or tuple of qarrays, each of shape (n, n)) Creation operator(s), with n = prod(dims).

Examples

Single-mode $a^\dag$:

>>> dq.create(4)
QArray: shape=(4, 4), dims=(4,), dtype=complex64, layout=dia, ndiags=1
[[    ⋅         ⋅         ⋅         ⋅    ]
 [1.   +0.j     ⋅         ⋅         ⋅    ]
 [    ⋅     1.414+0.j     ⋅         ⋅    ]
 [    ⋅         ⋅     1.732+0.j     ⋅    ]]

Multi-mode $a^\dag\otimes I_3$ and $I_2\otimes b^\dag$:

>>> adag, bdag = dq.create(2, 3)
>>> adag
QArray: shape=(6, 6), dims=(2, 3), dtype=complex64, layout=dia, ndiags=1
[[  ⋅      ⋅      ⋅      ⋅      ⋅      ⋅   ]
 [  ⋅      ⋅      ⋅      ⋅      ⋅      ⋅   ]
 [  ⋅      ⋅      ⋅      ⋅      ⋅      ⋅   ]
 [1.+0.j   ⋅      ⋅      ⋅      ⋅      ⋅   ]
 [  ⋅    1.+0.j   ⋅      ⋅      ⋅      ⋅   ]
 [  ⋅      ⋅    1.+0.j   ⋅      ⋅      ⋅   ]]
>>> bdag
QArray: shape=(6, 6), dims=(2, 3), dtype=complex64, layout=dia, ndiags=1
[[    ⋅         ⋅         ⋅         ⋅         ⋅         ⋅    ]
 [1.   +0.j     ⋅         ⋅         ⋅         ⋅         ⋅    ]
 [    ⋅     1.414+0.j     ⋅         ⋅         ⋅         ⋅    ]
 [    ⋅         ⋅         ⋅         ⋅         ⋅         ⋅    ]
 [    ⋅         ⋅         ⋅     1.   +0.j     ⋅         ⋅    ]
 [    ⋅         ⋅         ⋅         ⋅     1.414+0.j     ⋅    ]]