Skip to content

qoolqit.register

register

Classes:

  • Register –

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

Register 

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), ...}.

Returned by: 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 property 

n_qubits: int

Number of qubits in the Register.

qubits property 

qubits: dict

Returns the dictionary of qubits and respective coordinates.

qubits_ids property 

qubits_ids: list

Returns the qubit keys.

distances 

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 

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 classmethod 

from_coordinates(coords: list) -> Register

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 classmethod 

from_graph(graph: DataGraph) -> Register

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 

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 

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 

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 

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)