eoqrid 0.1.4__tar.gz

eoqrid-0.1.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sam.N
+
+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.

eoqrid-0.1.4/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

eoqrid-0.1.4/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: eoqrid
+Version: 0.1.4
+Summary: Exchange-Only Quantum Computation Simulator
+Author: Sam.N
+License: MIT License
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: networkx>=3.6.1
+Requires-Dist: matplotlib>=3.10.9
+Requires-Dist: pylatexenc>=2.10
+Requires-Dist: qiskit>=2.4.1
+Requires-Dist: qiskit-aer>=0.17.2
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+eoqrid
+======
+
+Exchange-Only Quantum Computing Simulator
+
+## Feature
+
+eoqrid is a Python library designed to simulate silicon quantum computers that control qubits using the Exchange-Only method. Itprovides the following two main features:
+
+* **Logical Quantum Circuit Transpilation**
+  - It can translate logically described quantum circuits into sets of exchange interactions and measurements so they can be executed on silicon qubits. Furthermore, it allows for the transformation and optimization of circuits to match the specific topology of a quantum chip.
+
+* **Physical Quantum Circuit Execution**
+  - It can simulate and verify the result from executing physical quantum circuits described by sets of exchange interactions and measurements.
+
+## Install
+
+```bash
+pip install eoqrid
+```
+or
+
+```bash
+git clone https://github.com/samn33/eoqrid.git
+cd eoqrid
+pip install .
+```
+
+## Uninstall
+
+```bash
+pip uninstall eoqrid
+```
+
+## Usage
+
+```pthon
+$ cat sample.py
+from qiskit import QuantumCircuit
+from eoqrid import EoqSimulator
+
+qc = QuantumCircuit(1)
+qc.h(0)
+
+print("== quantum circuit ==")
+print(qc)
+
+eoq = EoqSimulator()
+qc_native = eoq.transpile(qc)
+
+print("== transpiled quantum circuit ==")
+print(qc_native)
+print(f"depth = {qc_native.depth()}")
+
+res = eoq.execute(qc_native)
+
+print("== quantum state (logical) ==")
+res.qstate.draw()
+
+print("== quantum state (physical) ==")
+res.qstate.draw(mode='physical')
+```
+
+```
+$ python sample.py
+== quantum circuit ==
+   ┌───┐
+q: ┤ H ├
+   └───┘
+== transpiled quantum circuit ==
+         ┌───────────────┐                 ┌───────────────┐
+q_0 -> 0 ┤0              ├─────────────────┤0              ├
+         │  Ex(5.3279,1) │┌───────────────┐│  Ex(5.3279,1) │
+q_1 -> 1 ┤1              ├┤0              ├┤1              ├
+         └───────────────┘│  Ex(1.9106,1) │└───────────────┘
+q_2 -> 2 ─────────────────┤1              ├─────────────────
+                          └───────────────┘
+depth = 3
+== quantum state (logical) ==
+c[0] = +0.7071+0.0000*i : 0.5000 |++++++
+c[1] = +0.7071-0.0000*i : 0.5000 |++++++
+== quantum state (physical) ==
+c[000] = +0.0000+0.0000*i : 0.0000 |
+c[001] = +0.5774-0.0000*i : 0.3333 |++++
+c[010] = +0.2113-0.0000*i : 0.0447 |+
+c[011] = +0.0000+0.0000*i : 0.0000 |
+c[100] = -0.7887-0.0000*i : 0.6220 |+++++++
+c[101] = +0.0000+0.0000*i : 0.0000 |
+c[110] = +0.0000+0.0000*i : 0.0000 |
+c[111] = -0.0000-0.0000*i : 0.0000 |
+```															 
+
+## Documents
+
+- [Tutorial(japanese)](docs/tutorial_jp.md)
+
+## References
+
+1. [Aaron J. Weinstein, et al., "Universal logic with encoded spin qubits in silicon",arXiv:2202.03605](https://arxiv.org/abs/2202.03605)
+
+2. [Exchange Only 量子ビットの仕組み：3つのスピンで「磁場」を超える(YuichiroMinato)](https://zenn.dev/yuichirominato/articles/96b88617c4bffa)
+
+## Requirements
+
+- Linux (Ubuntu 24.04 LTS)
+- Python 3.12
+
+## Licence
+
+MIT
+
+## Author
+
+[Sam.N](http://github.com/samn33)

eoqrid-0.1.4/README.md

@@ -0,0 +1,114 @@
+eoqrid
+======
+
+Exchange-Only Quantum Computing Simulator
+
+## Feature
+
+eoqrid is a Python library designed to simulate silicon quantum computers that control qubits using the Exchange-Only method. Itprovides the following two main features:
+
+* **Logical Quantum Circuit Transpilation**
+  - It can translate logically described quantum circuits into sets of exchange interactions and measurements so they can be executed on silicon qubits. Furthermore, it allows for the transformation and optimization of circuits to match the specific topology of a quantum chip.
+
+* **Physical Quantum Circuit Execution**
+  - It can simulate and verify the result from executing physical quantum circuits described by sets of exchange interactions and measurements.
+
+## Install
+
+```bash
+pip install eoqrid
+```
+or
+
+```bash
+git clone https://github.com/samn33/eoqrid.git
+cd eoqrid
+pip install .
+```
+
+## Uninstall
+
+```bash
+pip uninstall eoqrid
+```
+
+## Usage
+
+```pthon
+$ cat sample.py
+from qiskit import QuantumCircuit
+from eoqrid import EoqSimulator
+
+qc = QuantumCircuit(1)
+qc.h(0)
+
+print("== quantum circuit ==")
+print(qc)
+
+eoq = EoqSimulator()
+qc_native = eoq.transpile(qc)
+
+print("== transpiled quantum circuit ==")
+print(qc_native)
+print(f"depth = {qc_native.depth()}")
+
+res = eoq.execute(qc_native)
+
+print("== quantum state (logical) ==")
+res.qstate.draw()
+
+print("== quantum state (physical) ==")
+res.qstate.draw(mode='physical')
+```
+
+```
+$ python sample.py
+== quantum circuit ==
+   ┌───┐
+q: ┤ H ├
+   └───┘
+== transpiled quantum circuit ==
+         ┌───────────────┐                 ┌───────────────┐
+q_0 -> 0 ┤0              ├─────────────────┤0              ├
+         │  Ex(5.3279,1) │┌───────────────┐│  Ex(5.3279,1) │
+q_1 -> 1 ┤1              ├┤0              ├┤1              ├
+         └───────────────┘│  Ex(1.9106,1) │└───────────────┘
+q_2 -> 2 ─────────────────┤1              ├─────────────────
+                          └───────────────┘
+depth = 3
+== quantum state (logical) ==
+c[0] = +0.7071+0.0000*i : 0.5000 |++++++
+c[1] = +0.7071-0.0000*i : 0.5000 |++++++
+== quantum state (physical) ==
+c[000] = +0.0000+0.0000*i : 0.0000 |
+c[001] = +0.5774-0.0000*i : 0.3333 |++++
+c[010] = +0.2113-0.0000*i : 0.0447 |+
+c[011] = +0.0000+0.0000*i : 0.0000 |
+c[100] = -0.7887-0.0000*i : 0.6220 |+++++++
+c[101] = +0.0000+0.0000*i : 0.0000 |
+c[110] = +0.0000+0.0000*i : 0.0000 |
+c[111] = -0.0000-0.0000*i : 0.0000 |
+```															 
+
+## Documents
+
+- [Tutorial(japanese)](docs/tutorial_jp.md)
+
+## References
+
+1. [Aaron J. Weinstein, et al., "Universal logic with encoded spin qubits in silicon",arXiv:2202.03605](https://arxiv.org/abs/2202.03605)
+
+2. [Exchange Only 量子ビットの仕組み：3つのスピンで「磁場」を超える(YuichiroMinato)](https://zenn.dev/yuichirominato/articles/96b88617c4bffa)
+
+## Requirements
+
+- Linux (Ubuntu 24.04 LTS)
+- Python 3.12
+
+## Licence
+
+MIT
+
+## Author
+
+[Sam.N](http://github.com/samn33)

eoqrid-0.1.4/eoqrid/__init__.py

@@ -0,0 +1,8 @@
+__version__ = "0.1.4"
+from .eoq_simulator import EoqSimulator
+from .quantum_state import QuantumState
+from .transpiler import Transpiler
+from .exchange_interaction import ExchangeInteraction
+from .measurement import Measurement
+from .result import Result
+from .util import plot_qc, plot_graph, random_connected_graph, random_quantum_circuit

eoqrid-0.1.4/eoqrid/eoq_simulator.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+import itertools
+from collections import defaultdict
+import numpy as np
+import networkx as nx
+from qiskit import QuantumCircuit, transpile
+from qiskit.quantum_info import Statevector
+from qiskit_aer import AerSimulator
+
+from eoqrid.quantum_state import QuantumState
+from eoqrid.transpiler import Transpiler
+from eoqrid.result import Result
+
+DEF_EXCHANGE_INTEGRAL = 1.0
+
+class EoqSimulator:
+    """
+    Exchange-Only Quantum Computing Simulator
+    
+    Attributes
+    ----------
+    topology : nx.Graph
+        quantum chip topology
+
+    """
+    def __init__(self, topology: nx.Graph = None) -> None:
+        """
+        Parameters
+        ----------
+        topology : nx.Graph
+            quantum chip topology
+
+        Returns
+        -------
+        None
+        
+        """
+        self._topology = topology
+
+    @property
+    def topology(self) -> nx.Graph:
+        return self._topology
+
+    @topology.setter
+    def topology(self, value) -> None:
+        self._topology = value
+
+    def _qc_is_noops(self, qc: QuantumCircuit) -> bool:
+        """
+        quantum circuit contains no gates operation or not.
+
+        Parameters
+        ----------
+        qc : QuantumCircuit
+            quantum circuit
+        
+        Returns
+        -------
+        bool
+            true if quantum circuit contains no gates operation, false otherwise
+
+        """
+        return qc.count_ops() == {}
+        
+    def _qc_is_transpiled(self, qc: QuantumCircuit) -> bool:
+        """
+        quantum circuit is already transpiled or not.
+
+        Parameters
+        ----------
+        qc : QuantumCircuit
+            quantum circuit
+        
+        Returns
+        -------
+        bool
+            true if quantum circuit is transpiled, false otherwise
+
+        """
+        if qc.num_qubits % 3 != 0:
+            return False
+        for name in qc.count_ops():
+            if name != 'ex' and name != 'm':
+                return False
+        return True
+        
+    def _qc_is_native(self, qc: QuantumCircuit) -> bool:
+        """
+        quantum circuit is for physical device.
+
+        Parameters
+        ----------
+        qc : QuantumCircuit
+            quantum circuit
+        
+        Returns
+        -------
+        bool
+            true if quantum circuit is transpiled, false otherwise
+
+        """
+        for name in qc.count_ops():
+            if name == 'ex' or name == 'm':
+                return True
+        return False
+        
+    def optimize(self, qc_native: QuantumCircuit,
+                 optimization_level: int = 0,
+                 seed: int | None = None) -> QuantumCircuit:
+        """
+        optimize the native quantum circuit.
+        
+        Parameters
+        ----------
+        qc_native : QuantumCircuit
+            quantum circuits for native device.
+        optimization_level : int
+            optimization level.
+        seed : int | None, default None
+            seed of random generation.
+        
+        Returns
+        -------
+        QuantumCircuit
+            optimized quantum circuit.
+
+        """
+        if not isinstance(qc_native, QuantumCircuit):
+            raise TypeError("the qc must be a QuantumCircuit object.")
+        for name in qc_native.count_ops():
+            if name != 'ex' and name != 'm':
+                raise ValueError("the qc_native contains gates other than exchange interaction.")
+        if optimization_level not in (0, 1, 2, 3):
+            raise ValueError("the optimization_level must be 0, 1, 2, or 3.")
+
+        num_dots = qc_native.num_qubits
+        topology = nx.Graph()
+        if self._topology is None:
+            for pair in itertools.combinations(range(num_dots), 2):
+                topology.add_edge(pair[0], pair[1], weight=DEF_EXCHANGE_INTEGRAL)
+        else:
+            topology = self._topology
+        trans = Transpiler(topology)
+        return trans.optimize(qc_native, optimization_level, seed)
+
+    def transpile(self, qc: QuantumCircuit, optimization_level: int = 0, seed: int | None = None) -> QuantumCircuit:
+        """
+        transpile the quantum circuit.
+        
+        Parameters
+        ----------
+        qc_native : QuantumCircuit
+            quantum circuits for native device.
+        optimization_level : int, default 1
+            optimization level.
+        seed : int | None, default None
+            seed of random generation.
+        
+        Returns
+        -------
+        qc_t : QuantumCircuit
+            transpiled quantum circuit.
+
+        """
+        if not isinstance(qc, QuantumCircuit):
+            raise TypeError("the qc must be a QuantumCircuit object.")
+        if not self._qc_is_noops(qc) and self._qc_is_native(qc):
+            raise ValueError("the qc is for physical device.")
+
+        num_dots = qc.num_qubits * 3
+        topology = nx.Graph()
+        if self._topology is None:
+            for pair in itertools.combinations(range(num_dots), 2):
+                topology.add_edge(pair[0], pair[1], weight=DEF_EXCHANGE_INTEGRAL)
+        else:
+            topology = self._topology
+        trans = Transpiler(topology)
+        qc_t = trans.run(qc, optimization_level, seed)
+
+        return qc_t
+
+    def _execute_measurement(self, qc_native: QuantumCircuit, shots: int = 1) -> Result:
+        """
+        execute the native quantum circuit with measurements.
+        
+        Parameters
+        ----------
+        qc_native : QuantumCircuit
+            quantum circuits for native device.
+        shots : int, default 1
+            shots of execute the quantumcircuit.
+        
+        Returns
+        -------
+        res : Result
+            result of execution.
+
+        """
+        if not isinstance(qc_native, QuantumCircuit):
+            raise TypeError("the qc_native must be a QuantumCircuit object.")
+        if not self._qc_is_noops(qc_native) and not self._qc_is_transpiled(qc_native):
+            raise ValueError("the qc_native must be transpiled.")
+        
+        num_dots = qc_native.num_qubits
+        num_qubits = num_dots // 3
+        num_clbits = qc_native.num_clbits
+        
+        qstate = QuantumState(num_qubits)
+        backend = AerSimulator(method='statevector')
+        qc_t = QuantumCircuit(num_dots, num_clbits)
+        qc_t.set_statevector(qstate.statevector)
+        qc_t = qc_t.compose(
+            transpile(qc_native.decompose(), backend=backend, optimization_level=0)
+        )
+        
+        freq_qiskit = defaultdict(int)
+        if shots > 1:
+            result = backend.run(qc_t, shots=shots-1).result()
+            freq_qiskit |= result.get_counts()
+        
+        result = backend.run(qc_t, shots=1).result()
+        for k,v in result.get_counts().items():
+            m_last = k[::-1]
+            freq_qiskit[k] += v
+
+        freq = {k[::-1]:v for k,v in freq_qiskit.items()}
+
+        res = Result(
+            num_qubits = num_qubits,
+            num_clbits = num_clbits,
+            num_dots = num_dots,
+            qstate = None,
+            m_last = m_last,
+            freq = freq,
+        )
+        return res
+
+    def _execute_no_measurement(self, qc_native: QuantumCircuit, shots: int = 1) -> Result:
+        """
+        execute the native quantum circuit without measurements.
+        
+        Parameters
+        ----------
+        qc_native : QuantumCircuit
+            quantum circuits for native device.
+        shots : int, default 1
+            shots of execute the quantumcircuit.
+        
+        Returns
+        -------
+        res : Result
+            result of execution.
+
+        """
+        if not isinstance(qc_native, QuantumCircuit):
+            raise TypeError("the qc_native must be a QuantumCircuit object.")
+        
+        num_dots = qc_native.num_qubits
+        num_qubits = num_dots // 3
+        num_clbits = qc_native.num_clbits
+
+        qstate = QuantumState(num_qubits)
+
+        qstate.statevector = qstate.statevector.evolve(qc_native)
+
+        if qc_native.layout is None:
+            logical_indices = list(range(num_dots))
+        else:
+            logical_indices = qc_native.layout.final_index_layout()
+
+        data = np.zeros(2 ** num_dots, dtype=complex)
+        for p_id in range(2 ** num_dots):
+            b_str = f"{p_id:0{num_dots}b}"
+            b_list = list(map(int, list(b_str)))[::-1]
+            bb_list = [0] * num_dots
+            l_id = 0
+            for k in range(num_dots):
+                bb_list[logical_indices[k]] = b_list[k]
+                if b_list[k] == 1:
+                    l_id += (1 << logical_indices[k])
+            data[p_id] = qstate.statevector.data[l_id]
+    
+        qstate.statevector = Statevector(data)
+
+        res = Result(
+            num_qubits = num_qubits,
+            num_clbits = num_clbits,
+            num_dots = num_dots,
+            qstate = qstate,
+            m_last = None,
+            freq = None,
+        )
+        return res
+
+    def execute(self, qc_native: QuantumCircuit, shots: int = 1) -> Result:
+        """
+        execute the native quantum circuit.
+        
+        Parameters
+        ----------
+        qc_native : QuantumCircuit
+            quantum circuits for native device.
+        shots : int, default 1
+            shots of execute the quantumcircuit.
+        
+        Returns
+        -------
+        res : Result
+            result of execution.
+
+        """
+        if self._qc_is_transpiled(qc_native) is False:
+            raise ValueError("qc_native must be a transpiled native quantum circuit.")
+        
+        if 'm' in qc_native.count_ops():
+            res = self._execute_measurement(qc_native, shots)
+        else:
+            res = self._execute_no_measurement(qc_native, shots)
+        return res
+        
+    def run(self, qc: QuantumCircuit, optimization_level: int = 0, shots: int = 1, seed: int | None = None) -> Result:
+        """
+        run the quantum circuit (transpile and execute).
+        
+        Parameters
+        ----------
+        qc_native : QuantumCircuit
+            quantum circuits for native device.
+        optimization_level : int, default 1
+            optimization level.
+        shots : int, default 1
+            shots of execute the quantumcircuit.
+        seed : int | None, default None
+            seed of random generation.
+        
+        Returns
+        -------
+        res : Result
+            result of execution.
+
+        """
+        qc_native = self.transpile(qc, optimization_level = optimization_level, seed = seed)
+        res = self.execute(qc_native, shots)
+        return res
+        
+    def fidelity(self, qc: QuantumCircuit, qc_native: QuantumCircuit) -> float:
+        """
+        fidelity of the quantum circuit execution.
+        
+        Parameters
+        ----------
+        qc : QuantumCircuit
+            quantum circuits.
+        qc_native : QuantumCircuit
+            quantum circuits for native device.
+        
+        Returns
+        -------
+        fidelity : float
+            fidelity
+
+        """
+        if 'measure' in qc.count_ops():
+            raise ValueError("can't calculate fidelity in quantum circuits that include measurements.")
+        
+        sv_qiskit = Statevector.from_int(0, 2 ** qc.num_qubits).evolve(qc)
+        state_expect = sv_qiskit.reverse_qargs().data
+        
+        res = self.execute(qc_native)
+        
+        fidelity = np.abs(np.vdot(state_expect, res.qstate.logical_qstate)) ** 2
+        return fidelity

eoqrid-0.1.4/eoqrid/exchange_interaction.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from qiskit.circuit import Gate, QuantumCircuit
+
+class ExchangeInteraction(Gate):
+    """
+    Exchange Interaction
+
+    """
+    def __init__(self, t: float, J: float = 1.0, label: str = None):
+        super().__init__(name="ex", num_qubits=2, params=[t, J], label=label)
+
+    def _define(self):
+        duration = self.params[0]
+        exchange_integral = self.params[1]
+        if duration < 0.0:
+            raise ValueError("duration must be a positive value.")
+        qc = QuantumCircuit(self.num_qubits, name=self.name)
+        phase = 0.5 * exchange_integral * duration
+        qc.rxx(phase, 0, 1)
+        qc.ryy(phase, 0, 1)
+        qc.rzz(phase, 0, 1)
+        self.definition = qc

eoqrid-0.1.4/eoqrid/measurement.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+from qiskit.circuit import Instruction, QuantumCircuit
+
+class Measurement(Instruction):
+    """
+    Measurement
+
+    """
+    def __init__(self):
+        super().__init__(name="m", num_qubits=2, num_clbits=1, params=[])
+
+    def _define(self):
+        qc = QuantumCircuit(self.num_qubits, 1)
+        qc.cx(0, 1)
+        qc.h(0)
+        qc.x(0)
+        qc.x(1)
+        qc.measure(0, 0)
+        with qc.if_test((0, 0)):
+            qc.measure(1, 0)
+
+        self.definition = qc