tequila-basic 1.9.0__tar.gz → 1.9.1__tar.gz

{tequila-basic-1.9.0/src/tequila_basic.egg-info → tequila-basic-1.9.1}/PKG-INFO

@@ -1,12 +1,20 @@
 Metadata-Version: 2.1
 Name: tequila-basic
-Version: 1.9.0
+Version: 1.9.1
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
 Author: Tequila Developers 
 Author-email: jakob.kottmann@gmail.com
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy<1.11
+Requires-Dist: sympy
+Requires-Dist: autograd
+Requires-Dist: setuptools
+Requires-Dist: pytest
+Requires-Dist: openfermion~=1.0
+Requires-Dist: dataclasses; python_version < "3.7"
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-lightgrey.svg)](LICENCE) [![DOI](https://zenodo.org/badge/259718912.svg)](https://zenodo.org/badge/latestdoi/259718912) [![PyPI version](https://badge.fury.io/py/tequila-basic.svg)](https://badge.fury.io/py/tequila-basic) ![CI](https://github.com/tequilahub/tequila/actions/workflows/ci_basic.yml/badge.svg)
 

{tequila-basic-1.9.0 → tequila-basic-1.9.1}/src/tequila/circuit/gates.py

@@ -1081,10 +1081,14 @@ class QubitExcitationImpl(impl.GeneralizedRotationImpl):
     def compile(self, exponential_pauli=False, *args, **kwargs):
         # optimized compiling for single and double qubit excitaitons following arxiv:2005.14475
         # Alternative representation in arxiv:2104.05695 (not implemented -> could be added and controlled with optional compile keywords)
+        if self.is_controlled():
+            control = list(self.control)
+        else:
+            control = []
         if self.compile_options == "optimize" and len(self.target) == 2 and exponential_pauli:
             p,q = self.target
             U0 = X(target=p, control=q)
-            U1 = Ry(angle=self.parameter, target=q, control=p)
+            U1 = Ry(angle=self.parameter, target=q, control=[p]+control)
             return U0 + U1 + U0
         elif self.compile_options == "optimize" and len(self.target) == 4 and exponential_pauli:
             p,r,q,s = self.target
@@ -1093,10 +1097,11 @@ class QubitExcitationImpl(impl.GeneralizedRotationImpl):
             U0 += X(target=r, control=p)
             U0 += X(target=q)
             U0 += X(target=s)
-            U1 = Ry(angle=-self.parameter, target=p, control=[q,r,s])
+            U1 = Ry(angle=-self.parameter, target=p, control=[q,r,s]+control)
             return U0 + U1 + U0.dagger()
         else:
-            return Trotterized(angle=self.parameter, generator=self.generator, steps=1)
+            return Trotterized(angle=self.parameter, generator=self.generator, steps=1, control=self.control)
+
 
 def _convert_Paulistring(paulistring: typing.Union[PauliString, str, dict]) -> PauliString:
     '''

{tequila-basic-1.9.0 → tequila-basic-1.9.1}/src/tequila/optimizers/optimizer_gd.py

@@ -334,11 +334,12 @@ class OptimizerGD(Optimizer):
 
 
             if not self.silent:
+                self.__dx = numpy.asarray(self.__dx)
                 print("%3i   %+15.8f   %+7.2e   %7.3e   %7.3e    %s"
                       % (step,
                          e,
                          e-last,
-                         numpy.max(abs(self.__dx)),
+                         numpy.max([abs(x) for x in self.__dx]),
                          numpy.sqrt(numpy.average(self.__dx**2)),
                          comment))
 

{tequila-basic-1.9.0 → tequila-basic-1.9.1}/src/tequila/quantumchemistry/pyscf_interface.py

@@ -46,7 +46,15 @@ class QuantumChemistryPySCF(QuantumChemistryBase):
             # solve restricted HF
             mf = pyscf.scf.RHF(mol)
             mf.kernel()
-            self.irreps = mf.get_irrep_nelec()
+
+            # only works if point_group is not C1
+            # otherwise PySCF uses a different SCF object
+            # irrep information is however not critical to tequila
+            if hasattr(mf, "get_irrep_nelec"):
+                self.irreps = mf.get_irrep_nelec()
+            else:
+                self.irreps = None
+                
             orbital_energies = mf.mo_energy
 
             # compute mo integrals

{tequila-basic-1.9.0 → tequila-basic-1.9.1}/src/tequila/version.py

@@ -1,2 +1,2 @@
-__version__ = "1.9.0"
+__version__ = "1.9.1"
 __author__ = "Tequila Developers "

{tequila-basic-1.9.0 → tequila-basic-1.9.1/src/tequila_basic.egg-info}/PKG-INFO

@@ -1,12 +1,20 @@
 Metadata-Version: 2.1
 Name: tequila-basic
-Version: 1.9.0
+Version: 1.9.1
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
 Author: Tequila Developers 
 Author-email: jakob.kottmann@gmail.com
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy<1.11
+Requires-Dist: sympy
+Requires-Dist: autograd
+Requires-Dist: setuptools
+Requires-Dist: pytest
+Requires-Dist: openfermion~=1.0
+Requires-Dist: dataclasses; python_version < "3.7"
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-lightgrey.svg)](LICENCE) [![DOI](https://zenodo.org/badge/259718912.svg)](https://zenodo.org/badge/latestdoi/259718912) [![PyPI version](https://badge.fury.io/py/tequila-basic.svg)](https://badge.fury.io/py/tequila-basic) ![CI](https://github.com/tequilahub/tequila/actions/workflows/ci_basic.yml/badge.svg)
 

{tequila-basic-1.9.0 → tequila-basic-1.9.1}/src/tequila_basic.egg-info/SOURCES.txt

@@ -88,4 +88,37 @@ src/tequila_basic.egg-info/PKG-INFO
 src/tequila_basic.egg-info/SOURCES.txt
 src/tequila_basic.egg-info/dependency_links.txt
 src/tequila_basic.egg-info/requires.txt
-src/tequila_basic.egg-info/top_level.txt
+src/tequila_basic.egg-info/top_level.txt
+tests/test_TrotErr.py
+tests/test_adapt.py
+tests/test_array.py
+tests/test_binary_pauli.py
+tests/test_binary_utils.py
+tests/test_bitstrings.py
+tests/test_braket.py
+tests/test_chemistry.py
+tests/test_chemistry_f12.py
+tests/test_chemistry_madness.py
+tests/test_circuits.py
+tests/test_fermionic_meas.py
+tests/test_gd_optimizer.py
+tests/test_gpyopt.py
+tests/test_gradient.py
+tests/test_hamiltonian_arithmetic.py
+tests/test_krylov.py
+tests/test_mappings.py
+tests/test_noise.py
+tests/test_noise_opt.py
+tests/test_objectives.py
+tests/test_phoenics.py
+tests/test_pyzx.py
+tests/test_qasm.py
+tests/test_qtensor.py
+tests/test_recompilation_routines.py
+tests/test_scipy.py
+tests/test_simulator_backends.py
+tests/test_symbolic_simulator.py
+tests/test_torch_interface.py
+tests/test_unary_state_prep.py
+tests/test_variable.py
+tests/test_zzz_cleanup.py

tequila-basic-1.9.1/tests/test_TrotErr.py

@@ -0,0 +1,118 @@
+from tequila.trotter_err.main_trot import EstTrotErr
+import numpy as np
+import tequila as tq
+from tequila.hamiltonian import QubitHamiltonian, PauliString
+from tequila.grouping.binary_rep import BinaryPauliString, BinaryHamiltonian
+from tequila.grouping.fermionic_methods import do_svd
+from tequila.grouping.fermionic_functions import obt_to_ferm, convert_tbts_to_frags
+from tequila.grouping.fermionic_functions import n_elec
+import openfermion
+import pytest
+
+HAS_PYSCF = "pyscf" in tq.quantumchemistry.INSTALLED_QCHEMISTRY_BACKENDS
+
+def build_toymol():
+    '''
+    Build the qubit Hamiltonian with Jordan Wigner encoding for H2 at a particular geometry.
+    '''
+
+    trafo = "JordanWigner"
+    mol = tq.chemistry.Molecule(
+                            geometry="H 0.0 0.0 0.0 \n H 0.0 0.0 1.0",
+                            basis_set="sto3g",
+                            transformation=trafo,
+                            backend='pyscf'
+                                 )
+    H = mol.make_hamiltonian()
+
+    Hferm = mol.make_molecular_hamiltonian()
+
+    return H,openfermion.get_fermion_operator(Hferm)
+
+def get_fclf(H):
+    '''
+    Get the Hamiltonian fragments under the qubit FC-LF partition method, as explained in JCTC 16, 2400 (2020))
+    '''
+
+    Hbin = BinaryHamiltonian.init_from_qubit_hamiltonian(H)
+    options={"method":"lf", "condition": "fc"}
+
+    commuting_parts, _ = Hbin.commuting_groups(options=options)
+    print("Number of FC-LF groups: {}".format(len(commuting_parts)))
+
+    ListFrags=[]
+
+    for i in range(len(commuting_parts)):
+        tqqubFrag=commuting_parts[i].to_qubit_hamiltonian()
+        ListFrags.append(tqqubFrag.to_openfermion())
+
+    return ListFrags
+
+def get_fcsi(H):
+    '''
+    Get the Hamiltonian fragments under the qubit FC-SI partition method, as explained in JCTC 16, 2400 (2020))
+    '''
+
+    Hbin = BinaryHamiltonian.init_from_qubit_hamiltonian(H)
+    options={"method":"si", "condition": "fc"}
+
+    commuting_parts, _ = Hbin.commuting_groups(options=options)
+    print("Number of FC-SI groups: {}".format(len(commuting_parts)))
+
+    ListFrags=[]
+
+    for i in range(len(commuting_parts)):
+        tqqubFrag=commuting_parts[i].to_qubit_hamiltonian()
+        ListFrags.append(tqqubFrag.to_openfermion())
+
+    return ListFrags
+
+#set opf routines to get LR fragments...
+def cartan_to_fermionic_operator(cobt, ctbts, orb_rot):
+    '''
+    Turn Hamiltonian fragments in their diagonal form into OpenFermion's FermionOperator.
+    '''
+    obt = np.einsum("pa, qb, ab", orb_rot[0], orb_rot[0], cobt)
+    tbts = np.einsum("ipa, iqb, irc, isd, iabcd -> ipqrs",
+                     orb_rot[1:], orb_rot[1:], orb_rot[1:], orb_rot[1:], ctbts)
+    ferm_ops = [obt_to_ferm(obt,True)] + convert_tbts_to_frags(tbts, True)
+    return ferm_ops
+
+def get_LR(Hferm,name="h2"):
+    '''
+    Get Low-Rank Hamiltonian fragments, according to the technique outlined in npj Quantum Information 7, 83 (2021)
+    '''
+
+    orb_rots, cartan_obt, cartan_tbts, meas_alloc = do_svd(Hferm, n_elec(name))
+
+    ferm_ops = cartan_to_fermionic_operator(cartan_obt, cartan_tbts, orb_rots)
+
+    return ferm_ops
+
+#####Testing functions.....
+@pytest.mark.skipif(condition=not HAS_PYSCF, reason="you don't have pyscf")
+def test_FCLF():
+    Hq,Hferm=build_toymol()
+    FCLFFrags=get_fclf(Hq)
+    nqubs=openfermion.count_qubits(Hferm)
+    alpha=EstTrotErr(FCLFFrags,nqubs)
+
+    assert np.isclose(alpha, 0.42117695296, atol=1.e-4)
+
+@pytest.mark.skipif(condition=not HAS_PYSCF, reason="you don't have pyscf")
+def test_FCSI():
+    Hq,Hferm=build_toymol()
+    FCSIFrags=get_fcsi(Hq)
+    nqubs=openfermion.count_qubits(Hferm)
+    alpha=EstTrotErr(FCSIFrags,nqubs)
+
+    assert np.isclose(alpha, 0.42117695296, atol=1.e-4)
+
+@pytest.mark.skipif(condition=not HAS_PYSCF, reason="you don't have pyscf")
+def test_LR():
+    Hq,Hferm=build_toymol()
+    LRFrags=get_LR(Hferm)
+    nqubs=openfermion.count_qubits(Hferm)
+    alpha=EstTrotErr(LRFrags,nqubs)
+
+    assert np.isclose(alpha, 0.42178077369, atol=1.e-4)

tequila-basic-1.9.1/tests/test_adapt.py

@@ -0,0 +1,72 @@
+import tequila as tq
+import numpy
+
+
+def test_simple_example():
+    H = tq.paulis.X(0)
+    Upre = tq.gates.X(0)
+    Upost = tq.gates.Y(0)
+    generators = [tq.paulis.Y(0), tq.paulis.Z(0), tq.paulis.X(0)]
+    operator_pool = tq.adapt.AdaptPoolBase(generators=generators)
+    solver = tq.adapt.Adapt(H=H, operator_pool=operator_pool, Upre=Upre, UPost=Upost)
+    result = solver()
+    assert numpy.isclose(result.energy, -1.0, atol=1.e-4)
+
+
+def make_test_molecule():
+    one = numpy.array([[-1.94102524, -0.31651552],
+                       [-0.31651552, -0.0887454]])
+    two = numpy.array([[[[1.02689005, 0.31648659],
+                         [0.31648659, 0.22767214]],
+
+                        [[0.31648659, 0.22767214],
+                         [0.85813498, 0.25556095]]],
+
+                       [[[0.31648659, 0.85813498],
+                         [0.22767214, 0.25556095]],
+
+                        [[0.22767214, 0.25556095],
+                         [0.25556095, 0.76637672]]]])
+
+    return tq.Molecule(geometry="He 0.0 0.0 0.0", backend="base", one_body_integrals=one, two_body_integrals=two)
+
+
+def test_molecular_example():
+    mol = make_test_molecule()
+    Upost = mol.make_excitation_gate(angle="a", indices=[(0, 2)])
+    Upost += mol.make_excitation_gate(angle="a", indices=[(1, 3)])
+    operator_pool = tq.adapt.MolecularPool(molecule=mol, indices="UpCCSD")
+    solver = tq.adapt.Adapt(H=mol.make_hamiltonian(), Upre=mol.prepare_reference(),Upost=Upost, operator_pool=operator_pool)
+    result = solver(operator_pool=operator_pool, label=0)
+    energy = numpy.linalg.eigvalsh(mol.make_hamiltonian().to_matrix())[0]
+    assert numpy.isclose(result.energy, energy, atol=1.e-4)
+
+def test_molecular_excited_example():
+    mol = make_test_molecule()
+
+    H = mol.make_hamiltonian()
+    eigenvalues, eigenvectors = numpy.linalg.eigh(H.to_matrix())
+    n_qubits = H.n_qubits
+    reference_basis_state = 2 ** (n_qubits - 1) + 2 ** (n_qubits - 2)
+    energies = []
+    for i in range(len(eigenvalues)):
+        if not numpy.isclose(eigenvectors[:, i][reference_basis_state], 0.0, atol=1.e-4):
+            energies.append(eigenvalues[i])
+
+    operator_pool = tq.adapt.MolecularPool(molecule=mol, indices="UpCCSD")
+
+    circuits = []
+    variables = {}
+    for state in range(3):
+        Upre = mol.prepare_reference()
+        objective_factory = tq.adapt.ObjectiveFactorySequentialExcitedState(Upre=mol.prepare_reference(),
+                                                                            H=mol.make_hamiltonian(), circuits=circuits,
+                                                                            factors=[100.0] * len(circuits))
+        solver = tq.adapt.Adapt(objective_factory=objective_factory,
+                                Upre=mol.prepare_reference(),
+                                operator_pool=operator_pool)
+        result = solver(operator_pool=operator_pool, label=state, static_variables=variables)
+        U = Upre + result.U
+        circuits.append(U)
+        variables = {**variables, **result.variables}
+        assert numpy.isclose(result.energy, energies[state], atol=1.e-4)

tequila-basic-1.9.1/tests/test_array.py

@@ -0,0 +1,39 @@
+import tequila as tq
+import pytest, numpy
+
+# Backends
+import select_backends
+backends = select_backends.get()
+
+
+@pytest.mark.parametrize("backend", backends)
+def test_array_computation(backend):
+    U = tq.gates.X(target=0)
+    hamiltonians = [tq.paulis.I(), tq.paulis.X(0), tq.paulis.Y(0), tq.paulis.Z(0)]
+    E = tq.ExpectationValue(H=hamiltonians, U=U, shape=[4])
+    result = tq.simulate(E, backend=backend)
+    assert all(result == numpy.asarray([1.0, 0.0, 0.0, -1.0]))
+
+@pytest.mark.parametrize("backend", backends)
+@pytest.mark.parametrize("shape", [(4,),(2,2)])
+def test_array_shape(backend, shape):
+    expected = numpy.asarray([1.0, 0.0, 0.0, -1.0]).reshape(shape)
+    U = tq.gates.X(target=0)
+    hamiltonians = [tq.paulis.I(), tq.paulis.X(0), tq.paulis.Y(0), tq.paulis.Z(0)]
+    E = tq.ExpectationValue(H=hamiltonians, U=U, shape=shape)
+    result = tq.simulate(E, backend=backend)
+    assert (result == expected).all()
+
+@pytest.mark.parametrize("backend", backends)
+@pytest.mark.parametrize("shape", [(2,2)])
+def test_array_contraction(backend, shape):
+    def contraction(array):
+        bra = numpy.asarray([1.0, 1.0, 1.0, -1.0]).reshape(shape)
+        return numpy.trace(bra.dot(array))
+
+    expected = numpy.asarray([1.0, 0.0, 0.0, -1.0]).reshape(shape)
+    U = tq.gates.X(target=0)
+    hamiltonians = [tq.paulis.I(), tq.paulis.X(0), tq.paulis.Y(0), tq.paulis.Z(0)]
+    E = tq.ExpectationValue(H=hamiltonians, U=U, shape=shape, contraction=contraction)
+    result = tq.simulate(E, backend=backend)
+    assert result == contraction(expected)