Article INT_4, MML version 4.99.1005

:: INT_4:th 1
theorem
for b1 being real-membered set
for b2 being real set holds
   b1,b2 ++ b1 are_equipotent;

:: INT_4:funcreg 1
registration
  let a1 be finite real-membered set;
  let a2 be real set;
  cluster a2 ++ a1 -> finite;
end;

:: INT_4:th 2
theorem
for b1 being finite real-membered set
for b2 being real set holds
   card b1 = card (b2 ++ b1);

:: INT_4:th 3
theorem
for b1 being real-membered set
for b2 being real set
      st b2 <> 0
   holds b1,b2 ** b1 are_equipotent;

:: INT_4:th 4
theorem
for b1 being real-membered set
for b2 being real set holds
   (b2 = 0 & b1 is not empty implies b2 ** b1 = {0}) &
    (b2 ** b1 = {0} & b2 <> 0 implies b1 = {0});

:: INT_4:funcreg 2
registration
  let a1 be finite real-membered set;
  let a2 be real set;
  cluster a2 ** a1 -> finite;
end;

:: INT_4:th 5
theorem
for b1 being finite real-membered set
for b2 being real set
      st b2 <> 0
   holds card b1 = card (b2 ** b1);

:: INT_4:th 6
theorem
for b1, b2 being integer set
      st b1 divides b2 & b2 <> 0
   holds abs b1 <= abs b2;

:: INT_4:th 7
theorem
for b1, b2, b3 being integer set
      st b3 <> 0
   holds    b1 divides b2
   iff
      b1 * b3 divides b2 * b3;

:: INT_4:th 8
theorem
for b1, b2, b3 being natural set
for b4 being Element of NAT
      st b1 mod b3 = b2 mod b3
   holds (b1 |^ b4) mod b3 = (b2 |^ b4) mod b3;

:: INT_4:th 9
theorem
for b1, b2, b3, b4 being integer set
      st b1 * b2,b3 * b2 are_congruent_mod b4 & b2,b4 are_relative_prime
   holds b1,b3 are_congruent_mod b4;

:: INT_4:th 10
theorem
for b1, b2, b3 being integer set
for b4 being natural set
      st b1,b2 are_congruent_mod b3
   holds b1 * b4,b2 * b4 are_congruent_mod b3 * b4;

:: INT_4:th 11
theorem
for b1, b2, b3, b4 being integer set
      st b1,b2 are_congruent_mod b3
   holds b1 * b4,b2 * b4 are_congruent_mod b3;

:: INT_4:th 12
theorem
for b1 being integer set holds
   0 = 0 mod b1;

:: INT_4:th 13
theorem
for b1 being integer set
   st 0 < b1
for b2 being integer set holds
   ex b3, b4 being integer set st
      b2 = (b1 * b3) + b4 & 0 <= b4 & b4 < b1;

:: INT_4:th 14
theorem
for b1, b2, b3 being integer set
      st b1,b2 are_congruent_mod b3
   holds b1 gcd b3 = b2 gcd b3;

:: INT_4:th 15
theorem
for b1, b2, b3 being integer set
      st b1,b2 are_relative_prime
   holds ex b4 being integer set st
      ((b1 * b4) - b3) mod b2 = 0;

:: INT_4:th 16
theorem
for b1, b2, b3 being integer set
      st 0 < b1 & b2,b1 are_relative_prime
   holds ex b4 being natural set st
      ((b2 * b4) - b3) mod b1 = 0;

:: INT_4:th 17
theorem
for b1, b2, b3 being integer set
   st b1 <> 0 & not b2 gcd b1 divides b3
for b4 being integer set holds
   ((b2 * b4) - b3) mod b1 <> 0;

:: INT_4:th 18
theorem
for b1, b2, b3 being integer set
      st b1 <> 0 & b2 gcd b1 divides b3
   holds ex b4 being integer set st
      ((b2 * b4) - b3) mod b1 = 0;

:: INT_4:funcreg 3
registration
  let a1 be integer set;
  cluster a1 ^2 -> natural;
end;

:: INT_4:th 19
theorem
for b1, b2, b3 being natural set
      st 0 < b1 & 0 < b2
   holds (b2 * b3) mod (b2 |^ b1) = b2 * (b3 mod (b2 |^ (b1 -' 1)));

:: INT_4:th 20
theorem
for b1, b2, b3 being natural set holds
(b1 * b2) mod (b1 * b3) = b1 * (b2 mod b3);

:: INT_4:th 21
theorem
for b1, b2, b3 being natural set
      st 0 < b1 & b2 is prime & b2,b3 are_relative_prime
   holds not b2 divides b3 mod (b2 |^ b1);

:: INT_4:th 22
theorem
for b1, b2, b3 being natural set
      st 0 < b3
   holds    (b1 - b2) mod b3 = 0
   iff
      b1 mod b3 = b2 mod b3;

:: INT_4:th 23
theorem
for b1, b2, b3 being natural set
      st 0 < b3
   holds    b1 mod b3 = b2 mod b3
   iff
      b3 divides b1 - b2;

:: INT_4:th 24
theorem
for b1, b2, b3 being natural set
   st 0 < b1 & b2 is prime & b2,b3 are_relative_prime
for b4 being integer set holds
   ((b2 * (b4 ^2)) - b3) mod (b2 |^ b1) <> 0;

:: INT_4:th 25
theorem
for b1, b2, b3 being natural set
   st 0 < b1 & b2 is prime & b2,b3 are_relative_prime
for b4 being integer set holds
   ((b2 * b4) - b3) mod (b2 |^ b1) <> 0;

:: INT_4:funcnot 1 => INT_4:func 1
definition
  let a1 be integer set;
  func Cong A1 -> Relation of INT,INT means
    for b1, b2 being integer set holds
       [b1,b2] in it
    iff
       b1,b2 are_congruent_mod a1;
end;

:: INT_4:def 1
theorem
for b1 being integer set
for b2 being Relation of INT,INT holds
      b2 = Cong b1
   iff
      for b3, b4 being integer set holds
         [b3,b4] in b2
      iff
         b3,b4 are_congruent_mod b1;

:: INT_4:funcreg 4
registration
  let a1 be integer set;
  cluster Cong a1 -> total;
end;

:: INT_4:funcreg 5
registration
  let a1 be integer set;
  cluster Cong a1 -> reflexive symmetric transitive;
end;

:: INT_4:th 26
theorem
for b1, b2, b3, b4 being integer set
   st b1 <> 0 & ((b2 * b3) - b4) mod b1 = 0
for b5 being integer set holds
   (b2,b1 are_relative_prime & ((b2 * b5) - b4) mod b1 = 0 implies b5 in Class(Cong b1,b3)) &
    (b5 in Class(Cong b1,b3) implies ((b2 * b5) - b4) mod b1 = 0);

:: INT_4:th 27
theorem
for b1, b2, b3, b4 being integer set
      st b3 <> 0 & b1,b3 are_relative_prime & ((b1 * b4) - b2) mod b3 = 0
   holds ex b5 being integer set st
      [b4,b2 * b5] in Cong b3;

:: INT_4:th 28
theorem
for b1, b2 being Element of NAT
   st b1 <> 0 & 1 < b2 & b1,b2 are_relative_prime
for b3, b4 being integer set
      st ((b1 * b4) - b3) mod b2 = 0
   holds [b4,b3 * (b1 |^ ((Euler b2) -' 1))] in Cong b2;

:: INT_4:th 29
theorem
for b1, b2, b3 being integer set
      st b1 <> 0 & b2 gcd b1 divides b3
   holds ex b4 being FinSequence of INT st
      len b4 = b2 gcd b1 &
       (for b5 being Element of NAT
             st b5 in dom b4
          holds ((b2 * (b4 . b5)) - b3) mod b1 = 0) &
       (for b5, b6 being Element of NAT
             st b5 in dom b4 & b6 in dom b4 & b5 <> b6
          holds not b4 . b5,b4 . b6 are_congruent_mod b1);

:: INT_4:th 30
theorem
for b1 being FinSequence of NAT
for b2, b3, b4 being Element of NAT
      st b3 in dom b1 & len b1 = b4 + 1
   holds Del(b1 ^ <*b2*>,b3) = (Del(b1,b3)) ^ <*b2*>;

:: INT_4:th 31
theorem
for b1 being FinSequence of NAT
   st 2 <= len b1 &
      (for b2, b3 being Element of NAT
            st b2 in dom b1 & b3 in dom b1 & b2 <> b3
         holds (b1 . b2) hcf (b1 . b3) = 1)
for b2 being Element of NAT
      st b2 in dom b1
   holds (Product Del(b1,b2)) hcf (b1 . b2) = 1;

:: INT_4:th 32
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
      st b2 in dom b1
   holds b1 . b2 divides Product b1;

:: INT_4:th 33
theorem
for b1 being natural set
for b2 being FinSequence of NAT
for b3 being Element of NAT
      st b3 in dom b2 & b1 divides b2 . b3
   holds b1 divides Product b2;

:: INT_4:th 34
theorem
for b1 being FinSequence of NAT
for b2, b3 being Element of NAT
      st len b1 = b2 + 1 & 1 <= b3 & b3 <= b2
   holds (Del(b1,b3)) . b2 = b1 . len b1;

:: INT_4:th 35
theorem
for b1 being FinSequence of NAT
for b2, b3 being Element of NAT
      st b2 in dom b1 & b3 in dom b1 & b2 <> b3 & 1 <= len b1
   holds b1 . b3 divides Product Del(b1,b2);

:: INT_4:th 36
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
      st for b3 being Element of NAT
              st b3 in dom b1
           holds b2 divides b1 . b3
   holds b2 divides Sum b1;

:: INT_4:th 37
theorem
for b1 being FinSequence of NAT
   st 2 <= len b1 &
      (for b2, b3 being Element of NAT
            st b2 in dom b1 & b3 in dom b1 & b2 <> b3
         holds (b1 . b2) hcf (b1 . b3) = 1) &
      (for b2 being Element of NAT
            st b2 in dom b1
         holds b1 . b2 <> 0)
for b2 being FinSequence of NAT
      st len b2 = len b1
   holds ex b3 being integer set st
      for b4 being Element of NAT
            st b4 in dom b1
         holds (b3 - (b2 . b4)) mod (b1 . b4) = 0;

:: INT_4:th 38
theorem
for b1 being FinSequence of NAT
for b2 being Element of NAT
      st (for b3, b4 being Element of NAT
               st b3 in dom b1 & b4 in dom b1 & b3 <> b4
            holds (b1 . b3) hcf (b1 . b4) = 1) &
         (for b3 being Element of NAT
               st b3 in dom b1
            holds b1 . b3 divides b2)
   holds Product b1 divides b2;

:: INT_4:th 39
theorem
for b1, b2 being integer set
for b3 being FinSequence of NAT
   st 2 <= len b3 &
      (for b4, b5 being Element of NAT
            st b4 in dom b3 & b5 in dom b3 & b4 <> b5
         holds (b3 . b4) hcf (b3 . b5) = 1) &
      (for b4 being Element of NAT
            st b4 in dom b3
         holds 0 < b3 . b4)
for b4 being FinSequence of NAT
      st len b4 = len b3 &
         (for b5 being Element of NAT
               st b5 in dom b3
            holds (b1 - (b4 . b5)) mod (b3 . b5) = 0 &
             (b2 - (b4 . b5)) mod (b3 . b5) = 0)
   holds b1,b2 are_congruent_mod Product b3;

:: INT_4:th 40
theorem
for b1, b2, b3, b4 being integer set
      st b1 <> 0 & b2 <> 0 & b1,b2 are_relative_prime
   holds ex b5 being integer set st
      (for b6 being integer set
             st (b6 - b3) mod b1 = 0 & (b6 - b4) mod b2 = 0
          holds b6,b3 + (b1 * b5) are_congruent_mod b1 * b2) &
       ((b1 * b5) - (b4 - b3)) mod b2 = 0;

:: INT_4:th 41
theorem
for b1, b2, b3, b4 being integer set
   st b1 <> 0 & b2 <> 0 & not b1 gcd b2 divides b3 - b4
for b5 being integer set
      st (b5 - b3) mod b1 = 0
   holds (b5 - b4) mod b2 <> 0;

:: INT_4:th 42
theorem
for b1, b2, b3, b4 being integer set
      st b1 <> 0 & b2 <> 0 & b1 gcd b2 divides b3 - b4
   holds ex b5 being integer set st
      (for b6 being integer set
             st (b6 - b4) mod b1 = 0 & (b6 - b3) mod b2 = 0
          holds b6,b4 + (b1 * b5) are_congruent_mod b1 lcm b2) &
       (((b1 div (b1 gcd b2)) * b5) - ((b3 - b4) div (b1 gcd b2))) mod (b2 div (b1 gcd b2)) = 0;

:: INT_4:th 43
theorem
for b1, b2, b3, b4, b5, b6 being integer set
      st b1 <> 0 & b2 <> 0 & b3 gcd b1 divides b4 & b5 gcd b2 divides b6 & b1,b2 are_relative_prime
   holds ex b7, b8, b9 being integer set st
      (for b10 being integer set
             st ((b3 * b10) - b4) mod b1 = 0 & ((b5 * b10) - b6) mod b2 = 0
          holds b10,b8 + ((b1 div (b3 gcd b1)) * b7) are_congruent_mod (b1 div (b3 gcd b1)) * (b2 div (b5 gcd b2))) &
       (((b3 div (b3 gcd b1)) * b8) - (b4 div (b3 gcd b1))) mod (b1 div (b3 gcd b1)) = 0 &
       (((b5 div (b5 gcd b2)) * b9) - (b6 div (b5 gcd b2))) mod (b2 div (b5 gcd b2)) = 0 &
       (((b1 div (b3 gcd b1)) * b7) - (b9 - b8)) mod (b2 div (b5 gcd b2)) = 0;

:: INT_4:th 44
theorem
for b1, b2, b3, b4, b5, b6 being integer set
      st b1 <> 0 & b2 <> 0 & b3 <> 0 & b1,b2 are_relative_prime & b1,b3 are_relative_prime & b2,b3 are_relative_prime
   holds ex b7, b8 being integer set st
      for b9 being integer set
            st (b9 - b4) mod b1 = 0 & (b9 - b5) mod b2 = 0 & (b9 - b6) mod b3 = 0
         holds b9,(b4 + (b1 * b7)) + ((b1 * b2) * b8) are_congruent_mod (b1 * b2) * b3 &
          ((b1 * b7) - (b5 - b4)) mod b2 = 0 &
          (((b1 * b2) * b8) - ((b6 - b4) - (b1 * b7))) mod b3 = 0;

:: INT_4:th 45
theorem
for b1, b2, b3, b4, b5, b6 being integer set
   st b1 <> 0 &
      b2 <> 0 &
      b3 <> 0 &
      (b1 gcd b2 divides b4 - b5 & b1 gcd b3 divides b4 - b6 implies not b2 gcd b3 divides b5 - b6)
for b7 being integer set
      st (b7 - b4) mod b1 = 0 & (b7 - b5) mod b2 = 0
   holds (b7 - b6) mod b3 <> 0;

:: INT_4:th 46
theorem
for b1, b2, b3 being non empty natural set holds
(b1 hcf b3) lcm (b2 hcf b3) = (b1 lcm b2) hcf b3;

:: INT_4:th 47
theorem
for b1, b2, b3 being integer set
for b4, b5, b6 being non empty natural set
      st b4 hcf b5 divides b1 - b2 & b4 hcf b6 divides b1 - b3 & b5 hcf b6 divides b2 - b3
   holds ex b7, b8 being integer set st
      for b9 being integer set
            st (b9 - b1) mod b4 = 0 & (b9 - b2) mod b5 = 0 & (b9 - b3) mod b6 = 0
         holds b9,(b1 + (b4 * b7)) + ((b4 lcm b5) * b8) are_congruent_mod (b4 lcm b5) lcm b6 &
          (((b4 div (b4 hcf b5)) * b7) - ((b2 - b1) div (b4 hcf b5))) mod (b5 div (b4 hcf b5)) = 0 &
          ((((b4 lcm b5) div ((b4 lcm b5) hcf b6)) * b8) - ((b3 - (b1 + (b4 * b7))) div ((b4 lcm b5) hcf b6))) mod (b6 div ((b4 lcm b5) hcf b6)) = 0;

:: INT_4:prednot 1 => INT_4:pred 1
definition
  let a1 be natural set;
  let a2 be set;
  pred A2 is_CRS_of A1 means
    ex b1 being FinSequence of INT st
       a2 = rng b1 &
        len b1 = a1 &
        (for b2 being natural set
              st b2 in dom b1
           holds b1 . b2 in Class(Cong a1,b2 -' 1));
end;

:: INT_4:dfs 2
definiens
  let a1 be natural set;
  let a2 be set;
To prove
     a2 is_CRS_of a1
it is sufficient to prove
  thus ex b1 being FinSequence of INT st
       a2 = rng b1 &
        len b1 = a1 &
        (for b2 being natural set
              st b2 in dom b1
           holds b1 . b2 in Class(Cong a1,b2 -' 1));

:: INT_4:def 2
theorem
for b1 being natural set
for b2 being set holds
      b2 is_CRS_of b1
   iff
      ex b3 being FinSequence of INT st
         b2 = rng b3 &
          len b3 = b1 &
          (for b4 being natural set
                st b4 in dom b3
             holds b3 . b4 in Class(Cong b1,b4 -' 1));

:: INT_4:th 48
theorem
for b1 being Element of NAT holds
   {b2 where b2 is Element of NAT: b2 < b1} is_CRS_of b1;

:: INT_4:th 49
theorem
for b1 being Element of NAT
for b2 being finite set
      st b2 is_CRS_of b1
   holds card b2 = b1 &
    (for b3, b4 being integer set
          st b3 in b2 & b4 in b2 & b3 <> b4
       holds not [b3,b4] in Cong b1);

:: INT_4:th 50
theorem
for b1 being Element of NAT holds
      {} is_CRS_of b1
   iff
      b1 = 0;

:: INT_4:th 51
theorem
for b1 being Element of NAT
for b2 being finite set
      st card b2 = b1
   holds ex b3 being Relation-like Function-like FinSequence-like set st
      len b3 = b1 &
       (for b4 being Element of NAT
             st b4 in dom b3
          holds b3 . b4 in b2) &
       b3 is one-to-one;

:: INT_4:th 52
theorem
for b1 being Element of NAT
for b2 being finite Element of bool INT
      st card b2 = b1 &
         (for b3, b4 being integer set
               st b3 in b2 & b4 in b2 & b3 <> b4
            holds not [b3,b4] in Cong b1)
   holds b2 is_CRS_of b1;

:: INT_4:th 53
theorem
for b1 being Element of NAT
for b2 being integer set
for b3 being finite Element of bool INT
      st b3 is_CRS_of b1
   holds b2 ++ b3 is_CRS_of b1;

:: INT_4:th 54
theorem
for b1 being Element of NAT
for b2 being integer set
for b3 being finite Element of bool INT
      st b2,b1 are_relative_prime & b3 is_CRS_of b1
   holds b2 ** b3 is_CRS_of b1;