Article WSIERP_1, MML version 4.99.1005

:: WSIERP_1:th 2
theorem
for b1 being real set holds
   b1 |^ 2 = b1 * b1 & (- b1) |^ 2 = b1 |^ 2;

:: WSIERP_1:th 3
theorem
for b1 being real set
for b2 being natural set holds
   (- b1) |^ (2 * b2) = b1 |^ (2 * b2) &
    (- b1) |^ ((2 * b2) + 1) = - (b1 |^ ((2 * b2) + 1));

:: WSIERP_1:th 5
theorem
for b1, b2 being real set
for b3 being Element of NAT
      st 0 <= b1 & 0 <= b2 & 0 < b3 & b1 |^ b3 = b2 |^ b3
   holds b1 = b2;

:: WSIERP_1:th 6
theorem
for b1, b2, b3 being real set holds
   max(b2,b3) < b1
iff
   b2 < b1 & b3 < b1;

:: WSIERP_1:th 7
theorem
for b1, b2, b3 being real set
      st b1 <= 0 & b3 <= b2
   holds b3 <= b2 - b1 & b3 + b1 <= b2;

:: WSIERP_1:th 8
theorem
for b1, b2, b3 being real set
      st (b1 <= 0 & b3 < b2 or b1 < 0 & b3 <= b2)
   holds b3 + b1 < b2 & b3 < b2 - b1;

:: WSIERP_1:funcreg 1
registration
  let a1 be integer set;
  let a2 be Element of NAT;
  cluster a1 |^ a2 -> integer;
end;

:: WSIERP_1:th 9
theorem
for b1, b2, b3 being integer set
      st b1 divides b2 & b1 divides b3
   holds b1 divides b2 + b3;

:: WSIERP_1:th 10
theorem
for b1, b2, b3, b4, b5 being integer set
      st b1 divides b2 & b1 divides b3
   holds b1 divides (b2 * b4) + (b3 * b5);

:: WSIERP_1:th 11
theorem
for b1, b2, b3 being integer set
      st b1 gcd b2 = 1 & b3 gcd b2 = 1
   holds (b1 * b3) gcd b2 = 1;

:: WSIERP_1:th 12
theorem
for b1, b2, b3 being Element of NAT
      st b1 hcf b2 = 1 & b3 hcf b2 = 1
   holds (b1 * b3) hcf b2 = 1;

:: WSIERP_1:th 13
theorem
for b1 being integer set holds
   0 gcd b1 = abs b1 & 1 gcd b1 = 1;

:: WSIERP_1:th 14
theorem
for b1 being integer set holds
   1,b1 are_relative_prime;

:: WSIERP_1:th 15
theorem
for b1 being Element of NAT
for b2, b3 being integer set
      st b2,b3 are_relative_prime
   holds b2 |^ b1,b3 are_relative_prime;

:: WSIERP_1:th 16
theorem
for b1, b2 being Element of NAT
for b3, b4 being integer set
      st b3,b4 are_relative_prime
   holds b3 |^ b1,b4 |^ b2 are_relative_prime;

:: WSIERP_1:th 17
theorem
for b1, b2 being Element of NAT
for b3, b4 being integer set
      st b3 gcd b4 = 1
   holds b3 gcd (b4 |^ b1) = 1 & (b3 |^ b2) gcd (b4 |^ b1) = 1;

:: WSIERP_1:th 18
theorem
for b1, b2 being integer set holds
   abs b1 divides b2
iff
   b1 divides b2;

:: WSIERP_1:th 19
theorem
for b1, b2, b3 being Element of NAT
      st b1 divides b2
   holds b1 |^ b3 divides b2 |^ b3;

:: WSIERP_1:th 20
theorem
for b1 being Element of NAT
      st b1 divides 1
   holds b1 = 1;

:: WSIERP_1:th 21
theorem
for b1, b2, b3 being Element of NAT
      st b1 divides b2 & b2 hcf b3 = 1
   holds b1 hcf b3 = 1;

:: WSIERP_1:th 22
theorem
for b1, b2 being integer set
      st b1 <> 0
   holds    b1 divides b2
   iff
      b2 / b1 is integer set;

:: WSIERP_1:th 23
theorem
for b1, b2, b3 being Element of NAT
      st b1 <= b2 - b3
   holds b1 <= b2 & b3 <= b2;

:: WSIERP_1:funcreg 2
registration
  let a1 be FinSequence of INT;
  let a2 be set;
  cluster a1 . a2 -> integer;
end;

:: WSIERP_1:funcnot 1 => WSIERP_1:func 1
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool a1;
  let a3, a4 be FinSequence of a2;
  redefine func a3 ^ a4 -> FinSequence of a2;
end;

:: WSIERP_1:funcnot 2 => WSIERP_1:func 2
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool a1;
  redefine func <*> a2 -> empty FinSequence of a2;
end;

:: WSIERP_1:condreg 1
registration
  cluster -> real-valued (FinSequence of INT);
end;

:: WSIERP_1:condreg 2
registration
  cluster -> real-valued (FinSequence of NAT);
end;

:: WSIERP_1:funcreg 3
registration
  let a1 be FinSequence of INT;
  cluster Product a1 -> complex integer;
end;

:: WSIERP_1:funcnot 3 => WSIERP_1:func 3
definition
  let a1 be FinSequence of NAT;
  redefine func Sum a1 -> Element of NAT;
end;

:: WSIERP_1:funcnot 4 => WSIERP_1:func 4
definition
  let a1 be FinSequence of NAT;
  redefine func Product a1 -> Element of NAT;
end;

:: WSIERP_1:funcnot 5 => FINSEQ_3:func 2
definition
  let a1 be natural set;
  let a2 be Relation-like Function-like FinSequence-like set;
  func Del(A2,A1) -> Relation-like Function-like FinSequence-like set means
    it = a2
    if not a1 in dom a2
    otherwise (len it) + 1 = len a2 &
     (for b1 being Element of NAT holds
        (a1 <= b1 or it . b1 = a2 . b1) &
         (a1 <= b1 implies it . b1 = a2 . (b1 + 1)));
end;

:: WSIERP_1:def 1
theorem
for b1 being natural set
for b2, b3 being Relation-like Function-like FinSequence-like set holds
(b1 in dom b2 or    (b3 = Del(b2,b1)
 iff
    b3 = b2)) &
 (b1 in dom b2 implies    (b3 = Del(b2,b1)
 iff
    (len b3) + 1 = len b2 &
     (for b4 being Element of NAT holds
        (b1 <= b4 or b3 . b4 = b2 . b4) &
         (b1 <= b4 implies b3 . b4 = b2 . (b4 + 1)))));

:: WSIERP_1:funcnot 6 => WSIERP_1:func 5
definition
  let a1 be non empty set;
  let a2 be natural set;
  let a3 be FinSequence of a1;
  redefine func Del(a3,a2) -> FinSequence of a1;
end;

:: WSIERP_1:funcnot 7 => WSIERP_1:func 6
definition
  let a1 be non empty set;
  let a2 be non empty Element of bool a1;
  let a3 be natural set;
  let a4 be FinSequence of a2;
  redefine func Del(a4,a3) -> FinSequence of a2;
end;

:: WSIERP_1:th 26
theorem
for b1, b2, b3 being set holds
Del(<*b1*>,1) = {} &
 Del(<*b1,b2*>,1) = <*b2*> &
 Del(<*b1,b2*>,2) = <*b1*> &
 Del(<*b1,b2,b3*>,1) = <*b2,b3*> &
 Del(<*b1,b2,b3*>,2) = <*b1,b3*> &
 Del(<*b1,b2,b3*>,3) = <*b1,b2*>;

:: WSIERP_1:th 27
theorem
for b1 being Element of NAT
for b2 being FinSequence of REAL
      st b1 in dom b2
   holds (Sum Del(b2,b1)) + (b2 . b1) = Sum b2;

:: WSIERP_1:th 28
theorem
for b1 being Element of NAT
for b2 being FinSequence of NAT
      st b1 in dom b2
   holds (Product b2) / (b2 . b1) is Element of NAT;

:: WSIERP_1:th 29
theorem
for b1 being rational set holds
   numerator b1,denominator b1 are_relative_prime;

:: WSIERP_1:th 30
theorem
for b1 being Element of NAT
for b2 being integer set
for b3 being rational set
      st b3 <> 0 & b3 = b2 / b1 & b1 <> 0 & b2,b1 are_relative_prime
   holds b2 = numerator b3 & b1 = denominator b3;

:: WSIERP_1:th 31
theorem
for b1, b2 being Element of NAT
      st ex b3 being rational set st
           b1 = b3 |^ b2
   holds ex b3 being integer set st
      b1 = b3 |^ b2;

:: WSIERP_1:th 32
theorem
for b1, b2 being Element of NAT
      st ex b3 being rational set st
           b1 = b3 |^ b2
   holds ex b3 being Element of NAT st
      b1 = b3 |^ b2;

:: WSIERP_1:th 33
theorem
for b1, b2, b3 being Element of NAT
      st 0 < b1 & b2 |^ b1 divides b3 |^ b1
   holds b2 divides b3;

:: WSIERP_1:th 34
theorem
for b1, b2 being Element of NAT holds
ex b3, b4 being integer set st
   b1 hcf b2 = (b1 * b3) + (b2 * b4);

:: WSIERP_1:th 35
theorem
for b1, b2 being integer set holds
ex b3, b4 being integer set st
   b1 gcd b2 = (b1 * b3) + (b2 * b4);

:: WSIERP_1:th 36
theorem
for b1, b2, b3 being integer set
      st b1 divides b2 * b3 & b1 gcd b2 = 1
   holds b1 divides b3;

:: WSIERP_1:th 37
theorem
for b1, b2, b3 being natural set
      st b1 hcf b2 = 1 & b1 divides b2 * b3
   holds b1 divides b3;

:: WSIERP_1:th 38
theorem
for b1, b2 being Element of NAT
      st b1 <> 0 & b2 <> 0
   holds ex b3, b4 being Element of NAT st
      b1 hcf b2 = (b1 * b3) - (b2 * b4);

:: WSIERP_1:th 39
theorem
for b1, b2, b3, b4 being Element of NAT
      st 0 < b1 & 0 < b2 & b1 hcf b2 = 1 & b3 |^ b1 = b4 |^ b2
   holds ex b5 being Element of NAT st
      b3 = b5 |^ b2 & b4 = b5 |^ b1;

:: WSIERP_1:th 40
theorem
for b1, b2, b3 being integer set holds
   ex b4, b5 being integer set st
      (b1 * b4) + (b2 * b5) = b3
iff
   b1 gcd b2 divides b3;

:: WSIERP_1:th 41
theorem
for b1, b2, b3, b4, b5 being integer set
   st b1 <> 0 & b2 <> 0 & (b1 * b3) + (b2 * b4) = b5
for b6, b7 being integer set
      st (b1 * b6) + (b2 * b7) = b5
   holds ex b8 being integer set st
      b6 = b3 + (b8 * (b2 / (b1 gcd b2))) &
       b7 = b4 - (b8 * (b1 / (b1 gcd b2)));

:: WSIERP_1:th 42
theorem
for b1, b2, b3, b4 being Element of NAT
      st b1 hcf b2 = 1 & b1 * b2 = b3 |^ b4
   holds ex b5, b6 being Element of NAT st
      b1 = b5 |^ b4 & b2 = b6 |^ b4;

:: WSIERP_1:th 43
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 (b1 . b3) hcf b2 = 1
   holds (Product b1) hcf b2 = 1;

:: WSIERP_1:th 44
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 FinSequence of INT
      st len b2 = len b1
   holds ex b3 being FinSequence of INT st
      len b3 = len b1 &
       (for b4 being Element of NAT
             st b4 in dom b1
          holds ((b1 . b4) * (b3 . b4)) + (b2 . b4) = ((b1 . 1) * (b3 . 1)) + (b2 . 1));

:: WSIERP_1:th 46
theorem
for b1 being Element of NAT
for b2 being integer set
      st b1 <> 0 & b1 gcd b2 = 1
   holds ex b3, b4 being Element of NAT st
      0 <> b3 &
       0 <> b4 &
       b3 <= sqrt b1 &
       b4 <= sqrt b1 &
       (b1 divides (b2 * b3) + b4 or b1 divides (b2 * b3) - b4);

:: WSIERP_1:th 47
theorem
for b1 being Element of NAT
for b2 being Relation-like Function-like FinSequence-like set holds
   dom Del(b2,b1) c= dom b2;

:: WSIERP_1:th 48
theorem
for b1 being Relation-like Function-like FinSequence-like set
for b2 being set holds
   Del(<*b2*> ^ b1,1) = b1 &
    Del(b1 ^ <*b2*>,(len b1) + 1) = b1;

:: WSIERP_1:th 49
theorem
for b1 being integer set
for b2 being natural set
      st 0 < b2 & b1 mod b2 <> 0
   holds - (b1 div b2) = ((- b1) div b2) + 1;

:: WSIERP_1:th 50
theorem
for b1 being integer set
for b2 being natural set
      st 0 < b2 & b1 mod b2 = 0
   holds - (b1 div b2) = (- b1) div b2;