Skip to main contentIBM Quantum Documentation
This page is from a dev version of Qiskit SDK. This is a new interface that does not exist in the stable version.

LinearAmplitudeFunctionGate

class qiskit.circuit.library.LinearAmplitudeFunctionGate(num_state_qubits, slope, offset, domain, image, rescaling_factor=1, breakpoints=None, label='F')

GitHub

Bases: Gate

A circuit implementing a (piecewise) linear function on qubit amplitudes.

An amplitude function FF of a function ff is a mapping

F∣x⟩∣0⟩=1−f^(x)∣x⟩∣0⟩+f^(x)∣x⟩∣1⟩.F|x\rangle|0\rangle = \sqrt{1 - \hat{f}(x)} |x\rangle|0\rangle + \sqrt{\hat{f}(x)} |x\rangle|1\rangle.

for a function f^:{0,...,2n−1}→[0,1]\hat{f}: \{ 0, ..., 2^n - 1 \} \rightarrow [0, 1], where ∣x⟩|x\rangle is a nn qubit state.

This circuit implements FF for piecewise linear functions f^\hat{f}. In this case, the mapping FF can be approximately implemented using a Taylor expansion and linearly controlled Pauli-Y rotations, see [1, 2] for more detail. This approximation uses a rescaling_factor to determine the accuracy of the Taylor expansion.

In general, the function of interest ff is defined from some interval [a,b][a,b], the domain to [c,d][c,d], the image, instead of {1,...,N}\{ 1, ..., N \} to [0,1][0, 1]. Using an affine transformation we can rescale ff to f^\hat{f}:

f^(x)=f(ϕ(x))−cd−c\hat{f}(x) = \frac{f(\phi(x)) - c}{d - c}

with

ϕ(x)=a+b−a2n−1x.\phi(x) = a + \frac{b - a}{2^n - 1} x.

If ff is a piecewise linear function on mm intervals [pi−1,pi],i∈{1,...,m}[p_{i-1}, p_i], i \in \{1, ..., m\} with slopes αi\alpha_i and offsets βi\beta_i it can be written as

f(x)=∑i=1m1[pi−1,pi](x)(αix+βi)f(x) = \sum_{i=1}^m 1_{[p_{i-1}, p_i]}(x) (\alpha_i x + \beta_i)

where 1[a,b]1_{[a, b]} is an indication function that is 1 if the argument is in the interval [a,b][a, b] and otherwise 0. The breakpoints pip_i can be specified by the breakpoints argument.

References

[1]: Woerner, S., & Egger, D. J. (2018).

Quantum Risk Analysis. arXiv:1806.06893

[2]: Gacon, J., Zoufal, C., & Woerner, S. (2020).

Quantum-Enhanced Simulation-Based Optimization. arXiv:2005.10780

Parameters

  • num_state_qubits (int) – The number of qubits used to encode the variable xx.
  • slope (float |list[float]) – The slope of the linear function. Can be a list of slopes if it is a piecewise linear function.
  • offset (float |list[float]) – The offset of the linear function. Can be a list of offsets if it is a piecewise linear function.
  • domain (tuple[float, float]) – The domain of the function as tuple (xmin⁡,xmax⁡)(x_{\min}, x_{\max}).
  • image (tuple[float, float]) – The image of the function as tuple (fmin⁡,fmax⁡)(f_{\min}, f_{\max}).
  • rescaling_factor (float) – The rescaling factor to adjust the accuracy in the Taylor approximation.
  • breakpoints (list[float] | None) – The breakpoints if the function is piecewise linear. If None, the function is not piecewise.
  • label (str) – A label for the gate.

Attributes

base_class

Get the base class of this instruction. This is guaranteed to be in the inheritance tree of self.

The “base class” of an instruction is the lowest class in its inheritance tree that the object should be considered entirely compatible with for _all_ circuit applications. This typically means that the subclass is defined purely to offer some sort of programmer convenience over the base class, and the base class is the “true” class for a behavioral perspective. In particular, you should not override base_class if you are defining a custom version of an instruction that will be implemented differently by hardware, such as an alternative measurement strategy, or a version of a parametrized gate with a particular set of parameters for the purposes of distinguishing it in a Target from the full parametrized gate.

This is often exactly equivalent to type(obj), except in the case of singleton instances of standard-library instructions. These singleton instances are special subclasses of their base class, and this property will return that base. For example:

>>> isinstance(XGate(), XGate)
True
>>> type(XGate()) is XGate
False
>>> XGate().base_class is XGate
True

In general, you should not rely on the precise class of an instruction; within a given circuit, it is expected that Instruction.name should be a more suitable discriminator in most situations.

decompositions

Get the decompositions of the instruction from the SessionEquivalenceLibrary.

definition

Return definition in terms of other basic gates.

label

Return instruction label

mutable

Is this instance is a mutable unique instance or not.

If this attribute is False the gate instance is a shared singleton and is not mutable.

name

Return the name.

num_clbits

Return the number of clbits.

num_qubits

Return the number of qubits.

params

The parameters of this Instruction. Ideally these will be gate angles.

Methods

post_processing

post_processing(scaled_value)

GitHub

Map the function value of the approximated f^\hat{f} to ff.

Parameters

scaled_value (float) – A function value from the Taylor expansion of f^(x)\hat{f}(x).

Returns

The scaled_value mapped back to the domain of ff, by first inverting the transformation used for the Taylor approximation and then mapping back from [0,1][0, 1] to the original domain.

Return type

float

Was this page helpful?
Report a bug or request content on GitHub.