Article UNIROOTS, MML version 4.99.1005

:: UNIROOTS:th 1
theorem
for b1 being Element of NAT
      st b1 <> 0 & b1 <> 1
   holds 2 <= b1;

:: UNIROOTS:sch 1
scheme UNIROOTS:sch 1
for b1 being non empty Element of NAT holds
   P1[b1]
provided
   for b1 being non empty Element of NAT
         st for b2 being non empty Element of NAT
                 st b2 < b1
              holds P1[b2]
      holds P1[b1];


:: UNIROOTS:th 2
theorem
for b1 being Relation-like Function-like FinSequence-like set
      st 1 <= len b1
   holds b1 | Seg 1 = <*b1 . 1*>;

:: UNIROOTS:th 3
theorem
for b1 being FinSequence of the carrier of F_Complex
for b2 being FinSequence of REAL
      st len b1 = len b2 &
         (for b3 being Element of NAT
               st b3 in dom b1
            holds |.b1 /. b3.| = b2 . b3)
   holds |.Product b1.| = Product b2;

:: UNIROOTS:th 4
theorem
for b1 being non empty finite Element of bool the carrier of F_Complex
for b2 being Element of the carrier of F_Complex
for b3 being FinSequence of REAL
      st len b3 = card b1 &
         (for b4 being Element of NAT
         for b5 being Element of the carrier of F_Complex
               st b4 in dom b3 & b5 = (canFS b1) . b4
            holds b3 . b4 = |.b2 - b5.|)
   holds |.eval(poly_with_roots ((b1,1)-bag),b2).| = Product b3;

:: UNIROOTS:th 5
theorem
for b1 being FinSequence of the carrier of F_Complex
      st for b2 being Element of NAT
              st b2 in dom b1
           holds b1 . b2 is integer
   holds Sum b1 is integer;

:: UNIROOTS:th 7
theorem
for b1, b2 being Element of the carrier of F_Complex
for b3, b4 being Element of REAL
      st b3 = b1 & b4 = b2
   holds b3 * b4 = b1 * b2 & b3 + b4 = b1 + b2;

:: UNIROOTS:th 8
theorem
for b1 being Element of REAL
   st b1 is integer set & 0 < b1
for b2 being Element of the carrier of F_Complex
      st |.b2.| = 1 & b2 <> [**1,0**]
   holds b1 - 1 < |.[**b1,0**] - b2.|;

:: UNIROOTS:th 9
theorem
for b1 being non empty FinSequence of REAL
for b2 being Element of REAL
      st 1 <= b2 &
         (for b3 being Element of NAT
               st b3 in dom b1
            holds b2 < b1 . b3)
   holds b2 < Product b1;

:: UNIROOTS:th 10
theorem
for b1 being Element of NAT holds
   1_ F_Complex = (power F_Complex) .(1_ F_Complex,b1);

:: UNIROOTS:th 11
theorem
for b1, b2 being Element of NAT holds
cos (((2 * PI) * b2) / b1) = cos (((2 * PI) * (b2 mod b1)) / b1) &
 sin (((2 * PI) * b2) / b1) = sin (((2 * PI) * (b2 mod b1)) / b1);

:: UNIROOTS:th 12
theorem
for b1, b2 being Element of NAT holds
[**cos (((2 * PI) * b2) / b1),sin (((2 * PI) * b2) / b1)**] = [**cos (((2 * PI) * (b2 mod b1)) / b1),sin (((2 * PI) * (b2 mod b1)) / b1)**];

:: UNIROOTS:th 13
theorem
for b1, b2, b3 being Element of NAT holds
[**cos (((2 * PI) * b2) / b1),sin (((2 * PI) * b2) / b1)**] * [**cos (((2 * PI) * b3) / b1),sin (((2 * PI) * b3) / b1)**] = [**cos (((2 * PI) * ((b2 + b3) mod b1)) / b1),sin (((2 * PI) * ((b2 + b3) mod b1)) / b1)**];

:: UNIROOTS:th 14
theorem
for b1 being non empty unital associative multMagma
for b2 being Element of the carrier of b1
for b3, b4 being Element of NAT holds
(power b1) .(b2,b3 * b4) = (power b1) .((power b1) .(b2,b3),b4);

:: UNIROOTS:th 15
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of F_Complex
      st b2 is integer set
   holds (power F_Complex) .(b2,b1) is integer set;

:: UNIROOTS:th 16
theorem
for b1 being FinSequence of the carrier of F_Complex
      st for b2 being Element of NAT
              st b2 in dom b1
           holds b1 . b2 is integer set
   holds Sum b1 is integer set;

:: UNIROOTS:exreg 1
registration
  cluster non empty non degenerated non trivial finite right_complementable almost_left_invertible unital associative commutative right-distributive left-distributive right_unital well-unital distributive left_unital Abelian add-associative right_zeroed domRing-like doubleLoopStr;
end;

:: UNIROOTS:exreg 2
registration
  cluster non empty non degenerated non trivial finite right_complementable almost_left_invertible unital associative right-distributive left-distributive right_unital well-unital distributive left_unital Abelian add-associative right_zeroed doubleLoopStr;
end;

:: UNIROOTS:funcnot 1 => UNIROOTS:func 1
definition
  let a1 be non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  func MultGroup A1 -> non empty strict Group-like associative multMagma means
    the carrier of it = (the carrier of a1) \ {0. a1} &
     the multF of it = (the multF of a1) || the carrier of it;
end;

:: UNIROOTS:def 1
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being non empty strict Group-like associative multMagma holds
      b2 = MultGroup b1
   iff
      the carrier of b2 = (the carrier of b1) \ {0. b1} &
       the multF of b2 = (the multF of b1) || the carrier of b2;

:: UNIROOTS:th 18
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   the carrier of b1 = (the carrier of MultGroup b1) \/ {0. b1};

:: UNIROOTS:th 19
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2, b3 being Element of the carrier of b1
for b4, b5 being Element of the carrier of MultGroup b1
      st b2 = b4 & b3 = b5
   holds b4 * b5 = b2 * b3;

:: UNIROOTS:th 20
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   1_ b1 = 1_ MultGroup b1;

:: UNIROOTS:funcreg 1
registration
  let a1 be non empty non degenerated finite right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr;
  cluster MultGroup a1 -> non empty finite strict Group-like associative;
end;

:: UNIROOTS:th 21
theorem
for b1 being non empty non degenerated finite right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   ord MultGroup b1 = (card the carrier of b1) - 1;

:: UNIROOTS:th 22
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being set
      st b2 in the carrier of MultGroup b1
   holds b2 in the carrier of b1;

:: UNIROOTS:th 23
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr holds
   the carrier of MultGroup b1 c= the carrier of b1;

:: UNIROOTS:funcnot 2 => UNIROOTS:func 2
definition
  let a1 be non empty Element of NAT;
  func A1 -roots_of_1 -> Element of bool the carrier of F_Complex equals
    {b1 where b1 is Element of the carrier of F_Complex: b1 is CRoot of a1,1_ F_Complex};
end;

:: UNIROOTS:def 2
theorem
for b1 being non empty Element of NAT holds
   b1 -roots_of_1 = {b2 where b2 is Element of the carrier of F_Complex: b2 is CRoot of b1,1_ F_Complex};

:: UNIROOTS:th 24
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of F_Complex holds
      b2 in b1 -roots_of_1
   iff
      b2 is CRoot of b1,1_ F_Complex;

:: UNIROOTS:th 25
theorem
for b1 being non empty Element of NAT holds
   1_ F_Complex in b1 -roots_of_1;

:: UNIROOTS:th 26
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of F_Complex
      st b2 in b1 -roots_of_1
   holds |.b2.| = 1;

:: UNIROOTS:th 27
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of F_Complex holds
      b2 in b1 -roots_of_1
   iff
      ex b3 being Element of NAT st
         b2 = [**cos (((2 * PI) * b3) / b1),sin (((2 * PI) * b3) / b1)**];

:: UNIROOTS:th 28
theorem
for b1 being non empty Element of NAT
for b2, b3 being Element of COMPLEX
      st b2 in b1 -roots_of_1 & b3 in b1 -roots_of_1
   holds b2 * b3 in b1 -roots_of_1;

:: UNIROOTS:th 29
theorem
for b1 being non empty Element of NAT holds
   b1 -roots_of_1 = {[**cos (((2 * PI) * b2) / b1),sin (((2 * PI) * b2) / b1)**] where b2 is Element of NAT: b2 < b1};

:: UNIROOTS:th 30
theorem
for b1 being non empty Element of NAT holds
   Card (b1 -roots_of_1) = b1;

:: UNIROOTS:funcreg 2
registration
  let a1 be non empty Element of NAT;
  cluster a1 -roots_of_1 -> non empty;
end;

:: UNIROOTS:funcreg 3
registration
  let a1 be non empty Element of NAT;
  cluster a1 -roots_of_1 -> finite;
end;

:: UNIROOTS:th 31
theorem
for b1, b2 being non empty Element of NAT
      st b2 divides b1
   holds b2 -roots_of_1 c= b1 -roots_of_1;

:: UNIROOTS:th 32
theorem
for b1 being non empty non degenerated right_complementable almost_left_invertible associative well-unital distributive Abelian add-associative right_zeroed doubleLoopStr
for b2 being Element of the carrier of MultGroup b1
for b3 being Element of the carrier of b1
   st b3 = b2
for b4 being Element of NAT holds
   (power MultGroup b1) .(b2,b4) = (power b1) .(b3,b4);

:: UNIROOTS:th 33
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of MultGroup F_Complex
      st b2 in b1 -roots_of_1
   holds b2 is being_of_order_0(not MultGroup F_Complex);

:: UNIROOTS:th 34
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT
for b3 being Element of the carrier of MultGroup F_Complex
      st b3 = [**cos (((2 * PI) * b2) / b1),sin (((2 * PI) * b2) / b1)**]
   holds ord b3 = b1 div (b2 gcd b1);

:: UNIROOTS:th 35
theorem
for b1 being non empty Element of NAT holds
   b1 -roots_of_1 c= the carrier of MultGroup F_Complex;

:: UNIROOTS:th 36
theorem
for b1 being non empty Element of NAT holds
   ex b2 being Element of the carrier of MultGroup F_Complex st
      ord b2 = b1;

:: UNIROOTS:th 37
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of MultGroup F_Complex holds
      ord b2 divides b1
   iff
      b2 in b1 -roots_of_1;

:: UNIROOTS:th 38
theorem
for b1 being non empty Element of NAT holds
   b1 -roots_of_1 = {b2 where b2 is Element of the carrier of MultGroup F_Complex: ord b2 divides b1};

:: UNIROOTS:th 39
theorem
for b1 being non empty Element of NAT
for b2 being set holds
      b2 in b1 -roots_of_1
   iff
      ex b3 being Element of the carrier of MultGroup F_Complex st
         b2 = b3 & ord b3 divides b1;

:: UNIROOTS:funcnot 3 => UNIROOTS:func 3
definition
  let a1 be non empty Element of NAT;
  func A1 -th_roots_of_1 -> non empty strict Group-like associative multMagma means
    the carrier of it = a1 -roots_of_1 &
     the multF of it = (the multF of F_Complex) || (a1 -roots_of_1);
end;

:: UNIROOTS:def 3
theorem
for b1 being non empty Element of NAT
for b2 being non empty strict Group-like associative multMagma holds
      b2 = b1 -th_roots_of_1
   iff
      the carrier of b2 = b1 -roots_of_1 &
       the multF of b2 = (the multF of F_Complex) || (b1 -roots_of_1);

:: UNIROOTS:th 40
theorem
for b1 being non empty Element of NAT holds
   b1 -th_roots_of_1 is Subgroup of MultGroup F_Complex;

:: UNIROOTS:funcnot 4 => UNIROOTS:func 4
definition
  let a1 be natural non empty set;
  let a2 be non empty left_unital doubleLoopStr;
  func unital_poly(A2,A1) -> Function-like quasi_total finite-Support Relation of NAT,the carrier of a2 equals
    ((0_. a2) +*(0,- 1_ a2)) +*(a1,1_ a2);
end;

:: UNIROOTS:def 4
theorem
for b1 being natural non empty set
for b2 being non empty left_unital doubleLoopStr holds
   unital_poly(b2,b1) = ((0_. b2) +*(0,- 1_ b2)) +*(b1,1_ b2);

:: UNIROOTS:th 42
theorem
for b1 being non empty left_unital doubleLoopStr
for b2 being non empty Element of NAT holds
   (unital_poly(b1,b2)) . 0 = - 1_ b1 &
    (unital_poly(b1,b2)) . b2 = 1_ b1;

:: UNIROOTS:th 43
theorem
for b1 being non empty left_unital doubleLoopStr
for b2 being natural non empty set
for b3 being natural set
      st b3 <> 0 & b3 <> b2
   holds (unital_poly(b1,b2)) . b3 = 0. b1;

:: UNIROOTS:th 44
theorem
for b1 being non empty non degenerated well-unital doubleLoopStr
for b2 being non empty Element of NAT holds
   len unital_poly(b1,b2) = b2 + 1;

:: UNIROOTS:funcreg 4
registration
  let a1 be non empty non degenerated well-unital doubleLoopStr;
  let a2 be non empty Element of NAT;
  cluster unital_poly(a1,a2) -> Function-like quasi_total finite-Support non-zero;
end;

:: UNIROOTS:th 45
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of F_Complex holds
   eval(unital_poly(F_Complex,b1),b2) = ((power F_Complex) .(b2,b1)) - 1;

:: UNIROOTS:th 46
theorem
for b1 being non empty Element of NAT holds
   Roots unital_poly(F_Complex,b1) = b1 -roots_of_1;

:: UNIROOTS:th 47
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of F_Complex
      st b2 is Element of REAL
   holds ex b3 being Element of REAL st
      b3 = b2 & (power F_Complex) .(b2,b1) = b3 |^ b1;

:: UNIROOTS:th 48
theorem
for b1 being non empty Element of NAT
for b2 being Element of REAL holds
   ex b3 being Element of the carrier of F_Complex st
      b3 = b2 &
       eval(unital_poly(F_Complex,b1),b3) = (b2 |^ b1) - 1;

:: UNIROOTS:th 49
theorem
for b1 being non empty Element of NAT holds
   BRoots unital_poly(F_Complex,b1) = (b1 -roots_of_1,1)-bag;

:: UNIROOTS:th 50
theorem
for b1 being non empty Element of NAT holds
   unital_poly(F_Complex,b1) = poly_with_roots ((b1 -roots_of_1,1)-bag);

:: UNIROOTS:th 51
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of F_Complex
      st b2 is integer set
   holds eval(unital_poly(F_Complex,b1),b2) is integer set;

:: UNIROOTS:funcnot 5 => UNIROOTS:func 5
definition
  let a1 be natural non empty set;
  func cyclotomic_poly A1 -> Function-like quasi_total finite-Support Relation of NAT,the carrier of F_Complex means
    ex b1 being non empty finite Element of bool the carrier of F_Complex st
       b1 = {b2 where b2 is Element of the carrier of MultGroup F_Complex: ord b2 = a1} &
        it = poly_with_roots ((b1,1)-bag);
end;

:: UNIROOTS:def 5
theorem
for b1 being natural non empty set
for b2 being Function-like quasi_total finite-Support Relation of NAT,the carrier of F_Complex holds
      b2 = cyclotomic_poly b1
   iff
      ex b3 being non empty finite Element of bool the carrier of F_Complex st
         b3 = {b4 where b4 is Element of the carrier of MultGroup F_Complex: ord b4 = b1} &
          b2 = poly_with_roots ((b3,1)-bag);

:: UNIROOTS:th 52
theorem
cyclotomic_poly 1 = <%- 1_ F_Complex,1_ F_Complex%>;

:: UNIROOTS:th 53
theorem
for b1 being non empty Element of NAT
for b2 being FinSequence of the carrier of Polynom-Ring F_Complex
      st len b2 = b1 &
         (for b3 being non empty Element of NAT
               st b3 in dom b2
            holds (b3 divides b1 or b2 . b3 = <%1_ F_Complex%>) &
             (b3 divides b1 implies b2 . b3 = cyclotomic_poly b3))
   holds unital_poly(F_Complex,b1) = Product b2;

:: UNIROOTS:th 54
theorem
for b1 being non empty Element of NAT holds
   ex b2 being FinSequence of the carrier of Polynom-Ring F_Complex st
      ex b3 being Function-like quasi_total finite-Support Relation of NAT,the carrier of F_Complex st
         b3 = Product b2 &
          dom b2 = Seg b1 &
          (for b4 being non empty Element of NAT
                st b4 in Seg b1
             holds (b4 divides b1 & b4 <> b1 or b2 . b4 = <%1_ F_Complex%>) &
              (b4 divides b1 & b4 <> b1 implies b2 . b4 = cyclotomic_poly b4)) &
          unital_poly(F_Complex,b1) = (cyclotomic_poly b1) *' b3;

:: UNIROOTS:th 55
theorem
for b1 being non empty Element of NAT
for b2 being Element of NAT holds
   ((cyclotomic_poly b1) . 0 = 1 or (cyclotomic_poly b1) . 0 = - 1) &
    (cyclotomic_poly b1) . b2 is integer;

:: UNIROOTS:th 56
theorem
for b1 being non empty Element of NAT
for b2 being Element of the carrier of F_Complex
      st b2 is integer set
   holds eval(cyclotomic_poly b1,b2) is integer set;

:: UNIROOTS:th 57
theorem
for b1, b2 being non empty Element of NAT
for b3 being FinSequence of the carrier of Polynom-Ring F_Complex
for b4 being finite Element of bool the carrier of F_Complex
      st b4 = {b5 where b5 is Element of the carrier of MultGroup F_Complex: ord b5 divides b1 & not ord b5 divides b2 & ord b5 <> b1} &
         dom b3 = Seg b1 &
         (for b5 being non empty Element of NAT
               st b5 in dom b3
            holds (b5 divides b1 & not b5 divides b2 & b5 <> b1 or b3 . b5 = <%1_ F_Complex%>) &
             (b5 divides b1 & not b5 divides b2 & b5 <> b1 implies b3 . b5 = cyclotomic_poly b5))
   holds Product b3 = poly_with_roots ((b4,1)-bag);

:: UNIROOTS:th 58
theorem
for b1, b2 being non empty Element of NAT
      st b2 < b1 & b2 divides b1
   holds ex b3 being FinSequence of the carrier of Polynom-Ring F_Complex st
      ex b4 being Function-like quasi_total finite-Support Relation of NAT,the carrier of F_Complex st
         b4 = Product b3 &
          dom b3 = Seg b1 &
          (for b5 being non empty Element of NAT
                st b5 in Seg b1
             holds (b5 divides b1 & not b5 divides b2 & b5 <> b1 or b3 . b5 = <%1_ F_Complex%>) &
              (b5 divides b1 & not b5 divides b2 & b5 <> b1 implies b3 . b5 = cyclotomic_poly b5)) &
          unital_poly(F_Complex,b1) = ((unital_poly(F_Complex,b2)) *' cyclotomic_poly b1) *' b4;

:: UNIROOTS:th 59
theorem
for b1 being integer set
for b2 being Element of the carrier of F_Complex
for b3 being FinSequence of the carrier of Polynom-Ring F_Complex
for b4 being Function-like quasi_total finite-Support Relation of NAT,the carrier of F_Complex
      st b4 = Product b3 &
         b2 = b1 &
         (for b5 being non empty Element of NAT
               st b5 in dom b3 &
                  b3 . b5 <> <%1_ F_Complex%>
            holds b3 . b5 = cyclotomic_poly b5)
   holds eval(b4,b2) is integer;

:: UNIROOTS:th 60
theorem
for b1 being non empty Element of NAT
for b2, b3, b4 being integer set
for b5 being Element of the carrier of F_Complex
      st b5 = b4 & b2 = eval(cyclotomic_poly b1,b5) & b3 = eval(unital_poly(F_Complex,b1),b5)
   holds b2 divides b3;

:: UNIROOTS:th 61
theorem
for b1, b2 being non empty Element of NAT
for b3 being integer set
   st b2 < b1 & b2 divides b1
for b4 being Element of the carrier of F_Complex
   st b4 = b3
for b5, b6, b7 being integer set
      st b5 = eval(cyclotomic_poly b1,b4) & b6 = eval(unital_poly(F_Complex,b1),b4) & b7 = eval(unital_poly(F_Complex,b2),b4)
   holds b5 divides b6 div b7;

:: UNIROOTS:th 62
theorem
for b1, b2 being non empty Element of NAT
for b3 being Element of the carrier of F_Complex
   st b3 = b2
for b4 being integer set
      st b4 = eval(cyclotomic_poly b1,b3)
   holds b4 divides (b2 |^ b1) - 1;

:: UNIROOTS:th 63
theorem
for b1, b2, b3 being non empty Element of NAT
   st b2 < b1 & b2 divides b1
for b4 being Element of the carrier of F_Complex
   st b4 = b3
for b5 being integer set
      st b5 = eval(cyclotomic_poly b1,b4)
   holds b5 divides ((b3 |^ b1) - 1) div ((b3 |^ b2) - 1);

:: UNIROOTS:th 64
theorem
for b1 being non empty Element of NAT
   st 1 < b1
for b2 being Element of NAT
   st 1 < b2
for b3 being Element of the carrier of F_Complex
   st b3 = b2
for b4 being integer set
      st b4 = eval(cyclotomic_poly b1,b3)
   holds b2 - 1 < abs b4;