gydZddlmZddlmZddlmZddlmZm Z ddl m Z m Z m Z mZmZddlZddlmZdd lmZdd lmZmZd d lmZmZd d lmZmZmZej ej!dej"#dd d $d Z%ddZ&ddZ'd dZ(GddeZ)dS)!z BitArray ) annotations) defaultdict)partial)chainrepeat)CallableIterableLiteralMappingSequenceN)NDArray) QiskitError)Countssampled_expectation_value)ObservablesArrayObservablesArrayLike) ShapedMixin ShapeInput shape_tupledtypeaxisnum_bitsintreturnc |dz|dzdkzS)z@Return the minimum number of bytes needed to store ``num_bits``.rrs \/granary/edev/quantum/lib/python3.11/site-packages/qiskit/primitives/containers/bit_array.py_min_num_bytesr%%s q=HqL1, -- bit_arrayBitArrayNDArray[np.uint8]cjtj|jdd}|dd|j dz df}|S)Nrbigrbitorder.r)np unpackbitsarrayr)r'arrs r$_unpackr2*s@ - b5 A A AC c2++a/"44 5C Jr&r1tuple[NDArray[np.uint8], int]c|ddddf}|jd}| dz}|dkr+dg|jdz z|dfgz}tj||d}tj|dd }||fS) N.rr!r)rrr)constant_valuesr+r,)shapendimr.padpackbits)r1rpad_size pad_widths r$_packr<0s c44R4i.Cy}Hy1}H!||H1 -(A? fS)Q777 +cU 3 3 3C =r&ceZdZdZdOfd ZdPd ZdQd ZdRdZdSdZdQdZ dQdZ dZ dZ e dTdZe dUdZe dUdZedVdZedWdZdXd"ZdYd$Ze dZd[d)Ze d\d]d.Ze d\d^d1Zd\d_d3Zd\d`d5Zd\dad7Zdbd:ZdSd;Zdcd>Zdcd?ZdddCZ dedGZ!edfdgdLZ"edhdMZ#edhdNZ$xZ%S)ir(a9Stores an array of bit values. This object contains a single, contiguous block of data that represents an array of bitstrings. The last axis is over packed bits, the second last axis is over shots, and the preceding axes correspond to the shape of the pub that was executed to sample these bits. r0r)rrctt|tjst dt ||jtjkrt d|jd|j dkrtd|j dt|x}krtd|d||_ ||_|j j d d |_d S) a Args: array: The ``uint8`` data array. num_bits: How many bit are in each outcome. Raises: TypeError: If the input is not a NumPy array with type ``numpy.uint8``. ValueError: If the input array has fewer than two axes, or the size of the last axis is not the smallest number of bytes that can contain ``num_bits``. z"Input must be a numpy.ndarray not z'Input array must have dtype uint8, not .z,The input array must have at least two axes.rz$The input array is expected to have z bytes per shot.N)super__init__ isinstancer.ndarray TypeErrortyperuint8r7 ValueErrorr6r%_array _num_bits_shape)selfr0rexpected __class__s r$rCzBitArray.__init__Cs %,, PNeNNOO O ;"( " "TekTTTUU U :>>KLL L ;r?>(+C+CCx D D^H^^^__ _ !k', r&other 'BitArray'rtuple[NDArray[np.uint8], ...]c|j|jkrtd|d|d|j|jfz}|j|jfz} t j|||jjdfz}n(#t$r}t|d|d|d}~wwxYwt j|j|t j|j|fS)zSValidation and broadcasting of two bit arrays before element-wise binary operation.z'num_bits' must match in z and r?rz' are not compatible for this operation.N) rrIr6 num_shotsr.broadcast_shapesrJ broadcast_tor0)rMrP self_shape other_shaper6exs r$_prepare_broadcastablezBitArray._prepare_broadcastable^s =EN * *LLLELLLMM MZ4>"33 kU_$66  c' K@@DKDUVXDYC[[EE c c cYY5YYYZZ`b b ctz5112?5;PU3V3VVVs)A22 B<BBcjttj|||jSN)r(r. bitwise_andrZrrMrPs r$__and__zBitArray.__and__j)(C(CE(J(JKT][[[r&boolc|jx}|jkrdS|j|jg}|dzdkr@tjd| dzz gdg|dzzztjfd|D}tj|ddiS)NFr!rrc:g|]}tj|Sr")r.r]).0r1masks r$ z#BitArray.__eq__..ts%>>>#BN3-->>>r& equal_nan)rrJr.r0rH array_equal)rMrPnarrsrfs @r$__eq__zBitArray.__eq__ms A5> 1 15 U\* q51998SqbAX./3%162BB"(SSSD>>>>>>>D~t5u555r&cZttj|j|jSr\)r(r. bitwise_notrJrrMs r$ __invert__zBitArray.__invert__ws t{33T]CCCr&cjttj|||jSr\)r(r. bitwise_orrZrr^s r$__or__zBitArray.__or__zs) t'B'B5'I'IJDMZZZr&cjttj|||jSr\)r(r. bitwise_xorrZrr^s r$__xor__zBitArray.__xor__}r`r&cDd|jd|jd|jd}d|dS)Nzz BitArray())r6rTr)rMdescs r$__repr__zBitArray.__repr__s9\\\\\DM\\\"4""""r&ct|trTt||jdzkrt dt||jdzkrt dt |j||jS)NrzJBitArray cannot be sliced along the shots axis, use slice_shots() instead.r@zHBitArray cannot be sliced along the bits axis, use slice_bits() instead.)rDtuplelenr7 IndexErrorr(rJr)rMindicess r$ __getitem__zBitArray.__getitem__s gu % % 7||ty1},, `7||ty1},, ^ G,dm<<t|d|zS)Nr+)rr)rrfs r$ _bytes_to_intzBitArray._bytes_to_ints~~dE**T11r&locint | tuple[int, ...] | None converterCallable[[bytes], str | int]dict[str, int] | dict[int, int]c|+|jd|jjdn |j|}tt}|D]-}|||xxdz cc<.t |S)Nrr)rJreshaper6rrtobytesdict)rMrrr1countsshot_rows r$ _get_countszBitArray._get_countssAD dk!!"dk&7&;<<>ABB B H  #ttt)$EE e^^[U[[[ ;r?"a '9 :(;u{3B3'7CC4PPPCNC.sE   SZj&&A&A NG " " "w   r&c3tK|]3}|D]\}}t||D]}|V4dSr\)itemsr)rervscountvs r$ z'BitArray.from_counts..sUddgddIBRXY[]bRcRcddQddddddddr&rz;All of your mappings need to have the same number of shots.) rDr listrIr( from_samplesrTr~r)rr singletonrr's r$ from_countszBitArray.from_countss.#6733 39 JXFF&\\F J !HIII  ^d   edddd))$99  ["S[[0144 !^___!))#f++y7JcRXkk7YZZIr&samplesIterable[str] | Iterable[int]ct|} t|}n"#t$r}td|d}~wwxYwt |g|}t |t r'|drdndfd|D}|>t|}tttj |}|dkrd}t|d fd |D}tj|tjt%| }t'|d |S) aConstruct a new bit array from an iterable of bitstrings, hexstrings, or integers. All samples are assumed to be integers if the first one is. Strings are all assumed to be bitstrings whenever the first string doesn't start with ``"0x"``. Consider pairing this method with :meth:`~reshape` if your samples represent nested data. Args: samples: A list of bitstrings, a list of integers, or a list of hexstrings. num_bits: The desired number of bits per sample. If unset, the biggest sample provided is used to determine this value, with a minimum of one bit. Returns: A new bit array. Raises: ValueError: If no strings are given. z At least one sample is required.N0xr@c3:K|]}t|VdS))baseN)r)rerrs r$rz(BitArray.from_samples...s088CC$'''888888r&rrr&c3DK|]}|dVdS)r+N)to_bytes)rer num_bytess r$rz(BitArray.from_samples..9s1GG3 Y66GGGGGGr&)rrr)iternext StopIterationrIrrDr startswithrmaxmapr bit_lengthr%joinr. frombufferrHr~r(r) rr first_samplerYintsrr0rrs @@r$rzBitArray.from_samplessY,w-- I==LL I I I?@@b H Il^W-- lC ( ( 9%0066=22AD88884888D  ::D3s~t4455H1}}"8,, xxGGGG$GGGGG d"(#d))DDD b)44h???s# A=Adict[str, int]cd|jzdz }t|j|j|}|||S)aWReturn a counts dictionary with bitstring keys. Args: loc: Which entry of this array to return a dictionary for. If ``None``, counts from all positions in this array are unioned together. Returns: A dictionary mapping bitstrings to the number of occurrences of that bitstring. r@rrrfrr)rrrr)rMrrfrs r$ get_countszBitArray.get_counts=sH$-!#D4t}SWXXX C9===r&dict[int, int]crt|jd|jzdz }|||S)ajReturn a counts dictionary, where bitstrings are stored as ``int``\s. Args: loc: Which entry of this array to return a dictionary for. If ``None``, counts from all positions in this array are unioned together. Returns: A dictionary mapping ``ints`` to the number of occurrences of that ``int``. r@r)rfr)rrrr)rMrrs r$get_int_countszBitArray.get_int_countsKs>D.Q 5E5IJJJ C9===r& list[str]cd|jzdz }t|j|j||+|jd|jjdn |j|}fd|DS)a Return a list of bitstrings. Args: loc: Which entry of this array to return a dictionary for. If ``None``, counts from all positions in this array are unioned together. Returns: A list of bitstrings. r@rrNrcJg|]}| Sr")r)rerrs r$rgz+BitArray.get_bitstrings..fs/BBB( (**,,--BBBr&)rrrrJrr6)rMrrfr1rs @r$get_bitstringszBitArray.get_bitstringsYs~$-!#D4t}SWXXX @C dk!!"dk&7&;<<>EE TY/ / /t{'8'=>>EECDD D ++E22DMBBBr&cHt|dkr.tttj}t|dkr#t |dt r|d}t|jkrtd|D]6}|jksj|zdkrtd|djd7tfd|Ddz}tj |j S) aReturn a bit array with axes transposed. Args: axes: None, tuple of ints or n ints. See `ndarray.transpose `_ for the details. Returns: BitArray: A bit array with axes permuted. Raises: ValueError: If ``axes`` don't match this bit array. ValueError: If ``axes`` includes any indices that are out of bounds. rrzaxes don't match bit arrayaxis - is out of bounds for bit array of dimension r?c3<K|]}|dkr|n j|zVdS)rN)r7)reirMs r$rz%BitArray.transpose..s5BB!q&&QQdi!mBBBBBBr&)rAr) r~r}reversedranger7rDr rIr(rJ transposer)rMaxesrs` r$rzBitArray.transposes# t99>>% "2"23344D t99>>ja(;;>7D t99 ! !9:: :  ADI~~Q!2!2 XAXXDIXXX"3BBBBTBBBBBXM --d33T]CCCr&rint | Sequence[int]c t|tr|f}|D].}|dks ||jkrtd|d|jd/t |}|d|f}t |\}}t ||S)aReturn a bit array sliced along the bit axis of some indices of interest. .. note:: The convention used by this method is that the index ``0`` corresponds to the least-significant bit in the :attr:`~array`, or equivalently the right-most bitstring entry as returned by :meth:`~get_counts` or :meth:`~get_bitstrings`, etc. If this bit array was produced by a sampler, then an index ``i`` corresponds to the :class:`~.ClassicalRegister` location ``creg[i]``. Args: indices: The bit positions of interest to slice along. Returns: A bit array sliced along the bit axis. Raises: IndexError: If there are any invalid indices of the bit axis. rindex z) is out of bounds for the number of bits r?.)rDrrrr2r<r()rMrindexr1rs r$ slice_bitszBitArray.slice_bitss, gs # # !jG  EqyyET]22 ]U]]T]]]]3dmm#w,c XX&&&r&ct|tr|f}|D].}|dks ||jkrtd|d|jd/|j}|d|ddf}t ||jS)aLReturn a bit array sliced along the shots axis of some indices of interest. Args: indices: The shots positions of interest to slice along. Returns: A bit array sliced along the shots axis. Raises: IndexError: If there are any invalid indices of the shots axis. rrz* is out of bounds for the number of shots r?.N)rDrrTrrJr(r)rMrrr1s r$ slice_shotszBitArray.slice_shotss gs # # !jG  EqyyET^33 _U__dn___4k#w/"T]+++r&Sequence[int] | int selection!Sequence[bool | int] | bool | intc|t|tr|f}t|ttfr|f}tj|t}t |}t ||krt d|jjd}tj|}|dkr| |j kr:tdt| d|j d| |j kr:tdt| d|j d| d|j|jz}|dkr|S||j z}tj|||tj|jdkr6t%tjd|ftj|j Stj|d \}}|d z |z }|tj} tj|tj} tj| |tjd | ztj|tj} tj| |tj|tj| zt%|j|j| z| kd |j S) avPost-select this bit array based on sliced equality with a given bitstring. .. note:: If this bit array contains any shape axes, it is first flattened into a long list of shots before applying post-selection. This is done because :class:`~BitArray` cannot handle ragged numbers of shots across axes. Args: indices: A list of the indices of the cbits on which to postselect. If this bit array was produced by a sampler, then an index ``i`` corresponds to the :class:`~.ClassicalRegister` location ``creg[i]`` (as in :meth:`~slice_bits`). Negative indices are allowed. selection: A list of binary values (will be cast to ``bool``) of length matching ``indices``, with ``indices[i]`` corresponding to ``selection[i]``. Shots will be discarded unless all cbits specified by ``indices`` have the values given by ``selection``. Returns: A new bit array with ``shape=(), num_bits=data.num_bits, num_shots<=data.num_shots``. Raises: IndexError: If ``max(indices)`` is greater than or equal to :attr:`num_bits`. IndexError: If ``min(indices)`` is less than negative :attr:`num_bits`. ValueError: If the lengths of ``selection`` and ``indices`` do not match. rz.Lengths of indices and selection do not match.rrrz& out of bounds for the number of bits r?r"r#r!rr)rDrrar.rr~rIrJr6rrrminrrrT intersect1d logical_notr(emptyrHdivmodastyperrratall) rMrr num_indicesr flattenedbyte_significancebit_significancebyte_idx bit_offsetbitmaskselection_bytess r$ postselectzBitArray.postselects> gs # # !jG i$ - - %" IJy555 'll y>>[ ( (MNN NK%b) *W%% ??{{}} -- gS//ggW[Wdggg{{}} ~-- gS//ggW[WdgggLLTY%?@@  !    4=  >'),gbnY6O6O.P Q Q VYZ Z ZBHa^28DDDt}]]] ]/1i.C.C++M%66%,,RX66 (9BH555 (BHQKK:,EFFF(9BH===  Xrz)28'L'L'LPZ'Z     y/'9oMRRXZR[[ \]    r& observablesrNDArray[np.float64]ctj|}tjtj|jt |j}tj||\}}i}tj |t}tj|jD]}||}|| D]s\} } ||vr| |||< t||| } n'#t$r} t| j| d} ~ wwxYw||xx| | zz cc<t|S)aCompute the expectation values of the provided observables, broadcasted against this bit array. .. note:: This method returns the real part of the expectation value even if the operator has complex coefficients due to the specification of :func:`~.sampled_expectation_value`. Args: observables: The observable(s) to take the expectation value of. Must have a shape broadcastable with with this bit array and the same number of qubits as the number of bits of this bit array. The observables must be diagonal (I, Z, 0 or 1) too. Returns: An array of expectation values whose shape is the broadcast shape of ``observables`` and this bit array. Raises: ValueError: If the provided observables does not have a shape broadcastable with this bit array. ValueError: If the provided observables does not have the same number of qubits as the number of bits of this bit array. ValueError: If the provided observables are not diagonal. rN)rcoercer.fromiterndindexr6objectrbroadcast_arrays zeros_likefloatrrrrrImessage) rMr arr_indices bc_indicesbc_obsrr1rrpaulicoeffexpvalrYs r$expectation_valueszBitArray.expectation_values9sR6'-k:: k"*TZ"8"8GGGOOPTPZ[[ 0kJJ FmJe444Z 011 - -EU#C &u 3 3 5 5 - - uf$$"&//#"6"6F3K96vc{EJJFF"999$RZ00b89E fun,  - s3D  D.D))D.r bit_arraysSequence[BitArray]rc t|dkrtd|dj}|dj}|dj}|dkrtdt |D]\}}|j|krtd|d|d|jd|j|krtd|d |d|jd |j|krtd |d |d|jd |dks||krtd|d|dt jd|D|}t||S)aJoin a sequence of bit arrays along an existing axis. Args: bit_arrays: The bit arrays must have (1) the same number of bits, (2) the same number of shots, and (3) the same shape, except in the dimension corresponding to axis (the first, by default). axis: The axis along which the arrays will be joined. Default is 0. Returns: The concatenated bit array. Raises: ValueError: If the sequence of bit arrays is empty. ValueError: If any bit arrays has a different number of bits. ValueError: If any bit arrays has a different number of shots. ValueError: If any bit arrays has a different number of dimensions. rz*Need at least one bit array to concatenatez2Zero-dimensional bit arrays cannot be concatenatedOAll bit arrays must have same number of bits, but the bit array at index 0 has ! bits and the bit array at index  has  bits.PAll bit arrays must have same number of shots, but the bit array at index 0 has " shots and the bit array at index  shots.zUAll bit arrays must have same number of dimensions, but the bit array at index 0 has z) dimension(s) and the bit array at index z dimension(s).rrr?cg|] }|j Sr"r0rebas r$rgz(BitArray.concatenate..===Brx===r&r) r~rIrrTr7 enumerater.rr()rrrrTr7rr#rs r$rzBitArray.concatenatees( z??a  IJJ Ja=)qM+ !}! 199QRR Rz**  EAr{h&& N8@NN23NN:<+NNN |y(( P8APP23PP:<,PPP w$ R8<RR23RR:<'RRR !88tt||_T__X\___`` `~==*===DIIIh'''r&c t|dkrtd|dj}|dj}t |D]W\}}|j|krtd|d|d|jd|j|krtd|d|d |jd Xt jd |Dd }t||S)aJoin a sequence of bit arrays along the shots axis. Args: bit_arrays: The bit arrays must have (1) the same number of bits, and (2) the same shape. Returns: The stacked bit array. Raises: ValueError: If the sequence of bit arrays is empty. ValueError: If any bit arrays has a different number of bits. ValueError: If any bit arrays has a different shape. r$Need at least one bit array to stackrrrrLAll bit arrays must have same shape, but the bit array at index 0 has shape  and the bit array at index has shape r?cg|] }|j Sr"r!r"s r$rgz.BitArray.concatenate_shots..r$r&rAr)r~rIrr6r%r.rr()rrr6rr#rs r$concatenate_shotszBitArray.concatenate_shotssG z??a  CDD Da=)1 #z**  EAr{h&& N8@NN23NN:<+NNN x5   L>CLL23LL@BLLL! ~==*===BGGGh'''r&c t|dkrtd|dj}|dj}t |D]W\}}|j|krtd|d|d|jd|j|krtd|d|d |jd Xt jd |Dd }t|\}}t||S)a-Join a sequence of bit arrays along the bits axis. .. note:: This method is equivalent to per-shot bitstring concatenation. Args: bit_arrays: Bit arrays that have (1) the same number of shots, and (2) the same shape. Returns: The stacked bit array. Raises: ValueError: If the sequence of bit arrays is empty. ValueError: If any bit arrays has a different number of shots. ValueError: If any bit arrays has a different shape. rr'rrrrr(r)r*r?c,g|]}t|Sr")r2r"s r$rgz-BitArray.concatenate_bits..s@@@rwr{{@@@r&rr) r~rIrTr6r%r.rr<r()rrTr6rr#rrs r$concatenate_bitszBitArray.concatenate_bitssV& z??a  CDD DqM+ 1 #z**  EAr|y(( P8APP23PP:<,PPP x5   L>CLL23LL@BLLL!~@@Z@@@rJJJthh'''r&)r0r)rr)rPrQrrR)rPrQrrQ)rPrQrra)rrQ)rr))rr)rrrrrfrrr)rrrfrrr)rrrrrr)rr)r+)r0rrrrrQr\)rrrrrrQ)rrrrrrQ)rrrr)rrrr)rrrr)r6rrrQ)rrrrQ)rrrrrr()rrrr)r)rrrrrr()rrrr()&__name__ __module__ __qualname____doc__rCrZr_rlrprsrvr{rpropertyr0rrT staticmethodrrrrrrrrrrrrrrrrrr,r/ __classcell__)rOs@r$r(r(;s~------6 W W W W\\\\6666DDDD[[[[\\\\### = = =XX%%%X%,,,\,222\28888DI!H!H!H!H\!HF $((((\(TGK+@+@+@+@\+@Z > > > > > > > > > > C C C C CCCCC8DDDD<#'#'#'#'J,,,,.Y Y Y Y v****X0(0(0(0(\0(d!(!(!(\!(F((((((\((((((((((r&)rrrr)r'r(rr))r1r)rr3)*r3 __future__r collectionsr functoolsr itertoolsrrtypingrr r r r numpyr. numpy.typingr qiskit.exceptionsr qiskit.resultrrobservables_arrayrrr6rrrr/arangerHrrrr%r2r<r(r"r&r$rBs#"""""##############AAAAAAAAAAAAAA ))))));;;;;;;;EEEEEEEE7777777777yryBH===EEb!LLSTUUUYY_`Yaa....  j (j (j (j (j ({j (j (j (j (j (r&