tequila-basic 1.9.9__py3-none-any.whl → 1.9.10__py3-none-any.whl

tequila/circuit/gradient.py

@@ -1,6 +1,12 @@
 from tequila.circuit.compiler import CircuitCompiler
-from tequila.objective.objective import Objective, ExpectationValueImpl, Variable, \
-    assign_variable, identity, FixedVariable
+from tequila.objective.objective import (
+    Objective,
+    ExpectationValueImpl,
+    Variable,
+    assign_variable,
+    identity,
+    FixedVariable,
+)
 from tequila import TequilaException
 from tequila.objective import QTensor
 from tequila.simulators.simulator_api import compile
@@ -10,13 +16,13 @@ from tequila.autograd_imports import jax, __AUTOGRAD__BACKEND__
 
 
 def grad(objective: typing.Union[Objective, QTensor], variable: Variable = None, no_compile=False, *args, **kwargs):
-    '''
+    """
     wrapper function for getting the gradients of Objectives,ExpectationValues, Unitaries (including single gates), and Transforms.
     :param obj (QCircuit,ParametrizedGateImpl,Objective,ExpectationValue,Transform,Variable): structure to be differentiated
     :param variables (list of Variable): parameter with respect to which obj should be differentiated.
         default None: total gradient.
     return: dictionary of Objectives, if called on gate, circuit, exp.value, or objective; if Variable or Transform, returns number.
-    '''
+    """
 
     if variable is None:
         # None means that all components are created
@@ -27,13 +33,12 @@ def grad(objective: typing.Union[Objective, QTensor], variable: Variable = None,
             raise TequilaException("Error in gradient: Objective has no variables")
 
         for k in variables:
-            assert (k is not None)
+            assert k is not None
             result[k] = grad(objective, k, no_compile=no_compile)
         return result
     else:
         variable = assign_variable(variable)
 
-
     if isinstance(objective, QTensor):
         f = lambda x: grad(objective=x, variable=variable, *args, **kwargs)
         ff = vectorize(f)
@@ -46,20 +51,25 @@ def grad(objective: typing.Union[Objective, QTensor], variable: Variable = None,
     # if the objective was already translated to a backend
     # we need to reverse that here
     if objective.is_translated():
-        raise TequilaException("\n\ngradient of:{}\ncan not form gradient that was already compiled to a quantum backend\ntq.grad neds to be applied to the abstract - non compiled objective\nE.g. for the (compiled) objective E1 \n\tE1 = tq.compile(E0)\ninstead of doing\n\tdE = tq.grad(E1)\ndo\n\tdE = tq.grad(E0)\nand compile dE afterwards (if wanted) with\n\tdE = tq.compile(dE)\n".format(str(objective)))
-     
+        raise TequilaException(
+            "\n\ngradient of:{}\ncan not form gradient that was already compiled to a quantum backend\ntq.grad neds to be applied to the abstract - non compiled objective\nE.g. for the (compiled) objective E1 \n\tE1 = tq.compile(E0)\ninstead of doing\n\tdE = tq.grad(E1)\ndo\n\tdE = tq.grad(E0)\nand compile dE afterwards (if wanted) with\n\tdE = tq.compile(dE)\n".format(
+                str(objective)
+            )
+        )
 
     # circuit compilation
     if no_compile:
         compiled = objective
     else:
-        compiler = CircuitCompiler(multitarget=True,
-                                   trotterized=True,
-                                   hadamard_power=True,
-                                   power=True,
-                                   controlled_phase=True,
-                                   controlled_rotation=True,
-                                   gradient_mode=True)
+        compiler = CircuitCompiler(
+            multitarget=True,
+            trotterized=True,
+            hadamard_power=True,
+            power=True,
+            controlled_phase=True,
+            controlled_rotation=True,
+            gradient_mode=True,
+        )
 
         compiled = compiler(objective, variables=[variable])
 
@@ -174,15 +184,15 @@ def __grad_objective(objective: Objective, variable: Variable):
 
 
 def __grad_inner(arg, variable):
-    '''
+    """
     a modified loop over __grad_objective, which gets derivatives
      all the way down to variables, return 1 or 0 when a variable is (isnt) identical to var.
     :param arg: a transform or variable object, to be differentiated
     :param variable: the Variable with respect to which par should be differentiated.
     :ivar var: the string representation of variable
-    '''
+    """
 
-    assert (isinstance(variable, Variable))
+    assert isinstance(variable, Variable)
     if isinstance(arg, Variable):
         if arg == variable:
             return 1.0
@@ -196,17 +206,19 @@ def __grad_inner(arg, variable):
         E = arg.abstract_expectationvalue
         dE = __grad_expectationvalue(E, variable=variable)
         return compile(dE, **arg._input_args)
+    elif hasattr(arg, "grad"):
+        return arg.grad(variable)
     else:
         return __grad_objective(objective=arg, variable=variable)
 
 
 def __grad_expectationvalue(E: ExpectationValueImpl, variable: Variable):
-    '''
+    """
     implements the analytic partial derivative of a unitary as it would appear in an expectation value. See the paper.
     :param unitary: the unitary whose gradient should be obtained
     :param variables (list, dict, str): the variables with respect to which differentiation should be performed.
     :return: vector (as dict) of dU/dpi as Objective (without hamiltonian)
-    '''
+    """
 
     hamiltonian = E.H
     unitary = E.U
@@ -230,7 +242,7 @@ def __grad_expectationvalue(E: ExpectationValueImpl, variable: Variable):
 
 
 def __grad_shift_rule(unitary, g, i, variable, hamiltonian):
-    '''
+    """
     function for getting the gradients of directly differentiable gates. Expects precompiled circuits.
     :param unitary: QCircuit: the QCircuit object containing the gate to be differentiated
     :param g: a parametrized: the gate being differentiated
@@ -239,7 +251,7 @@ def __grad_shift_rule(unitary, g, i, variable, hamiltonian):
     :param hamiltonian: the hamiltonian with respect to which unitary is to be measured, in the case that unitary
         is contained within an ExpectationValue
     :return: an Objective, whose calculation yields the gradient of g w.r.t variable
-    '''
+    """
 
     # possibility for overwride in custom gate construction
     if hasattr(g, "shifted_gates"):
@@ -254,4 +266,4 @@ def __grad_shift_rule(unitary, g, i, variable, hamiltonian):
             dOinc += wx * Ex
         return dOinc
     else:
-        raise TequilaException('No shift found for gate {}\nWas the compiler called?'.format(g))
+        raise TequilaException("No shift found for gate {}\nWas the compiler called?".format(g))

tequila/circuit/noise.py

@@ -4,31 +4,32 @@ from tequila.utils import TequilaException
 import copy
 
 names_dict = {
-    'x': 'x',
-    'y': 'y',
-    'z': 'z',
-    'h': 'h',
-    'rx': 'r',
-    'ry': 'r',
-    'rz': 'r',
-    'r': 'r',
-    'phase': 'r',
-    'single': 'single',
-    'swap': 'control',
-    'cx': 'control',
-    'cy': 'control',
-    'cz': 'control',
-    'crx': 'control',
-    'cry': 'control',
-    'crz': 'control',
-    'control': 'control',
-    'cnot': 'control',
-    'ccnot': 'multicontrol',
-    'multicontrol': 'multicontrol'
+    "x": "x",
+    "y": "y",
+    "z": "z",
+    "h": "h",
+    "rx": "r",
+    "ry": "r",
+    "rz": "r",
+    "r": "r",
+    "phase": "r",
+    "single": "single",
+    "swap": "control",
+    "cx": "control",
+    "cy": "control",
+    "cz": "control",
+    "crx": "control",
+    "cry": "control",
+    "crz": "control",
+    "control": "control",
+    "cnot": "control",
+    "ccnot": "multicontrol",
+    "multicontrol": "multicontrol",
 }
 
-noises_available=['bit flip','phase flip','phase damp','amplitude damp','phase-amplitude damp','depolarizing']
-krausses=['bit flip','phase flip','phase damp','amplitude damp','phase-amplitude damp','depolarizing']
+noises_available = ["bit flip", "phase flip", "phase damp", "amplitude damp", "phase-amplitude damp", "depolarizing"]
+krausses = ["bit flip", "phase flip", "phase damp", "amplitude damp", "phase-amplitude damp", "depolarizing"]
+
 
 class QuantumNoise:
     """
@@ -48,13 +49,14 @@ class QuantumNoise:
     from_dict:
         initialize from a dictionary.
     """
-    prob_length={
-        'bit flip':1,
-        'phase flip':1,
-        'phase damp':1,
-        'amplitude damp':1,
-        'phase-amplitude damp':2,
-        'depolarizing':1
+
+    prob_length = {
+        "bit flip": 1,
+        "phase flip": 1,
+        "phase damp": 1,
+        "amplitude damp": 1,
+        "phase-amplitude damp": 2,
+        "depolarizing": 1,
     }
 
     @property
@@ -65,7 +67,7 @@ class QuantumNoise:
     def level(self):
         return self._level
 
-    def __init__(self,name:str,probs:typing.List[float],level:int):
+    def __init__(self, name: str, probs: typing.List[float], level: int):
         """
 
         Parameters
@@ -77,22 +79,24 @@ class QuantumNoise:
         level: int:
             the number of qubits in the gates this noise acts upon.
         """
-        probs=list_assignment(probs)
+        probs = list_assignment(probs)
         if name not in noises_available:
-            raise TequilaException('The name you asked for, {}, is not recognized'.format(name))
-        self._name=name
-        self._level=int(level)
+            raise TequilaException("The name you asked for, {}, is not recognized".format(name))
+        self._name = name
+        self._level = int(level)
 
         if len(probs) != self.prob_length[name]:
-            raise TequilaException('{} noise requires {} probabilities; recieved {}'.format(name, self.prob_length[name], len(probs)))
+            raise TequilaException(
+                "{} noise requires {} probabilities; recieved {}".format(name, self.prob_length[name], len(probs))
+            )
         if name in krausses:
-            assert sum(probs)<=1.
-        self.probs=list_assignment(probs)
+            assert sum(probs) <= 1.0
+        self.probs = list_assignment(probs)
 
     def __str__(self):
-        back=self.name
-        back+=' on ' + str(self._level) + ' qubit gates'
-        back+=', probs = ' +str(self.probs)
+        back = self.name
+        back += " on " + str(self._level) + " qubit gates"
+        back += ", probs = " + str(self.probs)
         return back
 
     @staticmethod
@@ -102,10 +106,10 @@ class QuantumNoise:
         elif type(d) is QuantumNoise:
             return d
         else:
-            raise TequilaException('object provided is neither a dictionary nor a QuantumNoise.')
+            raise TequilaException("object provided is neither a dictionary nor a QuantumNoise.")
 
 
-class NoiseModel():
+class NoiseModel:
     """
     class representing noises to apply to a quantum circuit during simulation.
 
@@ -122,34 +126,35 @@ class NoiseModel():
         remove all noise of a given type, I.E get rid of all bit flips.
 
     """
-    def __init__(self, noises: typing.List[typing.Union[dict, QuantumNoise]]=None):
+
+    def __init__(self, noises: typing.List[typing.Union[dict, QuantumNoise]] = None):
         if noises is None:
             self.noises = []
         else:
-            self.noises=[QuantumNoise.from_dict(d) for d in list_assignment(noises)]
+            self.noises = [QuantumNoise.from_dict(d) for d in list_assignment(noises)]
 
     def __str__(self):
-        back='NoiseModel with: \n'
+        back = "NoiseModel with: \n"
         for noise in self.noises:
             back += str(noise)
-            back += ',\n'
+            back += ",\n"
         return back
 
     def __add__(self, other):
-        new=NoiseModel()
-        new.noises+=self.noises
+        new = NoiseModel()
+        new.noises += self.noises
         if type(other) is dict:
             new.noises.append(QuantumNoise.from_dict(other))
         elif type(other) is QuantumNoise:
             new.noises.append(other)
-        elif hasattr(other,'noises'):
+        elif hasattr(other, "noises"):
             new.noises.extend(copy.copy(other.noises))
         return new
 
     def __iadd__(self, other):
         if type(other) is dict:
-            self.noises+=QuantumNoise.from_dict(other)
-        elif hasattr(other,'noises'):
+            self.noises += QuantumNoise.from_dict(other)
+        elif hasattr(other, "noises"):
             self.noises.extend(copy.copy(other.noises))
         return self
 
@@ -175,7 +180,8 @@ class NoiseModel():
     def wrap_noise(other):
         return NoiseModel(noises=other)
 
-def BitFlip(p:float,level:int):
+
+def BitFlip(p: float, level: int):
     """
     Returns a NoiseModel with one QuantumNoise, having  a kraus map corresponding to applying pauli X with likelihood p.
 
@@ -191,11 +197,12 @@ def BitFlip(p:float,level:int):
     NoiseModel
     """
 
-    new=NoiseModel.wrap_noise(QuantumNoise(name='bit flip', probs=list_assignment(p), level=level))
+    new = NoiseModel.wrap_noise(QuantumNoise(name="bit flip", probs=list_assignment(p), level=level))
     return new
 
-def PhaseFlip(p:float,level:int):
-    '''
+
+def PhaseFlip(p: float, level: int):
+    """
     Returns a NoiseModel of one QuantumNoise, having a kraus map corresponding to applying  pauli Z with likelihood p.
 
     Parameters
@@ -208,14 +215,14 @@ def PhaseFlip(p:float,level:int):
     Returns
     -------
     NoiseModel
-    '''
+    """
 
-    new=NoiseModel.wrap_noise(QuantumNoise(name='phase flip', probs=list_assignment(p), level=level))
+    new = NoiseModel.wrap_noise(QuantumNoise(name="phase flip", probs=list_assignment(p), level=level))
     return new
 
 
-def PhaseDamp(p:float,level:int):
-    '''
+def PhaseDamp(p: float, level: int):
+    """
     Returns a NoiseModel of one QuantumNoise, having a kraus map corresponding to phase damping;
     Krauss map is defined following Nielsen and Chuang;
     E_0= [[1,0],
@@ -233,14 +240,14 @@ def PhaseDamp(p:float,level:int):
     Returns
     -------
     NoiseModel
-    '''
+    """
 
-    new=NoiseModel.wrap_noise(QuantumNoise(name='phase damp', probs=list_assignment(p), level=level))
+    new = NoiseModel.wrap_noise(QuantumNoise(name="phase damp", probs=list_assignment(p), level=level))
     return new
 
 
-def AmplitudeDamp(p:float,level:int):
-    '''
+def AmplitudeDamp(p: float, level: int):
+    """
     Returns a NoiseModel one QuantumNoise, corresponding to amplitude damping.
     this channel takes 1 to 0, but leaves 0 unaffected.
     kraus maps:
@@ -260,13 +267,14 @@ def AmplitudeDamp(p:float,level:int):
     Returns
     -------
     NoiseModel
-    '''
+    """
 
-    new=NoiseModel.wrap_noise(QuantumNoise(name='amplitude damp', probs=list_assignment(p), level=level))
+    new = NoiseModel.wrap_noise(QuantumNoise(name="amplitude damp", probs=list_assignment(p), level=level))
     return new
 
-def PhaseAmplitudeDamp(p1:float,p2:float,level:int):
-    '''
+
+def PhaseAmplitudeDamp(p1: float, p2: float, level: int):
+    """
     Returns a NoiseModel with one QuantumNoise, having a kraus map corresponding to phase and amplitude damping.
 
     Parameters
@@ -281,12 +289,13 @@ def PhaseAmplitudeDamp(p1:float,p2:float,level:int):
     Returns
     -------
     NoiseModel
-    '''
-    new=NoiseModel.wrap_noise(QuantumNoise(name='phase-amplitude damp', probs=list_assignment([p1, p2]), level=level))
+    """
+    new = NoiseModel.wrap_noise(QuantumNoise(name="phase-amplitude damp", probs=list_assignment([p1, p2]), level=level))
     return new
 
-def DepolarizingError(p:float,level:int):
-    '''
+
+def DepolarizingError(p: float, level: int):
+    """
     Returns a NoiseModel with one QuantumNoise, having a kraus map corresponding to equal
     probabilities of each of the three pauli matrices being applied.
 
@@ -300,6 +309,6 @@ def DepolarizingError(p:float,level:int):
     Returns
     -------
     NoiseModel
-    '''
-    new = NoiseModel.wrap_noise(QuantumNoise(name='depolarizing', probs=list_assignment(p), level=level))
+    """
+    new = NoiseModel.wrap_noise(QuantumNoise(name="depolarizing", probs=list_assignment(p), level=level))
     return new

tequila/circuit/postselection.py

@@ -0,0 +1,120 @@
+from copy import deepcopy
+from typing import Union
+import numpy as np
+import tequila as tq
+from tequila import QCircuit, QubitWaveFunction, BitNumbering
+
+
+class Postselection:
+    """
+    A class representing a postselection operation on a set of qubits,
+    i.e. a projection of the wavefunction onto the subspace where all
+    selected qubits are in the state |0>.
+    """
+
+    def __init__(self, qubits: list[int]):
+        self._qubits = qubits
+
+    @property
+    def qubits(self):
+        return self._qubits
+
+    @qubits.setter
+    def qubits(self, qubits: list[int]):
+        self._qubits = qubits
+
+    def mask(self, nbits: int, numbering: BitNumbering) -> int:
+        """
+        Returns a bitmask for the postselected qubits.
+        """
+        mask = 0
+        for qubit in self.qubits:
+            if numbering == BitNumbering.LSB:
+                mask |= 1 << qubit
+            else:
+                mask |= 1 << (nbits - qubit - 1)
+        return mask
+
+
+class PostselectionCircuit:
+    """
+    An extended circuit class that supports Postselection operations
+    which project the wavefunction onto the subspace where a specified
+    set of qubits are all in the state |0>.
+
+    This works by storing a list of fragments which can be either QCircuits
+    or Postselection objects. These fragments are processed in order by
+    passing the result from the previous fragment as the initial state of its
+    successor. When a postselection is encountered, the bitmask is used to
+    check which amplitudes belong to the projected subspace, and the rest
+    is set to 0.
+    """
+
+    def __init__(self, circuit: tq.QCircuit = None):
+        self._fragments: list[Union[QCircuit, Postselection]] = []
+        if circuit is not None:
+            self._fragments = [circuit]
+
+    def simulate(
+        self,
+        backend: str = None,
+        initial_wfn: Union[QubitWaveFunction, int] = 0,
+        repetitions: int = 1,
+        optimize_circuit: bool = True,
+    ):
+        backend = tq.pick_backend(backend=backend)
+        numbering = tq.INSTALLED_SIMULATORS[tq.pick_backend(backend)].CircType.numbering
+
+        compiled = {}
+        for i, fragment in enumerate(self._fragments):
+            if isinstance(fragment, QCircuit):
+                # TODO: Handle empty qubits properly instead of doing this
+                for j in range(self.n_qubits):
+                    fragment += tq.gates.X(target=j)
+                    fragment += tq.gates.X(target=j)
+                compiled[i] = tq.compile(fragment, backend=backend, optimize_circuit=optimize_circuit)
+
+        wfn = initial_wfn
+        for _ in range(repetitions):
+            for i, fragment in enumerate(self._fragments):
+                if isinstance(fragment, QCircuit):
+                    wfn = compiled[i](initial_state=wfn)
+                elif isinstance(fragment, Postselection):
+                    amplitudes = wfn.to_array(numbering, copy=False)
+                    mask = fragment.mask(self.n_qubits, numbering)
+                    indices = np.arange(2**self.n_qubits) & mask != 0
+                    amplitudes[indices] = 0
+                    wfn = QubitWaveFunction.from_array(amplitudes, numbering, copy=False)
+        norm = np.linalg.norm(wfn.to_array(numbering))
+        # TODO: Reconsider how to handle norm == 0.0
+        normalized_wfn = (1.0 / norm) * wfn if norm != 0.0 else 0.0 * wfn
+        return normalized_wfn, norm
+
+    def __iadd__(self, other: Union[QCircuit, Postselection, "PostselectionCircuit"]):
+        if isinstance(other, QCircuit) or isinstance(other, Postselection):
+            self.add_fragment(other)
+        elif isinstance(other, PostselectionCircuit):
+            for fragment in other._fragments:
+                self.add_fragment(fragment)
+        return self
+
+    def __add__(self, other: Union[QCircuit, Postselection, "PostselectionCircuit"]):
+        result = deepcopy(self)
+        result += other
+        return result
+
+    def add_fragment(self, fragment: Union[QCircuit, Postselection]):
+        if self._fragments and isinstance(self._fragments[-1], QCircuit) and isinstance(fragment, QCircuit):
+            self._fragments[-1] += fragment
+        elif self._fragments and isinstance(self._fragments[-1], Postselection) and isinstance(fragment, Postselection):
+            self._fragments[-1].qubits += fragment.qubits
+        else:
+            self._fragments.append(fragment)
+        return self
+
+    @property
+    def n_qubits(self):
+        if self._fragments:
+            return self._fragments[0].n_qubits
+        else:
+            return 0

tequila/circuit/pyzx.py

@@ -4,17 +4,19 @@ Add to tequila the ability to make ZX-Calculus
 Using the pyzx library: https://github.com/Quantomatic/pyzx
 """
 
+from tequila import TequilaException
+from tequila import export_open_qasm, import_open_qasm
+from tequila.circuit import QCircuit
+
+
 HAS_PYZX = True
 try:
     import pyzx
+
     HAS_PYZX = True
 except ImportError:
     HAS_PYZX = False
 
-from tequila import TequilaException
-from tequila import export_open_qasm, import_open_qasm
-from tequila.circuit import QCircuit
-
 
 def convert_to_pyzx(circuit: QCircuit, variables=None):
     """
@@ -28,7 +30,9 @@ def convert_to_pyzx(circuit: QCircuit, variables=None):
         pyzx.circuit.Circuit: pyzx circuit
     """
     if HAS_PYZX:
-        return pyzx.circuit.Circuit.from_qasm(export_open_qasm(circuit=circuit, variables=variables, version="2.0", zx_calculus=True))
+        return pyzx.circuit.Circuit.from_qasm(
+            export_open_qasm(circuit=circuit, variables=variables, version="2.0", zx_calculus=True)
+        )
     else:
         raise TequilaException("Pyzx package not installed.")
 
@@ -49,4 +53,4 @@ def convert_from_pyzx(circuit) -> QCircuit:
         else:
             raise TequilaException("Circuit provided must be of type pyzx.circuit.Circuit")
     else:
-        raise TequilaException("Pyzx package not installed.")
+        raise TequilaException("Pyzx package not installed.")