Article C0SP1, MML version 4.99.1005

:: C0SP1:attrnot 1 => C0SP1:attr 1
definition
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is having-inverse means
    for b1 being Element of the carrier of a1
          st b1 in a2
       holds - b1 in a2;
end;

:: C0SP1:dfs 1
definiens
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is having-inverse
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
          st b1 in a2
       holds - b1 in a2;

:: C0SP1:def 1
theorem
for b1 being non empty addLoopStr
for b2 being Element of bool the carrier of b1 holds
      b2 is having-inverse(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 in b2
         holds - b3 in b2;

:: C0SP1:attrnot 2 => C0SP1:attr 2
definition
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is additively-closed means
    a2 is add-closed(a1) & a2 is having-inverse(a1);
end;

:: C0SP1:dfs 2
definiens
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is additively-closed
it is sufficient to prove
  thus a2 is add-closed(a1) & a2 is having-inverse(a1);

:: C0SP1:def 2
theorem
for b1 being non empty addLoopStr
for b2 being Element of bool the carrier of b1 holds
      b2 is additively-closed(b1)
   iff
      b2 is add-closed(b1) & b2 is having-inverse(b1);

:: C0SP1:funcreg 1
registration
  let a1 be non empty addLoopStr;
  cluster [#] a1 -> add-closed having-inverse;
end;

:: C0SP1:condreg 1
registration
  let a1 be non empty doubleLoopStr;
  cluster additively-closed -> add-closed having-inverse (Element of bool the carrier of a1);
end;

:: C0SP1:condreg 2
registration
  let a1 be non empty doubleLoopStr;
  cluster add-closed having-inverse -> additively-closed (Element of bool the carrier of a1);
end;

:: C0SP1:exreg 1
registration
  let a1 be non empty addLoopStr;
  cluster non empty add-closed having-inverse Element of bool the carrier of a1;
end;

:: C0SP1:modenot 1 => C0SP1:mode 1
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  mode Subring of A1 -> non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr means
    the carrier of it c= the carrier of a1 & the addF of it = (the addF of a1) || the carrier of it & the multF of it = (the multF of a1) || the carrier of it & 1. it = 1. a1 & 0. it = 0. a1;
end;

:: C0SP1:dfs 3
definiens
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
To prove
     a2 is Subring of a1
it is sufficient to prove
  thus the carrier of a2 c= the carrier of a1 &
     the addF of a2 = (the addF of a1) || the carrier of a2 &
     the multF of a2 = (the multF of a1) || the carrier of a2 &
     1. a2 = 1. a1 &
     0. a2 = 0. a1;

:: C0SP1:def 3
theorem
for b1, b2 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr holds
   b2 is Subring of b1
iff
   the carrier of b2 c= the carrier of b1 &
    the addF of b2 = (the addF of b1) || the carrier of b2 &
    the multF of b2 = (the multF of b1) || the carrier of b2 &
    1. b2 = 1. b1 &
    0. b2 = 0. b1;

:: C0SP1:th 1
theorem
for b1 being non empty set
for b2, b3 being Element of b1
for b4, b5 being Function-like quasi_total Relation of [:b1,b1:],b1
for b6 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b7 being Element of bool the carrier of b6
      st b7 = b1 & b4 = (the addF of b6) || b7 & b5 = (the multF of b6) || b7 & b2 = 1. b6 & b3 = 0. b6 & b7 is having-inverse(b6)
   holds doubleLoopStr(#b1,b4,b5,b2,b3#) is Subring of b6;

:: C0SP1:exreg 2
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;
  cluster non empty left_complementable right_complementable complementable strict Abelian add-associative right_zeroed zeroed unital associative right-distributive left-distributive right_unital well-unital distributive left_unital Subring of a1;
end;

:: C0SP1:attrnot 3 => C0SP1:attr 3
definition
  let a1 be non empty multLoopStr_0;
  let a2 be Element of bool the carrier of a1;
  attr a2 is multiplicatively-closed means
    1. a1 in a2 &
     (for b1, b2 being Element of the carrier of a1
           st b1 in a2 & b2 in a2
        holds b1 * b2 in a2);
end;

:: C0SP1:dfs 4
definiens
  let a1 be non empty multLoopStr_0;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is multiplicatively-closed
it is sufficient to prove
  thus 1. a1 in a2 &
     (for b1, b2 being Element of the carrier of a1
           st b1 in a2 & b2 in a2
        holds b1 * b2 in a2);

:: C0SP1:def 4
theorem
for b1 being non empty multLoopStr_0
for b2 being Element of bool the carrier of b1 holds
      b2 is multiplicatively-closed(b1)
   iff
      1. b1 in b2 &
       (for b3, b4 being Element of the carrier of b1
             st b3 in b2 & b4 in b2
          holds b3 * b4 in b2);

:: C0SP1:funcnot 1 => C0SP1:func 1
definition
  let a1 be non empty addLoopStr;
  let a2 be Element of bool the carrier of a1;
  assume a2 is add-closed(a1) & a2 is not empty;
  func Add_(A2,A1) -> Function-like quasi_total Relation of [:a2,a2:],a2 equals
    (the addF of a1) || a2;
end;

:: C0SP1:def 5
theorem
for b1 being non empty addLoopStr
for b2 being Element of bool the carrier of b1
      st b2 is add-closed(b1) & b2 is not empty
   holds Add_(b2,b1) = (the addF of b1) || b2;

:: C0SP1:funcnot 2 => C0SP1:func 2
definition
  let a1 be non empty multLoopStr_0;
  let a2 be Element of bool the carrier of a1;
  assume a2 is multiplicatively-closed(a1) & a2 is not empty;
  func mult_(A2,A1) -> Function-like quasi_total Relation of [:a2,a2:],a2 equals
    (the multF of a1) || a2;
end;

:: C0SP1:def 6
theorem
for b1 being non empty multLoopStr_0
for b2 being Element of bool the carrier of b1
      st b2 is multiplicatively-closed(b1) & b2 is not empty
   holds mult_(b2,b1) = (the multF of b1) || b2;

:: C0SP1:funcnot 3 => C0SP1:func 3
definition
  let a1 be non empty right_complementable add-associative right_zeroed doubleLoopStr;
  let a2 be Element of bool the carrier of a1;
  assume a2 is add-closed(a1) & a2 is having-inverse(a1) & a2 is not empty;
  func Zero_(A2,A1) -> Element of a2 equals
    0. a1;
end;

:: C0SP1:def 7
theorem
for b1 being non empty right_complementable add-associative right_zeroed doubleLoopStr
for b2 being Element of bool the carrier of b1
      st b2 is add-closed(b1) & b2 is having-inverse(b1) & b2 is not empty
   holds Zero_(b2,b1) = 0. b1;

:: C0SP1:funcnot 4 => C0SP1:func 4
definition
  let a1 be non empty multLoopStr_0;
  let a2 be Element of bool the carrier of a1;
  assume a2 is multiplicatively-closed(a1) & a2 is not empty;
  func One_(A2,A1) -> Element of a2 equals
    1. a1;
end;

:: C0SP1:def 8
theorem
for b1 being non empty multLoopStr_0
for b2 being Element of bool the carrier of b1
      st b2 is multiplicatively-closed(b1) & b2 is not empty
   holds One_(b2,b1) = 1. b1;

:: C0SP1:th 2
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr
for b2 being Element of bool the carrier of b1
      st b2 is additively-closed(b1) & b2 is multiplicatively-closed(b1) & b2 is not empty
   holds doubleLoopStr(#b2,Add_(b2,b1),mult_(b2,b1),One_(b2,b1),Zero_(b2,b1)#) is non empty right_complementable Abelian add-associative right_zeroed associative well-unital distributive doubleLoopStr;

:: C0SP1:modenot 2 => C0SP1:mode 2
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;
  mode Subalgebra of A1 -> non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr means
    the carrier of it c= the carrier of a1 &
     the addF of it = (the addF of a1) || the carrier of it &
     the multF of it = (the multF of a1) || the carrier of it &
     the Mult of it = (the Mult of a1) | [:REAL,the carrier of it:] &
     1. it = 1. a1 &
     0. it = 0. a1;
end;

:: C0SP1:dfs 9
definiens
  let a1, a2 be non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;
To prove
     a2 is Subalgebra of a1
it is sufficient to prove
  thus the carrier of a2 c= the carrier of a1 &
     the addF of a2 = (the addF of a1) || the carrier of a2 &
     the multF of a2 = (the multF of a1) || the carrier of a2 &
     the Mult of a2 = (the Mult of a1) | [:REAL,the carrier of a2:] &
     1. a2 = 1. a1 &
     0. a2 = 0. a1;

:: C0SP1:def 9
theorem
for b1, b2 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr holds
   b2 is Subalgebra of b1
iff
   the carrier of b2 c= the carrier of b1 &
    the addF of b2 = (the addF of b1) || the carrier of b2 &
    the multF of b2 = (the multF of b1) || the carrier of b2 &
    the Mult of b2 = (the Mult of b1) | [:REAL,the carrier of b2:] &
    1. b2 = 1. b1 &
    0. b2 = 0. b1;

:: C0SP1:th 3
theorem
for b1 being non empty set
for b2, b3 being Element of b1
for b4, b5 being Function-like quasi_total Relation of [:b1,b1:],b1
for b6 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr
for b7 being Element of bool the carrier of b6
for b8 being Function-like quasi_total Relation of [:REAL,b1:],b1
      st b7 = b1 &
         b2 = 0. b6 &
         b3 = 1. b6 &
         b4 = (the addF of b6) || b7 &
         b5 = (the multF of b6) || b7 &
         b8 = (the Mult of b6) | [:REAL,b7:] &
         b7 is having-inverse(b6)
   holds AlgebraStr(#b1,b5,b4,b8,b3,b2#) is Subalgebra of b6;

:: C0SP1:exreg 3
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;
  cluster non empty left_complementable right_complementable complementable Abelian add-associative right_zeroed zeroed strict Algebra-like unital associative commutative right-distributive left-distributive right_unital well-unital distributive left_unital Subalgebra of a1;
end;

:: C0SP1:attrnot 4 => C0SP1:attr 4
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is additively-linearly-closed means
    a2 is add-closed(a1) &
     a2 is having-inverse(a1) &
     (for b1 being Element of REAL
     for b2 being Element of the carrier of a1
           st b2 in a2
        holds b1 * b2 in a2);
end;

:: C0SP1:dfs 10
definiens
  let a1 be non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is additively-linearly-closed
it is sufficient to prove
  thus a2 is add-closed(a1) &
     a2 is having-inverse(a1) &
     (for b1 being Element of REAL
     for b2 being Element of the carrier of a1
           st b2 in a2
        holds b1 * b2 in a2);

:: C0SP1:def 10
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr
for b2 being Element of bool the carrier of b1 holds
      b2 is additively-linearly-closed(b1)
   iff
      b2 is add-closed(b1) &
       b2 is having-inverse(b1) &
       (for b3 being Element of REAL
       for b4 being Element of the carrier of b1
             st b4 in b2
          holds b3 * b4 in b2);

:: C0SP1:condreg 3
registration
  let a1 be non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;
  cluster additively-linearly-closed -> additively-closed (Element of bool the carrier of a1);
end;

:: C0SP1:funcnot 5 => C0SP1:func 5
definition
  let a1 be non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;
  let a2 be Element of bool the carrier of a1;
  assume a2 is additively-linearly-closed(a1) & a2 is not empty;
  func Mult_(A2,A1) -> Function-like quasi_total Relation of [:REAL,a2:],a2 equals
    (the Mult of a1) | [:REAL,a2:];
end;

:: C0SP1:def 11
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr
for b2 being Element of bool the carrier of b1
      st b2 is additively-linearly-closed(b1) & b2 is not empty
   holds Mult_(b2,b1) = (the Mult of b1) | [:REAL,b2:];

:: C0SP1:attrnot 5 => C0SP1:attr 5
definition
  let a1 be non empty RLSStruct;
  attr a1 is scalar-mult-cancelable means
    for b1 being Element of REAL
    for b2 being Element of the carrier of a1
          st b1 * b2 = 0. a1 & b1 <> 0
       holds b2 = 0. a1;
end;

:: C0SP1:dfs 12
definiens
  let a1 be non empty RLSStruct;
To prove
     a1 is scalar-mult-cancelable
it is sufficient to prove
  thus for b1 being Element of REAL
    for b2 being Element of the carrier of a1
          st b1 * b2 = 0. a1 & b1 <> 0
       holds b2 = 0. a1;

:: C0SP1:def 12
theorem
for b1 being non empty RLSStruct holds
      b1 is scalar-mult-cancelable
   iff
      for b2 being Element of REAL
      for b3 being Element of the carrier of b1
            st b2 * b3 = 0. b1 & b2 <> 0
         holds b3 = 0. b1;

:: C0SP1:th 4
theorem
for b1 being non empty right_complementable add-associative right_zeroed Algebra-like AlgebraStr
for b2 being Element of REAL holds
   b2 * 0. b1 = 0. b1;

:: C0SP1:th 5
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like AlgebraStr
      st b1 is scalar-mult-cancelable
   holds b1 is non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;

:: C0SP1:th 6
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr
for b2 being Element of bool the carrier of b1
      st b2 is additively-linearly-closed(b1) & b2 is multiplicatively-closed(b1) & b2 is not empty
   holds AlgebraStr(#b2,mult_(b2,b1),Add_(b2,b1),Mult_(b2,b1),One_(b2,b1),Zero_(b2,b1)#) is Subalgebra of b1;

:: C0SP1:funcreg 2
registration
  let a1 be non empty set;
  cluster RAlgebra a1 -> right_complementable Abelian add-associative right_zeroed strict Algebra-like associative commutative right-distributive right_unital;
end;

:: C0SP1:th 7
theorem
for b1 being non empty set holds
   RAlgebra b1 is non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;

:: C0SP1:th 8
theorem
for b1 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr
for b2 being Subalgebra of b1 holds
   (for b3, b4 being Element of the carrier of b2
    for b5, b6 being Element of the carrier of b1
          st b3 = b5 & b4 = b6
       holds b3 + b4 = b5 + b6) &
    (for b3, b4 being Element of the carrier of b2
    for b5, b6 being Element of the carrier of b1
          st b3 = b5 & b4 = b6
       holds b3 * b4 = b5 * b6) &
    (for b3 being Element of the carrier of b2
    for b4 being Element of the carrier of b1
    for b5 being Element of REAL
          st b3 = b4
       holds b5 * b3 = b5 * b4) &
    1_ b2 = 1_ b1 &
    0. b2 = 0. b1;

:: C0SP1:funcnot 6 => C0SP1:func 6
definition
  let a1 be non empty set;
  func BoundedFunctions A1 -> non empty Element of bool the carrier of RAlgebra a1 equals
    {b1 where b1 is Function-like quasi_total Relation of a1,REAL: b1 is_bounded_on a1};
end;

:: C0SP1:def 13
theorem
for b1 being non empty set holds
   BoundedFunctions b1 = {b2 where b2 is Function-like quasi_total Relation of b1,REAL: b2 is_bounded_on b1};

:: C0SP1:th 9
theorem
for b1 being non empty set holds
   BoundedFunctions b1 is additively-linearly-closed(RAlgebra b1) & BoundedFunctions b1 is multiplicatively-closed(RAlgebra b1);

:: C0SP1:funcreg 3
registration
  let a1 be non empty set;
  cluster BoundedFunctions a1 -> non empty multiplicatively-closed additively-linearly-closed;
end;

:: C0SP1:th 10
theorem
for b1 being non empty set holds
   AlgebraStr(#BoundedFunctions b1,mult_(BoundedFunctions b1,RAlgebra b1),Add_(BoundedFunctions b1,RAlgebra b1),Mult_(BoundedFunctions b1,RAlgebra b1),One_(BoundedFunctions b1,RAlgebra b1),Zero_(BoundedFunctions b1,RAlgebra b1)#) is Subalgebra of RAlgebra b1;

:: C0SP1:funcnot 7 => C0SP1:func 7
definition
  let a1 be non empty set;
  func R_Algebra_of_BoundedFunctions A1 -> non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr equals
    AlgebraStr(#BoundedFunctions a1,mult_(BoundedFunctions a1,RAlgebra a1),Add_(BoundedFunctions a1,RAlgebra a1),Mult_(BoundedFunctions a1,RAlgebra a1),One_(BoundedFunctions a1,RAlgebra a1),Zero_(BoundedFunctions a1,RAlgebra a1)#);
end;

:: C0SP1:def 14
theorem
for b1 being non empty set holds
   R_Algebra_of_BoundedFunctions b1 = AlgebraStr(#BoundedFunctions b1,mult_(BoundedFunctions b1,RAlgebra b1),Add_(BoundedFunctions b1,RAlgebra b1),Mult_(BoundedFunctions b1,RAlgebra b1),One_(BoundedFunctions b1,RAlgebra b1),Zero_(BoundedFunctions b1,RAlgebra b1)#);

:: C0SP1:th 11
theorem
for b1 being non empty set holds
   R_Algebra_of_BoundedFunctions b1 is non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;

:: C0SP1:th 12
theorem
for b1 being non empty set
for b2, b3, b4 being Element of the carrier of R_Algebra_of_BoundedFunctions b1
for b5, b6, b7 being Function-like quasi_total Relation of b1,REAL
      st b5 = b2 & b6 = b3 & b7 = b4
   holds    b4 = b2 + b3
   iff
      for b8 being Element of b1 holds
         b7 . b8 = (b5 . b8) + (b6 . b8);

:: C0SP1:th 13
theorem
for b1 being non empty set
for b2 being Element of REAL
for b3, b4 being Element of the carrier of R_Algebra_of_BoundedFunctions b1
for b5, b6 being Function-like quasi_total Relation of b1,REAL
      st b5 = b3 & b6 = b4
   holds    b4 = b2 * b3
   iff
      for b7 being Element of b1 holds
         b6 . b7 = b2 * (b5 . b7);

:: C0SP1:th 14
theorem
for b1 being non empty set
for b2, b3, b4 being Element of the carrier of R_Algebra_of_BoundedFunctions b1
for b5, b6, b7 being Function-like quasi_total Relation of b1,REAL
      st b5 = b2 & b6 = b3 & b7 = b4
   holds    b4 = b2 * b3
   iff
      for b8 being Element of b1 holds
         b7 . b8 = (b5 . b8) * (b6 . b8);

:: C0SP1:th 15
theorem
for b1 being non empty set holds
   0. R_Algebra_of_BoundedFunctions b1 = b1 --> 0;

:: C0SP1:th 16
theorem
for b1 being non empty set holds
   1_ R_Algebra_of_BoundedFunctions b1 = b1 --> 1;

:: C0SP1:funcnot 8 => C0SP1:func 8
definition
  let a1 be non empty set;
  let a2 be set;
  assume a2 in BoundedFunctions a1;
  func modetrans(A2,A1) -> Function-like quasi_total Relation of a1,REAL means
    it = a2 & it is_bounded_on a1;
end;

:: C0SP1:def 15
theorem
for b1 being non empty set
for b2 being set
   st b2 in BoundedFunctions b1
for b3 being Function-like quasi_total Relation of b1,REAL holds
      b3 = modetrans(b2,b1)
   iff
      b3 = b2 & b3 is_bounded_on b1;

:: C0SP1:funcnot 9 => C0SP1:func 9
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of a1,REAL;
  func PreNorms A2 -> non empty Element of bool REAL equals
    {abs (a2 . b1) where b1 is Element of a1: TRUE};
end;

:: C0SP1:def 16
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of b1,REAL holds
   PreNorms b2 = {abs (b2 . b3) where b3 is Element of b1: TRUE};

:: C0SP1:th 17
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of b1,REAL
      st b2 is_bounded_on b1
   holds PreNorms b2 is not empty & PreNorms b2 is bounded_above;

:: C0SP1:th 18
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of b1,REAL holds
      b2 is_bounded_on b1
   iff
      PreNorms b2 is bounded_above;

:: C0SP1:th 19
theorem
for b1 being non empty set holds
   ex b2 being Function-like quasi_total Relation of BoundedFunctions b1,REAL st
      for b3 being set
            st b3 in BoundedFunctions b1
         holds b2 . b3 = sup PreNorms modetrans(b3,b1);

:: C0SP1:funcnot 10 => C0SP1:func 10
definition
  let a1 be non empty set;
  func BoundedFunctionsNorm A1 -> Function-like quasi_total Relation of BoundedFunctions a1,REAL means
    for b1 being set
          st b1 in BoundedFunctions a1
       holds it . b1 = sup PreNorms modetrans(b1,a1);
end;

:: C0SP1:def 17
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of BoundedFunctions b1,REAL holds
      b2 = BoundedFunctionsNorm b1
   iff
      for b3 being set
            st b3 in BoundedFunctions b1
         holds b2 . b3 = sup PreNorms modetrans(b3,b1);

:: C0SP1:th 20
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of b1,REAL
      st b2 is_bounded_on b1
   holds modetrans(b2,b1) = b2;

:: C0SP1:th 21
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of b1,REAL
      st b2 is_bounded_on b1
   holds (BoundedFunctionsNorm b1) . b2 = sup PreNorms b2;

:: C0SP1:funcnot 11 => C0SP1:func 11
definition
  let a1 be non empty set;
  func R_Normed_Algebra_of_BoundedFunctions A1 -> Normed_AlgebraStr equals
    Normed_AlgebraStr(#BoundedFunctions a1,mult_(BoundedFunctions a1,RAlgebra a1),Add_(BoundedFunctions a1,RAlgebra a1),Mult_(BoundedFunctions a1,RAlgebra a1),One_(BoundedFunctions a1,RAlgebra a1),Zero_(BoundedFunctions a1,RAlgebra a1),BoundedFunctionsNorm a1#);
end;

:: C0SP1:def 18
theorem
for b1 being non empty set holds
   R_Normed_Algebra_of_BoundedFunctions b1 = Normed_AlgebraStr(#BoundedFunctions b1,mult_(BoundedFunctions b1,RAlgebra b1),Add_(BoundedFunctions b1,RAlgebra b1),Mult_(BoundedFunctions b1,RAlgebra b1),One_(BoundedFunctions b1,RAlgebra b1),Zero_(BoundedFunctions b1,RAlgebra b1),BoundedFunctionsNorm b1#);

:: C0SP1:funcreg 4
registration
  let a1 be non empty set;
  cluster R_Normed_Algebra_of_BoundedFunctions a1 -> non empty;
end;

:: C0SP1:funcreg 5
registration
  let a1 be non empty set;
  cluster R_Normed_Algebra_of_BoundedFunctions a1 -> unital;
end;

:: C0SP1:th 22
theorem
for b1 being Normed_AlgebraStr
for b2 being non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr
      st AlgebraStr(#the carrier of b1,the multF of b1,the addF of b1,the Mult of b1,the OneF of b1,the ZeroF of b1#) = b2 &
         1. b2 = 1. b1
   holds b1 is non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;

:: C0SP1:th 23
theorem
for b1 being non empty set holds
   R_Normed_Algebra_of_BoundedFunctions b1 is non empty right_complementable Abelian add-associative right_zeroed Algebra-like associative commutative right-distributive right_unital AlgebraStr;

:: C0SP1:th 24
theorem
for b1 being non empty set
for b2 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1 holds
   (Mult_(BoundedFunctions b1,RAlgebra b1)) .(1,b2) = b2;

:: C0SP1:th 25
theorem
for b1 being non empty set holds
   R_Normed_Algebra_of_BoundedFunctions b1 is non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;

:: C0SP1:th 26
theorem
for b1 being non empty set holds
   b1 --> 0 = 0. R_Normed_Algebra_of_BoundedFunctions b1;

:: C0SP1:th 27
theorem
for b1 being non empty set
for b2 being Element of b1
for b3 being Function-like quasi_total Relation of b1,REAL
for b4 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1
      st b3 = b4 & b3 is_bounded_on b1
   holds abs (b3 . b2) <= ||.b4.||;

:: C0SP1:th 28
theorem
for b1 being non empty set
for b2 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1 holds
   0 <= ||.b2.||;

:: C0SP1:th 29
theorem
for b1 being non empty set
for b2 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1
      st b2 = 0. R_Normed_Algebra_of_BoundedFunctions b1
   holds 0 = ||.b2.||;

:: C0SP1:th 30
theorem
for b1 being non empty set
for b2, b3, b4 being Function-like quasi_total Relation of b1,REAL
for b5, b6, b7 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1
      st b2 = b5 & b3 = b6 & b4 = b7
   holds    b7 = b5 + b6
   iff
      for b8 being Element of b1 holds
         b4 . b8 = (b2 . b8) + (b3 . b8);

:: C0SP1:th 31
theorem
for b1 being non empty set
for b2 being Element of REAL
for b3, b4 being Function-like quasi_total Relation of b1,REAL
for b5, b6 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1
      st b3 = b5 & b4 = b6
   holds    b6 = b2 * b5
   iff
      for b7 being Element of b1 holds
         b4 . b7 = b2 * (b3 . b7);

:: C0SP1:th 32
theorem
for b1 being non empty set
for b2, b3, b4 being Function-like quasi_total Relation of b1,REAL
for b5, b6, b7 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1
      st b2 = b5 & b3 = b6 & b4 = b7
   holds    b7 = b5 * b6
   iff
      for b8 being Element of b1 holds
         b4 . b8 = (b2 . b8) * (b3 . b8);

:: C0SP1:th 33
theorem
for b1 being non empty set
for b2 being Element of REAL
for b3, b4 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1 holds
(||.b3.|| = 0 implies b3 = 0. R_Normed_Algebra_of_BoundedFunctions b1) &
 (b3 = 0. R_Normed_Algebra_of_BoundedFunctions b1 implies ||.b3.|| = 0) &
 ||.b2 * b3.|| = (abs b2) * ||.b3.|| &
 ||.b3 + b4.|| <= ||.b3.|| + ||.b4.||;

:: C0SP1:th 34
theorem
for b1 being non empty set holds
   R_Normed_Algebra_of_BoundedFunctions b1 is RealNormSpace-like;

:: C0SP1:funcreg 6
registration
  let a1 be non empty set;
  cluster R_Normed_Algebra_of_BoundedFunctions a1 -> right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RealNormSpace-like;
end;

:: C0SP1:th 35
theorem
for b1 being non empty set
for b2, b3, b4 being Function-like quasi_total Relation of b1,REAL
for b5, b6, b7 being Element of the carrier of R_Normed_Algebra_of_BoundedFunctions b1
      st b2 = b5 & b3 = b6 & b4 = b7
   holds    b7 = b5 - b6
   iff
      for b8 being Element of b1 holds
         b4 . b8 = (b2 . b8) - (b3 . b8);

:: C0SP1:th 36
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,the carrier of R_Normed_Algebra_of_BoundedFunctions b1
      st b2 is CCauchy(R_Normed_Algebra_of_BoundedFunctions b1)
   holds b2 is convergent(R_Normed_Algebra_of_BoundedFunctions b1);

:: C0SP1:th 37
theorem
for b1 being non empty set holds
   R_Normed_Algebra_of_BoundedFunctions b1 is non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RealNormSpace-like complete NORMSTR;

:: C0SP1:funcreg 7
registration
  let a1 be non empty set;
  cluster R_Normed_Algebra_of_BoundedFunctions a1 -> complete;
end;

:: C0SP1:th 38
theorem
for b1 being non empty set holds
   R_Normed_Algebra_of_BoundedFunctions b1 is non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RealNormSpace-like Algebra-like associative right-distributive right_unital Banach_Algebra-like Normed_AlgebraStr;