def expand(self):
weight = self.parameters[0]
# Interpret first and last wire as r and p
r = self.wires[0]
p = self.wires[-1]
# Sequence of the wires entering the CNOTs between wires 'r' and 'p'
set_cnot_wires = [
self.wires[l:l + 2] for l in range(len(self.wires) - 1)
]
with qml.tape.QuantumTape() as tape:
# ------------------------------------------------------------------
# Apply the first layer
# U_1, U_2 acting on wires 'r' and 'p'
RX(-np.pi / 2, wires=r)
Hadamard(wires=p)
# Applying CNOTs between wires 'r' and 'p'
for cnot_wires in set_cnot_wires:
CNOT(wires=cnot_wires)
# Z rotation acting on wire 'p'
RZ(weight / 2, wires=p)
# Applying CNOTs in reverse order
for cnot_wires in reversed(set_cnot_wires):
CNOT(wires=cnot_wires)
# U_1^+, U_2^+ acting on wires 'r' and 'p'
RX(np.pi / 2, wires=r)
Hadamard(wires=p)
# ------------------------------------------------------------------
# Apply the second layer
# U_1, U_2 acting on wires 'r' and 'p'
Hadamard(wires=r)
RX(-np.pi / 2, wires=p)
# Applying CNOTs between wires 'r' and 'p'
for cnot_wires in set_cnot_wires:
CNOT(wires=cnot_wires)
# Z rotation acting on wire 'p'
RZ(-weight / 2, wires=p)
# Applying CNOTs in reverse order
for cnot_wires in reversed(set_cnot_wires):
CNOT(wires=cnot_wires)
# U_1^+, U_2^+ acting on wires 'r' and 'p'
Hadamard(wires=r)
RX(np.pi / 2, wires=p)
return tape
def AngleEmbedding(features, wires, rotation="X"):
r"""
Encodes :math:`N` features into the rotation angles of :math:`n` qubits, where :math:`N \leq n`.
The rotations can be chosen as either :class:`~pennylane.ops.RX`, :class:`~pennylane.ops.RY`
or :class:`~pennylane.ops.RZ` gates, as defined by the ``rotation`` parameter:
* ``rotation='X'`` uses the features as angles of RX rotations
* ``rotation='Y'`` uses the features as angles of RY rotations
* ``rotation='Z'`` uses the features as angles of RZ rotations
The length of ``features`` has to be smaller or equal to the number of qubits. If there are fewer entries in
``features`` than rotations, the circuit does not apply the remaining rotation gates.
Args:
features (array): input array of shape ``(N,)``, where N is the number of input features to embed,
with :math:`N\leq n`
wires (Sequence[int] or int): qubit indices that the template acts on
rotation (str): Type of rotations used
Raises:
ValueError: if inputs do not have the correct format
"""
#############
# Input checks
_check_no_variable(rotation, msg="'rotation' cannot be differentiable")
wires = _check_wires(wires)
_check_shape(
features,
(len(wires), ),
bound="max",
msg="'features' must be of shape {} or smaller; "
"got {}.".format((len(wires), ), _get_shape(features)),
)
_check_type(rotation, [str],
msg="'rotation' must be a string; got {}".format(rotation))
_check_is_in_options(
rotation,
["X", "Y", "Z"],
msg="did not recognize option {} for 'rotation'.".format(rotation),
)
###############
if rotation == "X":
for f, w in zip(features, wires):
RX(f, wires=w)
elif rotation == "Y":
for f, w in zip(features, wires):
RY(f, wires=w)
elif rotation == "Z":
for f, w in zip(features, wires):
RZ(f, wires=w)
def AngleEmbedding(features, wires, rotation='X'):
r"""
Encodes :math:`N` features into the rotation angles of :math:`n` qubits, where :math:`N \leq n`.
The rotations can be chosen as either :class:`~pennylane.ops.RX`, :class:`~pennylane.ops.RY`
or :class:`~pennylane.ops.RZ` gates, as defined by the ``rotation`` parameter:
* ``rotation='X'`` uses the features as angles of RX rotations
* ``rotation='Y'`` uses the features as angles of RY rotations
* ``rotation='Z'`` uses the features as angles of RZ rotations
The length of ``features`` has to be smaller or equal to the number of qubits. If there are fewer entries in
``features`` than rotations, the circuit does not apply the remaining rotation gates.
This embedding method can also be used to encode a binary sequence into a basis state. For example, to prepare
basis state :math:`|0,1,1,0\rangle`, choose ``rotation='X'`` and use the
feature vector :math:`[0, \pi/2, \pi/2, 0]`. Alternatively, one can use the :mod:`BasisEmbedding()` template.
Args:
features (array): Input array of shape ``(N,)``, where N is the number of features
to embed. ``N`` must be smaller or equal to the total number of wires.
wires (Sequence[int]): sequence of qubit indices that the template acts on
Keyword Args:
rotation (str): Type of rotations used
Raises:
ValueError: if ``features`` or ``wires`` is invalid
"""
if not isinstance(wires, Iterable):
raise ValueError(
"Wires must be passed as a list of integers; got {}.".format(
wires))
if len(features) > len(wires):
raise ValueError(
"Number of features to embed cannot be larger than number of wires, which is {}; "
"got {}.".format(len(wires), len(features)))
if rotation == 'X':
for f, w in zip(features, wires):
RX(f, wires=w)
elif rotation == 'Y':
for f, w in zip(features, wires):
RY(f, wires=w)
elif rotation == 'Z':
for f, w in zip(features, wires):
RZ(f, wires=w)
else:
raise ValueError(
"Rotation has to be `X`, `Y` or `Z`; got {}.".format(rotation))
def _layer1(weight, s, r, q, p, set_cnot_wires):
r"""Implement the first layer of the circuit to exponentiate the double-excitation
operator entering the UCCSD ansatz.
.. math::
\hat{U}_{pqrs}^{(1)}(\theta) = \mathrm{exp} \Big\{ \frac{i\theta}{8}
\bigotimes_{b=s+1}^{r-1} \hat{Z}_b \bigotimes_{a=q+1}^{p-1} \hat{Z}_a
(\hat{X}_s \hat{X}_r \hat{Y}_q \hat{X}_p) \Big\}
Args:
weight (float): angle :math:`\theta` entering the Z rotation acting on wire ``p``
s (int): qubit index ``s``
r (int): qubit index ``r``
q (int): qubit index ``q``
p (int): qubit index ``p``
set_cnot_wires (sequence[int]): two-element sequence with the indices of the qubits
the CNOT gates act on
"""
# U_1, U_2, U_3, U_4 acting on wires 's', 'r', 'q' and 'p'
Hadamard(wires=s)
Hadamard(wires=r)
RX(-np.pi / 2, wires=q)
Hadamard(wires=p)
# Applying CNOTs between wires 's' and 'p'
for cnot_wires in set_cnot_wires:
CNOT(wires=cnot_wires)
# Z rotation acting on wire 'p'
RZ(weight / 8, wires=p)
# Applying CNOTs in reverse order
for cnot_wires in reversed(set_cnot_wires):
CNOT(wires=cnot_wires)
# U_1^+, U_2^+, U_3^+, U_4^+ acting on wires 's', 'r', 'q' and 'p'
Hadamard(wires=s)
Hadamard(wires=r)
RX(np.pi / 2, wires=q)
Hadamard(wires=p)
def _layer6(weight, s, r, q, p, set_cnot_wires):
r"""Implement the sixth layer of the circuit to exponentiate the double-excitation
operator entering the UCCSD ansatz.
.. math::
\hat{U}_{pqrs}^{(6)}(\theta) = \mathrm{exp} \Big\{ -\frac{i\theta}{8}
\bigotimes_{b=s+1}^{r-1} \hat{Z}_b \bigotimes_{a=q+1}^{p-1} \hat{Z}_a
(\hat{X}_s \hat{Y}_r \hat{X}_q \hat{X}_p) \Big\}
Args:
weight (float): angle :math:`\theta` entering the Z rotation acting on wire ``p``
s (int): qubit index ``s``
r (int): qubit index ``r``
q (int): qubit index ``q``
p (int): qubit index ``p``
set_cnot_wires (list[Wires]): list of CNOT wires
"""
# U_1, U_2, U_3, U_4 acting on wires 's', 'r', 'q' and 'p'
Hadamard(wires=s)
RX(-np.pi / 2, wires=r)
Hadamard(wires=q)
Hadamard(wires=p)
# Applying CNOTs
for cnot_wires in set_cnot_wires:
CNOT(wires=cnot_wires)
# Z rotation acting on wire 'p'
RZ(-weight / 8, wires=p)
# Applying CNOTs in reverse order
for cnot_wires in reversed(set_cnot_wires):
CNOT(wires=cnot_wires)
# U_1^+, U_2^+, U_3^+, U_4^+ acting on wires 's', 'r', 'q' and 'p'
Hadamard(wires=s)
RX(np.pi / 2, wires=r)
Hadamard(wires=q)
Hadamard(wires=p)
def qaoa_feature_encoding_hamiltonian(features, n_features, wires):
"""Implements the encoding Hamiltonian of the QAOA embedding.
Args:
features (array): array of features to encode
n_features (int): number of features to encode
"""
for idx, w in enumerate(wires):
# Either feed in feature
if idx < n_features:
RX(features[idx], wires=w)
# or a Hadamard
else:
Hadamard(wires=w)
def AngleEmbedding(features, wires, rotation='X'):
r"""
Encodes :math:`N` features into the rotation angles of :math:`n` qubits, where :math:`N \leq n`.
The rotations can be chosen as either :class:`~pennylane.ops.RX`, :class:`~pennylane.ops.RY`
or :class:`~pennylane.ops.RZ` gates, as defined by the ``rotation`` parameter:
* ``rotation='X'`` uses the features as angles of RX rotations
* ``rotation='Y'`` uses the features as angles of RY rotations
* ``rotation='Z'`` uses the features as angles of RZ rotations
The length of ``features`` has to be smaller or equal to the number of qubits. If there are fewer entries in
``features`` than rotations, the circuit does not apply the remaining rotation gates.
Args:
features (array): input array of shape ``(N,)``, where N is the number of input features to embed,
with :math:`N\leq n`
wires (Sequence[int] or int): qubit indices that the template acts on
rotation (str): Type of rotations used
Raises:
ValueError: if inputs do not have the correct format
"""
#############
# Input checks
_check_no_variable([rotation], ['rotation'])
wires, n_wires = _check_wires(wires)
msg = "AngleEmbedding cannot process more features than number of qubits {};" \
"got {}.".format(n_wires, len(features))
_check_shape(features, (n_wires,), bound='max', msg=msg)
_check_type(rotation, [str])
msg = "Rotation strategy {} not recognized.".format(rotation)
_check_hyperp_is_in_options(rotation, ['X', 'Y', 'Z'], msg=msg)
###############
if rotation == 'X':
for f, w in zip(features, wires):
RX(f, wires=w)
elif rotation == 'Y':
for f, w in zip(features, wires):
RY(f, wires=w)
elif rotation == 'Z':
for f, w in zip(features, wires):
RZ(f, wires=w)
def SingleExcitationUnitary(weight, wires=None):
r"""Circuit to exponentiate the tensor product of Pauli matrices representing the
single-excitation operator entering the Unitary Coupled-Cluster Singles
and Doubles (UCCSD) ansatz. UCCSD is a VQE ansatz commonly used to run quantum
chemistry simulations.
The CC single-excitation operator is given by
.. math::
\hat{U}_{pr}(\theta) = \mathrm{exp} \{ \theta_{pr} (\hat{c}_p^\dagger \hat{c}_r
-\mathrm{H.c.}) \},
where :math:`\hat{c}` and :math:`\hat{c}^\dagger` are the fermionic annihilation and
creation operators and the indices :math:`r` and :math:`p` run over the occupied and
unoccupied molecular orbitals, respectively. Using the `Jordan-Wigner transformation
<https://arxiv.org/abs/1208.5986>`_ the fermionic operator defined above can be written
in terms of Pauli matrices (for more details see
`arXiv:1805.04340 <https://arxiv.org/abs/1805.04340>`_).
.. math::
\hat{U}_{pr}(\theta) = \mathrm{exp} \Big\{ \frac{i\theta}{2}
\bigotimes_{a=r+1}^{p-1}\hat{Z}_a (\hat{Y}_r \hat{X}_p) \Big\}
\mathrm{exp} \Big\{ -\frac{i\theta}{2}
\bigotimes_{a=r+1}^{p-1} \hat{Z}_a (\hat{X}_r \hat{Y}_p) \Big\}.
The quantum circuit to exponentiate the tensor product of Pauli matrices entering
the latter equation is shown below (see `arXiv:1805.04340 <https://arxiv.org/abs/1805.04340>`_):
|
.. figure:: ../../_static/templates/subroutines/single_excitation_unitary.png
:align: center
:width: 60%
:target: javascript:void(0);
|
As explained in `Seely et al. (2012) <https://arxiv.org/abs/1208.5986>`_,
the exponential of a tensor product of Pauli-Z operators can be decomposed in terms of
:math:`2(n-1)` CNOT gates and a single-qubit Z-rotation referred to as :math:`U_\theta` in
the figure above. If there are :math:`X` or :math:`Y` Pauli matrices in the product,
the Hadamard (:math:`H`) or :math:`R_x` gate has to be applied to change to the
:math:`X` or :math:`Y` basis, respectively. The latter operations are denoted as
:math:`U_1` and :math:`U_2` in the figure above. See the Usage Details section for more
information.
Args:
weight (float): angle :math:`\theta` entering the Z rotation acting on wire ``p``
wires (Iterable or Wires): Wires that the template acts on.
The wires represent the subset of orbitals in the interval ``[r, p]``. Must be of
minimum length 2. The first wire is interpreted as ``r`` and the last wire as ``p``.
Wires in between are acted on with CNOT gates to compute the parity of the set
of qubits.
Raises:
ValueError: if inputs do not have the correct format
.. UsageDetails::
Notice that:
#. :math:`\hat{U}_{pr}(\theta)` involves two exponentiations where :math:`\hat{U}_1`,
:math:`\hat{U}_2`, and :math:`\hat{U}_\theta` are defined as follows,
.. math::
[U_1, U_2, U_{\theta}] = \Bigg\{\bigg[R_x(-\pi/2), H, R_z(\theta/2)\bigg],
\bigg[H, R_x(-\frac{\pi}{2}), R_z(-\theta/2) \bigg] \Bigg\}
#. For a given pair ``[r, p]``, ten single-qubit and ``4*(len(wires)-1)`` CNOT
operations are applied. Notice also that CNOT gates act only on qubits
``wires[1]`` to ``wires[-2]``. The operations performed across these qubits
are shown in dashed lines in the figure above.
An example of how to use this template is shown below:
.. code-block:: python
import pennylane as qml
from pennylane.templates import SingleExcitationUnitary
dev = qml.device('default.qubit', wires=3)
@qml.qnode(dev)
def circuit(weight, wires=None):
SingleExcitationUnitary(weight, wires=wires)
return qml.expval(qml.PauliZ(0))
weight = 0.56
print(circuit(weight, wires=[0, 1, 2]))
"""
##############
# Input checks
wires = Wires(wires)
if len(wires) < 2:
raise ValueError("expected at least two wires; got {}".format(
len(wires)))
expected_shape = ()
check_shape(
weight,
expected_shape,
msg="'weight' must be of shape {}; got {}".format(
expected_shape, get_shape(weight)),
)
###############
# Interpret first and last wire as r and p
r = wires[0]
p = wires[-1]
# Sequence of the wires entering the CNOTs between wires 'r' and 'p'
set_cnot_wires = [wires.subset([l, l + 1]) for l in range(len(wires) - 1)]
# ------------------------------------------------------------------
# Apply the first layer
# U_1, U_2 acting on wires 'r' and 'p'
RX(-np.pi / 2, wires=r)
Hadamard(wires=p)
# Applying CNOTs between wires 'r' and 'p'
for cnot_wires in set_cnot_wires:
CNOT(wires=cnot_wires)
# Z rotation acting on wire 'p'
RZ(weight / 2, wires=p)
# Applying CNOTs in reverse order
for cnot_wires in reversed(set_cnot_wires):
CNOT(wires=cnot_wires)
# U_1^+, U_2^+ acting on wires 'r' and 'p'
RX(np.pi / 2, wires=r)
Hadamard(wires=p)
# ------------------------------------------------------------------
# Apply the second layer
# U_1, U_2 acting on wires 'r' and 'p'
Hadamard(wires=r)
RX(-np.pi / 2, wires=p)
# Applying CNOTs between wires 'r' and 'p'
for cnot_wires in set_cnot_wires:
CNOT(wires=cnot_wires)
# Z rotation acting on wire 'p'
RZ(-weight / 2, wires=p)
# Applying CNOTs in reverse order
for cnot_wires in reversed(set_cnot_wires):
CNOT(wires=cnot_wires)
# U_1^+, U_2^+ acting on wires 'r' and 'p'
Hadamard(wires=r)
RX(np.pi / 2, wires=p)
def ParametrizedTemplate(par1, par2, wires):
RX(par1, wires=wires)
RY(par2, wires=wires)
