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;