tequila-basic 1.9.11__tar.gz → 1.9.12__tar.gz

{tequila_basic-1.9.11/src/tequila_basic.egg-info → tequila_basic-1.9.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tequila-basic
-Version: 1.9.11
+Version: 1.9.12
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
 Author: Tequila Developers 
@@ -13,7 +13,8 @@ Requires-Dist: sympy
 Requires-Dist: autograd
 Requires-Dist: setuptools
 Requires-Dist: pytest
-Requires-Dist: openfermion~=1.0
+Requires-Dist: openfermion>=1.0
+Requires-Dist: excitationsolve
 Requires-Dist: dataclasses; python_version < "3.7"
 Dynamic: author
 Dynamic: author-email
@@ -45,7 +46,7 @@ Further sources:
 - [talks and slides](https://kottmanj.github.io/talks_and_material/)  
 
 # Installation
-Recommended Python version is 3.10 (3.11).   
+Recommended Python version is 3.11 (3.10 or 3.12 shouldn't be a problem either).   
 Tequila supports linux, osx and windows. However, not all optional dependencies (especially chemistry) are supported on windows.  
 
 ## Install from PyPi

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/README.md

@@ -18,7 +18,7 @@ Further sources:
 - [talks and slides](https://kottmanj.github.io/talks_and_material/)  
 
 # Installation
-Recommended Python version is 3.10 (3.11).   
+Recommended Python version is 3.11 (3.10 or 3.12 shouldn't be a problem either).   
 Tequila supports linux, osx and windows. However, not all optional dependencies (especially chemistry) are supported on windows.  
 
 ## Install from PyPi

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/requirements.txt

@@ -7,9 +7,10 @@ sympy
 autograd # autograd works better on OSX-ARM64 (M1 and M2) and Windows, feel free to try jax however (no big differences)
 setuptools
 pytest
-openfermion ~= 1.0 # can not be smaller than 1.0 
+openfermion >= 1.0 # can not be smaller than 1.0 
 #cmake # needed by #qulacs, can be removed otherwise, now in #qulacs requirements
 #qulacs # default simulator (best integration), remove if the installation gives you trouble and just install one of the other supported backend. Version restriction only for noise models, otherwise the new version is fine
+excitationsolve
 
 #optional quantum backends
 #cirq >= 0.9.2 #
@@ -18,7 +19,6 @@ openfermion ~= 1.0 # can not be smaller than 1.0
 #pyquil<3.0 # you also need to install the forest-sdk
 ##qulacs-gpu # you can't have #qulacs and #qulacs-gpu at the same time
 #qibo <= 0.1.1 # can not be installed in the same environment as gpyopt
-#quimb
 #mqt.ddsim == 2.0.0b2  # requires qiskit < 2
 
 #optional optimizers
@@ -28,3 +28,4 @@ openfermion ~= 1.0 # can not be smaller than 1.0
 #pyzx
 #pyscf # if used also restrict h5py version untill the issue is fixed upstream in pyscf
 #h5py <= 3.1 # version 3.3.0 leads to crashes when pyscf is imported
+#pygridsynth # used to compile Pauli rotations into Clifford + T gates

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/src/tequila/__init__.py

@@ -5,14 +5,19 @@ from tequila.objective import (
     Objective,
     VectorObjective,
     ExpectationValue,
+    BraKet,
+    RealBraKet,
+    ImagBraKet,
     Variable,
     assign_variable,
     format_variable_dictionary,
     vectorize,
+    make_transition,
+    make_overlap,
+    Overlap,
+    Fidelity,
 )
 from tequila.objective import QTensor
-from tequila.objective.braket import BraKet, make_transition, make_overlap, Overlap, Fidelity
-
 from tequila.optimizers import INSTALLED_OPTIMIZERS, show_available_optimizers
 from tequila.optimizers import minimize, minimize_scipy, minimize_gd, optimizer_scipy
 

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/src/tequila/apps/krylov/krylov.py

@@ -1,6 +1,7 @@
 import copy
 import scipy
-from tequila import BraKet, QTensor, simulate
+from tequila import QTensor, simulate
+from tequila.objective import BraKetImpl, RealBraKet
 from tequila.hamiltonian.qubit_hamiltonian import QubitHamiltonian
 
 
@@ -37,13 +38,13 @@ def krylov_method(
     for i in range(n_krylov_states):
         for j in range(i, n_krylov_states):
             if assume_real:
-                h_real = BraKet(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H)[0]
+                h_real = BraKetImpl(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H).compile()[0]
                 h_im = 0
             else:
-                h_real, h_im = BraKet(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H)
+                h_real, h_im = BraKetImpl(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H).compile()
             HM[i, j] = h_real + 1j * h_im
             HM[j, i] = h_real - 1j * h_im
-            s_real, s_im = BraKet(bra=krylov_circs_x[i], ket=krylov_circs_x[j])
+            s_real, s_im = BraKetImpl(bra=krylov_circs_x[i], ket=krylov_circs_x[j]).compile()
             SM[i, j] = s_real + 1j * s_im
             SM[j, i] = s_real - 1j * s_im
 
@@ -53,3 +54,39 @@ def krylov_method(
     v, vv = scipy.linalg.eigh(h, s)
 
     return v, vv
+
+
+# Improved version
+
+# def krylov_method(
+#     krylov_circs: list, H: QubitHamiltonian, variables: dict = None, assume_real: bool = False, *args, **kwargs
+# ) -> tuple:
+#     n_krylov_states = len(krylov_circs)
+
+#     if variables is not None:
+#         krylov_circs_x = [U.map_variables(variables) for U in krylov_circs]
+#     else:
+#         krylov_circs_x = copy.deepcopy(krylov_circs)
+
+#     HM = numpy.zeros((n_krylov_states, n_krylov_states), dtype=complex)
+#     SM = numpy.zeros((n_krylov_states, n_krylov_states), dtype=complex)
+
+#     for i in range(n_krylov_states):
+#         for j in range(i, n_krylov_states):
+#             h_bk = BraKetImpl(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H)
+#             s_bk = BraKetImpl(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=None)
+
+#             h_val = simulate(h_bk, *args, **kwargs)
+#             s_val = simulate(s_bk, *args, **kwargs)
+
+#             if assume_real:
+#                 h_val = h_val.real
+
+#             HM[i, j] = h_val
+#             HM[j, i] = h_val.conjugate()
+
+#             SM[i, j] = s_val
+#             SM[j, i] = s_val.conjugate()
+
+#     v, vv = scipy.linalg.eigh(HM, SM)
+#     return v, vv

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/src/tequila/circuit/circuit.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 from tequila.circuit._gates_impl import QGateImpl, assign_variable, list_assignment, GlobalPhaseGateImpl, PhaseGateImpl
 from tequila.utils.exceptions import TequilaException, TequilaWarning
-from tequila.utils.bitstrings import BitNumbering
+from tequila.utils.bitstrings import BitNumbering, reverse_int_bits
 import typing
 import copy
 from collections import defaultdict
@@ -449,7 +449,7 @@ class QCircuit:
         else:
             return QCircuit(gates=[gate])
 
-    def to_matrix(self, variables=None):
+    def to_matrix(self, variables=None, numbering: BitNumbering = BitNumbering.MSB, backend: str = None):
         """
         take the circuit and return the unitary matrix corresponding to it.
         Parameters
@@ -464,60 +464,31 @@ class QCircuit:
         np.ndarray:
             the unitary matrix corresponding to the circuit.
         """
-        import quimb.gates
-        import quimb.tensor as qtn
-        from tequila import compile_circuit
+        from tequila import format_variable_dictionary
+        from tequila.simulators.simulator_api import compile_circuit
 
-        num_variables = len(self.extract_variables())
+        variables = format_variable_dictionary(variables)
 
-        if num_variables == 0:
-            variables = {}
-        elif variables is None:
+        if variables is None and not (len(self.extract_variables()) == 0):
             raise TequilaException(
-                f"QCircuit.to_matrix(): no variables provided, but the circuit has {num_variables} variables"
+                "You called simulate for a parametrized type but forgot to pass down the variables: {}".format(
+                    self.extract_variables()
+                )
             )
 
-        compiled_circuit = compile_circuit(
-            self,
+        compiled = compile_circuit(
+            abstract_circuit=self,
+            variables=variables,
+            backend=backend,
         )
-        compiled_circuit = compiled_circuit.map_variables(variables)
-
-        gate_mapping = {"Rx": "RX", "Ry": "RY", "Rz": "RZ", "H": "H", "X": "X"}
-
-        quimb_circuit = qtn.Circuit(self.n_qubits)
-
-        # quimb uses MSB convention, so we need to modify the qubit indices
-        # to LSB
-        for g in compiled_circuit.gates:
-            if g.name not in gate_mapping:
-                raise TequilaException(
-                    f"Gate {g.name} is not supported for conversion to matrix. "
-                    f"Supported gates: {list(gate_mapping.keys())}"
-                )
-
-            if g.is_parameterized():
-                quimb_circuit.apply_gate(
-                    gate_mapping[g.name],
-                    params=[float(g.parameter())],
-                    qubits=[abs(t - self.n_qubits + 1) for t in list(g.target)],
-                    parameterize=True,
-                )
-            elif g.is_controlled():
-                quimb_circuit.apply_gate(
-                    gate_mapping[g.name],
-                    qubits=[abs(t - self.n_qubits + 1) for t in list(g.target)],
-                    controls=[abs(c - self.n_qubits + 1) for c in list(g.control)],
-                )
-            else:
-                quimb_circuit.apply_gate(
-                    gate_mapping[g.name],
-                    qubits=[abs(t - self.n_qubits + 1) for t in list(g.target)],
-                )
 
-        uni = quimb_circuit.get_uni()
-        unitary = np.array(uni.to_dense())
+        columns = []
+        for i in range(2**self.n_qubits):
+            initial_state = reverse_int_bits(i, nbits=self.n_qubits) if numbering == BitNumbering.LSB else i
+            output = compiled.simulate(variables=variables, initial_state=initial_state).to_array(numbering, copy=False)
+            columns.append(output)
 
-        return unitary
+        return np.column_stack(columns)
 
     def to_networkx(self):
         """

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/src/tequila/circuit/compiler.py

@@ -1,6 +1,9 @@
+import numbers
+import warnings
+
 from tequila import TequilaException
 from tequila.circuit.circuit import QCircuit
-from tequila.circuit.gates import Rx, Ry, H, X, Rz, ExpPauli, CNOT, Phase, T, Z, GlobalPhase
+from tequila.circuit.gates import Rx, Ry, H, X, S, Rz, ExpPauli, CNOT, Phase, T, Z, GlobalPhase
 from tequila.circuit._gates_impl import (
     RotationGateImpl,
     PhaseGateImpl,
@@ -12,7 +15,7 @@ from tequila.circuit._gates_impl import (
 from tequila.utils import to_float
 from tequila.objective.objective import Variable, FixedVariable
 from tequila.objective.objective import Objective
-from tequila.objective.objective import ExpectationValueImpl
+from tequila.objective.objective import BraKetImpl, ExpectationValueImpl
 import numpy
 from numpy import pi as pi
 
@@ -70,6 +73,7 @@ class CircuitCompiler:
         c.gradient_mode = False
         c.y_gate = False
         c.ry_gate = False
+        c.pauli_rotations = False
 
         for k, v in kwargs.items():
             if k in c.__dict__:
@@ -79,6 +83,13 @@ class CircuitCompiler:
             c.cc_max = False
         return c
 
+    @classmethod
+    def error_correctable_gate_set(cls, epsilon, *args, **kwargs):
+        c = cls.all_flags_true(args, kwargs)
+        c.pauli_rotations = True
+        c.epsilon = epsilon
+        return c
+
     def __init__(
         self,
         multitarget=False,
@@ -102,9 +113,10 @@ class CircuitCompiler:
         y_gate=False,
         ch_gate=False,
         hadamard=False,
+        pauli_rotations=False,
+        epsilon=1e-6,
     ):
         """
-        all parameters are booleans.
         Parameters
         ----------
         multitarget:
@@ -145,6 +157,11 @@ class CircuitCompiler:
             whether or not to break down all y gates
         ch_gate:
             whether or not to break down all controlled-H gates
+        pauli_rotations:
+            whether or not to approximate rotations with Clifford and T gates
+        epsilon:
+            The maximum absolute error when compilations are not exact.
+            Currently only applies to the rotations compilation.
         """
         self.multitarget = multitarget
         self.multicontrol = multicontrol
@@ -167,6 +184,8 @@ class CircuitCompiler:
         self.ry_gate = ry_gate
         self.y_gate = y_gate
         self.ch_gate = ch_gate
+        self.pauli_rotations = pauli_rotations
+        self.epsilon = epsilon
 
     def __call__(
         self, objective: typing.Union[Objective, QCircuit, ExpectationValueImpl], variables=None, *args, **kwargs
@@ -249,7 +268,21 @@ class CircuitCompiler:
         the arg, compiled
         """
 
-        if isinstance(arg, ExpectationValueImpl) or (hasattr(arg, "U") and hasattr(arg, "H")):
+        if isinstance(arg, BraKetImpl):
+            # a braket has U and H as well, but its U is only the ket: compiling it like an
+            # expectation value below would silently drop the bra
+            ket = self.compile_circuit(abstract_circuit=arg.ket, *args, **kwargs)
+            return BraKetImpl(
+                ket=ket,
+                bra=ket if arg.bra is arg.ket else self.compile_circuit(abstract_circuit=arg.bra, *args, **kwargs),
+                operator=arg.operator,
+                contraction=arg._contraction,
+                shape=arg._shape,
+                samples=arg.samples,
+                *arg._args,
+                **arg._kwargs,
+            )
+        elif isinstance(arg, ExpectationValueImpl) or (hasattr(arg, "U") and hasattr(arg, "H")):
             return ExpectationValueImpl(H=arg.H, U=self.compile_circuit(abstract_circuit=arg.U, *args, **kwargs))
         elif hasattr(arg, "abstract_expectationvalue"):
             E = arg.abstract_expectationvalue
@@ -296,6 +329,9 @@ class CircuitCompiler:
 
         compiled_gates = []
 
+        # Keep a dicitionary of compiled pauli_rotations
+        pauli_dict = {}
+
         for idx, gate in gatelist:
             cg = gate
             controlled = gate.is_controlled()
@@ -333,6 +369,10 @@ class CircuitCompiler:
             if self.ry_gate:
                 cg = compile_ry(gate=cg, controlled_rotation=self.controlled_rotation)
             if controlled:
+                if self.toffoli:
+                    cg = compile_toffoli(gate=cg)
+                    if self.phase:
+                        cg = compile_phase(gate=cg)
                 if self.cc_max or self.multicontrol:
                     cg = compile_to_single_control(gate=cg)
                 if self.controlled_exponential_pauli:
@@ -343,12 +383,10 @@ class CircuitCompiler:
                     cg = compile_controlled_phase(gate=cg)
                     if self.phase:
                         cg = compile_phase(gate=cg)
-                if self.toffoli:
-                    cg = compile_toffoli(gate=cg)
-                    if self.phase:
-                        cg = compile_phase(gate=cg)
                 if self.controlled_rotation:
                     cg = compile_controlled_rotation(gate=cg)
+            if self.pauli_rotations:
+                cg = compile_pauli_rotations(gate=cg, epsilon=self.epsilon, pauli_dict=pauli_dict)
 
             compiled_gates.append((idx, cg))
 
@@ -586,7 +624,7 @@ def compile_toffoli(gate) -> QCircuit:
         A QCircuit; the result of compilation.
     """
 
-    if gate.name.lower != "x":
+    if not (gate.name.lower() == "x" and len(gate.control) == 2):
         return QCircuit.wrap_gate(gate)
     control = gate.control
     c1 = control[1]
@@ -1039,3 +1077,82 @@ def compile_ch(gate: QGateImpl) -> QCircuit:
         )
     else:
         return QCircuit.wrap_gate(gate)
+
+
+@compiler
+def compile_pauli_rotations(gate: QGateImpl, epsilon: float, pauli_dict: dict) -> QCircuit:
+    """
+    Compile uncontrolled Pauli rotations gates into Clifford + T gates.
+
+    Parameters
+    ----------
+    gate:
+        the gate.
+    epsilon:
+        the maximum absolute error of the compilation.
+
+    Returns
+    -------
+    QCircuit, the result of compilation.
+    """
+    from pygridsynth import gridsynth_gates
+
+    # In principle, we could compile controlled Pauli rotations with the same method by making all
+    # the resulting gates controlled, but then this compilation makes no sense, since its point is
+    # to compile to a Clifford + T gateset. Compiling controlled rotations to uncontrolled ones
+    # should be handled by other compiler passes.
+    if gate.name.lower() in ["rx", "ry", "rz"] and not gate.is_controlled():
+        if not isinstance(gate.parameter, numbers.Number):
+            raise TequilaCompilerException("Can't compile parametrized rotations to Clifford + T gates")
+
+        # Compute bucket by rounding to the next multiple of epsilon
+        bucket = int(numpy.round(gate.parameter / (2 * epsilon)))
+        rounded_parameter = bucket * (2 * epsilon)
+        if bucket in pauli_dict:
+            result = pauli_dict[bucket]
+        elif bucket == 0:
+            result = QCircuit()
+        else:
+            with warnings.catch_warnings():
+                # Silence warning about using floats
+                warnings.simplefilter(action="ignore", category=UserWarning, lineno=362)
+                gates = gridsynth_gates(theta=rounded_parameter, epsilon=epsilon, up_to_phase=True)
+
+            result = QCircuit()
+            v = numpy.array([1, 0], dtype=complex)
+            H_mat = numpy.array([[1, 1], [1, -1]]) / numpy.sqrt(2)
+            T_val = numpy.exp(pi / 4 * 1j)
+            for g in reversed(gates):
+                match g:
+                    case "X":
+                        result += X(target=0)
+                        v = v[::-1]
+                    case "H":
+                        result += H(target=0)
+                        v = H_mat @ v
+                    case "S":
+                        result += S(target=0)
+                        v[1] *= 1j
+                    case "T":
+                        result += T(target=0)
+                        v[1] *= T_val
+                    case c:
+                        raise ValueError(f"Got unexpected gate {c}")
+
+            global_phase = -rounded_parameter / 2 - numpy.angle(v[0])
+            result += GlobalPhase(angle=global_phase)
+            pauli_dict[bucket] = result
+
+        result = result.map_qubits({0: gate.target[0]})
+
+        if gate.name.lower() in ["rx", "ry"]:
+            result = H(target=gate.target) + result + H(target=gate.target)
+
+        if gate.name.lower() == "ry":
+            result = (
+                S(target=gate.target) + S(target=gate.target) + S(target=gate.target) + result + S(target=gate.target)
+            )
+
+        return result
+    else:
+        return QCircuit.wrap_gate(gate)

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/src/tequila/circuit/gates.py

@@ -85,19 +85,16 @@ def Phase(
     return QCircuit.wrap_gate(gates)
 
 
-def I(
-    target: typing.Union[list, int], control: typing.Union[list, int] = None, power=None, angle=None, *args, **kwargs
-) -> QCircuit:
+def I(target: typing.Union[list, int], control: typing.Union[list, int] = None, *args, **kwargs) -> QCircuit:
     """
     A gate that has no effect, but can be used to mark a qubit as being used.
     This can for example be useful if a qubit is only being used in some variants
     of a circuit, but you want to prevent the output format from changing.
     """
-    # Ugly workaround, we can't simply use paulis.Zero() because this wouldn't mark the qubit as being used.
-    generator = lambda q: 0 * paulis.X(q)
-    return _initialize_power_gate(
-        name="I", power=power, angle=angle, target=target, control=control, generator=generator, *args, **kwargs
-    )
+    target = list_assignment(target)
+    control = list_assignment(control) if control is not None else None
+    gates = [impl.QGateImpl(name="I", target=q, control=control) for q in target]
+    return QCircuit.wrap_gate(gates)
 
 
 def S(target: typing.Union[list, int], control: typing.Union[list, int] = None) -> QCircuit:

{tequila_basic-1.9.11 → tequila_basic-1.9.12}/src/tequila/circuit/gradient.py

@@ -1,6 +1,7 @@
 from tequila.circuit.compiler import CircuitCompiler
 from tequila.objective.objective import (
     Objective,
+    BraKetImpl,
     ExpectationValueImpl,
     Variable,
     assign_variable,
@@ -11,8 +12,10 @@ from tequila import TequilaException
 from tequila.objective import QTensor
 from tequila.simulators.simulator_api import compile
 import typing
-from numpy import vectorize
+from numpy import vectorize, isclose
+from copy import deepcopy
 from tequila.autograd_imports import jax, __AUTOGRAD__BACKEND__
+from tequila.circuit._gates_impl import DifferentiableGateImpl
 
 
 def grad(objective: typing.Union[Objective, QTensor], variable: Variable = None, no_compile=False, *args, **kwargs):
@@ -78,7 +81,9 @@ def grad(objective: typing.Union[Objective, QTensor], variable: Variable = None,
 
     if isinstance(objective, ExpectationValueImpl):
         return __grad_expectationvalue(E=objective, variable=variable)
-    elif objective.is_expectationvalue():
+    elif objective.is_expectationvalue() and not isinstance(compiled.args[-1], BraKetImpl):
+        # is_expectationvalue() only tests for a quantum argument, and a braket is not an
+        # expectation value: let it fall through to __grad_objective/__grad_inner
         return __grad_expectationvalue(E=compiled.args[-1], variable=variable)
     elif isinstance(compiled, Objective) or (hasattr(compiled, "args") and hasattr(compiled, "transformation")):
         return __grad_objective(objective=compiled, variable=variable)
@@ -91,12 +96,20 @@ def __grad_objective(objective: Objective, variable: Variable):
     transformation = objective.transformation
     dO = None
 
+    # an objective holding a braket is complex valued, and the plain autograd gradient only
+    # accepts real output. the arithmetic combining the arguments (sums, products, quotients)
+    # is holomorphic, so the outer derivative is well defined and just has to be asked for
+    holomorphic = any(isinstance(arg, BraKetImpl) for arg in args)
+
     processed_expectationvalues = {}
     for i, arg in enumerate(args):
         if __AUTOGRAD__BACKEND__ == "jax":
-            df = jax.grad(transformation, argnums=i)
+            df = jax.grad(transformation, argnums=i, holomorphic=holomorphic)
         elif __AUTOGRAD__BACKEND__ == "autograd":
-            df = jax.grad(transformation, argnum=i)
+            if holomorphic:
+                df = jax.holomorphic_grad(transformation, i)
+            else:
+                df = jax.grad(transformation, argnum=i)
         else:
             raise TequilaException("Can't differentiate without autograd or jax")
 
@@ -206,6 +219,10 @@ def __grad_inner(arg, variable):
         E = arg.abstract_expectationvalue
         dE = __grad_expectationvalue(E, variable=variable)
         return compile(dE, **arg._input_args)
+    elif isinstance(arg, BraKetImpl):
+        # real, imaginary = arg.compile()
+        # return grad(real, variable) + 1.0j * grad(imaginary, variable)
+        return __grad_braKet(objective=arg, variable=variable)
     elif hasattr(arg, "grad"):
         return arg.grad(variable)
     else:
@@ -267,3 +284,66 @@ def __grad_shift_rule(unitary, g, i, variable, hamiltonian):
         return dOinc
     else:
         raise TequilaException("No shift found for gate {}\nWas the compiler called?".format(g))
+
+
+def __grad_braKet(objective: BraKetImpl, variable: Variable = None) -> Objective:
+    r"""
+    Gradient of <bra|H|ket> by differentiating the amplitudes of bra and ket directly,
+    instead of differentiating the Hadamard tests that BraKetImpl.compile() produces.
+    Every term of the result is again a BraKetImpl with one gate of bra or ket modified.
+    :param objective: the BraKetImpl to differentiate
+    :param variable: the variable to differentiate with respect to. None gives a dict with all of them
+    :return: an Objective (or dict of Objectives) whose simulation gives the gradient
+    """
+    # <U|U> = 1 does not depend on anything
+    if variable not in objective.extract_variables() or objective.is_self_overlap:
+        return Objective()
+    if objective.is_diagonal:
+        return __grad_expectationvalue(objective, variable)
+
+    if not (objective.bra.verify()):
+        raise TequilaException("error in grad_braket unitary is {}".format(objective.bra))
+    if not (objective.ket.verify()):
+        raise TequilaException("error in grad_braket unitary is {}".format(objective.ket))
+
+    def make_braket(bra, ket):
+        return Objective(
+            args=[
+                BraKetImpl(
+                    ket=ket,
+                    bra=bra,
+                    operator=objective.operator,
+                    contraction=objective._contraction,
+                    shape=objective._shape,
+                    samples=objective.samples,
+                    *objective._args,
+                    **objective._kwargs,
+                )
+            ]
+        )
+
+    dO = Objective()
+    for is_bra, U in [(False, deepcopy(objective.ket)), (True, deepcopy(objective.bra))]:
+        for i, g in U._parameter_map.get(variable, []):
+            if hasattr(g, "shifted_gates"):
+                g = deepcopy(g)
+                if not g.is_controlled() and type(g).shifted_gates is DifferentiableGateImpl.shifted_gates:
+                    shifted = g.shifted_gates(r=g.eigenvalues_magnitude / 2)
+                else:
+                    shifted = g.shifted_gates()
+                g.assume_real = False
+                inner = __grad_inner(g.parameter, variable)
+                if isinstance(inner, float) and isclose(inner, 0, atol=1.0e-6):
+                    continue
+                for x in shifted:
+                    w, g = x
+                    Ux = U.replace_gates(positions=[i], circuits=[g])
+                    if is_bra:
+                        # the bra enters complex conjugated
+                        dO += w.conjugate() * inner * make_braket(bra=Ux, ket=objective.ket)
+                    else:
+                        dO += w * inner * make_braket(bra=objective.bra, ket=Ux)
+            else:
+                raise TequilaException("No shift found for gate {}\nWas the compiler called?".format(g))
+    assert dO is not None
+    return dO