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/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