
    z	i*                    8   S r SSKJr  SSKrSSKJr  SSKJr  SSKr	SSK
Jr  SSKJrJrJr  SSKJr  S	S
KJr  S	SKJr  S	SKJrJrJrJrJr  S	SKJr  S	SKJr  S	SK J!r!  S	SK"J#r#  \ " S S5      5       r$ " S S\5      r%SS jr&        SS jr'SS jr(SS jr)g)z
Statevector Sampler V2 class
    )annotationsN)	dataclass)Iterable)NDArray)ClassicalRegisterQiskitErrorQuantumCircuit)Statevector   )BaseSamplerV2)_has_measure)BitArrayDataBinPrimitiveResultSamplerPubResultSamplerPubLike)
SamplerPub)_min_num_bytes)PrimitiveJob)bound_circuit_to_instructionc                  >    \ rS rSr% S\S'   S\S'   S\S'   S\S'   S	rg
)_MeasureInfo+   str	creg_nameintnum_bits	num_bytes	list[int]qreg_indices N)__name__
__module____qualname____firstlineno____annotations____static_attributes__r!       _/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/primitives/statevector_sampler.pyr   r   +   s    NMNr(   r   c                      \ rS rSrSrSSS.SS jjr\SS j5       r\SS j5       rSS	.     SS
 jjr	SS jr
SS jrSrg)StatevectorSampler3   a  
Simple implementation of :class:`BaseSamplerV2` using full state vector simulation.

This class is implemented via :class:`~.Statevector` which turns provided circuits into
pure state vectors, and is therefore incompatible with mid-circuit measurements (although
other implementations may be).

As seen in the example below, this sampler supports providing arrays of parameter value sets to
bind against a single circuit.

Each tuple of ``(circuit, <optional> parameter values, <optional> shots)``, called a sampler
primitive unified bloc (PUB), produces its own array-valued result. The :meth:`~run` method can
be given many pubs at once.

.. plot::
   :include-source:
   :nofigs:

    from qiskit.circuit import (
        Parameter, QuantumCircuit, ClassicalRegister, QuantumRegister
    )
    from qiskit.primitives import StatevectorSampler

    import matplotlib.pyplot as plt
    import numpy as np

    # Define our circuit registers, including classical registers
    # called 'alpha' and 'beta'.
    qreg = QuantumRegister(3)
    alpha = ClassicalRegister(2, "alpha")
    beta = ClassicalRegister(1, "beta")

    # Define a quantum circuit with two parameters.
    circuit = QuantumCircuit(qreg, alpha, beta)
    circuit.h(0)
    circuit.cx(0, 1)
    circuit.cx(1, 2)
    circuit.ry(Parameter("a"), 0)
    circuit.rz(Parameter("b"), 0)
    circuit.cx(1, 2)
    circuit.cx(0, 1)
    circuit.h(0)
    circuit.measure([0, 1], alpha)
    circuit.measure([2], beta)

    # Define a sweep over parameter values, where the second axis is over.
    # the two parameters in the circuit.
    params = np.vstack([
        np.linspace(-np.pi, np.pi, 100),
        np.linspace(-4 * np.pi, 4 * np.pi, 100)
    ]).T

    # Instantiate a new statevector simulation based sampler object.
    sampler = StatevectorSampler()

    # Start a job that will return shots for all 100 parameter value sets.
    pub = (circuit, params)
    job = sampler.run([pub], shots=256)

    # Extract the result for the 0th pub (this example only has one pub).
    result = job.result()[0]

    # There is one BitArray object for each ClassicalRegister in the
    # circuit. Here, we can see that the BitArray for alpha contains data
    # for all 100 sweep points, and that it is indeed storing data for 2
    # bits over 256 shots.
    assert result.data.alpha.shape == (100,)
    assert result.data.alpha.num_bits == 2
    assert result.data.alpha.num_shots == 256

    # We can work directly with a binary array in performant applications.
    raw = result.data.alpha.array

    # For small registers where it is anticipated to have many counts
    # associated with the same bitstrings, we can turn the data from,
    # for example, the 22nd sweep index into a dictionary of counts.
    counts = result.data.alpha.get_counts(22)

    # Or, convert into a list of bitstrings that preserve shot order.
    bitstrings = result.data.alpha.get_bitstrings(22)
    print(bitstrings)

i   N)default_shotsseedc                   Xl         X l        g)z
Args:
    default_shots: The default shots for the sampler if not specified during run.
    seed: The seed or Generator object for random number generation.
        If None, a random seeded default RNG will be used.
N_default_shots_seed)selfr-   r.   s      r)   __init__StatevectorSampler.__init__   s     ,
r(   c                    U R                   $ )zReturn the default shots)r1   r3   s    r)   r-    StatevectorSampler.default_shots   s     """r(   c                    U R                   $ )zAReturn the seed or Generator object for random number generation.)r2   r7   s    r)   r.   StatevectorSampler.seed   s     zzr(   )shotsc               *   Uc  U R                   nU Vs/ s H  n[        R                  " X25      PM     nn[        S U 5       5      (       a  [        R
                  " S[        5        [        U R                  U5      nUR                  5         U$ s  snf )Nc              3  f   #    U  H'  n[        UR                  R                  5      S :H  v   M)     g7f)r   N)lencircuitcregs).0pubs     r)   	<genexpr>)StatevectorSampler.run.<locals>.<genexpr>   s$     Clss3;;$$%*ls   /1zOne of your circuits has no output classical registers and so the result will be empty. Did you mean to add measurement instructions?)
r1   r   coerceanywarningswarnUserWarningr   _run_submit)r3   pubsr;   rB   coerced_pubsjobs         r)   runStatevectorSampler.run   s     =''EAEF#
))#5FClCCCMMO 499l3
 Gs    Bc                d    U Vs/ s H  o R                  U5      PM     nn[        USS0S9$ s  snf )Nversion   metadata)_run_pubr   )r3   rL   rB   resultss       r)   rJ   StatevectorSampler._run   s3    156#==%6w)Q@@ 7s   -c                H   [        UR                  5      u  p#nUR                  R                  U5      nU Vs0 s HT  nUR                  [
        R                  " UR                  UR                  UR                  4-   [
        R                  S9_MV     nn[
        R                  " U5       H  u  p[        [        U	5      5      n
U
R                  U R                  5        U(       a  U
R!                  UR                  US9nOS/UR                  -  n[
        R"                  " U Vs/ s H&  n[
        R$                  " U[
        R                  S9PM(     sn5      nU H4  n['        XR(                  UR*                  5      nXUR                     U'   M6     M     U Vs0 s H/  ofR                  [-        XvR                     UR(                  5      _M1     nn[/        [1        S0 UDSUR                  0D6UR                  UR                  R2                  S.S9$ s  snf s  snf s  snf )N)dtype)r;   qargs shape)r;   circuit_metadatarT   r!   )_preprocess_circuitr?   parameter_valuesbind_allr   npzerosr]   r;   r   uint8ndenumerater
   r   r.   r2   sample_memoryarrayfromiter_samples_to_packed_arrayr   r    r   r   r   rU   )r3   rB   r?   r[   	meas_infobound_circuitsitemarraysindexbound_circuitfinal_statesamplessamplesamples_arrayarymeass                   r)   rV   StatevectorSampler._run_pub   s   $7$D!	--66w?
 "	
 " NNBHH$$		4>>'BB"((  "	 	 
 %'NN>$B E%&B=&QRKTZZ(%33#))53Q$*HHX_%`X_fbkk&&IX_%`aM!.}mmTM^M^_03t~~&u- " %C Yb
XaPTNNHVNN%;T]]KKXa 	 
  ,d,#)),"yyckk>R>RS
 	
+
 &a

s   AH%-H
6Hr0   )r-   r   r.    np.random.Generator | int | None)returnr   )rx   rw   )rL   zIterable[SamplerPubLike]r;   z
int | Nonerx   z/PrimitiveJob[PrimitiveResult[SamplerPubResult]])rL   zIterable[SamplerPub]rx   z!PrimitiveResult[SamplerPubResult])rB   r   rx   r   )r"   r#   r$   r%   __doc__r4   propertyr-   r.   rO   rJ   rV   r'   r!   r(   r)   r+   r+   3   sm    Rh 04^b  # #  
 FJ,8B	8"A
r(   r+   c                   U R                    Vs0 s H  oR                  UR                  _M     nn[        U 5      n[	        [        UR                  5       5      5      n[        U5       VVs0 s H  u  pVXe_M	     nnnU R                  SS9n [        U 5      (       a  [        S5      e[        U 5      (       a  [        S5      e[        U5      nUR                  5        V	V
s0 s H  u  pX/U
-  _M     nn	n
UR                  5        H  u  pU	u  pX|   XR                     U'   M     UR                  5        VVs/ s H  u  p[        UU[        U5      X   S9PM     nnnXU4$ s  snf s  snnf s  sn
n	f s  snnf )NF)inplacez.StatevectorSampler cannot handle ControlFlowOpz9StatevectorSampler cannot handle mid-circuit measurements)r   r   r   r    )r@   namesize_final_measurement_mappingsortedsetvalues	enumerateremove_final_measurements_has_control_flowr   r   r>   itemsr   r   )r?   cregnum_bits_dictmappingr[   kvqargs_indexsentinelkeyvalindicesqregindr}   r   rj   s                    r)   r_   r_      sr   6=mmDmdYY		)mMD(1G3w~~'()E$-e$45$4DA14$4K5///>G!!JKKGUVV5zH5B5H5H5JK5JsJ$$5JGK]]_		"-"3		3 % ,113 4ND 	$X. 		
 4   9$$1 E 6 Ls    E",E' E-8#E3c                    [         R                  " U S S 2S S S24   SSS9nUS S 2US S S2   4   nU* S-  n[         R                  " USUS44SS9n[         R                  " USS9nU$ )N)r   r   )r   r   r   )constant_values   r   )axis)rb   padpackbits)rq   r   r   rt   pad_sizes        r)   ri   ri      sx     &&DbD!#3Q
GC
a2
C y1}H
&&v!}-q
AC
++c
#CJr(   c                   [        [        U R                  5      5      n[        [        U R                  5      5      n0 nU SSS2    GH  nUR                  R
                  S:X  a  U R                  UR                  S   5      nUR                  nU R                  UR                  S   5      R                  nXb;   a-  Xq;   a(  UR                   H  nXsU'   M	     UR                  U5        O`UR                  R
                  S;  aF  UR                   H6  n	U R                  U	5      R                  n
X;   d  M%  UR                  U
5        M8     U(       a
  U(       a  GM    U$    U$ )zReturn the final measurement mapping for the circuit.

Parameters:
    circuit: Input quantum circuit.

Returns:
    Mapping of classical bits to qubits for final measurements.
Nr   measurer   )barrierdelay)r   range
num_qubits
num_clbits	operationr}   find_bitclbitsrn   qubits	registersremove)r?   active_qubitsactive_cbitsr   rl   loccbitqbitr   qq_temp_qubits              r)   r   r      s*    g0012MuW//01L G">>)+""4;;q>2C99D##DKKN399D#(=MMD$(DM *##D)^^  (<<kk%..r288/!((5 "
 ==N% $ Nr(   c                &    [        S U  5       5      $ )Nc              3  @   #    U  H  oR                  5       v   M     g 7f)N)is_control_flow)rA   instructions     r)   rC   $_has_control_flow.<locals>.<genexpr>"  s     H**,,s   )rF   )r?   s    r)   r   r   !  s    HHHHr(   )r?   r	   )rq   NDArray[np.uint8]r   r   r   r   rx   r   )r?   r	   rx   z(dict[tuple[ClassicalRegister, int], int])r?   r	   rx   bool)*ry   
__future__r   rG   dataclassesr   typingr   numpyrb   numpy.typingr   qiskitr   r   r	   qiskit.quantum_infor
   baser   base.validation_v1r   
containersr   r   r   r   r   containers.sampler_pubr   containers.bit_arrayr   primitive_jobr   utilsr   r   r+   r_   ri   r   r   r!   r(   r)   <module>r      s    #  !     A A +  ,  / 0 ' /   Y
 Y
x%8*-8A& FIr(   