Skip to content

base

base ¤

CompiledCircuit = TypeVar('CompiledCircuit') 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

Source code in cirkit/backend/base.py 
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
class AbstractCompiler(ABC):
    def __init__(self, registry: CompilerRegistry, **flags):
        self._registry = registry
        self._flags = flags
        self._compiled_circuits = CompiledCircuitsMap()

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

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

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

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

    def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuit):
        self._compiled_circuits.register_compiled_circuit(sc, cc)

    def add_layer_rule(self, func: LayerCompilationFunc):
        self._registry.add_layer_rule(func)

    def add_parameter_rule(self, func: ParameterCompilationFunc):
        self._registry.add_parameter_rule(func)

    def add_initializer_rule(self, func: InitializerCompilationFunc):
        self._registry.add_initializer_rule(func)

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

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

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

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

    @abstractmethod
    def compile_layer(self, sl: Layer) -> Any:
        ...

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

    @abstractmethod
    def save(
        self,
        sym_filepath: IO | os.PathLike | str,
        compiled_filepath: IO | os.PathLike | str,
    ):
        ...

    @staticmethod
    @abstractmethod
    def load(
        sym_filepath: IO | os.PathLike | str, tens_filepath: IO | os.PathLike | str
    ) -> "AbstractCompiler":
        ...

_compiled_circuits = CompiledCircuitsMap() instance-attribute ¤

_flags = flags instance-attribute ¤

_registry = registry instance-attribute ¤

__init__(registry, **flags) ¤

Source code in cirkit/backend/base.py 
131
132
133
134
def __init__(self, registry: CompilerRegistry, **flags):
    self._registry = registry
    self._flags = flags
    self._compiled_circuits = CompiledCircuitsMap()

add_initializer_rule(func) ¤

Source code in cirkit/backend/base.py 
157
158
def add_initializer_rule(self, func: InitializerCompilationFunc):
    self._registry.add_initializer_rule(func)

add_layer_rule(func) ¤

Source code in cirkit/backend/base.py 
151
152
def add_layer_rule(self, func: LayerCompilationFunc):
    self._registry.add_layer_rule(func)

add_parameter_rule(func) ¤

Source code in cirkit/backend/base.py 
154
155
def add_parameter_rule(self, func: ParameterCompilationFunc):
    self._registry.add_parameter_rule(func)

compile(sc) ¤

Source code in cirkit/backend/base.py 
173
174
175
176
def compile(self, sc: Circuit) -> CompiledCircuit:
    if self.is_compiled(sc):
        return self.get_compiled_circuit(sc)
    return self.compile_pipeline(sc)

compile_layer(sl) abstractmethod ¤

Source code in cirkit/backend/base.py 
178
179
180
@abstractmethod
def compile_layer(self, sl: Layer) -> Any:
    ...

compile_pipeline(sc) abstractmethod ¤

Source code in cirkit/backend/base.py 
182
183
184
@abstractmethod
def compile_pipeline(self, sc: Circuit) -> CompiledCircuit:
    ...

get_compiled_circuit(sc) ¤

Source code in cirkit/backend/base.py 
142
143
def get_compiled_circuit(self, sc: Circuit) -> CompiledCircuit:
    return self._compiled_circuits.get_compiled_circuit(sc)

get_symbolic_circuit(cc) ¤

Source code in cirkit/backend/base.py 
145
146
def get_symbolic_circuit(self, cc: CompiledCircuit) -> Circuit:
    return self._compiled_circuits.get_symbolic_circuit(cc)

has_symbolic(cc) ¤

Source code in cirkit/backend/base.py 
139
140
def has_symbolic(self, cc: CompiledCircuit) -> bool:
    return self._compiled_circuits.has_symbolic(cc)

is_compiled(sc) ¤

Source code in cirkit/backend/base.py 
136
137
def is_compiled(self, sc: Circuit) -> bool:
    return self._compiled_circuits.is_compiled(sc)

load(sym_filepath, tens_filepath) abstractmethod staticmethod ¤

Source code in cirkit/backend/base.py 
194
195
196
197
198
199
@staticmethod
@abstractmethod
def load(
    sym_filepath: IO | os.PathLike | str, tens_filepath: IO | os.PathLike | str
) -> "AbstractCompiler":
    ...

register_compiled_circuit(sc, cc) ¤

Source code in cirkit/backend/base.py 
148
149
def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuit):
    self._compiled_circuits.register_compiled_circuit(sc, cc)

retrieve_initializer_rule(signature) ¤

Source code in cirkit/backend/base.py 
168
169
170
171
def retrieve_initializer_rule(
    self, signature: InitializerCompilationSign
) -> InitializerCompilationFunc:
    return self._registry.retrieve_initializer_rule(signature)

retrieve_layer_rule(signature) ¤

Source code in cirkit/backend/base.py 
160
161
def retrieve_layer_rule(self, signature: LayerCompilationSign) -> LayerCompilationFunc:
    return self._registry.retrieve_layer_rule(signature)

retrieve_parameter_rule(signature) ¤

Source code in cirkit/backend/base.py 
163
164
165
166
def retrieve_parameter_rule(
    self, signature: ParameterCompilationSign
) -> ParameterCompilationFunc:
    return self._registry.retrieve_parameter_rule(signature)

save(sym_filepath, compiled_filepath) abstractmethod ¤

Source code in cirkit/backend/base.py 
186
187
188
189
190
191
192
@abstractmethod
def save(
    self,
    sym_filepath: IO | os.PathLike | str,
    compiled_filepath: IO | os.PathLike | str,
):
    ...

CompilationRuleNotFound ¤

Bases: Exception

Source code in cirkit/backend/base.py 
33
34
35
class CompilationRuleNotFound(Exception):
    def __init__(self, msg: str):
        super().__init__(msg)

__init__(msg) ¤

Source code in cirkit/backend/base.py 
34
35
def __init__(self, msg: str):
    super().__init__(msg)

CompiledCircuitsMap ¤

Source code in cirkit/backend/base.py 
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
class CompiledCircuitsMap:
    def __init__(self):
        self._bimap = BiMap[Circuit, CompiledCircuit]()

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

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

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

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

    def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuit):
        self._bimap.add(sc, cc)

_bimap = BiMap[Circuit, CompiledCircuit]() instance-attribute ¤

__init__() ¤

Source code in cirkit/backend/base.py 
42
43
def __init__(self):
    self._bimap = BiMap[Circuit, CompiledCircuit]()

get_compiled_circuit(sc) ¤

Source code in cirkit/backend/base.py 
51
52
def get_compiled_circuit(self, sc: Circuit) -> CompiledCircuit:
    return self._bimap.get_left(sc)

get_symbolic_circuit(cc) ¤

Source code in cirkit/backend/base.py 
54
55
def get_symbolic_circuit(self, cc: CompiledCircuit) -> Circuit:
    return self._bimap.get_right(cc)

has_symbolic(cc) ¤

Source code in cirkit/backend/base.py 
48
49
def has_symbolic(self, cc: CompiledCircuit) -> bool:
    return self._bimap.has_right(cc)

is_compiled(sc) ¤

Source code in cirkit/backend/base.py 
45
46
def is_compiled(self, sc: Circuit) -> bool:
    return self._bimap.has_left(sc)

register_compiled_circuit(sc, cc) ¤

Source code in cirkit/backend/base.py 
57
58
def register_compiled_circuit(self, sc: Circuit, cc: CompiledCircuit):
    self._bimap.add(sc, cc)

CompilerRegistry ¤

Source code in cirkit/backend/base.py 
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 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
class CompilerRegistry:
    def __init__(
        self,
        layer_rules: dict[LayerCompilationSign, LayerCompilationFunc] | None = None,
        parameter_rules: dict[ParameterCompilationSign, ParameterCompilationFunc] | None = None,
        initializer_rules: None
        | (dict[InitializerCompilationSign, InitializerCompilationFunc]) = None,
    ):
        self._layer_rules = {} if layer_rules is None else layer_rules
        self._parameter_rules = {} if parameter_rules is None else parameter_rules
        self._initializer_rules = {} if initializer_rules is None else initializer_rules

    @staticmethod
    def _validate_rule_sign(func: Callable, sym_cls: type) -> type | None:
        args = func.__annotations__
        if "return" not in args or "compiler" not in args or len(args) != 3:
            return None
        if not issubclass(args["compiler"], AbstractCompiler):
            return None
        arg_names = list(filter(lambda a: a not in ("return", "compiler"), args.keys()))
        found_sym_cls = args[arg_names[0]]
        if not issubclass(found_sym_cls, sym_cls):
            return None
        return found_sym_cls

    def add_layer_rule(self, func: LayerCompilationFunc):
        layer_cls: type[Layer] | None = self._validate_rule_sign(func, Layer)
        if layer_cls is None:
            raise ValueError("The function is not a symbolic layer compilation rule")
        self._layer_rules[layer_cls] = func

    def add_parameter_rule(self, func: ParameterCompilationFunc):
        param_cls: type[ParameterNode] | None = self._validate_rule_sign(func, ParameterNode)
        if param_cls is None:
            raise ValueError("The function is not a symbolic parameter compilation rule")
        self._parameter_rules[param_cls] = func

    def add_initializer_rule(self, func: InitializerCompilationFunc):
        init_cls: type[Initializer] | None = self._validate_rule_sign(func, Initializer)
        if init_cls is None:
            raise ValueError("The function is not a symbolic initializer compilation rule")
        self._initializer_rules[init_cls] = func

    def retrieve_layer_rule(self, signature: LayerCompilationSign) -> LayerCompilationFunc:
        if signature not in self._layer_rules:
            raise CompilationRuleNotFound(
                f"Layer compilation rule for signature '{signature}' not found"
            )
        return self._layer_rules[signature]

    def retrieve_parameter_rule(
        self, signature: ParameterCompilationSign
    ) -> ParameterCompilationFunc:
        if signature not in self._parameter_rules:
            raise CompilationRuleNotFound(
                f"Parameter compilation rule for signature '{signature}' not found"
            )
        return self._parameter_rules[signature]

    def retrieve_initializer_rule(
        self, signature: InitializerCompilationSign
    ) -> InitializerCompilationFunc:
        if signature not in self._initializer_rules:
            raise CompilationRuleNotFound(
                f"Initializer compilation rule for signature '{signature}' not found"
            )
        return self._initializer_rules[signature]

_initializer_rules = {} if initializer_rules is None else initializer_rules instance-attribute ¤

_layer_rules = {} if layer_rules is None else layer_rules instance-attribute ¤

_parameter_rules = {} if parameter_rules is None else parameter_rules instance-attribute ¤

__init__(layer_rules=None, parameter_rules=None, initializer_rules=None) ¤

Source code in cirkit/backend/base.py 
62
63
64
65
66
67
68
69
70
71
def __init__(
    self,
    layer_rules: dict[LayerCompilationSign, LayerCompilationFunc] | None = None,
    parameter_rules: dict[ParameterCompilationSign, ParameterCompilationFunc] | None = None,
    initializer_rules: None
    | (dict[InitializerCompilationSign, InitializerCompilationFunc]) = None,
):
    self._layer_rules = {} if layer_rules is None else layer_rules
    self._parameter_rules = {} if parameter_rules is None else parameter_rules
    self._initializer_rules = {} if initializer_rules is None else initializer_rules

_validate_rule_sign(func, sym_cls) staticmethod ¤

Source code in cirkit/backend/base.py 
73
74
75
76
77
78
79
80
81
82
83
84
@staticmethod
def _validate_rule_sign(func: Callable, sym_cls: type) -> type | None:
    args = func.__annotations__
    if "return" not in args or "compiler" not in args or len(args) != 3:
        return None
    if not issubclass(args["compiler"], AbstractCompiler):
        return None
    arg_names = list(filter(lambda a: a not in ("return", "compiler"), args.keys()))
    found_sym_cls = args[arg_names[0]]
    if not issubclass(found_sym_cls, sym_cls):
        return None
    return found_sym_cls

add_initializer_rule(func) ¤

Source code in cirkit/backend/base.py 
 98
 99
100
101
102
def add_initializer_rule(self, func: InitializerCompilationFunc):
    init_cls: type[Initializer] | None = self._validate_rule_sign(func, Initializer)
    if init_cls is None:
        raise ValueError("The function is not a symbolic initializer compilation rule")
    self._initializer_rules[init_cls] = func

add_layer_rule(func) ¤

Source code in cirkit/backend/base.py 
86
87
88
89
90
def add_layer_rule(self, func: LayerCompilationFunc):
    layer_cls: type[Layer] | None = self._validate_rule_sign(func, Layer)
    if layer_cls is None:
        raise ValueError("The function is not a symbolic layer compilation rule")
    self._layer_rules[layer_cls] = func

add_parameter_rule(func) ¤

Source code in cirkit/backend/base.py 
92
93
94
95
96
def add_parameter_rule(self, func: ParameterCompilationFunc):
    param_cls: type[ParameterNode] | None = self._validate_rule_sign(func, ParameterNode)
    if param_cls is None:
        raise ValueError("The function is not a symbolic parameter compilation rule")
    self._parameter_rules[param_cls] = func

retrieve_initializer_rule(signature) ¤

Source code in cirkit/backend/base.py 
120
121
122
123
124
125
126
127
def retrieve_initializer_rule(
    self, signature: InitializerCompilationSign
) -> InitializerCompilationFunc:
    if signature not in self._initializer_rules:
        raise CompilationRuleNotFound(
            f"Initializer compilation rule for signature '{signature}' not found"
        )
    return self._initializer_rules[signature]

retrieve_layer_rule(signature) ¤

Source code in cirkit/backend/base.py 
104
105
106
107
108
109
def retrieve_layer_rule(self, signature: LayerCompilationSign) -> LayerCompilationFunc:
    if signature not in self._layer_rules:
        raise CompilationRuleNotFound(
            f"Layer compilation rule for signature '{signature}' not found"
        )
    return self._layer_rules[signature]

retrieve_parameter_rule(signature) ¤

Source code in cirkit/backend/base.py 
111
112
113
114
115
116
117
118
def retrieve_parameter_rule(
    self, signature: ParameterCompilationSign
) -> ParameterCompilationFunc:
    if signature not in self._parameter_rules:
        raise CompilationRuleNotFound(
            f"Parameter compilation rule for signature '{signature}' not found"
        )
    return self._parameter_rules[signature]

InitializerCompilationFunc ¤

Bases: Protocol

Source code in cirkit/backend/base.py 
28
29
30
class InitializerCompilationFunc(Protocol):
    def __call__(self, compiler: "AbstractCompiler", init: Initializer, **kwargs) -> Any:
        ...

__call__(compiler, init, **kwargs) ¤

Source code in cirkit/backend/base.py 
29
30
def __call__(self, compiler: "AbstractCompiler", init: Initializer, **kwargs) -> Any:
    ...

LayerCompilationFunc ¤

Bases: Protocol

Source code in cirkit/backend/base.py 
18
19
20
class LayerCompilationFunc(Protocol):
    def __call__(self, compiler: "AbstractCompiler", sl: Layer, **kwargs) -> Any:
        ...

__call__(compiler, sl, **kwargs) ¤

Source code in cirkit/backend/base.py 
19
20
def __call__(self, compiler: "AbstractCompiler", sl: Layer, **kwargs) -> Any:
    ...

ParameterCompilationFunc ¤

Bases: Protocol

Source code in cirkit/backend/base.py 
23
24
25
class ParameterCompilationFunc(Protocol):
    def __call__(self, compiler: "AbstractCompiler", p: ParameterNode, **kwargs) -> Any:
        ...

__call__(compiler, p, **kwargs) ¤

Source code in cirkit/backend/base.py 
24
25
def __call__(self, compiler: "AbstractCompiler", p: ParameterNode, **kwargs) -> Any:
    ...