qamomile 0.1.0__tar.gz

qamomile-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.1
+Name: qamomile
+Version: 0.1.0
+Summary: 
+Author: Jij Inc.
+Author-email: info@j-ij.com
+Requires-Python: >=3.9.8,<3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Provides-Extra: qiskit
+Provides-Extra: quri-parts
+Requires-Dist: black (>=23.11.0,<24.0.0)
+Requires-Dist: jijmodeling-transpiler (>=0.6.0rc3)
+Requires-Dist: qiskit[qiskit] (>=0.44.0) ; extra == "qiskit"
+Requires-Dist: quri-parts-qulacs[quri-parts] ; extra == "quri-parts"
+Description-Content-Type: text/markdown
+
+# Qamomile
+
+`Qamomile` is a transpiler from model written in [JijModeling]() to quantum optimization algorithms on variaous quantum platform.
+
+- [Qiskit](#qiskit)
+- [QURI-Parts](#quri-parts) 
+
+Documentation: [https://jij-inc.github.io/Qamomile/](https://jij-inc.github.io/Qamomile/)
+
+## Qiskit
+
+[Qiskit](https://qiskit.org/) is an open-source SDK for working with quantum computers at the level of circuits, algorithms, and application modules.
+
+### Installation
+
+```bash
+pip install "qamomile[qiskit]"
+```
+
+### Quantum Approximate Optimization Algorithm (QAOA)
+
+```python
+import jijmodeling as jm
+import jijmodeling_transpiler as jmt
+import qamomile as jtq
+
+# Create model
+problem = jm.Problem("model")
+...  # Modeling ...
+
+# Compile
+compiled_instance = jmt.compile_model(problem, instance_data, fixed_vars)
+
+# Transpile to QAOA of qikit
+qaoa_builder = jtq.qiskit.transpile_to_qaoa(compiled_instance)
+```
+
+
+## QURI-Parts
+
+[QURI Parts](https://quri-parts.qunasys.com/) is an open source library suite for creating and executing quantum algorithms on various quantum computers and simulators.
+
+```bash
+pip install "qamomile[quri-parts]"
+```
+
+### Quantum Approximate Optimization Algorithm (QAOA)
+
+```python
+import jijmodeling as jm
+import jijmodeling_transpiler as jmt
+import qamomile as jtq
+
+# Create model
+problem = jm.Problem("model")
+...  # Modeling ...
+
+# Compile
+compiled_instance = jmt.compile_model(problem, instance_data, fixed_vars)
+
+# Transpile to QAOA of qikit
+qaoa_builder = jtq.quri.transpile_to_qaoa(compiled_instance)
+```
+
+
+## Contributing
+
+### Setup
+
+```bash
+pip install poetry
+poetry install --all-extras
+poetry shell
+```
+
+### Test
+
+```bash
+pytest tests
+```
+
+
+
+

qamomile-0.1.0/README.md

@@ -0,0 +1,83 @@
+# Qamomile
+
+`Qamomile` is a transpiler from model written in [JijModeling]() to quantum optimization algorithms on variaous quantum platform.
+
+- [Qiskit](#qiskit)
+- [QURI-Parts](#quri-parts) 
+
+Documentation: [https://jij-inc.github.io/Qamomile/](https://jij-inc.github.io/Qamomile/)
+
+## Qiskit
+
+[Qiskit](https://qiskit.org/) is an open-source SDK for working with quantum computers at the level of circuits, algorithms, and application modules.
+
+### Installation
+
+```bash
+pip install "qamomile[qiskit]"
+```
+
+### Quantum Approximate Optimization Algorithm (QAOA)
+
+```python
+import jijmodeling as jm
+import jijmodeling_transpiler as jmt
+import qamomile as jtq
+
+# Create model
+problem = jm.Problem("model")
+...  # Modeling ...
+
+# Compile
+compiled_instance = jmt.compile_model(problem, instance_data, fixed_vars)
+
+# Transpile to QAOA of qikit
+qaoa_builder = jtq.qiskit.transpile_to_qaoa(compiled_instance)
+```
+
+
+## QURI-Parts
+
+[QURI Parts](https://quri-parts.qunasys.com/) is an open source library suite for creating and executing quantum algorithms on various quantum computers and simulators.
+
+```bash
+pip install "qamomile[quri-parts]"
+```
+
+### Quantum Approximate Optimization Algorithm (QAOA)
+
+```python
+import jijmodeling as jm
+import jijmodeling_transpiler as jmt
+import qamomile as jtq
+
+# Create model
+problem = jm.Problem("model")
+...  # Modeling ...
+
+# Compile
+compiled_instance = jmt.compile_model(problem, instance_data, fixed_vars)
+
+# Transpile to QAOA of qikit
+qaoa_builder = jtq.quri.transpile_to_qaoa(compiled_instance)
+```
+
+
+## Contributing
+
+### Setup
+
+```bash
+pip install poetry
+poetry install --all-extras
+poetry shell
+```
+
+### Test
+
+```bash
+pytest tests
+```
+
+
+

qamomile-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["poetry-core>=1.5.2", "poetry-dynamic-versioning>=0.21.4"]
+build-backend = "poetry_dynamic_versioning.backend"
+
+[tool.poetry-dynamic-versioning]
+enable = false
+style = "pep440"
+
+[tool.poetry]
+name = "qamomile"
+version = "0.1.0" # using poetry-dynamic-versioning
+description = ""
+authors = ["Jij Inc. <info@j-ij.com>"]
+readme = "README.md"
+packages = [
+    {include = "qamomile"},
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9.8,<3.11"
+jijmodeling-transpiler = ">=0.6.0rc3"
+qiskit = {version = ">=0.44.0", extras = ["qiskit"]}
+quri-parts-qulacs = {version = "*", extras = ["quri-parts"]}
+black = "^23.11.0"
+
+
+[tool.poetry.group.dev.dependencies]
+jupyter = "^1.0.0"
+matplotlib = "^3.7.1"
+pylatexenc = "^2.10"
+pytest = "^7.3.2"
+
+[tool.poetry.extras]
+qiskit = ["qiskit"]
+quri-parts = ["quri-parts-qulacs"]
+
+
+[tool.pytest.ini_options]
+addopts = "--doctest-modules"
+
+[tool.poetry.group.docs.dependencies]
+mkdocs = "^1.4.2"
+mkdocs-material = "^9.1.5"
+mkdocs-gen-files = ">=0.4,<0.6"
+mkdocs-section-index = "^0.3.5"
+mkdocs-literate-nav = "^0.6.0"
+mkdocs-jupyter = "^0.24.0"
+mkdocstrings = {version = ">=0.19", extras = ["python"]}

qamomile-0.1.0/qamomile/core/__init__.py

@@ -0,0 +1,12 @@
+from qamomile.core import ising_qubo as ising_qubo
+from qamomile.core import qrac as qrac
+from .ising_qubo import qubo_to_ising, IsingModel
+from .qrac import greedy_graph_coloring
+
+__all__ = [
+    "ising_qubo",
+    "qrac",
+    "qubo_to_ising",
+    "IsingModel",
+    "greedy_graph_coloring",
+]

qamomile-0.1.0/qamomile/core/ising_qubo/__init__.py

@@ -0,0 +1,8 @@
+from .ising_qubo import IsingModel, calc_qubo_energy, qubo_to_ising
+
+
+__all__ = [
+    "IsingModel",
+    "calc_qubo_energy",
+    "qubo_to_ising",
+]

qamomile-0.1.0/qamomile/core/ising_qubo/ising_qubo.py

@@ -0,0 +1,76 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class IsingModel:
+    quad: dict[tuple[int, int], float]
+    linear: dict[int, float]
+    constant: float
+
+    def calc_energy(self, state: list[int]) -> float:
+        """Calculates the energy of the state.
+
+        Examples:
+            >>> ising = IsingModel({(0, 1): 2.0}, {0: 4.0, 1: 5.0}, 6.0)
+            >>> ising.calc_energy([1, -1])
+            3.0
+
+        """
+        energy = self.constant
+        for (i, j), value in self.quad.items():
+            energy += value * state[i] * state[j]
+        for i, value in self.linear.items():
+            energy += value * state[i]
+        return energy
+
+
+def calc_qubo_energy(qubo: dict[tuple[int, int], float], state: list[int]) -> float:
+    """Calculates the energy of the state.
+
+    Examples:
+        >>> calc_qubo_energy({(0, 0): 1.0, (0, 1): 2.0, (1, 1): 3.0}, [1, 1])
+        6.0
+    """
+    energy = 0.0
+    for (i, j), value in qubo.items():
+        energy += value * state[i] * state[j]
+    return energy
+
+
+def qubo_to_ising(qubo: dict[tuple[int, int], float], simplify=True) -> IsingModel:
+    """Converts a QUBO to an Ising model.
+
+    QUBO: sum_{ij} Q_{ij} x_i x_j -> Ising: sum_{ij} J_{ij} z_i z_j + sum_i h_i z_i
+    Correspondence - x_i = (1 - z_i) / 2, where x_i in {0, 1} and z_i in {-1, 1}
+
+    Examples:
+        >>> qubo = {(0, 0): 1.0, (0, 1): 2.0, (1, 1): 3.0}
+        >>> ising = qubo_to_ising(qubo)
+        >>> binary = [1, 0]
+        >>> spin = [-1, 1]
+        >>> qubo_energy = calc_qubo_energy(qubo, binary)
+        >>> assert qubo_energy == ising.calc_energy(spin)
+
+        >>> qubo = {(0, 1): 2, (0, 0): -1, (1, 1): -1}
+        >>> ising = qubo_to_ising(qubo)
+        >>> assert ising.constant == -0.5
+        >>> assert ising.linear == {}
+        >>> assert ising.quad == {(0, 1): 0.5}
+
+    """
+    ising_J: dict[tuple[int, int], float] = {}
+    ising_h: dict[int, float] = {}
+    constant = 0.0
+    for (i, j), value in qubo.items():
+        if i != j:
+            ising_J[(i, j)] = value / 4.0 + ising_J.get((i, j), 0.0)
+            constant += value / 4.0
+        else:
+            constant += value / 2.0
+        ising_h[i] = -value / 4.0 + ising_h.get(i, 0.0)
+        ising_h[j] = -value / 4.0 + ising_h.get(j, 0.0)
+
+    if simplify:
+        ising_J = {ij: value for ij, value in ising_J.items() if value != 0.0}
+        ising_h = {i: value for i, value in ising_h.items() if value != 0.0}
+    return IsingModel(ising_J, ising_h, constant)

qamomile-0.1.0/qamomile/core/qrac/__init__.py

@@ -0,0 +1,8 @@
+"""
+This module provides utilities for the Quantum Random Access Coding (QRAC).
+Ex: QRAC utilizes are used Quantum Random Access Optimization (QRAO).
+"""
+
+from .graph_coloring import greedy_graph_coloring, check_linear_term
+
+__all__ = ["greedy_graph_coloring", "check_linear_term"]

qamomile-0.1.0/qamomile/core/qrac/graph_coloring.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+import typing as typ
+
+
+def greedy_graph_coloring(
+    graph: typ.Iterable[tuple[int, int]],
+    max_color_group_size: int,
+    init_coloring: typ.Optional[dict[int, int]] = None,
+) -> tuple[dict[int, int], dict[int, list[int]]]:
+    """graph coloring for QRAC
+
+    Args:
+        graph (typ.Iterable[tuple[int, int]]): _description_
+        max_color_group_size (int): if you want to use for the qrac31, set 3.
+        init_coloring (typ.Optional[dict[int, int]], optional): initial coloring. Defaults to None.
+
+    Returns:
+        tuple[dict[int, int], dict[int, list[int]]]: coloring, color_group
+
+
+    Examples:
+        >>> graph = [(0, 1), (1, 2), (2, 0), (0, 4)]
+        >>> greedy_graph_coloring(graph, 2)
+        ({0: 0, 1: 1, 2: 2, 4: 1}, {0: [0], 1: [1, 4], 2: [2]})
+
+    """
+    coloring = {}
+    if init_coloring:
+        coloring.update(init_coloring)
+
+    max_color = max(coloring.values()) if coloring else -1
+
+    adj_matrix: dict[int, list[int]] = {}
+    for i, j in graph:
+        if i == j:
+            continue
+        if i not in adj_matrix:
+            adj_matrix[i] = []
+        if j not in adj_matrix:
+            adj_matrix[j] = []
+        adj_matrix[i].append(j)
+        adj_matrix[j].append(i)
+
+    color_group: dict[int, list[int]] = {}
+    for index, color in coloring.items():
+        if color not in coloring:
+            color_group[color] = []
+        color_group[color].append(index)
+
+    for i, neigborhoors in adj_matrix.items():
+        if i in coloring:
+            continue
+
+        neighbor_colors = [coloring[k] for k in neigborhoors if k in coloring]
+
+        done_coloring = False
+        for color in range(max_color + 1):
+            if color not in color_group or color not in neighbor_colors:
+                if color not in color_group or max_color_group_size > len(
+                    color_group[color]
+                ):
+                    coloring[i] = color
+                    done_coloring = True
+                    if color not in color_group:
+                        color_group[color] = []
+                    color_group[color].append(i)
+                    break
+        if not done_coloring:
+            coloring[i] = max_color + 1
+            color_group[max_color + 1] = [i]
+            max_color += 1
+
+    return coloring, color_group
+
+
+def check_linear_term(
+    color_group: dict[int, list[int]],
+    linear_term_index: list[int],
+    max_color_group_size: int,
+) -> dict[int, list[int]]:
+    """Search for items within the index of linear term that have not been assigned to the color_group, and add them.
+
+    Args:
+        color_group (dict[int, list[int]]): color_group
+        linear_term_index (list[int]): list of index of linear term
+        max_color_group_size (int): the maximum number of encoding qubits. if you want to use for the qrac31, set 3.
+
+    Returns:
+        dict[int, list[int]]: color_group which added items within the index of linear term that have not been assigned to the color_group.
+    """
+    idx_in_color_group = []
+    for v in color_group.values():
+        idx_in_color_group.extend(v)
+
+    # We're adding a bit to the next index of the 'quad' qubit, affecting only the linear term. 
+    # If the Ising Hamiltonian has only linear terms, making 'quad' empty and causing a 'max' error, we return index 0 to avoid this.
+    qubit_index_for_linear = max(color_group.keys()) + 1 if color_group else 0
+    bits_in_qubits_counter = 1
+    for idx in linear_term_index:
+        if idx not in idx_in_color_group:
+            if bits_in_qubits_counter == 1:
+                color_group[qubit_index_for_linear] = []
+
+            color_group[qubit_index_for_linear].append(idx)
+            bits_in_qubits_counter += 1
+
+            if bits_in_qubits_counter > max_color_group_size:
+                qubit_index_for_linear += 1
+                bits_in_qubits_counter = 1
+
+    return color_group

qamomile-0.1.0/qamomile/qiskit/__init__.py

@@ -0,0 +1,19 @@
+from qamomile.qiskit import qaoa as qaoa
+from qamomile.qiskit import qrao as qrao
+from .qaoa.to_qaoa import transpile_to_qaoa_ansatz
+from .qrao.to_qrac import (
+    transpile_to_qrac31_hamiltonian,
+    transpile_to_qrac21_hamiltonian,
+    transpile_to_qrac32_hamiltonian,
+    transpile_to_qrac_space_efficient_hamiltonian,
+)
+
+__all__ = [
+    "qaoa",
+    "qrao",
+    "transpile_to_qaoa_ansatz",
+    "transpile_to_qrac31_hamiltonian",
+    "transpile_to_qrac21_hamiltonian",
+    "transpile_to_qrac32_hamiltonian",
+    "transpile_to_qrac_space_efficient_hamiltonian",
+]

qamomile-0.1.0/qamomile/qiskit/minimal_encoding/__init__.py

@@ -0,0 +1,9 @@
+from qamomile.qiskit import (
+    minimal_encoding as minimal_encoding,
+)
+from qamomile.qiskit.minimal_encoding.to_minimal_encoding import (
+    transpile_to_minimal_encoding,
+)
+
+
+__all__ = ["minimal_encoding", "transpile_to_minimal_encoding"]

qamomile-0.1.0/qamomile/qiskit/minimal_encoding/cost_function.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import itertools
+import typing as typ
+from collections.abc import Callable
+
+import numpy as np
+import qiskit as qk
+import qiskit.quantum_info as qk_info
+from qiskit.primitives import Estimator
+
+
+def define_pauli_op(
+    num_register_bits: int, ancilla: bool = False
+) -> list[qk_info.SparsePauliOp]:
+    """Function to define pauli operators
+
+    Args:
+        num_register_bits (int): number of register bits
+        ancilla (bool, optional): whether to add ancilla qubit |1> or not. Defaults to False.
+
+    Raises:
+        ValueError: if num_register_bits < 1
+
+    Returns:
+        list[qk_info.SparsePauliOp]: list of pauli operators
+    """
+
+    if num_register_bits < 1:
+        raise ValueError("num_register_bits must be greater than 0")
+
+    z = [[False], [True]]
+    x = [[False], [False]]
+    zero_op = qk_info.SparsePauliOp(
+        qk_info.PauliList.from_symplectic(z, x), coeffs=[1 / 2, 1 / 2]
+    )
+
+    one_op = qk_info.SparsePauliOp(
+        qk_info.PauliList.from_symplectic(z, x), coeffs=[1 / 2, -1 / 2]
+    )
+
+    identity_op = qk_info.SparsePauliOp(qk_info.Pauli(([0], [0])))
+
+    ancilla_operator = one_op if ancilla else identity_op
+
+    pauli_ops = []
+
+    if num_register_bits == 1:
+        for _op in [one_op, zero_op]:
+            pauli_ops.append(_op.tensor(ancilla_operator))
+    else:
+        for val in itertools.product(
+            [one_op, zero_op], repeat=num_register_bits
+        ):
+            pauli_op = val[0]
+            for _op in val[1:]:
+                pauli_op = pauli_op.tensor(_op)
+
+            pauli_ops.append(pauli_op.tensor(ancilla_operator))
+
+    return pauli_ops
+
+
+def initialize_cost_function(
+    qubo: dict[tuple[int, int], float], num_cbits: int
+) -> Callable[[np.array], float]:
+    """Function to initialize cost function for minimal encoding
+
+    Args:
+        qubo (dict[tuple[int, int], float]): QUBO Matrix
+        num_cbit (int): number of classical bits
+
+    Returns:
+        Callable[[np.array], float]: cost function for minimal encoding
+    """
+
+    # define cost function
+    def cost_function(one_coeffs: np.array) -> float:
+        """Function to compute value of cost function for minimal encoding
+
+        Args:
+            one_coeffs (np.array): the ratio of the expectation value of each pauli operator for when ancilla qubit is |1> and the expectation value of each pauli operator ignoring ancilla qubit
+
+        Returns:
+            float: value of cost function
+        """
+
+        cost = 0
+        for i in range(num_cbits):
+            for j in range(i, num_cbits):
+                if i != j:
+                    cost += 2 * qubo[(i, j)] * one_coeffs[i] * one_coeffs[j]
+                else:
+                    cost += qubo[(i, j)] * one_coeffs[i]
+
+        return cost
+
+    return cost_function