Skip to content

compiler

compiler ¤

CompiledCircuitT = TypeVar('CompiledCircuitT') module-attribute ¤

InitializerCompilationSign = type[Initializer] module-attribute ¤

LayerCompilationSign = type[Layer] module-attribute ¤

ParameterCompilationSign = type[ParameterNode] module-attribute ¤

SUPPORTED_BACKENDS = ['torch'] module-attribute ¤

AbstractCompiler ¤

Bases: ABC, Generic[CompiledCircuitT]

Source code in cirkit/backend/compiler.py 
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
209
210
211
212
class AbstractCompiler(ABC, Generic[CompiledCircuitT]):
    def __init__(
        self,
        layers_registry: CompilerLayerRegistry,
        parameters_registry: CompilerParameterRegistry,
        initializers_registry: CompilerInitializerRegistry,
        **flags: Any,
    ) -> None:
        self._layers_registry = layers_registry
        self._parameters_registry = parameters_registry
        self._initializers_registry = initializers_registry
        self._flags = flags
        self._compiled_circuits = CompiledCircuitsMap[CompiledCircuitT]()

    def is_compiled(self, sc: Circuit) -> bool:
        return self._compiled_circuits.is_compiled(sc)

    def has_symbolic(self, cc: CompiledCircuitT) -> bool:
        return self._compiled_circuits.has_symbolic(cc)

    def get_compiled_circuit(self, sc: Circuit) -> CompiledCircuitT:
        return self._compiled_circuits.get_compiled_circuit(sc)

    def get_symbolic_circuit(self, cc: CompiledCircuitT) -> Circuit:
        return self._compiled_circuits.get_symbolic_circuit(cc)

    def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuitT) -> None:
        self._compiled_circuits.register_compiled_circuit(sc, cc)

    def add_layer_rule(self, func: LayerCompilationFunc) -> None:
        self._layers_registry.add_rule(func)

    def add_parameter_rule(self, func: ParameterCompilationFunc) -> None:
        self._parameters_registry.add_rule(func)

    def add_initializer_rule(self, func: InitializerCompilationFunc) -> None:
        self._initializers_registry.add_rule(func)

    def retrieve_layer_rule(self, signature: LayerCompilationSign) -> LayerCompilationFunc:
        return self._layers_registry.retrieve_rule(signature)

    def retrieve_parameter_rule(
        self, signature: ParameterCompilationSign
    ) -> ParameterCompilationFunc:
        return self._parameters_registry.retrieve_rule(signature)

    def retrieve_initializer_rule(
        self, signature: InitializerCompilationSign
    ) -> InitializerCompilationFunc:
        return self._initializers_registry.retrieve_rule(signature)

    def compile(self, sc: Circuit) -> CompiledCircuitT:
        if self.is_compiled(sc):
            return self.get_compiled_circuit(sc)
        return self.compile_pipeline(sc)

    @abstractmethod
    def compile_pipeline(self, sc: Circuit) -> CompiledCircuitT: ...

__init__(layers_registry, parameters_registry, initializers_registry, **flags) ¤

Source code in cirkit/backend/compiler.py 
156
157
158
159
160
161
162
163
164
165
166
167
def __init__(
    self,
    layers_registry: CompilerLayerRegistry,
    parameters_registry: CompilerParameterRegistry,
    initializers_registry: CompilerInitializerRegistry,
    **flags: Any,
) -> None:
    self._layers_registry = layers_registry
    self._parameters_registry = parameters_registry
    self._initializers_registry = initializers_registry
    self._flags = flags
    self._compiled_circuits = CompiledCircuitsMap[CompiledCircuitT]()

add_initializer_rule(func) ¤

Source code in cirkit/backend/compiler.py 
190
191
def add_initializer_rule(self, func: InitializerCompilationFunc) -> None:
    self._initializers_registry.add_rule(func)

add_layer_rule(func) ¤

Source code in cirkit/backend/compiler.py 
184
185
def add_layer_rule(self, func: LayerCompilationFunc) -> None:
    self._layers_registry.add_rule(func)

add_parameter_rule(func) ¤

Source code in cirkit/backend/compiler.py 
187
188
def add_parameter_rule(self, func: ParameterCompilationFunc) -> None:
    self._parameters_registry.add_rule(func)

compile(sc) ¤

Source code in cirkit/backend/compiler.py 
206
207
208
209
def compile(self, sc: Circuit) -> CompiledCircuitT:
    if self.is_compiled(sc):
        return self.get_compiled_circuit(sc)
    return self.compile_pipeline(sc)

compile_pipeline(sc) abstractmethod ¤

Source code in cirkit/backend/compiler.py 
211
212
@abstractmethod
def compile_pipeline(self, sc: Circuit) -> CompiledCircuitT: ...

get_compiled_circuit(sc) ¤

Source code in cirkit/backend/compiler.py 
175
176
def get_compiled_circuit(self, sc: Circuit) -> CompiledCircuitT:
    return self._compiled_circuits.get_compiled_circuit(sc)

get_symbolic_circuit(cc) ¤

Source code in cirkit/backend/compiler.py 
178
179
def get_symbolic_circuit(self, cc: CompiledCircuitT) -> Circuit:
    return self._compiled_circuits.get_symbolic_circuit(cc)

has_symbolic(cc) ¤

Source code in cirkit/backend/compiler.py 
172
173
def has_symbolic(self, cc: CompiledCircuitT) -> bool:
    return self._compiled_circuits.has_symbolic(cc)

is_compiled(sc) ¤

Source code in cirkit/backend/compiler.py 
169
170
def is_compiled(self, sc: Circuit) -> bool:
    return self._compiled_circuits.is_compiled(sc)

register_compiled_circuit(sc, cc) ¤

Source code in cirkit/backend/compiler.py 
181
182
def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuitT) -> None:
    self._compiled_circuits.register_compiled_circuit(sc, cc)

retrieve_initializer_rule(signature) ¤

Source code in cirkit/backend/compiler.py 
201
202
203
204
def retrieve_initializer_rule(
    self, signature: InitializerCompilationSign
) -> InitializerCompilationFunc:
    return self._initializers_registry.retrieve_rule(signature)

retrieve_layer_rule(signature) ¤

Source code in cirkit/backend/compiler.py 
193
194
def retrieve_layer_rule(self, signature: LayerCompilationSign) -> LayerCompilationFunc:
    return self._layers_registry.retrieve_rule(signature)

retrieve_parameter_rule(signature) ¤

Source code in cirkit/backend/compiler.py 
196
197
198
199
def retrieve_parameter_rule(
    self, signature: ParameterCompilationSign
) -> ParameterCompilationFunc:
    return self._parameters_registry.retrieve_rule(signature)

CompilationRuleNotFound ¤

Bases: Exception

An exception that is raised when a compilation rule is not found.

Source code in cirkit/backend/compiler.py 
88
89
90
91
92
93
94
95
96
97
class CompilationRuleNotFound(Exception):
    """An exception that is raised when a compilation rule is not found."""

    def __init__(self, msg: str):
        """Initializes a compilation rule not found exception.

        Args:
            msg: The message of the exception.
        """
        super().__init__(msg)

__init__(msg) ¤

Initializes a compilation rule not found exception.

Parameters:

Name Type Description Default
msg str

The message of the exception.

 required
Source code in cirkit/backend/compiler.py 
91
92
93
94
95
96
97
def __init__(self, msg: str):
    """Initializes a compilation rule not found exception.

    Args:
        msg: The message of the exception.
    """
    super().__init__(msg)

CompiledCircuitsMap ¤

Bases: Generic[CompiledCircuitT]

Source code in cirkit/backend/compiler.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class CompiledCircuitsMap(Generic[CompiledCircuitT]):
    def __init__(self) -> None:
        self._bimap = BiMap[Circuit, CompiledCircuitT]()

    def is_compiled(self, sc: Circuit) -> bool:
        return self._bimap.has_left(sc)

    def has_symbolic(self, cc: CompiledCircuitT) -> bool:
        return self._bimap.has_right(cc)

    def get_compiled_circuit(self, sc: Circuit) -> CompiledCircuitT:
        return self._bimap.get_left(sc)

    def get_symbolic_circuit(self, cc: CompiledCircuitT) -> Circuit:
        return self._bimap.get_right(cc)

    def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuitT) -> None:
        self._bimap.add(sc, cc)

__init__() ¤

Source code in cirkit/backend/compiler.py 
21
22
def __init__(self) -> None:
    self._bimap = BiMap[Circuit, CompiledCircuitT]()

get_compiled_circuit(sc) ¤

Source code in cirkit/backend/compiler.py 
30
31
def get_compiled_circuit(self, sc: Circuit) -> CompiledCircuitT:
    return self._bimap.get_left(sc)

get_symbolic_circuit(cc) ¤

Source code in cirkit/backend/compiler.py 
33
34
def get_symbolic_circuit(self, cc: CompiledCircuitT) -> Circuit:
    return self._bimap.get_right(cc)

has_symbolic(cc) ¤

Source code in cirkit/backend/compiler.py 
27
28
def has_symbolic(self, cc: CompiledCircuitT) -> bool:
    return self._bimap.has_right(cc)

is_compiled(sc) ¤

Source code in cirkit/backend/compiler.py 
24
25
def is_compiled(self, sc: Circuit) -> bool:
    return self._bimap.has_left(sc)

register_compiled_circuit(sc, cc) ¤

Source code in cirkit/backend/compiler.py 
36
37
def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuitT) -> None:
    self._bimap.add(sc, cc)

CompilerInitializerRegistry ¤

Bases: CompilerRegistry[InitializerCompilationSign, InitializerCompilationFunc]

Source code in cirkit/backend/compiler.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
class CompilerInitializerRegistry(
    CompilerRegistry[
        InitializerCompilationSign,
        InitializerCompilationFunc,
    ]
):
    @classmethod
    def _validate_rule_function(cls, func: InitializerCompilationFunc) -> bool:
        ann = func.__annotations__.copy()
        del ann["return"]
        args = tuple(ann.keys())
        return issubclass(ann[args[-1]], Initializer)

    @classmethod
    def _retrieve_signature(cls, func: InitializerCompilationFunc) -> InitializerCompilationSign:
        ann = func.__annotations__.copy()
        del ann["return"]
        args = tuple(ann.keys())
        return cast(InitializerCompilationSign, ann[args[-1]])

CompilerLayerRegistry ¤

Bases: CompilerRegistry[LayerCompilationSign, LayerCompilationFunc]

Source code in cirkit/backend/compiler.py 
100
101
102
103
104
105
106
107
108
109
110
111
112
113
class CompilerLayerRegistry(CompilerRegistry[LayerCompilationSign, LayerCompilationFunc]):
    @classmethod
    def _validate_rule_function(cls, func: LayerCompilationFunc) -> bool:
        ann = func.__annotations__.copy()
        del ann["return"]
        args = tuple(ann.keys())
        return issubclass(ann[args[-1]], Layer)

    @classmethod
    def _retrieve_signature(cls, func: LayerCompilationFunc) -> LayerCompilationSign:
        ann = func.__annotations__.copy()
        del ann["return"]
        args = tuple(ann.keys())
        return cast(LayerCompilationSign, ann[args[-1]])

CompilerParameterRegistry ¤

Bases: CompilerRegistry[ParameterCompilationSign, ParameterCompilationFunc]

Source code in cirkit/backend/compiler.py 
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
class CompilerParameterRegistry(
    CompilerRegistry[ParameterCompilationSign, ParameterCompilationFunc]
):
    @classmethod
    def _validate_rule_function(cls, func: ParameterCompilationFunc) -> bool:
        ann = func.__annotations__.copy()
        del ann["return"]
        args = tuple(ann.keys())
        return issubclass(ann[args[-1]], ParameterNode)

    @classmethod
    def _retrieve_signature(cls, func: ParameterCompilationFunc) -> ParameterCompilationSign:
        ann = func.__annotations__.copy()
        del ann["return"]
        args = tuple(ann.keys())
        return cast(ParameterCompilationSign, ann[args[-1]])

InitializerCompilationFunc ¤

Bases: Protocol

The initialization method compilation function protocol.

Source code in cirkit/backend/compiler.py 
72
73
74
75
76
77
78
79
80
81
82
83
84
85
class InitializerCompilationFunc(Protocol):
    """The initialization method compilation function protocol."""

    def __call__(self, compiler: "AbstractCompiler[CompiledCircuitT]", init: Initializer) -> Any:
        """Compile a symbolic initializer, given a compiler.

        Args:
            compiler: The compiler.
            init: The symbolic initializer.

        Returns:
            A representation of the compiled initializer,
                which depends on the chosen compilation backend.
        """

__call__(compiler, init) ¤

Compile a symbolic initializer, given a compiler.

Parameters:

Name Type Description Default
compiler AbstractCompiler[CompiledCircuitT]

The compiler.

 required
init Initializer

The symbolic initializer.

 required

Returns:

Type Description
Any

A representation of the compiled initializer, which depends on the chosen compilation backend.
Source code in cirkit/backend/compiler.py 
75
76
77
78
79
80
81
82
83
84
85
def __call__(self, compiler: "AbstractCompiler[CompiledCircuitT]", init: Initializer) -> Any:
    """Compile a symbolic initializer, given a compiler.

    Args:
        compiler: The compiler.
        init: The symbolic initializer.

    Returns:
        A representation of the compiled initializer,
            which depends on the chosen compilation backend.
    """

LayerCompilationFunc ¤

Bases: Protocol

The layer compilation function protocol.

Source code in cirkit/backend/compiler.py 
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class LayerCompilationFunc(Protocol):
    """The layer compilation function protocol."""

    def __call__(self, compiler: "AbstractCompiler[CompiledCircuitT]", sl: Layer) -> Any:
        """Compile a symbolic layer, given a compiler.

        Args:
            compiler: The compiler.
            sl: The symbolic layer.

        Returns:
            A representation of the compiled layer,
                which depends on the chosen compilation backend.
        """

__call__(compiler, sl) ¤

Compile a symbolic layer, given a compiler.

Parameters:

Name Type Description Default
compiler AbstractCompiler[CompiledCircuitT]

The compiler.

 required
sl Layer

The symbolic layer.

 required

Returns:

Type Description
Any

A representation of the compiled layer, which depends on the chosen compilation backend.
Source code in cirkit/backend/compiler.py 
43
44
45
46
47
48
49
50
51
52
53
def __call__(self, compiler: "AbstractCompiler[CompiledCircuitT]", sl: Layer) -> Any:
    """Compile a symbolic layer, given a compiler.

    Args:
        compiler: The compiler.
        sl: The symbolic layer.

    Returns:
        A representation of the compiled layer,
            which depends on the chosen compilation backend.
    """

ParameterCompilationFunc ¤

Bases: Protocol

The parameter node compilation function protocol.

Source code in cirkit/backend/compiler.py 
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class ParameterCompilationFunc(Protocol):
    """The parameter node compilation function protocol."""

    def __call__(self, compiler: "AbstractCompiler[CompiledCircuitT]", p: ParameterNode) -> Any:
        """Compile a symbolic parameter node, given a compiler.

        Args:
            compiler: The compiler.
            p: The symbolic parameter node.

        Returns:
            A representation of the compiled parameter node,
                which depends on the chosen compilation backend.
        """

__call__(compiler, p) ¤

Compile a symbolic parameter node, given a compiler.

Parameters:

Name Type Description Default
compiler AbstractCompiler[CompiledCircuitT]

The compiler.

 required
p ParameterNode

The symbolic parameter node.

 required

Returns:

Type Description
Any

A representation of the compiled parameter node, which depends on the chosen compilation backend.
Source code in cirkit/backend/compiler.py 
59
60
61
62
63
64
65
66
67
68
69
def __call__(self, compiler: "AbstractCompiler[CompiledCircuitT]", p: ParameterNode) -> Any:
    """Compile a symbolic parameter node, given a compiler.

    Args:
        compiler: The compiler.
        p: The symbolic parameter node.

    Returns:
        A representation of the compiled parameter node,
            which depends on the chosen compilation backend.
    """