States, gates, and various other methods accept a list of qubits labels upon which the given State or Gate acts. A Qubit label can be any hashable python object, but typically an integer or string. e.g. [0, 1, 2], or [‘a’, ‘b’, ‘c’]. Note that some operations expect the qubits to be sortable, so don’t mix different uncomparable data types.
quantumflow.
QubitVector
(tensor: TensorLike, qubits: Qubits, rank: int = None)¶A container for a tensor representation of a quantum state or operation on qubits. The QubitTensor contains a list of qubits, and a backend complex tensor in product form.
The rank of the quantum tensor represents the order of the quantum state of operation:
Rank
1 vectors
2 operators
4 superoperators
8 superduperoperators
A vector is an element of a vector space. An operator (normally represented by a 2 dimensional matrix) is a linear map on a vector space. Superoperators are operators of operators – linear maps on the vector space of operators. Similarly rank 8 superduper operators are operators of superoperators.
Pure states are represented by vectors; gates and mixed states by rank 2 operators; and quantum channels by rank 4 superoperators.
A tensor of rank R on N qubits is stored as a tensor product with (N*R) dimensions, each of length 2. (Except for scalers, rank=0, which have only a single element) In other words the shape of the tensor array is [2]*(N*R). This representation is convenient for addressing individual qubits (e.g. For a state of 4 qubits, the state amplitude of 0110 is located in tensor element [0,1,1,0])
A quantum logic gate is a unitary operator acting on a collection of K
qubits, which can be represented by a matrix of shape (2**K, 2**K).
This operator is stored as a mixed tensor of shape
([2]*(2*K)). e.g. for 4 qubits, the gate shape is
(2, 2, 2, 2, 2, 2, 2, 2). Gates have ket and bra components, which are
ordered kets then bras, e.g. gate[k0, k1, k2, k3, b0, b1, b2, b3]
.
This is so we can go back and forth between the product tensor and more
common matrix representations with a simple reshape.:
operator_matrix = np.reshape(gate_tensor, shape=(2**K, 2**K))
gate_tensor = np.reshape(operator_matrix, shape=([2]*(2*K))
The indices of superoperators are ordered [ket_out, bra_out, bra_in, ket_in].
Parameters: 


Variables: 
H
¶Return the conjugate transpose of this tensor.
asarray
() → numpy.ndarray¶Return the tensor as a numpy array
flatten
() → BKTensor¶Return tensor with with qubit indices flattened
norm
() → BKTensor¶Return the norm of this vector
partial_trace
(qubits: Qubits) → qf.QubitVector¶Return the partial trace over some subset of qubits
permute
(qubits: Qubits) → qf.QubitVector¶Permute the order of the qubits
relabel
(qubits: Qubits) → qf.QubitVector¶Return a copy of this vector with new qubits
trace
() → BKTensor¶Return the trace, the sum of the diagonal elements of the (super) operator.