QuPRS 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- QuPRS/__init__.py +12 -0
- QuPRS/_version.py +21 -0
- QuPRS/cache_manager/__init__.py +5 -0
- QuPRS/cache_manager/cache_decorator.py +18 -0
- QuPRS/cache_manager/global_cache_manager.py +24 -0
- QuPRS/config.py +14 -0
- QuPRS/interface/__init__.py +0 -0
- QuPRS/interface/gate_library.py +26 -0
- QuPRS/interface/load_qiskit.py +225 -0
- QuPRS/interface/ps2wmc.py +252 -0
- QuPRS/interface/qasm2qc.py +68 -0
- QuPRS/pathsum.py +664 -0
- QuPRS/utils/Qiskit_Circuit_Utils.py +471 -0
- QuPRS/utils/__init__.py +6 -0
- QuPRS/utils/gpmc +0 -0
- QuPRS/utils/reduction.py +104 -0
- QuPRS/utils/strategy.py +176 -0
- QuPRS/utils/util.py +184 -0
- quprs-0.1.0.dist-info/METADATA +215 -0
- quprs-0.1.0.dist-info/RECORD +24 -0
- quprs-0.1.0.dist-info/WHEEL +5 -0
- quprs-0.1.0.dist-info/licenses/LICENSE.md +10 -0
- quprs-0.1.0.dist-info/licenses/NOTICE.md +228 -0
- quprs-0.1.0.dist-info/top_level.txt +1 -0
QuPRS/pathsum.py
ADDED
|
@@ -0,0 +1,664 @@
|
|
|
1
|
+
import symengine as se
|
|
2
|
+
import sympy as sp
|
|
3
|
+
import math
|
|
4
|
+
from sympy.logic.boolalg import to_anf
|
|
5
|
+
from QuPRS.utils.util import logical_to_algebraic, reduce_expression, div_pi, find_new_variables
|
|
6
|
+
from QuPRS.utils.reduction import match_Elim, match_HH, match_omega, HH_reduction, omega_reduction
|
|
7
|
+
from QuPRS.cache_manager import cache_manager
|
|
8
|
+
from QuPRS import config
|
|
9
|
+
|
|
10
|
+
class Register:
|
|
11
|
+
def __init__(self, size: int | None = None, name: str | None = None, bits=None) -> None:
|
|
12
|
+
if bits is not None:
|
|
13
|
+
size = len(bits)
|
|
14
|
+
if name is None:
|
|
15
|
+
name = 'x'
|
|
16
|
+
else:
|
|
17
|
+
name = name
|
|
18
|
+
self._name = name
|
|
19
|
+
self._size = size
|
|
20
|
+
self._repr = f'{self.__class__.__name__}(name={self.name}, size={self.size})'
|
|
21
|
+
self._bits = tuple(bits) if bits is not None else tuple(se.symbols(f'{name}_:{size}'))
|
|
22
|
+
|
|
23
|
+
def __repr__(self) -> str:
|
|
24
|
+
return self._repr
|
|
25
|
+
|
|
26
|
+
@property
|
|
27
|
+
def name(self) -> str:
|
|
28
|
+
return self._name
|
|
29
|
+
|
|
30
|
+
@property
|
|
31
|
+
def size(self) -> int:
|
|
32
|
+
return self._size
|
|
33
|
+
|
|
34
|
+
def __len__(self):
|
|
35
|
+
"""Return register size."""
|
|
36
|
+
return self._size
|
|
37
|
+
|
|
38
|
+
def __getitem__(self, key: int):
|
|
39
|
+
"""Return a bit from the register."""
|
|
40
|
+
return self._bits[key]
|
|
41
|
+
|
|
42
|
+
class F:
|
|
43
|
+
def __init__(self, *regs, data=None, bits=None) -> None:
|
|
44
|
+
self._regs = tuple(regs)
|
|
45
|
+
self._bits = tuple(bits) if bits is not None else list()
|
|
46
|
+
self._data = data if data is not None else dict()
|
|
47
|
+
if data is None:
|
|
48
|
+
for reg in regs:
|
|
49
|
+
for item in reg:
|
|
50
|
+
self._data[item.name] = item
|
|
51
|
+
self._bits.append(item.name)
|
|
52
|
+
self._bits = tuple(self._bits)
|
|
53
|
+
self._data = self._data
|
|
54
|
+
def __repr__(self) -> str:
|
|
55
|
+
repr_data = {self.bits[i]: 1 if isinstance(item, sp.logic.boolalg.BooleanTrue) else 0 if isinstance(item, sp.logic.boolalg.BooleanFalse) else item for i, item in enumerate(self)}
|
|
56
|
+
return f'{self.__class__.__name__}(data={repr_data}, regs={self.regs})'
|
|
57
|
+
|
|
58
|
+
def __hash__(self) -> int:
|
|
59
|
+
return hash(self.data)
|
|
60
|
+
|
|
61
|
+
def __eq__(self, other: object) -> bool:
|
|
62
|
+
if not isinstance(other, F):
|
|
63
|
+
return False
|
|
64
|
+
return self.data == other.data
|
|
65
|
+
|
|
66
|
+
@property
|
|
67
|
+
def regs(self):
|
|
68
|
+
return self._regs
|
|
69
|
+
|
|
70
|
+
@property
|
|
71
|
+
def bits(self):
|
|
72
|
+
return self._bits
|
|
73
|
+
|
|
74
|
+
@property
|
|
75
|
+
def data(self):
|
|
76
|
+
return self._data
|
|
77
|
+
|
|
78
|
+
def __len__(self):
|
|
79
|
+
return len(self._bits)
|
|
80
|
+
|
|
81
|
+
def __getitem__(self, key: int | se.Symbol | str):
|
|
82
|
+
key_name = self._bits[key] if isinstance(key, int) else key.name if isinstance(key, se.Symbol) else key
|
|
83
|
+
return self.data[key_name]
|
|
84
|
+
|
|
85
|
+
def sub(self, arg1, arg2):
|
|
86
|
+
new_data = {key: to_anf(sp.sympify(value).subs(arg1, arg2)) for key, value in self.data.items()}
|
|
87
|
+
self = self.update_data(new_data)
|
|
88
|
+
return self
|
|
89
|
+
def update(self, key: int | se.Symbol | str, value):
|
|
90
|
+
key_name = self._bits[key] if isinstance(key, int) else key.name if isinstance(key, se.Symbol) else key
|
|
91
|
+
new_data = dict(self.data)
|
|
92
|
+
new_data[key_name] = value
|
|
93
|
+
return F(*self.regs, data=new_data, bits=self.bits)
|
|
94
|
+
|
|
95
|
+
def update_data(self, data):
|
|
96
|
+
return F(*self.regs, data=data, bits=self.bits)
|
|
97
|
+
|
|
98
|
+
def items(self):
|
|
99
|
+
return self.data.items()
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
class PathSum:
|
|
103
|
+
reduction_counts = {
|
|
104
|
+
'total': 0,
|
|
105
|
+
'Elim': 0,
|
|
106
|
+
'HH': 0,
|
|
107
|
+
'omega': 0,
|
|
108
|
+
}
|
|
109
|
+
_reduction_enabled = True
|
|
110
|
+
|
|
111
|
+
def __init__(self, P: se.Expr, f: F, pathvar: frozenset | set = frozenset()) -> None:
|
|
112
|
+
self._P = P
|
|
113
|
+
self._f = f
|
|
114
|
+
self._pathvar = frozenset(pathvar) if isinstance(pathvar, set) else pathvar
|
|
115
|
+
self._num_qubits = len(f)
|
|
116
|
+
|
|
117
|
+
def __repr__(self) -> str:
|
|
118
|
+
return f'P:{self.P}\nf: {self.f}\npathvar: {self.pathvar}'
|
|
119
|
+
|
|
120
|
+
def __hash__(self) -> int:
|
|
121
|
+
return hash((self.P, self.f, self.pathvar))
|
|
122
|
+
|
|
123
|
+
def __eq__(self, other: object) -> bool:
|
|
124
|
+
return (self.P == other.P) and (self.f == other.f) and (self.pathvar == other.pathvar)
|
|
125
|
+
|
|
126
|
+
@property
|
|
127
|
+
def regs(self):
|
|
128
|
+
return self.f.regs
|
|
129
|
+
|
|
130
|
+
@property
|
|
131
|
+
def bits(self):
|
|
132
|
+
return self.f.bits
|
|
133
|
+
|
|
134
|
+
@property
|
|
135
|
+
def P(self) -> se.Expr:
|
|
136
|
+
return self._P
|
|
137
|
+
|
|
138
|
+
@property
|
|
139
|
+
def f(self):
|
|
140
|
+
return self._f
|
|
141
|
+
|
|
142
|
+
@property
|
|
143
|
+
def pathvar(self):
|
|
144
|
+
return self._pathvar
|
|
145
|
+
|
|
146
|
+
@property
|
|
147
|
+
def num_qubits(self) -> int:
|
|
148
|
+
'''return the number of qubits'''
|
|
149
|
+
return self._num_qubits
|
|
150
|
+
|
|
151
|
+
@property
|
|
152
|
+
def num_pathvar(self) -> int:
|
|
153
|
+
'''return the number of pathvar'''
|
|
154
|
+
return len(self.pathvar)
|
|
155
|
+
|
|
156
|
+
@classmethod
|
|
157
|
+
def get_reduction_counts(cls):
|
|
158
|
+
return cls.reduction_counts.copy()
|
|
159
|
+
@classmethod
|
|
160
|
+
def get_reduction_count(cls, key: str):
|
|
161
|
+
return cls.reduction_counts.get(key, 0)
|
|
162
|
+
@classmethod
|
|
163
|
+
def get_reduction_hitrate(cls):
|
|
164
|
+
total = cls.reduction_counts['total']
|
|
165
|
+
if total == 0:
|
|
166
|
+
return 1
|
|
167
|
+
else:
|
|
168
|
+
hit = 0
|
|
169
|
+
for key, value in cls.reduction_counts.items():
|
|
170
|
+
if key == 'total':
|
|
171
|
+
continue
|
|
172
|
+
hit += value
|
|
173
|
+
return hit / total
|
|
174
|
+
@classmethod
|
|
175
|
+
def reset_reduction_counts(cls):
|
|
176
|
+
for key in cls.reduction_counts:
|
|
177
|
+
cls.reduction_counts[key] = 0
|
|
178
|
+
@classmethod
|
|
179
|
+
def set_reduction_switch(cls, value: bool) -> None:
|
|
180
|
+
cls._reduction_enabled = value
|
|
181
|
+
@classmethod
|
|
182
|
+
def is_reduction_enabled(cls) -> bool:
|
|
183
|
+
return cls._reduction_enabled
|
|
184
|
+
@staticmethod
|
|
185
|
+
def QuantumCircuit(*regs: Register | int, initial_state: bool | list | tuple = None) -> 'PathSum':
|
|
186
|
+
'''initialize'''
|
|
187
|
+
cache_manager.clear_all_caches()
|
|
188
|
+
P = se.S.Zero
|
|
189
|
+
if len(regs) == 1 and isinstance(*regs, int):
|
|
190
|
+
regs = [Register(*regs)]
|
|
191
|
+
f = F(*regs)
|
|
192
|
+
if initial_state is not None:
|
|
193
|
+
f_data = {f.bits[i]: to_anf(initial_state[i]) for i in range(len(f))}
|
|
194
|
+
f = f.update_data(f_data)
|
|
195
|
+
PathSum.reset_reduction_counts()
|
|
196
|
+
return PathSum(P, f)
|
|
197
|
+
|
|
198
|
+
@staticmethod
|
|
199
|
+
def load_from_qasm_file(filename: str, initial_state: bool | list | tuple = None):
|
|
200
|
+
'''load a PathSum item from qasm file'''
|
|
201
|
+
from qiskit import qasm2, qasm3
|
|
202
|
+
from QuPRS.interface.load_qiskit import build_circuit
|
|
203
|
+
with open(filename, 'r') as f:
|
|
204
|
+
data = f.read()
|
|
205
|
+
qiskit_circuit = qasm3.load(filename) if 'OPENQASM 3.0' in data else qasm2.load(filename)
|
|
206
|
+
return build_circuit(qiskit_circuit, initial_state)
|
|
207
|
+
|
|
208
|
+
@staticmethod
|
|
209
|
+
def load_from_qasm_str(program: str, initial_state: bool | list | tuple = None):
|
|
210
|
+
'''load a PathSum item from qasm str'''
|
|
211
|
+
from qiskit import qasm2, qasm3
|
|
212
|
+
from QuPRS.interface.load_qiskit import build_circuit
|
|
213
|
+
qiskit_circuit = qasm3.loads(program) if 'OPENQASM 3.0' in program else qasm2.loads(program)
|
|
214
|
+
return build_circuit(qiskit_circuit, initial_state)
|
|
215
|
+
|
|
216
|
+
# Apply H gate
|
|
217
|
+
def h(self, qubit: int | str, is_bra: bool = False) -> 'PathSum':
|
|
218
|
+
# index = 0
|
|
219
|
+
# while se.Symbol(f'y_{index}') in self.pathvar:
|
|
220
|
+
# index += 1
|
|
221
|
+
# new_var = se.Symbol(f'y_{index}')
|
|
222
|
+
new_var = find_new_variables(self.pathvar)[0]
|
|
223
|
+
if not is_bra:
|
|
224
|
+
x_i = logical_to_algebraic(self.f[qubit], 1)
|
|
225
|
+
new_P = self.P + se.Rational(1, 2) * new_var * x_i
|
|
226
|
+
new_f = self.f.update(qubit, new_var)
|
|
227
|
+
else:
|
|
228
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
229
|
+
new_P = self.P.subs(x_i, new_var) + se.Rational(1, 2) * new_var * x_i
|
|
230
|
+
new_f = self.f.sub(x_i, logical_to_algebraic(new_var))
|
|
231
|
+
new_pathvar = frozenset(set(self.pathvar).union({new_var}))
|
|
232
|
+
new_pathsum = PathSum(new_P, new_f, new_pathvar).reduction()
|
|
233
|
+
return new_pathsum
|
|
234
|
+
|
|
235
|
+
# Apply X gate
|
|
236
|
+
def x(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
237
|
+
if not is_bra:
|
|
238
|
+
new_P = self.P
|
|
239
|
+
new_f = self.f.update(qubit, to_anf(sp.Not(self.f[qubit])))
|
|
240
|
+
else:
|
|
241
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
242
|
+
new_P = self.P.subs(x_i, 1 - x_i)
|
|
243
|
+
new_f = self.f.sub(x_i, sp.Not(x_i))
|
|
244
|
+
new_P = reduce_expression(new_P)
|
|
245
|
+
return PathSum(new_P, new_f, self.pathvar)
|
|
246
|
+
|
|
247
|
+
# Apply Y gate
|
|
248
|
+
def y(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
249
|
+
if not is_bra:
|
|
250
|
+
x_i = logical_to_algebraic(self.f[qubit], 1)
|
|
251
|
+
new_P = (self.P + se.Rational(3, 4) + se.Rational(1, 2) * x_i).expand()
|
|
252
|
+
new_f = self.f.update(qubit, to_anf(sp.Not(self.f[qubit])))
|
|
253
|
+
else:
|
|
254
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
255
|
+
new_P = (self.P.subs(x_i, 1 - x_i) + se.Rational(3, 4) + se.Rational(1, 2) * x_i).expand()
|
|
256
|
+
new_f = self.f.sub(x_i, sp.Not(x_i))
|
|
257
|
+
new_P = reduce_expression(new_P)
|
|
258
|
+
return PathSum(new_P, new_f, self.pathvar)
|
|
259
|
+
|
|
260
|
+
# Apply Z gate
|
|
261
|
+
def z(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
262
|
+
if not is_bra:
|
|
263
|
+
x_i = logical_to_algebraic(self.f[qubit], 1)
|
|
264
|
+
new_P = (self.P + se.Rational(1, 2) * x_i).expand()
|
|
265
|
+
else:
|
|
266
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
267
|
+
new_P = (self.P + se.Rational(1, 2) * x_i).expand()
|
|
268
|
+
new_P = reduce_expression(new_P)
|
|
269
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
270
|
+
|
|
271
|
+
# Apply S gate
|
|
272
|
+
def s(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
273
|
+
if not is_bra:
|
|
274
|
+
x_i = logical_to_algebraic(self.f[qubit], 2)
|
|
275
|
+
new_P = (self.P + se.Rational(1, 4) * x_i).expand()
|
|
276
|
+
else:
|
|
277
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
278
|
+
new_P = (self.P + se.Rational(-1, 4) * x_i).expand()
|
|
279
|
+
new_P = reduce_expression(new_P)
|
|
280
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
281
|
+
|
|
282
|
+
# Apply Sdg gate
|
|
283
|
+
def sdg(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
284
|
+
if not is_bra:
|
|
285
|
+
x_i = logical_to_algebraic(self.f[qubit], 2)
|
|
286
|
+
new_P = (self.P + se.Rational(-1, 4) * x_i).expand()
|
|
287
|
+
else:
|
|
288
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
289
|
+
new_P = (self.P + se.Rational(1, 4) * x_i).expand()
|
|
290
|
+
new_P = reduce_expression(new_P)
|
|
291
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
292
|
+
|
|
293
|
+
# Apply T gate
|
|
294
|
+
def t(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
295
|
+
if not is_bra:
|
|
296
|
+
x_i = logical_to_algebraic(self.f[qubit], 3)
|
|
297
|
+
new_P = (self.P + se.Rational(1, 8) * x_i).expand()
|
|
298
|
+
else:
|
|
299
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
300
|
+
new_P = (self.P + se.Rational(-1, 8) * x_i).expand()
|
|
301
|
+
new_P = reduce_expression(new_P)
|
|
302
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
303
|
+
|
|
304
|
+
# Apply Tdg gate
|
|
305
|
+
def tdg(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
306
|
+
if not is_bra:
|
|
307
|
+
x_i = logical_to_algebraic(self.f[qubit], 3)
|
|
308
|
+
new_P = (self.P + se.Rational(-1, 8) * x_i).expand()
|
|
309
|
+
else:
|
|
310
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
311
|
+
new_P = self.P + se.Rational(1, 8) * x_i
|
|
312
|
+
new_P = reduce_expression(new_P)
|
|
313
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
314
|
+
|
|
315
|
+
# Apply Sx gate
|
|
316
|
+
def sx(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
317
|
+
self = self.rx(se.pi / 2, qubit, is_bra)
|
|
318
|
+
new_P = self.P + se.Rational(1, 8) if not is_bra else self.P - se.Rational(1, 8)
|
|
319
|
+
new_P = reduce_expression(new_P)
|
|
320
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
321
|
+
|
|
322
|
+
# Apply Sxdg gate
|
|
323
|
+
def sxdg(self, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
324
|
+
self = self.rx(-se.pi / 2, qubit, is_bra)
|
|
325
|
+
new_P = self.P - se.Rational(1, 8) if not is_bra else self.P + se.Rational(1, 8)
|
|
326
|
+
new_P = reduce_expression(new_P)
|
|
327
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
328
|
+
|
|
329
|
+
# Apply P gate
|
|
330
|
+
def p(self, theta, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
331
|
+
theta = div_pi(theta)
|
|
332
|
+
if not is_bra:
|
|
333
|
+
if theta.is_number:
|
|
334
|
+
max_order = math.log2(theta.as_numer_denom()[1])
|
|
335
|
+
max_order = int(max_order) + 1 if int(max_order) == max_order else None
|
|
336
|
+
else:
|
|
337
|
+
max_order = None
|
|
338
|
+
x_i = logical_to_algebraic(self.f[qubit], max_order=max_order)
|
|
339
|
+
new_P = self.P + se.Rational(1, 2) * theta * x_i
|
|
340
|
+
else:
|
|
341
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
342
|
+
new_P = self.P - se.Rational(1, 2) * theta * x_i
|
|
343
|
+
new_P = reduce_expression(new_P)
|
|
344
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
345
|
+
|
|
346
|
+
# Apply Rz gate
|
|
347
|
+
def rz(self, theta, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
348
|
+
theta = div_pi(theta)
|
|
349
|
+
if not is_bra:
|
|
350
|
+
if theta.is_number:
|
|
351
|
+
max_order = math.log2(theta.as_numer_denom()[1])
|
|
352
|
+
max_order = int(max_order) + 2 if int(max_order) == max_order else None
|
|
353
|
+
else:
|
|
354
|
+
max_order = None
|
|
355
|
+
x_i = logical_to_algebraic(self.f[qubit], max_order=max_order)
|
|
356
|
+
new_P = self.P + se.Rational(1, 4) * (-theta + 2 * theta * x_i)
|
|
357
|
+
else:
|
|
358
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
359
|
+
new_P = self.P + se.Rational(1, 4) * (theta - 2 * theta * x_i)
|
|
360
|
+
new_P = reduce_expression(new_P)
|
|
361
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
362
|
+
|
|
363
|
+
# Apply Rx gate
|
|
364
|
+
def rx(self, theta, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
365
|
+
return self.u(theta, -se.pi / 2, se.pi / 2, qubit, is_bra)
|
|
366
|
+
|
|
367
|
+
# Apply Ry gate
|
|
368
|
+
def ry(self, theta, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
369
|
+
return self.u(theta, 0, 0, qubit, is_bra)
|
|
370
|
+
|
|
371
|
+
# Apply U gate
|
|
372
|
+
def u(self, theta, phi, lam, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
373
|
+
theta, phi, lam = map(div_pi, [theta, phi, lam])
|
|
374
|
+
new_vars = find_new_variables(self.pathvar, 2)
|
|
375
|
+
if not is_bra:
|
|
376
|
+
if lam.is_number:
|
|
377
|
+
max_order = math.log2(lam.as_numer_denom()[1])
|
|
378
|
+
max_order = int(max_order) +1 if int(max_order) == max_order else None
|
|
379
|
+
else:
|
|
380
|
+
max_order = None
|
|
381
|
+
x_i_lam = logical_to_algebraic(self.f[qubit], max_order=max_order)
|
|
382
|
+
x_i = logical_to_algebraic(self.f[qubit], max_order=2 )
|
|
383
|
+
new_P = self.P + se.Rational(1, 2) * lam * x_i_lam + \
|
|
384
|
+
se.Rational(1, 2) * phi * new_vars[1] + \
|
|
385
|
+
se.Rational(1, 4) * theta * (2 * new_vars[0] - 1) + \
|
|
386
|
+
se.Rational(3, 4) * x_i + \
|
|
387
|
+
se.Rational(1, 4) * new_vars[1] + \
|
|
388
|
+
se.Rational(1, 2) * x_i * new_vars[0] + \
|
|
389
|
+
se.Rational(1, 2) * new_vars[0] * new_vars[1]
|
|
390
|
+
new_f = self.f.update(qubit, new_vars[1])
|
|
391
|
+
else:
|
|
392
|
+
x_i = se.symbols(f'{self.bits[qubit]}' if isinstance(qubit, int) else str(qubit))
|
|
393
|
+
new_P = self.P.subs(x_i, new_vars[1]) + \
|
|
394
|
+
se.Rational(-1, 2) * phi * x_i + \
|
|
395
|
+
se.Rational(-1, 2) * lam * new_vars[1] + \
|
|
396
|
+
se.Rational(1, 4) * theta * (2 * new_vars[0] - 1) + \
|
|
397
|
+
se.Rational(1, 4) * x_i + \
|
|
398
|
+
se.Rational(3, 4) * new_vars[1] + \
|
|
399
|
+
se.Rational(1, 2) * x_i * new_vars[0] + \
|
|
400
|
+
se.Rational(1, 2) * new_vars[0] * new_vars[1]
|
|
401
|
+
new_f = self.f.sub(x_i, logical_to_algebraic(new_vars[1]))
|
|
402
|
+
new_pathvar = frozenset(set(self.pathvar).union(new_vars))
|
|
403
|
+
new_pathsum = PathSum(new_P, new_f, new_pathvar)
|
|
404
|
+
new_pathsum = new_pathsum.reduction()
|
|
405
|
+
return new_pathsum
|
|
406
|
+
|
|
407
|
+
def u1(self, theta, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
408
|
+
return self.p(theta, qubit, is_bra)
|
|
409
|
+
|
|
410
|
+
def u2(self, phi, lam, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
411
|
+
return self.u(se.Rational(1, 2) * se.pi, phi, lam, qubit, is_bra)
|
|
412
|
+
|
|
413
|
+
def u3(self, theta, phi, lam, qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
414
|
+
return self.u(theta, phi, lam, qubit, is_bra)
|
|
415
|
+
|
|
416
|
+
# Apply CX gate
|
|
417
|
+
def cx(self, control_qubit: int | str | se.Symbol, target_qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
418
|
+
if not is_bra:
|
|
419
|
+
new_f = self.f.update(target_qubit, to_anf(sp.Xor(self.f[control_qubit], self.f[target_qubit])))
|
|
420
|
+
return PathSum(self.P, new_f, self.pathvar)
|
|
421
|
+
else:
|
|
422
|
+
x_i = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
423
|
+
x_j = se.symbols(f'{self.bits[control_qubit]}' if isinstance(control_qubit, int) else str(control_qubit))
|
|
424
|
+
new_var = sp.Xor(x_i, x_j)
|
|
425
|
+
update_var = logical_to_algebraic(new_var)
|
|
426
|
+
new_P = self.P.subs(x_i, update_var)
|
|
427
|
+
new_P = reduce_expression(new_P)
|
|
428
|
+
new_f = self.f.sub(x_i, new_var)
|
|
429
|
+
return PathSum(new_P, new_f, self.pathvar)
|
|
430
|
+
|
|
431
|
+
# Apply CH gate
|
|
432
|
+
def ch(self, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
433
|
+
new_pathsum = self.s(target_qubit, is_bra)
|
|
434
|
+
new_pathsum = new_pathsum.h(target_qubit, is_bra)
|
|
435
|
+
new_pathsum = new_pathsum.t(target_qubit, is_bra)
|
|
436
|
+
new_pathsum = new_pathsum.cx(control_qubit, target_qubit, is_bra)
|
|
437
|
+
new_pathsum = new_pathsum.tdg(target_qubit, is_bra)
|
|
438
|
+
new_pathsum = new_pathsum.h(target_qubit, is_bra)
|
|
439
|
+
new_pathsum = new_pathsum.sdg(target_qubit, is_bra)
|
|
440
|
+
return new_pathsum
|
|
441
|
+
|
|
442
|
+
# Apply CZ gate
|
|
443
|
+
def cz(self, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
444
|
+
if not is_bra:
|
|
445
|
+
x_i = logical_to_algebraic(self.f[control_qubit], 1)
|
|
446
|
+
x_j = logical_to_algebraic(self.f[target_qubit], 1)
|
|
447
|
+
new_P = self.P + se.Rational(1, 2) * x_i * x_j
|
|
448
|
+
else:
|
|
449
|
+
x_i = se.symbols(f'{self.bits[control_qubit]}' if isinstance(control_qubit, int) else str(control_qubit))
|
|
450
|
+
x_j = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
451
|
+
new_P = self.P + se.Rational(1, 2) * x_i * x_j
|
|
452
|
+
new_P = reduce_expression(new_P)
|
|
453
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
454
|
+
|
|
455
|
+
# Apply CRk gate
|
|
456
|
+
def CRk(self, k: int, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
457
|
+
if not is_bra:
|
|
458
|
+
x_i = logical_to_algebraic(self.f[control_qubit], k)
|
|
459
|
+
x_j = logical_to_algebraic(self.f[target_qubit], k)
|
|
460
|
+
new_P = self.P + se.Rational(1, 2**k) * x_i * x_j
|
|
461
|
+
else:
|
|
462
|
+
x_i = se.symbols(f'{self.bits[control_qubit]}' if isinstance(control_qubit, int) else str(control_qubit))
|
|
463
|
+
x_j = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
464
|
+
new_P = self.P + se.Rational(-1, 2**k) * x_i * x_j
|
|
465
|
+
new_P = reduce_expression(new_P)
|
|
466
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
467
|
+
|
|
468
|
+
# Apply CRk dagger gate
|
|
469
|
+
def CRkdg(self, k: int, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
470
|
+
if not is_bra:
|
|
471
|
+
x_i = logical_to_algebraic(self.f[control_qubit], k)
|
|
472
|
+
x_j = logical_to_algebraic(self.f[target_qubit], k)
|
|
473
|
+
new_P = self.P + se.Rational(-1, 2**k) * x_i * x_j
|
|
474
|
+
else:
|
|
475
|
+
x_i = se.symbols(f'{self.bits[control_qubit]}' if isinstance(control_qubit, int) else str(control_qubit))
|
|
476
|
+
x_j = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
477
|
+
new_P = self.P + se.Rational(1, 2**k) * x_i * x_j
|
|
478
|
+
new_P = reduce_expression(new_P)
|
|
479
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
480
|
+
|
|
481
|
+
# Apply CRZ gate
|
|
482
|
+
def crz(self, theta, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
483
|
+
theta = div_pi(theta)
|
|
484
|
+
if not is_bra:
|
|
485
|
+
if theta.is_number:
|
|
486
|
+
max_order = math.log2(theta.as_numer_denom()[1])
|
|
487
|
+
max_order = int(max_order) +2 if int(max_order) == max_order else None
|
|
488
|
+
else:
|
|
489
|
+
max_order = None
|
|
490
|
+
x_i = logical_to_algebraic(self.f[control_qubit], max_order=max_order)
|
|
491
|
+
x_j = logical_to_algebraic(self.f[target_qubit], max_order=max_order)
|
|
492
|
+
new_P = self.P + se.Rational(1, 4) * x_i * (-theta + 2 * theta * x_j)
|
|
493
|
+
else:
|
|
494
|
+
x_i = se.symbols(f'{self.bits[control_qubit]}' if isinstance(control_qubit, int) else str(control_qubit))
|
|
495
|
+
x_j = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
496
|
+
new_P = self.P + se.Rational(1, 4) * x_i * (theta - 2 * theta * x_j)
|
|
497
|
+
new_P = reduce_expression(new_P)
|
|
498
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
499
|
+
|
|
500
|
+
# Apply CRY gate
|
|
501
|
+
def cry(self, theta, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
502
|
+
|
|
503
|
+
# angle = se.pi / 2
|
|
504
|
+
# new_pathsum = self.crz(-angle, control_qubit, target_qubit, is_bra)
|
|
505
|
+
# new_pathsum = new_pathsum.crx(theta, control_qubit, target_qubit, is_bra)
|
|
506
|
+
# new_pathsum = new_pathsum.crz(angle, control_qubit, target_qubit, is_bra)
|
|
507
|
+
# print('0',self)
|
|
508
|
+
new_pathsum = self.ry(theta/2, target_qubit, is_bra)
|
|
509
|
+
new_pathsum = new_pathsum.cx(control_qubit, target_qubit, is_bra)
|
|
510
|
+
new_pathsum = new_pathsum.ry(-theta/2, target_qubit, is_bra)
|
|
511
|
+
new_pathsum = new_pathsum.cx(control_qubit, target_qubit, is_bra)
|
|
512
|
+
return new_pathsum
|
|
513
|
+
|
|
514
|
+
# Apply CRX gate
|
|
515
|
+
def crx(self, theta, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
516
|
+
new_pathsum = self.h(target_qubit, is_bra)
|
|
517
|
+
new_pathsum = new_pathsum.crz(theta, control_qubit, target_qubit, is_bra)
|
|
518
|
+
new_pathsum = new_pathsum.h(target_qubit, is_bra)
|
|
519
|
+
return new_pathsum
|
|
520
|
+
|
|
521
|
+
# Apply CP gate
|
|
522
|
+
def cp(self, theta, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
523
|
+
theta = div_pi(theta)
|
|
524
|
+
if not is_bra:
|
|
525
|
+
if theta.is_number:
|
|
526
|
+
max_order = math.log2(theta.as_numer_denom()[1])
|
|
527
|
+
max_order = int(max_order) +1 if int(max_order) == max_order else None
|
|
528
|
+
else:
|
|
529
|
+
max_order = None
|
|
530
|
+
x_i = logical_to_algebraic(self.f[control_qubit], max_order=max_order)
|
|
531
|
+
x_j = logical_to_algebraic(self.f[target_qubit], max_order=max_order)
|
|
532
|
+
new_P = self.P + se.Rational(1, 2) * theta * x_i * x_j
|
|
533
|
+
else:
|
|
534
|
+
x_i = se.symbols(f'{self.bits[control_qubit]}' if isinstance(control_qubit, int) else str(control_qubit))
|
|
535
|
+
x_j = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
536
|
+
new_P = self.P - se.Rational(1, 2) * theta * x_i * x_j
|
|
537
|
+
new_P = reduce_expression(new_P)
|
|
538
|
+
return PathSum(new_P, self.f, self.pathvar)
|
|
539
|
+
|
|
540
|
+
def cu1(self, theta, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
541
|
+
return self.cp(theta, control_qubit, target_qubit, is_bra)
|
|
542
|
+
|
|
543
|
+
def cu3(self, theta, phi, lam, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
544
|
+
new_pathsum = self.crz(lam, control_qubit, target_qubit, is_bra)
|
|
545
|
+
new_pathsum = new_pathsum.cry(theta, control_qubit, target_qubit, is_bra)
|
|
546
|
+
new_pathsum = new_pathsum.crz(phi, control_qubit, target_qubit, is_bra)
|
|
547
|
+
new_pathsum = new_pathsum.cp(se.Rational(1, 2) * (phi + lam), control_qubit, target_qubit, is_bra) # global phase
|
|
548
|
+
return new_pathsum
|
|
549
|
+
|
|
550
|
+
def cu(self, theta, phi, lam, gamma, control_qubit: int, target_qubit: int, is_bra: bool = False) -> 'PathSum':
|
|
551
|
+
new_pathsum = self.cu3(theta, phi, lam, control_qubit, target_qubit, is_bra)
|
|
552
|
+
new_pathsum = new_pathsum.cp(gamma, control_qubit, target_qubit, is_bra)
|
|
553
|
+
return new_pathsum
|
|
554
|
+
|
|
555
|
+
# Apply CCX gate
|
|
556
|
+
def ccx(self, control_qubit1: int | str | se.Symbol, control_qubit2: int | str | se.Symbol, target_qubit: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
557
|
+
if not is_bra:
|
|
558
|
+
new_f = self.f.update(target_qubit, to_anf(sp.Xor(self.f[target_qubit], sp.And(self.f[control_qubit1], self.f[control_qubit2]))))
|
|
559
|
+
return PathSum(self.P, new_f, self.pathvar)
|
|
560
|
+
else:
|
|
561
|
+
x_i = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
562
|
+
x_j = se.symbols(f'{self.bits[control_qubit1]}' if isinstance(control_qubit1, int) else str(control_qubit1))
|
|
563
|
+
x_k = se.symbols(f'{self.bits[control_qubit2]}' if isinstance(control_qubit2, int) else str(control_qubit2))
|
|
564
|
+
new_var = sp.Xor(x_i, sp.And(x_j, x_k))
|
|
565
|
+
update_var = logical_to_algebraic(new_var)
|
|
566
|
+
new_P = self.P.subs(x_i, update_var)
|
|
567
|
+
new_P = reduce_expression(new_P)
|
|
568
|
+
new_f = self.f.sub(x_i, new_var)
|
|
569
|
+
return PathSum(new_P, new_f, self.pathvar)
|
|
570
|
+
|
|
571
|
+
# Apply MCX gate
|
|
572
|
+
def mcx(self, *qubits, is_bra: bool = False) -> 'PathSum':
|
|
573
|
+
target_qubit = qubits[-1]
|
|
574
|
+
control_qubits = qubits[0:-1]
|
|
575
|
+
if not is_bra:
|
|
576
|
+
new_f = self.f.update(target_qubit, to_anf(sp.Xor(self.f[target_qubit], sp.And([self.f[i] for i in control_qubits]))))
|
|
577
|
+
return PathSum(self.P, new_f, self.pathvar)
|
|
578
|
+
else:
|
|
579
|
+
x_i = se.symbols(f'{self.bits[target_qubit]}' if isinstance(target_qubit, int) else str(target_qubit))
|
|
580
|
+
x_j_list = [se.symbols(f'{self.bits[control_qubit]}' if isinstance(control_qubit, int) else str(control_qubit)) for control_qubit in control_qubits]
|
|
581
|
+
new_var = sp.Xor(x_i, sp.And(*x_j_list))
|
|
582
|
+
update_var = logical_to_algebraic(new_var)
|
|
583
|
+
new_P = self.P.subs(x_i, update_var)
|
|
584
|
+
new_P = reduce_expression(new_P)
|
|
585
|
+
new_f = self.f.sub(x_i, new_var)
|
|
586
|
+
return PathSum(new_P, new_f, self.pathvar)
|
|
587
|
+
|
|
588
|
+
# Apply SWAP gate
|
|
589
|
+
def swap(self, qubit1: int | str | se.Symbol, qubit2: int | str | se.Symbol, is_bra: bool = False) -> 'PathSum':
|
|
590
|
+
if not is_bra:
|
|
591
|
+
new_P = self.P
|
|
592
|
+
new_f = self.f.update(qubit1, self.f[qubit2])
|
|
593
|
+
new_f = new_f.update(qubit2, self.f[qubit1])
|
|
594
|
+
else:
|
|
595
|
+
x_i = se.symbols(f'{self.bits[qubit1]}' if isinstance(qubit1, int) else str(qubit1))
|
|
596
|
+
x_j = se.symbols(f'{self.bits[qubit2]}' if isinstance(qubit2, int) else str(qubit2))
|
|
597
|
+
temp_sym = se.symbols('temp')
|
|
598
|
+
new_P = self.P.subs({x_i:x_j, x_j:x_i})
|
|
599
|
+
new_P = reduce_expression(new_P)
|
|
600
|
+
# new_f = self.f.sub({x_i:temp_sym, x_j:x_i, temp_sym:x_j})
|
|
601
|
+
new_f = self.f.sub(x_i,temp_sym)
|
|
602
|
+
new_f = self.f.sub(x_j,x_i)
|
|
603
|
+
new_f = self.f.sub(temp_sym,x_j)
|
|
604
|
+
return PathSum(new_P, new_f, self.pathvar)
|
|
605
|
+
|
|
606
|
+
def compose(self, other_pathsum: 'PathSum')-> 'PathSum':
|
|
607
|
+
assert self.bits == other_pathsum.bits, f"Bits mismatch: {self.bits} != {other_pathsum.bits}"
|
|
608
|
+
intersect = self.pathvar.intersection(other_pathsum.pathvar)
|
|
609
|
+
temp_P = other_pathsum.P
|
|
610
|
+
temp_f = other_pathsum.f
|
|
611
|
+
new_vars_set = {}
|
|
612
|
+
if intersect:
|
|
613
|
+
temp_pathvar = self.pathvar.union(other_pathsum.pathvar)
|
|
614
|
+
new_vars = find_new_variables(temp_pathvar, len(intersect))
|
|
615
|
+
new_vars_set = set(new_vars)
|
|
616
|
+
for var in intersect:
|
|
617
|
+
new_var = new_vars.pop(0)
|
|
618
|
+
temp_P = temp_P.subs(var, new_var)
|
|
619
|
+
temp_f = temp_f.sub(var, new_var)
|
|
620
|
+
for i in range(self.num_qubits):
|
|
621
|
+
symbol = se.symbols(f'{self.bits[i]}')
|
|
622
|
+
temp_P = temp_P.subs(symbol, logical_to_algebraic(self.f[i]))
|
|
623
|
+
temp_f = temp_f.sub(symbol, self.f[i])
|
|
624
|
+
new_P = self.P + temp_P
|
|
625
|
+
new_f = temp_f
|
|
626
|
+
new_pathvar = self.pathvar.union(other_pathsum.pathvar)
|
|
627
|
+
if new_vars_set:
|
|
628
|
+
new_pathvar = new_pathvar.union(new_vars_set)
|
|
629
|
+
new_pathsum = PathSum(new_P, new_f, new_pathvar)
|
|
630
|
+
new_pathsum = new_pathsum.reduction()
|
|
631
|
+
return new_pathsum
|
|
632
|
+
# Apply reduction
|
|
633
|
+
def reduction(self) -> 'PathSum':
|
|
634
|
+
if not self.is_reduction_enabled():
|
|
635
|
+
return self
|
|
636
|
+
|
|
637
|
+
new_P = reduce_expression(self.P)
|
|
638
|
+
free_symbols = set().union(*map(lambda i: self.f[i].free_symbols, range(self.num_qubits)))
|
|
639
|
+
f_var_names = {f_var.name for f_var in free_symbols}
|
|
640
|
+
reducible_vars = tuple(filter(lambda x: x.name not in f_var_names, self.pathvar))
|
|
641
|
+
if reducible_vars:
|
|
642
|
+
# PathSum.reduction_counts['total'] += 1
|
|
643
|
+
yo_val = match_Elim(new_P, reducible_vars)
|
|
644
|
+
if yo_val is not None:
|
|
645
|
+
new_pathvar = set(self.pathvar)
|
|
646
|
+
new_pathvar.remove(yo_val)
|
|
647
|
+
new_pathsum = PathSum(new_P, self.f, frozenset(new_pathvar))
|
|
648
|
+
PathSum.reduction_counts['Elim'] += 1
|
|
649
|
+
return new_pathsum.reduction()
|
|
650
|
+
pathvar_as_tuple = tuple(self.pathvar)
|
|
651
|
+
yo_val, Q_val, R_val, return_flag = match_omega(new_P, reducible_vars, pathvar_as_tuple, self.bits)
|
|
652
|
+
if yo_val is not None:
|
|
653
|
+
new_pathsum = omega_reduction(self, yo_val, Q_val, R_val, return_flag)
|
|
654
|
+
PathSum.reduction_counts['omega'] += 1
|
|
655
|
+
return new_pathsum.reduction()
|
|
656
|
+
yo_val, yi_val, Q_val, R_val = match_HH(new_P, reducible_vars, pathvar_as_tuple, self.bits)
|
|
657
|
+
if yo_val is not None:
|
|
658
|
+
new_pathsum = HH_reduction(self, yo_val, yi_val, Q_val, R_val)
|
|
659
|
+
PathSum.reduction_counts['HH'] += 1
|
|
660
|
+
return new_pathsum.reduction()
|
|
661
|
+
|
|
662
|
+
new_pathsum = PathSum(new_P, self.f, self.pathvar)
|
|
663
|
+
return new_pathsum
|
|
664
|
+
# TODO: inverse (dagger), simulation, measure
|