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

tequila/simulators/test_spex_simulator.py

@@ -0,0 +1,208 @@
+import tequila as tq
+import numpy as np
+import time
+import os
+import csv
+from tequila.hamiltonian import PauliString
+import pytest
+
+
+#!/usr/bin/env python
+import tequila as tq
+import numpy as np
+import time
+
+print("Test: Circuit und Hamiltonian mit Variablen (SPEX vs. Qulacs)")
+
+# --- Parameterdefinition ---
+# Definiere mehrere Variablen für die Rotation
+a = tq.Variable("a")
+b = tq.Variable("b")
+c = tq.Variable("c")
+variables = {"a": np.pi / 3, "b": np.pi / 4, "c": np.pi / 6}
+
+# --- Circuitaufbau ---
+# Erzeuge einen Circuit, der auf 3 Qubits operiert:
+# - Eine Rx-Rotation auf Qubit 0 (Winkel "a")
+# - Eine Ry-Rotation auf Qubit 1 (Winkel "b")
+# - Eine Rz-Rotation auf Qubit 2 (Winkel "c")
+# - Zusätzlich eine parametrische exponentielle Pauli-Rotation (ExpPauli) auf Qubit 0 und 2 (Pauli-String "X(0)Z(2)")
+U = tq.gates.Rx(angle="a", target=(0,)) + tq.gates.Ry(angle="b", target=(1,)) + tq.gates.Rz(angle="c", target=(2,))
+U += tq.gates.ExpPauli(angle="a", paulistring="X(0)Z(2)")
+
+print("\nCircuit U:")
+print(U)
+
+# --- Hamiltonianaufbau ---
+# Erstelle einen zusammengesetzten Hamiltonian auf 3 Qubits,
+# z.B.: H = Z(0) + X(1)Y(2) + Z(0)Z(1)
+H = tq.QubitHamiltonian("Z(0) + X(1)Y(2) + Z(0)Z(1)")
+print("\nHamiltonian H:")
+print(H)
+
+# Erzeuge ein Erwartungswertobjekt
+E = tq.ExpectationValue(U=U, H=H)
+
+# --- Simulation mit SPEX ---
+start = time.time()
+wfn_spex = tq.simulate(U, variables, backend="spex")
+exp_spex = tq.simulate(E, variables, backend="spex")
+end = time.time()
+time_spex = end - start
+
+# --- Simulation mit Qulacs ---
+start = time.time()
+wfn_qulacs = tq.simulate(U, variables, backend="qulacs")
+exp_qulacs = tq.simulate(E, variables, backend="qulacs")
+end = time.time()
+time_qulacs = end - start
+
+# --- Ergebnisse ausgeben ---
+print("\nSimulationsergebnisse:")
+print("Wellenfunktion (SPEX backend):")
+print(wfn_spex)
+print("\nWellenfunktion (Qulacs backend):")
+print(wfn_qulacs)
+
+print("\nErwartungswert (SPEX backend):", exp_spex, f"(Simulationszeit: {time_spex:.3f}s)")
+print("Erwartungswert (Qulacs backend):", exp_qulacs, f"(Simulationszeit: {time_qulacs:.3f}s)")
+
+# Optional: Vergleiche das innere Produkt der beiden Wavefunctions (Quadrat des Betrags)
+inner_prod = np.abs(wfn_spex.inner(wfn_qulacs)) ** 2
+print("\nInneres Produkt (Quadrat) zwischen SPEX und Qulacs:", inner_prod)
+
+
+"""
+print("\nTest: 1")
+U = tq.gates.ExpPauli(paulistring=PauliString({0: "X", 1: "Z"}), angle=np.pi / 2)
+H = tq.QubitHamiltonian("Z(0)")
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+
+print("\nTest: 2")
+H = tq.QubitHamiltonian("Z(0)X(1)")
+
+U = tq.gates.Rx(angle=np.pi / 4, target=(0,))
+U += tq.gates.Ry(angle=np.pi / 3, target=(1,)) 
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+
+print("\nTest: 3")
+H = tq.QubitHamiltonian("Z(0)")
+
+U = tq.gates.X(target=(0,))
+U += tq.gates.Y(target=(1,)) 
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+
+print("\nTest: 4")
+U = (
+    tq.gates.Rx(angle=np.pi / 2, target=(0,)) +
+    tq.gates.Rz(angle=np.pi / 2, target=(1,)) +
+    tq.gates.Ry(angle=np.pi / 3, target=(2,)) +
+    tq.gates.ExpPauli(paulistring=PauliString({0: "X", 1: "X", 2: "X"}), angle=np.pi / 4)
+)
+
+H = tq.QubitHamiltonian("X(0)X(1)X(2) + Z(0) + Z(1) + Z(2)")
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+print("\nTest: 5")
+os.environ["OMP_NUM_THREADS"] = "6"
+
+results = []
+
+for n in range(1, 15):
+    # 1) Geometrie aufbauen
+    geom = ""
+    for k in range(2*n):
+        geom += f"h 0.0 0.0 {1.5*k}\n"
+
+    # 2) Molekül + Hamiltonian
+    mol = tq.Molecule(geometry=geom, basis_set="sto-3g")
+    H   = mol.make_hardcore_boson_hamiltonian()
+
+    # 3) Ansatz U
+    edges = [(2*i, 2*i+1) for i in range(n)]
+    U = mol.make_ansatz(name="HCB-SPA", edges=edges)
+    # Alle im Ansatz auftretenden Variablen auf 1.0 setzen
+    U = U.map_variables({var: 1.0 for var in U.extract_variables()})
+
+    # 4) Erwartungswert-Objekt
+    E_obj = tq.ExpectationValue(H=H, U=U)
+
+    # -- SPEX-Berechnung --
+    start_spex = time.time()
+    E_spex = tq.simulate(E_obj, backend='spex', num_threads=6)
+    end_spex = time.time()
+    time_spex = end_spex - start_spex
+
+    # -- Qulacs-Berechnung --
+    if n <= 10:
+        start_qulacs = time.time()
+        E_qulacs = tq.simulate(E_obj, backend='qulacs')
+        end_qulacs = time.time()
+        time_qulacs = end_qulacs - start_qulacs
+
+    total_measurements = E_obj.count_measurements()
+
+    # Speichern der Daten
+    results.append({
+        'n': n,
+        'total_measurements' : total_measurements,
+        'E_spex': E_spex,
+        'time_spex': time_spex,
+        'E_qulacs': E_qulacs,
+        'time_qulacs': time_qulacs
+    })
+
+    if E_qulacs is not None:
+        print(f"n={n:2d} | total_measurements={total_measurements} | "
+              f"E_spex={E_spex:.6f} (dt={time_spex:.2f}s) | "
+              f"E_qulacs={E_qulacs:.6f} (dt={time_qulacs:.2f}s)")
+    else:
+        print(f"n={n:2d} | total_measurements={total_measurements} | "
+              f"E_spex={E_spex:.6f} (dt={time_spex:.2f}s) | "
+              f"E_qulacs=--- (dt=---)  (für n>13 nicht berechnet)")
+    
+    with open("spex_qulacs_comparison.csv", mode="w", newline="") as f:
+        writer = csv.writer(f)
+        # Kopfzeile
+        writer.writerow(["n", "total_measurements", "E_spex", "time_spex", "E_qulacs", "time_qulacs"])
+        # Datenzeilen
+        for entry in results:
+            writer.writerow([
+                entry["n"],
+                entry["total_measurements"],
+                entry["E_spex"],
+                entry["time_spex"],
+                entry["E_qulacs"] if entry["E_qulacs"] is not None else "NA",
+                entry["time_qulacs"] if entry["time_qulacs"] is not None else "NA"
+            ])
+    
+    E_qulacs = None
+
+"""

tequila/tools/convenience.py

@@ -12,7 +12,7 @@ def list_assignment(o):
     """
     if o is None:
         return []
-    elif isinstance(o,tuple):
+    elif isinstance(o, tuple):
         return o
     elif hasattr(o, "__get_item__"):
         return list(o)
@@ -22,14 +22,14 @@ def list_assignment(o):
         return [o]
 
 
-def number_to_string(number: complex, precision: int = 4, threshold: float = 1.e-6) -> str:
+def number_to_string(number: complex, precision: int = 4, threshold: float = 1.0e-6) -> str:
     if not isinstance(number, numbers.Number):
         return str(number)
 
     number = complex(number)
     real = number.real
     imag = number.imag
-    prec = '{:+.' + str(precision) + 'f}'
+    prec = "{:+." + str(precision) + "f}"
 
     if isclose(real, 0.0, atol=threshold):
         return prec.format(imag) + "i"
@@ -37,7 +37,7 @@ def number_to_string(number: complex, precision: int = 4, threshold: float = 1.e
         return prec.format(real)
     else:
         r, theta = polar(number)
-        return prec.format(r) + ('e^(' + prec).format(theta / pi) + 'πi)'
+        return prec.format(r) + ("e^(" + prec).format(theta / pi) + "πi)"
 
 
 if __name__ == "__main__":

tequila/tools/qng.py

@@ -5,15 +5,19 @@ from tequila.circuit.circuit import QCircuit
 from tequila.simulators.simulator_api import compile_objective
 from tequila.circuit.gradient import __grad_inner
 from tequila.autograd_imports import jax
-from tequila.circuit.compiler import compile_controlled_rotation, compile_power_gate, \
-    compile_trotterized_gate, compile_controlled_phase, compile_multitarget
+from tequila.circuit.compiler import (
+    compile_controlled_rotation,
+    compile_power_gate,
+    compile_trotterized_gate,
+    compile_controlled_phase,
+    compile_multitarget,
+)
 import typing
 import numpy
 import copy
 
 
 class QngMatrix:
-
     """
     A callable class which is meant to be used for calculating the inverse qgt of an expectationvalue.
 
@@ -40,18 +44,18 @@ class QngMatrix:
         d = 0
         for block in self.blocks:
             d += len(block)
-        return (d,d)
+        return (d, d)
 
-    def __init__(self,blocks):
+    def __init__(self, blocks):
         """
         Parameters
         ----------
         blocks: list:
             list of list of lists. the blocks of the qgt.
         """
-        self.blocks= blocks
+        self.blocks = blocks
 
-    def __call__(self, variables,samples=None) -> numpy.ndarray:
+    def __call__(self, variables, samples=None) -> numpy.ndarray:
         """
         from the blocks provided, evaluate all qgt terms, then calculate the pseudo-inverse, and return it.
         Parameters
@@ -71,22 +75,21 @@ class QngMatrix:
         # displace our running index of position, as we enumerate through a block
         # d_v does this. If you only provide one block (the whole QGT), this won't matter
         for block in self.blocks:
-
-            d_v_temp = 0 # how much to increment d_v by when done with the block at hand.
+            d_v_temp = 0  # how much to increment d_v by when done with the block at hand.
             for i, row in enumerate(block):
                 for j, term in enumerate(row):
                     if i <= j:
                         # if its an objective, call it. Else, it is a float.
                         try:
-                            output[i + d_v][j + d_v] = term(variables=variables,samples=samples)
-                        except:
+                            output[i + d_v][j + d_v] = term(variables=variables, samples=samples)
+                        except Exception:
                             output[i + d_v][j + d_v] = term
                     else:
                         output[i + d_v][j + d_v] = output[j + d_v][i + d_v]
                 d_v_temp += 1
             d_v += d_v_temp
 
-        back = numpy.linalg.pinv(output) # return the pseudo_inverse of the matrix!
+        back = numpy.linalg.pinv(output)  # return the pseudo_inverse of the matrix!
         return back
 
 
@@ -104,7 +107,7 @@ class CallableVector:
     def dim(self):
         return (len(self._vector),)
 
-    def __init__(self,vector):
+    def __init__(self, vector):
         """
         init.
         Parameters
@@ -133,7 +136,7 @@ class CallableVector:
 
         output = numpy.empty(self.dim)
         for i, entry in enumerate(self._vector):
-            if hasattr(entry, '__call__'):
+            if hasattr(entry, "__call__"):
                 output[i] = entry(variables, samples=samples)
             else:
                 output[i] = entry
@@ -155,24 +158,23 @@ def get_generator(gate) -> paulis.QubitHamiltonian:
 
     """
 
-    if gate.name.lower() == 'rx':
+    if gate.name.lower() == "rx":
         gen = paulis.X(gate.target[0])
-    elif gate.name.lower() == 'ry':
+    elif gate.name.lower() == "ry":
         gen = paulis.Y(gate.target[0])
-    elif gate.name.lower() == 'rz':
+    elif gate.name.lower() == "rz":
         gen = paulis.Z(gate.target[0])
-    elif gate.name.lower() == 'phase':
+    elif gate.name.lower() == "phase":
         gen = paulis.Qm(gate.target[0])
     else:
         print(gate.name.lower())
-        raise TequilaException('cant get the generator of a non Gaussian gate, you fool!')
+        raise TequilaException("cant get the generator of a non Gaussian gate, you fool!")
     return gen
 
 
-def stokes_block(expectation, initial_values=None, samples=None, device=None,
-                 backend=None,
-                 noise=None) -> typing.List[typing.List[typing.List[typing.Union[float,Objective]]]]:
-
+def stokes_block(
+    expectation, initial_values=None, samples=None, device=None, backend=None, noise=None
+) -> typing.List[typing.List[typing.List[typing.Union[float, Objective]]]]:
     """
     returns the blocks of the layerwise block-diagonal approximation to the qgt.
     The default for all qng-based optimizations, as a method for obtaining the qgt.
@@ -207,7 +209,7 @@ def stokes_block(expectation, initial_values=None, samples=None, device=None,
     # rebuild the sub circuits used in the expectation values that populate the QGT
     sub = [QCircuit.from_moments(moments[:i]) for i in range(1, len(moments), 2)]
     # this is the list of just the moments which are parametrized.
-    parametric_moms = [moments[i] for i in range(1, len(moments)+1, 2)]
+    parametric_moms = [moments[i] for i in range(1, len(moments) + 1, 2)]
     generators = []
     # generators is a list of lists, ultimately, where each sublist is all the generators in order
     # for a given parametric layer (if said layer is
@@ -238,13 +240,15 @@ def stokes_block(expectation, initial_values=None, samples=None, device=None,
                 for q, gen2 in enumerate(g_set):
                     ### make sure you compile the objectives! otherwise this bad boy will not run
                     if k == q:
-                        arg = (ExpectationValue(U=sub[i], H=gen1 * gen1) - ExpectationValue(U=sub[i], H=gen1)**2)/4
+                        arg = (ExpectationValue(U=sub[i], H=gen1 * gen1) - ExpectationValue(U=sub[i], H=gen1) ** 2) / 4
                     else:
-                        arg = (ExpectationValue(U=sub[i], H=gen1 * gen2) - ExpectationValue(U=sub[i], H=gen1) *
-                               ExpectationValue(U=sub[i], H=gen2)) / 4
-                    block[k][q] = compile_objective(arg, variables=initial_values, samples=samples,
-                                                    backend=backend, device=device,
-                                                    noise=noise)
+                        arg = (
+                            ExpectationValue(U=sub[i], H=gen1 * gen2)
+                            - ExpectationValue(U=sub[i], H=gen1) * ExpectationValue(U=sub[i], H=gen2)
+                        ) / 4
+                    block[k][q] = compile_objective(
+                        arg, variables=initial_values, samples=samples, backend=backend, device=device, noise=noise
+                    )
             blocks.append(block)
     return blocks
 
@@ -270,18 +274,18 @@ def qng_circuit_grad(E: ExpectationValueImpl) -> typing.List[Objective]:
     unitary = E.U
 
     # fast return if possible
-    out=[]
+    out = []
     for i, g in enumerate(unitary.gates):
-        if g.is_parametrized():
+        if g.is_parameterized():
             if g.is_controlled():
                 raise TequilaException("controlled gate in qng circuit gradient: Compiler was not called")
             if hasattr(g, "eigenvalues_magnitude"):
-                if hasattr(g._parameter,'extract_variables'):
+                if hasattr(g._parameter, "extract_variables"):
                     shifter = qng_grad_gaussian(unitary, g, i, hamiltonian)
                     out.append(shifter)
             else:
                 print(g, type(g))
-                raise TequilaException('No shift found for gate {}'.format(g))
+                raise TequilaException("No shift found for gate {}".format(g))
     if out is None:
         raise TequilaException("caught a dead circuit in qng gradient")
     return out
@@ -336,8 +340,9 @@ def qng_grad_gaussian(unitary, g, i, hamiltonian) -> Objective:
     return dOinc
 
 
-def subvector_procedure(e_val, initial_values=None, samples=None, device=None,
-                        backend=None, noise=None) -> CallableVector:
+def subvector_procedure(
+    e_val, initial_values=None, samples=None, device=None, backend=None, noise=None
+) -> CallableVector:
     """
     take an expectation value and return its (qng style) gradient as a CallableVector.
 
@@ -364,9 +369,11 @@ def subvector_procedure(e_val, initial_values=None, samples=None, device=None,
     vect = qng_circuit_grad(e_val)
     out = []
     for entry in vect:
-        out.append(compile_objective(entry, variables=initial_values, samples=samples, device=device,
-                                     backend=backend,
-                                     noise=noise))
+        out.append(
+            compile_objective(
+                entry, variables=initial_values, samples=samples, device=device, backend=backend, noise=noise
+            )
+        )
     return CallableVector(out)
 
 
@@ -384,10 +391,10 @@ def get_self_pars(U) -> typing.List:
         list eg. of Objectives and Variables; the self-parameters of a circuit.
     """
 
-    out=[]
+    out = []
     for g in U.gates:
-        if g.is_parametrized():
-            if hasattr(g._parameter,'extract_variables'):
+        if g.is_parameterized():
+            if hasattr(g._parameter, "extract_variables"):
                 out.append(g._parameter)
     return out
 
@@ -416,13 +423,12 @@ def qng_dict(argument, matrix, subvector, mapping, positional) -> typing.Dict:
         dict containing information used to obtain the qng of some argument of an objective.
 
     """
-    return {'arg': argument, 'matrix': matrix, 'vector': subvector, 'mapping': mapping, 'positional': positional}
-
+    return {"arg": argument, "matrix": matrix, "vector": subvector, "mapping": mapping, "positional": positional}
 
-def get_qng_combos(objective, func=stokes_block,
-                   initial_values=None, samples=None,
-                   backend=None, device=None, noise=None) -> typing.List[typing.Dict]:
 
+def get_qng_combos(
+    objective, func=stokes_block, initial_values=None, samples=None, backend=None, device=None, noise=None
+) -> typing.List[typing.Dict]:
     """
     get all the objects needed to evaluate the qng for some objective; return them in a list of dictionaries.
 
@@ -459,7 +465,7 @@ def get_qng_combos(objective, func=stokes_block,
     compiled = compile_power_gate(gate=compiled)
     compiled = compile_controlled_phase(gate=compiled)
     compiled = compile_controlled_rotation(gate=compiled)
-    for i,arg in enumerate(compiled.args):
+    for i, arg in enumerate(compiled.args):
         if not isinstance(arg, ExpectationValueImpl):
             # this is a variable, no QNG involved
             mat = QngMatrix([[[1]]])
@@ -467,13 +473,15 @@ def get_qng_combos(objective, func=stokes_block,
             mapping = {0: {v: __grad_inner(arg, v) for v in var_list}}
         else:
             # if the arg is an expectationvalue, we need to build some qngs and mappings!
-            blocks = func(arg, initial_values=initial_values, samples=samples, device=device,
-                          backend=backend, noise=noise)
+            blocks = func(
+                arg, initial_values=initial_values, samples=samples, device=device, backend=backend, noise=noise
+            )
 
             mat = QngMatrix(blocks)
 
-            vec = subvector_procedure(arg, initial_values=initial_values, samples=samples, device=device,
-                                      backend=backend, noise=noise)
+            vec = subvector_procedure(
+                arg, initial_values=initial_values, samples=samples, device=device, backend=backend, noise=noise
+            )
 
             mapping = {}
             self_pars = get_self_pars(arg.U)
@@ -482,25 +490,25 @@ def get_qng_combos(objective, func=stokes_block,
                 for v in p.extract_variables():
                     gi = __grad_inner(p, v)
                     if isinstance(gi, Objective):
-                        g = compile_objective(gi, variables=initial_values, samples=samples, device=device,
-                                              backend=backend, noise=noise)
+                        g = compile_objective(
+                            gi, variables=initial_values, samples=samples, device=device, backend=backend, noise=noise
+                        )
                     else:
                         g = gi
                     indict[v] = g
                 mapping[j] = indict
 
-
         pos_arg = jax.grad(compiled.transformation, i)
         p = Objective(compiled.args, transformation=pos_arg)
 
-        pos = compile_objective(p, variables=initial_values, samples=samples, device=device,
-                                backend=backend, noise=noise)
+        pos = compile_objective(
+            p, variables=initial_values, samples=samples, device=device, backend=backend, noise=noise
+        )
         combos.append(qng_dict(arg, mat, vec, mapping, pos))
     return combos
 
 
 def evaluate_qng(combos, variables, samples=None) -> list:
-
     """
     actually evaluate the terms of a qng.
     Parameters
@@ -520,17 +528,17 @@ def evaluate_qng(combos, variables, samples=None) -> list:
     """
     gd = {v: 0 for v in variables.keys()}
     for c in combos:
-        qgt = c['matrix']
-        vec = c['vector']
-        m = c['mapping']
-        pos = c['positional']
+        qgt = c["matrix"]
+        vec = c["vector"]
+        m = c["mapping"]
+        pos = c["positional"]
         marco = qgt(variables, samples=samples)
         polo = vec(variables, samples=samples)
         ev = numpy.dot(marco, polo)
         for i, val in enumerate(ev):
             maps = m[i]
             for k in maps.keys():
-                gd[k] += (val*maps[k]*pos)(variables=variables, samples=samples)
+                gd[k] += (val * maps[k] * pos)(variables=variables, samples=samples)
 
     out = [v for v in gd.values()]
     return out
@@ -547,7 +555,7 @@ class QNGVector:
 
     """
 
-    def __init__(self,combos):
+    def __init__(self, combos):
         """
         init.
         Parameters