qutritium 0.0.1__tar.gz

qutritium-0.0.1/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2023 SON PHAM and TIEN NGUYEN
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

qutritium-0.0.1/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.1
+Name: qutritium
+Version: 0.0.1
+Summary: Qutritium package provides basic calibration and features for qutrit system using Qiskit and other quantum packages
+Home-page: https://github.com/spham1611/qutritium
+Author: Son Pham, Tien Nguyen, Bao Bach
+Author-email: reachphamhson@gmail.com
+License: MIT License
+Project-URL: Bug Tracker, https://github.com/spham1611/qutritium/~/issues
+Project-URL: repository, https://github.com/spham1611/qutritium
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Utilities
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+ 
+
+<div align="center">
+<img src="project_images/csm_ritsch_slider_796236face.jpg" width=150%>
+
+<div style="color: aquamarine" href="https://www.oeaw.ac.at/detail/news/qutrit-complex-quantum-teleportation-achieved-for-the-first-time-1"><b>IMAGE REFERENCE</b></div>
+
+[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=for-the-badge)](https://unitary.fund)
+# Qutritium
+</div>
+
+## What is Qutritium?
+It is a Python package that provides qutrit processing techniques such as calibration and decomposition, etc (not exclusive).
+
+Qutritium enables students researchers to run a qutrit system on available quantum computers which mainly comes from IBM cloud quantum computers.
+
+## 📦 Installation
+
+**Qutritium** runs in python environment. User can download newest python released **[here](https://www.python.org/downloads/)**.\
+Recommendation: **[Anaconda](https://www.anaconda.com/products/distribution)** for environment separation
+
+```bash
+  pip install qutritium
+```
+
+## ✅ Qutritium Available Functions
+
+| Protocol        | Purpose and functionalities |
+|-----------------|-----------------------------|
+| Calibration     | ...                         |
+| Virtual Machine | ...                         |
+ | Decomposition   | ...                         | 
+
+## ✍️ Usage/Examples
+
+```python
+from qutritium.calibration import TR01
+
+```
+
+## 👥 Authors
+
+- **[Son Pham](https://github.com/spham1611)**
+- **[Tien Nguyen](https://github.com/ngdnhtien)**
+- **[Bao Bach](https://github.com/bachbao)**
+
+## 🧾License
+
+[MIT License](LICENSE.txt)
+
+
+## 📌 Documentation
+
+[Documentation](https://spham1611.github.io/qutritium/)
+
+

qutritium-0.0.1/README.md

@@ -0,0 +1,56 @@
+ 
+
+<div align="center">
+<img src="project_images/csm_ritsch_slider_796236face.jpg" width=150%>
+
+<div style="color: aquamarine" href="https://www.oeaw.ac.at/detail/news/qutrit-complex-quantum-teleportation-achieved-for-the-first-time-1"><b>IMAGE REFERENCE</b></div>
+
+[![Unitary Fund](https://img.shields.io/badge/Supported%20By-UNITARY%20FUND-brightgreen.svg?style=for-the-badge)](https://unitary.fund)
+# Qutritium
+</div>
+
+## What is Qutritium?
+It is a Python package that provides qutrit processing techniques such as calibration and decomposition, etc (not exclusive).
+
+Qutritium enables students researchers to run a qutrit system on available quantum computers which mainly comes from IBM cloud quantum computers.
+
+## 📦 Installation
+
+**Qutritium** runs in python environment. User can download newest python released **[here](https://www.python.org/downloads/)**.\
+Recommendation: **[Anaconda](https://www.anaconda.com/products/distribution)** for environment separation
+
+```bash
+  pip install qutritium
+```
+
+## ✅ Qutritium Available Functions
+
+| Protocol        | Purpose and functionalities |
+|-----------------|-----------------------------|
+| Calibration     | ...                         |
+| Virtual Machine | ...                         |
+ | Decomposition   | ...                         | 
+
+## ✍️ Usage/Examples
+
+```python
+from qutritium.calibration import TR01
+
+```
+
+## 👥 Authors
+
+- **[Son Pham](https://github.com/spham1611)**
+- **[Tien Nguyen](https://github.com/ngdnhtien)**
+- **[Bao Bach](https://github.com/bachbao)**
+
+## 🧾License
+
+[MIT License](LICENSE.txt)
+
+
+## 📌 Documentation
+
+[Documentation](https://spham1611.github.io/qutritium/)
+
+

qutritium-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ['setuptools>=61.0']
+build-backend = 'setuptools.build_meta'

qutritium-0.0.1/setup.cfg

@@ -0,0 +1,29 @@
+[metadata]
+name = qutritium
+version = 0.0.1
+author = Son Pham, Tien Nguyen
+description = Qutritium package provides basic calibration and features for qutrit system using Qiskit and other quantum packages
+long_description = file: README.md, LICENSE.txt
+long_description_content_type = text/markdown
+url = https://github.com/spham1611/qutritium
+project_urls = 
+	Bug Tracker = https://github.com/spham1611/qutritium/~/issues
+	repository = https://github.com/spham1611/qutritium
+classifiers = 
+	Programming Language :: Python :: 3
+	License :: OSI Approved :: MIT License
+	Operating System :: OS Independent
+
+[options]
+package_dir = 
+	= src
+packages = find:
+python_requires = >=3.6
+
+[options.packages.find]
+where = src
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

qutritium-0.0.1/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="qutritium",
+    version="0.0.1",
+    author="Son Pham, Tien Nguyen, Bao Bach",
+    author_email="reachphamhson@gmail.com",
+    description="Qutritium package provides basic calibration and features for qutrit system using Qiskit and other "
+                "quantum packages",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    license='MIT License',
+    url="https://github.com/spham1611/qutritium",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Utilities",
+    ],
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    python_requires=">=3.6"
+)
+

qutritium-0.0.1/src/backend/backend_ibm.py

@@ -0,0 +1,131 @@
+# MIT License
+#
+# Copyright (c) [2023] [son pham, tien nguyen, bach bao]
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""List all the available backends and assign their empirically effective qubit"""
+from qiskit_ibm_provider import IBMProvider, IBMBackend
+
+from src.constant import  QubitParameters
+
+from typing import DefaultDict, Tuple, Optional
+
+from collections import defaultdict
+
+
+def set_qubit_dict() -> DefaultDict:
+    """ Set initiated qubit for each ibm quantum computers
+    Returns:
+        Dictionary that has the following format
+        ===============  ===============
+        IBMBackend Name  Effective Qubit
+        'ibm_brisbane'    0
+        ===============  ===============
+    """
+    return defaultdict(lambda: 0)
+
+
+class CustomProvider(IBMProvider):
+    """ Customize IBMProvider
+    An example of this flow::
+
+        from qutritium.backend.backend_ibm import EffProvider
+
+        eff_provider = EffProvider()
+        backend, _ = eff_provider.backend('ibmq_lima')
+
+        eff_provider.show()
+
+    Notes:
+        * This class inherits IBMProvider so the docs is analogous to IBMProvider.
+
+    Here is a list of available attributes in class "EffProvider" class, besides IBMProvider attrs:
+        * eff_dict: a dictionary that contains effective qubit number of respective quantum computer
+        * backend(): return the wanted backend and its parameters
+        * show(): print all available backends
+    """
+
+    def __init__(
+            self,
+            token: Optional[str] = None,
+            url: Optional[str] = None,
+            name: Optional[str] = None,
+            instance: Optional[str] = None,
+            proxies: Optional[dict] = None,
+            verify: Optional[bool] = None,
+            custom_dict: Optional[DefaultDict] = None,
+    ) -> None:
+        """ Refer to the IBMProvider doc
+        Args:
+            token:
+            url:
+            name:
+            instance:
+            proxies:
+            verify:
+            custom_dict: Dictionary contains name of the backend and their effective qubits. For example:
+                        dict_eff = {'ibmq_lima': 2,
+                                    'ibm_nairobi': 6,}
+
+        Returns:
+            An instance of EffBackends
+        """
+        super().__init__(token, url, name, instance, proxies, verify)
+        if not self.active_account():
+            raise ValueError('Can not find account saved on disk. Please provide token via constructor'
+                             ', or save_account() function')
+        self.custom_dict: DefaultDict[str, int] = custom_dict if custom_dict else set_qubit_dict()
+
+    def retrieve_backend_info(self, name: str) -> Tuple[IBMBackend, DefaultDict]:
+        """
+
+        Args:
+            name: name of the quantum computer which appears on API
+
+        Returns:
+            Tuple: IBMBackend and its parameters
+
+        """
+        backend = self.backends(name=name)[0]
+        default_freq = backend.defaults().qubit_freq_est[self.custom_dict[name]]
+        anharmonicity = backend.properties().qubits[self.custom_dict[name]][3].value * QubitParameters.GHZ.value
+        backend_params = defaultdict(lambda: 0,
+                                     {'effective_qubit': self.custom_dict[name],
+                                      'drive_frequency': default_freq,
+                                      'anharmonicity': anharmonicity})
+        # from src.simple_backend_log import write_log
+        #
+        # write_log(backend)
+        return backend, backend_params
+
+    def show(self) -> None:
+        """
+        Show all available backends based on given provider
+        """
+        print(f"{'Backend name:':<30}{'# Qubit used:':<40}")
+        for available_backend in self.backends():
+            name = available_backend.name
+            print(f"{name:<30}{self.custom_dict[name]:<40}")
+
+    def qubit_optimization(self):
+        ...
+
+    def customize_qubit(self):
+        ...

qutritium-0.0.1/src/calibration/__init__.py

@@ -0,0 +1,22 @@
+# MIT License
+#
+# Copyright (c) [2023] [son pham, tien nguyen, bach bao]
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+

qutritium-0.0.1/src/calibration/discriminator.py

@@ -0,0 +1,178 @@
+# MIT License
+#
+# Copyright (c) [2023] [son pham, tien nguyen, bach bao]
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+""" Discriminator circuit and iq plot function """
+from qiskit.circuit import Gate
+
+from src.pulse import Pulse12
+from src.pulse_creation import GateSchedule
+from src.backend.backend_ibm import CustomProvider
+from src.calibration.utility import _SetAttribute
+from src.constant import QubitParameters
+
+from typing import List
+
+
+ghz_unit = QubitParameters.GHZ.value
+
+
+class DiscriminatorQutrit(_SetAttribute):
+    """ A Simple Discriminator class that set up circuit and plot the iq graph
+    An example of using this class::
+
+        from qutritium.calibration.discriminator import Discriminator
+        from qutritium.backend.backend_ibm import EffProvider
+        from qutritium.pulse import Pulse01, Pulse12
+
+        efF_provider = EffProvider()
+        pulse01 = Pulse01(duration=144, x_amp=0.2)
+        pulse12 = Pulse12(pulse01=pulse01, duration=pulse01.duration, x_amp=pulse01.x_amp)
+
+        ...Running Rough Rabi
+
+        discriminator = Discriminator(eff_provider, pulse12, num_shots=4096)
+        discriminator.prepare_circuit()
+        discriminator.run_monitor()
+        discriminator.plot_iq()
+
+    Here is a list of available attributes of "DiscriminatorQutrit" class:
+        * prepare_circuit(): prepares a discriminator with different QuantumCircuits
+        * run_monitor(): run custom execute
+        * plot_iq(): plot iq 012 graph
+
+    To see more details, visit:
+    ...
+    """
+    def __init__(self,
+                 custom_provider: CustomProvider,
+                 pulse_model: Pulse12,
+                 backend_name: str = 'ibm_brisbane',
+                 num_shots=4096,
+                 delay_time: int = 22496) -> None:
+        """ ctor
+
+        Args:
+            custom_provider: EffProvider instance which contains necessary information
+            pulse_model: Pulse12 model only
+            backend_name: name to choose which backend running on IBM server
+            num_shots: number of experiments
+            delay_time: sending a time delay pulse
+
+        Notes:
+            * model_space parameter is not necessary as we are discriminating states not processing
+        """
+        super().__init__(custom_provider=custom_provider,
+                         pulse_model=pulse_model,
+                         backend_name=backend_name,
+                         num_shots=num_shots,
+                         model_space='01')
+        self.ramsey_frequency01 = self.pulse_model.pulse01.frequency
+        self.ramsey_frequency12 = self.pulse_model.frequency
+        self._delay_gate = Gate('5mus_delay', 1, [])
+        self._x12 = Gate('X12', 1, [])
+
+        # Schedules
+        self._delay_schedule = GateSchedule.delay(backend=self.backend,
+                                                  qubit=self.qubit,
+                                                  delay_time=delay_time)
+
+        self._x12_schedule = GateSchedule.x_amp_gaussian(backend=self.backend,
+                                                         qubit=self.qubit,
+                                                         pulse_model=self.pulse_model,
+                                                         x_amp=self.pulse_model.x_amp)
+
+        # Package
+        self.package: List = []
+
+    def prepare_circuit(self) -> None:
+        """
+        Creating a circuit that can represent a single qutrit state in IBM superconducting quantum computer.
+        This helps us to visualize qutrit state with calibrated parameters.
+        """
+        from qiskit import QuantumCircuit
+
+        ground_state_prep = QuantumCircuit(self.qubit + 1, self.cbit + 1)
+        ground_state_prep.append(self._delay_gate, [self.qubit])
+        ground_state_prep.add_calibration(self._delay_gate, [self.qubit], self._delay_schedule)
+        # noinspection DuplicatedCode
+        ground_state_prep.measure(self.qubit, self.cbit)
+
+        first_excited_state_prep = QuantumCircuit(self.qubit + 1, self.cbit + 1)
+        first_excited_state_prep.append(self._delay_gate, [self.qubit])
+        first_excited_state_prep.add_calibration(self._delay_gate, [self.qubit], self._delay_schedule)
+        first_excited_state_prep.x(self.qubit)
+        # noinspection DuplicatedCode
+        first_excited_state_prep.measure(self.qubit, self.cbit)
+
+        second_excited_state_prep = QuantumCircuit(self.qubit + 1, self.cbit + 1)
+        second_excited_state_prep.append(self._delay_gate, [self.qubit])
+        second_excited_state_prep.add_calibration(self._delay_gate, [self.qubit], self._delay_schedule)
+        second_excited_state_prep.x(self.qubit)
+        second_excited_state_prep.append(self._x12, [self.qubit])
+        second_excited_state_prep.add_calibration(self._x12, [self.qubit], self._x12_schedule)
+        second_excited_state_prep.measure(self.qubit, self.cbit)
+
+        self.package = [ground_state_prep, first_excited_state_prep, second_excited_state_prep]
+
+    # noinspection DuplicatedCode
+    def run_monitor(self,
+                    num_shots: int = 4096,
+                    meas_return='single',
+                    meas_level=1,
+                    **kwargs) -> None:
+        """
+        Run via run_monitor in abstract class
+        Args:
+            num_shots:
+            meas_return:
+            meas_level:
+            **kwargs:
+
+        Returns:
+
+        """
+        super().backend.run(num_shots=num_shots,
+                            meas_return=meas_return,
+                            meas_level=meas_level,
+                            **kwargs)
+
+    def plot_iq(self,
+                x_min: int = -30,
+                x_max: int = 30,
+                y_min: int = -30,
+                y_max: int = 30) -> None:
+        """ Plot iq qutrit state
+
+        Args:
+            x_min: Min x-value of the plot
+            x_max: Max x-value of the plot
+            y_min: Min y-value of the plot
+            y_max: Max y-value of the plot
+        """
+        import matplotlib.pyplot as plt
+        from src.analyzer import DataAnalysis
+
+        discriminator_job = self.backend.retrieve_job(self.submitted_job)
+        discriminator_data = DataAnalysis(discriminator_job)
+        discriminator_data.retrieve_data(True)
+        discriminator_data.iq_012_plot(x_min, x_max, y_min, y_max)
+        plt.savefig('output/0 1 2 Discrimination.svg', format='svg', dpi=1200)