Expression of type Lambda

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, ExprRange, IndexedVar, Lambda, Variable, i, lambda_, m, n
from proveit.core_expr_types import a_1_to_m, a_i, b_1_to_n, b_i, lambda_i
from proveit.linear_algebra import OrthoNormBases, ScalarMult, VecSum
from proveit.logic import CartExp, Equals, Exists, InSet, Set
from proveit.numbers import Complex, Interval, Min, RealNonNeg, one
from proveit.physics.quantum import Ket, Qmult, var_ket_psi
from proveit.physics.quantum.algebra import a_1_to_m_kets, b_1_to_n_kets

# build up the expression from sub-expressions
sub_expr1 = Variable("_a", latex_format = r"{_{-}a}")
sub_expr2 = Min(m, n)
expr = Lambda([a_1_to_m], Conditional(Exists(instance_param_or_params = [b_1_to_n], instance_expr = Exists(instance_param_or_params = [ExprRange(sub_expr1, IndexedVar(lambda_, sub_expr1), one, sub_expr2)], instance_expr = Equals(var_ket_psi, VecSum(index_or_indices = [i], summand = ScalarMult(lambda_i, Qmult(Ket(a_i), Ket(b_i))), domain = Interval(one, sub_expr2))), domain = RealNonNeg).with_wrapping(), condition = InSet(Set(b_1_to_n_kets), OrthoNormBases(CartExp(Complex, n)))).with_wrapping(), InSet(Set(a_1_to_m_kets), OrthoNormBases(CartExp(Complex, 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())

\left(a_{1}, a_{2}, \ldots, a_{m}\right) \mapsto \left\{\begin{array}{l}\exists_{b_{1}, b_{2}, \ldots, b_{n}~|~\left\{\left\{\lvert b_{1} \rangle, \lvert b_{2} \rangle, \ldots, \lvert b_{n} \rangle\right\}\right\} \in \textrm{O.N.Bases}\left(\mathbb{C}^{n}\right)}~\\
\left[\begin{array}{l}\exists_{\lambda_{1}, \lambda_{2}, \ldots, \lambda_{{\rm Min}\left(m, n\right)} \in \mathbb{R}^{\ge 0}}~\\
\left(\lvert \psi \rangle = \left(\sum_{i=1}^{{\rm Min}\left(m, n\right)} \left(\lambda_{i} \cdot \left(\lvert a_{i} \rangle \thinspace \lvert b_{i} \rangle\right)\right)\right)\right)\end{array}\right]\end{array} \textrm{ if } \left\{\left\{\lvert a_{1} \rangle, \lvert a_{2} \rangle, \ldots, \lvert a_{m} \rangle\right\}\right\} \in \textrm{O.N.Bases}\left(\mathbb{C}^{m}\right)\right..

stored_expr.style_options()

no style options

# display the expression information
stored_expr.expr_info()

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