Article MOEBIUS1, MML version 4.99.1005

:: MOEBIUS1:sch 1
scheme MOEBIUS1:sch 1
{F1 -> Element of NAT,
  F2 -> set,
  F3 -> set}:
ex b1 being Function-like quasi_total Relation of NAT,F2() st
   b1 . 0 = F1() &
    (for b2 being non empty Element of NAT holds
       b1 . b2 = F3(b2))
provided
   F1() in F2()
and
   for b1 being non empty Element of NAT holds
      F3(b1) in F2();


:: MOEBIUS1:exreg 1
registration
  cluster non empty epsilon-transitive epsilon-connected ordinal natural complex real integer non prime complex-membered ext-real-membered real-membered rational-membered integer-membered natural-membered rational ext-real non negative Element of NAT;
end;

:: MOEBIUS1:th 1
theorem
for b1 being non empty natural set
      st b1 <> 1
   holds 2 <= b1;

:: MOEBIUS1:th 2
theorem
for b1, b2, b3 being natural set
      st 1 <= b1
   holds    b3 in Seg b2
   iff
      b1 * b3 in Seg (b1 * b2);

:: MOEBIUS1:th 3
theorem
for b1, b2 being Element of NAT
      st b1,b2 are_relative_prime & b1 <= 0
   holds 0 < b2;

:: MOEBIUS1:th 4
theorem
for b1 being non prime Element of NAT
      st b1 <> 1
   holds ex b2 being natural prime set st
      b2 divides b1 & b2 <> b1;

:: MOEBIUS1:th 5
theorem
for b1 being natural set
      st b1 <> 1
   holds ex b2 being natural prime set st
      b2 divides b1;

:: MOEBIUS1:th 6
theorem
for b1 being natural prime set
for b2 being non empty natural set holds
      b1 divides b2
   iff
      0 < b1 |-count b2;

:: MOEBIUS1:th 7
theorem
support prime_factorization 1 = {};

:: MOEBIUS1:th 8
theorem
for b1 being natural prime set holds
   support prime_factorization b1 = {b1};

:: MOEBIUS1:th 9
theorem
for b1, b2 being natural set
for b3 being natural prime set
      st b1 <> 0 & b2 <= b3 |-count b1
   holds b3 |^ b2 divides b1;

:: MOEBIUS1:condreg 1
registration
  cluster natural odd -> non empty (set);
end;

:: MOEBIUS1:th 10
theorem
for b1 being Element of NAT
for b2 being natural prime set
      st b2 |^ 2 divides b1
   holds b2 divides b1;

:: MOEBIUS1:th 11
theorem
for b1 being prime Element of NAT
for b2, b3 being non empty Element of NAT
      st b2,b3 are_relative_prime & b1 |^ 2 divides b2 * b3 & not b1 |^ 2 divides b2
   holds b1 |^ 2 divides b3;

:: MOEBIUS1:th 12
theorem
for b1 being natural set
for b2 being real-valued finite-support ManySortedSet of NAT
      st support b2 = {b1}
   holds Sum b2 = b2 . b1;

:: MOEBIUS1:funcreg 1
registration
  cluster canFS {} -> empty;
end;

:: MOEBIUS1:th 13
theorem
for b1 being natural set
for b2 being natural prime set
      st b2 divides b1
   holds {b3 where b3 is Element of NAT: 0 < b3 & b3 divides b1 & b2 divides b3} = {b2 * b3 where b3 is Element of NAT: 0 < b3 & b3 divides b1 div b2};

:: MOEBIUS1:th 14
theorem
for b1 being non empty natural set holds
   ex b2 being Element of NAT st
      support prime_factorization b1 c= Seg b2;

:: MOEBIUS1:th 15
theorem
for b1 being non empty Element of NAT
for b2 being natural prime set
      st not b2 in support prime_factorization b1
   holds b2 |-count b1 = 0;

:: MOEBIUS1:th 16
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
      st support prime_factorization b2 c= Seg (b1 + 1) &
         not support prime_factorization b2 c= Seg b1
   holds b1 + 1 is natural prime set;

:: MOEBIUS1:th 17
theorem
for b1, b2 being non empty natural set
      st for b3 being natural prime set holds
           b3 |-count b1 <= b3 |-count b2
   holds support prime_factorization b1 c= support prime_factorization b2;

:: MOEBIUS1:th 18
theorem
for b1 being Element of NAT
for b2 being non empty Element of NAT
      st support prime_factorization b2 c= Seg (b1 + 1)
   holds ex b3 being non empty Element of NAT st
      ex b4 being Element of NAT st
         support prime_factorization b3 c= Seg b1 &
          b2 = b3 * ((b1 + 1) |^ b4) &
          (for b5 being natural prime set holds
             (b5 in support prime_factorization b3 implies b5 |-count b3 = b5 |-count b2) &
              (b5 in support prime_factorization b3 or b5 |-count b3 <= b5 |-count b2));

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

:: MOEBIUS1:attrnot 1 => MOEBIUS1:attr 1
definition
  let a1 be natural set;
  attr a1 is square-containing means
    ex b1 being natural prime set st
       b1 |^ 2 divides a1;
end;

:: MOEBIUS1:dfs 1
definiens
  let a1 be natural set;
To prove
     a1 is square-containing
it is sufficient to prove
  thus ex b1 being natural prime set st
       b1 |^ 2 divides a1;

:: MOEBIUS1:def 1
theorem
for b1 being natural set holds
      b1 is square-containing
   iff
      ex b2 being natural prime set st
         b2 |^ 2 divides b1;

:: MOEBIUS1:th 20
theorem
for b1 being natural set
      st ex b2 being non empty natural set st
           b2 <> 1 & b2 |^ 2 divides b1
   holds b1 is square-containing;

:: MOEBIUS1:attrnot 2 => MOEBIUS1:attr 1
notation
  let a1 be natural set;
  antonym square-free for square-containing;
end;

:: MOEBIUS1:th 21
theorem
0 is square-containing;

:: MOEBIUS1:th 22
theorem
1 is square-free;

:: MOEBIUS1:th 23
theorem
for b1 being natural prime set holds
   b1 is square-free;

:: MOEBIUS1:condreg 2
registration
  cluster prime -> square-free (Element of NAT);
end;

:: MOEBIUS1:funcnot 1 => MOEBIUS1:func 1
definition
  func SCNAT -> Element of bool NAT means
    for b1 being natural set holds
          b1 in it
       iff
          b1 is square-free;
end;

:: MOEBIUS1:def 2
theorem
for b1 being Element of bool NAT holds
      b1 = SCNAT
   iff
      for b2 being natural set holds
            b2 in b1
         iff
            b2 is square-free;

:: MOEBIUS1:exreg 2
registration
  cluster epsilon-transitive epsilon-connected ordinal natural complex real integer ext-real non negative square-free set;
end;

:: MOEBIUS1:exreg 3
registration
  cluster epsilon-transitive epsilon-connected ordinal natural complex real integer ext-real non negative square-containing set;
end;

:: MOEBIUS1:condreg 3
registration
  cluster natural non trivial square -> square-containing (set);
end;

:: MOEBIUS1:th 24
theorem
for b1 being natural set
   st b1 is square-free
for b2 being natural prime set holds
   b2 |-count b1 <= 1;

:: MOEBIUS1:th 25
theorem
for b1, b2 being natural set
      st b1 * b2 is square-free
   holds b1 is square-free;

:: MOEBIUS1:th 26
theorem
for b1, b2 being natural set
      st b1 is square-free & b2 divides b1
   holds b2 is square-free;

:: MOEBIUS1:th 27
theorem
for b1 being natural prime set
for b2, b3 being natural set
      st b2 is square-free & b1 divides b2 & b3 divides b2 div b1
   holds b3 divides b2 & not b1 divides b3;

:: MOEBIUS1:th 28
theorem
for b1 being natural prime set
for b2, b3 being natural set
      st b1 divides b2 & b3 divides b2 & not b1 divides b3
   holds b3 divides b2 div b1;

:: MOEBIUS1:th 29
theorem
for b1 being natural prime set
for b2 being natural set
      st b2 is square-free & b1 divides b2
   holds {b3 where b3 is Element of NAT: 0 < b3 & b3 divides b2 & not b1 divides b3} = {b3 where b3 is Element of NAT: 0 < b3 & b3 divides b2 div b1};

:: MOEBIUS1:funcnot 2 => MOEBIUS1:func 2
definition
  let a1 be natural set;
  func Moebius A1 -> real set means
    it = 0
    if a1 is square-containing
    otherwise ex b1 being non empty natural set st
       b1 = a1 &
        it = (- 1) |^ card support prime_factorization b1;
end;

:: MOEBIUS1:def 3
theorem
for b1 being natural set
for b2 being real set holds
   (b1 is square-containing implies    (b2 = Moebius b1
    iff
       b2 = 0)) &
    (b1 is square-containing or    (b2 = Moebius b1
    iff
       ex b3 being non empty natural set st
          b3 = b1 &
           b2 = (- 1) |^ card support prime_factorization b3));

:: MOEBIUS1:th 30
theorem
Moebius 1 = 1;

:: MOEBIUS1:th 31
theorem
Moebius 2 = - 1;

:: MOEBIUS1:th 32
theorem
Moebius 3 = - 1;

:: MOEBIUS1:th 33
theorem
for b1 being natural set
      st b1 is square-free
   holds Moebius b1 <> 0;

:: MOEBIUS1:funcreg 2
registration
  let a1 be natural square-free set;
  cluster Moebius a1 -> non empty real;
end;

:: MOEBIUS1:th 34
theorem
for b1 being natural prime set holds
   Moebius b1 = - 1;

:: MOEBIUS1:th 35
theorem
for b1, b2 being non empty Element of NAT
      st b1,b2 are_relative_prime
   holds Moebius (b1 * b2) = (Moebius b1) * Moebius b2;

:: MOEBIUS1:th 36
theorem
for b1 being natural prime set
for b2 being Element of NAT
      st 1 <= b2 & b2 * b1 is square-free
   holds Moebius (b2 * b1) = - Moebius b2;

:: MOEBIUS1:th 37
theorem
for b1, b2 being non empty Element of NAT
      st not b1,b2 are_relative_prime
   holds Moebius (b1 * b2) = 0;

:: MOEBIUS1:th 38
theorem
for b1 being natural set holds
      b1 in SCNAT
   iff
      Moebius b1 <> 0;

:: MOEBIUS1:funcnot 3 => MOEBIUS1:func 3
definition
  let a1 be natural set;
  func NatDivisors A1 -> Element of bool NAT equals
    {b1 where b1 is Element of NAT: b1 <> 0 & b1 divides a1};
end;

:: MOEBIUS1:def 4
theorem
for b1 being natural set holds
   NatDivisors b1 = {b2 where b2 is Element of NAT: b2 <> 0 & b2 divides b1};

:: MOEBIUS1:th 39
theorem
for b1, b2 being natural set holds
   b2 in NatDivisors b1
iff
   0 < b2 & b2 divides b1;

:: MOEBIUS1:th 40
theorem
for b1 being non empty natural set holds
   NatDivisors b1 c= Seg b1;

:: MOEBIUS1:funcreg 3
registration
  let a1 be non empty natural set;
  cluster NatDivisors a1 -> with_non-empty_elements finite;
end;

:: MOEBIUS1:th 41
theorem
NatDivisors 1 = {1};

:: MOEBIUS1:funcnot 4 => MOEBIUS1:func 4
definition
  let a1 be set;
  func SMoebius A1 -> ManySortedSet of NAT means
    support it = a1 /\ SCNAT &
     (for b1 being Element of NAT
           st b1 in support it
        holds it . b1 = Moebius b1);
end;

:: MOEBIUS1:def 5
theorem
for b1 being set
for b2 being ManySortedSet of NAT holds
      b2 = SMoebius b1
   iff
      support b2 = b1 /\ SCNAT &
       (for b3 being Element of NAT
             st b3 in support b2
          holds b2 . b3 = Moebius b3);

:: MOEBIUS1:funcreg 4
registration
  let a1 be set;
  cluster SMoebius a1 -> real-valued;
end;

:: MOEBIUS1:funcreg 5
registration
  let a1 be finite set;
  cluster SMoebius a1 -> finite-support;
end;

:: MOEBIUS1:th 42
theorem
Sum SMoebius NatDivisors 1 = 1;

:: MOEBIUS1:th 43
theorem
for b1, b2 being finite Element of bool NAT
      st b1 misses b2
   holds (support SMoebius b1) \/ support SMoebius b2 = support ((SMoebius b1) + SMoebius b2);

:: MOEBIUS1:th 44
theorem
for b1, b2 being finite Element of bool NAT
      st b1 misses b2
   holds SMoebius (b1 \/ b2) = (SMoebius b1) + SMoebius b2;

:: MOEBIUS1:funcnot 5 => MOEBIUS1:func 5
definition
  let a1 be non empty natural set;
  func PFactors 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);
end;

:: MOEBIUS1:def 6
theorem
for b1 being non empty natural set
for b2 being ManySortedSet of SetPrimes holds
      b2 = PFactors b1
   iff
      support b2 = support prime_exponents b1 &
       (for b3 being natural set
             st b3 in support prime_exponents b1
          holds b2 . b3 = b3);

:: MOEBIUS1:funcreg 6
registration
  let a1 be non empty natural set;
  cluster PFactors a1 -> natural-valued finite-support;
end;

:: MOEBIUS1:th 45
theorem
PFactors 1 = EmptyBag SetPrimes;

:: MOEBIUS1:th 46
theorem
for b1 being natural prime set holds
   <*b1*> * PFactors b1 = <*b1*>;

:: MOEBIUS1:th 47
theorem
for b1 being natural prime set
for b2 being non empty natural set holds
   <*b1*> * PFactors (b1 |^ b2) = <*b1*>;

:: MOEBIUS1:th 48
theorem
for b1 being natural prime set
for b2 being non empty natural set
      st b1 |-count b2 = 0
   holds (PFactors b2) . b1 = 0;

:: MOEBIUS1:th 49
theorem
for b1 being non empty natural set
for b2 being natural prime set
      st b2 |-count b1 <> 0
   holds (PFactors b1) . b2 = b2;

:: MOEBIUS1:th 50
theorem
for b1, b2 being non empty Element of NAT
      st b1,b2 are_relative_prime
   holds PFactors (b1 * b2) = (PFactors b1) + PFactors b2;

:: MOEBIUS1:th 51
theorem
for b1 being non empty Element of NAT
for b2 being finite Element of bool NAT
      st b2 = {b3 where b3 is Element of NAT: 0 < b3 & b3 divides b1 & b3 is square-containing}
   holds SMoebius b2 = EmptyBag NAT;

:: MOEBIUS1:funcnot 6 => MOEBIUS1:func 6
definition
  let a1 be non empty natural set;
  func Radical A1 -> Element of NAT equals
    Product PFactors a1;
end;

:: MOEBIUS1:def 7
theorem
for b1 being non empty natural set holds
   Radical b1 = Product PFactors b1;

:: MOEBIUS1:th 52
theorem
for b1 being non empty natural set holds
   0 < Radical b1;

:: MOEBIUS1:funcreg 7
registration
  let a1 be non empty natural set;
  cluster Radical a1 -> non empty;
end;

:: MOEBIUS1:th 53
theorem
for b1 being natural prime set holds
   b1 = Radical b1;

:: MOEBIUS1:th 54
theorem
for b1 being natural prime set
for b2 being non empty Element of NAT holds
   Radical (b1 |^ b2) = b1;

:: MOEBIUS1:th 55
theorem
for b1 being non empty natural set holds
   Radical b1 divides b1;

:: MOEBIUS1:th 56
theorem
for b1 being natural prime set
for b2 being non empty natural set holds
      b1 divides b2
   iff
      b1 divides Radical b2;

:: MOEBIUS1:th 57
theorem
for b1 being non empty natural set
      st b1 is square-free
   holds Radical b1 = b1;

:: MOEBIUS1:th 58
theorem
for b1 being non empty natural set holds
   Radical b1 <= b1;

:: MOEBIUS1:th 59
theorem
for b1 being natural prime set
for b2 being non empty natural set holds
   b1 |-count Radical b2 <= b1 |-count b2;

:: MOEBIUS1:th 60
theorem
for b1 being non empty natural set holds
      Radical b1 = 1
   iff
      b1 = 1;

:: MOEBIUS1:th 61
theorem
for b1 being natural prime set
for b2 being non empty natural set holds
   b1 |-count Radical b2 <= 1;

:: MOEBIUS1:funcreg 8
registration
  let a1 be non empty natural set;
  cluster Radical a1 -> square-free;
end;

:: MOEBIUS1:th 62
theorem
for b1 being non empty natural set holds
   Radical Radical b1 = Radical b1;

:: MOEBIUS1:th 63
theorem
for b1 being non empty Element of NAT
for b2 being natural prime set holds
   {b3 where b3 is Element of NAT: 0 < b3 & b3 divides Radical b1 & b2 divides b3} c= Seg b1;

:: MOEBIUS1:th 64
theorem
for b1 being non empty Element of NAT
for b2 being natural prime set holds
   {b3 where b3 is Element of NAT: 0 < b3 & b3 divides Radical b1 & not b2 divides b3} c= Seg b1;

:: MOEBIUS1:th 65
theorem
for b1, b2 being non empty natural set holds
   b1 divides b2 & b1 is square-free
iff
   b1 divides Radical b2;

:: MOEBIUS1:th 66
theorem
for b1 being non empty natural set holds
   {b2 where b2 is Element of NAT: 0 < b2 & b2 divides b1 & b2 is square-free} = {b2 where b2 is Element of NAT: 0 < b2 & b2 divides Radical b1};