Expression of type ExprTuple

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, ExprTuple, 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 = ExprTuple(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())

\left(\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}\right)

stored_expr.style_options()

no style options

# display the expression information
stored_expr.expr_info()

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