Skip to content

qoolqit.register

register

Classes:

  • Register –

    The Register in QoolQit, representing a set of qubits with coordinates.

Register(qubits: dict)

The Register in QoolQit, representing a set of qubits with coordinates.

Parameters:

  • qubits

    (dict) –

    a dictionary of qubits and respective coordinates {q: (x, y), ...}.

Used by:

Methods:

Attributes:

  • n_qubits (int) –

    Number of qubits in the Register.

  • qubits (dict) –

    Returns the dictionary of qubits and respective coordinates.

  • qubits_ids (list) –

    Returns the qubit keys.

Source code in qoolqit/register.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
def __init__(self, qubits: dict) -> None:
    """Default constructor for the Register.

    Arguments:
        qubits: a dictionary of qubits and respective coordinates {q: (x, y), ...}.
    """
    if not isinstance(qubits, dict):
        raise TypeError(
            "Register must be initialized with a dictionary of "
            "qubits and respective coordinates {q: (x, y), ...}."
        )

    self._qubits: dict = qubits

n_qubits: int property

Number of qubits in the Register.

qubits: dict property

Returns the dictionary of qubits and respective coordinates.

qubits_ids: list property

Returns the qubit keys.

distances() -> dict

Distance between each qubit pair.

Source code in qoolqit/register.py 
77
78
79
80
def distances(self) -> dict:
    """Distance between each qubit pair."""
    pairs = all_node_pairs(list(self.qubits.keys()))
    return distances(self.qubits, pairs)

draw(return_fig: bool = False) -> Figure | None

Draw the register.

Parameters:

  • return_fig
    (bool, default: False ) –

    boolean argument to return the matplotlib figure.

Source code in qoolqit/register.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
def draw(self, return_fig: bool = False) -> Figure | None:
    """Draw the register.

    Arguments:
        return_fig: boolean argument to return the matplotlib figure.
    """
    fig, ax = plt.subplots(1, 1, figsize=(4, 4), dpi=150)
    ax.set_aspect("equal")

    x_coords, y_coords = zip(*self.qubits.values())
    x_min, x_max = min(x_coords), max(x_coords)
    y_min, y_max = min(y_coords), max(y_coords)

    grid_x_min, grid_x_max = min(-1, x_min), max(1, x_max)
    grid_y_min, grid_y_max = min(-1, y_min), max(1, y_max)

    grid_scale = ceil(max(grid_x_max - grid_x_min, grid_y_max - grid_y_min))

    ax.grid(True, color="lightgray", linestyle="--", linewidth=0.7)
    ax.set_axisbelow(True)
    ax.set_xlabel("x")
    ax.set_ylabel("y")

    eps = 0.05 * grid_scale
    ax.set_xlim(grid_x_min - eps, grid_x_max + eps)
    ax.set_ylim(grid_y_min - eps, grid_y_max + eps)

    possible_multiples = [0.2, 0.25, 0.5, 1.0, 2.0, 2.5, 5.0, 10.0]
    grid_multiple = min(possible_multiples, key=lambda x: abs(x - grid_scale / 8))
    majorLocatorX = MultipleLocator(grid_multiple)
    majorLocatorY = MultipleLocator(grid_multiple)
    ax.xaxis.set_major_locator(majorLocatorX)
    ax.yaxis.set_major_locator(majorLocatorY)

    ax.scatter(x_coords, y_coords, s=50, color="darkgreen")

    ax.tick_params(axis="both", which="both", labelbottom=True, labelleft=True, labelsize=8)

    if return_fig:
        plt.close()
        return fig
    else:
        return None

from_coordinates(coords: list) -> Register classmethod

Initializes a Register from a list of coordinates.

Parameters:

  • coords
    (list) –

    a list of coordinates [(x, y), ...]

Source code in qoolqit/register.py 
48
49
50
51
52
53
54
55
56
57
58
59
60
@classmethod
def from_coordinates(cls, coords: list) -> Register:
    """Initializes a Register from a list of coordinates.

    Arguments:
        coords: a list of coordinates [(x, y), ...]
    """
    if not isinstance(coords, list):
        raise TypeError(
            "Register must be initialized with a dictionary of qubit and coordinates."
        )
    coords_dict = {i: pos for i, pos in enumerate(coords)}
    return cls(coords_dict)

from_graph(graph: DataGraph) -> Register classmethod

Initializes a Register from a graph that has coordinates.

Parameters:

  • graph
    (DataGraph) –

    a DataGraph instance.

Source code in qoolqit/register.py 
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
@classmethod
def from_graph(cls, graph: DataGraph) -> Register:
    """Initializes a Register from a graph that has coordinates.

    Arguments:
        graph: a DataGraph instance.
    """

    if not graph.has_coords:
        raise ValueError("Initializing a register from a graph requires node coordinates.")

    if len(graph.nodes) == 0:
        raise ValueError("Trying to initialize a register from an empty graph.")

    return cls(graph.coords)

interactions() -> dict

Interaction 1/r^6 between each qubit pair.

Source code in qoolqit/register.py 
96
97
98
def interactions(self) -> dict:
    """Interaction 1/r^6 between each qubit pair."""
    return {p: 1.0 / (r**6) for p, r in self.distances().items()}

max_radial_distance() -> float

Maximum radial distance between all qubits.

Source code in qoolqit/register.py 
91
92
93
94
def max_radial_distance(self) -> float:
    """Maximum radial distance between all qubits."""
    max_radial_distance: float = max(self.radial_distances().values())
    return max_radial_distance

min_distance() -> float

Minimum distance between all qubit pairs.

Source code in qoolqit/register.py 
82
83
84
85
def min_distance(self) -> float:
    """Minimum distance between all qubit pairs."""
    distance: float = min(self.distances().values())
    return distance

radial_distances() -> dict

Radial distance of each qubit from the origin.

Source code in qoolqit/register.py 
87
88
89
def radial_distances(self) -> dict:
    """Radial distance of each qubit from the origin."""
    return radial_distances(self.qubits)