def test_conventions():
qubit = numpy.random.randint(0, 3)
angle = Variable("angle")
Rx1 = Rx(target=qubit, angle=angle)
Rx2 = QCircuit.wrap_gate(
RotationGateImpl(axis="X", target=qubit, angle=angle))
Rx3 = QCircuit.wrap_gate(
RotationGateImpl(axis="x", target=qubit, angle=angle))
Rx4 = RotationGate(axis=0, target=qubit, angle=angle)
Rx5 = RotationGate(axis="X", target=qubit, angle=angle)
Rx6 = RotationGate(axis="x", target=qubit, angle=angle)
Rx7 = RotationGate(axis=0, target=qubit, angle=angle)
Rx7.axis = "X"
ll = [Rx1, Rx2, Rx3, Rx4, Rx5, Rx6, Rx7]
for l1 in ll:
for l2 in ll:
assert (l1 == l2)
qubit = 2
for c in [None, 0, 3]:
for angle in ["angle", 0, 1.234]:
for axes in [[0, "x", "X"], [1, "y", "Y"], [2, "z", "Z"]]:
ll = [
RotationGate(axis=i, target=qubit, control=c, angle=angle)
for i in axes
]
for l1 in ll:
for l2 in ll:
assert (l1 == l2)
l1.axis = axes[numpy.random.randint(0, 2)]
assert (l1 == l2)
def compile_controlled_rotation(gate: RotationGateImpl,
angles: list = None) -> QCircuit:
"""
Recompilation of a controlled-rotation gate
Basis change into Rz then recompilation of controled Rz, then change basis back
:param gate: The rotational gate
:param angles: new angles to set, given as a list of two. If None the angle in the gate is used (default)
:return: set of gates wrapped in QCircuit class
"""
if not gate.is_controlled():
return QCircuit.wrap_gate(gate)
if not isinstance(gate, RotationGateImpl):
return QCircuit.wrap_gate(gate)
if angles is None:
angles = [gate.parameter / 2, -gate.parameter / 2]
if len(gate.target) > 1:
return compile_controlled_rotation(gate=compile_multitarget(gate=gate),
angles=angles)
target = gate.target
control = gate.control
result = QCircuit()
result += change_basis(target=target, axis=gate._axis)
result += RotationGateImpl(axis="z", target=target, angle=angles[0])
result += QGateImpl(name="X", target=target, control=control)
result += RotationGateImpl(axis="Z", target=target, angle=angles[1])
result += QGateImpl(name="X", target=target, control=control)
result += change_basis(target=target, axis=gate._axis, daggered=True)
result.n_qubits = result.max_qubit() + 1
return result
def compile_ry(gate: RotationGateImpl,
controlled_rotation: bool = False) -> QCircuit:
"""
Compile Ry gates into Rx and Rz.
Parameters
----------
gate:
the gate.
controlled_rotation:
determines if the decomposition of the controlled-Ry gate will be performed in compile_controlled_rotation,
if not, decomposition will be performed here
Returns
-------
QCircuit, the result of compilation.
"""
if gate.name.lower() == "ry":
if not (gate.is_controlled() and controlled_rotation):
return Rz(target=gate.target, control=None, angle=-numpy.pi / 2) \
+ Rx(target=gate.target, control=gate.control, angle=gate.parameter) \
+ Rz(target=gate.target, control=None, angle=numpy.pi / 2)
return QCircuit.wrap_gate(gate)
def compile_controlled_rotation(gate: RotationGateImpl) -> QCircuit:
"""
Recompilation of a controlled-rotation gate
Basis change into Rz then recompilation of controled Rz, then change basis back
:param gate: The rotational gate
:return: set of gates wrapped in QCircuit class
"""
if not gate.is_controlled():
return QCircuit.wrap_gate(gate)
if not isinstance(gate, RotationGateImpl):
return QCircuit.wrap_gate(gate)
if len(gate.target) > 1:
return compile_controlled_rotation(gate=compile_multitarget(gate=gate))
target = gate.target
control = gate.control
k = len(control)
cind = _pattern(k) + [k - 1]
result = QCircuit()
result += change_basis(target=target, axis=gate._axis)
coeff = -1 / pow(2, k)
for i, ci in enumerate(cind):
coeff *= -1
result += Rz(target=target, angle=coeff * gate.parameter)
result += CNOT(control[ci], target)
result += change_basis(target=target, axis=gate._axis, daggered=True)
result.n_qubits = result.max_qubit() + 1
return result
def Rz(angle,
target: typing.Union[list, int],
control: typing.Union[list, int] = None) -> QCircuit:
"""
Notes
----------
Rz gate of the form
.. math::
R_{z}(\\text{angle}) = e^{-i\\frac{\\text{angle}}{2} \\sigma_{z}}
Parameters
----------
angle
Hashable type (will be treated as Variable) or Numeric type (static angle)
target
integer or list of integers
control
integer or list of integers
Returns
QCircuit object with this RotationGate
-------
"""
return QCircuit.wrap_gate(
RotationGateImpl(axis=2, angle=angle, target=target, control=control))
def RotationGate(axis: int,
angle: typing.Union[typing.Hashable, numbers.Number],
target: typing.Union[list, int],
control: typing.Union[list, int] = None):
"""
Notes
----------
Initialize an abstract rotation gate of the form
.. math::
R_{\\text{axis}}(\\text{angle}) = e^{-i\\frac{\\text{angle}}{2} \\sigma_{\\text{axis}}}
Parameters
----------
axis
integer 1 for x, 2 for y, 3 for z
angle
Hashable type (will be treated as Variable) or Numeric type (static angle)
target
integer or list of integers
control
integer or list of integers
Returns
-------
QCircuit object with this RotationGate
"""
return QCircuit.wrap_gate(
RotationGateImpl(axis=axis,
angle=angle,
target=target,
control=control))
def ExpPauli(paulistring: typing.Union[PauliString, str],
angle,
control: typing.Union[list, int] = None):
"""Exponentiated Pauligate:
ExpPauli(PauliString, angle) = exp(-i* angle/2* PauliString)
Parameters
----------
paulistring :
given as PauliString structure or as string or dict or list
if given as string: Format should be like X(0)Y(3)Z(2)
if given as list: Format should be like [(0,'X'),(3,'Y'),(2,'Z')]
if given as dict: Format should be like { 0:'X', 3:'Y', 2:'Z' }
angle :
the angle (will be multiplied by paulistring coefficient if there is one)
control :
control qubits
paulistring: typing.Union[PauliString :
str] :
control: typing.Union[list :
int] :
(Default value = None)
Returns
-------
type
Gate wrapped in circuit
"""
if isinstance(paulistring, str):
ps = PauliString.from_string(string=paulistring)
elif isinstance(paulistring, list):
ps = PauliString.from_openfermion(key=list)
elif isinstance(paulistring, dict):
ps = PauliString(data=paulistring)
else:
ps = paulistring
# Failsave: If the paulistring contains just one pauli matrix
# it is better to initialize a rotational gate due to strange conventions in some simulators
if len(ps.items()) == 1:
target, axis = tuple(ps.items())[0]
return QCircuit.wrap_gate(
RotationGateImpl(axis=axis,
target=target,
angle=ps.coeff * assign_variable(angle),
control=control))
else:
return QCircuit.wrap_gate(
ExponentialPauliGateImpl(paulistring=ps,
angle=angle,
control=control))