#
# Copyright © 2022-2023 University of Strasbourg. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
from fractions import Fraction
from symengine import Matrix, pi
from mimiqcircuits.printutils import print_wrapped_parens
import sympy as sp
import numpy as np
import mimiqcircuits as mc
[docs]
class Power(mc.Operation):
"""Power operation.
Represents a Power operation raised to a specified exponent.
Examples:
>>> from mimiqcircuits import *
>>> c= Circuit()
>>> c.push(Power(GateX(),1/2),1)
2-qubit circuit with 1 instructions:
└── SX @ q[1]
<BLANKLINE>
>>> c.push(Power(GateX(),5),1)
2-qubit circuit with 2 instructions:
├── SX @ q[1]
└── X**5 @ q[1]
<BLANKLINE>
>>> c.decompose()
2-qubit circuit with 6 instructions:
├── U(1.57079632679490, -1.57079632679490, 1.57079632679490, 0.785398163397448) @ q[1]
├── X @ q[1]
├── X @ q[1]
├── X @ q[1]
├── X @ q[1]
└── X @ q[1]
<BLANKLINE>
"""
_name = "Power"
_num_qubits = None
_num_bits = 0
_num_cregs = 0
_op = None
_parnames = ("exponent",)
def __init__(self, operation, exponent, *args, **kwargs):
if isinstance(operation, type) and issubclass(operation, mc.Operation):
op = operation(*args, **kwargs)
elif isinstance(operation, mc.Operation):
op = operation
else:
raise ValueError("Operation must be an Operation object or type.")
if self.num_bits != 0:
raise ValueError("Power operation cannot act on classical bits.")
if isinstance(op, (mc.Barrier, mc.Reset, mc.Measure)):
raise TypeError(f"{op.__class__.__name__} cannot be powered operation.")
super().__init__()
self._exponent = exponent
self._op = op
self._num_qubits = op.num_qubits
self._num_qregs = op.num_qregs
self._qregsizes = op.qregsizes
self._parnames = op.parnames
if isinstance(op, mc.Power):
self._op = op.op
self._exponent = exponent * op.exponent
@property
def op(self):
return self._op
@op.setter
def op(self, op):
raise ValueError("Cannot set op. Read only parameter.")
@property
def exponent(self):
return self._exponent
@exponent.setter
def exponent(self, power):
raise ValueError("Cannot set exponent. Read only parameter.")
[docs]
def iswrapper(self):
return True
def _power(self, pwr):
return self.op.power(pwr * self._exponent)
[docs]
def power(self, *args):
if len(args) == 0:
return mc.power(self)
elif len(args) == 1:
exponent = args[0]
return self._power(exponent)
else:
raise ValueError("Invalid number of arguments.")
def __pow__(self, exponent):
return self.power(exponent)
[docs]
def inverse(self):
return mc.Inverse(self)
[docs]
def control(self, *args):
if len(args) == 0:
return mc.control(self)
elif len(args) == 1:
num_controls = args[0]
return mc.Control(num_controls, self)
else:
raise ValueError("Invalid number of arguments.")
[docs]
def parallel(self, *args):
if len(args) == 0:
return mc.parallel(self)
elif len(args) == 1:
num_repeats = args[0]
return mc.Parallel(num_repeats, self)
else:
raise ValueError("Invalid number of arguments.")
[docs]
def matrix(self):
matrix = sp.Matrix(self.op.matrix().tolist())
pow_matrix = matrix ** (self.exponent)
return Matrix(sp.simplify(sp.Matrix(pow_matrix.tolist()).evalf()))
[docs]
def getparams(self):
return self.op.getparams()
def __str__(self):
if self._op == mc.GateX() and self._exponent == 1 / 2:
return mc.GateSX().name
fraction = Fraction(self.exponent).limit_denominator(100)
if float(fraction) == self.exponent and int(fraction) != self.exponent:
return f"{print_wrapped_parens(self.op)}**({fraction})"
if self.exponent == pi:
return f"{print_wrapped_parens(self.op)}**π"
if self.exponent == -pi:
return f"{print_wrapped_parens(self.op)}**(-π)"
divpi = Fraction(self.exponent / np.pi).limit_denominator(100)
if float(divpi) == self.exponent / np.pi:
if divpi == 1:
return f"{print_wrapped_parens(self.op)}**π"
if divpi == -1:
return f"{print_wrapped_parens(self.op)}**(-1)"
if divpi > 0:
return f"{print_wrapped_parens(self.op)}**({divpi} * π)"
return f"{print_wrapped_parens(self.op)}**(({divpi}) * π)"
if self.exponent < 0:
return f"{print_wrapped_parens(self.op)}**({self.exponent})"
return f"{print_wrapped_parens(self.op)}**{self.exponent}"
def __repr__(self):
return self.__str__()
[docs]
def evaluate(self, d):
exponent = self.exponent
return self.op.evaluate(d).power(exponent)
def _decompose(self, circ, qubits, bits):
if isinstance(self.exponent, int) and self.exponent >= 1:
for _ in range(self.exponent):
circ.push(self.op, *qubits)
return circ
# try to decompose,
# if there is only a gate, maybe it is ok
# if the gates are all diagonal then we can continue
# otherwise just do nothing and push the same thing
cop = self.op.decompose()
if len(cop) == 1:
circ.push(cop.instructions[0].operation._power(self.exponent), *qubits)
return circ
circ.push(self, *qubits)
return circ
[docs]
def decompose(self):
return self._decompose(
mc.Circuit(), range(self.num_qubits), range(self.num_bits)
)
# export operation
__all__ = ["Power"]
