mindquantum.utils
Utils
- mindquantum.utils.bprint(strings: list, align=':', title='', v_around='=', h_around='|', fill_char=' ')[source]
Print the information in block shape.
- Parameters
align (str) – The align char alone vertal direction. Default: “:”.
title (str) – The title of this information block. Default: “”.
v_around (str) – Vertical boundary char. Default: “=”.
h_around (str) – horizontal boundary char. Default: “|”.
fill_char (str) – Empty space fill with this char. Default: ” “.
- Returns
list, a list of formatted string.
Examples
>>> from mindquantum.utils import bprint >>> title='Info of Bob' >>> o = bprint(['Name:Bob', 'Age:17', 'Nationality:China'], >>> title=title) >>> for i in o: >>> print(i) ====Info of Bob==== |Name :Bob | |Age :17 | |Nationality:China| ===================
- mindquantum.utils.commutator(left_operator, right_operator)[source]
Compute the commutator of two operators.
- Parameters
left_operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) – FermionOperator or QubitOperator.
right_operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) – FermionOperator or QubitOperator.
- Raises
TypeError – operator_a and operator_b are not of the same type.
Examples
>>> from mindquantum.ops import QubitOperator,FermionOperator >>> from mindquantum.utils import commutator >>> qub_op1 = QubitOperator("X1 Y2") >>> qub_op2 = QubitOperator("X1 Z2") >>> commutator(qub_op1, qub_op1) 0 >>> commutator(qub_op1, qub_op2) 2j [X2]
- mindquantum.utils.count_qubits(operator)[source]
Calculate the number of qubits on which operator acts before removing the unused qubit
Note
In some case, we need to remove the unused index.
- Parameters
operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) – FermionOperator or QubitOperator or QubitExcitationOperator.
- Returns
int, The minimum number of qubits on which operator acts.
- Raises
TypeError – Operator of invalid type.
Examples
>>> from mindquantum.ops import QubitOperator,FermionOperator >>> from mindquantum.utils import count_qubits >>> qubit_op = QubitOperator("X1 Y2") >>> count_qubits(qubit_op) 3 >>> fer_op = FermionOperator("1^") >>> count_qubits(fer_op) 2
- mindquantum.utils.down_index(index)[source]
The index order, by default we set the spinless orbits as even-odd-even-odd (0,1,2,3,…). The spin_down orbitals (beta orbital) with index odd.
- Parameters
index (int) – spatial orbital index.
- Returns
An integer that is the index of the associated spin-down orbital.
Examples
>>> from mindquantum.utils import down_index >>> down_index(1) 3
- mindquantum.utils.get_fermion_operator(operator)[source]
Convert the tensor (PolynomialTensor) to FermionOperator.
- Returns
fermion_operator, An instance of the FermionOperator class.
- mindquantum.utils.hermitian_conjugated(operator)[source]
Return Hermitian conjugate of FermionOperator or QubitOperator.
- Parameters
operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]) – The input operator.
- Returns
operator (Union[FermionOperator, QubitOperator, QubitExcitationOperator]), the hermitian form of the input operator.
Examples
>>> from mindquantum.ops import QubitOperator >>> from mindquantum.utils import hermitian_conjugated >>> q = QubitOperator('X0', {'a' : 2j}) >>> hermitian_conjugated(q) -2.0*I*a [X0]
- mindquantum.utils.ket_string(state, tol=1e-07)[source]
Get the ket format of the quantum state.
- Parameters
state (numpy.ndarray) – The input quantum state.
tol (float) – The ignore tolence for small amplitude. Default: 1e-7.
- Returns
str, the ket format of the quantum state.
Examples
>>> import numpy as np >>> from mindquantum.utils import ket_string >>> state = np.array([1, -1j])/np.sqrt(2) >>> print('\n'.join(ket_string(state))) √2/2¦0⟩ -√2/2j¦1⟩
- mindquantum.utils.mod(vec_in, axis=0)[source]
Calculate the mod of input vectors.
- Parameters
vec_in (Union[list[numbers.Number], numpy.ndarray]) – The vector you want to calculate mod.
axis (int) – Along which axis you want to calculate mod. Default: 0.
- Returns
numpy.ndarray, The mod of input vector.
Examples
>>> from mindquantum.utils import mod >>> vec_in = np.array([[1, 2, 3], [4, 5, 6]]) >>> mod(vec_in) array([[4.12310563, 5.38516481, 6.70820393]]) >>> mod(vec_in, 1) array([[3.74165739], [8.77496439]])
- mindquantum.utils.normal_ordered(fermion_operator)[source]
Calculate and return the normal order of the FermionOperator. By convention, normal ordering implies terms are ordered from highest mode index (on left) to lowest (on right). Also, creation operators come first then follows the annihilation operator. e.g 3 4^ \(\rightarrow\) - 4^ 3.
- Parameters
fermion_operator (FermionOperator) – Only Fermion type Operator has such forms.
- Returns
FermionOperator, the normal_ordered FermionOperator.
Examples
>>> from mindquantum.ops import FermionOperator >>> from mindquantum.utils import normal_ordered >>> op = FermionOperator("3 4^", 'a') >>> normal_ordered(op) -a [4^ 3]
- mindquantum.utils.normalize(vec_in, axis=0)[source]
Normalize the input vectors based on specified axis.
- Parameters
vec_in (Union[list[number], numpy.ndarray]) – Vector you want to normalize.
axis (int) – Along which axis you want to normalize your vector. Default: 0.
- Returns
numpy.ndarray, Vector after normalization.
Examples
>>> from mindquantum.utils import normalize >>> vec_in = np.array([[1, 2, 3], [4, 5, 6]]) >>> normalize(vec_in) array([[0.24253563, 0.37139068, 0.4472136 ], [0.9701425 , 0.92847669, 0.89442719]]) >>> normalize(vec_in, 1) array([[0.26726124, 0.53452248, 0.80178373], [0.45584231, 0.56980288, 0.68376346]])
- mindquantum.utils.number_operator(n_modes=None, mode=None, coefficient=1.0)[source]
Return a fermionic number operator for the reverse_jordan_wigner transform.
- Parameters
- Returns
FermionOperator, a fermionic number operator for the reverse_jordan_wigner transform.
Examples
>>> from mindquantum.ops import FermionOperator >>> from mindquantum.utils import number_operator >>> nmode = 3 >>> number_operator(nmode) 1.0 [0^ 0] + 1.0 [1^ 1] + 1.0 [2^ 2]
- mindquantum.utils.random_state(shapes, norm_axis=0, comp=True, seed=None)[source]
Generate some random quantum state.
- Parameters
shapes (tuple) – shapes = (m, n) means m quantum states with each state formed by \(\log_2(n)\) qubits.
norm_axis (int) – which axis you want to apply normalization. Default: 0.
comp (bool) – if True, each amplitude of the quantum state will be a complex number. Default: True.
seed (int) – the random seed. Default: None.
- Returns
numpy.ndarray, A normalized random quantum state.
Examples
>>> from mindquantum.utils import random_state >>> random_state((2, 2), seed=42) array([[0.44644744+0.18597239j, 0.66614846+0.10930256j], [0.87252821+0.06923499j, 0.41946926+0.60691409j]])
- mindquantum.utils.sz_operator(n_spatial_orbitals)[source]
Return the sz operator.
- Parameters
n_spatial_orbitals (int) – number of spatial orbitals (n_qubits // 2).
- Returns
FermionOperator, corresponding to the sz operator over n_spatial_orbitals.
Note
The default index order spin_up(alpha) corresponds to even index, while the spin_down(beta) corresponds to odd index.rpartition()
Examples
>>> from mindquantum.utils import sz_operator >>> sz_operator(3) 0.5 [0^ 0] + -0.5 [1^ 1] + 0.5 [2^ 2] + -0.5 [3^ 3] + 0.5 [4^ 4] + -0.5 [5^ 5]
- mindquantum.utils.up_index(index)[source]
The index order, by default we set the spinless orbits as even-odd-even-odd (0,1,2,3,…). The spin_up orbitals (alpha orbitals) with index even.
- Parameters
index (int) – spatial orbital index.
- Returns
An integer that is the index of the associated spin-up orbital.
Examples
>>> from mindquantum.utils import up_index >>> up_index(1) 2