"""
********************************************************************************
* Copyright (c) 2025 the Qrisp authors
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the Eclipse
* Public License, v. 2.0 are satisfied: GNU General Public License, version 2
* with the GNU Classpath Exception which is
* available at https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
********************************************************************************
"""
import copy
from itertools import product
import numpy as np
import jax.numpy as jnp
import jax
from qrisp.circuit import transpile
from qrisp.core import QuantumVariable, qompiler, QuantumSession, merge
from qrisp.misc import bin_rep
from qrisp.jasp import (
check_for_tracing_mode,
q_fori_loop,
jrange,
create_qubits,
DynamicQubitArray,
TracingQuantumSession,
)
[docs]
class QuantumArray:
"""
This class allows the convenient management of multiple :ref:`QuantumVariables <QuantumVariable>` of one
type. Inspired by the well known
`numpy ndarray <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.html>`_, the
QuantumArray supports many convenient array manipulation methods. Similar to the
numpy equivalent, creating a QuantumArray can be achieved by specifying a shape and
a ``qtype``:
>>> import numpy as np
>>> from qrisp import QuantumArray, QuantumFloat
>>> qtype = QuantumFloat(5, -2)
>>> q_array = QuantumArray(qtype = qtype, shape = (2, 2, 2))
Note that ``qtype`` is not a type object but a QuantumVariable which serves as an
"example".
To retrieve the entries (i.e. QuantumVariables) from the QuantumArray, we simply
index as with regular numpy arrays:
>>> from qrisp import h
>>> qv = q_array[0,0,1]
>>> h(qv[0])
>>> print(q_array)
{OutcomeArray([[[0., 0.],
[0., 0.]],
[[0., 0.],
[0., 0.]]]): 0.5,
OutcomeArray([[[0. , 0.25],
[0. , 0. ]],
[[0. , 0. ],
[0. , 0. ]]]): 0.5}
We see the value 0.25 in the second entry because we applied an H-gate onto the 0-th
qubit of the QuantumVariable at position (0,0,1). Since the type of this array is a
QuantumFloat, with exponent -2, the significance of this qubit is 0.25.
Note that the keys of the dictionary returned by the get_measurement method are no
regular numpy arrays, as key objects need to be hashable. Instead, they are objects
of an immutable subclass of np.ndarray called OutcomeArray, that supports hashing.
For QuantumArrays, many methods known from numpy arrays work here too:
>>> q_array = q_array.reshape(2,4)
Not only do the ndarray methods work but also many other convenience functions from
the numpy module:
>>> q_array_swap = np.swapaxes(q_array, 0, 1)
>>> print(q_array_swap)
{OutcomeArray([[0., 0.],
[0., 0.],
[0., 0.],
[0., 0.]]): 0.5,
OutcomeArray([[0. , 0. ],
[0.25, 0. ],
[0. , 0. ],
[0. , 0. ]]): 0.5}
To initiate the array, we use the :meth:`encode <qrisp.QuantumArray.encode>` method.
Similar to QuantumVariables, we can also use the slicing operator, but this time
non-trivial slices are possible as well:
>>> q_array[1:,:] = 2*np.ones((1,4))
>>> print(q_array)
{OutcomeArray([[0., 0., 0., 0.],
[2., 2., 2., 2.]]): 0.5,
OutcomeArray([[0. , 0.25, 0. , 0. ],
[2. , 2. , 2. , 2. ]]): 0.5}
**Quantum indexing**
QuantumArrays can be dereferenced by :ref:`QuantumFloats <QuantumFloat>`. This
returns a :ref:`QuantumEnvironment <QuantumEnvironment>` in which the corresponding entry is avaliable as
a QuantumVariable. ::
from qrisp import QuantumBool, QuantumArray, QuantumFloat, h, x, multi_measurement
q_array = QuantumArray(QuantumFloat(1), shape = (4,4))
index_0 = QuantumFloat(2)
index_1 = QuantumFloat(2)
index_0[:] = 2
index_1[:] = 1
h(index_0[0])
with q_array[index_0, index_1] as entry:
x(entry)
>>> print(multi_measurement([index_0, index_1, q_array]))
{(2, 1, OutcomeArray([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 0., 0.]])): 0.5,
(3, 1, OutcomeArray([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 1., 0., 0.]])): 0.5}
.. note::
This only works for arrays which have a size of an integer power of 2.
**Matrix multiplication**
For QuantumArrays with ``qtype`` QuantumFloat, matrix multiplication is available.
>>> q_array_1 = QuantumArray(qtype, (2,2))
>>> q_array_2 = QuantumArray(qtype, (2,2))
>>> q_array_1[:] = 2*np.eye(2)
>>> q_array_2[:] = [[1,2],[3,4]]
>>> print(q_array_1 @ q_array_2)
{OutcomeArray([[2., 4.],
[6., 0.]]): 1.0}
.. note::
By default, the output matrix will have the same ``qtype`` as the first input
matrix. Here, the ``qtype`` is a QuantumFloat with 5 mantissa bits and exponent
-2, implying that the result 8 yields overflow. Since qrisps unsigend arithmetic
is modular, we get a 0.
It is also possible to multiply classical and quantum matrices
>>> q_array = QuantumArray(qtype, (2,2))
>>> q_array[:] = 3*np.eye(2)
>>> cl_array = np.array([[1,2],[3,4]])
>>> print(q_array @ cl_array)
{OutcomeArray([[3., 6.],
[1., 4.]]): 1.0}
"""
def __init__(self, qtype, shape, qs=None):
if isinstance(shape, int):
shape = (shape,)
size = 1
for s in shape:
if not isinstance(s, int):
raise Exception(
f"Tried to create QuantumArray with non-integer tuple {shape}"
)
size *= s
# The idea to implement this class with compatibility to dynamic features
# (such as dynamic index support) is rooted in two core attributes:
# 1. An integer jax array containing adresses
# 2. A dynamic qubit array containig ALL qubits of the array
# Many of the important properties (such as shape, size etc.) are derived
# from the index array. Therefore manipulating these things can be achieved
# by manipulating the index array.
# If the user requests to retrieve a QuantumVariable from the QuantumArray,
# the (dynamic) position of the corresponding qubits is retrieved from
# the index array and from this a QuantumVariable is built up.
# More on that in the __getitem__ method.
self.ind_array = jnp.arange(size)
self.ind_array = self.ind_array.reshape(shape)
self.qtype = qtype
if check_for_tracing_mode():
if isinstance(qtype.reg, list):
raise Exception(
"Tried to create QuantumArray with qtype defined outside of tracing context"
)
qs = qtype.qs
self.qs = qs
qb_array_tracer, qs.abs_qc = create_qubits(size * qtype.size, qs.abs_qc)
self.qb_array = DynamicQubitArray(qb_array_tracer)
self.qtype_size = qtype.size
else:
if qs is None:
self.qs = QuantumSession()
else:
self.qs = qs
self.qv_list = []
for i in range(size):
self.qv_list.append(
qtype.duplicate(name=self.qtype.name + "*", qs=self.qs)
)
@property
def shape(self):
return self.ind_array.shape
@property
def size(self):
return self.ind_array.size
@property
def ndim(self):
return self.ind_array.ndim
def __getitem__(self, key):
from qrisp.environments import conjugate
# These cases represent the quantum indexing features
if isinstance(key, QuantumVariable):
merge([self.qs, key.qs])
return conjugate(manipulate_array)(self, key)
if isinstance(key, tuple):
if all(isinstance(index, QuantumVariable) for index in key):
merge([self.qs, key[0].qs])
return conjugate(manipulate_array)(self, key)
# If the key is not a tuple, convert to make further processing easier
if not isinstance(key, tuple):
key = (key,)
# Retrieve the index address
# This can either be an integer or an array slice, depending on what
# the type of key is
sliced_ind_array = self.ind_array[key]
if len(sliced_ind_array.shape):
# If the sliced_ind_array has a non trivial shape,
# the result will be a QuantumArray (instead of a QuantumVariable).
# We construct the sliced QuantumArray by copying all attributes
# but instead use the sliced array as the index array.
res = copy.copy(self)
res.ind_array = sliced_ind_array
return res
else:
# Otherwise the sliced_ind_array represents an integer indicating
# the address.
index = sliced_ind_array
if check_for_tracing_mode():
# To construct the resulting QuantumVariable we copy the qtype
# variable and update the qv.reg attribute.
qv = copy.copy(self.qtype)
s = self.qtype_size
qv.reg = self.qb_array[index * s : (index + 1) * s]
qv.qs = self.qs
return qv
else:
for i in range(len(key)):
if key[i] >= self.shape[i]:
raise Exception(
f"Index {key} out of bounds for QuantumArray with shape {self.shape}"
)
return self.qv_list[index]
def __setitem__(self, key, value):
if isinstance(value, QuantumVariable):
return
sliced_array = self[key]
sliced_array.encode(value)
[docs]
def encode(self, value):
"""
The encode method allows to quickly bring a QuantumArray in a desired
computational basis state. For this, it performs a circuit, bringing fresh
qubits into the integer state specified by the encoder.
A shorthand for this method is given by the ``[:]`` operator.
Note that the qubits to initialize have to be fresh (i.e. no operations
performed on them).
Parameters
----------
value :
A value supported by the encoder.
Examples
--------
We create a QuantumArray and encode the identity matrix.
>>> from qrisp import QuantumArray, QuantumFloat
>>> qtype = QuantumFloat(5)
>>> q_array = QuantumArray(qtype, (4,4))
>>> q_array.encode(np.eye(4))
>>> print(q_array)
{OutcomeArray([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]]): 1.0}
Using the slice operator we can also encode on slices of QuantumArrays
>>> q_array = QuantumArray(qtype, (4,4))
>>> q_array[:,:2] = np.ones((4,2))
>>> print(q_array)
{OutcomeArray([[1, 1, 0, 0],
[1, 1, 0, 0],
[1, 1, 0, 0],
[1, 1, 0, 0]]): 1.0}
"""
if isinstance(value, list):
value = np.array(value, dtype="object")
if not value.shape == self.shape:
raise Exception(
"Tried to initialize a QuantumArray with incompatible shape"
)
flattened_value_array = value.flatten()
flat_self = self.flatten()
if check_for_tracing_mode() and isinstance(
flattened_value_array, (np.ndarray, list)
):
flattened_value_array = jnp.array(flattened_value_array)
for i in jrange(self.size):
flat_self[i][:] = flattened_value_array[i]
[docs]
def reshape(self, *args):
"""
Adjusts the shape of the QuantumArray with similar semantics as
`numpy.ndarray.reshape <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.reshape.html>`_.
.. note::
This method never allocates additional qubits and instead returns a
`"view" <https://numpy.org/doc/2.2/user/basics.copies.html>`_,
Parameters
----------
shape : tuple
The target shape.
Returns
-------
res : QuantumArray
The reshaped QuantumArray.
Examples
--------
We create a 1-dimensional QuantumArray with $2**n$ entries and reshape it into
a n dimensional QuantumArray with 2 entries per dimension.
::
from qrisp import QuantumArray, QuantumFloat
import numpy as np
n = 3
qtype = QuantumFloat(n)
qa = QuantumArray(qtype = qtype, shape = 2**n)
qa[:] = np.arange(2**n)
print(qa)
# Yields:
# {OutcomeArray([0, 1, 2, 3, 4, 5, 6, 7]): 1.0}
We can now reshape:
::
reshaped_qa = qa.reshape(tuple(n*[2]))
print(reshaped_qa)
# Yields:
# {OutcomeArray([[[0, 1],
# [2, 3]],
# [[4, 5],
# [6, 7]]]): 1.0}
"""
if isinstance(args[0], (tuple, list)):
shape = args[0]
else:
shape = args
res = copy.copy(self)
res.ind_array = self.ind_array.reshape(shape)
return res
[docs]
def flatten(self):
"""
Flattens the QuantumArray with similar semantics as
`numpy.ndarray.flatten <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flatten.html>`_.
.. note::
This method never allocates additional qubits and instead returns a
`"view" <https://numpy.org/doc/2.2/user/basics.copies.html>`_,
Returns
-------
res : QuantumArray
The flattened QuantumArray.
"""
return self.reshape(self.size)
[docs]
def ravel(self):
"""
Ravels the QuantumArray with similar semantics as
`numpy.ndarray.ravel <https://numpy.org/doc/stable/reference/generated/numpy.ravel.html>`_.
.. note::
This method never allocates additional qubits and instead returns a
`"view" <https://numpy.org/doc/2.2/user/basics.copies.html>`_,
Returns
-------
res : QuantumArray
The raveled QuantumArray.
"""
return self.flatten()
[docs]
def transpose(self, *axes):
"""
Reverses the axes of the QuantumArray with similar semantics as
`numpy.ndarray.transpose <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.transpose.html>`_.
.. note::
This method never allocates additional qubits and instead returns a
`"view" <https://numpy.org/doc/2.2/user/basics.copies.html>`_.
Parameters
----------
*axes : None, tuple of ints, or n ints
* None or no argument: reverses the order of the axes.
* tuple of ints: i in the j-th place in the tuple means that the array’s i-th axis becomes the transposed array’s j-th axis.
* n ints: same as an n-tuple of the same ints (this form is intended simply as a “convenience” alternative to the tuple form).
Returns
-------
res : QuantumArray
The transposed QuantumArray.
"""
res = copy.copy(self)
res.ind_array = self.ind_array.transpose(*axes)
return res
[docs]
def swapaxes(self, axis_1, axis_2):
"""
Swaps the axes of the QuantumArray with similar semantics as
`numpy.ndarray.swapaxes <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.swapaxes.html>`_.
.. note::
This method never allocates additional qubits and instead returns a
`"view" <https://numpy.org/doc/2.2/user/basics.copies.html>`_:
Parameters
----------
axis_1 : int
First axis.
axis_2 : int
Second axis.
Returns
-------
res : QuantumArray
The QuantumArray with swapped axes.
"""
res = copy.copy(self)
res.ind_array = self.ind_array.swapaxes(axis_1, axis_2)
return res
[docs]
def delete(self, verify=False):
r"""
Performs the :meth:`delete <qrisp.QuantumVariable.delete>` method on all
QuantumVariables in this array.
Parameters
----------
verify : bool, optional
If this keyword is set to true, a simulator is queried to check if the
deleted qubits are in the $\ket{0}$ state. The default is False.
"""
if check_for_tracing_mode():
self.qs.clear_qubits(self.qb_array)
else:
for i in range(self.size):
self.qv_list[i].delete(verify=verify)
def measure(self):
from qrisp import measure
dtype = self.qtype.decoder(jnp.zeros(1)[0]).dtype
meas_res = jnp.zeros(self.size, dtype=dtype)
flattened_qa = self.flatten()
def body_fun(i, val):
meas_res, flattened_qa = val
meas_res = meas_res.at[i].set(measure(flattened_qa[i]))
return (meas_res, flattened_qa)
meas_res, flattened_qa = q_fori_loop(
0, flattened_qa.size, body_fun, (meas_res, flattened_qa)
)
return meas_res.reshape(self.shape)
# Retrieves a measurement of the arrays state
# Returns a list of tuples of the type (array, count)
# ie. [(array([1,1,0]), 232), (array([1,1,3]), 115), ...]
[docs]
def get_measurement(
self,
backend=None,
shots=None,
compile=True,
compilation_kwargs={},
subs_dic={},
circuit_preprocessor=None,
precompiled_qc=None,
):
"""
Method for acquiring measurement results for the given array. The semantics are
similar to the :meth:`get_measurement <qrisp.QuantumVariable.get_measurement>`
method of QuantumVariable. The results are returned as a dictionary of another
numpy subtype called OutcomeArray.
Parameters
----------
backend : BackendClient, optional
The backend on which to evaluate the quantum circuit. The default can be
specified in the file default_backend.py.
shots : integer, optional
The amount of shots to evaluate the circuit. The default is given by the backend used.
compile : bool, optional
Boolean indicating if the .compile method of the underlying QuantumSession
should be called before. The default is True.
compilation_kwargs : dict, optional
Keyword arguments for the compile method. For more details check
:meth:`QuantumSession.compile <qrisp.QuantumSession.compile>`.
The default is ``{}``.
subs_dic : dict, optional
A dictionary of sympy symbols and floats to specify parameters in the case
of a circuit with unspecified, abstract parameters. The default is {}.
circuit_preprocessor : Python function, optional
A function which recieves a QuantumCircuit and returns one, which is applied
after compilation and parameter substitution. The default is None.
Raises
------
Exception
Tried to get measurement within open environment.
Returns
-------
list of tuples
The measurement results in the form [(outcome_label, probability), ...].
Examples
--------
>>> from qrisp import QuantumFloat, QuantumArray
>>> qtype = QuantumFloat(3)
>>> q_array = QuantumArray(qtype)
>>> q_array[:] = [[1,0],[0,1]]
>>> res = q_array.get_measurement()
>>> print(res)
{OutcomeArray([[1, 0],
[0, 1]]): 1.0}
"""
if check_for_tracing_mode():
raise Exception(
"Tried to get_measurement from QuantumArray in tracing mode"
)
for qv in self.flatten():
if qv.is_deleted():
raise Exception(
"Tried to measure QuantumArray containing deleted QuantumVariables"
)
if backend is None:
if self.qs.backend is None:
from qrisp.default_backend import def_backend
backend = def_backend
else:
backend = self.qs.backend
if len(self.qs.env_stack) != 0:
raise Exception("Tried to get measurement within open environment")
qubits = sum([qv.reg for qv in self.flatten()[::-1]], [])
# Copy circuit in over to prevent modification
# from qrisp.quantum_network import QuantumNetworkClient
if precompiled_qc is None:
if compile:
qc = qompiler(
self.qs, intended_measurements=qubits, **compilation_kwargs
)
else:
qc = self.qs.copy()
# Transpile circuit
qc = transpile(qc)
else:
qc = precompiled_qc.copy()
# Bind parameters
if subs_dic:
qc = qc.bind_parameters(subs_dic)
from qrisp.core.compilation import combine_single_qubit_gates
qc = combine_single_qubit_gates(qc)
# Execute user specified circuit_preprocessor
if circuit_preprocessor is not None:
qc = circuit_preprocessor(qc)
from qrisp.misc import get_measurement_from_qc
counts = get_measurement_from_qc(qc, qubits, backend, shots)
# Insert outcome labels (if available and hashable)
new_counts_dic = {}
for key in counts.keys():
outcome_label = self.decoder(key)
new_counts_dic[outcome_label] = counts[key]
counts = new_counts_dic
# Sort keys
sorted_key_list = list(counts.keys())
sorted_key_list.sort(key=lambda x: -counts[x])
counts = {key: counts[key] for key in sorted_key_list}
return counts
def decoder(self, code_int):
"""
The decoder method specifies how a QuantumArray turns the outcomes of
measurements into human-readable values. It recieves an integer i and returns an
OutcomeArray.
Parameters
----------
i : int
Integer representing the outcome of a measurement of the qubits of this
QuantumArray.
Returns
-------
res : np.ndarray
An array with entries of the type of the results of the .decoder of the
qtype of this array.
Examples
--------
We create a QuantumFloat and inspect its decoder:
>>> from qrisp import QuantumArray, QuantumFloat
>>> qtype = QuantumFloat(3)
>>> q_array = QuantumArray(qtype, (2,2))
>>> print(q_array.decoder(1))
[[0 0]
[0 1]]
"""
flattened_array = self.flatten()
from qrisp.qtypes.quantum_float import QuantumFloat
if isinstance(self.qtype, QuantumFloat):
if self.qtype.exponent >= 0:
res = np.zeros(len(flattened_array), dtype=np.int32)
else:
res = np.zeros(len(flattened_array))
else:
res = np.zeros(len(flattened_array))
n = len(self.qtype)
bin_string = bin_rep(code_int, len(flattened_array) * n)
for i in range(len(flattened_array)):
if isinstance(self.qtype, QuantumFloat):
res[i] = self.qtype.decoder(int(bin_string[i * n : (i + 1) * n], 2))
else:
res = res.astype("object")
res[i] = self.qtype.decoder(int(bin_string[i * n : (i + 1) * n], 2))
return OutcomeArray(res.reshape(self.shape))
def __len__(self):
return len(self.ind_array)
def __str__(self):
if not check_for_tracing_mode():
return str(self.get_measurement())
else:
return "<QuantumArray[" + str(self.shape)[1:-1] + "]>"
def __matmul__(self, other):
from qrisp import QuantumFloat
if isinstance(self.qtype, QuantumFloat):
if isinstance(other, QuantumArray):
from qrisp.alg_primitives.arithmetic import q_matmul
return q_matmul(self, other)
elif isinstance(other, np.ndarray):
from qrisp.alg_primitives.arithmetic import semi_classic_matmul
return semi_classic_matmul(self, other)
raise Exception("Matrix multiplication for non-float types not implemented")
def __rmatmul__(self, other):
from qrisp import QuantumFloat
if isinstance(self.qtype, QuantumFloat):
return (self.transpose() @ other.transpose()).transpose()
def __iter__(self):
return QuantumArrayIterator(self.flatten())
def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
if ufunc is np.matmul:
return inputs[1].__rmatmul__(inputs[0])
return NotImplemented
[docs]
def concatenate(self, other, axis=0):
"""
Concatenates two QuantumArrays along an axis with similar semantics as
`numpy.concatenate <https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html>`_.
.. note::
This method never allocates additional qubits and instead returns a
`"view" <https://numpy.org/doc/2.2/user/basics.copies.html>`_.
Parameters
----------
other : QuantumArray
The other array to concatenate.
axis : int, optional
The axis to concatenate along. The default is 0.
Raises
------
Exception
Tried to concatenate two QuantumArrays with non-identical qtype.
Returns
-------
res : QuantumArray
The concatenated QuantumArray.
"""
if not self.qtype is other.qtype:
raise Exception(
"Tried to concatenate two QuantumArrays with non-identical qtype"
)
res = copy.copy(self)
ind_array_other_shifted = other.ind_array + self.size
concat_ind_array = jnp.concatenate(
(self.ind_array, ind_array_other_shifted), axis=axis
)
res.ind_array = concat_ind_array
if check_for_tracing_mode():
res.qb_array = self.qb_array + other.qb_array
else:
merge([self.qs, other.qs])
res.qv_list = self.qv_list + other.qv_list
return res
[docs]
def duplicate(self, init=False, qs=None):
"""
This method returns a fresh QuantumArray, with equal ``qtype`` and shape.
Parameters
----------
init : bool, optional
If set to True, the :meth:`init_from <qrisp.QuantumArray.init_from>` method
will be called after creation. The default is False.
qs : QuantumSession, optional
The QuantumSession where the duplicate should be registered. By default,
the duplicate will be registered in a new QuantumSession.
Returns
-------
res : QuantumArray
The duplicated array.
Examples
--------
We duplicate a QuantumArray consisting of QuantumFloats with and without
initiation.
>>> from qrisp import QuantumArray, QuantumFloat
>>> qtype = QuantumFloat(4)
>>> q_array_0 = QuantumArray(qtype, (2,2))
>>> q_array_0[:] = np.ones((2,2))
>>> print(q_array_0)
{OutcomeArray([[1, 1],
[1, 1]]): 1.0}
>>> q_array_1 = q_array_0.duplicate()
>>> print(q_array_1)
{OutcomeArray([[0, 0],
[0, 0]]): 1.0}
Note that no values have been carried over:
>>> q_array_2 = q_array_0.duplicate(init = True)
>>> print(q_array_2)
{OutcomeArray([[1, 1],
[1, 1]]): 1.0}
Now the values have been carried over. Note that this does NOT copy the state.
For more information on this check the documentation of the
:meth:`init_from <qrisp.QuantumVariable.init_from>` method of QuantumVariable.
"""
res = copy.copy(self)
if check_for_tracing_mode():
qs = self.qs
qb_array_tracer, qs.abs_qc = create_qubits(
self.size * self.qtype_size, qs.abs_qc
)
res.qb_array = DynamicQubitArray(qb_array_tracer)
if init:
from qrisp import cx
for i in jrange(self.size * self.qtype_size):
cx(self.qb_array[i], res.qb_array[i])
else:
if qs is None:
res.qs = QuantumSession()
else:
res.qs = qs
res.qv_list = []
for i in range(self.size):
res.qv_list.append(
self.qv_list[i].duplicate(
name=self.qtype.name + "*", qs=res.qs, init=init
)
)
return res
[docs]
def most_likely(self, **meas_kwargs):
"""
Performs a measurement and returns the most likely outcome.
Parameters
----------
**kwargs : Keyword arguments for the get_measurement call.
Examples
--------
>>> from qrisp import QuantumFloat, QuantumArray, ry
>>> import numpy as np
>>> qa = QuantumArray(QuantumFloat(3), shape = 4)
>>> ry(np.pi*9/8, qa[0][0])
>>> print(qa)
{OutcomeArray([1, 0, 0, 0]): 0.9619, OutcomeArray([0, 0, 0, 0]): 0.0381}
>>> qa.most_likely()
OutcomeArray([1, 0, 0, 0])
"""
meas_res = self.get_measurement(**meas_kwargs)
return list(meas_res.keys())[0]
class QuantumArrayIterator:
def __init__(self, qa):
self.qa = qa
self.counter = -1
def __next__(self):
self.counter += 1
if self.counter >= self.qa.size:
raise StopIteration
return self.qa[self.counter]
def flatten_qa(qa):
children = []
qtype_children, qtype_aux_values = jax.tree.flatten(qa.qtype)
children.append(qa.qtype_size)
children.append(qa.ind_array)
children.append(qa.qb_array)
children.extend(qtype_children)
aux_values = [qtype_aux_values]
return tuple(children), tuple(aux_values)
def unflatten_qa(aux_data, children):
qtype_children = children[3:]
qtype_aux_values = aux_data[0]
qtype = jax.tree.unflatten(qtype_aux_values, qtype_children)
qa_dummy = object.__new__(QuantumArray)
qtype_size = children[0]
ind_array = children[1]
qb_array = children[2]
qa_dummy.qtype_size = qtype_size
qa_dummy.qtype = qtype
qa_dummy.ind_array = ind_array
qa_dummy.qb_array = qb_array
qa_dummy.qs = TracingQuantumSession.get_instance()
return qa_dummy
jax.tree_util.register_pytree_node(QuantumArray, flatten_qa, unflatten_qa)
def manipulate_array(q_array, index):
from qrisp import QuantumFloat, demux, invert
if isinstance(index, tuple):
if len(q_array.shape) != len(index):
raise Exception(
"Tried to quantum deref QuantumArray with index of mismatching shape"
)
for qf in index:
if isinstance(qf, QuantumFloat):
if qf.signed:
raise Exception("Tried to quantum deref with a signed QuantumFloat")
if qf.exponent != 0:
raise Exception("Tried to quantum deref with a non-integer")
index = sum([qv.reg for qv in index[::-1]], [])
q_array = q_array.flatten()
with invert():
demux(q_array[0], index, q_array)
return q_array[0]
class OutcomeArray(np.ndarray):
def __new__(subtype, ndarray):
if isinstance(ndarray, list):
ndarray = np.array(ndarray)
if ndarray.dtype == np.int64:
ndarray = np.array(ndarray, dtype=np.int32)
obj = super().__new__(subtype, ndarray.shape, dtype=ndarray.dtype)
indices = product(*[list(range(i)) for i in ndarray.shape])
for i in indices:
np.ndarray.__setitem__(obj, i, ndarray[i])
obj.flags.writeable = False
return obj
def __hash__(self):
return hash(self.ravel().data.tobytes())
# return hash(str(self))
def __eq__(self, other):
return np.array_equal(self, other)
def __repr__(self):
res = np.ndarray.__repr__(self).replace(", dtype=int32", "")
return res
