Article PYTHTRIP, MML version 4.99.1005

:: PYTHTRIP:prednot 1 => INT_2:pred 1
definition
  let a1, a2 be integer set;
  pred A1,A2 are_relative_prime means
    for b1 being natural set
          st b1 divides a1 & b1 divides a2
       holds b1 = 1;
  symmetry;
::  for a1, a2 being integer set
::        st a1,a2 are_relative_prime
::     holds a2,a1 are_relative_prime;
end;

:: PYTHTRIP:dfs 1
definiens
  let a1, a2 be natural set;
To prove
     a1,a2 are_relative_prime
it is sufficient to prove
  thus for b1 being natural set
          st b1 divides a1 & b1 divides a2
       holds b1 = 1;

:: PYTHTRIP:def 1
theorem
for b1, b2 being natural set holds
   b1,b2 are_relative_prime
iff
   for b3 being natural set
         st b3 divides b1 & b3 divides b2
      holds b3 = 1;

:: PYTHTRIP:prednot 2 => INT_2:pred 1
definition
  let a1, a2 be integer set;
  pred A1,A2 are_relative_prime means
    for b1 being natural prime set
          st b1 divides a1
       holds not b1 divides a2;
  symmetry;
::  for a1, a2 being integer set
::        st a1,a2 are_relative_prime
::     holds a2,a1 are_relative_prime;
end;

:: PYTHTRIP:dfs 2
definiens
  let a1, a2 be natural set;
To prove
     a1,a2 are_relative_prime
it is sufficient to prove
  thus for b1 being natural prime set
          st b1 divides a1
       holds not b1 divides a2;

:: PYTHTRIP:def 2
theorem
for b1, b2 being natural set holds
   b1,b2 are_relative_prime
iff
   for b3 being natural prime set
         st b3 divides b1
      holds not b3 divides b2;

:: PYTHTRIP:attrnot 1 => PYTHTRIP:attr 1
definition
  let a1 be set;
  attr a1 is square means
    ex b1 being natural set st
       a1 = b1 ^2;
end;

:: PYTHTRIP:dfs 3
definiens
  let a1 be set;
To prove
     a1 is square
it is sufficient to prove
  thus ex b1 being natural set st
       a1 = b1 ^2;

:: PYTHTRIP:def 3
theorem
for b1 being set holds
      b1 is square
   iff
      ex b2 being natural set st
         b1 = b2 ^2;

:: PYTHTRIP:condreg 1
registration
  cluster square -> natural (set);
end;

:: PYTHTRIP:funcreg 1
registration
  let a1 be natural set;
  cluster a1 ^2 -> square;
end;

:: PYTHTRIP:exreg 1
registration
  cluster epsilon-transitive epsilon-connected ordinal natural complex real integer ext-real non negative even square Element of NAT;
end;

:: PYTHTRIP:exreg 2
registration
  cluster epsilon-transitive epsilon-connected ordinal natural complex real integer ext-real non negative odd square Element of NAT;
end;

:: PYTHTRIP:exreg 3
registration
  cluster even square set;
end;

:: PYTHTRIP:exreg 4
registration
  cluster odd square set;
end;

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

:: PYTHTRIP:th 1
theorem
for b1, b2 being Element of NAT
      st b1 * b2 is square & b1,b2 are_relative_prime
   holds b1 is square & b2 is square;

:: PYTHTRIP:funcreg 3
registration
  let a1 be integer even set;
  cluster a1 ^2 -> even;
end;

:: PYTHTRIP:funcreg 4
registration
  let a1 be integer odd set;
  cluster a1 ^2 -> odd;
end;

:: PYTHTRIP:th 2
theorem
for b1 being integer set holds
      b1 is even
   iff
      b1 ^2 is even;

:: PYTHTRIP:th 3
theorem
for b1 being integer set
      st b1 is even
   holds b1 ^2 mod 4 = 0;

:: PYTHTRIP:th 4
theorem
for b1 being integer set
      st b1 is odd
   holds b1 ^2 mod 4 = 1;

:: PYTHTRIP:funcreg 5
registration
  let a1, a2 be odd square set;
  cluster a1 + a2 -> non square;
end;

:: PYTHTRIP:th 5
theorem
for b1, b2 being Element of NAT
      st b1 ^2 = b2 ^2
   holds b1 = b2;

:: PYTHTRIP:th 6
theorem
for b1, b2 being Element of NAT holds
   b1 divides b2
iff
   b1 ^2 divides b2 ^2;

:: PYTHTRIP:th 7
theorem
for b1, b2, b3 being Element of NAT holds
   (b1 divides b2 or b3 = 0)
iff
   b3 * b1 divides b3 * b2;

:: PYTHTRIP:th 8
theorem
for b1, b2, b3 being Element of NAT holds
(b1 * b2) hcf (b1 * b3) = b1 * (b2 hcf b3);

:: PYTHTRIP:th 9
theorem
for b1 being set
      st for b2 being Element of NAT holds
           ex b3 being Element of NAT st
              b2 <= b3 & b3 in b1
   holds b1 is infinite;

:: PYTHTRIP:th 10
theorem
for b1, b2 being Element of NAT
      st b1,b2 are_relative_prime & b1 is even
   holds b2 is odd;

:: PYTHTRIP:th 11
theorem
for b1, b2, b3 being Element of NAT
      st b1 ^2 + (b2 ^2) = b3 ^2 & b1,b2 are_relative_prime & b1 is odd
   holds ex b4, b5 being Element of NAT st
      b4 <= b5 & b1 = b5 ^2 - (b4 ^2) & b2 = (2 * b4) * b5 & b3 = b5 ^2 + (b4 ^2);

:: PYTHTRIP:th 12
theorem
for b1, b2, b3, b4, b5 being Element of NAT
      st b1 = b2 ^2 - (b3 ^2) & b4 = (2 * b3) * b2 & b5 = b2 ^2 + (b3 ^2)
   holds b1 ^2 + (b4 ^2) = b5 ^2;

:: PYTHTRIP:modenot 1 => PYTHTRIP:mode 1
definition
  mode Pythagorean_triple -> Element of bool NAT means
    ex b1, b2, b3 being Element of NAT st
       b1 ^2 + (b2 ^2) = b3 ^2 & it = {b1,b2,b3};
end;

:: PYTHTRIP:dfs 4
definiens
  let a1 be Element of bool NAT;
To prove
     a1 is Pythagorean_triple
it is sufficient to prove
  thus ex b1, b2, b3 being Element of NAT st
       b1 ^2 + (b2 ^2) = b3 ^2 & a1 = {b1,b2,b3};

:: PYTHTRIP:def 4
theorem
for b1 being Element of bool NAT holds
      b1 is Pythagorean_triple
   iff
      ex b2, b3, b4 being Element of NAT st
         b2 ^2 + (b3 ^2) = b4 ^2 & b1 = {b2,b3,b4};

:: PYTHTRIP:condreg 2
registration
  cluster -> finite (Pythagorean_triple);
end;

:: PYTHTRIP:modenot 2 => PYTHTRIP:mode 1
definition
  mode Pythagorean_triple -> Element of bool NAT means
    ex b1, b2, b3 being Element of NAT st
       b2 <= b3 &
        it = {b1 * (b3 ^2 - (b2 ^2)),b1 * ((2 * b2) * b3),b1 * (b3 ^2 + (b2 ^2))};
end;

:: PYTHTRIP:dfs 5
definiens
  let a1 be Element of bool NAT;
To prove
     a1 is Pythagorean_triple
it is sufficient to prove
  thus ex b1, b2, b3 being Element of NAT st
       b2 <= b3 &
        a1 = {b1 * (b3 ^2 - (b2 ^2)),b1 * ((2 * b2) * b3),b1 * (b3 ^2 + (b2 ^2))};

:: PYTHTRIP:def 5
theorem
for b1 being Element of bool NAT holds
      b1 is Pythagorean_triple
   iff
      ex b2, b3, b4 being Element of NAT st
         b3 <= b4 &
          b1 = {b2 * (b4 ^2 - (b3 ^2)),b2 * ((2 * b3) * b4),b2 * (b4 ^2 + (b3 ^2))};

:: PYTHTRIP:attrnot 2 => PYTHTRIP:attr 2
definition
  let a1 be Pythagorean_triple;
  attr a1 is degenerate means
    0 in a1;
end;

:: PYTHTRIP:dfs 6
definiens
  let a1 be Pythagorean_triple;
To prove
     a1 is degenerate
it is sufficient to prove
  thus 0 in a1;

:: PYTHTRIP:def 6
theorem
for b1 being Pythagorean_triple holds
      b1 is degenerate
   iff
      0 in b1;

:: PYTHTRIP:th 13
theorem
for b1 being Element of NAT
      st 2 < b1
   holds ex b2 being Pythagorean_triple st
      b2 is not degenerate & b1 in b2;

:: PYTHTRIP:attrnot 3 => PYTHTRIP:attr 3
definition
  let a1 be Pythagorean_triple;
  attr a1 is simplified means
    for b1 being Element of NAT
          st for b2 being Element of NAT
                  st b2 in a1
               holds b1 divides b2
       holds b1 = 1;
end;

:: PYTHTRIP:dfs 7
definiens
  let a1 be Pythagorean_triple;
To prove
     a1 is simplified
it is sufficient to prove
  thus for b1 being Element of NAT
          st for b2 being Element of NAT
                  st b2 in a1
               holds b1 divides b2
       holds b1 = 1;

:: PYTHTRIP:def 7
theorem
for b1 being Pythagorean_triple holds
      b1 is simplified
   iff
      for b2 being Element of NAT
            st for b3 being Element of NAT
                    st b3 in b1
                 holds b2 divides b3
         holds b2 = 1;

:: PYTHTRIP:attrnot 4 => PYTHTRIP:attr 3
definition
  let a1 be Pythagorean_triple;
  attr a1 is simplified means
    ex b1, b2 being Element of NAT st
       b1 in a1 & b2 in a1 & b1,b2 are_relative_prime;
end;

:: PYTHTRIP:dfs 8
definiens
  let a1 be Pythagorean_triple;
To prove
     a1 is simplified
it is sufficient to prove
  thus ex b1, b2 being Element of NAT st
       b1 in a1 & b2 in a1 & b1,b2 are_relative_prime;

:: PYTHTRIP:def 8
theorem
for b1 being Pythagorean_triple holds
      b1 is simplified
   iff
      ex b2, b3 being Element of NAT st
         b2 in b1 & b3 in b1 & b2,b3 are_relative_prime;

:: PYTHTRIP:th 14
theorem
for b1 being Element of NAT
      st 0 < b1
   holds ex b2 being Pythagorean_triple st
      b2 is not degenerate & b2 is simplified & 4 * b1 in b2;

:: PYTHTRIP:exreg 5
registration
  cluster finite non degenerate simplified Pythagorean_triple;
end;

:: PYTHTRIP:th 15
theorem
{3,4,5} is non degenerate simplified Pythagorean_triple;

:: PYTHTRIP:th 16
theorem
{b1 where b1 is Pythagorean_triple: b1 is not degenerate & b1 is simplified} is infinite;