Expression of type ExprTuple

from the theory of proveit.physics.quantum.algebra

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, ExprTuple, Lambda, M, i, n
from proveit.core_expr_types import a_1_to_n, a_i, v_1_to_n, v_i
from proveit.linear_algebra import Adj, Dim, HilbertSpaces, Hspace, LinMap, OrthoNormBases, ScalarMult, VecSum
from proveit.logic import And, Equals, Exists, Forall, Iff, InClass, InSet, Set
from proveit.numbers import Complex, Interval, one
from proveit.physics.quantum import Bra, Ket, Qmult
from proveit.physics.quantum.algebra import v_1_to_n_kets

# build up the expression from sub-expressions
sub_expr1 = Adj(M)
expr = ExprTuple(Lambda(Hspace, Conditional(Forall(instance_param_or_params = [M], instance_expr = Iff(Equals(Qmult(sub_expr1, M), Qmult(M, sub_expr1)), Exists(instance_param_or_params = [v_1_to_n], instance_expr = Exists(instance_param_or_params = [a_1_to_n], instance_expr = Equals(M, VecSum(index_or_indices = [i], summand = ScalarMult(a_i, Qmult(Ket(v_i), Bra(v_i))), domain = Interval(one, n))), domain = Complex).with_wrapping(), condition = InSet(Set(v_1_to_n_kets), OrthoNormBases(Hspace))).with_wrapping()).with_wrapping_at(2), domain = LinMap(Hspace, Hspace)), And(InClass(Hspace, HilbertSpaces), Equals(Dim(Hspace), n)))))

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(\mathcal{H} \mapsto \left\{\forall_{M \in \mathcal{L}\left(\mathcal{H}, \mathcal{H}\right)}~\left(\begin{array}{c} \begin{array}{l} \left(\left(M^{\dagger} \thinspace M\right) = \left(M \thinspace M^{\dagger}\right)\right) \Leftrightarrow  \\ \left[\begin{array}{l}\exists_{v_{1}, v_{2}, \ldots, v_{n}~|~\left\{\left\{\lvert v_{1} \rangle, \lvert v_{2} \rangle, \ldots, \lvert v_{n} \rangle\right\}\right\} \in \textrm{O.N.Bases}\left(\mathcal{H}\right)}~\\
\left[\begin{array}{l}\exists_{a_{1}, a_{2}, \ldots, a_{n} \in \mathbb{C}}~\\
\left(M = \left(\sum_{i=1}^{n} \left(a_{i} \cdot \left(\lvert v_{i} \rangle \thinspace \langle v_{i} \rvert\right)\right)\right)\right)\end{array}\right]\end{array}\right] \end{array} \end{array}\right) \textrm{ if } \mathcal{H} \underset{{\scriptscriptstyle c}}{\in} \textrm{HilbertSpaces} ,  \textrm{Dim}\left(\mathcal{H}\right) = n\right..\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	Lambda	parameter: 59 body: 2
2	Conditional	value: 3 condition: 4
3	Operation	operator: 5 operand: 8
4	Operation	operator: 63 operands: 7
5	Literal
6	ExprTuple	8
7	ExprTuple	9, 10
8	Lambda	parameter: 67 body: 11
9	Operation	operator: 12 operands: 13
10	Operation	operator: 61 operands: 14
11	Conditional	value: 15 condition: 16
12	Literal
13	ExprTuple	59, 17
14	ExprTuple	18, 103
15	Operation	operator: 19 operands: 20
16	Operation	operator: 88 operands: 21
17	Literal
18	Operation	operator: 22 operand: 59
19	Literal
20	ExprTuple	23, 24
21	ExprTuple	67, 25
22	Literal
23	Operation	operator: 61 operands: 26
24	Operation	operator: 44 operand: 32
25	Operation	operator: 28 operands: 29
26	ExprTuple	30, 31
27	ExprTuple	32
28	Literal
29	ExprTuple	59, 59
30	Operation	operator: 96 operands: 33
31	Operation	operator: 96 operands: 34
32	Lambda	parameters: 35 body: 36
33	ExprTuple	37, 67
34	ExprTuple	67, 37
35	ExprTuple	38
36	Conditional	value: 39 condition: 40
37	Operation	operator: 41 operand: 67
38	ExprRange	lambda_map: 43 start_index: 102 end_index: 103
39	Operation	operator: 44 operand: 47
40	Operation	operator: 88 operands: 46
41	Literal
42	ExprTuple	67
43	Lambda	parameter: 94 body: 85
44	Literal
45	ExprTuple	47
46	ExprTuple	48, 49
47	Lambda	parameters: 50 body: 51
48	Operation	operator: 65 operand: 58
49	Operation	operator: 53 operand: 59
50	ExprTuple	55
51	Conditional	value: 56 condition: 57
52	ExprTuple	58
53	Literal
54	ExprTuple	59
55	ExprRange	lambda_map: 60 start_index: 102 end_index: 103
56	Operation	operator: 61 operands: 62
57	Operation	operator: 63 operands: 64
58	Operation	operator: 65 operands: 66
59	Variable
60	Lambda	parameter: 94 body: 83
61	Literal
62	ExprTuple	67, 68
63	Literal
64	ExprTuple	69
65	Literal
66	ExprTuple	70
67	Variable
68	Operation	operator: 71 operand: 75
69	ExprRange	lambda_map: 73 start_index: 102 end_index: 103
70	ExprRange	lambda_map: 74 start_index: 102 end_index: 103
71	Literal
72	ExprTuple	75
73	Lambda	parameter: 94 body: 76
74	Lambda	parameter: 94 body: 77
75	Lambda	parameter: 110 body: 78
76	Operation	operator: 88 operands: 79
77	Operation	operator: 104 operand: 85
78	Conditional	value: 81 condition: 82
79	ExprTuple	83, 84
80	ExprTuple	85
81	Operation	operator: 86 operands: 87
82	Operation	operator: 88 operands: 89
83	IndexedVar	variable: 95 index: 94
84	Literal
85	IndexedVar	variable: 108 index: 94
86	Literal
87	ExprTuple	91, 92
88	Literal
89	ExprTuple	110, 93
90	ExprTuple	94
91	IndexedVar	variable: 95 index: 110
92	Operation	operator: 96 operands: 97
93	Operation	operator: 98 operands: 99
94	Variable
95	Variable
96	Literal
97	ExprTuple	100, 101
98	Literal
99	ExprTuple	102, 103
100	Operation	operator: 104 operand: 107
101	Operation	operator: 105 operand: 107
102	Literal
103	Variable
104	Literal
105	Literal
106	ExprTuple	107
107	IndexedVar	variable: 108 index: 110
108	Variable
109	ExprTuple	110
110	Variable