Article INT_1, MML version 4.99.1005

:: INT_1:funcnot 1 => NUMBERS:func 4
definition
  func INT -> set means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being Element of NAT st
             (b1 = b2 or b1 = - b2);
end;

:: INT_1:def 1
theorem
for b1 being set holds
      b1 = INT
   iff
      for b2 being set holds
            b2 in b1
         iff
            ex b3 being Element of NAT st
               (b2 = b3 or b2 = - b3);

:: INT_1:attrnot 1 => INT_1:attr 1
definition
  let a1 be set;
  attr a1 is integer means
    a1 in INT;
end;

:: INT_1:dfs 2
definiens
  let a1 be set;
To prove
     a1 is integer
it is sufficient to prove
  thus a1 in INT;

:: INT_1:def 2
theorem
for b1 being set holds
      b1 is integer
   iff
      b1 in INT;

:: INT_1:exreg 1
registration
  cluster ext-real complex real integer Element of REAL;
end;

:: INT_1:exreg 2
registration
  cluster integer set;
end;

:: INT_1:condreg 1
registration
  cluster -> integer (Element of INT);
end;

:: INT_1:modenot 1
definition
  mode Integer is integer set;
end;

:: INT_1:th 7
theorem
for b1 being real set
for b2 being natural set
      st (b1 = b2 or b1 = - b2)
   holds b1 is integer set;

:: INT_1:th 8
theorem
for b1 being real set
      st b1 is integer set
   holds ex b2 being Element of NAT st
      (b1 = b2 or b1 = - b2);

:: INT_1:condreg 2
registration
  cluster -> integer (Element of NAT);
end;

:: INT_1:condreg 3
registration
  cluster natural -> integer (set);
end;

:: INT_1:condreg 4
registration
  cluster integer -> real (set);
end;

:: INT_1:funcreg 1
registration
  let a1, a2 be integer set;
  cluster a1 + a2 -> integer;
end;

:: INT_1:funcreg 2
registration
  let a1, a2 be integer set;
  cluster a1 * a2 -> integer;
end;

:: INT_1:funcreg 3
registration
  let a1 be integer set;
  cluster - a1 -> complex integer;
end;

:: INT_1:funcreg 4
registration
  let a1, a2 be integer set;
  cluster a1 - a2 -> integer;
end;

:: INT_1:funcreg 5
registration
  let a1 be Element of NAT;
  cluster - a1 -> complex integer;
end;

:: INT_1:funcreg 6
registration
  let a1 be Element of NAT;
  let a2 be integer set;
  cluster a2 + a1 -> integer;
end;

:: INT_1:funcreg 7
registration
  let a1 be Element of NAT;
  let a2 be integer set;
  cluster a2 * a1 -> integer;
end;

:: INT_1:funcreg 8
registration
  let a1 be Element of NAT;
  let a2 be integer set;
  cluster a2 - a1 -> integer;
end;

:: INT_1:funcreg 9
registration
  let a1, a2 be Element of NAT;
  cluster a1 - a2 -> integer;
end;

:: INT_1:th 16
theorem
for b1 being integer set
      st 0 <= b1
   holds b1 in NAT;

:: INT_1:th 17
theorem
for b1 being real set
      st b1 is integer set
   holds b1 + 1 is integer set & b1 - 1 is integer set;

:: INT_1:th 18
theorem
for b1, b2 being integer set
      st b1 <= b2
   holds b2 - b1 in NAT;

:: INT_1:th 19
theorem
for b1 being Element of NAT
for b2, b3 being integer set
      st b2 + b1 = b3
   holds b2 <= b3;

:: INT_1:th 20
theorem
for b1, b2 being integer set
      st b1 < b2
   holds b1 + 1 <= b2;

:: INT_1:th 21
theorem
for b1 being integer set
      st b1 < 0
   holds b1 <= - 1;

:: INT_1:th 22
theorem
for b1, b2 being integer set holds
   b1 * b2 = 1
iff
   (b1 = 1 & b2 = 1 or b1 = - 1 & b2 = - 1);

:: INT_1:th 23
theorem
for b1, b2 being integer set holds
   b1 * b2 = - 1
iff
   (b1 = - 1 & b2 = 1 or b1 = 1 & b2 = - 1);

:: INT_1:sch 1
scheme INT_1:sch 1
ex b1 being Element of bool INT st
   for b2 being integer set holds
         b2 in b1
      iff
         P1[b2]


:: INT_1:sch 2
scheme INT_1:sch 2
{F1 -> integer set}:
for b1 being integer set
      st F1() <= b1
   holds P1[b1]
provided
   P1[F1()]
and
   for b1 being integer set
         st F1() <= b1 & P1[b1]
      holds P1[b1 + 1];


:: INT_1:sch 3
scheme INT_1:sch 3
{F1 -> integer set}:
for b1 being integer set
      st b1 <= F1()
   holds P1[b1]
provided
   P1[F1()]
and
   for b1 being integer set
         st b1 <= F1() & P1[b1]
      holds P1[b1 - 1];


:: INT_1:sch 4
scheme INT_1:sch 4
{F1 -> integer set}:
for b1 being integer set holds
   P1[b1]
provided
   P1[F1()]
and
   for b1 being integer set
         st P1[b1]
      holds P1[b1 - 1] & P1[b1 + 1];


:: INT_1:sch 5
scheme INT_1:sch 5
{F1 -> integer set}:
ex b1 being integer set st
   P1[b1] &
    (for b2 being integer set
          st P1[b2]
       holds b1 <= b2)
provided
   for b1 being integer set
         st P1[b1]
      holds F1() <= b1
and
   ex b1 being integer set st
      P1[b1];


:: INT_1:sch 6
scheme INT_1:sch 6
{F1 -> integer set}:
ex b1 being integer set st
   P1[b1] &
    (for b2 being integer set
          st P1[b2]
       holds b2 <= b1)
provided
   for b1 being integer set
         st P1[b1]
      holds b1 <= F1()
and
   ex b1 being integer set st
      P1[b1];


:: INT_1:prednot 1 => INT_1:pred 1
definition
  let a1, a2, a3 be integer set;
  pred A1,A2 are_congruent_mod A3 means
    ex b1 being integer set st
       a3 * b1 = a1 - a2;
end;

:: INT_1:dfs 3
definiens
  let a1, a2, a3 be integer set;
To prove
     a1,a2 are_congruent_mod a3
it is sufficient to prove
  thus ex b1 being integer set st
       a3 * b1 = a1 - a2;

:: INT_1:def 3
theorem
for b1, b2, b3 being integer set holds
   b1,b2 are_congruent_mod b3
iff
   ex b4 being integer set st
      b3 * b4 = b1 - b2;

:: INT_1:th 32
theorem
for b1, b2 being integer set holds
b1,b1 are_congruent_mod b2;

:: INT_1:th 33
theorem
for b1 being integer set holds
   b1,0 are_congruent_mod b1 & 0,b1 are_congruent_mod b1;

:: INT_1:th 34
theorem
for b1, b2 being integer set holds
b1,b2 are_congruent_mod 1;

:: INT_1:th 35
theorem
for b1, b2, b3 being integer set
      st b1,b2 are_congruent_mod b3
   holds b2,b1 are_congruent_mod b3;

:: INT_1:th 36
theorem
for b1, b2, b3, b4 being integer set
      st b1,b2 are_congruent_mod b3 & b2,b4 are_congruent_mod b3
   holds b1,b4 are_congruent_mod b3;

:: INT_1:th 37
theorem
for b1, b2, b3, b4, b5 being integer set
      st b1,b2 are_congruent_mod b3 & b4,b5 are_congruent_mod b3
   holds b1 + b4,b2 + b5 are_congruent_mod b3;

:: INT_1:th 38
theorem
for b1, b2, b3, b4, b5 being integer set
      st b1,b2 are_congruent_mod b3 & b4,b5 are_congruent_mod b3
   holds b1 - b4,b2 - b5 are_congruent_mod b3;

:: INT_1:th 39
theorem
for b1, b2, b3, b4, b5 being integer set
      st b1,b2 are_congruent_mod b3 & b4,b5 are_congruent_mod b3
   holds b1 * b4,b2 * b5 are_congruent_mod b3;

:: INT_1:th 40
theorem
for b1, b2, b3, b4 being integer set holds
   b1 + b2,b3 are_congruent_mod b4
iff
   b1,b3 - b2 are_congruent_mod b4;

:: INT_1:th 41
theorem
for b1, b2, b3, b4, b5 being integer set
      st b1 * b2 = b3 & b4,b5 are_congruent_mod b3
   holds b4,b5 are_congruent_mod b1;

:: INT_1:th 42
theorem
for b1, b2, b3 being integer set holds
   b1,b2 are_congruent_mod b3
iff
   b1 + b3,b2 are_congruent_mod b3;

:: INT_1:th 43
theorem
for b1, b2, b3 being integer set holds
   b1,b2 are_congruent_mod b3
iff
   b1 - b3,b2 are_congruent_mod b3;

:: INT_1:th 44
theorem
for b1 being real set
for b2, b3 being integer set
      st b2 <= b1 & b1 - 1 < b2 & b3 <= b1 & b1 - 1 < b3
   holds b2 = b3;

:: INT_1:th 45
theorem
for b1 being real set
for b2, b3 being integer set
      st b1 <= b2 & b2 < b1 + 1 & b1 <= b3 & b3 < b1 + 1
   holds b2 = b3;

:: INT_1:funcnot 2 => INT_1:func 1
definition
  let a1 be real set;
  func [\A1/] -> integer set means
    it <= a1 & a1 - 1 < it;
end;

:: INT_1:def 4
theorem
for b1 being real set
for b2 being integer set holds
      b2 = [\b1/]
   iff
      b2 <= b1 & b1 - 1 < b2;

:: INT_1:th 47
theorem
for b1 being real set holds
      [\b1/] = b1
   iff
      b1 is integer;

:: INT_1:th 48
theorem
for b1 being real set holds
      [\b1/] < b1
   iff
      b1 is not integer;

:: INT_1:th 50
theorem
for b1 being real set holds
   [\b1/] - 1 < b1 & [\b1/] < b1 + 1;

:: INT_1:th 51
theorem
for b1 being real set
for b2 being integer set holds
   [\b1/] + b2 = [\b1 + b2/];

:: INT_1:th 52
theorem
for b1 being real set holds
   b1 < [\b1/] + 1;

:: INT_1:funcnot 3 => INT_1:func 2
definition
  let a1 be real set;
  func [/A1\] -> integer set means
    a1 <= it & it < a1 + 1;
end;

:: INT_1:def 5
theorem
for b1 being real set
for b2 being integer set holds
      b2 = [/b1\]
   iff
      b1 <= b2 & b2 < b1 + 1;

:: INT_1:th 54
theorem
for b1 being real set holds
      [/b1\] = b1
   iff
      b1 is integer;

:: INT_1:th 55
theorem
for b1 being real set holds
      b1 < [/b1\]
   iff
      b1 is not integer;

:: INT_1:th 57
theorem
for b1 being real set holds
   b1 - 1 < [/b1\] & b1 < [/b1\] + 1;

:: INT_1:th 58
theorem
for b1 being real set
for b2 being integer set holds
   [/b1\] + b2 = [/b1 + b2\];

:: INT_1:th 59
theorem
for b1 being real set holds
      [\b1/] = [/b1\]
   iff
      b1 is integer;

:: INT_1:th 60
theorem
for b1 being real set holds
      [\b1/] < [/b1\]
   iff
      b1 is not integer;

:: INT_1:th 61
theorem
for b1 being real set holds
   [\b1/] <= [/b1\];

:: INT_1:th 62
theorem
for b1 being real set holds
   [\[/b1\]/] = [/b1\];

:: INT_1:th 63
theorem
for b1 being real set holds
   [\[\b1/]/] = [\b1/];

:: INT_1:th 64
theorem
for b1 being real set holds
   [/[/b1\]\] = [/b1\];

:: INT_1:th 65
theorem
for b1 being real set holds
   [/[\b1/]\] = [\b1/];

:: INT_1:th 66
theorem
for b1 being real set holds
      [\b1/] = [/b1\]
   iff
      [\b1/] + 1 <> [/b1\];

:: INT_1:funcnot 4 => INT_1:func 3
definition
  let a1 be real set;
  func frac A1 -> set equals
    a1 - [\a1/];
end;

:: INT_1:def 6
theorem
for b1 being real set holds
   frac b1 = b1 - [\b1/];

:: INT_1:funcreg 10
registration
  let a1 be real set;
  cluster frac a1 -> real;
end;

:: INT_1:funcnot 5 => INT_1:func 4
definition
  let a1 be real set;
  redefine func frac a1 -> Element of REAL;
end;

:: INT_1:th 68
theorem
for b1 being real set holds
   b1 = [\b1/] + frac b1;

:: INT_1:th 69
theorem
for b1 being real set holds
   frac b1 < 1 & 0 <= frac b1;

:: INT_1:th 70
theorem
for b1 being real set holds
   [\frac b1/] = 0;

:: INT_1:th 71
theorem
for b1 being real set holds
      frac b1 = 0
   iff
      b1 is integer;

:: INT_1:th 72
theorem
for b1 being real set holds
      0 < frac b1
   iff
      b1 is not integer;

:: INT_1:funcnot 6 => INT_1:func 5
definition
  let a1, a2 be integer set;
  func A1 div A2 -> integer set equals
    [\a1 / a2/];
end;

:: INT_1:def 7
theorem
for b1, b2 being integer set holds
b1 div b2 = [\b1 / b2/];

:: INT_1:funcnot 7 => INT_1:func 6
definition
  let a1, a2 be integer set;
  func A1 mod A2 -> integer set equals
    a1 - ((a1 div a2) * a2)
    if a2 <> 0
    otherwise 0;
end;

:: INT_1:def 8
theorem
for b1, b2 being integer set holds
(b2 = 0 or b1 mod b2 = b1 - ((b1 div b2) * b2)) &
 (b2 = 0 implies b1 mod b2 = 0);

:: INT_1:prednot 2 => INT_1:pred 2
definition
  let a1, a2 be integer set;
  pred A1 divides A2 means
    ex b1 being integer set st
       a2 = a1 * b1;
  reflexivity;
::  for a1 being integer set holds
::     a1 divides a1;
end;

:: INT_1:dfs 9
definiens
  let a1, a2 be integer set;
To prove
     a1 divides a2
it is sufficient to prove
  thus ex b1 being integer set st
       a2 = a1 * b1;

:: INT_1:def 9
theorem
for b1, b2 being integer set holds
   b1 divides b2
iff
   ex b3 being integer set st
      b2 = b1 * b3;

:: INT_1:th 74
theorem
for b1 being real set
      st b1 <> 0
   holds [\b1 / b1/] = 1;

:: INT_1:th 75
theorem
for b1 being integer set holds
   b1 div 0 = 0;

:: INT_1:th 76
theorem
for b1 being integer set
      st b1 <> 0
   holds b1 div b1 = 1;

:: INT_1:th 77
theorem
for b1 being integer set holds
   b1 mod b1 = 0;

:: INT_1:th 78
theorem
for b1 being Element of NAT
for b2 being integer set
      st b1 < b2
   holds ex b3 being Element of NAT st
      b3 = b2 - b1 & 1 <= b3;

:: INT_1:th 79
theorem
for b1, b2 being integer set
      st b1 < b2
   holds b1 <= b2 - 1;

:: INT_1:th 80
theorem
for b1 being real set
      st 0 <= b1
   holds 0 <= [/b1\] & 0 <= [\b1/] & [/b1\] is Element of NAT & [\b1/] is Element of NAT;

:: INT_1:th 81
theorem
for b1 being integer set
for b2 being real set
      st b1 <= b2
   holds b1 <= [\b2/];

:: INT_1:th 82
theorem
for b1, b2 being natural set holds
0 <= b1 div b2;

:: INT_1:th 83
theorem
for b1, b2 being integer set
      st 0 < b1 & 1 < b2
   holds b1 div b2 < b1;

:: INT_1:th 84
theorem
for b1, b2 being integer set
      st 0 <= b1
   holds 0 <= b2 mod b1;

:: INT_1:th 85
theorem
for b1, b2 being integer set
      st 0 < b1
   holds b2 mod b1 < b1;

:: INT_1:th 86
theorem
for b1, b2 being integer set
      st b1 <> 0
   holds b2 = ((b2 div b1) * b1) + (b2 mod b1);

:: INT_1:th 87
theorem
for b1, b2 being integer set holds
b1 * b2,0 are_congruent_mod b1;

:: INT_1:th 88
theorem
for b1, b2 being integer set
      st 0 <= b1 & 0 <= b2
   holds 0 <= b1 div b2;

:: INT_1:th 89
theorem
for b1 being natural set
   st 0 < b1
for b2 being integer set holds
      b2 mod b1 = 0
   iff
      b1 divides b2;

:: INT_1:th 90
theorem
for b1, b2 being real set
      st b1 / b2 is not integer set
   holds - [\b1 / b2/] = [\(- b1) / b2/] + 1;

:: INT_1:th 91
theorem
for b1, b2 being real set
      st b1 / b2 is integer set
   holds - [\b1 / b2/] = [\(- b1) / b2/];