Expression of type Qcircuit

from the theory of proveit.physics.quantum.circuits

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, IndexedVar, U, Variable, VertExprArray, m, t
from proveit.linear_algebra import ScalarMult, VecAdd
from proveit.logic import Equals, NotEquals, Set
from proveit.numbers import Add, Exp, Interval, Mult, e, frac, i, one, pi, sqrt, two
from proveit.physics.quantum import CONTROL, I, ket0, ket1, ket_plus, var_ket_u, varphi
from proveit.physics.quantum.circuits import Gate, 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 = Interval(sub_expr3, Add(t, m))
expr = Qcircuit(vert_expr_array = VertExprArray([ExprRange(sub_expr1, Input(state = ket_plus), one, t), ExprRange(sub_expr1, MultiQubitElem(element = Input(state = var_ket_u, part = sub_expr1), targets = sub_expr4), one, m)], ExprRange(sub_expr2, [ExprRange(sub_expr1, ConditionalSet(Conditional(MultiQubitElem(element = CONTROL, targets = Set(sub_expr3)), Equals(sub_expr2, sub_expr1)), Conditional(Gate(operation = I).with_implicit_representation(), NotEquals(sub_expr2, sub_expr1))), one, t).with_case_simplification(), ExprRange(sub_expr1, MultiQubitElem(element = Gate(operation = IndexedVar(U, sub_expr2), part = sub_expr1), targets = sub_expr4), one, m)], one, t).with_case_simplification(), [ExprRange(sub_expr1, Output(state = ScalarMult(frac(one, sqrt(two)), VecAdd(ket0, ScalarMult(Exp(e, Mult(two, pi, i, IndexedVar(varphi, sub_expr1))), ket1)))), one, t), ExprRange(sub_expr1, MultiQubitElem(element = Output(state = var_ket_u, part = sub_expr1), targets = sub_expr4), one, m)]))

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 \varphi_{1}} \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 \varphi_{2}} \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 \varphi_{t}} \cdot \lvert 1 \rangle\right)\right)} \\
\qin{\lvert u \rangle} & \gate{U_{1}} & \gate{U_{2}} & \gate{\cdots} & \gate{U_{t}} & \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: 102 end_index: 101
5	ExprTuple	9, 10
6	ExprRange	lambda_map: 11 start_index: 102 end_index: 101
7	ExprRange	lambda_map: 12 start_index: 102 end_index: 85
8	Lambda	parameter: 84 body: 13
9	ExprRange	lambda_map: 14 start_index: 102 end_index: 101
10	ExprRange	lambda_map: 15 start_index: 102 end_index: 85
11	Lambda	parameter: 111 body: 16
12	Lambda	parameter: 111 body: 17
13	ExprTuple	18, 19
14	Lambda	parameter: 111 body: 20
15	Lambda	parameter: 111 body: 21
16	Operation	operator: 35 operands: 22
17	Operation	operator: 60 operands: 23
18	ExprRange	lambda_map: 24 start_index: 102 end_index: 101
19	ExprRange	lambda_map: 25 start_index: 102 end_index: 85
20	Operation	operator: 40 operands: 26
21	Operation	operator: 60 operands: 27
22	NamedExprs	state: 28
23	NamedExprs	element: 29 targets: 46
24	Lambda	parameter: 111 body: 30
25	Lambda	parameter: 111 body: 31
26	NamedExprs	state: 32
27	NamedExprs	element: 33 targets: 46
28	Operation	operator: 95 operand: 42
29	Operation	operator: 35 operands: 41
30	Operation	operator: 36 operands: 37
31	Operation	operator: 60 operands: 38
32	Operation	operator: 80 operands: 39
33	Operation	operator: 40 operands: 41
34	ExprTuple	42
35	Literal
36	Literal
37	ExprTuple	43, 44
38	NamedExprs	element: 45 targets: 46
39	ExprTuple	47, 48
40	Literal
41	NamedExprs	state: 49 part: 111
42	Literal
43	Conditional	value: 50 condition: 51
44	Conditional	value: 52 condition: 53
45	Operation	operator: 63 operands: 54
46	Operation	operator: 55 operands: 56
47	Operation	operator: 91 operands: 57
48	Operation	operator: 58 operands: 59
49	Variable
50	Operation	operator: 60 operands: 61
51	Operation	operator: 62 operands: 66
52	Operation	operator: 63 operands: 64
53	Operation	operator: 65 operands: 66
54	NamedExprs	operation: 67 part: 111
55	Literal
56	ExprTuple	90, 68
57	ExprTuple	102, 69
58	Literal
59	ExprTuple	70, 71
60	Literal
61	NamedExprs	element: 72 targets: 73
62	Literal
63	Literal
64	NamedExprs	operation: 74
65	Literal
66	ExprTuple	84, 111
67	IndexedVar	variable: 75 index: 84
68	Operation	operator: 97 operands: 77
69	Operation	operator: 93 operands: 78
70	Operation	operator: 95 operand: 87
71	Operation	operator: 80 operands: 81
72	Literal
73	Operation	operator: 82 operand: 90
74	Literal
75	Variable
76	ExprTuple	84
77	ExprTuple	101, 85
78	ExprTuple	105, 86
79	ExprTuple	87
80	Literal
81	ExprTuple	88, 89
82	Literal
83	ExprTuple	90
84	Variable
85	Variable
86	Operation	operator: 91 operands: 92
87	Literal
88	Operation	operator: 93 operands: 94
89	Operation	operator: 95 operand: 102
90	Operation	operator: 97 operands: 98
91	Literal
92	ExprTuple	102, 105
93	Literal
94	ExprTuple	99, 100
95	Literal
96	ExprTuple	102
97	Literal
98	ExprTuple	101, 102
99	Literal
100	Operation	operator: 103 operands: 104
101	Variable
102	Literal
103	Literal
104	ExprTuple	105, 106, 107, 108
105	Literal
106	Literal
107	Literal
108	IndexedVar	variable: 109 index: 111
109	Variable
110	ExprTuple	111
111	Variable