z iSSrSSKJr SSKrSSKJr SSKJr SSKJ r SSK r SSK J r JrJr SSKJr SS KJr SS KJrJr SS KJrJr SS KJrJr SS KJr SSKJ r SSK!J"r"J#r#J$r$J%r% SSK&J'r' SSK(J)r) SSK*J+r+ S S!Sjjr,S"Sjr-S#Sjr.S$Sjr/S%Sjr0\ "SS55r1\ "SS55r2"SS\ 5r3S&Sjr4g)'zDM'9%%++ :;;QH |< < KKs'9: Jk J<  '++d((*d+  ++h6+6==?@   ,s !DD c/nUH<nUR5n[U[5(dU/nURU5 M> U$N) get_countsrlistextend)resultscountsrescounts r._prepare_countsr9MsD F %&&GE e  Mct[U5n[U5n[R"U[S9nSnUR 5HeupgSU;aUR SS5SOUn[US5n XW- n[U5H$n S[X:U -5-n XJ==X{-- ss'M& Mg XE-nSUS-- n XL4$)zReturn array of expval and variance pairs for input Paulis. Note: All non-identity Pauli's are treated as Z-paulis, assuming that basis rotations have been applied to convert them to the diagonal basis. dtyper r) r# _paulis2indsnpzerosfloatitemssplitintr"_parity) r6paulissize diag_indsexpvalsdenom bin_outcomefreq split_outcomeoutcomekcoeff variancess r._pauli_expval_with_variancerUWs v;DV$Ihht5)G E#\\^ 8;{8J ))#q1!4P[ mQ' tAGIL7$:;;E J$, &J , GGQJI  r:cURUR-n[R"USSS9nSS[R"UR S[ S9--nX#-nUR5$)zConvert PauliList to diagonal integers. These are integer representations of the binary string with a 1 where there are Paulis, and 0 where there are identities. rlittle)axisbitorderr<)zr-rBpackbitsarangeshapeobjecttolist)rInonid packed_vals power_uint8indss r.rArAssc HHvxx E++e!h?KBIIk&7&7&:&IIJK  $D ;;=r:c<[U5RS5S-$)zReturn the parity of an integer1r?)binr8)integers r.rHrHs w<  c "Q &&r:cH\rSrSr%SrSrS\S'SrS\S'S rS \S 'S r g ) Optionsz*Options for :class:`~.BackendEstimatorV2`.g?rDdefault_precisionTboolabelian_groupingNz int | Noneseed_simulator) __name__ __module__ __qualname____firstlineno____doc__rl__annotations__rnro__static_attributes__rpr:r.rjrjs84'u'"d!"&NJ%r:rjc<\rSrSr%SrS\S'S\S'S\S'Srg ) _PreprocessedDatazKInternal data structure to store the results of the preprocessing of a pub.list[QuantumCircuit]r&z np.ndarrayparameter_indices observablesrpN)rqrrrsrtrurvrwrpr:r.ryrys U""T!!TGr:ryc\rSrSrSrSS.SSjjr\SSj5r\SSj5rSS.SS jjr SS jr SS jr SS jr SS jr SSjrSSjrSSjrSSjrSrg)BackendEstimatorV2a Evaluates expectation values for provided quantum circuit and observable combinations. The :class:`~.BackendEstimatorV2` class is a generic implementation of the :class:`~.BaseEstimatorV2` interface that is used to wrap a :class:`~.BackendV2` object in the :class:`~.BaseEstimatorV2` API. It facilitates using backends that do not provide a native :class:`~.BaseEstimatorV2` implementation in places that work with :class:`~.BaseEstimatorV2`. However, if you're using a provider that has a native implementation of :class:`~.BaseEstimatorV2`, it is a better choice to leverage that native implementation as it will likely include additional optimizations and be a more efficient implementation. The generic nature of this class precludes doing any provider- or backend-specific optimizations. This class does not perform any measurement or gate mitigation, and, presently, is only compatible with Pauli-based observables. More formally, given an observable of the type :math:`O=\sum_{i=1}^Na_iP_i`, where :math:`a_i` is a complex number and :math:`P_i` is a Pauli operator, the estimator calculates the expectation :math:`\mathbb{E}(P_i)` of each :math:`P_i` and finally calculates the expectation value of :math:`O` as :math:`\mathbb{E}(O)=\sum_{i=1}^Na_i\mathbb{E}(P_i)`. The reported ``std`` is calculated as .. math:: \frac{\sum_{i=1}^{n}|a_i|\sqrt{\textrm{Var}\big(P_i\big)}}{\sqrt{N}}\:, where :math:`\textrm{Var}(P_i)` is the variance of :math:`P_i`, :math:`N=O(\epsilon^{-2})` is the number of shots, and :math:`\epsilon` is the target precision [1]. Each tuple of ``(circuit, observables, parameter values, precision)``, called an estimator primitive unified bloc (PUB), produces its own array-based result. The :meth:`~.BackendEstimatorV2.run` method can be given a sequence of pubs to run in one call. The options for :class:`~.BackendEstimatorV2` consist of the following items. * ``default_precision``: The default precision to use if none are specified in :meth:`~run`. Default: 0.015625 (1 / sqrt(4096)). * ``abelian_grouping``: Whether the observables should be grouped into sets of qubit-wise commuting observables. Default: True. * ``seed_simulator``: The seed to use in the simulator. If None, a random seed will be used. Default: None. **Reference:** [1] O. Crawford, B. van Straaten, D. Wang, T. Parks, E. Campbell, St. Brierley, Efficient quantum measurement of Pauli operators in the presence of finite sampling error. `Quantum 5, 385 `_ N)optionscXlU(a [S0UD6O [5Ul[R"U5R n[ U[5(a[X1RS9nO [US9n[U/5Ul g)a Args: backend: The backend to run the primitive on. options: The options to control the default precision (``default_precision``), the operator grouping (``abelian_grouping``), and the random seed for the simulator (``seed_simulator``). )basistarget)rNrp) _backendrj_optionsr from_backend basis_gatesrr rrr _passmanager)selfr'rropt1qs r.__init__BackendEstimatorV2.__init__sh .5*'*79 !..w7CC gy ) )0u^^TE0u=E'0r:cUR$)zReturn the options)rrs r.rBackendEstimatorV2.options}}r:cUR$)z7Returns the backend which this sampler object based on.)rrs r.r'BackendEstimatorV2.backendrr:) precisioncUcURRnUVs/sHn[R"X25PM nnUR U5 [ UR U5nUR5 U$s snfr1)rrlrcoerce_validate_pubsr_run_submit)rpubsrpub coerced_pubsjobs r.r$BackendEstimatorV2.runsj   77IGKLt ++C;t L L)499l3  Ms A9c[U5H2up#URS::dM[SUSURS3S5e g)NgzThe z/-th pub has precision less than or equal to 0 (z). z&But precision should be larger than 0.) enumerater ValueError)rrirs r.r!BackendEstimatorV2._validate_pubs sFoFA}}# 1#LS]]O[^_<&r:c[[5n[U5HGup4[[R "SUR S-- 55nX%RU5 MI S/[U5-nUR5HBupWURUVs/sHo1UPM snU5n[Xx5H up9XU'M MD [USS0S9$s snf)Ng?r?versionr) rr3rrGmathceilrrr#rE _run_pubszipr) rrpub_dictrrshotsr5lst pub_results pub_results r.rBackendEstimatorV2._runst$oFA # q(8"89:E O " "1 %&&3t9$"..*JE..3)?3aq'3)?GK!$S!6 ' "7 + w)Q@@ *@sC c /n/nUH@nURU5nURU5 URUR5 MB [ X@R X R RS9upx[U5n /n Sn [X5HVupVU [UR5-n URXU XU 5n U n U RURX]Xb55 MX U $)zFCompute results for pubs that all require the same value of ``shots``.)rror) _preprocess_pubrr4r&r/rrror9rr#_calc_expval_map_postprocess_pub)rrrpreprocessed_data flat_circuitsrdata run_resultrr6r5startend expval_maps r.rBackendEstimatorV2._run_pubs#s C'',D  $ $T *   / - ==mmFbFb  !,T5IC#dmm,,C..vC/@(QTBUVJE NN400$N O 6 r:cURnURnURnURn[R "[R "U5[S9RU5n[R"Xc5upx[[5n [R "UR6Hn Xzn XRX5 M URX$U 5n [XU5$)aConverts a pub into a list of bound circuits necessary to estimate all its observables. The circuits contain metadata explaining which bindings array index they are with respect to, and which measurement basis they are measuring. Args: pub: The pub to preprocess. Returns: The values ``(circuits, bc_param_ind, bc_obs)`` where ``circuits`` are the circuits to execute on the backend, ``bc_param_ind`` are indices of the pub's bindings array and ``bc_obs`` is the observables array, both broadcast to the shape of the pub. r<)circuitr}parameter_valuesr^rBfromiterndindexr_reshapebroadcast_arraysrsetupdate_bind_and_add_measurementsry) rrrr}r param_shape param_indices bc_param_indbc_obs param_obs_mapindex param_indexbound_circuitss r.r"BackendEstimatorV2._preprocess_pub:s++oo //',,  BJJ{$;6JRRS^_ !22=N #C( ZZ!3!34E&-K  & - -fm <588Tab vFFr:cFURnURn[R"U[S9n[R"U[S9n[R "UR 6H^n XYn XiR5HAupX*U 4upXy==X-- ss'X==[R"U 5US--- ss'MC M` U[R"U5- n[XUR S9n[UURUURRS.S9$)a0Computes expectation values (evs) and standard errors (stds). The values are stored in arrays broadcast to the shape of the pub. Args: pub: The pub to postprocess. expval_map: The map data: The result data of the preprocessing. shots: The number of shots. Returns: The pub result. r<g?)evsstdsr^)target_precisionrcircuit_metadatar)r|r}rB zeros_likerDrr^rEabssqrtrrrrr)rrrrrrrrrTrrpaulirSexpvalvariancerdata_bins r.r#BackendEstimatorV2._postprocess_pubYs -- !!mmL6MM,e< ZZ!3!34E&-K & 3 3 5 #-5.@#A  fn,  BFF5MHcM$AA !65 2775>)sSYY? $'MM$'KK$8$8  r:c/nUR5HMupVURX5n[[U55nUR XxU5n UR U 5 MO U$)aBind the given circuit against each parameter value set, and add necessary measurements to each. Args: circuit: The (possibly parametric) circuit of interest. parameter_values: An array of parameter value sets that can be applied to the circuit. param_obs_map: A mapping from locations in ``parameter_values`` to a sets of Pauli terms whose expectation values are required in those locations. Returns: A flat list of circuits sufficient to measure all Pauli terms in the ``param_obs_map`` values at the corresponding ``parameter_values`` location, where requisite book-keeping is stored as circuit metadata. )rEbindr sorted_create_measurement_circuitsr4) rrrrr&r pauli_strings bound_circuit meas_paulis new_circuitss r.r-BackendEstimatorV2._bind_and_add_measurements~si(*7*=*=*? &K,11'GM#F=$9:K<<KL OOL )+@r:c0n[X5HLupEUSnUSnUSn[XG5up[XiU 5Hupn X4X8U R54'M MN U$)aComputes the map of expectation values. Args: counts: The counts data. metadata: The metadata. Returns: The map of expectation values takes a pair of an index of the bindings array and a pauli string as a key and returns the expectation value of the pauli string with the the pub's circuit bound against the parameter value set in the index of the bindings array. orig_paulisrr)rrUto_label)rr6rrr8metarrrrLrTrrrs r.r#BackendEstimatorV2._calc_expval_maps}"NP v0KE}-K}-K}-K!L"''*F$**;;$))+%$$*8,RR+  % %f -  d K$0$9$9L ! ! ( ( 6* %$r:)rrr)r'r rz dict | None)returnrj)rr )rzIterable[EstimatorPubLike]rz float | Nonerz(PrimitiveJob[PrimitiveResult[PubResult]])rlist[EstimatorPub])rrrzPrimitiveResult[PubResult])rrrrGrzlist[PubResult])rrrry) rrrdictrryrrGrr)rrrrrzdict[tuple[int, ...], set[str]]rr{)r6z list[Counts]rrrz6dict[tuple[tuple[int, ...], str], tuple[float, float]])rrrr rztuple[int, ...]rr{)rqrrrsrtrurpropertyrr'r$rrrrrrrrrwrpr:r.rrs-2p $ 11 1. NR . >J  1 A .G># # -1# 9J# SV# # J(7   > @ 6F%%F%3<F%KZF% F%r:rc[R"UR5URUR-n[R "U5(dS/n[ [US5[[U5SU355n[U5H`upEURU(a6URU(aURU5 URU5 URXT5 Mb X24$)Nrq__c_)rBr]rr[r-anyrr rr#rsdghmeasure)rr qubit_indicesrclbitrs r.rrs IIe../%''0ABM 66-  ! C(*;C r"sC" #$!MM)&0(<A!MM42'  #3# ## % #L8  '   &  H H  HT%T%n 'r: