Metrics#

Set of functions that are used to calculate metrics of states, (pseudo-)distance measures between states, and distance measures between quantum channels.

Purity#

qibo.quantum_info.purity(state, backend=None)[source]#

Purity of a quantum state \(\rho\).

This is given by

\[\text{purity}(\rho) = \text{tr}(\rho^{2}) \, .\]
Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Purity of quantum state \(\rho\).

Return type:

float

Impurity#

qibo.quantum_info.impurity(state, backend=None)[source]#

Impurity of quantum state \(\rho\).

This is given by \(1 - \text{purity}(\rho)\), where \(\text{purity}\) is defined in qibo.quantum_info.purity().

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Impurity of state \(\rho\).

Return type:

float

Trace distance#

qibo.quantum_info.trace_distance(state, target, backend=None)[source]#

Trace distance between two quantum states, \(\rho\) and \(\sigma\):

\[T(\rho, \sigma) = \frac{1}{2} \, \|\rho - \sigma\|_{1} = \frac{1}{2} \, \text{tr}\left[ \sqrt{(\rho - \sigma)^{\dagger}(\rho - \sigma)} \right] \, ,\]

where \(\|\cdot\|_{1}\) is the Schatten 1-norm.

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Trace distance between state \(\rho\) and target \(\sigma\).

Return type:

float

Hilbert-Schmidt inner product#

qibo.quantum_info.hilbert_schmidt_inner_product(operator_A, operator_B, backend=None)[source]#

Calculate the Hilbert-Schmidt inner product between two operators.

Given two operators \(A, \, B \in \mathcal{H}\), the Hilbert-Schmidt inner product between the two is given by

\[\braket{A, \, B}_{\text{HS}} = \text{tr}\left(A^{\dagger} \, B\right) \, .\]
Parameters:

  • operator_A (ArrayLike) – operator \(A\).

  • operator_B (ArrayLike) – operator \(B\).

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Hilbert-Schmidt inner product \(\braket{A, \, B}_{\text{HS}}\).

Return type:

float

Hilbert-Schmidt distance#

qibo.quantum_info.hilbert_schmidt_distance(state, target, backend=None)[source]#

Calculate the Hilbert-Schmidt distance between two quantum states:

\[\braket{\rho - \sigma, \, \rho - \sigma}_{\text{HS}} = \text{tr}\left((\rho - \sigma)^{2}\right) \, ,\]

where \(\braket{\cdot, \, \cdot}_{\text{HS}}\) is the qibo.quantum_info.hilbert_schmidt_inner_product().

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Hilbert-Schmidt distance between state \(\rho\) and target \(\sigma\).

Return type:

float

References

1. P. J. Coles, M. Cerezo, and L. Cincio, Strong bound between trace distance and Hilbert-Schmidt distance for low-rank states, Phys. Rev. A 100, 022103 (2019).

Fidelity#

qibo.quantum_info.fidelity(state, target, precision_tol=1e-08, backend=None)[source]#

Fidelity \(F(\rho, \sigma)\) between state \(\rho\) and target state \(\sigma\). In general,

\[F(\rho, \sigma) = \text{tr}^{2}\left( \sqrt{\sqrt{\sigma} \, \rho^{\dagger} \, \sqrt{\sigma}} \right) \, .\]

However, when at least one of the states is pure, then

\[F(\rho, \sigma) = \text{tr}(\rho \, \sigma)\]
Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • precision_tol (float, optional) – precision tolerance in qibo.quantum_info.impurity() used to decide if state and target are pure or mixed states. Defaults to \(10^{-8}\).

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Fidelity between state \(\rho\) and target \(\sigma\).

Return type:

float

Infidelity#

qibo.quantum_info.infidelity(state, target, backend=None)[source]#

Infidelity between state \(\rho\) and target state \(\sigma\), which is given by

\[1 - F(\rho, \, \sigma) \, ,\]

where \(F(\rho, \, \sigma)\) is the qibo.quantum_info.fidelity() between state and target.

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Infidelity between state \(\rho\) and target \(\sigma\).

Return type:

float

A fidelity#

qibo.quantum_info.a_fidelity(state, target, backend=None)[source]#

Return the \(A\)-fidelity between two quantum states.

For a quantum state \(\rho\) and a target quantum state \(\sigma\), the \(A\)-fidelity is defined as:

\[F_{\text{A}}(\rho, \, \sigma) = \text{tr}^{2}(\sqrt{\rho} \, \sqrt{\sigma}) \, .\]
Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

\(A\)-fidelity between \(\rho\) and \(\sigma\).

Return type:

float

References

1. Y.-C. Liang, Y.-H. Yeh, P. E. M. F. Mendonça, R. Y. Teh, M. D. Reid, and P. D. Drummond, Quantum fidelity measures for mixed states, Rep. Prog. Phys. 82 076001 (2019).

2. Z. Ma, F.-L. Zhang, and J.-L. Chen. Geometric interpretation for the A fidelity and its relation with the Bures fidelity, Phys. Rev. A, 78(6):064305, (2008).

N fidelity#

qibo.quantum_info.n_fidelity(state, target, backend=None)[source]#

Return the \(N\)-fidelity between two quantum states.

For a quantum state \(\rho\) and a target quantum state \(\sigma\), the \(N\)-fidelity is defined as:

\[F_{\text{N}}(\rho, \, \sigma) = \text{tr}(\rho \, \sigma) + \sqrt{1 - \text{tr}(\rho^{2})} \, \sqrt{1 - \text{tr}(\sigma^{2})} \, ,\]

where \(\text{tr}(\varrho^{2})\) is the qibo.quantum_info.purity of a quantum state \(\varrho\).

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

\(N\)-fidelity between \(\rho\) and \(\sigma\).

Return type:

float

References

1. Y.-C. Liang, Y.-H. Yeh, P. E. M. F. Mendonça, R. Y. Teh, M. D. Reid, and P. D. Drummond, Quantum fidelity measures for mixed states, Rep. Prog. Phys. 82 076001 (2019).

2. P. E. M. F. Mendonça, R. d. J. Napolitano, M. A. Marchiolli, C. J. Foster, and Y.-C. Liang. Alternative fidelity measure between quantum states, Phys. Rev. A, 78 052330 (2008).

3. A. Miszczak, Z. Puchala, P. Horodecki, A. Uhlmann, and K. Zyczkowski. Sub- and super-fidelity as bounds for quantum fidelity. Quantum Inf. Comput., 9(1):103–130, (2009).

Chen fidelity#

qibo.quantum_info.chen_fidelity(state, target, backend=None)[source]#

Return the Chen fidelity between two quantum states.

For a quantum state \(\rho\) and a target quantum state \(\sigma\), the Chen fidelity is defined as:

\[F_{\text{C}}(\rho, \, \sigma) = \frac{1 - r}{2} + \frac{1 + r}{2} \, F_{\text{N}}(\rho, \, \sigma) \, ,\]

where \(r = 1 / (d - 1)\), with \(d\) being the dimension of the quantum states, and \(F_{\text{N}}\) is the qibo.quantum_info.n_fidelity().

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Chen fidelity between \(\rho\) and \(\sigma\).

Return type:

float

References

1. Y.-C. Liang, Y.-H. Yeh, P. E. M. F. Mendonça, R. Y. Teh, M. D. Reid, and P. D. Drummond, Quantum fidelity measures for mixed states, Rep. Prog. Phys. 82 076001 (2019).

2. J.-L. Chen, L. Fu, A. A. Ungar, and X.-G. Zhao, Alternative fidelity measure between two states of an N-state quantum system, Phys. Rev. A 65, 054304 (2002).

Geometric-mean fidelity#

qibo.quantum_info.geometric_mean_fidelity(state, target, backend=None)[source]#

Return the geometric-mean fidelity between two quantum states.

For a quantum state \(\rho\) and a target quantum state \(\sigma\), the geometric-mean fidelity is defined as:

\[F_{\text{GM}}(\rho, \, \sigma) = \frac{\text{tr}(\rho \, \sigma)} {\sqrt{\text{tr}(\rho^{2}) \, \text{tr}(\sigma^{2})}} \, ,\]

where \(\text{tr}(\varrho^{2})\) is the qibo.quantum_info.purity of a quantum state \(\varrho\). If at least one of the quantum states is pure, then the geometric-mean fidelity reduces to the usual qibo.quantum_info.fidelity.

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Geometric-mean fidelity between \(\rho\) and \(\sigma\).

Return type:

float

References

1. Y.-C. Liang, Y.-H. Yeh, P. E. M. F. Mendonça, R. Y. Teh, M. D. Reid, and P. D. Drummond, Quantum fidelity measures for mixed states, Rep. Prog. Phys. 82 076001 (2019).

2. X. Wang, C.-S. Yu, and X.X. Yi. An alternative quantum fidelity for mixed states of qudits. Phys. Lett. A, 373(1):58–60, (2008).

Max fidelity#

qibo.quantum_info.max_fidelity(state, target, backend=None)[source]#

Return max fidelity between two quantum states.

For a quantum state \(\rho\) and a target quantum state \(\sigma\), the max fidelity is defined as:

\[F_{\text{max}}(\rho, \, \sigma) = \frac{\text{tr}(\rho \, \sigma)} {\text{max}(\text{tr}(\rho^{2}), \, \text{tr}(\sigma^{2}))} \, ,\]

where \(\text{tr}(\varrho^{2})\) is the qibo.quantum_info.purity of a quantum state \(\varrho\). If at least one of the quantum states is pure, then the max fidelity reduces to the usual qibo.quantum_info.fidelity.

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Max fidelity between \(\rho\) and \(\sigma\).

Return type:

float

References

1. Y.-C. Liang, Y.-H. Yeh, P. E. M. F. Mendonça, R. Y. Teh, M. D. Reid, and P. D. Drummond, Quantum fidelity measures for mixed states, Rep. Prog. Phys. 82 076001 (2019).

Bures angle#

qibo.quantum_info.bures_angle(state, target, backend=None)[source]#

Calculates the Bures angle \(D_{A}\) between a state \(\rho\) and a target state \(\sigma\). This is given by

\[D_{A}(\rho, \, \sigma) = \text{arccos}\left(\sqrt{F(\rho, \, \sigma)}\right) \, ,\]

where \(F(\rho, \sigma)\) is the qibo.quantum_info.fidelity() between state and target.

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Bures angle between state and target.

Return type:

float

Bures distance#

qibo.quantum_info.bures_distance(state, target, backend=None)[source]#

Calculates the Bures distance \(D_{B}\) between a state \(\rho\) and a target state \(\sigma\). This is given by

\[D_{B}(\rho, \, \sigma) = \sqrt{2 \, \left(1 - \sqrt{F(\rho, \, \sigma)}\right)}\]

where \(F(\rho, \sigma)\) is the qibo.quantum_info.fidelity() between state and target.

Parameters:

  • state (ArrayLike) – statevector or density matrix.

  • target (ArrayLike) – statevector or density matrix.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Bures distance between state and target.

Return type:

float

Process fidelity#

qibo.quantum_info.process_fidelity(channel, target=None, check_unitary=False, backend=None)[source]#

Process fidelity between a quantum channel \(\mathcal{E}\) and a target unitary channel \(U\). The process fidelity is defined as

\[F_{\text{pro}}(\mathcal{E}, \mathcal{U}) = \frac{1}{d^{2}} \, \text{tr}(\mathcal{E}^{\dagger} \, \mathcal{U})\]
Parameters:

  • channel (ArrayLike) – quantum channel \(\mathcal{E}\).

  • target (ArrayLike, optional) – quantum channel \(U\). If None, target is the Identity channel. Defaults to None.

  • check_unitary (bool, optional) – if True, checks if one of the input channels is unitary. Default: False.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Process fidelity between channel and target.

Return type:

float

Process infidelity#

qibo.quantum_info.process_infidelity(channel, target=None, check_unitary=False, backend=None)[source]#

Process infidelity between quantum channel \(\mathcal{E}\) and a target unitary channel \(U\). The process infidelity is defined as

\[1 - F_{\text{pro}}(\mathcal{E}, \mathcal{U}) \, ,\]

where \(F_{\text{pro}}\) is the qibo.quantum_info.process_fidelity().

Parameters:

  • channel (ArrayLike) – quantum channel \(\mathcal{E}\).

  • target (ArrayLike, optional) – quantum channel \(U\). If None, target is the Identity channel. Defaults to None.

  • check_unitary (bool, optional) – if True, checks if one of the input channels is unitary. Defaults to False.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Process infidelity between channel \(\mathcal{E}\) and target \(U\).

Return type:

float

Average gate fidelity#

qibo.quantum_info.average_gate_fidelity(channel, target=None, check_unitary=False, backend=None)[source]#

Average gate fidelity between a quantum channel \(\mathcal{E}\) and a target unitary channel \(U\). The average gate fidelity is defined as

\[F_{\text{avg}}(\mathcal{E}, \mathcal{U}) = \frac{d \, F_{pro}(\mathcal{E}, \mathcal{U}) + 1}{d + 1}\]

where \(d\) is the dimension of the Hilbert space that the channels act on, i.e. the Liouville representation of a channel has shape \((d^{2}, \, d^{2})\), and \(F_{pro}(\mathcal{E}, \mathcal{U})\) is the process_fidelily() of channel \(\mathcal{E}\) with respect to the unitary channel \(\mathcal{U}\).

Parameters:

  • channel (ArrayLike) – quantum channel \(\mathcal{E}\).

  • target (ArrayLike, optional) – quantum channel \(\mathcal{U}\). If None, target is the Identity channel. Defaults to None.

  • check_unitary (bool, optional) – if True, checks if one of the input channels is unitary. Default: False.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Process fidelity between channel \(\mathcal{E}\) and target unitary channel \(\mathcal{U}\).

Return type:

float

Gate error#

qibo.quantum_info.gate_error(channel, target=None, check_unitary=False, backend=None)[source]#

Gate error between a quantum channel \(\mathcal{E}\) and a target unitary channel \(U\), which is defined as

\[E(\mathcal{E}, \mathcal{U}) = 1 - F_{\text{avg}}(\mathcal{E}, \mathcal{U}) \, ,\]

where \(F_{\text{avg}}(\mathcal{E}, \mathcal{U})\) is the qibo.quantum_info.average_gate_fidelity().

Parameters:

  • channel (ArrayLike) – quantum channel \(\mathcal{E}\).

  • target (ArrayLike, optional) – quantum channel \(\mathcal{U}\). If None, target is the Identity channel. Defaults to None.

  • check_unitary (bool, optional) – if True, checks if one of the input channels is unitary. Default: False.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Gate error between channel \(\mathcal{E}\) and target \(\mathcal{U}\).

Return type:

float

Diamond Norm#

qibo.quantum_info.diamond_norm(channel, target=None, backend=None, **kwargs)[source]#

Calculates the diamond norm \(\|\mathcal{E}\|_{\diamond}\) of channel \(\mathcal{E}\), which is given by

\[\|\mathcal{E}\|_{\diamond} = \max_{\rho} \, \| \left(\mathcal{E} \otimes I_{d^{2}}\right)(\rho) \|_{1} \, ,\]

where \(I_{d^{2}}\) is the \(d^{2} \times d^{2}\) Identity operator, \(d = 2^{n}\), \(n\) is the number of qubits, and \(\|\cdot\|_{1}\) denotes the trace norm.

If a target channel \(\Lambda\) is specified, then it calculates \(\| \mathcal{E} - \Lambda\|_{\diamond}\).

Example:

from qibo.quantum_info import diamond_norm, random_unitary, to_choi

nqubits = 1
dim = 2**nqubits

unitary = random_unitary(dim)
unitary = to_choi(unitary, order="row")

unitary_2 = random_unitary(dim)
unitary_2 = to_choi(unitary_2, order="row")

dnorm = diamond_norm(unitary, unitary_2)
Parameters:

  • channel (ArrayLike) – row-vectorized Choi representation of a quantum channel.

  • target (ArrayLike, optional) – row-vectorized Choi representation of a target quantum channel. Defaults to None.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

  • kwargs – optional arguments to pass to CVXPY solver. For more information, please visit CVXPY’s API documentation.

Returns:

diamond norm of either channel or channel - target.

Return type:

float

Note

This function requires the optional CVXPY package to be installed.

Expressibility of parameterized quantum circuits#

qibo.quantum_info.expressibility(circuit, power_t, samples, order=2, backend=None)[source]#

Returns the expressibility \(\|A\|\) of a parametrized circuit, where

\[A = \int_{\text{Haar}} d\psi \, \left(|\psi\rangle\right.\left. \langle\psi|\right)^{\otimes t} - \int_{\Theta} d\psi \, \left(|\psi_{\theta}\rangle\right.\left. \langle\psi_{\theta}|\right)^{\otimes t}\]
Parameters:

  • circuit (qibo.models.Circuit) – Parametrized circuit.

  • power_t (int) – power that defines the \(t\)-design.

  • samples (int) – number of samples to estimate the integrals.

  • order (int or float or str, optional) – order of the norm \(\|A\|\). For specifications, see qibo.backends.abstract.calculate_norm(). Defaults to \(2\).

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Expressibility of parametrized circuit.

Return type:

float

Frame Potential#

qibo.quantum_info.frame_potential(circuit, power_t, samples, backend=None)[source]#

Returns the frame potential of a parametrized circuit under uniform sampling of the parameters.

For \(n\) qubits and moment \(t\), the frame potential \(\mathcal{F}_{\mathcal{U}}^{(t)}\) if given by [1]

\[\mathcal{F}_{\mathcal{U}}^{(t)} = \int_{U,V \in \mathcal{U}} \, \text{d}U \, \text{d}V \, \bigl| \, \text{tr}(U^{\dagger} \, V) \, / \, d \, \bigr|^{2t} \, ,\]

where \(d = 2^{n}\), i.e. the unitaries are normalized by \(d^{-1/2}\), hence the frame potential of the Haar measure is \(t! \, / \, d^{2t}\).

where \(\mathcal{U}\) is the group of unitaries defined by the parametrized circuit. The frame potential is approximated by the average

\[\mathcal{F}_{\mathcal{U}}^{(t)} \approx \frac{1}{N^{2}} \, \sum_{j, k=1}^{N} \, \bigl| \, \text{tr}(U_{j}^{\dagger} \, V_{k}) \, / \, d \, \bigr|^{2t} \, ,\]

where \(N\) is the number of samples, and \(U_{j}\) and \(V_{k}\) are independently sampled from the circuit.

Parameters:

  • circuit (qibo.models.circuit.Circuit) – Parametrized circuit.

  • power_t (int) – power that defines the \(t\)-design.

  • samples (int) – number of samples to estimate the integral.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses the current backend. Defaults to None.

Returns:

Frame potential of the parametrized circuit.

Return type:

float

References

1. M. Liu et al., Estimating the randomness of quantum circuit ensembles up to 50 qubits. arXiv:2205.09900 [quant-ph].

Quantum Fisher Information Matrix#

qibo.quantum_info.quantum_fisher_information_matrix(circuit, parameters=None, initial_state=None, return_complex=True, backend=None)[source]#

Calculate the Quantum Fisher Information Matrix (QFIM) of a parametrized circuit.

Given a set of parameters \(\theta = \{\theta_{k}\}_{k\in[M]}\) and a parameterized unitary circuit \(U(\theta)\) acting on an initial_state \(\ket{\phi}\), the QFIM is such that its elements can be calculated as

\[\mathbf{F}_{jk} = 4 \, \text{Re}\left\{ \braket{\partial_{j} \psi | \partial_{k} \psi} - \braket{\partial_{j} \psi | \psi}\!\braket{\psi | \partial_{k} \psi} \right\} \, ,\]

where we have used the short notations \(\ket{\psi} \equiv \ket{\psi(\theta)} = U(\theta) \ket{\phi}\), and \(\ket{\partial_{k} \psi} \equiv \frac{\partial} {\partial\theta_{k}} \ket{\psi(\theta)}\). If the initial_state \(\ket{\phi}\) is not specified, it defaults to \(\ket{0}^{\otimes n}\).

Parameters:

  • circuit (qibo.models.circuit.Circuit) – parametrized circuit \(U(\theta)\).

  • parameters (ArrayLike, optional) – parameters whose QFIM to calculate. If None, QFIM is calculated with the paremeters from circuit, i.e. parameters = circuit.get_parameters(). Defaults to None.

  • initial_state (ArrayLike, optional) – Initial configuration. It can be specified by the setting the state vector using an array or a circuit. If None, the initial state is \(\ket{0}^{\otimes n}\). Defaults to None.

  • return_complex (bool, optional) – If True, calculates the Jacobian matrix of real and imaginary parts of \(\ket{\psi(\theta)}\). If False, calculates only the Jacobian matrix of the real part. Defaults to True.

  • backend (qibo.backends.abstract.Backend, optional) – backend to be used in the execution. If None, it uses qibo.backends.GlobalBackend. Defaults to None.

Returns:

Quantum Fisher Information \(\mathbf{F}\).

Return type:

ArrayLike