Expression of type Qcircuit

from the theory of proveit.physics.quantum.QPE

import proveit
# Automation is not needed when building an expression:
proveit.defaults.automation = False # This will speed things up.
proveit.defaults.inline_pngs = False # Makes files smaller.
%load_expr # Load the stored expression as 'stored_expr'
# import Expression classes needed to build the expression
from proveit import Conditional, ConditionalSet, ExprRange, Variable, VertExprArray, t
from proveit.linear_algebra import MatrixExp, ScalarMult, VecAdd
from proveit.logic import Equals, NotEquals, Set
from proveit.numbers import Add, Exp, Interval, Mult, Neg, e, frac, i, one, pi, sqrt, two, zero
from proveit.physics.quantum import CONTROL, ket0, ket1, ket_plus
from proveit.physics.quantum.QPE import _U, _ket_u, _phase, _s
from proveit.physics.quantum.circuits import Gate, Igate, Input, MultiQubitElem, Output, Qcircuit

# build up the expression from sub-expressions
sub_expr1 = Variable("_a", latex_format = r"{_{-}a}")
sub_expr2 = Variable("_b", latex_format = r"{_{-}b}")
sub_expr3 = Add(t, one)
sub_expr4 = Add(sub_expr2, t)
sub_expr5 = Interval(sub_expr3, Add(t, _s))
sub_expr6 = Add(Neg(t), one)
expr = Qcircuit(vert_expr_array = VertExprArray([ExprRange(sub_expr1, Input(state = ket_plus), one, t), ExprRange(sub_expr1, MultiQubitElem(element = Input(state = _ket_u, part = sub_expr1), targets = sub_expr5), one, _s)], ExprRange(sub_expr2, [ExprRange(sub_expr1, ConditionalSet(Conditional(MultiQubitElem(element = CONTROL, targets = Set(sub_expr3)), Equals(sub_expr4, sub_expr1)), Conditional(Igate, NotEquals(sub_expr4, sub_expr1))), one, t).with_case_simplification(), ExprRange(sub_expr1, MultiQubitElem(element = Gate(operation = MatrixExp(_U, Exp(two, Neg(sub_expr2))), part = sub_expr1), targets = sub_expr5), one, _s)], sub_expr6, zero).with_decreasing_order(), [ExprRange(sub_expr1, Output(state = ScalarMult(frac(one, sqrt(two)), VecAdd(ket0, ScalarMult(Exp(e, Mult(two, pi, i, Exp(two, Neg(sub_expr1)), _phase)), ket1)))), sub_expr6, zero).with_decreasing_order(), ExprRange(sub_expr1, MultiQubitElem(element = Output(state = _ket_u, part = sub_expr1), targets = sub_expr5), one, _s)]))

expr:

# check that the built expression is the same as the stored expression
assert expr == stored_expr
assert expr._style_id == stored_expr._style_id
print("Passed sanity check: expr matches stored_expr")

Passed sanity check: expr matches stored_expr

# Show the LaTeX representation of the expression for convenience if you need it.
print(stored_expr.latex())

\begin{array}{c} \Qcircuit@C=1em @R=.7em{
\qin{\lvert + \rangle} & \control{} \qw \qwx[1] & \qw & \gate{\cdots} \qwx[1] & \qw & \qout{\frac{1}{\sqrt{2}} \cdot \left(\lvert 0 \rangle + \left(\mathsf{e}^{2 \cdot \pi \cdot \mathsf{i} \cdot 2^{t - 1} \cdot \varphi} \cdot \lvert 1 \rangle\right)\right)} \\
\qin{\lvert + \rangle} & \qw \qwx[1] & \control{} \qw \qwx[1] & \gate{\cdots} \qwx[1] & \qw & \qout{\frac{1}{\sqrt{2}} \cdot \left(\lvert 0 \rangle + \left(\mathsf{e}^{2 \cdot \pi \cdot \mathsf{i} \cdot 2^{t - 2} \cdot \varphi} \cdot \lvert 1 \rangle\right)\right)} \\
\qin{\begin{array}{c}:\\ \left(t - 3\right) \times \\:\end{array}} & \gate{\vdots} \qwx[1] & \gate{\vdots} \qwx[1] & \gate{\ddots} \qwx[1] & \gate{\vdots} & \qout{\vdots} \\
\qin{\lvert + \rangle} & \qw \qwx[1] & \qw \qwx[1] & \gate{\cdots} \qwx[1] & \control{} \qw \qwx[1] & \qout{\frac{1}{\sqrt{2}} \cdot \left(\lvert 0 \rangle + \left(\mathsf{e}^{2 \cdot \pi \cdot \mathsf{i} \cdot 2^{0} \cdot \varphi} \cdot \lvert 1 \rangle\right)\right)} \\
\qin{\lvert u \rangle} & \gate{U^{2^{t - 1}}} & \gate{U^{2^{t - 2}}} & \gate{\cdots} & \gate{U^{2^{0}}} & \qout{\lvert u \rangle}
} \end{array}

stored_expr.style_options()

name	description	default	current value	related methods
spacing	change the spacing of a circuit using the format '@C=1em @R=.7em' where C is the column spacing and R is the row spacing	@C=1em @R=.7em	@C=1em @R=.7em

# display the expression information
stored_expr.expr_info()

	core type	sub-expressions	expression
0	Operation	operator: 1 operands: 2
1	Literal
2	ExprTuple	3, 4, 5
3	ExprTuple	6, 7
4	ExprRange	lambda_map: 8 start_index: 15 end_index: 94
5	ExprTuple	9, 10
6	ExprRange	lambda_map: 11 start_index: 110 end_index: 109
7	ExprRange	lambda_map: 12 start_index: 110 end_index: 92
8	Lambda	parameter: 114 body: 13
9	ExprRange	lambda_map: 14 start_index: 15 end_index: 94
10	ExprRange	lambda_map: 16 start_index: 110 end_index: 92
11	Lambda	parameter: 125 body: 17
12	Lambda	parameter: 125 body: 18
13	ExprTuple	19, 20
14	Lambda	parameter: 125 body: 21
15	Operation	operator: 104 operands: 22
16	Lambda	parameter: 125 body: 23
17	Operation	operator: 39 operands: 24
18	Operation	operator: 64 operands: 25
19	ExprRange	lambda_map: 26 start_index: 110 end_index: 109
20	ExprRange	lambda_map: 27 start_index: 110 end_index: 92
21	Operation	operator: 44 operands: 28
22	ExprTuple	29, 110
23	Operation	operator: 64 operands: 30
24	NamedExprs	state: 31
25	NamedExprs	element: 32 targets: 50
26	Lambda	parameter: 125 body: 33
27	Lambda	parameter: 125 body: 34
28	NamedExprs	state: 35
29	Operation	operator: 123 operand: 109
30	NamedExprs	element: 37 targets: 50
31	Operation	operator: 102 operand: 46
32	Operation	operator: 39 operands: 45
33	Operation	operator: 40 operands: 41
34	Operation	operator: 64 operands: 42
35	Operation	operator: 85 operands: 43
36	ExprTuple	109
37	Operation	operator: 44 operands: 45
38	ExprTuple	46
39	Literal
40	Literal
41	ExprTuple	47, 48
42	NamedExprs	element: 49 targets: 50
43	ExprTuple	51, 52
44	Literal
45	NamedExprs	state: 53 part: 125
46	Literal
47	Conditional	value: 54 condition: 55
48	Conditional	value: 56 condition: 57
49	Operation	operator: 67 operands: 58
50	Operation	operator: 59 operands: 60
51	Operation	operator: 99 operands: 61
52	Operation	operator: 62 operands: 63
53	Literal
54	Operation	operator: 64 operands: 65
55	Operation	operator: 66 operands: 70
56	Operation	operator: 67 operands: 68
57	Operation	operator: 69 operands: 70
58	NamedExprs	operation: 71 part: 125
59	Literal
60	ExprTuple	97, 72
61	ExprTuple	110, 73
62	Literal
63	ExprTuple	74, 75
64	Literal
65	NamedExprs	element: 76 targets: 77
66	Literal
67	Literal
68	NamedExprs	operation: 78
69	Literal
70	ExprTuple	79, 125
71	Operation	operator: 80 operands: 81
72	Operation	operator: 104 operands: 82
73	Operation	operator: 119 operands: 83
74	Operation	operator: 102 operand: 94
75	Operation	operator: 85 operands: 86
76	Literal
77	Operation	operator: 87 operand: 97
78	Literal
79	Operation	operator: 104 operands: 89
80	Literal
81	ExprTuple	90, 91
82	ExprTuple	109, 92
83	ExprTuple	121, 93
84	ExprTuple	94
85	Literal
86	ExprTuple	95, 96
87	Literal
88	ExprTuple	97
89	ExprTuple	114, 109
90	Literal
91	Operation	operator: 119 operands: 98
92	Literal
93	Operation	operator: 99 operands: 100
94	Literal
95	Operation	operator: 119 operands: 101
96	Operation	operator: 102 operand: 110
97	Operation	operator: 104 operands: 105
98	ExprTuple	121, 106
99	Literal
100	ExprTuple	110, 121
101	ExprTuple	107, 108
102	Literal
103	ExprTuple	110
104	Literal
105	ExprTuple	109, 110
106	Operation	operator: 123 operand: 114
107	Literal
108	Operation	operator: 112 operands: 113
109	Variable
110	Literal
111	ExprTuple	114
112	Literal
113	ExprTuple	121, 115, 116, 117, 118
114	Variable
115	Literal
116	Literal
117	Operation	operator: 119 operands: 120
118	Literal
119	Literal
120	ExprTuple	121, 122
121	Literal
122	Operation	operator: 123 operand: 125
123	Literal
124	ExprTuple	125
125	Variable