z i" SrSSKJr SSKJrJr SSKJrJr SSK J r SSK J r J r SSK Jr SSKJr SS KJr SS KJr S S KJrJrJrJr S S KJr SSKJr SSKJ r SSK!J"r" \ "S\S9r#"SS\5r$"SS\ \ \#5r%g)z Base Estimator V1 and V2 classes) annotations)abstractmethodABC)IterableSequence)copy)GenericTypeVar)QuantumCircuit)JobV1) SparsePauliOp) BaseOperator)DataBinEstimatorPubLikePrimitiveResult PubResult) EstimatorPub)_validate_estimator_args)BasePrimitiveV1)BasePrimitiveJobT)boundcR\rSrSrSr\SSj5r\SS.S Sjj5rSr g) BaseEstimatorV2)agBase class for ``EstimatorV2`` implementations. An estimator calculates expectation values for provided quantum circuit and observable combinations. Implementations of this :class:`.BaseEstimatorV2` interface must define their own :meth:`.run` method, which is designed to take the following inputs: * pubs: list of pubs (Primitive Unified Blocs). An estimator pub is a list or tuple of two to four elements that define the unit of work for the estimator. These are: * A single :class:`~qiskit.circuit.QuantumCircuit`, possibly parametrized, whose final state we define as :math:`\psi(\theta)`. * One or more observables (specified as any :class:`~.ObservablesArrayLike`, including :class:`~.quantum_info.Pauli`, :class:`~.SparsePauliOp`, ``str``) that specify which expectation values to estimate, denoted :math:`H_j`. * A collection parameter value sets to bind the circuit against, :math:`\theta_k` * Optionally, the estimation precision. * precision: the estimation precision. This specification is optional and will be overriden by the pub-wise shots if provided. All estimator implementations must implement default value for the ``precision`` in the :meth:`.run` method. This default value will be used any time ``precision=None`` is specified, which can take place in the :meth:`.run` kwargs or at the pub level. c[$N)r)_s _/home/james-whalen/.local/lib/python3.13/site-packages/qiskit/primitives/base/base_estimator.py_make_data_binBaseEstimatorV2._make_data_binHs N) precisioncg)aEstimate expectation values for each provided pub (Primitive Unified Bloc). Args: pubs: An iterable of pub-like objects, such as tuples ``(circuit, observables)`` or ``(circuit, observables, parameter_values)``. precision: The target precision for expectation value estimates of each run Estimator Pub that does not specify its own precision. If None the estimator's default precision value will be used. Returns: A job object that contains results. N)selfpubsr%s r!runBaseEstimatorV2.runNsr$r')r rreturnz type[DataBin])r)zIterable[EstimatorPubLike]r%z float | Noner,z,BasePrimitiveJob[PrimitiveResult[PubResult]]) __name__ __module__ __qualname____firstlineno____doc__ staticmethodr"rr*__static_attributes__r'r$r!rr)sJ< MQ . >J 5  r$rc^\rSrSrSrSrSS.S U4SjjjrS S Sjjr\S Sj5r Sr U=r $) BaseEstimatorV1`a Base class for ``EstimatorV1`` implementations. Note that the reference estimator in Qiskit follows the ``EstimatorV2`` interface specifications instead. An estimator calculates expectation values for provided quantum circuit and observable combinations. Implementations of :class:`.BaseEstimatorV1` should define their own :meth:`.BaseEstimatorV1._run` method that will be called by the public-facing :meth:`qiskit.primitives.BaseEstimatorV1.run`, which takes the following inputs: * quantum circuits (:math:`\psi_i(\theta)`): list of (parameterized) quantum circuits (a list of :class:`~qiskit.circuit.QuantumCircuit` objects). * observables (:math:`H_j`): a list of :class:`~qiskit.quantum_info.SparsePauliOp` objects. * parameter values (:math:`\theta_k`): list of sets of values to be bound to the parameters of the quantum circuits (list of list of float). The method returns a :class:`~qiskit.providers.JobV1` object. Calling :meth:`qiskit.providers.JobV1.result()` yields the a list of expectation values plus optional metadata like confidence intervals for the estimation. .. math:: \langle\psi_i(\theta_k)|H_j|\psi_i(\theta_k)\rangle Here is an example of how a :class:`.BaseEstimatorV1` would be used: .. code-block:: python # This is a fictional import path. # There are currently no EstimatorV1 implementations in Qiskit. from estimator_v1_location import EstimatorV1 from qiskit.circuit.library import RealAmplitudes from qiskit.quantum_info import SparsePauliOp psi1 = RealAmplitudes(num_qubits=2, reps=2) psi2 = RealAmplitudes(num_qubits=2, reps=3) H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)]) H2 = SparsePauliOp.from_list([("IZ", 1)]) H3 = SparsePauliOp.from_list([("ZI", 1), ("ZZ", 1)]) theta1 = [0, 1, 1, 2, 3, 5] theta2 = [0, 1, 1, 2, 3, 5, 8, 13] theta3 = [1, 2, 3, 4, 5, 6] estimator = EstimatorV1() # calculate [ ] job = estimator.run([psi1], [H1], [theta1]) job_result = job.result() # It will block until the job finishes. print(f"The primitive-job finished with result {job_result}") # calculate [ , # , # ] job2 = estimator.run([psi1, psi2, psi1], [H1, H2, H3], [theta1, theta2, theta3]) job_result = job2.result() print(f"The primitive-job finished with result {job_result}") N)optionsc$>[TU]U5 g)zB Initialize ``EstimatorV1``. Args: options: Default options. N)super__init__)r(r7 __class__s r!r:BaseEstimatorV1.__init__s !r$c [XU5upn[UR5nUR"S0UD6 UR"UUU40UR D6$)aRun the job of the estimation of expectation value(s). ``circuits``, ``observables``, and ``parameter_values`` should have the same length. The i-th element of the result is the expectation of observable .. code-block:: python obs = observables[i] for the state prepared by .. code-block:: python circ = circuits[i] with bound parameters .. code-block:: python values = parameter_values[i] Args: circuits: one or more circuit objects. observables: one or more observable objects. Several formats are allowed; importantly, ``str`` should follow the string representation format for :class:`~qiskit.quantum_info.Pauli` objects. parameter_values: concrete parameters to be bound. run_options: runtime options used for circuit execution. Returns: The job object of EstimatorResult. Raises: TypeError: Invalid argument type given. ValueError: Invalid argument values given. r')rrr7update_options_run__dict__)r(circuits observablesparameter_values run_optionsrun_optss r!r*BaseEstimatorV1.runsgX3K #33 //  %.+.yy       r$c [S5e)Nz=The subclass of BaseEstimatorV1 must implement `_run` method.)NotImplementedError)r(rArBrCrDs r!r?BaseEstimatorV1._runs""abbr$r')r7z dict | Noner)rAz)Sequence[QuantumCircuit] | QuantumCircuitrBz1Sequence[BaseOperator | str] | BaseOperator | strrCz:Sequence[Sequence[float]] | Sequence[float] | float | Noner,r)rAztuple[QuantumCircuit, ...]rBztuple[SparsePauliOp, ...]rCztuple[tuple[float, ...], ...]r,r) r-r.r/r0r1__hash__r:r*rr?r3 __classcell__)r;s@r!r5r5`sBHH $ " " ""X\ 9 ;9 G9 U 9 9 vc,c/c8 c ccr$r5N)&r1 __future__rabcrrcollections.abcrrrtypingr r qiskit.circuitr qiskit.providersr Jobqiskit.quantum_info.operatorsr +qiskit.quantum_info.operators.base_operatorr containersrrrrcontainers.estimator_pubr validation_v1rbase_primitive_v1rbase_primitive_jobrrrr5r'r$r!rZsl'"#.#))7D 43.0 Cs4 c4 nWcowqzWcr$