Article JORDAN_A, MML version 4.99.1005

:: JORDAN_A:th 1
theorem
for b1, b2 being non empty finite Element of bool REAL holds
lower_bound (b1 \/ b2) = min(lower_bound b1,lower_bound b2);

:: JORDAN_A:th 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Function-like quasi_total continuous Relation of the carrier of b1,REAL
for b3 being compact Element of bool the carrier of b1 holds
   b2 .: b3 is compact;

:: JORDAN_A:th 3
theorem
for b1 being compact Element of bool REAL
for b2 being non empty Element of bool REAL
      st b2 c= b1
   holds inf b2 in b1;

:: JORDAN_A:th 4
theorem
for b1 being Element of NAT
for b2, b3 being non empty compact Element of bool the carrier of TOP-REAL b1
for b4 being Function-like quasi_total continuous Relation of the carrier of [:TOP-REAL b1,TOP-REAL b1:],REAL
for b5 being Function-like quasi_total Relation of the carrier of TOP-REAL b1,REAL
      st for b6 being Element of the carrier of TOP-REAL b1 holds
           ex b7 being Element of bool REAL st
              b7 = {b4 .(b6,b8) where b8 is Element of the carrier of TOP-REAL b1: b8 in b3} &
               b5 . b6 = inf b7
   holds inf (b4 .: [:b2,b3:]) = inf (b5 .: b2);

:: JORDAN_A:th 5
theorem
for b1 being Element of NAT
for b2, b3 being non empty compact Element of bool the carrier of TOP-REAL b1
for b4 being Function-like quasi_total continuous Relation of the carrier of [:TOP-REAL b1,TOP-REAL b1:],REAL
for b5 being Function-like quasi_total Relation of the carrier of TOP-REAL b1,REAL
      st for b6 being Element of the carrier of TOP-REAL b1 holds
           ex b7 being Element of bool REAL st
              b7 = {b4 .(b8,b6) where b8 is Element of the carrier of TOP-REAL b1: b8 in b2} &
               b5 . b6 = inf b7
   holds inf (b4 .: [:b2,b3:]) = inf (b5 .: b3);

:: JORDAN_A:th 6
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in Lower_Arc b1 & b2 <> W-min b1
   holds LE E-max b1,b2,b1;

:: JORDAN_A:th 7
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in Upper_Arc b1
   holds LE b2,E-max b1,b1;

:: JORDAN_A:funcnot 1 => JORDAN_A:func 1
definition
  let a1 be Element of NAT;
  func Eucl_dist A1 -> Function-like quasi_total Relation of the carrier of [:TOP-REAL a1,TOP-REAL a1:],REAL means
    for b1, b2 being Element of the carrier of TOP-REAL a1 holds
    it .(b1,b2) = |.b1 - b2.|;
end;

:: JORDAN_A:def 1
theorem
for b1 being Element of NAT
for b2 being Function-like quasi_total Relation of the carrier of [:TOP-REAL b1,TOP-REAL b1:],REAL holds
      b2 = Eucl_dist b1
   iff
      for b3, b4 being Element of the carrier of TOP-REAL b1 holds
      b2 .(b3,b4) = |.b3 - b4.|;

:: JORDAN_A:attrnot 1 => PSCOMP_1:attr 9
definition
  let a1 be TopStruct;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
  attr a2 is continuous means
    for b1 being Element of the carrier of a1
    for b2 being Neighbourhood of a2 . b1 holds
       ex b3 being a_neighborhood of b1 st
          a2 .: b3 c= b2;
end;

:: JORDAN_A:dfs 2
definiens
  let a1 be non empty TopSpace-like TopStruct;
  let a2 be Function-like quasi_total Relation of the carrier of a1,REAL;
To prove
     a2 is continuous
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Neighbourhood of a2 . b1 holds
       ex b3 being a_neighborhood of b1 st
          a2 .: b3 c= b2;

:: JORDAN_A:def 2
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Function-like quasi_total Relation of the carrier of b1,REAL holds
      b2 is continuous(b1)
   iff
      for b3 being Element of the carrier of b1
      for b4 being Neighbourhood of b2 . b3 holds
         ex b5 being a_neighborhood of b3 st
            b2 .: b5 c= b4;

:: JORDAN_A:funcreg 1
registration
  let a1 be Element of NAT;
  cluster Eucl_dist a1 -> Function-like quasi_total continuous;
end;

:: JORDAN_A:th 8
theorem
for b1 being Element of NAT
for b2, b3 being non empty compact Element of bool the carrier of TOP-REAL b1
      st b2 misses b3
   holds 0 < dist_min(b2,b3);

:: JORDAN_A:th 9
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st LE b2,b3,b1 & LE b3,E-max b1,b1 & b2 <> b3
   holds Segment(b2,b3,b1) = Segment(Upper_Arc b1,W-min b1,E-max b1,b2,b3);

:: JORDAN_A:th 10
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st LE E-max b1,b2,b1
   holds Segment(E-max b1,b2,b1) = Segment(Lower_Arc b1,E-max b1,W-min b1,E-max b1,b2);

:: JORDAN_A:th 11
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st LE E-max b1,b2,b1
   holds Segment(b2,W-min b1,b1) = Segment(Lower_Arc b1,E-max b1,W-min b1,b2,W-min b1);

:: JORDAN_A:th 12
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st LE b2,b3,b1 & LE E-max b1,b2,b1
   holds Segment(b2,b3,b1) = Segment(Lower_Arc b1,E-max b1,W-min b1,b2,b3);

:: JORDAN_A:th 13
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st LE b2,E-max b1,b1 & LE E-max b1,b3,b1
   holds Segment(b2,b3,b1) = (R_Segment(Upper_Arc b1,W-min b1,E-max b1,b2)) \/ L_Segment(Lower_Arc b1,E-max b1,W-min b1,b3);

:: JORDAN_A:th 14
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st LE b2,E-max b1,b1
   holds Segment(b2,W-min b1,b1) = (R_Segment(Upper_Arc b1,W-min b1,E-max b1,b2)) \/ L_Segment(Lower_Arc b1,E-max b1,W-min b1,W-min b1);

:: JORDAN_A:th 15
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2 holds
   R_Segment(Upper_Arc b1,W-min b1,E-max b1,b2) = Segment(Upper_Arc b1,W-min b1,E-max b1,b2,E-max b1);

:: JORDAN_A:th 16
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2 holds
   L_Segment(Lower_Arc b1,E-max b1,W-min b1,b2) = Segment(Lower_Arc b1,E-max b1,W-min b1,E-max b1,b2);

:: JORDAN_A:th 17
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in b1 & b2 <> W-min b1
   holds Segment(b2,W-min b1,b1) is_an_arc_of b2,W-min b1;

:: JORDAN_A:th 18
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st b2 <> b3 & LE b2,b3,b1
   holds Segment(b2,b3,b1) is_an_arc_of b2,b3;

:: JORDAN_A:th 19
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2 holds
   b1 = Segment(W-min b1,W-min b1,b1);

:: JORDAN_A:th 20
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b2 in b1
   holds Segment(b2,W-min b1,b1) is compact(TOP-REAL 2);

:: JORDAN_A:th 21
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2, b3 being Element of the carrier of TOP-REAL 2
      st LE b2,b3,b1
   holds Segment(b2,b3,b1) is compact(TOP-REAL 2);

:: JORDAN_A:modenot 1 => JORDAN_A:mode 1
definition
  let a1 be being_simple_closed_curve Element of bool the carrier of TOP-REAL 2;
  mode Segmentation of A1 -> FinSequence of the carrier of TOP-REAL 2 means
    it /. 1 = W-min a1 &
     it is one-to-one &
     8 <= len it &
     rng it c= a1 &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 < len it
        holds LE it /. b1,it /. (b1 + 1),a1) &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 + 1 < len it
        holds (Segment(it /. b1,it /. (b1 + 1),a1)) /\ Segment(it /. (b1 + 1),it /. (b1 + 2),a1) = {it /. (b1 + 1)}) &
     (Segment(it /. len it,it /. 1,a1)) /\ Segment(it /. 1,it /. 2,a1) = {it /. 1} &
     (Segment(it /. ((len it) -' 1),it /. len it,a1)) /\ Segment(it /. len it,it /. 1,a1) = {it /. len it} &
     Segment(it /. ((len it) -' 1),it /. len it,a1) misses Segment(it /. 1,it /. 2,a1) &
     (for b1, b2 being Element of NAT
           st 1 <= b1 & b1 < b2 & b2 < len it & not b1,b2 are_adjacent1
        holds Segment(it /. b1,it /. (b1 + 1),a1) misses Segment(it /. b2,it /. (b2 + 1),a1)) &
     (for b1 being Element of NAT
           st 1 < b1 & b1 + 1 < len it
        holds Segment(it /. len it,it /. 1,a1) misses Segment(it /. b1,it /. (b1 + 1),a1));
end;

:: JORDAN_A:dfs 3
definiens
  let a1 be being_simple_closed_curve Element of bool the carrier of TOP-REAL 2;
  let a2 be FinSequence of the carrier of TOP-REAL 2;
To prove
     a2 is Segmentation of a1
it is sufficient to prove
  thus a2 /. 1 = W-min a1 &
     a2 is one-to-one &
     8 <= len a2 &
     rng a2 c= a1 &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 < len a2
        holds LE a2 /. b1,a2 /. (b1 + 1),a1) &
     (for b1 being Element of NAT
           st 1 <= b1 & b1 + 1 < len a2
        holds (Segment(a2 /. b1,a2 /. (b1 + 1),a1)) /\ Segment(a2 /. (b1 + 1),a2 /. (b1 + 2),a1) = {a2 /. (b1 + 1)}) &
     (Segment(a2 /. len a2,a2 /. 1,a1)) /\ Segment(a2 /. 1,a2 /. 2,a1) = {a2 /. 1} &
     (Segment(a2 /. ((len a2) -' 1),a2 /. len a2,a1)) /\ Segment(a2 /. len a2,a2 /. 1,a1) = {a2 /. len a2} &
     Segment(a2 /. ((len a2) -' 1),a2 /. len a2,a1) misses Segment(a2 /. 1,a2 /. 2,a1) &
     (for b1, b2 being Element of NAT
           st 1 <= b1 & b1 < b2 & b2 < len a2 & not b1,b2 are_adjacent1
        holds Segment(a2 /. b1,a2 /. (b1 + 1),a1) misses Segment(a2 /. b2,a2 /. (b2 + 1),a1)) &
     (for b1 being Element of NAT
           st 1 < b1 & b1 + 1 < len a2
        holds Segment(a2 /. len a2,a2 /. 1,a1) misses Segment(a2 /. b1,a2 /. (b1 + 1),a1));

:: JORDAN_A:def 3
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being FinSequence of the carrier of TOP-REAL 2 holds
      b2 is Segmentation of b1
   iff
      b2 /. 1 = W-min b1 &
       b2 is one-to-one &
       8 <= len b2 &
       rng b2 c= b1 &
       (for b3 being Element of NAT
             st 1 <= b3 & b3 < len b2
          holds LE b2 /. b3,b2 /. (b3 + 1),b1) &
       (for b3 being Element of NAT
             st 1 <= b3 & b3 + 1 < len b2
          holds (Segment(b2 /. b3,b2 /. (b3 + 1),b1)) /\ Segment(b2 /. (b3 + 1),b2 /. (b3 + 2),b1) = {b2 /. (b3 + 1)}) &
       (Segment(b2 /. len b2,b2 /. 1,b1)) /\ Segment(b2 /. 1,b2 /. 2,b1) = {b2 /. 1} &
       (Segment(b2 /. ((len b2) -' 1),b2 /. len b2,b1)) /\ Segment(b2 /. len b2,b2 /. 1,b1) = {b2 /. len b2} &
       Segment(b2 /. ((len b2) -' 1),b2 /. len b2,b1) misses Segment(b2 /. 1,b2 /. 2,b1) &
       (for b3, b4 being Element of NAT
             st 1 <= b3 & b3 < b4 & b4 < len b2 & not b3,b4 are_adjacent1
          holds Segment(b2 /. b3,b2 /. (b3 + 1),b1) misses Segment(b2 /. b4,b2 /. (b4 + 1),b1)) &
       (for b3 being Element of NAT
             st 1 < b3 & b3 + 1 < len b2
          holds Segment(b2 /. len b2,b2 /. 1,b1) misses Segment(b2 /. b3,b2 /. (b3 + 1),b1));

:: JORDAN_A:condreg 1
registration
  let a1 be being_simple_closed_curve Element of bool the carrier of TOP-REAL 2;
  cluster -> non trivial (Segmentation of a1);
end;

:: JORDAN_A:th 22
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3 being Element of NAT
      st 1 <= b3 & b3 <= len b2
   holds b2 /. b3 in b1;

:: JORDAN_A:funcnot 2 => JORDAN_A:func 2
definition
  let a1 be being_simple_closed_curve Element of bool the carrier of TOP-REAL 2;
  let a2 be natural set;
  let a3 be Segmentation of a1;
  func Segm(A3,A2) -> Element of bool the carrier of TOP-REAL 2 equals
    Segment(a3 /. a2,a3 /. (a2 + 1),a1)
    if 1 <= a2 & a2 < len a3
    otherwise Segment(a3 /. len a3,a3 /. 1,a1);
end;

:: JORDAN_A:def 4
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being natural set
for b3 being Segmentation of b1 holds
   (1 <= b2 & b2 < len b3 implies Segm(b3,b2) = Segment(b3 /. b2,b3 /. (b2 + 1),b1)) &
    (1 <= b2 & b2 < len b3 or Segm(b3,b2) = Segment(b3 /. len b3,b3 /. 1,b1));

:: JORDAN_A:th 23
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of NAT
for b3 being Segmentation of b1
      st b2 in dom b3
   holds Segm(b3,b2) c= b1;

:: JORDAN_A:funcreg 2
registration
  let a1 be being_simple_closed_curve Element of bool the carrier of TOP-REAL 2;
  let a2 be Segmentation of a1;
  let a3 be Element of NAT;
  cluster Segm(a2,a3) -> non empty compact;
end;

:: JORDAN_A:th 24
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3 being Element of the carrier of TOP-REAL 2
      st b3 in b1
   holds ex b4 being natural set st
      b4 in dom b2 & b3 in Segm(b2,b4);

:: JORDAN_A:th 25
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3, b4 being Element of NAT
      st 1 <= b3 & b3 < b4 & b4 < len b2 & not b3,b4 are_adjacent1
   holds Segm(b2,b3) misses Segm(b2,b4);

:: JORDAN_A:th 26
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3 being Element of NAT
      st 1 < b3 & b3 < (len b2) -' 1
   holds Segm(b2,len b2) misses Segm(b2,b3);

:: JORDAN_A:th 27
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3, b4 being Element of NAT
      st 1 <= b3 & b3 < b4 & b4 < len b2 & b3,b4 are_adjacent1
   holds (Segm(b2,b3)) /\ Segm(b2,b4) = {b2 /. (b3 + 1)};

:: JORDAN_A:th 28
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3, b4 being Element of NAT
      st 1 <= b3 & b3 < b4 & b4 < len b2 & b3,b4 are_adjacent1
   holds Segm(b2,b3) meets Segm(b2,b4);

:: JORDAN_A:th 29
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1 holds
   (Segm(b2,len b2)) /\ Segm(b2,1) = {b2 /. 1};

:: JORDAN_A:th 30
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1 holds
   Segm(b2,len b2) meets Segm(b2,1);

:: JORDAN_A:th 31
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1 holds
   (Segm(b2,len b2)) /\ Segm(b2,(len b2) -' 1) = {b2 /. len b2};

:: JORDAN_A:th 32
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1 holds
   Segm(b2,len b2) meets Segm(b2,(len b2) -' 1);

:: JORDAN_A:funcnot 3 => JORDAN_A:func 3
definition
  let a1 be Element of NAT;
  let a2 be Element of bool the carrier of TOP-REAL a1;
  func diameter A2 -> Element of REAL means
    ex b1 being Element of bool the carrier of Euclid a1 st
       b1 = a2 & it = diameter b1;
end;

:: JORDAN_A:def 5
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3 being Element of REAL holds
      b3 = diameter b2
   iff
      ex b4 being Element of bool the carrier of Euclid b1 st
         b4 = b2 & b3 = diameter b4;

:: JORDAN_A:funcnot 4 => JORDAN_A:func 4
definition
  let a1 be being_simple_closed_curve Element of bool the carrier of TOP-REAL 2;
  let a2 be Segmentation of a1;
  func diameter A2 -> Element of REAL means
    ex b1 being non empty finite Element of bool REAL st
       b1 = {diameter Segm(a2,b2) where b2 is Element of NAT: b2 in dom a2} &
        it = max b1;
end;

:: JORDAN_A:def 6
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3 being Element of REAL holds
      b3 = diameter b2
   iff
      ex b4 being non empty finite Element of bool REAL st
         b4 = {diameter Segm(b2,b5) where b5 is Element of NAT: b5 in dom b2} &
          b3 = max b4;

:: JORDAN_A:th 33
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3 being Element of NAT holds
   diameter Segm(b2,b3) <= diameter b2;

:: JORDAN_A:th 34
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3 being Element of REAL
      st for b4 being Element of NAT holds
           diameter Segm(b2,b4) < b3
   holds diameter b2 < b3;

:: JORDAN_A:th 35
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Element of REAL
      st 0 < b2
   holds ex b3 being Segmentation of b1 st
      diameter b3 < b2;

:: JORDAN_A:funcnot 5 => JORDAN_A:func 5
definition
  let a1 be being_simple_closed_curve Element of bool the carrier of TOP-REAL 2;
  let a2 be Segmentation of a1;
  func S-Gap A2 -> Element of REAL means
    ex b1, b2 being non empty finite Element of bool REAL st
       b1 = {dist_min(Segm(a2,b3),Segm(a2,b4)) where b3 is Element of NAT, b4 is Element of NAT: 1 <= b3 & b3 < b4 & b4 < len a2 & not b3,b4 are_adjacent1} &
        b2 = {dist_min(Segm(a2,len a2),Segm(a2,b3)) where b3 is Element of NAT: 1 < b3 & b3 < (len a2) -' 1} &
        it = min(lower_bound b1,lower_bound b2);
end;

:: JORDAN_A:def 7
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1
for b3 being Element of REAL holds
      b3 = S-Gap b2
   iff
      ex b4, b5 being non empty finite Element of bool REAL st
         b4 = {dist_min(Segm(b2,b6),Segm(b2,b7)) where b6 is Element of NAT, b7 is Element of NAT: 1 <= b6 & b6 < b7 & b7 < len b2 & not b6,b7 are_adjacent1} &
          b5 = {dist_min(Segm(b2,len b2),Segm(b2,b6)) where b6 is Element of NAT: 1 < b6 & b6 < (len b2) -' 1} &
          b3 = min(lower_bound b4,lower_bound b5);

:: JORDAN_A:th 36
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1 holds
   ex b3 being non empty finite Element of bool REAL st
      b3 = {dist_min(Segm(b2,b4),Segm(b2,b5)) where b4 is Element of NAT, b5 is Element of NAT: 1 <= b4 & b4 < b5 & b5 <= len b2 & Segm(b2,b4) misses Segm(b2,b5)} &
       S-Gap b2 = lower_bound b3;

:: JORDAN_A:th 37
theorem
for b1 being being_simple_closed_curve Element of bool the carrier of TOP-REAL 2
for b2 being Segmentation of b1 holds
   0 < S-Gap b2;