Article FUNCSDOM, MML version 4.99.1005

:: FUNCSDOM:funcnot 1 => FUNCSDOM:func 1
definition
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:Funcs(a1,a2),Funcs(a1,a2):],Funcs(a1,a2);
  let a4, a5 be Element of Funcs(a1,a2);
  redefine func a3 .(a4,a5) -> Element of Funcs(a1,a2);
end;

:: FUNCSDOM:funcnot 2 => FUNCSDOM:func 2
definition
  let a1, a2, a3, a4 be non empty set;
  let a5 be Function-like quasi_total Relation of [:a3,a4:],Funcs(a1,a2);
  let a6 be Element of [:a3,a4:];
  redefine func a5 . a6 -> Element of Funcs(a1,a2);
end;

:: FUNCSDOM:funcnot 3 => FUNCSDOM:func 3
definition
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  func @ A3 -> Element of Funcs(a1,a2) equals
    a3;
end;

:: FUNCSDOM:def 1
theorem
for b1, b2 being non empty set
for b3 being Function-like quasi_total Relation of b1,b2 holds
   @ b3 = b3;

:: FUNCSDOM:funcnot 4 => FUNCSDOM:func 4
definition
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4, a5 be Function-like quasi_total Relation of a2,a1;
  redefine func a3 .:(a4,a5) -> Element of Funcs(a2,a1);
end;

:: FUNCSDOM:funcnot 5 => FUNCSDOM:func 5
definition
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4 be Element of a1;
  let a5 be Function-like quasi_total Relation of a2,a1;
  redefine func a3 [;](a4,a5) -> Element of Funcs(a2,a1);
end;

:: FUNCSDOM:funcnot 6 => FUNCSDOM:func 6
definition
  let a1 be non empty set;
  func RealFuncAdd A1 -> Function-like quasi_total Relation of [:Funcs(a1,REAL),Funcs(a1,REAL):],Funcs(a1,REAL) means
    for b1, b2 being Element of Funcs(a1,REAL) holds
    it .(b1,b2) = addreal .:(b1,b2);
end;

:: FUNCSDOM:def 2
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:Funcs(b1,REAL),Funcs(b1,REAL):],Funcs(b1,REAL) holds
      b2 = RealFuncAdd b1
   iff
      for b3, b4 being Element of Funcs(b1,REAL) holds
      b2 .(b3,b4) = addreal .:(b3,b4);

:: FUNCSDOM:funcnot 7 => FUNCSDOM:func 7
definition
  let a1 be non empty set;
  func RealFuncMult A1 -> Function-like quasi_total Relation of [:Funcs(a1,REAL),Funcs(a1,REAL):],Funcs(a1,REAL) means
    for b1, b2 being Element of Funcs(a1,REAL) holds
    it .(b1,b2) = multreal .:(b1,b2);
end;

:: FUNCSDOM:def 3
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:Funcs(b1,REAL),Funcs(b1,REAL):],Funcs(b1,REAL) holds
      b2 = RealFuncMult b1
   iff
      for b3, b4 being Element of Funcs(b1,REAL) holds
      b2 .(b3,b4) = multreal .:(b3,b4);

:: FUNCSDOM:funcnot 8 => FUNCSDOM:func 8
definition
  let a1 be non empty set;
  func RealFuncExtMult A1 -> Function-like quasi_total Relation of [:REAL,Funcs(a1,REAL):],Funcs(a1,REAL) means
    for b1 being Element of REAL
    for b2 being Element of Funcs(a1,REAL)
    for b3 being Element of a1 holds
       (it . [b1,b2]) . b3 = b1 * (b2 . b3);
end;

:: FUNCSDOM:def 4
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of [:REAL,Funcs(b1,REAL):],Funcs(b1,REAL) holds
      b2 = RealFuncExtMult b1
   iff
      for b3 being Element of REAL
      for b4 being Element of Funcs(b1,REAL)
      for b5 being Element of b1 holds
         (b2 . [b3,b4]) . b5 = b3 * (b4 . b5);

:: FUNCSDOM:funcnot 9 => FUNCSDOM:func 9
definition
  let a1 be non empty set;
  func RealFuncZero A1 -> Element of Funcs(a1,REAL) equals
    a1 --> 0;
end;

:: FUNCSDOM:def 5
theorem
for b1 being non empty set holds
   RealFuncZero b1 = b1 --> 0;

:: FUNCSDOM:funcnot 10 => FUNCSDOM:func 10
definition
  let a1 be non empty set;
  func RealFuncUnit A1 -> Element of Funcs(a1,REAL) equals
    a1 --> 1;
end;

:: FUNCSDOM:def 6
theorem
for b1 being non empty set holds
   RealFuncUnit b1 = b1 --> 1;

:: FUNCSDOM:th 10
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,REAL) holds
   b2 = (RealFuncAdd b1) .(b3,b4)
iff
   for b5 being Element of b1 holds
      b2 . b5 = (b3 . b5) + (b4 . b5);

:: FUNCSDOM:th 11
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,REAL) holds
   b2 = (RealFuncMult b1) .(b3,b4)
iff
   for b5 being Element of b1 holds
      b2 . b5 = (b3 . b5) * (b4 . b5);

:: FUNCSDOM:th 14
theorem
for b1 being non empty set holds
   RealFuncZero b1 <> RealFuncUnit b1;

:: FUNCSDOM:th 15
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,REAL)
for b4 being Element of REAL holds
      b2 = (RealFuncExtMult b1) . [b4,b3]
   iff
      for b5 being Element of b1 holds
         b2 . b5 = b4 * (b3 . b5);

:: FUNCSDOM:th 16
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,REAL) holds
(RealFuncAdd b1) .(b2,b3) = (RealFuncAdd b1) .(b3,b2);

:: FUNCSDOM:th 17
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,REAL) holds
(RealFuncAdd b1) .(b2,(RealFuncAdd b1) .(b3,b4)) = (RealFuncAdd b1) .((RealFuncAdd b1) .(b2,b3),b4);

:: FUNCSDOM:th 18
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,REAL) holds
(RealFuncMult b1) .(b2,b3) = (RealFuncMult b1) .(b3,b2);

:: FUNCSDOM:th 19
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,REAL) holds
(RealFuncMult b1) .(b2,(RealFuncMult b1) .(b3,b4)) = (RealFuncMult b1) .((RealFuncMult b1) .(b2,b3),b4);

:: FUNCSDOM:th 20
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,REAL) holds
   (RealFuncMult b1) .(RealFuncUnit b1,b2) = b2;

:: FUNCSDOM:th 21
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,REAL) holds
   (RealFuncAdd b1) .(RealFuncZero b1,b2) = b2;

:: FUNCSDOM:th 22
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,REAL) holds
   (RealFuncAdd b1) .(b2,(RealFuncExtMult b1) . [- 1,b2]) = RealFuncZero b1;

:: FUNCSDOM:th 23
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,REAL) holds
   (RealFuncExtMult b1) . [1,b2] = b2;

:: FUNCSDOM:th 24
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,REAL)
for b3, b4 being Element of REAL holds
(RealFuncExtMult b1) . [b3,(RealFuncExtMult b1) . [b4,b2]] = (RealFuncExtMult b1) . [b3 * b4,b2];

:: FUNCSDOM:th 25
theorem
for b1 being non empty set
for b2 being Element of Funcs(b1,REAL)
for b3, b4 being Element of REAL holds
(RealFuncAdd b1) .((RealFuncExtMult b1) . [b3,b2],(RealFuncExtMult b1) . [b4,b2]) = (RealFuncExtMult b1) . [b3 + b4,b2];

:: FUNCSDOM:th 26
theorem
for b1 being non empty set
for b2, b3, b4 being Element of Funcs(b1,REAL) holds
(RealFuncMult b1) .(b2,(RealFuncAdd b1) .(b3,b4)) = (RealFuncAdd b1) .((RealFuncMult b1) .(b2,b3),(RealFuncMult b1) .(b2,b4));

:: FUNCSDOM:th 27
theorem
for b1 being non empty set
for b2, b3 being Element of Funcs(b1,REAL)
for b4 being Element of REAL holds
   (RealFuncMult b1) .((RealFuncExtMult b1) . [b4,b2],b3) = (RealFuncExtMult b1) . [b4,(RealFuncMult b1) .(b2,b3)];

:: FUNCSDOM:th 28
theorem
for b1 being set
for b2 being non empty set holds
   ex b3, b4 being Element of Funcs(b2,REAL) st
      (for b5 being set
             st b5 in b2
          holds (b5 = b1 implies b3 . b5 = 1) & (b5 = b1 or b3 . b5 = 0)) &
       (for b5 being set
             st b5 in b2
          holds (b5 = b1 implies b4 . b5 = 0) & (b5 = b1 or b4 . b5 = 1));

:: FUNCSDOM:th 29
theorem
for b1, b2 being set
for b3 being non empty set
for b4, b5 being Element of Funcs(b3,REAL)
   st b1 in b3 &
      b2 in b3 &
      b1 <> b2 &
      (for b6 being set
            st b6 in b3
         holds (b6 = b1 implies b4 . b6 = 1) & (b6 = b1 or b4 . b6 = 0)) &
      (for b6 being set
            st b6 in b3
         holds (b6 = b1 implies b5 . b6 = 0) & (b6 = b1 or b5 . b6 = 1))
for b6, b7 being Element of REAL
      st (RealFuncAdd b3) .((RealFuncExtMult b3) . [b6,b4],(RealFuncExtMult b3) . [b7,b5]) = RealFuncZero b3
   holds b6 = 0 & b7 = 0;

:: FUNCSDOM:th 30
theorem
for b1, b2 being set
for b3 being non empty set
      st b1 in b3 & b2 in b3 & b1 <> b2
   holds ex b4, b5 being Element of Funcs(b3,REAL) st
      for b6, b7 being Element of REAL
            st (RealFuncAdd b3) .((RealFuncExtMult b3) . [b6,b4],(RealFuncExtMult b3) . [b7,b5]) = RealFuncZero b3
         holds b6 = 0 & b7 = 0;

:: FUNCSDOM:th 31
theorem
for b1, b2 being set
for b3 being non empty set
for b4, b5 being Element of Funcs(b3,REAL)
   st b3 = {b1,b2} &
      b1 <> b2 &
      (for b6 being set
            st b6 in b3
         holds (b6 = b1 implies b4 . b6 = 1) & (b6 = b1 or b4 . b6 = 0)) &
      (for b6 being set
            st b6 in b3
         holds (b6 = b1 implies b5 . b6 = 0) & (b6 = b1 or b5 . b6 = 1))
for b6 being Element of Funcs(b3,REAL) holds
   ex b7, b8 being Element of REAL st
      b6 = (RealFuncAdd b3) .((RealFuncExtMult b3) . [b7,b4],(RealFuncExtMult b3) . [b8,b5]);

:: FUNCSDOM:th 32
theorem
for b1, b2 being set
for b3 being non empty set
      st b3 = {b1,b2} & b1 <> b2
   holds ex b4, b5 being Element of Funcs(b3,REAL) st
      for b6 being Element of Funcs(b3,REAL) holds
         ex b7, b8 being Element of REAL st
            b6 = (RealFuncAdd b3) .((RealFuncExtMult b3) . [b7,b4],(RealFuncExtMult b3) . [b8,b5]);

:: FUNCSDOM:th 33
theorem
for b1, b2 being set
for b3 being non empty set
      st b3 = {b1,b2} & b1 <> b2
   holds ex b4, b5 being Element of Funcs(b3,REAL) st
      (for b6, b7 being Element of REAL
             st (RealFuncAdd b3) .((RealFuncExtMult b3) . [b6,b4],(RealFuncExtMult b3) . [b7,b5]) = RealFuncZero b3
          holds b6 = 0 & b7 = 0) &
       (for b6 being Element of Funcs(b3,REAL) holds
          ex b7, b8 being Element of REAL st
             b6 = (RealFuncAdd b3) .((RealFuncExtMult b3) . [b7,b4],(RealFuncExtMult b3) . [b8,b5]));

:: FUNCSDOM:th 34
theorem
for b1 being non empty set holds
   RLSStruct(#Funcs(b1,REAL),RealFuncZero b1,RealFuncAdd b1,RealFuncExtMult b1#) is non empty right_complementable Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct;

:: FUNCSDOM:funcnot 11 => FUNCSDOM:func 11
definition
  let a1 be non empty set;
  func RealVectSpace A1 -> non empty right_complementable strict Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct equals
    RLSStruct(#Funcs(a1,REAL),RealFuncZero a1,RealFuncAdd a1,RealFuncExtMult a1#);
end;

:: FUNCSDOM:def 7
theorem
for b1 being non empty set holds
   RealVectSpace b1 = RLSStruct(#Funcs(b1,REAL),RealFuncZero b1,RealFuncAdd b1,RealFuncExtMult b1#);

:: FUNCSDOM:th 37
theorem
ex b1 being non empty right_complementable strict Abelian add-associative right_zeroed RealLinearSpace-like RLSStruct st
   ex b2, b3 being Element of the carrier of b1 st
      (for b4, b5 being Element of REAL
             st (b4 * b2) + (b5 * b3) = 0. b1
          holds b4 = 0 & b5 = 0) &
       (for b4 being Element of the carrier of b1 holds
          ex b5, b6 being Element of REAL st
             b4 = (b5 * b2) + (b6 * b3));

:: FUNCSDOM:funcnot 12 => FUNCSDOM:func 12
definition
  let a1 be non empty set;
  func RRing A1 -> strict doubleLoopStr equals
    doubleLoopStr(#Funcs(a1,REAL),RealFuncAdd a1,RealFuncMult a1,RealFuncUnit a1,RealFuncZero a1#);
end;

:: FUNCSDOM:def 12
theorem
for b1 being non empty set holds
   RRing b1 = doubleLoopStr(#Funcs(b1,REAL),RealFuncAdd b1,RealFuncMult b1,RealFuncUnit b1,RealFuncZero b1#);

:: FUNCSDOM:funcreg 1
registration
  let a1 be non empty set;
  cluster RRing a1 -> non empty strict;
end;

:: FUNCSDOM:funcreg 2
registration
  let a1 be non empty set;
  cluster RRing a1 -> strict unital;
end;

:: FUNCSDOM:th 41
theorem
for b1 being non empty set holds
   1. RRing b1 = RealFuncUnit b1;

:: FUNCSDOM:th 42
theorem
for b1 being non empty set
for b2, b3, b4 being Element of the carrier of RRing b1 holds
b2 + b3 = b3 + b2 &
 (b2 + b3) + b4 = b2 + (b3 + b4) &
 b2 + 0. RRing b1 = b2 &
 (ex b5 being Element of the carrier of RRing b1 st
    b2 + b5 = 0. RRing b1) &
 b2 * b3 = b3 * b2 &
 (b2 * b3) * b4 = b2 * (b3 * b4) &
 b2 * 1. RRing b1 = b2 &
 (1. RRing b1) * b2 = b2 &
 b2 * (b3 + b4) = (b2 * b3) + (b2 * b4) &
 (b3 + b4) * b2 = (b3 * b2) + (b4 * b2);

:: FUNCSDOM:exreg 1
registration
  cluster non empty right_complementable strict associative commutative right-distributive right_unital Abelian add-associative right_zeroed doubleLoopStr;
end;

:: FUNCSDOM:modenot 1
definition
  mode Ring is non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
end;

:: FUNCSDOM:th 43
theorem
for b1 being non empty set holds
   RRing b1 is non empty right_complementable associative commutative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;

:: FUNCSDOM:structnot 1 => FUNCSDOM:struct 1
definition
  struct(doubleLoopStrRLSStruct) AlgebraStr(#
    carrier -> set,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    Mult -> Function-like quasi_total Relation of [:REAL,the carrier of it:],the carrier of it,
    OneF -> Element of the carrier of it,
    ZeroF -> Element of the carrier of it
  #);
end;

:: FUNCSDOM:attrnot 1 => FUNCSDOM:attr 1
definition
  let a1 be AlgebraStr;
  attr a1 is strict;
end;

:: FUNCSDOM:exreg 2
registration
  cluster strict AlgebraStr;
end;

:: FUNCSDOM:aggrnot 1 => FUNCSDOM:aggr 1
definition
  let a1 be set;
  let a2, a3 be Function-like quasi_total Relation of [:a1,a1:],a1;
  let a4 be Function-like quasi_total Relation of [:REAL,a1:],a1;
  let a5, a6 be Element of a1;
  aggr AlgebraStr(#a1,a2,a3,a4,a5,a6#) -> strict AlgebraStr;
end;

:: FUNCSDOM:exreg 3
registration
  cluster non empty AlgebraStr;
end;

:: FUNCSDOM:funcnot 13 => FUNCSDOM:func 13
definition
  let a1 be non empty set;
  func RAlgebra A1 -> strict AlgebraStr equals
    AlgebraStr(#Funcs(a1,REAL),RealFuncMult a1,RealFuncAdd a1,RealFuncExtMult a1,RealFuncUnit a1,RealFuncZero a1#);
end;

:: FUNCSDOM:def 19
theorem
for b1 being non empty set holds
   RAlgebra b1 = AlgebraStr(#Funcs(b1,REAL),RealFuncMult b1,RealFuncAdd b1,RealFuncExtMult b1,RealFuncUnit b1,RealFuncZero b1#);

:: FUNCSDOM:funcreg 3
registration
  let a1 be non empty set;
  cluster RAlgebra a1 -> non empty strict;
end;

:: FUNCSDOM:funcreg 4
registration
  let a1 be non empty set;
  cluster RAlgebra a1 -> unital strict;
end;

:: FUNCSDOM:th 44
theorem
for b1 being non empty set holds
   1. RAlgebra b1 = RealFuncUnit b1;

:: FUNCSDOM:th 49
theorem
for b1 being non empty set
for b2, b3, b4 being Element of the carrier of RAlgebra b1
for b5, b6 being Element of REAL holds
b2 + b3 = b3 + b2 &
 (b2 + b3) + b4 = b2 + (b3 + b4) &
 b2 + 0. RAlgebra b1 = b2 &
 b2 * b3 = b3 * b2 &
 (b2 * b3) * b4 = b2 * (b3 * b4) &
 b2 * 1. RAlgebra b1 = b2 &
 b2 * (b3 + b4) = (b2 * b3) + (b2 * b4) &
 b5 * (b2 * b3) = (b5 * b2) * b3 &
 b5 * (b2 + b3) = (b5 * b2) + (b5 * b3) &
 (b5 + b6) * b2 = (b5 * b2) + (b6 * b2) &
 (b5 * b6) * b2 = b5 * (b6 * b2);

:: FUNCSDOM:attrnot 2 => FUNCSDOM:attr 2
definition
  let a1 be non empty AlgebraStr;
  attr a1 is Algebra-like means
    for b1, b2, b3 being Element of the carrier of a1
    for b4, b5 being Element of REAL holds
    b4 * (b1 * b2) = (b4 * b1) * b2 &
     b4 * (b1 + b2) = (b4 * b1) + (b4 * b2) &
     (b4 + b5) * b1 = (b4 * b1) + (b5 * b1) &
     (b4 * b5) * b1 = b4 * (b5 * b1);
end;

:: FUNCSDOM:dfs 10
definiens
  let a1 be non empty AlgebraStr;
To prove
     a1 is Algebra-like
it is sufficient to prove
  thus for b1, b2, b3 being Element of the carrier of a1
    for b4, b5 being Element of REAL holds
    b4 * (b1 * b2) = (b4 * b1) * b2 &
     b4 * (b1 + b2) = (b4 * b1) + (b4 * b2) &
     (b4 + b5) * b1 = (b4 * b1) + (b5 * b1) &
     (b4 * b5) * b1 = b4 * (b5 * b1);

:: FUNCSDOM:def 20
theorem
for b1 being non empty AlgebraStr holds
      b1 is Algebra-like
   iff
      for b2, b3, b4 being Element of the carrier of b1
      for b5, b6 being Element of REAL holds
      b5 * (b2 * b3) = (b5 * b2) * b3 &
       b5 * (b2 + b3) = (b5 * b2) + (b5 * b3) &
       (b5 + b6) * b2 = (b5 * b2) + (b6 * b2) &
       (b5 * b6) * b2 = b5 * (b6 * b2);

:: FUNCSDOM:exreg 4
registration
  cluster non empty right_complementable associative commutative right-distributive right_unital Abelian add-associative right_zeroed strict Algebra-like AlgebraStr;
end;

:: FUNCSDOM:modenot 2
definition
  mode Algebra is non empty right_complementable associative commutative right-distributive right_unital Abelian add-associative right_zeroed Algebra-like AlgebraStr;
end;

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