tequila-basic 1.9.3__py3-none-any.whl → 1.9.5__py3-none-any.whl

tequila/apps/adapt/adapt.py

@@ -21,7 +21,7 @@ class AdaptParameters:
     degeneracy_threshold: float = 5.e-4
     silent: bool = False
     
-    def __post__init__(self):
+    def __post_init__(self):
         # avoid stacking of same operator-types in a row
         if "method_options" in self.optimizer_args:
             if "gtol" in self.optimizer_args["method_options"]:

tequila/circuit/qasm.py

@@ -313,19 +313,33 @@ def parse_command(command: str, custom_gates_map: Dict[str, QCircuit], qregister
         return apply_custom_gate(custom_circuit=custom_circuit, qregisters_values=qregisters_values)
 
     if name in ("x", "y", "z", "h", "cx", "cy", "cz", "ch"):
-        return QCircuit.wrap_gate(gates.impl.QGateImpl(name=(name[1] if name[0] == 'c' else name).upper(),
-                                            control=get_qregister(args[0], qregisters) if name[0] == 'c' else None,
-                                            target=get_qregister(args[1 if name[0] == 'c' else 0], qregisters)))
+        target = get_qregister(args[0], qregisters)
+        control = None
+        if name[0].lower() == 'c':
+            control = get_qregister(args[0], qregisters)
+            target = get_qregister(args[1], qregisters)
+            name = name[1]
+        G = getattr(gates, name.upper())
+        return G(control=control, target=target)
+
     if name in ("ccx", "ccy", "ccz"):
-        return QCircuit.wrap_gate(gates.impl.QGateImpl(name=name.upper()[2],
-                                            control=[get_qregister(args[0], qregisters), get_qregister(args[1], qregisters)],
-                                            target=get_qregister(args[2], qregisters)))
+        G = getattr(gates, name[2].upper())
+        control = [get_qregister(args[0], qregisters), get_qregister(args[1], qregisters)]
+        target = get_qregister(args[2], qregisters)
+        return G(control=control, target=target)
+
     if name.startswith("rx(") or name.startswith("ry(") or name.startswith("rz(") or \
         name.startswith("crx(") or name.startswith("cry(") or name.startswith("crz("):
-        return QCircuit.wrap_gate(gates.impl.RotationGateImpl(axis=name[2 if name[0] == 'c' else 1],
-                                                   angle=get_angle(name)[0],
-                                                   control=get_qregister(args[0], qregisters) if name[0] == 'c' else None,
-                                                   target=get_qregister(args[1 if name[0] == 'c' else 0], qregisters)))
+        angle = get_angle(name)[0]
+        i = name.find('(')
+        name = name[0:i]
+        name = name.upper()
+        name = [x for x in name]
+        name[-1] = name[-1].lower()
+        name = "".join(name)
+        G = getattr(gates, name)
+        return G(angle=angle,control=get_qregister(args[0], qregisters) if name[0] == 'C' else None,target=get_qregister(args[1 if name[0] == 'C' else 0], qregisters))
+            
     if name.startswith("U("):
         angles = get_angle(name)
         return gates.U(theta=angles[0], phi=angles[1], lambd=angles[2],
@@ -362,7 +376,7 @@ def parse_command(command: str, custom_gates_map: Dict[str, QCircuit], qregister
                   control=get_qregister(args[0], qregisters),
                   target=get_qregister(args[1], qregisters))
     if name in ("s", "t", "sdg", "tdg"):
-        g = gates.Phase(pi / (2 if name.startswith("s") else 4),
+        g = gates.Phase(angle=pi / (2 if name.startswith("s") else 4),
                      control=None,
                      target=get_qregister(args[0], qregisters))
         if name.find("dg") != -1:

tequila/optimizers/__init__.py

@@ -16,7 +16,7 @@ class _Optimizers:
     methods: list = None
 
 
-SUPPORTED_OPTIMIZERS = ['scipy', 'phoenics', 'gpyopt', 'gd']
+SUPPORTED_OPTIMIZERS = ['scipy', 'gpyopt', 'gd']
 INSTALLED_OPTIMIZERS = {}
 INSTALLED_OPTIMIZERS['scipy'] = _Optimizers(cls=OptimizerSciPy,
                                             minimize=minimize_scipy,
@@ -37,19 +37,6 @@ try:
 except ImportError:
     has_gpyopt = False
 
-has_phoenics = False
-try:
-    from tequila.optimizers.optimizer_phoenics import OptimizerPhoenics
-    from tequila.optimizers.optimizer_phoenics import minimize as minimize_phoenics
-
-    INSTALLED_OPTIMIZERS['phoenics'] = _Optimizers(cls=OptimizerPhoenics,
-                                                   minimize=minimize_phoenics,
-                                                   methods=OptimizerPhoenics.available_methods())
-    has_phoenics = True
-except ImportError:
-    has_phoenics = False
-
-
 def show_available_optimizers(module=None):
     """
     Returns

tequila/optimizers/optimizer_gpyopt.py

@@ -4,8 +4,6 @@ import typing
 import numbers
 from tequila.objective.objective import Variable
 import warnings
-
-warnings.simplefilter("ignore")
 import GPyOpt
 from GPyOpt.methods import BayesianOptimization
 import numpy as np

tequila/quantumchemistry/__init__.py

@@ -95,6 +95,8 @@ def Molecule(geometry: str = None,
     if backend is None:
         if basis_set is None or basis_set.lower() in ["madness", "mra", "pno"]:
             backend = "madness"
+            basis_set = "mra"
+            parameters.basis_set = basis_set
             if orbital_type is not None and orbital_type.lower() not in ["pno", "mra-pno"]:
                 warnings.warn("only PNOs supported as orbital_type without basis set. Setting to pno - You gave={}".format(orbital_type), TequilaWarning)
             orbital_type = "pno"

tequila/quantumchemistry/chemistry_tools.py

@@ -569,7 +569,7 @@ class NBodyTensor:
         return True
 
     def __init__(self, elems: numpy.ndarray = None, active_indices: list = None, ordering: str = None,
-                 size_full: int = None):
+                 size_full: int = None, verify=False):
         """
         Parameters
         ----------
@@ -611,7 +611,7 @@ class NBodyTensor:
         if self.order == 4:
             if ordering is None:
                 ordering = self.identify_ordering()
-            else:
+            elif verify:
                 try: # some RDMs are really sloppy (depends on backend)
                     auto_ordering=self.identify_ordering()
                     if auto_ordering is not ordering:
@@ -804,20 +804,18 @@ class IntegralManager:
     _one_body_integrals: numpy.ndarray = None
     _two_body_integrals: NBodyTensor = None
     _constant_term: float = None
-    _basis_type: str = "unknown"
     _basis_name: str = "unknown"
     _orbital_type: str = "unknown" # e.g. "HF", "PNO", "native"
     _orbital_coefficients: numpy.ndarray = None
     _active_space: ActiveSpaceData = None
     _orbitals: typing.List[OrbitalData] = None
 
-    def __init__(self, one_body_integrals, two_body_integrals, basis_type="custom",
+    def __init__(self, one_body_integrals, two_body_integrals,
                  basis_name="unknown", orbital_type="unknown",
                  constant_term=0.0, orbital_coefficients=None, active_space=None, overlap_integrals=None, orbitals=None, *args, **kwargs):
         self._one_body_integrals = one_body_integrals
         self._two_body_integrals = two_body_integrals
         self._constant_term = constant_term
-        self._basis_type = basis_type
         self._basis_name = basis_name
         self._orbital_type = orbital_type
 
@@ -956,9 +954,16 @@ class IntegralManager:
         """
         c = self.get_orthonormalized_orbital_coefficients()
         self.orbital_coefficients=c
-        self._orbital_type="orthonormalized-{}-basis".format(self._orbital_type)
+        self._orbital_type="orthonormalized-{}-basis".format(self._basis_name)
+
+    def is_unitary(self, U):
+        if len(U.shape) != 2: return False
+        if U.shape[0] != U.shape[1]: return False
+        test = (U.conj().T).dot(U) - numpy.eye(U.shape[0])
+        if not numpy.isclose(numpy.linalg.norm(test), 0.0): return False
+        return True
 
-    def transform_orbitals(self, U):
+    def transform_orbitals(self, U, name=None):
         """
         Transform orbitals
         Parameters
@@ -969,10 +974,12 @@ class IntegralManager:
         -------
         updates the structure with new orbitals: c = cU
         """
-        c = self.orbital_coefficients
-        c = numpy.einsum("ix, xj -> ij", c, U, optimize="greedy")
-        self.orbital_coefficients = c
-        self._orbital_type += "-transformed"
+        assert self.is_unitary(U)
+        self.orbital_coefficients = numpy.einsum("ix, xj -> ij", self.orbital_coefficients, U, optimize="greedy")
+        if name is None:
+            self._orbital_type += "-transformed"
+        else:
+            self._orbital_type = name
 
     def get_integrals(self, orbital_coefficients=None, ordering="openfermion", ignore_active_space=False, *args, **kwargs):
         """
@@ -1001,7 +1008,9 @@ class IntegralManager:
             active_integrals = get_active_space_integrals(one_body_integrals=h, two_body_integrals=g,
                                                           occupied_indices=self._active_space.frozen_reference_orbitals,
                                                           active_indices=self._active_space.active_orbitals)
+
             c = active_integrals[0] + c
+
             h = active_integrals[1]
             g = NBodyTensor(elems=active_integrals[2], ordering="openfermion")
         g.reorder(to=ordering)
@@ -1069,14 +1078,16 @@ class IntegralManager:
             result += str(x) + "\n"
         return result
 
-    def print_basis_info(self, *args, **kwargs) -> None:
-        print("{:15} : {}".format("basis_type", self._basis_type), *args, **kwargs)
+    def print_basis_info(self, print_coefficients=True, *args, **kwargs) -> None:
         print("{:15} : {}".format("basis_name", self._basis_name), *args, **kwargs)
         print("{:15} : {}".format("orbital_type", self._orbital_type), *args, **kwargs)
-        print("{:15} : {}".format("orthogonal", self.basis_is_orthogonal()), *args, **kwargs)
-        print("{:15} : {}".format("functions", self.one_body_integrals.shape[0]), *args, **kwargs)
+        print("{:15} : {}".format("orthogonal basis", self.basis_is_orthogonal()), *args, **kwargs)
+        print("{:15} : {}".format("basis functions", self.one_body_integrals.shape[0]), *args, **kwargs)
+        print("{:15} : {}".format("active orbitals", [o.idx_total for o in self.active_orbitals]), *args, **kwargs)
         print("{:15} : {}".format("reference", [x.idx_total for x in self.reference_orbitals]), *args, **kwargs)
 
+        if not print_coefficients: return
+
         print("Current Orbitals", *args, **kwargs)
         for i,x in enumerate(self.orbitals):
             print(x, *args, **kwargs)

tequila/quantumchemistry/madness_interface.py

@@ -122,7 +122,7 @@ class QuantumChemistryMadness(QuantumChemistryBase):
             h = "failed"
             g = "failed"
 
-        if "failed" in h or "failed" in g:
+        if (isinstance(h, str) and "failed" in h) or (isinstance(g, str) and "failed" in g):
             status = "found {}_htensor.npy={}\n".format(name, "failed" not in h)
             status += "found {}_gtensor.npy={}\n".format(name, "failed" not in g)
             try:

tequila/quantumchemistry/orbital_optimizer.py

@@ -37,7 +37,7 @@ class OptimizeOrbitalsResult:
         self.iterations += 1
 
 def optimize_orbitals(molecule, circuit=None, vqe_solver=None, pyscf_arguments=None, silent=False,
-                      vqe_solver_arguments=None, initial_guess=None, return_mcscf=False, use_hcb=False, molecule_factory=None, molecule_arguments=None, *args, **kwargs):
+                      vqe_solver_arguments=None, initial_guess=None, return_mcscf=False, use_hcb=False, molecule_factory=None, molecule_arguments=None, restrict_to_active_space=True, *args, **kwargs):
     """
 
     Parameters
@@ -78,7 +78,12 @@ def optimize_orbitals(molecule, circuit=None, vqe_solver=None, pyscf_arguments=N
     if pyscf_arguments is None:
         pyscf_arguments = {"max_cycle_macro": 10, "max_cycle_micro": 3}
     no = molecule.n_orbitals
-    pyscf_molecule = QuantumChemistryPySCF.from_tequila(molecule=molecule, transformation=molecule.transformation)
+
+    if not isinstance(molecule, QuantumChemistryPySCF):
+        pyscf_molecule = QuantumChemistryPySCF.from_tequila(molecule=molecule, transformation=molecule.transformation)
+    else:
+        pyscf_molecule = molecule
+
     mf = pyscf_molecule._get_hf()
     result=OptimizeOrbitalsResult()
     mc = mcscf.CASSCF(mf, pyscf_molecule.n_orbitals, pyscf_molecule.n_electrons)
@@ -118,13 +123,15 @@ def optimize_orbitals(molecule, circuit=None, vqe_solver=None, pyscf_arguments=N
         print(wrapper)
     if initial_guess is not None:
         if hasattr(initial_guess, "lower"):
-            if "random" in initial_guess.lower():
-                scale = 0.1
+            if "random" or "near_zero" in initial_guess.lower():
+                scale = 1.e-3
+                if "random" in initial_guess.lower():
+                    scale = 1.0
                 loc = 0.0
                 if "scale" in kwargs:
-                    scale = kwargs["scale"]
+                    scale = float(initial_guess.split("scale")[1].split("_")[0].split("=")[1])
                 if "loc" in kwargs:
-                    loc = kwargs["loc"]
+                    loc = float(initial_guess.split("loc")[1].split("_")[0].split("=")[1])
                 initial_guess = numpy.eye(no) + numpy.random.normal(scale=scale, loc=loc, size=no * no).reshape(no, no)
             else:
                 raise Exception("Unknown initial_guess={}".format(initial_guess.lower()))
@@ -138,10 +145,11 @@ def optimize_orbitals(molecule, circuit=None, vqe_solver=None, pyscf_arguments=N
         mc.kernel()
     # make new molecule
 
-    transformed_molecule = pyscf_molecule.transform_orbitals(orbital_coefficients=mc.mo_coeff)
+    mo_coeff = mc.mo_coeff
+    transformed_molecule = pyscf_molecule.transform_orbitals(orbital_coefficients=mo_coeff, name="optimized")
     result.molecule=transformed_molecule
     result.old_molecule=molecule
-    result.mo_coeff=mc.mo_coeff
+    result.mo_coeff=mo_coeff
     result.energy=mc.e_tot
     
     if return_mcscf:

tequila/quantumchemistry/pyscf_interface.py

@@ -75,6 +75,7 @@ class QuantumChemistryPySCF(QuantumChemistryBase):
             kwargs["two_body_integrals"] = g_ao
             kwargs["one_body_integrals"] = h_ao
             kwargs["orbital_coefficients"] = mo_coeff
+            kwargs["orbital_type"] = "hf"
 
             if "nuclear_repulsion" not in kwargs:
                 kwargs["nuclear_repulsion"] = mol.energy_nuc()

tequila/quantumchemistry/qc_base.py

@@ -94,7 +94,7 @@ class QuantumChemistryBase:
         else:
             self.integral_manager = self.initialize_integral_manager(active_orbitals=active_orbitals,
                                                                      reference_orbitals=reference_orbitals,
-                                                                     orbitals=orbitals, frozen_orbitals=frozen_orbitals, orbital_type=orbital_type, *args,
+                                                                     orbitals=orbitals, frozen_orbitals=frozen_orbitals, orbital_type=orbital_type, basis_name=self.parameters.basis_set, *args,
                                                                      **kwargs)
         
         if orbital_type is not None and orbital_type.lower() == "native":
@@ -109,15 +109,23 @@ class QuantumChemistryBase:
 
     @classmethod
     def from_tequila(cls, molecule, transformation=None, *args, **kwargs):
-        c, h1, h2 = molecule.get_integrals()
+        c = molecule.integral_manager.constant_term
+        h1 = molecule.integral_manager.one_body_integrals
+        h2 = molecule.integral_manager.two_body_integrals
+        S = molecule.integral_manager.overlap_integrals
+        active_orbitals = [o.idx_total for o in molecule.integral_manager.active_orbitals]
         if transformation is None:
             transformation = molecule.transformation
+        parameters = molecule.parameters
         return cls(nuclear_repulsion=c,
                    one_body_integrals=h1,
                    two_body_integrals=h2,
-                   n_electrons=molecule.n_electrons,
+                   overlap_integrals = S,
+                   orbital_coefficients = molecule.integral_manager.orbital_coefficients,
+                   active_orbitals= active_orbitals,
                    transformation=transformation,
-                   parameters=molecule.parameters, *args, **kwargs)
+                   orbital_type=molecule.integral_manager._orbital_type,
+                   parameters=parameters, *args, **kwargs)
 
     def supports_ucc(self):
         """
@@ -543,11 +551,13 @@ class QuantumChemistryBase:
 
         return manager
 
-    def transform_orbitals(self, orbital_coefficients, *args, **kwargs):
+    def transform_orbitals(self, orbital_coefficients, ignore_active_space=False, name=None, *args, **kwargs):
         """
         Parameters
         ----------
-        orbital_coefficients: second index is new orbital indes, first is old orbital index (summed over)
+        orbital_coefficients: second index is new orbital indes, first is old orbital index (summed over), indices are assumed to be defined on the active space
+        ignore_active_space: if true orbital_coefficients are not assumed to be given in the active space
+        name: str, name the new orbitals
         args
         kwargs
 
@@ -556,9 +566,20 @@ class QuantumChemistryBase:
         New molecule with transformed orbitals
         """
 
+        U = numpy.eye(self.integral_manager.orbital_coefficients.shape[0])
+        # mo_coeff by default only acts on the active space
+        active_indices = [o.idx_total for o in self.integral_manager.active_orbitals]
+
+        if ignore_active_space:
+            U = orbital_coefficients
+        else:
+            for kk,k in enumerate(active_indices):
+                for ll,l in enumerate(active_indices):
+                    U[k][l] = orbital_coefficients[kk][ll]
+
         # can not be an instance of a specific backend (otherwise we get inconsistencies with classical methods in the backend)
         integral_manager = copy.deepcopy(self.integral_manager)
-        integral_manager.transform_orbitals(U=orbital_coefficients)
+        integral_manager.transform_orbitals(U=U, name=name)
         result = QuantumChemistryBase(parameters=self.parameters, integral_manager=integral_manager, transformation=self.transformation)
         return result
     
@@ -583,7 +604,7 @@ class QuantumChemistryBase:
         else:
             integral_manager = copy.deepcopy(self.integral_manager)
             integral_manager.transform_to_native_orbitals()
-            result = QuantumChemistryBase(parameters=self.parameters, integral_manager=integral_manager, orbital_type="native", transformation=self.transformation)
+            result = QuantumChemistryBase(parameters=self.parameters, integral_manager=integral_manager, transformation=self.transformation)
             return result
 
 
@@ -645,6 +666,68 @@ class QuantumChemistryBase:
         """
         return 2 * len(self.integral_manager.active_reference_orbitals)
 
+    def make_annihilation_op(self, orbital, coefficient=1.0):
+        """
+        Compute annihilation operator on spin-orbital in qubit representation
+        Spin-orbital order is always (up,down,up,down,...)
+        """
+        assert orbital<=self.n_orbitals*2
+        aop = openfermion.ops.FermionOperator(f'{orbital}', coefficient)
+        return self.transformation(aop)
+
+    def make_creation_op(self, orbital, coefficient=1.0):
+        """
+        Compute creation operator on spin-orbital in qubit representation
+        Spin-orbital order is always (up,down,up,down,...)
+        """
+        assert orbital<=self.n_orbitals*2
+        cop = openfermion.ops.FermionOperator(f'{orbital}^', coefficient)
+        return self.transformation(cop)
+
+    def make_number_op(self, orbital):
+        """
+        Compute number operator on spin-orbital in qubit representation
+        Spin-orbital order is always (up,down,up,down,...)
+        """
+        num_op = self.make_creation_op(orbital) * self.make_annihilation_op(orbital)
+        return num_op
+    
+    def make_sz_op(self):
+        """
+        Compute the spin_z operator of the molecule in qubit representation
+        """
+        sz = QubitHamiltonian()
+        for i in range(0, self.n_orbitals * 2, 2):
+            one = 0.5 * self.make_creation_op(i) * self.make_annihilation_op(i)
+            two = 0.5 * self.make_creation_op(i+1) * self.make_annihilation_op(i+1)
+            sz += (one - two)
+        return sz
+
+    def make_sp_op(self):
+        """
+        Compute the spin+ operator of the molecule in qubit representation
+        """
+        sp = QubitHamiltonian()
+        for i in range(self.n_orbitals):
+            sp += self.make_creation_op(i*2) * self.make_annihilation_op(i*2 + 1)
+        return sp
+
+    def make_sm_op(self):
+        """
+        Compute the spin- operator of the molecule in qubit representation
+        """
+        sm = QubitHamiltonian()
+        for i in range(self.n_orbitals):
+            sm += self.make_creation_op(i*2 + 1) * self.make_annihilation_op(i*2)
+        return sm
+
+    def make_s2_op(self):
+        """
+        Compute the spin^2 operator of the molecule in qubit representation
+        """
+        s2_op = self.make_sm_op() * self.make_sp_op() + self.make_sz_op() * (self.make_sz_op() + 1)
+        return s2_op
+
     def make_hamiltonian(self, *args, **kwargs) -> QubitHamiltonian:
         """
         Parameters
@@ -805,13 +888,13 @@ class QuantumChemistryBase:
         """
         if U is None:
             U = QCircuit()
-
-        # consistency
-        consistency = [x < self.n_orbitals for x in U.qubits]
-        if not all(consistency):
-            warnings.warn(
-                "hcb_to_me: given circuit is not defined on the first {} qubits. Is this a HCB circuit?".format(
-                    self.n_orbitals))
+        else:
+            ups = [self.transformation.up(i.idx) for i in self.orbitals]
+            consistency = [x in ups for x in U.qubits]
+            if not all(consistency):
+                warnings.warn(
+                    "hcb_to_me: given circuit is not defined on all first {} qubits. Is this a HCB circuit?".format(
+                        self.n_orbitals))
 
         # map to alpha qubits
         if condensed:
@@ -1939,7 +2022,7 @@ class QuantumChemistryBase:
             self._rdm2 = _assemble_rdm2_spinful(evals_2) if get_rdm2 else self._rdm2
 
         if get_rdm2:
-            rdm2 = NBodyTensor(elems=self.rdm2, ordering="dirac")
+            rdm2 = NBodyTensor(elems=self.rdm2, ordering="dirac", verify=False)
             rdm2.reorder(to=ordering)
             rdm2 = rdm2.elems
             self._rdm2 = rdm2

tequila/version.py

@@ -1,2 +1,2 @@
-__version__ = "1.9.3"
+__version__ = "1.9.5"
 __author__ = "Tequila Developers "

{tequila_basic-1.9.3.dist-info → tequila_basic-1.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tequila-basic
-Version: 1.9.3
+Version: 1.9.5
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
 Author: Tequila Developers 
@@ -32,7 +32,7 @@ Tequila can execute the underlying quantum expectation values on state of the ar
 - [talks and slides](https://kottmanj.github.io/talks_and_material/)  
 
 # Installation
-Recommended Python version is 3.8-3.9.   
+Recommended Python version is 3.9 - 3.10.   
 Tequila supports linux, osx and windows. However, not all optional dependencies are supported on windows.  
 
 ## Install from PyPi
@@ -258,6 +258,14 @@ A.G. Cadavid, I. Montalban, A. Dalal, E. Solano, N.N. Hegade
 Efficient DCQO Algorithm within the Impulse Regime for Portfolio Optimization  
 [arxiv:2308.15475](https://arxiv.org/abs/2308.15475)  
 
+A. Anand, K. Brown  
+Hamiltonians, groups, graphs and ansätze  
+[arxiv:2312.17146](https://arxiv.org/abs/2312.17146)  
+
+P.W.K. Jensen, E.R. Kjellgren, P. Reinholdt, K.M. Ziems, S. Coriani, J. Kongsted, S. Sauer  
+Quantum Equation of Motion with Orbital Optimization for Computing Molecular Properties in Near-Term Quantum Computing  
+[arxiv:2312.12386](https://arxiv.org/abs/2312.12386)  
+
 Let us know, if you want your research project and/or tutorial to be included in this list!
 
 # Dependencies
@@ -285,7 +293,7 @@ Currently supported
 ### [Psi4](https://github.com/psi4/psi4).
 In a conda environment this can be installed with
 ```bash
-conda install psi4 -c psi4
+conda install psi4 -c conda-forge
 ```
 Here is a small [tutorial](https://nbviewer.org/github/tequilahub/tequila-tutorials/blob/main/chemistry/ChemistryModule.ipynb) that illustrates the usage.
 

{tequila_basic-1.9.3.dist-info → tequila_basic-1.9.5.dist-info}/RECORD

@@ -1,11 +1,11 @@
 tequila/__init__.py,sha256=FV8-j7GEw_VYadsZUp3M2mGRQxVUYYG3W1jiI6in3CY,1959
 tequila/autograd_imports.py,sha256=t7V5uYaI0GzjD7pSjkYtiaj3BzSvkm_RL2KcYfNwNhM,1529
-tequila/version.py,sha256=fyejnt-h5HHJUsr2oT4LevELwW82LlGR2EKQx51jYow,57
+tequila/version.py,sha256=TrfaFu9jLo_4f8zxqIwjs8NumC_hbB4Op1r-ZZIEnyY,57
 tequila/apps/__init__.py,sha256=GJb04napv8AAx5EHxS5C1CMv9kxQeu7aA-ZMWk6X_eQ,1623
 tequila/apps/_unary_state_prep_impl.py,sha256=SzRtI0Nx29ODygvYYdC1NnSTCL70wY7NTAvqhiwpMDs,21757
 tequila/apps/unary_state_prep.py,sha256=QCrD9Ty2RkXc1Mh_MitFPIdaPs_fLxp_dtWVBZi0tSE,9403
 tequila/apps/adapt/__init__.py,sha256=_XTo-36nJRXdM13rbPkWEowFXGdViFduINwzri5i1iM,166
-tequila/apps/adapt/adapt.py,sha256=Eqc2Fx0GqkjI2EyTX2hGpVNeBP9BdUVz9ejE19IcR9I,19530
+tequila/apps/adapt/adapt.py,sha256=Wf2k7DWJaos_7se9YU6zw6ZZorcNvwCY3HQbo-ha884,19529
 tequila/apps/krylov/__init__.py,sha256=Kp3WBq-_OaaxRr8G8I_DBjvjkMKNa9cDWJHLRHGNGsU,33
 tequila/apps/krylov/krylov.py,sha256=z6Hpo5deawJNMW77KaOa8QIHQ8rXXCl341DVUf326_s,2274
 tequila/apps/robustness/__init__.py,sha256=6BOjqcFWP3ymuit4JJ5cbzxS-G2AOCTdwcl87I-pNG8,62
@@ -19,7 +19,7 @@ tequila/circuit/gates.py,sha256=pOvX9_vACFyUAZRG4EGW3_aZGXysUJwUV8oFiKyLJ50,3590
 tequila/circuit/gradient.py,sha256=Y4dNL6nkZUEkKJvaA3hxaSEa8_b_3XZwxy3j8tGsOmA,10465
 tequila/circuit/noise.py,sha256=2LJ7Xq5f78x9p4imIz76l_lABQZwgNteNBFkWmUAQvo,8322
 tequila/circuit/pyzx.py,sha256=XHhKoklhEcbpYkgkWHBLmKF-vyt_Oz-pX-Ctvd4nAOQ,1472
-tequila/circuit/qasm.py,sha256=05LFOJ357Gfb7oINbD6JVgdINy0sDWynVyBJNg3aRe8,15455
+tequila/circuit/qasm.py,sha256=iB5stV6Exo3bAn7ac1PgFKH53XD-57b9lpmzjavJK7k,15418
 tequila/circuit/qpic.py,sha256=rjNAStvgNtqa89wJ3pmuzPoPWGZVI0gxARZuUnGtJa0,10789
 tequila/grouping/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 tequila/grouping/binary_rep.py,sha256=VVM2o6B_RC0uH8kqE4yNxTzkGlgUm-CJTZ6z5J7R9I8,19406
@@ -41,21 +41,20 @@ tequila/objective/__init__.py,sha256=_BS3tVabs0zdon46nKpKmk3gI40z6KaWsjynIBMnPuc
 tequila/objective/braket.py,sha256=10jEj7F3VWAj-fVrD4nhptrgRfrGvij84mVYcJWq4ZU,6019
 tequila/objective/objective.py,sha256=8MzzTousgJf7w7rEdqGr8MU0PRF7S4kwh3BgsMMjnEg,31763
 tequila/objective/qtensor.py,sha256=eSjFOEVW-kLoM8jn1RD2_E_kHVAm579Ji3_lMcJg7cE,7957
-tequila/optimizers/__init__.py,sha256=sSyXc_FD0wTzS0cmgkdf1DhH-0XMUp2k5wARMM57nhI,5603
+tequila/optimizers/__init__.py,sha256=1AhFyARYIfdyFGwnjOX0RDDa_kGrhiLJyjEbEm4NgZI,5086
 tequila/optimizers/_containers.py,sha256=CXbWWQory_aADxlaMw4deIr03K_el-0E12GmpA0vX10,7161
 tequila/optimizers/optimizer_base.py,sha256=Nc1HwlgfeB6XifoaWdFVLhdyHfeqQuhLvOtmtoFDMPY,32272
 tequila/optimizers/optimizer_gd.py,sha256=QF84K2XDn_-0w9htDlEpIaaGGtfudNamIvVCgx1JkuE,39059
-tequila/optimizers/optimizer_gpyopt.py,sha256=ZDiln0khwc5PHTBuX83eRkclSKIt-iFVYaTK8A1ZX9w,11313
-tequila/optimizers/optimizer_phoenics.py,sha256=31GBSC4P_-JqjYn3Bjmn3W7vDXW3Zn8aRxi8FWh2Uqc,13448
+tequila/optimizers/optimizer_gpyopt.py,sha256=-aVuutZUScyo6_4q4PyvMMa_OVd3L8ev9Ge2fXyWGV8,11280
 tequila/optimizers/optimizer_scipy.py,sha256=zqRVQ-Whr74KCGP7Zg1jQkl9S3j9s1kS4oCrCtX30gY,18949
-tequila/quantumchemistry/__init__.py,sha256=7P3LAgRt9BYHFlByOx0u_lkYuUykqMXPFnic5YBNpEI,7349
-tequila/quantumchemistry/chemistry_tools.py,sha256=zQ9CX3qXhkGvSpdsZGHzdwnzCBP-PhY06M0FyOXJedc,40939
+tequila/quantumchemistry/__init__.py,sha256=KP99PNJYVwBcfQGwL-MB9IBLSBJNRPf-5WN9NLqT-Rg,7424
+tequila/quantumchemistry/chemistry_tools.py,sha256=2zpQU8p_xV2mDQ6Q1tWqQPdAvt2OqjQV8PcGgiOo0UU,41353
 tequila/quantumchemistry/encodings.py,sha256=y9h6rjq1K9IPVBMbRFQWXyBuAIZzgh2DVw2IUKtpuIM,8656
-tequila/quantumchemistry/madness_interface.py,sha256=WbBnbVInjoA_2xtp7ejifj2I1L7ZHtxK5ToOEwMD2BY,36254
-tequila/quantumchemistry/orbital_optimizer.py,sha256=2umPiT5GasteMz-9_4IL5q54PWKJ9rIKGVlJP593aM0,11995
+tequila/quantumchemistry/madness_interface.py,sha256=f5c19Whb9Ene9UnkU1aKFqcGFkvN_TrR1o_G7xuC5dE,36304
+tequila/quantumchemistry/orbital_optimizer.py,sha256=P_y4Q1qK-C46wgBjL4FBnSHeVSoKlzmkCG5eQWFU4_k,12376
 tequila/quantumchemistry/psi4_interface.py,sha256=syNaDvlSmCsyB4f7idn3VGbMKyKo83vJHD5y5LpHwaM,29953
-tequila/quantumchemistry/pyscf_interface.py,sha256=CBmMk-K0W-AbWzMslZqoXtFidg0I2HiWCq4yNHEDaoM,6110
-tequila/quantumchemistry/qc_base.py,sha256=ROCOQj5wd2h_YlbLzvtmJ6Ii9WdmQf_05G-Hxq7cv0Y,92894
+tequila/quantumchemistry/pyscf_interface.py,sha256=XgecUnKKg2rGiKqsYCJnDQ89ekkDkKuwc3qHULLMYck,6152
+tequila/quantumchemistry/qc_base.py,sha256=Bmz2lHsbtiJkb07ZZJ5EPAoW0TywQOxZgwagVHT3rEg,96531
 tequila/simulators/__init__.py,sha256=VFw4sJIt4Zc0-__eYnksN8Ku9qMhbPpHJEkXMWUiD30,4
 tequila/simulators/simulator_api.py,sha256=mLYA6GzujaNAGrDq1rtLQrW8tFZsCeyYnOnWRTlU6Eo,24172
 tequila/simulators/simulator_base.py,sha256=93d-f4fNkJ2CtpL9OpgKcypmZH96Mdd9ESdZYn9jH48,33174
@@ -79,8 +78,8 @@ tequila/utils/keymap.py,sha256=RgQzeHEfRVee0-uoH-QsLYsGsXyMhEp3n33KCH-EV2k,3735
 tequila/utils/misc.py,sha256=e62ASkFReaLJQXnBXzyYukzXZnXNoURsM1luoMeIXiE,919
 tequila/wavefunction/__init__.py,sha256=q4DVL0lGFg03PogRMYA6S8MQqqmLYQiU9VNOF-YQxfQ,50
 tequila/wavefunction/qubit_wavefunction.py,sha256=16Y9vRj6Yc6sBAKRUHVXJG4lJLDjWyN1b5fugf2LAmI,11881
-tequila_basic-1.9.3.dist-info/LICENSE,sha256=oG1FtUav5_xrym9ByiG5emJDQRcbnAfTB08fRV9TCiE,1114
-tequila_basic-1.9.3.dist-info/METADATA,sha256=YsBmwDgB65C2lQ7SS1smMY4Jq0M0BtHCXg2gN4b3ET4,19293
-tequila_basic-1.9.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-tequila_basic-1.9.3.dist-info/top_level.txt,sha256=VBH0gl6mDMbcLHKlO0yEAqtcq08DqBHz4gRJ9jafl5w,8
-tequila_basic-1.9.3.dist-info/RECORD,,
+tequila_basic-1.9.5.dist-info/LICENSE,sha256=oG1FtUav5_xrym9ByiG5emJDQRcbnAfTB08fRV9TCiE,1114
+tequila_basic-1.9.5.dist-info/METADATA,sha256=dkAMyh6gVEZDDlmGeJ2NFZVvmXbjE3jpxYYrDY-7XbI,19694
+tequila_basic-1.9.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tequila_basic-1.9.5.dist-info/top_level.txt,sha256=VBH0gl6mDMbcLHKlO0yEAqtcq08DqBHz4gRJ9jafl5w,8
+tequila_basic-1.9.5.dist-info/RECORD,,

{tequila_basic-1.9.3.dist-info → tequila_basic-1.9.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tequila/optimizers/optimizer_phoenics.py

@@ -1,348 +0,0 @@
-from tequila.objective.objective import Objective
-from tequila.optimizers.optimizer_base import Optimizer, OptimizerResults, dataclass
-import typing
-import numbers
-from tequila.objective.objective import Variable
-import copy
-import warnings
-import pickle
-import time
-from tequila import TequilaException
-warnings.simplefilter("ignore")
-with warnings.catch_warnings():
-    warnings.filterwarnings("ignore", category=DeprecationWarning)
-    warnings.filterwarnings("ignore")
-import phoenics
-
-import numpy as np
-from numpy import pi as pi
-from tequila.simulators.simulator_api import compile_objective
-import os
-
-#numpy, tf, etc can get real, real, real, noisy here. We suppress it.
-warnings.filterwarnings('ignore', category=DeprecationWarning)
-os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
-warnings.filterwarnings('ignore', category=FutureWarning)
-
-@dataclass
-class PhoenicsResults(OptimizerResults):
-
-    observations: list = None
-    phoenics_instance: phoenics.Phoenics = None
-
-class OptimizerPhoenics(Optimizer):
-    """
-    wrapper to allow optimization of objectives with Phoenics, a bayesian optimizer.
-    See: https://github.com/aspuru-guzik-group/phoenics
-    """
-    @classmethod
-    def available_methods(cls):
-        return ["phoenics"]
-
-    def __init__(self, maxiter, backend=None, save_history=True, minimize=True,
-                 samples=None, silent=None, noise=None, device=None):
-        self._minimize = minimize
-
-        super().__init__(backend=backend, maxiter=maxiter, samples=samples,
-                         noise=noise,device=device,
-                         save_history=save_history, silent=silent)
-
-    def _process_for_sim(self, recommendation, passive_angles):
-        """
-        convert from the phoenics suggestion format to a version recognizable by objectives.
-        Parameters
-        ----------
-        recommendation: dict:
-            the a phoenics suggestion.
-        passive_angles: dict:
-            passive angles not optimized over.
-
-        Returns
-        -------
-        dict:
-            dict of Bariable, float pairs.
-        """
-        rec = copy.deepcopy(recommendation)
-        for part in rec:
-            for k, v in part.items():
-                part[k] = v.item()
-            if passive_angles is not None:
-                for k, v in passive_angles.items():
-                    part[k] = v
-        return rec
-
-    def _process_for_phoenics(self, pset, result, passive_angles=None):
-        """
-        Convert results of a call to an objective into a form interpretable by phoenics.
-        Parameters
-        ----------
-        pset: dict:
-            the parameters evaluated, as a dictionary
-        result:
-            the result of calling some objective, using pset as parameters.
-        passive_angles: dict, optional:
-            passive_angles, not optimized over.
-
-        Returns
-        -------
-        dict:
-            the a dictionary, formatted as phoenics prefers it, for use as an 'observation'.
-        """
-        new = copy.deepcopy(pset)
-        for k, v in new.items():
-            new[k] = np.array([v], dtype=np.float32)
-        if passive_angles is not None:
-            for k in passive_angles.keys():
-                del new[k]
-        new['Energy'] = result
-
-        return new
-
-    def _make_phoenics_object(self, objective, passive_angles=None, conf=None, *args, **kwargs):
-        """
-        instantiate phoenics, to perform optimization.
-
-        Parameters
-        ----------
-        objective: Objective:
-            the objective to optimize over.
-        passive_angles: dict, optional:
-            a dictionary of angles not to optimize over.
-        conf: optional:
-            a user built configuration object or file, from which to initialize a phoenics object.
-            For advanced users only.
-        args
-        kwargs
-
-        Returns
-        -------
-        phoenics.Phoenics
-            a phoenics object configured to optimize an objective.
-        """
-        if conf is not None:
-            if hasattr(conf, 'readlines'):
-                bird = phoenics.Phoenics(config_file=conf)
-            else:
-                bird = phoenics.Phoenics(config_dict=conf)
-
-            return bird
-        op = objective.extract_variables()
-        if passive_angles is not None:
-            for i, thing in enumerate(op):
-                if thing in passive_angles.keys():
-                    op.remove(thing)
-
-        config = {"general": {"auto_desc_gen": "False", "batches": 5, "boosted": "False", "parallel": "False", "scratch_dir":os.getcwd()}}
-        config['parameters'] = [
-            {'name': k, 'periodic': 'True', 'type': 'continuous', 'size': 1, 'low': 0, 'high': 2 * pi} for k in op]
-        if self._minimize is True:
-            config['objectives'] = [{"name": "Energy", "goal": "minimize"}]
-        else:
-            config['objectives'] = [{"name": "Energy", "goal": "maximize"}]
-
-        for k,v in kwargs.items():
-            if hasattr(k, "lower") and k.lower() in config["general"]:
-                config["general"][k.lower()] = v
-
-        bird = phoenics.Phoenics(config_dict=config)
-        return bird
-
-    def __call__(self, objective: Objective,
-                 maxiter=None,
-                 variables: typing.List[Variable] = None,
-                 initial_values: typing.Dict[Variable, numbers.Real] = None,
-                 previous=None,
-                 phoenics_config=None,
-                 file_name=None,
-                 *args,
-                 **kwargs):
-        """
-        Perform optimization with phoenics.
-
-        Parameters
-        ----------
-        objective: Objective
-            the objective to optimize.
-        maxiter: int:
-            (Default value = None)
-            if not None, overwrite the init maxiter with new number.
-        variables: list:
-            (Default value = None)
-            which variables to optimize over. If None: all of the variables in objective are used.
-        initial_values: dict:
-            (Default value = None)
-            an initial point to begin optimization from. Random, if None.
-        previous:
-            previous observations, formatted for phoenics, to use in optimization. For use by advanced users.
-        phoenics_config:
-            a config for a phoenics object.
-        file_name:
-            a file
-        args
-        kwargs
-
-        Returns
-        -------
-        PhoenicsResults:
-            the results of optimization by phoenics.
-
-        """
-
-        objective = objective.contract()
-        active_angles, passive_angles, variables = self.initialize_variables(objective,
-                                                               initial_values=initial_values,
-                                                               variables=variables)
-
-        if maxiter is None:
-            maxiter = 10
-
-        obs = []
-        bird = self._make_phoenics_object(objective, passive_angles, phoenics_config, *args, **kwargs)
-        if previous is not None:
-            if type(previous) is str:
-                try:
-                    obs = pickle.load(open(previous, 'rb'))
-                except:
-                    print(
-                        'failed to load previous observations, which are meant to be a pickle file. Starting fresh.')
-            elif type(previous) is list:
-                if all([type(k) == dict for k in previous]):
-                    obs = previous
-                else:
-                    print('previous observations were not in the correct format (list of dicts). Starting fresh.')
-
-
-
-        if not (type(file_name) == str or file_name == None):
-            raise TequilaException('file_name must be a string, or None. Recieved {}'.format(type(file_name)))
-
-        best = None
-        best_angles = None
-
-        # avoid multiple compilations
-        compiled_objective = compile_objective(objective=objective, backend=self.backend,
-                                               device=self.device,
-                                               samples=self.samples, noise=self.noise)
-
-        if not self.silent:
-            print('phoenics has recieved')
-            print("objective: \n")
-            print(objective)
-            print("noise model : {}".format(self.noise))
-            print("samples     : {}".format(self.samples))
-            print("maxiter     : {}".format(maxiter))
-            print("variables   : {}".format(objective.extract_variables()))
-            print("passive var : {}".format(passive_angles))
-            print('now lets begin')
-        for i in range(0, maxiter):
-            with warnings.catch_warnings():
-                np.testing.suppress_warnings()
-                warnings.simplefilter("ignore")
-                warnings.filterwarnings("ignore", category=FutureWarning)
-
-            precs = bird.recommend(observations=obs)
-
-            runs = []
-            recs = self._process_for_sim(precs, passive_angles=passive_angles)
-
-            start = time.time()
-            for j, rec in enumerate(recs):
-                En = compiled_objective(variables=rec, samples=self.samples, noise=self.noise)
-                runs.append((rec, En))
-                if not self.silent:
-                    if self.print_level > 2:
-                        print("energy = {:+2.8f} , angles=".format(En), rec)
-                    else:
-                        print("energy = {:+2.8f}".format(En))
-            stop = time.time()
-            if not self.silent:
-                print("Quantum Objective evaluations: {}s Wall-Time".format(stop-start))
-
-            for run in runs:
-                angles = run[0]
-                E = run[1]
-                if best is None:
-                    best = E
-                    best_angles = angles
-                else:
-                    if self._minimize:
-                        if E < best:
-                            best = E
-                            best_angles = angles
-                    else:
-                        if E > best:
-                            best = E
-                            best_angles = angles
-
-                if self.save_history:
-                    self.history.energies.append(E)
-                    self.history.angles.append(angles)
-                obs.append(self._process_for_phoenics(angles, E, passive_angles=passive_angles))
-
-        if file_name is not None:
-            with open(file_name, 'wb') as file:
-                pickle.dump(obs, file)
-
-        if not self.silent:
-            print("best energy after {} iterations : {:+2.8f}".format(self.maxiter, best))
-        return PhoenicsResults(energy=best, variables=best_angles, history=self.history, observations=obs,phoenics_instance=bird)
-
-
-def minimize(objective: Objective,
-             maxiter: int = None,
-             samples: int = None,
-             variables: typing.List = None,
-             initial_values: typing.Dict = None,
-             backend: str = None,
-             noise=None,
-             device: str = None,
-             previous: typing.Union[str, list] = None,
-             phoenics_config: typing.Union[str, typing.Dict] = None,
-             file_name: str = None,
-             silent: bool = False,
-             *args,
-             **kwargs) -> PhoenicsResults:
-    """
-
-    Parameters
-    ----------
-    objective: Objective:
-        The tequila objective to optimize
-    initial_values: typing.Dict[typing.Hashable, numbers.Real], optional:
-        Initial values as dictionary of Hashable types (variable keys) and floating point numbers.
-        If given None they will be randomized.
-    variables: typing.List[typing.Hashable], optional:
-         List of Variables to optimize
-    samples: int, optional:
-         samples/shots to take in every run of the quantum circuits (None activates full wavefunction simulation)
-    maxiter: int:
-         how many iterations of phoenics to run.
-         Note that this is NOT identical to the number of times the circuit will run.
-    backend: str, optional:
-         Simulator backend, will be automatically chosen if set to None
-    noise: NoiseModel, optional:
-         a noise model to apply to the circuits of Objective.
-    device: optional:
-        the device from which to (potentially, simulatedly) sample all quantum circuits employed in optimization.
-    previous: optional:
-        Previous phoenics observations. If string, the name of a file from which to load them. Else, a list.
-    phoenics_config: optional:
-        a pre-made phoenics configuration. if str, the name of a file from which to load it; Else, a dictionary.
-        Individual keywords of the 'general' sections can also be passed down as kwargs
-    file_name: str, optional:
-        where to save output to, if save_to_file is True.
-    kwargs: dict:
-        Send down more keywords for single replacements in the phoenics config 'general' section, like e.g. batches=5,
-        boosted=True etc
-    Returns
-    -------
-    PhoenicsResults:
-        the result of an optimization by phoenics.
-    """
-
-    optimizer = OptimizerPhoenics(samples=samples, backend=backend,
-                                  noise=noise,device=device,
-                                  maxiter=maxiter, silent=silent)
-    return optimizer(objective=objective, initial_values=initial_values, variables=variables, previous=previous,
-                     maxiter=maxiter,
-                     phoenics_config=phoenics_config, file_name=file_name, *args, **kwargs)