Article NAT_3, MML version 4.99.1005

:: NAT_3:funcreg 1
registration
  let a1 be empty set;
  cluster Card a1 -> empty cardinal;
end;

:: NAT_3:exreg 1
registration
  cluster Relation-like Function-like finite FinSequence-like natural-valued finite-support set;
end;

:: NAT_3:funcreg 2
registration
  let a1 be non empty natural set;
  let a2 be natural set;
  cluster a1 |^ a2 -> non empty;
end;

:: NAT_3:condreg 1
registration
  cluster natural prime -> non empty (set);
end;

:: NAT_3:th 1
theorem
for b1, b2, b3, b4 being natural set
      st b1 divides b3 & b2 divides b4
   holds b1 * b2 divides b3 * b4;

:: NAT_3:th 2
theorem
for b1, b2 being natural set
      st 1 < b1
   holds b2 <= b1 |^ b2;

:: NAT_3:th 3
theorem
for b1, b2 being natural set
      st b1 <> 0
   holds b2 divides b2 |^ b1;

:: NAT_3:th 4
theorem
for b1, b2, b3, b4 being natural set
      st b1 < b2 & b3 |^ b2 divides b4
   holds b3 |^ (b1 + 1) divides b4;

:: NAT_3:th 5
theorem
for b1, b2 being natural set
for b3 being natural prime set
      st b3 divides b1 |^ b2
   holds b3 divides b1;

:: NAT_3:th 6
theorem
for b1 being natural set
for b2, b3 being natural prime set
      st b3 divides b2 |^ b1
   holds b3 = b2;

:: NAT_3:th 7
theorem
for b1 being natural set
for b2 being FinSequence of NAT
      st b1 in rng b2
   holds b1 divides Product b2;

:: NAT_3:th 8
theorem
for b1 being natural prime set
for b2 being FinSequence of SetPrimes
      st b1 divides Product b2
   holds b1 in rng b2;

:: NAT_3:funcnot 1 => NAT_3:func 1
definition
  let a1 be Relation-like Function-like FinSequence-like real-valued set;
  let a2 be natural set;
  func A1 |^ A2 -> Relation-like Function-like FinSequence-like set means
    len it = len a1 &
     (for b1 being set
           st b1 in dom it
        holds it . b1 = (a1 . b1) |^ a2);
end;

:: NAT_3:def 1
theorem
for b1 being Relation-like Function-like FinSequence-like real-valued set
for b2 being natural set
for b3 being Relation-like Function-like FinSequence-like set holds
      b3 = b1 |^ b2
   iff
      len b3 = len b1 &
       (for b4 being set
             st b4 in dom b3
          holds b3 . b4 = (b1 . b4) |^ b2);

:: NAT_3:funcreg 3
registration
  let a1 be Relation-like Function-like FinSequence-like real-valued set;
  let a2 be natural set;
  cluster a1 |^ a2 -> Relation-like Function-like FinSequence-like real-valued;
end;

:: NAT_3:funcreg 4
registration
  let a1 be Relation-like Function-like FinSequence-like natural-valued set;
  let a2 be natural set;
  cluster a1 |^ a2 -> Relation-like Function-like FinSequence-like natural-valued;
end;

:: NAT_3:funcnot 2 => NAT_3:func 2
definition
  let a1 be FinSequence of REAL;
  let a2 be natural set;
  redefine func a1 |^ a2 -> FinSequence of REAL;
end;

:: NAT_3:funcnot 3 => NAT_3:func 3
definition
  let a1 be FinSequence of NAT;
  let a2 be natural set;
  redefine func a1 |^ a2 -> FinSequence of NAT;
end;

:: NAT_3:th 9
theorem
for b1 being FinSequence of REAL holds
   b1 |^ 0 = (len b1) |-> 1;

:: NAT_3:th 10
theorem
for b1 being FinSequence of REAL holds
   b1 |^ 1 = b1;

:: NAT_3:th 11
theorem
for b1 being natural set holds
   (<*> REAL) |^ b1 = <*> REAL;

:: NAT_3:th 12
theorem
for b1 being natural set
for b2 being Element of REAL holds
   <*b2*> |^ b1 = <*b2 |^ b1*>;

:: NAT_3:th 13
theorem
for b1 being natural set
for b2 being Element of REAL
for b3 being FinSequence of REAL holds
   (b3 ^ <*b2*>) |^ b1 = (b3 |^ b1) ^ (<*b2*> |^ b1);

:: NAT_3:th 14
theorem
for b1 being natural set
for b2 being FinSequence of REAL holds
   Product (b2 |^ (b1 + 1)) = (Product (b2 |^ b1)) * Product b2;

:: NAT_3:th 15
theorem
for b1 being natural set
for b2 being FinSequence of REAL holds
   Product (b2 |^ b1) = (Product b2) |^ b1;

:: NAT_3:exreg 2
registration
  let a1 be set;
  cluster Relation-like Function-like natural-valued finite-support ManySortedSet of a1;
end;

:: NAT_3:funcnot 4 => NAT_3:func 4
definition
  let a1 be set;
  let a2 be real-valued ManySortedSet of a1;
  let a3 be natural set;
  func A3 * A2 -> ManySortedSet of a1 means
    for b1 being set holds
       it . b1 = a3 * (a2 . b1);
end;

:: NAT_3:def 2
theorem
for b1 being set
for b2 being real-valued ManySortedSet of b1
for b3 being natural set
for b4 being ManySortedSet of b1 holds
      b4 = b3 * b2
   iff
      for b5 being set holds
         b4 . b5 = b3 * (b2 . b5);

:: NAT_3:funcreg 5
registration
  let a1 be set;
  let a2 be real-valued ManySortedSet of a1;
  let a3 be natural set;
  cluster a3 * a2 -> real-valued;
end;

:: NAT_3:funcreg 6
registration
  let a1 be set;
  let a2 be natural-valued ManySortedSet of a1;
  let a3 be natural set;
  cluster a3 * a2 -> natural-valued;
end;

:: NAT_3:funcreg 7
registration
  let a1 be set;
  let a2 be real-valued ManySortedSet of a1;
  cluster support (0 * a2) -> empty;
end;

:: NAT_3:th 16
theorem
for b1 being natural set
for b2 being set
for b3 being real-valued ManySortedSet of b2
      st b1 <> 0
   holds support b3 = support (b1 * b3);

:: NAT_3:funcreg 8
registration
  let a1 be set;
  let a2 be real-valued finite-support ManySortedSet of a1;
  let a3 be natural set;
  cluster a3 * a2 -> finite-support;
end;

:: NAT_3:funcnot 5 => NAT_3:func 5
definition
  let a1 be set;
  let a2, a3 be real-valued ManySortedSet of a1;
  func min(A2,A3) -> ManySortedSet of a1 means
    for b1 being set holds
       (a2 . b1 <= a3 . b1 implies it . b1 = a2 . b1) &
        (a2 . b1 <= a3 . b1 or it . b1 = a3 . b1);
end;

:: NAT_3:def 3
theorem
for b1 being set
for b2, b3 being real-valued ManySortedSet of b1
for b4 being ManySortedSet of b1 holds
      b4 = min(b2,b3)
   iff
      for b5 being set holds
         (b2 . b5 <= b3 . b5 implies b4 . b5 = b2 . b5) &
          (b2 . b5 <= b3 . b5 or b4 . b5 = b3 . b5);

:: NAT_3:funcreg 9
registration
  let a1 be set;
  let a2, a3 be real-valued ManySortedSet of a1;
  cluster min(a2,a3) -> real-valued;
end;

:: NAT_3:funcreg 10
registration
  let a1 be set;
  let a2, a3 be natural-valued ManySortedSet of a1;
  cluster min(a2,a3) -> natural-valued;
end;

:: NAT_3:th 17
theorem
for b1 being set
for b2, b3 being real-valued finite-support ManySortedSet of b1 holds
support min(b2,b3) c= (support b2) \/ support b3;

:: NAT_3:funcreg 11
registration
  let a1 be set;
  let a2, a3 be real-valued finite-support ManySortedSet of a1;
  cluster min(a2,a3) -> finite-support;
end;

:: NAT_3:funcnot 6 => NAT_3:func 6
definition
  let a1 be set;
  let a2, a3 be real-valued ManySortedSet of a1;
  func max(A2,A3) -> ManySortedSet of a1 means
    for b1 being set holds
       (a2 . b1 <= a3 . b1 implies it . b1 = a3 . b1) &
        (a2 . b1 <= a3 . b1 or it . b1 = a2 . b1);
end;

:: NAT_3:def 4
theorem
for b1 being set
for b2, b3 being real-valued ManySortedSet of b1
for b4 being ManySortedSet of b1 holds
      b4 = max(b2,b3)
   iff
      for b5 being set holds
         (b2 . b5 <= b3 . b5 implies b4 . b5 = b3 . b5) &
          (b2 . b5 <= b3 . b5 or b4 . b5 = b2 . b5);

:: NAT_3:funcreg 12
registration
  let a1 be set;
  let a2, a3 be real-valued ManySortedSet of a1;
  cluster max(a2,a3) -> real-valued;
end;

:: NAT_3:funcreg 13
registration
  let a1 be set;
  let a2, a3 be natural-valued ManySortedSet of a1;
  cluster max(a2,a3) -> natural-valued;
end;

:: NAT_3:th 18
theorem
for b1 being set
for b2, b3 being real-valued finite-support ManySortedSet of b1 holds
support max(b2,b3) c= (support b2) \/ support b3;

:: NAT_3:funcreg 14
registration
  let a1 be set;
  let a2, a3 be real-valued finite-support ManySortedSet of a1;
  cluster max(a2,a3) -> finite-support;
end;

:: NAT_3:condreg 2
registration
  cluster Relation-like natural-valued -> complex-valued (set);
end;

:: NAT_3:exreg 3
registration
  let a1 be set;
  cluster Relation-like Function-like complex-valued finite-support ManySortedSet of a1;
end;

:: NAT_3:funcnot 7 => NAT_3:func 7
definition
  let a1 be set;
  let a2 be complex-valued finite-support ManySortedSet of a1;
  func Product A2 -> complex set means
    ex b1 being FinSequence of COMPLEX st
       it = Product b1 & b1 = (canFS support a2) * a2;
end;

:: NAT_3:def 5
theorem
for b1 being set
for b2 being complex-valued finite-support ManySortedSet of b1
for b3 being complex set holds
      b3 = Product b2
   iff
      ex b4 being FinSequence of COMPLEX st
         b3 = Product b4 & b4 = (canFS support b2) * b2;

:: NAT_3:funcnot 8 => NAT_3:func 8
definition
  let a1 be set;
  let a2 be natural-valued finite-support ManySortedSet of a1;
  redefine func Product a2 -> Element of NAT;
end;

:: NAT_3:th 19
theorem
for b1 being set
for b2, b3 being natural-valued finite-support ManySortedSet of b1
      st support b2 misses support b3
   holds Product (b2 + b3) = (Product b2) * Product b3;

:: NAT_3:funcnot 9 => NAT_3:func 9
definition
  let a1 be set;
  let a2 be real-valued ManySortedSet of a1;
  let a3 be non empty natural set;
  func A2 |^ A3 -> ManySortedSet of a1 means
    support it = support a2 &
     (for b1 being set holds
        it . b1 = (a2 . b1) |^ a3);
end;

:: NAT_3:def 6
theorem
for b1 being set
for b2 being real-valued ManySortedSet of b1
for b3 being non empty natural set
for b4 being ManySortedSet of b1 holds
      b4 = b2 |^ b3
   iff
      support b4 = support b2 &
       (for b5 being set holds
          b4 . b5 = (b2 . b5) |^ b3);

:: NAT_3:funcreg 15
registration
  let a1 be set;
  let a2 be natural-valued ManySortedSet of a1;
  let a3 be non empty natural set;
  cluster a2 |^ a3 -> natural-valued;
end;

:: NAT_3:funcreg 16
registration
  let a1 be set;
  let a2 be real-valued finite-support ManySortedSet of a1;
  let a3 be non empty natural set;
  cluster a2 |^ a3 -> finite-support;
end;

:: NAT_3:th 20
theorem
for b1 being set holds
   Product EmptyBag b1 = 1;

:: NAT_3:funcnot 10 => NAT_3:func 10
definition
  let a1, a2 be natural set;
  assume a2 <> 1 & a1 <> 0;
  func A2 |-count A1 -> natural set means
    a2 |^ it divides a1 & not a2 |^ (it + 1) divides a1;
end;

:: NAT_3:def 7
theorem
for b1, b2 being natural set
   st b2 <> 1 & b1 <> 0
for b3 being natural set holds
      b3 = b2 |-count b1
   iff
      b2 |^ b3 divides b1 & not b2 |^ (b3 + 1) divides b1;

:: NAT_3:funcnot 11 => NAT_3:func 11
definition
  let a1, a2 be natural set;
  redefine func a2 |-count a1 -> Element of NAT;
end;

:: NAT_3:th 21
theorem
for b1 being natural set
      st b1 <> 1
   holds b1 |-count 1 = 0;

:: NAT_3:th 22
theorem
for b1 being natural set
      st 1 < b1
   holds b1 |-count b1 = 1;

:: NAT_3:th 23
theorem
for b1, b2 being natural set
      st b1 <> 0 & b1 < b2 & b2 <> 1
   holds b2 |-count b1 = 0;

:: NAT_3:th 24
theorem
for b1 being natural set
for b2 being natural prime set
      st b1 <> 1 & b1 <> b2
   holds b1 |-count b2 = 0;

:: NAT_3:th 25
theorem
for b1, b2 being natural set
      st 1 < b1
   holds b1 |-count (b1 |^ b2) = b2;

:: NAT_3:th 26
theorem
for b1, b2 being natural set
      st b1 <> 1 & b2 <> 0 & b1 divides b1 |^ (b1 |-count b2)
   holds b1 divides b2;

:: NAT_3:th 27
theorem
for b1, b2 being natural set
      st b1 <> 1
   holds    b2 <> 0 & b1 |-count b2 = 0
   iff
      not b1 divides b2;

:: NAT_3:th 28
theorem
for b1 being natural prime set
for b2, b3 being non empty natural set holds
b1 |-count (b2 * b3) = (b1 |-count b2) + (b1 |-count b3);

:: NAT_3:th 29
theorem
for b1 being natural prime set
for b2, b3 being non empty natural set holds
b1 |^ (b1 |-count (b2 * b3)) = (b1 |^ (b1 |-count b2)) * (b1 |^ (b1 |-count b3));

:: NAT_3:th 30
theorem
for b1 being natural prime set
for b2, b3 being non empty natural set
      st b3 divides b2
   holds b1 |-count b3 <= b1 |-count b2;

:: NAT_3:th 31
theorem
for b1 being natural prime set
for b2, b3 being non empty natural set
      st b3 divides b2
   holds b1 |-count (b2 div b3) = (b1 |-count b2) -' (b1 |-count b3);

:: NAT_3:th 32
theorem
for b1 being natural set
for b2 being natural prime set
for b3 being non empty natural set holds
   b2 |-count (b3 |^ b1) = b1 * (b2 |-count b3);

:: NAT_3:funcnot 12 => NAT_3:func 12
definition
  let a1 be natural set;
  func prime_exponents A1 -> ManySortedSet of SetPrimes means
    for b1 being natural prime set holds
       it . b1 = b1 |-count a1;
end;

:: NAT_3:def 8
theorem
for b1 being natural set
for b2 being ManySortedSet of SetPrimes holds
      b2 = prime_exponents b1
   iff
      for b3 being natural prime set holds
         b2 . b3 = b3 |-count b1;

:: NAT_3:funcnot 13 => NAT_3:func 12
notation
  let a1 be natural set;
  synonym pfexp a1 for prime_exponents a1;
end;

:: NAT_3:th 33
theorem
for b1 being natural set
for b2 being set
      st b2 in proj1 prime_exponents b1
   holds b2 is natural prime set;

:: NAT_3:th 34
theorem
for b1 being natural set
for b2 being set
      st b2 in support prime_exponents b1
   holds b2 is natural prime set;

:: NAT_3:th 35
theorem
for b1, b2 being natural set
      st b2 < b1 & b2 <> 0
   holds (prime_exponents b2) . b1 = 0;

:: NAT_3:funcreg 17
registration
  let a1 be natural set;
  cluster prime_exponents a1 -> natural-valued;
end;

:: NAT_3:th 36
theorem
for b1, b2 being natural set
      st b1 in support prime_exponents b2
   holds b1 divides b2;

:: NAT_3:th 37
theorem
for b1, b2 being natural set
      st b1 is not empty & b2 is natural prime set & b2 divides b1
   holds b2 in support prime_exponents b1;

:: NAT_3:funcreg 18
registration
  let a1 be non empty natural set;
  cluster prime_exponents a1 -> finite-support;
end;

:: NAT_3:th 38
theorem
for b1 being natural prime set
for b2 being non empty natural set
      st b1 divides b2
   holds (prime_exponents b2) . b1 <> 0;

:: NAT_3:th 39
theorem
prime_exponents 1 = EmptyBag SetPrimes;

:: NAT_3:funcreg 19
registration
  cluster support prime_exponents 1 -> empty;
end;

:: NAT_3:th 40
theorem
for b1 being natural set
for b2 being natural prime set holds
   (prime_exponents (b2 |^ b1)) . b2 = b1;

:: NAT_3:th 41
theorem
for b1 being natural prime set holds
   (prime_exponents b1) . b1 = 1;

:: NAT_3:th 42
theorem
for b1 being natural set
for b2 being natural prime set
      st b1 <> 0
   holds support prime_exponents (b2 |^ b1) = {b2};

:: NAT_3:th 43
theorem
for b1 being natural prime set holds
   support prime_exponents b1 = {b1};

:: NAT_3:funcreg 20
registration
  let a1 be natural prime set;
  let a2 be non empty natural set;
  cluster support prime_exponents (a1 |^ a2) -> non empty trivial;
end;

:: NAT_3:funcreg 21
registration
  let a1 be natural prime set;
  cluster support prime_exponents a1 -> non empty trivial;
end;

:: NAT_3:th 44
theorem
for b1, b2 being non empty natural set
      st b1,b2 are_relative_prime
   holds support prime_exponents b1 misses support prime_exponents b2;

:: NAT_3:th 45
theorem
for b1, b2 being non empty natural set holds
support prime_exponents b1 c= support prime_exponents (b1 * b2);

:: NAT_3:th 46
theorem
for b1, b2 being non empty natural set holds
support prime_exponents (b1 * b2) = (support prime_exponents b1) \/ support prime_exponents b2;

:: NAT_3:th 47
theorem
for b1, b2 being non empty natural set
      st b1,b2 are_relative_prime
   holds card support prime_exponents (b1 * b2) = (card support prime_exponents b1) + card support prime_exponents b2;

:: NAT_3:th 48
theorem
for b1, b2 being non empty natural set holds
support prime_exponents b1 = support prime_exponents (b1 |^ b2);

:: NAT_3:th 49
theorem
for b1, b2 being non empty natural set holds
prime_exponents (b1 * b2) = (prime_exponents b1) + prime_exponents b2;

:: NAT_3:th 50
theorem
for b1, b2 being non empty natural set
      st b1 divides b2
   holds prime_exponents (b2 div b1) = (prime_exponents b2) -' prime_exponents b1;

:: NAT_3:th 51
theorem
for b1 being natural set
for b2 being non empty natural set holds
   prime_exponents (b2 |^ b1) = b1 * prime_exponents b2;

:: NAT_3:th 52
theorem
for b1 being non empty natural set
      st support prime_exponents b1 = {}
   holds b1 = 1;

:: NAT_3:th 53
theorem
for b1, b2 being non empty natural set holds
prime_exponents (b2 hcf b1) = min(prime_exponents b2,prime_exponents b1);

:: NAT_3:th 54
theorem
for b1, b2 being non empty natural set holds
prime_exponents (b2 lcm b1) = max(prime_exponents b2,prime_exponents b1);

:: NAT_3:funcnot 14 => NAT_3:func 13
definition
  let a1 be non empty natural set;
  func prime_factorization A1 -> ManySortedSet of SetPrimes means
    support it = support prime_exponents a1 &
     (for b1 being natural set
           st b1 in support prime_exponents a1
        holds it . b1 = b1 |^ (b1 |-count a1));
end;

:: NAT_3:def 9
theorem
for b1 being non empty natural set
for b2 being ManySortedSet of SetPrimes holds
      b2 = prime_factorization b1
   iff
      support b2 = support prime_exponents b1 &
       (for b3 being natural set
             st b3 in support prime_exponents b1
          holds b2 . b3 = b3 |^ (b3 |-count b1));

:: NAT_3:funcnot 15 => NAT_3:func 13
notation
  let a1 be non empty natural set;
  synonym ppf a1 for prime_factorization a1;
end;

:: NAT_3:funcreg 22
registration
  let a1 be non empty natural set;
  cluster prime_factorization a1 -> natural-valued finite-support;
end;

:: NAT_3:th 55
theorem
for b1 being natural prime set
for b2 being non empty natural set
      st b1 |-count b2 = 0
   holds (prime_factorization b2) . b1 = 0;

:: NAT_3:th 56
theorem
for b1 being natural prime set
for b2 being non empty natural set
      st b1 |-count b2 <> 0
   holds (prime_factorization b2) . b1 = b1 |^ (b1 |-count b2);

:: NAT_3:th 57
theorem
for b1 being non empty natural set
      st support prime_factorization b1 = {}
   holds b1 = 1;

:: NAT_3:th 58
theorem
for b1, b2 being non empty natural set
      st b1,b2 are_relative_prime
   holds prime_factorization (b1 * b2) = (prime_factorization b1) + prime_factorization b2;

:: NAT_3:th 59
theorem
for b1 being natural prime set
for b2 being non empty natural set holds
   (prime_factorization (b1 |^ b2)) . b1 = b1 |^ b2;

:: NAT_3:th 60
theorem
for b1, b2 being non empty natural set holds
prime_factorization (b1 |^ b2) = (prime_factorization b1) |^ b2;

:: NAT_3:th 61
theorem
for b1 being non empty natural set holds
   Product prime_factorization b1 = b1;