Skip to content

register_manager

BitRegister

Bases: Register

BitRegister manages a (virtual) bit register.

Source code in opensquirrel/register_manager.py 
83
84
85
86
87
88
89
class BitRegister(Register):
    """BitRegister manages a (virtual) bit register."""

    default_name: ClassVar[str] = DEFAULT_BIT_REGISTER_NAME

    def __init__(self, size: int, name: str = default_name) -> None:
        super().__init__(size, name=name)

QubitRegister

Bases: Register

QubitRegister manages a (virtual) qubit register.

Source code in opensquirrel/register_manager.py 
74
75
76
77
78
79
80
class QubitRegister(Register):
    """QubitRegister manages a (virtual) qubit register."""

    default_name: ClassVar[str] = DEFAULT_QUBIT_REGISTER_NAME

    def __init__(self, size: int, name: str = default_name) -> None:
        super().__init__(size, name=name)

Register

Register manages a (virtual) register.

Source code in opensquirrel/register_manager.py 
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
class Register:
    """Register manages a (virtual) register."""

    default_name: ClassVar[str]

    def __init__(
        self,
        size: int,
        name: str,
        virtual_zero_index: int = 0,
    ) -> None:
        self._size = size
        self._name = name
        self._virtual_zero_index = virtual_zero_index

    @property
    def name(self) -> str:
        return self._name

    @property
    def size(self) -> int:
        return self._size

    @property
    def virtual_zero_index(self) -> int:
        return self._virtual_zero_index

    @virtual_zero_index.setter
    def virtual_zero_index(self, value: int) -> None:
        self._virtual_zero_index = value

    def __getitem__(self, key: int | slice) -> Any:
        if isinstance(key, int):
            if abs(key) >= len(self):
                msg = f"index {key!r} is out of range: register size is {len(self)!r}"
                raise IndexError(msg)
            size = len(self) if key < 0 else 0
            return self._virtual_zero_index + key + size
        if isinstance(key, slice):
            start, stop, step = key.indices(len(self))
            return list(range(start + self._virtual_zero_index, stop + self._virtual_zero_index, step))
        return None

    def __len__(self) -> int:
        return self._size

    def __iter__(self) -> Iterator[int]:
        index = self._virtual_zero_index
        while index < self._virtual_zero_index + self._size:
            yield index
            index += 1

    def __eq__(self, other: Any) -> bool:
        if not isinstance(other, Register):
            return False
        return (
            self.size == other.size and self.name == other.name and self.virtual_zero_index == other.virtual_zero_index
        )

    def __repr__(self) -> str:
        return f"{type(self)}: {self.name}, {self.size}"

RegisterManager

Source code in opensquirrel/register_manager.py 
 97
 98
 99
100
101
102
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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
class RegisterManager:
    def __init__(self, qubit_registry: QubitRegistry, bit_registry: BitRegistry) -> None:
        self._qubit_registry = qubit_registry
        self._bit_registry = bit_registry
        self._virtual_qubit_register = (
            QubitRegister(0) if not qubit_registry else (RegisterManager.generate_virtual_register(qubit_registry))
        )
        self._virtual_bit_register = (
            BitRegister(0) if not bit_registry else (RegisterManager.generate_virtual_register(bit_registry))
        )

    @property
    def qubit_register_size(self) -> int:
        return self._virtual_qubit_register.size

    @property
    def qubit_register_name(self) -> str:
        return self._virtual_qubit_register.name

    @property
    def bit_register_size(self) -> int:
        return self._virtual_bit_register.size

    @property
    def bit_register_name(self) -> str:
        return self._virtual_bit_register.name

    @staticmethod
    def generate_virtual_register(registry: Registry) -> Register:
        """Generate a virtual (qu)bit register from a registry of (qu)bit registers.

        Args:
            registry (Registry): Registry of (qu)bit registers.

        Returns:
            Register: Virtual (qu)bit register.

        """
        registers = list(registry.values())
        register_cls = registers[0].__class__
        virtual_index = 0
        for register in registers:
            register.virtual_zero_index = virtual_index
            virtual_index += register.size
        return register_cls(virtual_index, register_cls.default_name)

    @overload
    def add_register(self, register: QubitRegister) -> None: ...

    @overload
    def add_register(self, register: BitRegister) -> None: ...

    def add_register(self, register: QubitRegister | BitRegister) -> None:
        """Add a (qu)bit register to the register manager.

        Args:
            register (QubitRegister | BitRegister): (Qu)bit register to add.

        """
        if isinstance(register, QubitRegister):
            if register.name in self._qubit_registry:
                msg = f"qubit register with name {register.name!r} already exists"
                raise KeyError(msg)
            self._qubit_registry[register.name] = register
            self._virtual_qubit_register = RegisterManager.generate_virtual_register(self._qubit_registry)
        elif isinstance(register, BitRegister):
            if register.name in self._bit_registry:
                msg = f"bit register with name {register.name!r} already exists"
                raise KeyError(msg)
            self._bit_registry[register.name] = register
            self._virtual_bit_register = RegisterManager.generate_virtual_register(self._bit_registry)
        else:
            msg = f"unsupported register type: {type(register)}"
            raise TypeError(msg)

    def get_qubit_register(self, qubit_register_name: str) -> QubitRegister:
        """Get a qubit register by name.

        Args:
            qubit_register_name (str): Name of the qubit register.

        Returns:
            The qubit register with the specified name.

        """
        return self._qubit_registry[qubit_register_name]

    def get_bit_register(self, bit_register_name: str) -> BitRegister:
        """Get a bit register by name.

        Args:
            bit_register_name (str): Name of the bit register.

        Returns:
            The bit register with the specified name.

        """
        return self._bit_registry[bit_register_name]

    def __eq__(self, other: Any) -> bool:
        if not isinstance(other, RegisterManager):
            return False
        return (
            self._virtual_qubit_register == other._virtual_qubit_register
            and self._virtual_bit_register == other._virtual_bit_register
        )

    def __repr__(self) -> str:
        return (
            f"virtual_qubit_register:\n{self._virtual_qubit_register}\n"
            f"virtual_bit_register:\n{self._virtual_bit_register}"
        )

add_register 

add_register(register: QubitRegister) -> None

add_register(register: BitRegister) -> None

add_register(register: QubitRegister | BitRegister) -> None

Add a (qu)bit register to the register manager.

Parameters:

Name Type Description Default
register QubitRegister | BitRegister

(Qu)bit register to add.

 required
Source code in opensquirrel/register_manager.py 
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
def add_register(self, register: QubitRegister | BitRegister) -> None:
    """Add a (qu)bit register to the register manager.

    Args:
        register (QubitRegister | BitRegister): (Qu)bit register to add.

    """
    if isinstance(register, QubitRegister):
        if register.name in self._qubit_registry:
            msg = f"qubit register with name {register.name!r} already exists"
            raise KeyError(msg)
        self._qubit_registry[register.name] = register
        self._virtual_qubit_register = RegisterManager.generate_virtual_register(self._qubit_registry)
    elif isinstance(register, BitRegister):
        if register.name in self._bit_registry:
            msg = f"bit register with name {register.name!r} already exists"
            raise KeyError(msg)
        self._bit_registry[register.name] = register
        self._virtual_bit_register = RegisterManager.generate_virtual_register(self._bit_registry)
    else:
        msg = f"unsupported register type: {type(register)}"
        raise TypeError(msg)

generate_virtual_register staticmethod 

generate_virtual_register(registry: Registry) -> Register

Generate a virtual (qu)bit register from a registry of (qu)bit registers.

Parameters:

Name Type Description Default
registry Registry

Registry of (qu)bit registers.

 required

Returns:

Name Type Description
Register Register

Virtual (qu)bit register.
Source code in opensquirrel/register_manager.py 
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
@staticmethod
def generate_virtual_register(registry: Registry) -> Register:
    """Generate a virtual (qu)bit register from a registry of (qu)bit registers.

    Args:
        registry (Registry): Registry of (qu)bit registers.

    Returns:
        Register: Virtual (qu)bit register.

    """
    registers = list(registry.values())
    register_cls = registers[0].__class__
    virtual_index = 0
    for register in registers:
        register.virtual_zero_index = virtual_index
        virtual_index += register.size
    return register_cls(virtual_index, register_cls.default_name)

get_bit_register 

get_bit_register(bit_register_name: str) -> BitRegister

Get a bit register by name.

Parameters:

Name Type Description Default
bit_register_name str

Name of the bit register.

 required

Returns:

Type Description
BitRegister

The bit register with the specified name.
Source code in opensquirrel/register_manager.py 
184
185
186
187
188
189
190
191
192
193
194
def get_bit_register(self, bit_register_name: str) -> BitRegister:
    """Get a bit register by name.

    Args:
        bit_register_name (str): Name of the bit register.

    Returns:
        The bit register with the specified name.

    """
    return self._bit_registry[bit_register_name]

get_qubit_register 

get_qubit_register(
    qubit_register_name: str,
) -> QubitRegister

Get a qubit register by name.

Parameters:

Name Type Description Default
qubit_register_name str

Name of the qubit register.

 required

Returns:

Type Description
QubitRegister

The qubit register with the specified name.
Source code in opensquirrel/register_manager.py 
172
173
174
175
176
177
178
179
180
181
182
def get_qubit_register(self, qubit_register_name: str) -> QubitRegister:
    """Get a qubit register by name.

    Args:
        qubit_register_name (str): Name of the qubit register.

    Returns:
        The qubit register with the specified name.

    """
    return self._qubit_registry[qubit_register_name]