Article POLYALG1, MML version 4.99.1005

:: POLYALG1:structnot 1 => POLYALG1:struct 1
definition
  let a1 be 1-sorted;
  struct(doubleLoopStrVectSpStr over a1) AlgebraStr(#
    carrier -> set,
    addF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    multF -> Function-like quasi_total Relation of [:the carrier of it,the carrier of it:],the carrier of it,
    ZeroF -> Element of the carrier of it,
    OneF -> Element of the carrier of it,
    lmult -> Function-like quasi_total Relation of [:the carrier of A1,the carrier of it:],the carrier of it
  #);
end;

:: POLYALG1:attrnot 1 => POLYALG1:attr 1
definition
  let a1 be 1-sorted;
  let a2 be AlgebraStr over a1;
  attr a2 is strict;
end;

:: POLYALG1:exreg 1
registration
  let a1 be 1-sorted;
  cluster strict AlgebraStr over a1;
end;

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

:: POLYALG1:exreg 2
registration
  let a1 be non empty doubleLoopStr;
  cluster non empty strict AlgebraStr over a1;
end;

:: POLYALG1:attrnot 2 => POLYALG1:attr 2
definition
  let a1 be non empty doubleLoopStr;
  let a2 be non empty AlgebraStr over a1;
  attr a2 is mix-associative means
    for b1 being Element of the carrier of a1
    for b2, b3 being Element of the carrier of a2 holds
    b1 * (b2 * b3) = (b1 * b2) * b3;
end;

:: POLYALG1:dfs 1
definiens
  let a1 be non empty doubleLoopStr;
  let a2 be non empty AlgebraStr over a1;
To prove
     a2 is mix-associative
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2, b3 being Element of the carrier of a2 holds
    b1 * (b2 * b3) = (b1 * b2) * b3;

:: POLYALG1:def 1
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty AlgebraStr over b1 holds
      b2 is mix-associative(b1)
   iff
      for b3 being Element of the carrier of b1
      for b4, b5 being Element of the carrier of b2 holds
      b3 * (b4 * b5) = (b3 * b4) * b5;

:: POLYALG1:exreg 3
registration
  let a1 be non empty doubleLoopStr;
  cluster non empty unital distributive VectSp-like mix-associative AlgebraStr over a1;
end;

:: POLYALG1:modenot 1
definition
  let a1 be non empty doubleLoopStr;
  mode Algebra of a1 is non empty unital distributive VectSp-like mix-associative AlgebraStr over a1;
end;

:: POLYALG1:th 1
theorem
for b1, b2 being set
for b3 being Function-like quasi_total Relation of [:b1,b2:],b1 holds
   proj1 b3 = [:b1,b2:];

:: POLYALG1:th 2
theorem
for b1, b2 being set
for b3 being Function-like quasi_total Relation of [:b1,b2:],b2 holds
   proj1 b3 = [:b1,b2:];

:: POLYALG1:funcnot 1 => POLYALG1:func 1
definition
  let a1 be non empty doubleLoopStr;
  func Formal-Series A1 -> non empty strict AlgebraStr over a1 means
    (for b1 being set holds
           b1 in the carrier of it
        iff
           b1 is Function-like quasi_total Relation of NAT,the carrier of a1) &
     (for b1, b2 being Element of the carrier of it
     for b3, b4 being Function-like quasi_total Relation of NAT,the carrier of a1
           st b1 = b3 & b2 = b4
        holds b1 + b2 = b3 + b4) &
     (for b1, b2 being Element of the carrier of it
     for b3, b4 being Function-like quasi_total Relation of NAT,the carrier of a1
           st b1 = b3 & b2 = b4
        holds b1 * b2 = b3 *' b4) &
     (for b1 being Element of the carrier of a1
     for b2 being Element of the carrier of it
     for b3 being Function-like quasi_total Relation of NAT,the carrier of a1
           st b2 = b3
        holds b1 * b2 = b1 * b3) &
     0. it = 0_. a1 &
     1. it = 1_. a1;
end;

:: POLYALG1:def 2
theorem
for b1 being non empty doubleLoopStr
for b2 being non empty strict AlgebraStr over b1 holds
      b2 = Formal-Series b1
   iff
      (for b3 being set holds
             b3 in the carrier of b2
          iff
             b3 is Function-like quasi_total Relation of NAT,the carrier of b1) &
       (for b3, b4 being Element of the carrier of b2
       for b5, b6 being Function-like quasi_total Relation of NAT,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 Function-like quasi_total Relation of NAT,the carrier of b1
             st b3 = b5 & b4 = b6
          holds b3 * b4 = b5 *' b6) &
       (for b3 being Element of the carrier of b1
       for b4 being Element of the carrier of b2
       for b5 being Function-like quasi_total Relation of NAT,the carrier of b1
             st b4 = b5
          holds b3 * b4 = b3 * b5) &
       0. b2 = 0_. b1 &
       1. b2 = 1_. b1;

:: POLYALG1:funcreg 1
registration
  let a1 be non empty Abelian doubleLoopStr;
  cluster Formal-Series a1 -> non empty Abelian strict;
end;

:: POLYALG1:funcreg 2
registration
  let a1 be non empty add-associative doubleLoopStr;
  cluster Formal-Series a1 -> non empty add-associative strict;
end;

:: POLYALG1:funcreg 3
registration
  let a1 be non empty right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty right_zeroed strict;
end;

:: POLYALG1:funcreg 4
registration
  let a1 be non empty right_complementable add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty right_complementable strict;
end;

:: POLYALG1:funcreg 5
registration
  let a1 be non empty commutative Abelian add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty commutative strict;
end;

:: POLYALG1:funcreg 6
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty associative strict;
end;

:: POLYALG1:exreg 4
registration
  cluster non empty right_complementable left_zeroed associative well-unital distributive add-associative right_zeroed doubleLoopStr;
end;

:: POLYALG1:th 3
theorem
for b1 being non empty set
for b2 being non empty FinSequence of b1 holds
   b2 /^ 1 = Del(b2,1);

:: POLYALG1:th 4
theorem
for b1 being non empty set
for b2 being non empty FinSequence of b1 holds
   b2 = <*b2 . 1*> ^ Del(b2,1);

:: POLYALG1:th 5
theorem
for b1 being non empty right_complementable left-distributive well-unital add-associative right_zeroed doubleLoopStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   (1_. b1) *' b2 = b2;

:: POLYALG1:funcreg 7
registration
  let a1 be non empty right_complementable well-unital distributive add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty well-unital strict;
end;

:: POLYALG1:funcreg 8
registration
  let a1 be non empty right_complementable distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty right-distributive strict;
end;

:: POLYALG1:funcreg 9
registration
  let a1 be non empty right_complementable distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty left-distributive strict;
end;

:: POLYALG1:th 6
theorem
for b1 being non empty right_complementable distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of b1
for b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
b2 * (b3 + b4) = (b2 * b3) + (b2 * b4);

:: POLYALG1:th 7
theorem
for b1 being non empty right_complementable distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
for b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   (b2 + b3) * b4 = (b2 * b4) + (b3 * b4);

:: POLYALG1:th 8
theorem
for b1 being non empty associative doubleLoopStr
for b2, b3 being Element of the carrier of b1
for b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   (b2 * b3) * b4 = b2 * (b3 * b4);

:: POLYALG1:th 9
theorem
for b1 being non empty associative well-unital doubleLoopStr
for b2 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
   (1. b1) * b2 = b2;

:: POLYALG1:funcreg 10
registration
  let a1 be non empty right_complementable associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty VectSp-like strict;
end;

:: POLYALG1:th 10
theorem
for b1 being non empty right_complementable left_zeroed associative distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of b1
for b3, b4 being Function-like quasi_total Relation of NAT,the carrier of b1 holds
b2 * (b3 *' b4) = (b2 * b3) *' b4;

:: POLYALG1:funcreg 11
registration
  let a1 be non empty right_complementable left_zeroed associative distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster Formal-Series a1 -> non empty strict mix-associative;
end;

:: POLYALG1:modenot 2 => POLYALG1:mode 1
definition
  let a1 be 1-sorted;
  let a2 be AlgebraStr over a1;
  mode Subalgebra of A2 -> AlgebraStr over a1 means
    the carrier of it c= the carrier of a2 &
     1. it = 1. a2 &
     0. it = 0. a2 &
     the addF of it = (the addF of a2) || the carrier of it &
     the multF of it = (the multF of a2) || the carrier of it &
     the lmult of it = (the lmult of a2) | [:the carrier of a1,the carrier of it:];
end;

:: POLYALG1:dfs 3
definiens
  let a1 be 1-sorted;
  let a2, a3 be AlgebraStr over a1;
To prove
     a3 is Subalgebra of a2
it is sufficient to prove
  thus the carrier of a3 c= the carrier of a2 &
     1. a3 = 1. a2 &
     0. a3 = 0. a2 &
     the addF of a3 = (the addF of a2) || the carrier of a3 &
     the multF of a3 = (the multF of a2) || the carrier of a3 &
     the lmult of a3 = (the lmult of a2) | [:the carrier of a1,the carrier of a3:];

:: POLYALG1:def 3
theorem
for b1 being 1-sorted
for b2, b3 being AlgebraStr over b1 holds
   b3 is Subalgebra of b2
iff
   the carrier of b3 c= the carrier of b2 &
    1. b3 = 1. b2 &
    0. b3 = 0. b2 &
    the addF of b3 = (the addF of b2) || the carrier of b3 &
    the multF of b3 = (the multF of b2) || the carrier of b3 &
    the lmult of b3 = (the lmult of b2) | [:the carrier of b1,the carrier of b3:];

:: POLYALG1:th 11
theorem
for b1 being 1-sorted
for b2 being AlgebraStr over b1 holds
   b2 is Subalgebra of b2;

:: POLYALG1:th 12
theorem
for b1 being 1-sorted
for b2, b3, b4 being AlgebraStr over b1
      st b2 is Subalgebra of b3 & b3 is Subalgebra of b4
   holds b2 is Subalgebra of b4;

:: POLYALG1:th 13
theorem
for b1 being 1-sorted
for b2, b3 being AlgebraStr over b1
      st b2 is Subalgebra of b3 & b3 is Subalgebra of b2
   holds AlgebraStr(#the carrier of b2,the addF of b2,the multF of b2,the ZeroF of b2,the OneF of b2,the lmult of b2#) = AlgebraStr(#the carrier of b3,the addF of b3,the multF of b3,the ZeroF of b3,the OneF of b3,the lmult of b3#);

:: POLYALG1:th 14
theorem
for b1 being 1-sorted
for b2, b3 being AlgebraStr over b1
      st AlgebraStr(#the carrier of b2,the addF of b2,the multF of b2,the ZeroF of b2,the OneF of b2,the lmult of b2#) = AlgebraStr(#the carrier of b3,the addF of b3,the multF of b3,the ZeroF of b3,the OneF of b3,the lmult of b3#)
   holds b2 is Subalgebra of b3;

:: POLYALG1:exreg 5
registration
  let a1 be non empty 1-sorted;
  cluster non empty strict AlgebraStr over a1;
end;

:: POLYALG1:exreg 6
registration
  let a1 be 1-sorted;
  let a2 be AlgebraStr over a1;
  cluster strict Subalgebra of a2;
end;

:: POLYALG1:exreg 7
registration
  let a1 be non empty 1-sorted;
  let a2 be non empty AlgebraStr over a1;
  cluster non empty strict Subalgebra of a2;
end;

:: POLYALG1:attrnot 3 => POLYALG1:attr 3
definition
  let a1 be non empty multMagma;
  let a2 be non empty AlgebraStr over a1;
  let a3 be Element of bool the carrier of a2;
  attr a3 is opers_closed means
    a3 is linearly-closed(a1, a2) &
     (for b1, b2 being Element of the carrier of a2
           st b1 in a3 & b2 in a3
        holds b1 * b2 in a3) &
     1. a2 in a3 &
     0. a2 in a3;
end;

:: POLYALG1:dfs 4
definiens
  let a1 be non empty multMagma;
  let a2 be non empty AlgebraStr over a1;
  let a3 be Element of bool the carrier of a2;
To prove
     a3 is opers_closed
it is sufficient to prove
  thus a3 is linearly-closed(a1, a2) &
     (for b1, b2 being Element of the carrier of a2
           st b1 in a3 & b2 in a3
        holds b1 * b2 in a3) &
     1. a2 in a3 &
     0. a2 in a3;

:: POLYALG1:def 4
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being Element of bool the carrier of b2 holds
      b3 is opers_closed(b1, b2)
   iff
      b3 is linearly-closed(b1, b2) &
       (for b4, b5 being Element of the carrier of b2
             st b4 in b3 & b5 in b3
          holds b4 * b5 in b3) &
       1. b2 in b3 &
       0. b2 in b3;

:: POLYALG1:th 15
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being non empty Subalgebra of b2
for b4, b5 being Element of the carrier of b2
for b6, b7 being Element of the carrier of b3
      st b4 = b6 & b5 = b7
   holds b4 + b5 = b6 + b7;

:: POLYALG1:th 16
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being non empty Subalgebra of b2
for b4, b5 being Element of the carrier of b2
for b6, b7 being Element of the carrier of b3
      st b4 = b6 & b5 = b7
   holds b4 * b5 = b6 * b7;

:: POLYALG1:th 17
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being non empty Subalgebra of b2
for b4 being Element of the carrier of b1
for b5 being Element of the carrier of b2
for b6 being Element of the carrier of b3
      st b5 = b6
   holds b4 * b5 = b4 * b6;

:: POLYALG1:th 19
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being non empty Subalgebra of b2 holds
   ex b4 being Element of bool the carrier of b2 st
      the carrier of b3 = b4 & b4 is opers_closed(b1, b2);

:: POLYALG1:th 20
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being Element of bool the carrier of b2
      st b3 is opers_closed(b1, b2)
   holds ex b4 being strict Subalgebra of b2 st
      the carrier of b4 = b3;

:: POLYALG1:th 21
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being non empty Element of bool the carrier of b2
for b4 being Element of bool bool the carrier of b2
      st for b5 being set holds
              b5 in b4
           iff
              b5 c= the carrier of b2 &
               (ex b6 being Subalgebra of b2 st
                  b5 = the carrier of b6 & b3 c= b5)
   holds meet b4 is opers_closed(b1, b2);

:: POLYALG1:funcnot 2 => POLYALG1:func 2
definition
  let a1 be non empty multMagma;
  let a2 be non empty AlgebraStr over a1;
  let a3 be non empty Element of bool the carrier of a2;
  func GenAlg A3 -> non empty strict Subalgebra of a2 means
    a3 c= the carrier of it &
     (for b1 being Subalgebra of a2
           st a3 c= the carrier of b1
        holds the carrier of it c= the carrier of b1);
end;

:: POLYALG1:def 5
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being non empty Element of bool the carrier of b2
for b4 being non empty strict Subalgebra of b2 holds
      b4 = GenAlg b3
   iff
      b3 c= the carrier of b4 &
       (for b5 being Subalgebra of b2
             st b3 c= the carrier of b5
          holds the carrier of b4 c= the carrier of b5);

:: POLYALG1:th 22
theorem
for b1 being non empty multMagma
for b2 being non empty AlgebraStr over b1
for b3 being non empty Element of bool the carrier of b2
      st b3 is opers_closed(b1, b2)
   holds the carrier of GenAlg b3 = b3;

:: POLYALG1:funcnot 3 => POLYALG1:func 3
definition
  let a1 be non empty right_complementable distributive add-associative right_zeroed doubleLoopStr;
  func Polynom-Algebra A1 -> non empty strict AlgebraStr over a1 means
    ex b1 being non empty Element of bool the carrier of Formal-Series a1 st
       b1 = the carrier of Polynom-Ring a1 & it = GenAlg b1;
end;

:: POLYALG1:def 6
theorem
for b1 being non empty right_complementable distributive add-associative right_zeroed doubleLoopStr
for b2 being non empty strict AlgebraStr over b1 holds
      b2 = Polynom-Algebra b1
   iff
      ex b3 being non empty Element of bool the carrier of Formal-Series b1 st
         b3 = the carrier of Polynom-Ring b1 & b2 = GenAlg b3;

:: POLYALG1:funcreg 12
registration
  let a1 be non empty right_complementable distributive add-associative right_zeroed doubleLoopStr;
  cluster Polynom-Ring a1 -> non empty strict Loop-like;
end;

:: POLYALG1:th 23
theorem
for b1 being non empty right_complementable distributive add-associative right_zeroed doubleLoopStr
for b2 being non empty Element of bool the carrier of Formal-Series b1
      st b2 = the carrier of Polynom-Ring b1
   holds b2 is opers_closed(b1, Formal-Series b1);

:: POLYALG1:th 24
theorem
for b1 being non empty right_complementable distributive add-associative right_zeroed doubleLoopStr holds
   doubleLoopStr(#the carrier of Polynom-Algebra b1,the addF of Polynom-Algebra b1,the multF of Polynom-Algebra b1,the OneF of Polynom-Algebra b1,the ZeroF of Polynom-Algebra b1#) = Polynom-Ring b1;

:: POLYALG1:th 25
theorem
for b1 being non empty right_complementable well-unital distributive add-associative right_zeroed doubleLoopStr holds
   1_ Formal-Series b1 = 1_. b1;