qiskit.aqua.algorithms.MaximumLikelihoodAmplitudeEstimation¶

class MaximumLikelihoodAmplitudeEstimation(num_oracle_circuits, state_preparation=None, grover_operator=None, objective_qubits=None, post_processing=None, a_factory=None, q_factory=None, i_objective=None, likelihood_evals=None, quantum_instance=None)[Quellcode]¶

The Maximum Likelihood Amplitude Estimation algorithm.

This class implements the quantum amplitude estimation (QAE) algorithm without phase estimation, as introduced in [1]. In comparison to the original QAE algorithm [2], this implementation relies solely on different powers of the Grover operator and does not require additional evaluation qubits. Finally, the estimate is determined via a maximum likelihood estimation, which is why this class in named MaximumLikelihoodAmplitudeEstimation.

References

[1]: Suzuki, Y., Uno, S., Raymond, R., Tanaka, T., Onodera, T., & Yamamoto, N. (2019).: Amplitude Estimation without Phase Estimation. arXiv:1904.10246.
[2]: Brassard, G., Hoyer, P., Mosca, M., & Tapp, A. (2000).: Quantum Amplitude Amplification and Estimation. arXiv:quant-ph/0005055.

Parameter

num_oracle_circuits (int) – The number of circuits applying different powers of the Grover oracle Q. The (num_oracle_circuits + 1) executed circuits will be [id, Q^2^0, …, Q^2^{num_oracle_circuits-1}] A |0>, where A is the problem unitary encoded in the argument a_factory. Has a minimum value of 1.
state_preparation (Union[QuantumCircuit, CircuitFactory, None]) – A circuit preparing the input state, referred to as \(\mathcal{A}\).
grover_operator (Union[QuantumCircuit, CircuitFactory, None]) – The Grover operator \(\mathcal{Q}\) used as unitary in the phase estimation circuit.
objective_qubits (Optional[List[int]]) – A list of qubit indices. A measurement outcome is classified as ‚good‘ state if all objective qubits are in state \(|1\rangle\), otherwise it is classified as ‚bad‘.
post_processing (Optional[Callable[[float], float]]) – A mapping applied to the estimate of \(0 \leq a \leq 1\), usually used to map the estimate to a target interval.
a_factory (Optional[CircuitFactory]) – The CircuitFactory subclass object representing the problem unitary.
q_factory (Optional[CircuitFactory]) – The CircuitFactory subclass object representing. an amplitude estimation sample (based on a_factory)
i_objective (Optional[int]) – The index of the objective qubit, i.e. the qubit marking ‚good‘ solutions with the state |1> and ‚bad‘ solutions with the state |0>
likelihood_evals (Optional[int]) – The number of gridpoints for the maximum search of the likelihood function
quantum_instance (Union[QuantumInstance, Backend, BaseBackend, None]) – Quantum Instance or Backend

__init__(num_oracle_circuits, state_preparation=None, grover_operator=None, objective_qubits=None, post_processing=None, a_factory=None, q_factory=None, i_objective=None, likelihood_evals=None, quantum_instance=None)[Quellcode]¶

Parameter

num_oracle_circuits (int) – The number of circuits applying different powers of the Grover oracle Q. The (num_oracle_circuits + 1) executed circuits will be [id, Q^2^0, …, Q^2^{num_oracle_circuits-1}] A |0>, where A is the problem unitary encoded in the argument a_factory. Has a minimum value of 1.
state_preparation (Union[QuantumCircuit, CircuitFactory, None]) – A circuit preparing the input state, referred to as \(\mathcal{A}\).
grover_operator (Union[QuantumCircuit, CircuitFactory, None]) – The Grover operator \(\mathcal{Q}\) used as unitary in the phase estimation circuit.
objective_qubits (Optional[List[int]]) – A list of qubit indices. A measurement outcome is classified as ‚good‘ state if all objective qubits are in state \(|1\rangle\), otherwise it is classified as ‚bad‘.
post_processing (Optional[Callable[[float], float]]) – A mapping applied to the estimate of \(0 \leq a \leq 1\), usually used to map the estimate to a target interval.
a_factory (Optional[CircuitFactory]) – The CircuitFactory subclass object representing the problem unitary.
q_factory (Optional[CircuitFactory]) – The CircuitFactory subclass object representing. an amplitude estimation sample (based on a_factory)
i_objective (Optional[int]) – The index of the objective qubit, i.e. the qubit marking ‚good‘ solutions with the state |1> and ‚bad‘ solutions with the state |0>
likelihood_evals (Optional[int]) – The number of gridpoints for the maximum search of the likelihood function
quantum_instance (Union[QuantumInstance, Backend, BaseBackend, None]) – Quantum Instance or Backend

Methods

`__init__`(num_oracle_circuits[, …])	type num_oracle_circuits `int`
`confidence_interval`(alpha[, kind])	Compute the alpha confidence interval using the method kind.
`construct_circuits`([measurement])	Construct the Amplitude Estimation w/o QPE quantum circuits.
`is_good_state`(measurement)	Determine whether a given state is a good state.
`post_processing`(value)	Post processing of the raw amplitude estimation output \(0 \leq a \leq 1\).
`run`([quantum_instance])	Execute the algorithm with selected backend.
`set_backend`(backend, **kwargs)	Sets backend with configuration.

Attributes

`a_factory`	Get the A operator encoding the amplitude a that’s approximated, i.e.
`backend`	Returns backend.
`grover_operator`	Get the \(\mathcal{Q}\) operator, or Grover operator.
`i_objective`	Get the index of the objective qubit.
`objective_qubits`	Get the criterion for a measurement outcome to be in a ‚good‘ state.
`q_factory`	Get the Q operator, or Grover-operator for the Amplitude Estimation algorithm, i.e.
`quantum_instance`	Returns quantum instance.
`random`	Return a numpy random.
`state_preparation`	Get the \(\mathcal{A}\) operator encoding the amplitude \(a\).

property a_factory¶

Get the A operator encoding the amplitude a that’s approximated, i.e.

A |0>_n |0> = sqrt{1 - a} |psi_0>_n |0> + sqrt{a} |psi_1>_n |1>

see the original Brassard paper (https://arxiv.org/abs/quant-ph/0005055) for more detail.

Rückgabe: the A operator as CircuitFactory
Rückgabetyp: CircuitFactory

property backend¶

Returns backend.

Rückgabetyp: Union[Backend, BaseBackend]

confidence_interval(alpha, kind='fisher')[Quellcode]¶

Compute the alpha confidence interval using the method kind.

The confidence level is (1 - alpha) and supported kinds are ‚fisher‘, ‚likelihood_ratio‘ and ‚observed_fisher‘ with shorthand notations ‚fi‘, ‚lr‘ and ‚oi‘, respectively.

Parameter

alpha (float) – The confidence level.
kind (str) – The method to compute the confidence interval. Defaults to ‚fisher‘, which computes the theoretical Fisher information.

Rückgabetyp

List[float]

Rückgabe

The specified confidence interval.

Verursacht

AquaError – If run() hasn’t been called yet.
NotImplementedError – If the method kind is not supported.

construct_circuits(measurement=False)[Quellcode]¶

Construct the Amplitude Estimation w/o QPE quantum circuits.

Parameter: measurement (bool) – Boolean flag to indicate if measurement should be included in the circuits.
Rückgabetyp: List[QuantumCircuit]
Rückgabe: A list with the QuantumCircuit objects for the algorithm.

property grover_operator¶

Get the \(\mathcal{Q}\) operator, or Grover operator.

If the Grover operator is not set, we try to build it from the \(\mathcal{A}\) operator and objective_qubits. This only works if objective_qubits is a list of integers.

Rückgabetyp: Optional[QuantumCircuit]
Rückgabe: The Grover operator, or None if neither the Grover operator nor the \(\mathcal{A}\) operator is set.

property i_objective¶

Get the index of the objective qubit. The objective qubit marks the |psi_0> state (called ‚bad states‘ in https://arxiv.org/abs/quant-ph/0005055) with |0> and |psi_1> (‚good‘ states) with |1>. If the A operator performs the mapping

A |0>_n |0> = sqrt{1 - a} |psi_0>_n |0> + sqrt{a} |psi_1>_n |1>

then, the objective qubit is the last one (which is either |0> or |1>).

If the objective qubit (i_objective) is not set, we check if the Q operator (q_factory) is set and return the index specified there. If the q_factory is not defined, the index equals the number of qubits of the A operator (a_factory) minus one. If also the a_factory is not set, return None.

Rückgabe: the index of the objective qubit
Rückgabetyp: int

is_good_state(measurement)¶

Determine whether a given state is a good state.

Parameter: measurement (str) – A measurement as bitstring, e.g. ‚01100‘.
Rückgabetyp: bool
Rückgabe: True if the measurement corresponds to a good state, False otherwise.
Verursacht: ValueError – If self.objective_qubits is not set.

property objective_qubits¶

Get the criterion for a measurement outcome to be in a ‚good‘ state.

Rückgabetyp: Optional[List[int]]
Rückgabe: The criterion as list of qubit indices.

post_processing(value)¶

Post processing of the raw amplitude estimation output \(0 \leq a \leq 1\).

Parameter: value (float) – The estimation value \(a\).
Rückgabetyp: float
Rückgabe: The value after post processing, usually mapping the interval \([0, 1]\) to the target interval.

property q_factory¶

Get the Q operator, or Grover-operator for the Amplitude Estimation algorithm, i.e.

\[\mathcal{Q} = \mathcal{A} \mathcal{S}_0 \mathcal{A}^\dagger \mathcal{S}_f,\]

where \(\mathcal{S}_0\) reflects about the |0>_n state and S_psi0 reflects about \(|\Psi_0\rangle_n\). See https://arxiv.org/abs/quant-ph/0005055 for more detail.

If the Q operator is not set, we try to build it from the A operator. If neither the A operator is set, None is returned.

Rückgabe: returns the current Q factory of the algorithm
Rückgabetyp: QFactory

property quantum_instance¶

Returns quantum instance.

Rückgabetyp: Optional[QuantumInstance]

property random¶: Return a numpy random.

run(quantum_instance=None, **kwargs)¶

Execute the algorithm with selected backend.

Parameter

quantum_instance (Union[QuantumInstance, Backend, BaseBackend, None]) – the experimental setting.
kwargs (dict) – kwargs

Rückgabe

results of an algorithm.

Rückgabetyp

dict

Verursacht

AquaError – If a quantum instance or backend has not been provided

set_backend(backend, **kwargs)¶

Sets backend with configuration.

Rückgabetyp: None

property state_preparation¶

Get the \(\mathcal{A}\) operator encoding the amplitude \(a\).

Rückgabetyp: QuantumCircuit
Rückgabe: The \(\mathcal{A}\) operator as QuantumCircuit.