:: Banach Space of Bounded Linear Operators
:: by Yasunari Shidama
::
:: Copyright (c) 2003-2017 Association of Mizar Users

definition
let X be set ;
let Y be non empty set ;
let F be Function of [:REAL,Y:],Y;
let a be Real;
let f be Function of X,Y;
:: original: [;]
redefine func F [;] (a,f) -> Element of Funcs (X,Y);
coherence
F [;] (a,f) is Element of Funcs (X,Y)
proof end;
end;

definition
let X be non empty set ;
let Y be non empty addLoopStr ;
func FuncAdd (X,Y) -> BinOp of (Funcs (X, the carrier of Y)) means :Def1: :: LOPBAN_1:def 1
for f, g being Element of Funcs (X, the carrier of Y) holds it . (f,g) = the addF of Y .: (f,g);
existence
ex b1 being BinOp of (Funcs (X, the carrier of Y)) st
for f, g being Element of Funcs (X, the carrier of Y) holds b1 . (f,g) = the addF of Y .: (f,g)
proof end;
uniqueness
for b1, b2 being BinOp of (Funcs (X, the carrier of Y)) st ( for f, g being Element of Funcs (X, the carrier of Y) holds b1 . (f,g) = the addF of Y .: (f,g) ) & ( for f, g being Element of Funcs (X, the carrier of Y) holds b2 . (f,g) = the addF of Y .: (f,g) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def1 defines FuncAdd LOPBAN_1:def 1 :
for X being non empty set
for Y being non empty addLoopStr
for b3 being BinOp of (Funcs (X, the carrier of Y)) holds
( b3 = FuncAdd (X,Y) iff for f, g being Element of Funcs (X, the carrier of Y) holds b3 . (f,g) = the addF of Y .: (f,g) );

definition
let X be non empty set ;
let Y be RealLinearSpace;
func FuncExtMult (X,Y) -> Function of [:REAL,(Funcs (X, the carrier of Y)):],(Funcs (X, the carrier of Y)) means :Def2: :: LOPBAN_1:def 2
for a being Real
for f being Element of Funcs (X, the carrier of Y)
for x being Element of X holds (it . [a,f]) . x = a * (f . x);
existence
ex b1 being Function of [:REAL,(Funcs (X, the carrier of Y)):],(Funcs (X, the carrier of Y)) st
for a being Real
for f being Element of Funcs (X, the carrier of Y)
for x being Element of X holds (b1 . [a,f]) . x = a * (f . x)
proof end;
uniqueness
for b1, b2 being Function of [:REAL,(Funcs (X, the carrier of Y)):],(Funcs (X, the carrier of Y)) st ( for a being Real
for f being Element of Funcs (X, the carrier of Y)
for x being Element of X holds (b1 . [a,f]) . x = a * (f . x) ) & ( for a being Real
for f being Element of Funcs (X, the carrier of Y)
for x being Element of X holds (b2 . [a,f]) . x = a * (f . x) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def2 defines FuncExtMult LOPBAN_1:def 2 :
for X being non empty set
for Y being RealLinearSpace
for b3 being Function of [:REAL,(Funcs (X, the carrier of Y)):],(Funcs (X, the carrier of Y)) holds
( b3 = FuncExtMult (X,Y) iff for a being Real
for f being Element of Funcs (X, the carrier of Y)
for x being Element of X holds (b3 . [a,f]) . x = a * (f . x) );

definition
let X be set ;
let Y be non empty ZeroStr ;
func FuncZero (X,Y) -> Element of Funcs (X, the carrier of Y) equals :: LOPBAN_1:def 3
X --> (0. Y);
coherence
X --> (0. Y) is Element of Funcs (X, the carrier of Y)
by FUNCT_2:8;
end;

:: deftheorem defines FuncZero LOPBAN_1:def 3 :
for X being set
for Y being non empty ZeroStr holds FuncZero (X,Y) = X --> (0. Y);

Lm1: for A, B being non empty set
for x being Element of A
for f being Function of A,B holds x in dom f

proof end;

theorem Th1: :: LOPBAN_1:1
for X being non empty set
for Y being non empty addLoopStr
for f, g, h being Element of Funcs (X, the carrier of Y) holds
( h = (FuncAdd (X,Y)) . (f,g) iff for x being Element of X holds h . x = (f . x) + (g . x) )
proof end;

theorem Th2: :: LOPBAN_1:2
for X being non empty set
for Y being RealLinearSpace
for f, h being Element of Funcs (X, the carrier of Y)
for a being Real holds
( h = (FuncExtMult (X,Y)) . [a,f] iff for x being Element of X holds h . x = a * (f . x) )
proof end;

theorem Th3: :: LOPBAN_1:3
for X being non empty set
for Y being RealLinearSpace
for f, g being Element of Funcs (X, the carrier of Y) holds (FuncAdd (X,Y)) . (f,g) = (FuncAdd (X,Y)) . (g,f)
proof end;

theorem Th4: :: LOPBAN_1:4
for X being non empty set
for Y being RealLinearSpace
for f, g, h being Element of Funcs (X, the carrier of Y) holds (FuncAdd (X,Y)) . (f,((FuncAdd (X,Y)) . (g,h))) = (FuncAdd (X,Y)) . (((FuncAdd (X,Y)) . (f,g)),h)
proof end;

theorem Th5: :: LOPBAN_1:5
for X being non empty set
for Y being RealLinearSpace
for f being Element of Funcs (X, the carrier of Y) holds (FuncAdd (X,Y)) . ((FuncZero (X,Y)),f) = f
proof end;

reconsider jj = 1 as Element of REAL by XREAL_0:def 1;

theorem Th6: :: LOPBAN_1:6
for X being non empty set
for Y being RealLinearSpace
for f being Element of Funcs (X, the carrier of Y) holds (FuncAdd (X,Y)) . (f,((FuncExtMult (X,Y)) . [(- 1),f])) = FuncZero (X,Y)
proof end;

theorem Th7: :: LOPBAN_1:7
for X being non empty set
for Y being RealLinearSpace
for f being Element of Funcs (X, the carrier of Y) holds (FuncExtMult (X,Y)) . [1,f] = f
proof end;

theorem Th8: :: LOPBAN_1:8
for X being non empty set
for Y being RealLinearSpace
for f being Element of Funcs (X, the carrier of Y)
for a, b being Real holds (FuncExtMult (X,Y)) . [a,((FuncExtMult (X,Y)) . [b,f])] = (FuncExtMult (X,Y)) . [(a * b),f]
proof end;

theorem Th9: :: LOPBAN_1:9
for X being non empty set
for Y being RealLinearSpace
for f being Element of Funcs (X, the carrier of Y)
for a, b being Real holds (FuncAdd (X,Y)) . (((FuncExtMult (X,Y)) . [a,f]),((FuncExtMult (X,Y)) . [b,f])) = (FuncExtMult (X,Y)) . [(a + b),f]
proof end;

Lm2: for X being non empty set
for Y being RealLinearSpace
for f, g being Element of Funcs (X, the carrier of Y)
for a being Real holds (FuncAdd (X,Y)) . (((FuncExtMult (X,Y)) . [a,f]),((FuncExtMult (X,Y)) . [a,g])) = (FuncExtMult (X,Y)) . [a,((FuncAdd (X,Y)) . (f,g))]

proof end;

theorem Th10: :: LOPBAN_1:10
for X being non empty set
for Y being RealLinearSpace holds RLSStruct(# (Funcs (X, the carrier of Y)),(FuncZero (X,Y)),(FuncAdd (X,Y)),(FuncExtMult (X,Y)) #) is RealLinearSpace
proof end;

definition
let X be non empty set ;
let Y be RealLinearSpace;
func RealVectSpace (X,Y) -> RealLinearSpace equals :: LOPBAN_1:def 4
RLSStruct(# (Funcs (X, the carrier of Y)),(FuncZero (X,Y)),(FuncAdd (X,Y)),(FuncExtMult (X,Y)) #);
coherence
RLSStruct(# (Funcs (X, the carrier of Y)),(FuncZero (X,Y)),(FuncAdd (X,Y)),(FuncExtMult (X,Y)) #) is RealLinearSpace
by Th10;
end;

:: deftheorem defines RealVectSpace LOPBAN_1:def 4 :
for X being non empty set
for Y being RealLinearSpace holds RealVectSpace (X,Y) = RLSStruct(# (Funcs (X, the carrier of Y)),(FuncZero (X,Y)),(FuncAdd (X,Y)),(FuncExtMult (X,Y)) #);

registration
let X be non empty set ;
let Y be RealLinearSpace;
cluster RealVectSpace (X,Y) -> strict ;
coherence
RealVectSpace (X,Y) is strict
;
end;

registration
let X be non empty set ;
let Y be RealLinearSpace;
coherence by MONOID_0:80;
end;

definition
let X be non empty set ;
let Y be RealLinearSpace;
let f be VECTOR of (RealVectSpace (X,Y));
let x be Element of X;
:: original: .
redefine func f . x -> VECTOR of Y;
coherence
f . x is VECTOR of Y
proof end;
end;

theorem :: LOPBAN_1:11
for X being non empty set
for Y being RealLinearSpace
for f, g, h being VECTOR of (RealVectSpace (X,Y)) holds
( h = f + g iff for x being Element of X holds h . x = (f . x) + (g . x) ) by Th1;

theorem :: LOPBAN_1:12
for X being non empty set
for Y being RealLinearSpace
for f, h being VECTOR of (RealVectSpace (X,Y))
for a being Real holds
( h = a * f iff for x being Element of X holds h . x = a * (f . x) ) by Th2;

theorem :: LOPBAN_1:13
for X being non empty set
for Y being RealLinearSpace holds 0. (RealVectSpace (X,Y)) = X --> (0. Y) ;

definition
let X, Y be non empty RLSStruct ;
let IT be Function of X,Y;
attr IT is homogeneous means :Def5: :: LOPBAN_1:def 5
for x being VECTOR of X
for r being Real holds IT . (r * x) = r * (IT . x);
end;

:: deftheorem Def5 defines homogeneous LOPBAN_1:def 5 :
for X, Y being non empty RLSStruct
for IT being Function of X,Y holds
( IT is homogeneous iff for x being VECTOR of X
for r being Real holds IT . (r * x) = r * (IT . x) );

registration
let X be non empty RLSStruct ;
let Y be RealLinearSpace;
cluster non empty Relation-like the carrier of X -defined the carrier of Y -valued Function-like total quasi_total additive homogeneous for Element of bool [: the carrier of X, the carrier of Y:];
existence
ex b1 being Function of X,Y st
( b1 is additive & b1 is homogeneous )
proof end;
end;

definition end;

definition
let X, Y be RealLinearSpace;
func LinearOperators (X,Y) -> Subset of (RealVectSpace ( the carrier of X,Y)) means :Def6: :: LOPBAN_1:def 6
for x being set holds
( x in it iff x is LinearOperator of X,Y );
existence
ex b1 being Subset of (RealVectSpace ( the carrier of X,Y)) st
for x being set holds
( x in b1 iff x is LinearOperator of X,Y )
proof end;
uniqueness
for b1, b2 being Subset of (RealVectSpace ( the carrier of X,Y)) st ( for x being set holds
( x in b1 iff x is LinearOperator of X,Y ) ) & ( for x being set holds
( x in b2 iff x is LinearOperator of X,Y ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def6 defines LinearOperators LOPBAN_1:def 6 :
for X, Y being RealLinearSpace
for b3 being Subset of (RealVectSpace ( the carrier of X,Y)) holds
( b3 = LinearOperators (X,Y) iff for x being set holds
( x in b3 iff x is LinearOperator of X,Y ) );

registration
let X, Y be RealLinearSpace;
cluster LinearOperators (X,Y) -> non empty functional ;
coherence
( not LinearOperators (X,Y) is empty & LinearOperators (X,Y) is functional )
proof end;
end;

theorem Th14: :: LOPBAN_1:14
for X, Y being RealLinearSpace holds LinearOperators (X,Y) is linearly-closed
proof end;

theorem :: LOPBAN_1:15
for X, Y being RealLinearSpace holds RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is Subspace of RealVectSpace ( the carrier of X,Y) by ;

registration
let X, Y be RealLinearSpace;
cluster RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) -> right_complementable Abelian add-associative right_zeroed vector-distributive scalar-distributive scalar-associative scalar-unital ;
coherence
( RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is Abelian & RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is add-associative & RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is right_zeroed & RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is right_complementable & RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is vector-distributive & RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is scalar-distributive & RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is scalar-associative & RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is scalar-unital )
by ;
end;

definition
let X, Y be RealLinearSpace;
func R_VectorSpace_of_LinearOperators (X,Y) -> RealLinearSpace equals :: LOPBAN_1:def 7
RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #);
coherence
RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #) is RealLinearSpace
;
end;

:: deftheorem defines R_VectorSpace_of_LinearOperators LOPBAN_1:def 7 :
for X, Y being RealLinearSpace holds R_VectorSpace_of_LinearOperators (X,Y) = RLSStruct(# (LinearOperators (X,Y)),(Zero_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Add_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))),(Mult_ ((LinearOperators (X,Y)),(RealVectSpace ( the carrier of X,Y)))) #);

registration
let X, Y be RealLinearSpace;
coherence ;
end;

registration
let X, Y be RealLinearSpace;
coherence by MONOID_0:80;
end;

definition
let X, Y be RealLinearSpace;
let f be Element of ();
let v be VECTOR of X;
:: original: .
redefine func f . v -> VECTOR of Y;
coherence
f . v is VECTOR of Y
proof end;
end;

theorem Th16: :: LOPBAN_1:16
for X, Y being RealLinearSpace
for f, g, h being VECTOR of () holds
( h = f + g iff for x being VECTOR of X holds h . x = (f . x) + (g . x) )
proof end;

theorem Th17: :: LOPBAN_1:17
for X, Y being RealLinearSpace
for f, h being VECTOR of ()
for a being Real holds
( h = a * f iff for x being VECTOR of X holds h . x = a * (f . x) )
proof end;

theorem Th18: :: LOPBAN_1:18
for X, Y being RealLinearSpace holds 0. () = the carrier of X --> (0. Y)
proof end;

theorem Th19: :: LOPBAN_1:19
for X, Y being RealLinearSpace holds the carrier of X --> (0. Y) is LinearOperator of X,Y
proof end;

theorem Th20: :: LOPBAN_1:20
for X being RealNormSpace
for seq being sequence of X
for g being Point of X st seq is convergent & lim seq = g holds
( ||.seq.|| is convergent & lim ||.seq.|| = )
proof end;

definition
let X, Y be RealNormSpace;
let IT be LinearOperator of X,Y;
attr IT is Lipschitzian means :Def8: :: LOPBAN_1:def 8
ex K being Real st
( 0 <= K & ( for x being VECTOR of X holds ||.(IT . x).|| <= K * ) );
end;

:: deftheorem Def8 defines Lipschitzian LOPBAN_1:def 8 :
for X, Y being RealNormSpace
for IT being LinearOperator of X,Y holds
( IT is Lipschitzian iff ex K being Real st
( 0 <= K & ( for x being VECTOR of X holds ||.(IT . x).|| <= K * ) ) );

theorem Th21: :: LOPBAN_1:21
for X, Y being RealNormSpace
for f being LinearOperator of X,Y st ( for x being VECTOR of X holds f . x = 0. Y ) holds
f is Lipschitzian
proof end;

registration
let X, Y be RealNormSpace;
cluster non empty Relation-like the carrier of X -defined the carrier of Y -valued Function-like total quasi_total additive homogeneous Lipschitzian for Element of bool [: the carrier of X, the carrier of Y:];
existence
ex b1 being LinearOperator of X,Y st b1 is Lipschitzian
proof end;
end;

definition
let X, Y be RealNormSpace;
func BoundedLinearOperators (X,Y) -> Subset of () means :Def9: :: LOPBAN_1:def 9
for x being set holds
( x in it iff x is Lipschitzian LinearOperator of X,Y );
existence
ex b1 being Subset of () st
for x being set holds
( x in b1 iff x is Lipschitzian LinearOperator of X,Y )
proof end;
uniqueness
for b1, b2 being Subset of () st ( for x being set holds
( x in b1 iff x is Lipschitzian LinearOperator of X,Y ) ) & ( for x being set holds
( x in b2 iff x is Lipschitzian LinearOperator of X,Y ) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def9 defines BoundedLinearOperators LOPBAN_1:def 9 :
for X, Y being RealNormSpace
for b3 being Subset of () holds
( b3 = BoundedLinearOperators (X,Y) iff for x being set holds
( x in b3 iff x is Lipschitzian LinearOperator of X,Y ) );

registration
let X, Y be RealNormSpace;
cluster BoundedLinearOperators (X,Y) -> non empty ;
coherence
not BoundedLinearOperators (X,Y) is empty
proof end;
end;

theorem Th22: :: LOPBAN_1:22
for X, Y being RealNormSpace holds BoundedLinearOperators (X,Y) is linearly-closed
proof end;

theorem :: LOPBAN_1:23
for X, Y being RealNormSpace holds RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is Subspace of R_VectorSpace_of_LinearOperators (X,Y) by ;

registration
let X, Y be RealNormSpace;
coherence
( RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is Abelian & RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is add-associative & RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is right_zeroed & RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is right_complementable & RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is vector-distributive & RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is scalar-distributive & RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is scalar-associative & RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is scalar-unital )
by ;
end;

definition
let X, Y be RealNormSpace;
func R_VectorSpace_of_BoundedLinearOperators (X,Y) -> RealLinearSpace equals :: LOPBAN_1:def 10
RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #);
coherence
RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #) is RealLinearSpace
;
end;

:: deftheorem defines R_VectorSpace_of_BoundedLinearOperators LOPBAN_1:def 10 :
for X, Y being RealNormSpace holds R_VectorSpace_of_BoundedLinearOperators (X,Y) = RLSStruct(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())) #);

registration
let X, Y be RealNormSpace;
coherence ;
end;

registration
let X, Y be RealNormSpace;
cluster -> Relation-like Function-like for Element of the carrier of ;
coherence
for b1 being Element of holds
( b1 is Function-like & b1 is Relation-like )
;
end;

definition
let X, Y be RealNormSpace;
let f be Element of ;
let v be VECTOR of X;
:: original: .
redefine func f . v -> VECTOR of Y;
coherence
f . v is VECTOR of Y
proof end;
end;

theorem Th24: :: LOPBAN_1:24
for X, Y being RealNormSpace
for f, g, h being VECTOR of holds
( h = f + g iff for x being VECTOR of X holds h . x = (f . x) + (g . x) )
proof end;

theorem Th25: :: LOPBAN_1:25
for X, Y being RealNormSpace
for f, h being VECTOR of
for a being Real holds
( h = a * f iff for x being VECTOR of X holds h . x = a * (f . x) )
proof end;

theorem Th26: :: LOPBAN_1:26
for X, Y being RealNormSpace holds 0. = the carrier of X --> (0. Y)
proof end;

definition
let X, Y be RealNormSpace;
let f be object ;
assume A1: f in BoundedLinearOperators (X,Y) ;
func modetrans (f,X,Y) -> Lipschitzian LinearOperator of X,Y equals :Def11: :: LOPBAN_1:def 11
f;
coherence
f is Lipschitzian LinearOperator of X,Y
by ;
end;

:: deftheorem Def11 defines modetrans LOPBAN_1:def 11 :
for X, Y being RealNormSpace
for f being object st f in BoundedLinearOperators (X,Y) holds
modetrans (f,X,Y) = f;

definition
let X, Y be RealNormSpace;
let u be LinearOperator of X,Y;
func PreNorms u -> non empty Subset of REAL equals :: LOPBAN_1:def 12
{ ||.(u . t).|| where t is VECTOR of X : <= 1 } ;
coherence
{ ||.(u . t).|| where t is VECTOR of X : <= 1 } is non empty Subset of REAL
proof end;
end;

:: deftheorem defines PreNorms LOPBAN_1:def 12 :
for X, Y being RealNormSpace
for u being LinearOperator of X,Y holds PreNorms u = { ||.(u . t).|| where t is VECTOR of X : <= 1 } ;

theorem Th27: :: LOPBAN_1:27
for X, Y being RealNormSpace
for g being Lipschitzian LinearOperator of X,Y holds PreNorms g is bounded_above
proof end;

theorem :: LOPBAN_1:28
for X, Y being RealNormSpace
for g being LinearOperator of X,Y holds
( g is Lipschitzian iff PreNorms g is bounded_above )
proof end;

definition
let X, Y be RealNormSpace;
func BoundedLinearOperatorsNorm (X,Y) -> Function of (),REAL means :Def13: :: LOPBAN_1:def 13
for x being object st x in BoundedLinearOperators (X,Y) holds
it . x = upper_bound (PreNorms (modetrans (x,X,Y)));
existence
ex b1 being Function of (),REAL st
for x being object st x in BoundedLinearOperators (X,Y) holds
b1 . x = upper_bound (PreNorms (modetrans (x,X,Y)))
proof end;
uniqueness
for b1, b2 being Function of (),REAL st ( for x being object st x in BoundedLinearOperators (X,Y) holds
b1 . x = upper_bound (PreNorms (modetrans (x,X,Y))) ) & ( for x being object st x in BoundedLinearOperators (X,Y) holds
b2 . x = upper_bound (PreNorms (modetrans (x,X,Y))) ) holds
b1 = b2
proof end;
end;

:: deftheorem Def13 defines BoundedLinearOperatorsNorm LOPBAN_1:def 13 :
for X, Y being RealNormSpace
for b3 being Function of (),REAL holds
( b3 = BoundedLinearOperatorsNorm (X,Y) iff for x being object st x in BoundedLinearOperators (X,Y) holds
b3 . x = upper_bound (PreNorms (modetrans (x,X,Y))) );

theorem Th29: :: LOPBAN_1:29
for X, Y being RealNormSpace
for f being Lipschitzian LinearOperator of X,Y holds modetrans (f,X,Y) = f
proof end;

theorem Th30: :: LOPBAN_1:30
for X, Y being RealNormSpace
for f being Lipschitzian LinearOperator of X,Y holds () . f = upper_bound ()
proof end;

definition
let X, Y be RealNormSpace;
func R_NormSpace_of_BoundedLinearOperators (X,Y) -> non empty NORMSTR equals :: LOPBAN_1:def 14
NORMSTR(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())),() #);
coherence
NORMSTR(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())),() #) is non empty NORMSTR
;
end;

:: deftheorem defines R_NormSpace_of_BoundedLinearOperators LOPBAN_1:def 14 :
for X, Y being RealNormSpace holds R_NormSpace_of_BoundedLinearOperators (X,Y) = NORMSTR(# (),(Zero_ ((),())),(Add_ ((),())),(Mult_ ((),())),() #);

theorem Th31: :: LOPBAN_1:31
for X, Y being RealNormSpace holds the carrier of X --> (0. Y) = 0.
proof end;

theorem Th32: :: LOPBAN_1:32
for X, Y being RealNormSpace
for f being Point of
for g being Lipschitzian LinearOperator of X,Y st g = f holds
for t being VECTOR of X holds ||.(g . t).|| <= *
proof end;

theorem Th33: :: LOPBAN_1:33
for X, Y being RealNormSpace
for f being Point of holds 0 <=
proof end;

theorem Th34: :: LOPBAN_1:34
for X, Y being RealNormSpace
for f being Point of st f = 0. holds
0 =
proof end;

registration
let X, Y be RealNormSpace;
cluster -> Relation-like Function-like for Element of the carrier of ;
coherence
for b1 being Element of holds
( b1 is Function-like & b1 is Relation-like )
;
end;

definition
let X, Y be RealNormSpace;
let f be Element of ;
let v be VECTOR of X;
:: original: .
redefine func f . v -> VECTOR of Y;
coherence
f . v is VECTOR of Y
proof end;
end;

theorem Th35: :: LOPBAN_1:35
for X, Y being RealNormSpace
for f, g, h being Point of holds
( h = f + g iff for x being VECTOR of X holds h . x = (f . x) + (g . x) )
proof end;

theorem Th36: :: LOPBAN_1:36
for X, Y being RealNormSpace
for f, h being Point of
for a being Real holds
( h = a * f iff for x being VECTOR of X holds h . x = a * (f . x) )
proof end;

theorem Th37: :: LOPBAN_1:37
for X, Y being RealNormSpace
for f, g being Point of
for a being Real holds
( ( = 0 implies f = 0. ) & ( f = 0. implies = 0 ) & ||.(a * f).|| = |.a.| * & ||.(f + g).|| <= + )
proof end;

theorem Th38: :: LOPBAN_1:38
for X, Y being RealNormSpace holds
( R_NormSpace_of_BoundedLinearOperators (X,Y) is reflexive & R_NormSpace_of_BoundedLinearOperators (X,Y) is discerning & R_NormSpace_of_BoundedLinearOperators (X,Y) is RealNormSpace-like )
proof end;

theorem Th39: :: LOPBAN_1:39
for X, Y being RealNormSpace holds R_NormSpace_of_BoundedLinearOperators (X,Y) is RealNormSpace
proof end;

registration
let X, Y be RealNormSpace;
coherence by Th39;
end;

theorem Th40: :: LOPBAN_1:40
for X, Y being RealNormSpace
for f, g, h being Point of holds
( h = f - g iff for x being VECTOR of X holds h . x = (f . x) - (g . x) )
proof end;

definition
let X be RealNormSpace;
attr X is complete means :Def15: :: LOPBAN_1:def 15
for seq being sequence of X st seq is Cauchy_sequence_by_Norm holds
seq is convergent ;
end;

:: deftheorem Def15 defines complete LOPBAN_1:def 15 :
for X being RealNormSpace holds
( X is complete iff for seq being sequence of X st seq is Cauchy_sequence_by_Norm holds
seq is convergent );

registration
existence
ex b1 being RealNormSpace st b1 is complete
by ;
end;

definition end;

Lm3: for e being Real
for seq being Real_Sequence st seq is convergent & ex k being Nat st
for i being Nat st k <= i holds
seq . i <= e holds
lim seq <= e

proof end;

theorem Th41: :: LOPBAN_1:41
for X being RealNormSpace
for seq being sequence of X st seq is convergent holds
( ||.seq.|| is convergent & lim ||.seq.|| = ||.(lim seq).|| )
proof end;

theorem Th42: :: LOPBAN_1:42
for X, Y being RealNormSpace st Y is complete holds
for seq being sequence of st seq is Cauchy_sequence_by_Norm holds
seq is convergent
proof end;

theorem Th43: :: LOPBAN_1:43
for X being RealNormSpace
for Y being RealBanachSpace holds R_NormSpace_of_BoundedLinearOperators (X,Y) is RealBanachSpace
proof end;

registration
let X be RealNormSpace;
let Y be RealBanachSpace;
coherence by Th43;
end;