Article GR_CY_1, MML version 4.99.1005

:: GR_CY_1:funcreg 1
registration
  let a1 be natural non empty set;
  cluster Segm a1 -> non empty;
end;

:: GR_CY_1:th 10
theorem
for b1, b2 being natural set
      st 0 < b1
   holds    b2 in b1
   iff
      b2 < b1;

:: GR_CY_1:th 12
theorem
for b1 being natural set
      st 0 < b1
   holds 0 in b1;

:: GR_CY_1:th 13
theorem
Segm 1 = {0};

:: GR_CY_1:funcnot 1 => BINOP_2:func 44
definition
  func addint -> Function-like quasi_total Relation of [:INT,INT:],INT means
    for b1, b2 being Element of INT holds
    it .(b1,b2) = addreal .(b1,b2);
end;

:: GR_CY_1:def 2
theorem
for b1 being Function-like quasi_total Relation of [:INT,INT:],INT holds
      b1 = addint
   iff
      for b2, b3 being Element of INT holds
      b1 .(b2,b3) = addreal .(b2,b3);

:: GR_CY_1:th 14
theorem
for b1, b2 being integer set holds
addint .(b1,b2) = b1 + b2;

:: GR_CY_1:th 15
theorem
for b1 being Element of INT
      st b1 = 0
   holds b1 is_a_unity_wrt addint;

:: GR_CY_1:th 16
theorem
for b1 being FinSequence of INT holds
   Sum b1 = addint "**" b1;

:: GR_CY_1:funcnot 2 => GR_CY_1:func 1
definition
  let a1 be FinSequence of INT;
  redefine func Sum A1 -> Element of INT equals
    addint "**" a1;
end;

:: GR_CY_1:def 3
theorem
for b1 being FinSequence of INT holds
   Sum b1 = addint "**" b1;

:: GR_CY_1:th 20
theorem
for b1 being Element of INT
for b2 being FinSequence of INT holds
   Sum (b2 ^ <*b1*>) = (Sum b2) + b1;

:: GR_CY_1:th 22
theorem
Sum <*> INT = 0;

:: GR_CY_1:th 24
theorem
for b1 being non empty Group-like associative multMagma
for b2 being Element of the carrier of b1
for b3 being FinSequence of INT holds
   Product (((len b3) |-> b2) |^ b3) = b2 |^ Sum b3;

:: GR_CY_1:th 25
theorem
for b1 being non empty Group-like associative multMagma
for b2, b3 being Element of the carrier of b1 holds
   b2 in gr {b3}
iff
   ex b4 being integer set st
      b2 = b3 |^ b4;

:: GR_CY_1:th 26
theorem
for b1 being non empty finite Group-like associative multMagma
for b2 being Element of the carrier of b1 holds
   b2 is not being_of_order_0(b1);

:: GR_CY_1:th 27
theorem
for b1 being non empty finite Group-like associative multMagma
for b2 being Element of the carrier of b1 holds
   ord b2 = ord gr {b2};

:: GR_CY_1:th 28
theorem
for b1 being non empty finite Group-like associative multMagma
for b2 being Element of the carrier of b1 holds
   ord b2 divides ord b1;

:: GR_CY_1:th 29
theorem
for b1 being non empty finite Group-like associative multMagma
for b2 being Element of the carrier of b1 holds
   b2 |^ ord b1 = 1_ b1;

:: GR_CY_1:th 30
theorem
for b1 being Element of NAT
for b2 being non empty finite Group-like associative multMagma
for b3 being Element of the carrier of b2 holds
   (b3 |^ b1) " = b3 |^ ((ord b2) - (b1 mod ord b2));

:: GR_CY_1:funcreg 2
registration
  let a1 be non empty associative multMagma;
  cluster multMagma(#the carrier of a1,the multF of a1#) -> strict associative;
end;

:: GR_CY_1:funcreg 3
registration
  let a1 be non empty Group-like associative multMagma;
  cluster multMagma(#the carrier of a1,the multF of a1#) -> strict Group-like;
end;

:: GR_CY_1:th 31
theorem
for b1 being non empty finite strict Group-like associative multMagma
      st 1 < ord b1
   holds ex b2 being Element of the carrier of b1 st
      b2 <> 1_ b1;

:: GR_CY_1:th 32
theorem
for b1 being Element of NAT
for b2 being non empty finite strict Group-like associative multMagma
   st ord b2 = b1 & b1 is prime
for b3 being strict Subgroup of b2
      st not b3 = (1). b2
   holds b3 = b2;

:: GR_CY_1:th 33
theorem
multMagma(#INT,addint#) is associative & multMagma(#INT,addint#) is Group-like;

:: GR_CY_1:funcnot 3 => GR_CY_1:func 2
definition
  func INT.Group -> non empty strict Group-like associative multMagma equals
    multMagma(#INT,addint#);
end;

:: GR_CY_1:def 4
theorem
INT.Group = multMagma(#INT,addint#);

:: GR_CY_1:condreg 1
registration
  cluster -> integer (Element of the carrier of INT.Group);
end;

:: GR_CY_1:condreg 2
registration
  let a1 be natural set;
  cluster -> natural (Element of Segm a1);
end;

:: GR_CY_1:funcnot 4 => GR_CY_1:func 3
definition
  let a1 be natural set;
  assume 0 < a1;
  func addint A1 -> Function-like quasi_total Relation of [:Segm a1,Segm a1:],Segm a1 means
    for b1, b2 being Element of Segm a1 holds
    it .(b1,b2) = (b1 + b2) mod a1;
end;

:: GR_CY_1:def 5
theorem
for b1 being natural set
   st 0 < b1
for b2 being Function-like quasi_total Relation of [:Segm b1,Segm b1:],Segm b1 holds
      b2 = addint b1
   iff
      for b3, b4 being Element of Segm b1 holds
      b2 .(b3,b4) = (b3 + b4) mod b1;

:: GR_CY_1:th 34
theorem
for b1 being natural non empty set holds
   multMagma(#Segm b1,addint b1#) is associative & multMagma(#Segm b1,addint b1#) is Group-like;

:: GR_CY_1:funcnot 5 => GR_CY_1:func 4
definition
  let a1 be natural set;
  assume 0 < a1;
  func INT.Group A1 -> non empty strict Group-like associative multMagma equals
    multMagma(#Segm a1,addint a1#);
end;

:: GR_CY_1:def 6
theorem
for b1 being natural set
      st 0 < b1
   holds INT.Group b1 = multMagma(#Segm b1,addint b1#);

:: GR_CY_1:funcreg 4
registration
  let a1 be natural non empty set;
  cluster INT.Group a1 -> non empty finite strict Group-like associative;
end;

:: GR_CY_1:th 35
theorem
1_ INT.Group = 0;

:: GR_CY_1:th 36
theorem
for b1 being natural set
      st 0 < b1
   holds 1_ INT.Group b1 = 0;

:: GR_CY_1:funcnot 6 => GR_CY_1:func 5
definition
  let a1 be integer set;
  func @' A1 -> Element of the carrier of INT.Group equals
    a1;
end;

:: GR_CY_1:def 8
theorem
for b1 being integer set holds
   @' b1 = b1;

:: GR_CY_1:th 37
theorem
for b1 being Element of the carrier of INT.Group holds
   b1 " = - b1;

:: GR_CY_1:th 38
theorem
for b1 being Element of NAT holds
   (@' 1) |^ b1 = b1;

:: GR_CY_1:th 39
theorem
for b1 being integer set holds
   b1 = (@' 1) |^ b1;

:: GR_CY_1:attrnot 1 => GR_CY_1:attr 1
definition
  let a1 be non empty Group-like associative multMagma;
  attr a1 is cyclic means
    ex b1 being Element of the carrier of a1 st
       multMagma(#the carrier of a1,the multF of a1#) = gr {b1};
end;

:: GR_CY_1:dfs 7
definiens
  let a1 be non empty Group-like associative multMagma;
To prove
     a1 is cyclic
it is sufficient to prove
  thus ex b1 being Element of the carrier of a1 st
       multMagma(#the carrier of a1,the multF of a1#) = gr {b1};

:: GR_CY_1:def 9
theorem
for b1 being non empty Group-like associative multMagma holds
      b1 is cyclic
   iff
      ex b2 being Element of the carrier of b1 st
         multMagma(#the carrier of b1,the multF of b1#) = gr {b2};

:: GR_CY_1:exreg 1
registration
  cluster non empty strict unital Group-like associative cyclic multMagma;
end;

:: GR_CY_1:th 40
theorem
for b1 being non empty Group-like associative multMagma holds
   (1). b1 is cyclic;

:: GR_CY_1:funcreg 5
registration
  let a1 be non empty Group-like associative multMagma;
  cluster (1). a1 -> strict cyclic;
end;

:: GR_CY_1:exreg 2
registration
  cluster non empty finite strict unital Group-like associative cyclic multMagma;
end;

:: GR_CY_1:th 41
theorem
for b1 being non empty Group-like associative multMagma holds
      b1 is non empty Group-like associative cyclic multMagma
   iff
      ex b2 being Element of the carrier of b1 st
         for b3 being Element of the carrier of b1 holds
            ex b4 being integer set st
               b3 = b2 |^ b4;

:: GR_CY_1:th 42
theorem
for b1 being non empty finite Group-like associative multMagma holds
      b1 is cyclic
   iff
      ex b2 being Element of the carrier of b1 st
         for b3 being Element of the carrier of b1 holds
            ex b4 being Element of NAT st
               b3 = b2 |^ b4;

:: GR_CY_1:th 43
theorem
for b1 being non empty finite Group-like associative multMagma holds
      b1 is cyclic
   iff
      ex b2 being Element of the carrier of b1 st
         ord b2 = ord b1;

:: GR_CY_1:th 44
theorem
for b1 being non empty finite Group-like associative multMagma
for b2 being strict Subgroup of b1
      st b1 is cyclic
   holds b2 is cyclic;

:: GR_CY_1:th 45
theorem
for b1 being Element of NAT
for b2 being non empty finite strict Group-like associative multMagma
      st ord b2 = b1 & b1 is prime
   holds b2 is non empty Group-like associative cyclic multMagma;

:: GR_CY_1:th 46
theorem
for b1 being Element of NAT
      st 0 < b1
   holds ex b2 being Element of the carrier of INT.Group b1 st
      for b3 being Element of the carrier of INT.Group b1 holds
         ex b4 being integer set st
            b3 = b2 |^ b4;

:: GR_CY_1:condreg 3
registration
  cluster non empty Group-like associative cyclic -> commutative (multMagma);
end;

:: GR_CY_1:th 47
theorem
INT.Group = gr {@' 1};

:: GR_CY_1:th 48
theorem
INT.Group is cyclic;

:: GR_CY_1:funcreg 6
registration
  cluster INT.Group -> non empty strict Group-like associative cyclic;
end;

:: GR_CY_1:th 49
theorem
for b1 being Element of NAT
      st 0 < b1
   holds INT.Group b1 is cyclic;

:: GR_CY_1:th 50
theorem
INT.Group is commutative;

:: GR_CY_1:th 51
theorem
for b1, b2 being Element of NAT
      st 0 < b1 & b1 <= b2
   holds Segm b1 c= Segm b2;