Article JORDAN2C, MML version 4.99.1005

:: JORDAN2C:th 1
theorem
for b1 being Element of REAL
      st b1 <= 0
   holds abs b1 = - b1;

:: JORDAN2C:th 2
theorem
for b1, b2 being Element of NAT
      st b1 <= b2 & b2 <= b1 + 2 & b2 <> b1 & b2 <> b1 + 1
   holds b2 = b1 + 2;

:: JORDAN2C:th 3
theorem
for b1, b2 being Element of NAT
      st b1 <= b2 & b2 <= b1 + 3 & b2 <> b1 & b2 <> b1 + 1 & b2 <> b1 + 2
   holds b2 = b1 + 3;

:: JORDAN2C:th 4
theorem
for b1, b2 being Element of NAT
      st b1 <= b2 & b2 <= b1 + 4 & b2 <> b1 & b2 <> b1 + 1 & b2 <> b1 + 2 & b2 <> b1 + 3
   holds b2 = b1 + 4;

:: JORDAN2C:th 7
theorem
for b1, b2 being set
for b3 being Relation-like Function-like FinSequence-like set
      st proj2 b3 = {b1,b2} &
         len b3 = 2 &
         (b3 . 1 = b1 implies b3 . 2 <> b2)
   holds b3 . 1 = b2 & b3 . 2 = b1;

:: JORDAN2C:th 8
theorem
for b1, b2 being Element of REAL
for b3 being increasing FinSequence of REAL
      st rng b3 = {b1,b2} & len b3 = 2 & b1 <= b2
   holds b3 . 1 = b1 & b3 . 2 = b2;

:: JORDAN2C:th 9
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of the carrier of TOP-REAL b1 holds
(b2 + b3) - b4 = (b2 - b4) + b3;

:: JORDAN2C:th 10
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of TOP-REAL b1 holds
   abs |.b2.| = |.b2.|;

:: JORDAN2C:th 11
theorem
for b1 being Element of NAT
for b2, b3 being Element of the carrier of TOP-REAL b1 holds
abs (|.b2.| - |.b3.|) <= |.b2 - b3.|;

:: JORDAN2C:th 12
theorem
for b1 being Element of REAL holds
   |.|[b1]|.| = abs b1;

:: JORDAN2C:th 13
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of TOP-REAL b1 holds
   b2 - 0.REAL b1 = b2 & (0.REAL b1) - b2 = - b2;

:: JORDAN2C:th 15
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
for b4 being Element of bool the carrier of b1 | b3
      st b2 = b4 & b2 is connected(b1)
   holds b4 is connected(b1 | b3);

:: JORDAN2C:attrnot 1 => JORDAN2C:attr 1
definition
  let a1 be Element of NAT;
  let a2 be Element of bool the carrier of TOP-REAL a1;
  attr a2 is Bounded means
    a2 is bounded Element of bool the carrier of Euclid a1;
end;

:: JORDAN2C:dfs 1
definiens
  let a1 be Element of NAT;
  let a2 be Element of bool the carrier of TOP-REAL a1;
To prove
     a2 is Bounded
it is sufficient to prove
  thus a2 is bounded Element of bool the carrier of Euclid a1;

:: JORDAN2C:def 2
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
      b2 is Bounded(b1)
   iff
      b2 is bounded Element of bool the carrier of Euclid b1;

:: JORDAN2C:th 16
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is Bounded(b1) & b2 c= b3
   holds b2 is Bounded(b1);

:: JORDAN2C:prednot 1 => JORDAN2C:pred 1
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of bool the carrier of TOP-REAL a1;
  pred A3 is_inside_component_of A2 means
    a3 is_a_component_of a2 ` & a3 is Bounded(a1);
end;

:: JORDAN2C:dfs 2
definiens
  let a1 be Element of NAT;
  let a2, a3 be Element of bool the carrier of TOP-REAL a1;
To prove
     a3 is_inside_component_of a2
it is sufficient to prove
  thus a3 is_a_component_of a2 ` & a3 is Bounded(a1);

:: JORDAN2C:def 3
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1 holds
   b3 is_inside_component_of b2
iff
   b3 is_a_component_of b2 ` & b3 is Bounded(b1);

:: JORDAN2C:exreg 1
registration
  let a1 be non empty MetrStruct;
  cluster bounded Element of bool the carrier of a1;
end;

:: JORDAN2C:th 17
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1 holds
   b3 is_inside_component_of b2
iff
   ex b4 being Element of bool the carrier of (TOP-REAL b1) | (b2 `) st
      b4 = b3 & b4 is_a_component_of (TOP-REAL b1) | (b2 `) & b4 is bounded Element of bool the carrier of Euclid b1;

:: JORDAN2C:prednot 2 => JORDAN2C:pred 2
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of bool the carrier of TOP-REAL a1;
  pred A3 is_outside_component_of A2 means
    a3 is_a_component_of a2 ` & a3 is not Bounded(a1);
end;

:: JORDAN2C:dfs 3
definiens
  let a1 be Element of NAT;
  let a2, a3 be Element of bool the carrier of TOP-REAL a1;
To prove
     a3 is_outside_component_of a2
it is sufficient to prove
  thus a3 is_a_component_of a2 ` & a3 is not Bounded(a1);

:: JORDAN2C:def 4
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1 holds
   b3 is_outside_component_of b2
iff
   b3 is_a_component_of b2 ` & b3 is not Bounded(b1);

:: JORDAN2C:th 18
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1 holds
   b3 is_outside_component_of b2
iff
   ex b4 being Element of bool the carrier of (TOP-REAL b1) | (b2 `) st
      b4 = b3 & b4 is_a_component_of (TOP-REAL b1) | (b2 `) & b4 is not bounded Element of bool the carrier of Euclid b1;

:: JORDAN2C:th 19
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is_inside_component_of b2
   holds b3 c= b2 `;

:: JORDAN2C:th 20
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is_outside_component_of b2
   holds b3 c= b2 `;

:: JORDAN2C:funcnot 1 => JORDAN2C:func 1
definition
  let a1 be Element of NAT;
  let a2 be Element of bool the carrier of TOP-REAL a1;
  func BDD A2 -> Element of bool the carrier of TOP-REAL a1 equals
    union {b1 where b1 is Element of bool the carrier of TOP-REAL a1: b1 is_inside_component_of a2};
end;

:: JORDAN2C:def 5
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   BDD b2 = union {b3 where b3 is Element of bool the carrier of TOP-REAL b1: b3 is_inside_component_of b2};

:: JORDAN2C:funcnot 2 => JORDAN2C:func 2
definition
  let a1 be Element of NAT;
  let a2 be Element of bool the carrier of TOP-REAL a1;
  func UBD A2 -> Element of bool the carrier of TOP-REAL a1 equals
    union {b1 where b1 is Element of bool the carrier of TOP-REAL a1: b1 is_outside_component_of a2};
end;

:: JORDAN2C:def 6
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   UBD b2 = union {b3 where b3 is Element of bool the carrier of TOP-REAL b1: b3 is_outside_component_of b2};

:: JORDAN2C:th 21
theorem
for b1 being Element of NAT holds
   [#] TOP-REAL b1 is convex(b1);

:: JORDAN2C:th 22
theorem
for b1 being Element of NAT holds
   [#] TOP-REAL b1 is connected(TOP-REAL b1);

:: JORDAN2C:funcreg 1
registration
  let a1 be Element of NAT;
  cluster [#] TOP-REAL a1 -> connected;
end;

:: JORDAN2C:th 23
theorem
for b1 being Element of NAT holds
   [#] TOP-REAL b1 is_a_component_of TOP-REAL b1;

:: JORDAN2C:th 24
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   BDD b2 is a_union_of_components of (TOP-REAL b1) | (b2 `);

:: JORDAN2C:th 25
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   UBD b2 is a_union_of_components of (TOP-REAL b1) | (b2 `);

:: JORDAN2C:th 26
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is_inside_component_of b2
   holds b3 c= BDD b2;

:: JORDAN2C:th 27
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is_outside_component_of b2
   holds b3 c= UBD b2;

:: JORDAN2C:th 28
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   BDD b2 misses UBD b2;

:: JORDAN2C:th 29
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   BDD b2 c= b2 `;

:: JORDAN2C:th 30
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   UBD b2 c= b2 `;

:: JORDAN2C:th 31
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
   (BDD b2) \/ UBD b2 = b2 `;

:: JORDAN2C:th 33
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
      st b2 = REAL b1
   holds b2 is connected(TOP-REAL b1);

:: JORDAN2C:funcnot 3 => JORDAN2C:func 3
definition
  let a1 be Element of NAT;
  func 1* A1 -> FinSequence of REAL equals
    a1 |-> 1;
end;

:: JORDAN2C:def 7
theorem
for b1 being Element of NAT holds
   1* b1 = b1 |-> 1;

:: JORDAN2C:funcnot 4 => JORDAN2C:func 4
definition
  let a1 be Element of NAT;
  redefine func 1* a1 -> Element of REAL a1;
end;

:: JORDAN2C:funcnot 5 => JORDAN2C:func 5
definition
  let a1 be Element of NAT;
  func 1.REAL A1 -> Element of the carrier of TOP-REAL a1 equals
    1* a1;
end;

:: JORDAN2C:def 8
theorem
for b1 being Element of NAT holds
   1.REAL b1 = 1* b1;

:: JORDAN2C:th 34
theorem
for b1 being Element of NAT holds
   abs 1* b1 = b1 |-> 1;

:: JORDAN2C:th 35
theorem
for b1 being Element of NAT holds
   |.1* b1.| = sqrt b1;

:: JORDAN2C:th 37
theorem
for b1 being Element of NAT holds
   |.1.REAL b1.| = sqrt b1;

:: JORDAN2C:th 38
theorem
for b1 being Element of NAT
      st 1 <= b1
   holds 1 <= |.1.REAL b1.|;

:: JORDAN2C:th 39
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of Euclid b1
      st 1 <= b1 & b2 = REAL b1
   holds b2 is bounded(not Euclid b1);

:: JORDAN2C:th 40
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1 holds
      b2 is Bounded(b1)
   iff
      ex b3 being Element of REAL st
         for b4 being Element of the carrier of TOP-REAL b1
               st b4 in b2
            holds |.b4.| < b3;

:: JORDAN2C:th 41
theorem
for b1 being Element of NAT
      st 1 <= b1
   holds [#] TOP-REAL b1 is not Bounded(b1);

:: JORDAN2C:th 42
theorem
for b1 being Element of NAT
      st 1 <= b1
   holds UBD {} TOP-REAL b1 = REAL b1;

:: JORDAN2C:th 43
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of the carrier of TOP-REAL b1
for b5 being non empty Element of bool the carrier of TOP-REAL b1
for b6, b7 being Function-like quasi_total Relation of the carrier of I[01],the carrier of (TOP-REAL b1) | b5
      st b6 is continuous(I[01], (TOP-REAL b1) | b5) & b2 = b6 . 0 & b3 = b6 . 1 & b7 is continuous(I[01], (TOP-REAL b1) | b5) & b3 = b7 . 0 & b4 = b7 . 1
   holds ex b8 being Function-like quasi_total Relation of the carrier of I[01],the carrier of (TOP-REAL b1) | b5 st
      b8 is continuous(I[01], (TOP-REAL b1) | b5) & b2 = b8 . 0 & b4 = b8 . 1;

:: JORDAN2C:th 44
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3, b4, b5 being Element of the carrier of TOP-REAL b1
      st b3 in b2 & b4 in b2 & b5 in b2 & LSeg(b3,b4) c= b2 & LSeg(b4,b5) c= b2
   holds ex b6 being Function-like quasi_total Relation of the carrier of I[01],the carrier of (TOP-REAL b1) | b2 st
      b6 is continuous(I[01], (TOP-REAL b1) | b2) & b3 = b6 . 0 & b5 = b6 . 1;

:: JORDAN2C:th 45
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3, b4, b5, b6 being Element of the carrier of TOP-REAL b1
      st b3 in b2 & b4 in b2 & b5 in b2 & b6 in b2 & LSeg(b3,b4) c= b2 & LSeg(b4,b5) c= b2 & LSeg(b5,b6) c= b2
   holds ex b7 being Function-like quasi_total Relation of the carrier of I[01],the carrier of (TOP-REAL b1) | b2 st
      b7 is continuous(I[01], (TOP-REAL b1) | b2) & b3 = b7 . 0 & b6 = b7 . 1;

:: JORDAN2C:th 46
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3, b4, b5, b6, b7, b8, b9 being Element of the carrier of TOP-REAL b1
      st b3 in b2 & b4 in b2 & b5 in b2 & b6 in b2 & b7 in b2 & b8 in b2 & b9 in b2 & LSeg(b3,b4) c= b2 & LSeg(b4,b5) c= b2 & LSeg(b5,b6) c= b2 & LSeg(b6,b7) c= b2 & LSeg(b7,b8) c= b2 & LSeg(b8,b9) c= b2
   holds ex b10 being Function-like quasi_total Relation of the carrier of I[01],the carrier of (TOP-REAL b1) | b2 st
      b10 is continuous(I[01], (TOP-REAL b1) | b2) & b3 = b10 . 0 & b9 = b10 . 1;

:: JORDAN2C:th 47
theorem
for b1 being Element of NAT
for b2, b3 being Element of the carrier of TOP-REAL b1
      st for b4 being Element of REAL holds
           b2 <> b4 * b3 & b3 <> b4 * b2
   holds not 0.REAL b1 in LSeg(b2,b3);

:: JORDAN2C:th 48
theorem
for b1 being Element of NAT
for b2, b3 being Element of the carrier of TOP-REAL b1
for b4 being Element of bool the carrier of TopSpaceMetr Euclid b1
      st b4 = LSeg(b2,b3) & not 0.REAL b1 in LSeg(b2,b3)
   holds ex b5 being Element of the carrier of TOP-REAL b1 st
      b5 in LSeg(b2,b3) &
       0 < |.b5.| &
       |.b5.| = (dist_min b4) . 0.REAL b1;

:: JORDAN2C:th 49
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
for b4, b5 being Element of the carrier of TOP-REAL b1
      st b3 = {b6 where b6 is Element of the carrier of TOP-REAL b1: b2 < |.b6.|} &
         b4 in b3 &
         b5 in b3 &
         (for b6 being Element of REAL holds
            b4 <> b6 * b5 & b5 <> b6 * b4)
   holds ex b6, b7 being Element of the carrier of TOP-REAL b1 st
      b6 in b3 & b7 in b3 & LSeg(b4,b6) c= b3 & LSeg(b6,b7) c= b3 & LSeg(b7,b5) c= b3;

:: JORDAN2C:th 50
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
for b4, b5 being Element of the carrier of TOP-REAL b1
      st b3 = (REAL b1) \ {b6 where b6 is Element of the carrier of TOP-REAL b1: |.b6.| < b2} &
         b4 in b3 &
         b5 in b3 &
         (for b6 being Element of REAL holds
            b4 <> b6 * b5 & b5 <> b6 * b4)
   holds ex b6, b7 being Element of the carrier of TOP-REAL b1 st
      b6 in b3 & b7 in b3 & LSeg(b4,b6) c= b3 & LSeg(b6,b7) c= b3 & LSeg(b7,b5) c= b3;

:: JORDAN2C:th 52
theorem
for b1 being FinSequence of REAL holds
   b1 is Element of REAL len b1 & b1 is Element of the carrier of TOP-REAL len b1;

:: JORDAN2C:th 53
theorem
for b1 being Element of NAT
for b2 being Element of REAL b1
for b3, b4 being FinSequence of REAL
for b5 being Element of REAL
      st b3 = b2 & b4 = b5 * b2
   holds len b3 = len b4 &
    (for b6 being Element of NAT
          st 1 <= b6 & b6 <= len b3
       holds b4 /. b6 = b5 * (b3 /. b6));

:: JORDAN2C:th 54
theorem
for b1 being Element of NAT
for b2 being Element of REAL b1
for b3 being Relation-like Function-like FinSequence-like set
      st b2 <> 0* b1 & b2 = b3
   holds ex b4 being Element of NAT st
      1 <= b4 & b4 <= b1 & b3 . b4 <> 0;

:: JORDAN2C:th 55
theorem
for b1 being Element of NAT
for b2 being Element of REAL b1
      st 2 <= b1 & b2 <> 0* b1
   holds ex b3 being Element of REAL b1 st
      for b4 being Element of REAL holds
         b3 <> b4 * b2 & b2 <> b4 * b3;

:: JORDAN2C:th 56
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
for b4, b5 being Element of the carrier of TOP-REAL b1
      st 2 <= b1 &
         b3 = {b6 where b6 is Element of the carrier of TOP-REAL b1: b2 < |.b6.|} &
         b4 in b3 &
         b5 in b3 &
         (ex b6 being Element of REAL st
            (b4 = b6 * b5 or b5 = b6 * b4))
   holds ex b6, b7, b8, b9, b10 being Element of the carrier of TOP-REAL b1 st
      b6 in b3 & b7 in b3 & b8 in b3 & b9 in b3 & b10 in b3 & LSeg(b4,b6) c= b3 & LSeg(b6,b7) c= b3 & LSeg(b7,b8) c= b3 & LSeg(b8,b9) c= b3 & LSeg(b9,b10) c= b3 & LSeg(b10,b5) c= b3;

:: JORDAN2C:th 57
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
for b4, b5 being Element of the carrier of TOP-REAL b1
      st 2 <= b1 &
         b3 = (REAL b1) \ {b6 where b6 is Element of the carrier of TOP-REAL b1: |.b6.| < b2} &
         b4 in b3 &
         b5 in b3 &
         (ex b6 being Element of REAL st
            (b4 = b6 * b5 or b5 = b6 * b4))
   holds ex b6, b7, b8, b9, b10 being Element of the carrier of TOP-REAL b1 st
      b6 in b3 & b7 in b3 & b8 in b3 & b9 in b3 & b10 in b3 & LSeg(b4,b6) c= b3 & LSeg(b6,b7) c= b3 & LSeg(b7,b8) c= b3 & LSeg(b8,b9) c= b3 & LSeg(b9,b10) c= b3 & LSeg(b10,b5) c= b3;

:: JORDAN2C:th 58
theorem
for b1 being Element of NAT
for b2 being Element of REAL
      st 1 <= b1
   holds {b3 where b3 is Element of the carrier of TOP-REAL b1: b2 < |.b3.|} <> {};

:: JORDAN2C:th 59
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
      st 2 <= b1 &
         b3 = {b4 where b4 is Element of the carrier of TOP-REAL b1: b2 < |.b4.|}
   holds b3 is connected(TOP-REAL b1);

:: JORDAN2C:th 60
theorem
for b1 being Element of NAT
for b2 being Element of REAL
      st 1 <= b1
   holds (REAL b1) \ {b3 where b3 is Element of the carrier of TOP-REAL b1: |.b3.| < b2} <> {};

:: JORDAN2C:th 61
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
      st 2 <= b1 &
         b3 = (REAL b1) \ {b4 where b4 is Element of the carrier of TOP-REAL b1: |.b4.| < b2}
   holds b3 is connected(TOP-REAL b1);

:: JORDAN2C:th 62
theorem
for b1 being Element of REAL
for b2 being Element of NAT
for b3 being Element of bool the carrier of TOP-REAL b2
      st 1 <= b2 &
         b3 = (REAL b2) \ {b4 where b4 is Element of the carrier of TOP-REAL b2: |.b4.| < b1}
   holds b3 is not Bounded(b2);

:: JORDAN2C:th 63
theorem
for b1 being Element of REAL
for b2 being Element of bool the carrier of TOP-REAL 1
      st b2 = {b3 where b3 is Element of the carrier of TOP-REAL 1: ex b4 being Element of REAL st
           b3 = <*b4*> & b1 < b4}
   holds b2 is convex(1);

:: JORDAN2C:th 64
theorem
for b1 being Element of REAL
for b2 being Element of bool the carrier of TOP-REAL 1
      st b2 = {b3 where b3 is Element of the carrier of TOP-REAL 1: ex b4 being Element of REAL st
           b3 = <*b4*> & b4 < - b1}
   holds b2 is convex(1);

:: JORDAN2C:th 65
theorem
for b1 being Element of REAL
for b2 being Element of bool the carrier of TOP-REAL 1
      st b2 = {b3 where b3 is Element of the carrier of TOP-REAL 1: ex b4 being Element of REAL st
           b3 = <*b4*> & b1 < b4}
   holds b2 is connected(TOP-REAL 1);

:: JORDAN2C:th 66
theorem
for b1 being Element of REAL
for b2 being Element of bool the carrier of TOP-REAL 1
      st b2 = {b3 where b3 is Element of the carrier of TOP-REAL 1: ex b4 being Element of REAL st
           b3 = <*b4*> & b4 < - b1}
   holds b2 is connected(TOP-REAL 1);

:: JORDAN2C:th 67
theorem
for b1 being Element of bool the carrier of Euclid 1
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL 1
      st b1 = {b4 where b4 is Element of the carrier of TOP-REAL 1: ex b5 being Element of REAL st
            b4 = <*b5*> & b2 < b5} &
         b3 = b1
   holds b3 is connected(TOP-REAL 1) & b1 is bounded(not Euclid 1);

:: JORDAN2C:th 68
theorem
for b1 being Element of bool the carrier of Euclid 1
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL 1
      st b1 = {b4 where b4 is Element of the carrier of TOP-REAL 1: ex b5 being Element of REAL st
            b4 = <*b5*> & b5 < - b2} &
         b3 = b1
   holds b3 is connected(TOP-REAL 1) & b1 is bounded(not Euclid 1);

:: JORDAN2C:th 69
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of Euclid b1
for b3 being Element of REAL
for b4 being Element of bool the carrier of TOP-REAL b1
      st 2 <= b1 &
         b2 = {b5 where b5 is Element of the carrier of TOP-REAL b1: b3 < |.b5.|} &
         b4 = b2
   holds b4 is connected(TOP-REAL b1) & b2 is bounded(not Euclid b1);

:: JORDAN2C:th 70
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of Euclid b1
for b3 being Element of REAL
for b4 being Element of bool the carrier of TOP-REAL b1
      st 2 <= b1 &
         b2 = (REAL b1) \ {b5 where b5 is Element of the carrier of TOP-REAL b1: |.b5.| < b3} &
         b4 = b2
   holds b4 is connected(TOP-REAL b1) & b2 is bounded(not Euclid b1);

:: JORDAN2C:th 71
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of bool the carrier of TOP-REAL b1
for b5 being Element of bool the carrier of Euclid b1
      st b2 = b5 & b2 is connected(TOP-REAL b1) & b5 is bounded(not Euclid b1) & b3 = Component_of Down(b2,b4 `) & b5 misses b4
   holds b3 is_outside_component_of b4;

:: JORDAN2C:th 72
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of Euclid b1
for b3 being non empty Element of bool the carrier of Euclid b1
for b4 being Element of bool the carrier of (Euclid b1) | b3
      st b2 c= b3 & b2 = b4 & b4 is bounded((Euclid b1) | b3)
   holds b2 is bounded(Euclid b1);

:: JORDAN2C:th 73
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
      st b2 is compact(TOP-REAL b1)
   holds b2 is Bounded(b1);

:: JORDAN2C:condreg 1
registration
  let a1 be Element of NAT;
  cluster compact -> Bounded (Element of bool the carrier of TOP-REAL a1);
end;

:: JORDAN2C:th 74
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
      st 1 <= b1 & b2 is Bounded(b1)
   holds b2 ` <> {};

:: JORDAN2C:th 75
theorem
for b1 being Element of NAT
for b2 being Element of REAL holds
   (ex b3 being Element of bool the carrier of Euclid b1 st
       b3 = {b4 where b4 is Element of the carrier of TOP-REAL b1: |.b4.| < b2}) &
    (for b3 being Element of bool the carrier of Euclid b1
          st b3 = {b4 where b4 is Element of the carrier of TOP-REAL b1: |.b4.| < b2}
       holds b3 is bounded(Euclid b1));

:: JORDAN2C:th 76
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
      st 2 <= b1 & b2 is Bounded(b1)
   holds UBD b2 is_outside_component_of b2;

:: JORDAN2C:th 77
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
      st b3 = {b4 where b4 is Element of the carrier of TOP-REAL b1: |.b4.| < b2}
   holds b3 is convex(b1);

:: JORDAN2C:th 78
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of Euclid b1
for b3 being Element of REAL
for b4 being Element of bool the carrier of TOP-REAL b1
      st b4 = Ball(b2,b3)
   holds b4 is convex(b1);

:: JORDAN2C:th 79
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of bool the carrier of TOP-REAL b1
      st b3 = {b4 where b4 is Element of the carrier of TOP-REAL b1: |.b4.| < b2}
   holds b3 is connected(TOP-REAL b1);

:: JORDAN2C:th 80
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3, b4 being Element of the carrier of TOP-REAL b1
for b5 being Element of the carrier of Euclid b1
      st b3 <> b4 & b3 in Ball(b5,b2) & b4 in Ball(b5,b2)
   holds ex b6 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1 st
      b6 is continuous(I[01], TOP-REAL b1) & b6 . 0 = b3 & b6 . 1 = b4 & rng b6 c= Ball(b5,b2);

:: JORDAN2C:th 81
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3, b4, b5 being Element of the carrier of TOP-REAL b1
for b6 being Element of the carrier of Euclid b1
for b7 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1
      st b7 is continuous(I[01], TOP-REAL b1) & b7 . 0 = b3 & b7 . 1 = b4 & b5 in Ball(b6,b2) & b4 in Ball(b6,b2)
   holds ex b8 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1 st
      b8 is continuous(I[01], TOP-REAL b1) & b8 . 0 = b3 & b8 . 1 = b5 & rng b8 c= (rng b7) \/ Ball(b6,b2);

:: JORDAN2C:th 82
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3, b4, b5 being Element of the carrier of TOP-REAL b1
for b6 being Element of the carrier of Euclid b1
for b7 being Element of bool the carrier of TOP-REAL b1
for b8 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1
      st b8 is continuous(I[01], TOP-REAL b1) & rng b8 c= b7 & b8 . 0 = b3 & b8 . 1 = b4 & b5 in Ball(b6,b2) & b4 in Ball(b6,b2) & Ball(b6,b2) c= b7
   holds ex b9 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1 st
      b9 is continuous(I[01], TOP-REAL b1) & rng b9 c= b7 & b9 . 0 = b3 & b9 . 1 = b5;

:: JORDAN2C:th 83
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3 being Element of the carrier of TOP-REAL b1
for b4 being Element of bool the carrier of TOP-REAL b1
      st b2 is connected(TOP-REAL b1) &
         b2 is open(TOP-REAL b1) &
         b4 = {b5 where b5 is Element of the carrier of TOP-REAL b1: b5 <> b3 &
          b5 in b2 &
          (for b6 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1
                st b6 is continuous(I[01], TOP-REAL b1) & rng b6 c= b2 & b6 . 0 = b3
             holds b6 . 1 <> b5)}
   holds b4 is open(TOP-REAL b1);

:: JORDAN2C:th 84
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of TOP-REAL b1
for b3, b4 being Element of bool the carrier of TOP-REAL b1
      st b3 is connected(TOP-REAL b1) &
         b3 is open(TOP-REAL b1) &
         b2 in b3 &
         b4 = {b5 where b5 is Element of the carrier of TOP-REAL b1: (b5 <> b2 implies ex b6 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1 st
            b6 is continuous(I[01], TOP-REAL b1) & rng b6 c= b3 & b6 . 0 = b2 & b6 . 1 = b5)}
   holds b4 is open(TOP-REAL b1);

:: JORDAN2C:th 85
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of TOP-REAL b1
for b3, b4 being Element of bool the carrier of TOP-REAL b1
      st b2 in b4 &
         b3 = {b5 where b5 is Element of the carrier of TOP-REAL b1: (b5 <> b2 implies ex b6 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1 st
            b6 is continuous(I[01], TOP-REAL b1) & rng b6 c= b4 & b6 . 0 = b2 & b6 . 1 = b5)}
   holds b3 c= b4;

:: JORDAN2C:th 86
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
for b4 being Element of the carrier of TOP-REAL b1
      st b3 is connected(TOP-REAL b1) &
         b3 is open(TOP-REAL b1) &
         b4 in b3 &
         b2 = {b5 where b5 is Element of the carrier of TOP-REAL b1: (b5 <> b4 implies ex b6 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1 st
            b6 is continuous(I[01], TOP-REAL b1) & rng b6 c= b3 & b6 . 0 = b4 & b6 . 1 = b5)}
   holds b3 c= b2;

:: JORDAN2C:th 87
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3, b4 being Element of the carrier of TOP-REAL b1
      st b2 is connected(TOP-REAL b1) & b2 is open(TOP-REAL b1) & b3 in b2 & b4 in b2 & b3 <> b4
   holds ex b5 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1 st
      b5 is continuous(I[01], TOP-REAL b1) & rng b5 c= b2 & b5 . 0 = b3 & b5 . 1 = b4;

:: JORDAN2C:th 88
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
for b3 being real set
      st b2 = {b4 where b4 is Element of the carrier of TOP-REAL b1: |.b4.| = b3}
   holds b2 ` is open(TOP-REAL b1) & b2 is closed(TOP-REAL b1);

:: JORDAN2C:th 89
theorem
for b1 being Element of NAT
for b2 being non empty Element of bool the carrier of TOP-REAL b1
      st b2 is open(TOP-REAL b1)
   holds (TOP-REAL b1) | b2 is locally_connected;

:: JORDAN2C:th 90
theorem
for b1 being Element of NAT
for b2 being non empty Element of bool the carrier of TOP-REAL b1
for b3 being Element of bool the carrier of TOP-REAL b1
for b4 being real set
      st b3 = {b5 where b5 is Element of the carrier of TOP-REAL b1: |.b5.| = b4} &
         b3 ` = b2
   holds (TOP-REAL b1) | b2 is locally_connected;

:: JORDAN2C:th 91
theorem
for b1 being Element of NAT
for b2 being Function-like quasi_total Relation of the carrier of TOP-REAL b1,the carrier of R^1
      st for b3 being Element of the carrier of TOP-REAL b1 holds
           b2 . b3 = |.b3.|
   holds b2 is continuous(TOP-REAL b1, R^1);

:: JORDAN2C:th 92
theorem
for b1 being Element of NAT holds
   ex b2 being Function-like quasi_total Relation of the carrier of TOP-REAL b1,the carrier of R^1 st
      (for b3 being Element of the carrier of TOP-REAL b1 holds
          b2 . b3 = |.b3.|) &
       b2 is continuous(TOP-REAL b1, R^1);

:: JORDAN2C:funcnot 6 => PARTFUN1:func 7
notation
  let a1, a2 be non empty set;
  let a3 be Function-like quasi_total Relation of a1,a2;
  let a4 be set;
  synonym pi(a3,a4) for a3 /. a4;
end;

:: JORDAN2C:funcnot 7 => PARTFUN1:func 7
definition
  let a1, a2 be set;
  let a3 be Function-like Relation of a1,a2;
  let a4 be set;
  assume a4 is Element of a1;
  func pi(A3,A4) -> Element of a2 equals
    a3 . a4;
end;

:: JORDAN2C:def 10
theorem
for b1, b2 being non empty set
for b3 being Function-like quasi_total Relation of b1,b2
for b4 being set
      st b4 is Element of b1
   holds b3 /. b4 = b3 . b4;

:: JORDAN2C:th 93
theorem
for b1 being Element of NAT
for b2 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1
      st b2 is continuous(I[01], TOP-REAL b1)
   holds ex b3 being Function-like quasi_total Relation of the carrier of I[01],the carrier of R^1 st
      (for b4 being Element of the carrier of I[01] holds
          b3 . b4 = |.b2 . b4.|) &
       b3 is continuous(I[01], R^1);

:: JORDAN2C:th 94
theorem
for b1 being Element of NAT
for b2 being Function-like quasi_total Relation of the carrier of I[01],the carrier of TOP-REAL b1
for b3 being Element of REAL
      st b2 is continuous(I[01], TOP-REAL b1) & |.b2 /. 0.| <= b3 & b3 <= |.b2 /. 1.|
   holds ex b4 being Element of the carrier of I[01] st
      |.b2 /. b4.| = b3;

:: JORDAN2C:th 95
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of the carrier of TOP-REAL b1
      st b3 = <*b2*>
   holds |.b3.| = abs b2;

:: JORDAN2C:th 96
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
      st 1 <= b1 &
         0 < b3 &
         b2 = {b4 where b4 is Element of the carrier of TOP-REAL b1: |.b4.| = b3}
   holds BDD b2 is_inside_component_of b2;

:: JORDAN2C:th 97
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   len GoB SpStSeq b1 = 2 &
    width GoB SpStSeq b1 = 2 &
    (SpStSeq b1) /. 1 = (GoB SpStSeq b1) *(1,2) &
    (SpStSeq b1) /. 2 = (GoB SpStSeq b1) *(2,2) &
    (SpStSeq b1) /. 3 = (GoB SpStSeq b1) *(2,1) &
    (SpStSeq b1) /. 4 = (GoB SpStSeq b1) *(1,1) &
    (SpStSeq b1) /. 5 = (GoB SpStSeq b1) *(1,2);

:: JORDAN2C:th 98
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   LeftComp SpStSeq b1 is not Bounded(2);

:: JORDAN2C:th 99
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   LeftComp SpStSeq b1 c= UBD L~ SpStSeq b1;

:: JORDAN2C:th 100
theorem
for b1 being TopSpace-like TopStruct
for b2, b3, b4 being Element of bool the carrier of b1
      st b2 is_a_component_of b1 & b3 is_a_component_of b1 & b4 is connected(b1) & b2 meets b4 & b3 meets b4
   holds b2 = b3;

:: JORDAN2C:th 101
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of bool the carrier of TOP-REAL 2
      st b2 is_a_component_of (L~ SpStSeq b1) ` & b2 is not Bounded(2)
   holds b2 = LeftComp SpStSeq b1;

:: JORDAN2C:th 102
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   RightComp SpStSeq b1 c= BDD L~ SpStSeq b1 &
    RightComp SpStSeq b1 is Bounded(2);

:: JORDAN2C:th 103
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   LeftComp SpStSeq b1 = UBD L~ SpStSeq b1 &
    RightComp SpStSeq b1 = BDD L~ SpStSeq b1;

:: JORDAN2C:th 104
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2 holds
   UBD L~ SpStSeq b1 <> {} &
    UBD L~ SpStSeq b1 is_outside_component_of L~ SpStSeq b1 &
    BDD L~ SpStSeq b1 <> {} &
    BDD L~ SpStSeq b1 is_inside_component_of L~ SpStSeq b1;

:: JORDAN2C:th 105
theorem
for b1 being non empty TopSpace-like TopStruct
for b2 being Element of bool the carrier of b1
      st b2 ` <> {}
   holds    b2 is boundary(b1)
   iff
      for b3 being set
      for b4 being Element of bool the carrier of b1
            st b3 in b2 & b3 in b4 & b4 is open(b1)
         holds ex b5 being Element of bool the carrier of b1 st
            b5 is_a_component_of b2 ` & b4 meets b5;

:: JORDAN2C:th 106
theorem
for b1 being Element of bool the carrier of TOP-REAL 2
      st b1 ` <> {}
   holds    b1 is boundary(TOP-REAL 2) & b1 is Jordan
   iff
      ex b2, b3 being Element of bool the carrier of TOP-REAL 2 st
         b1 ` = b2 \/ b3 &
          b2 misses b3 &
          (Cl b2) \ b2 = (Cl b3) \ b3 &
          b1 = (Cl b2) \ b2 &
          (for b4, b5 being Element of bool the carrier of (TOP-REAL 2) | (b1 `)
                st b4 = b2 & b5 = b3
             holds b4 is_a_component_of (TOP-REAL 2) | (b1 `) & b5 is_a_component_of (TOP-REAL 2) | (b1 `));

:: JORDAN2C:th 107
theorem
for b1 being Element of NAT
for b2 being Element of the carrier of TOP-REAL b1
for b3 being Element of bool the carrier of TOP-REAL b1
      st 1 <= b1 & b3 = {b2}
   holds b3 is boundary(TOP-REAL b1);

:: JORDAN2C:th 108
theorem
for b1, b2 being Element of the carrier of TOP-REAL 2
for b3 being Element of REAL
      st b1 `1 = b2 `2 & - (b1 `2) = b2 `1 & b1 = b3 * b2
   holds b1 `1 = 0 & b1 `2 = 0 & b1 = 0.REAL 2;

:: JORDAN2C:th 109
theorem
for b1, b2 being Element of the carrier of TOP-REAL 2 holds
LSeg(b1,b2) is boundary(TOP-REAL 2);

:: JORDAN2C:funcreg 2
registration
  let a1, a2 be Element of the carrier of TOP-REAL 2;
  cluster LSeg(a1,a2) -> boundary;
end;

:: JORDAN2C:th 110
theorem
for b1 being FinSequence of the carrier of TOP-REAL 2 holds
   L~ b1 is boundary(TOP-REAL 2);

:: JORDAN2C:funcreg 3
registration
  let a1 be FinSequence of the carrier of TOP-REAL 2;
  cluster L~ a1 -> boundary;
end;

:: JORDAN2C:th 111
theorem
for b1 being Element of NAT
for b2 being Element of REAL
for b3 being Element of the carrier of Euclid b1
for b4, b5 being Element of the carrier of TOP-REAL b1
      st b4 = b3 & b5 in Ball(b3,b2)
   holds |.b4 - b5.| < b2 & |.b5 - b4.| < b2;

:: JORDAN2C:th 112
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of REAL
for b3 being Element of the carrier of TOP-REAL 2
      st 0 < b2 & b3 in L~ SpStSeq b1
   holds ex b4 being Element of the carrier of TOP-REAL 2 st
      b4 in UBD L~ SpStSeq b1 & |.b3 - b4.| < b2;

:: JORDAN2C:th 113
theorem
REAL 0 = {0.REAL 0};

:: JORDAN2C:th 114
theorem
for b1 being Element of NAT
for b2 being Element of bool the carrier of TOP-REAL b1
      st b2 is Bounded(b1)
   holds BDD b2 is Bounded(b1);

:: JORDAN2C:th 115
theorem
for b1 being non empty TopSpace-like TopStruct
for b2, b3, b4, b5 being Element of bool the carrier of b1
      st b2 is_a_component_of b1 & b3 is_a_component_of b1 & b4 is_a_component_of b1 & b2 \/ b3 = the carrier of b1 & b4 misses b2
   holds b4 = b3;

:: JORDAN2C:th 116
theorem
for b1 being Element of bool the carrier of TOP-REAL 2
      st b1 is Bounded(2) & b1 is Jordan
   holds BDD b1 is_inside_component_of b1;

:: JORDAN2C:th 117
theorem
for b1 being non empty compact non horizontal non vertical Element of bool the carrier of TOP-REAL 2
for b2 being Element of REAL
for b3 being Element of the carrier of TOP-REAL 2
      st 0 < b2 & b3 in L~ SpStSeq b1
   holds ex b4 being Element of the carrier of TOP-REAL 2 st
      b4 in BDD L~ SpStSeq b1 & |.b3 - b4.| < b2;

:: JORDAN2C:th 118
theorem
for b1 being non empty non constant circular special unfolded s.c.c. standard clockwise_oriented FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 /. 1 = N-min L~ b1 & b2 `1 < W-bound L~ b1
   holds b2 in LeftComp b1;

:: JORDAN2C:th 119
theorem
for b1 being non empty non constant circular special unfolded s.c.c. standard clockwise_oriented FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 /. 1 = N-min L~ b1 & E-bound L~ b1 < b2 `1
   holds b2 in LeftComp b1;

:: JORDAN2C:th 120
theorem
for b1 being non empty non constant circular special unfolded s.c.c. standard clockwise_oriented FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 /. 1 = N-min L~ b1 & b2 `2 < S-bound L~ b1
   holds b2 in LeftComp b1;

:: JORDAN2C:th 121
theorem
for b1 being non empty non constant circular special unfolded s.c.c. standard clockwise_oriented FinSequence of the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st b1 /. 1 = N-min L~ b1 & N-bound L~ b1 < b2 `2
   holds b2 in LeftComp b1;

:: JORDAN2C:th 122
theorem
for b1 being TopSpace-like TopStruct
for b2, b3 being Element of bool the carrier of b1
      st b3 is_a_component_of b2
   holds b3 is connected(b1);

:: JORDAN2C:th 123
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is_inside_component_of b2
   holds b3 is connected(TOP-REAL b1);

:: JORDAN2C:th 124
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is_outside_component_of b2
   holds b3 is connected(TOP-REAL b1);

:: JORDAN2C:th 125
theorem
for b1 being Element of NAT
for b2, b3 being Element of bool the carrier of TOP-REAL b1
      st b3 is_a_component_of b2 `
   holds b2 misses b3;

:: JORDAN2C:th 126
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of bool the carrier of TOP-REAL b1
      st b3 is_outside_component_of b4 & b2 is_inside_component_of b4
   holds b3 misses b2;

:: JORDAN2C:th 127
theorem
for b1 being Element of NAT
   st 2 <= b1
for b2, b3, b4 being Element of bool the carrier of TOP-REAL b1
      st b4 is Bounded(b1) & b2 is_outside_component_of b4 & b3 is_outside_component_of b4
   holds b2 = b3;

:: JORDAN2C:funcreg 4
registration
  let a1 be closed Element of bool the carrier of TOP-REAL 2;
  cluster BDD a1 -> open;
end;

:: JORDAN2C:funcreg 5
registration
  let a1 be closed Element of bool the carrier of TOP-REAL 2;
  cluster UBD a1 -> open;
end;

:: JORDAN2C:funcreg 6
registration
  let a1 be compact Element of bool the carrier of TOP-REAL 2;
  cluster UBD a1 -> connected;
end;

:: JORDAN2C:th 128
theorem
for b1 being Element of the carrier of TOP-REAL 2 holds
   west_halfline b1 is not Bounded(2);

:: JORDAN2C:th 129
theorem
for b1 being Element of the carrier of TOP-REAL 2 holds
   east_halfline b1 is not Bounded(2);

:: JORDAN2C:th 130
theorem
for b1 being Element of the carrier of TOP-REAL 2 holds
   north_halfline b1 is not Bounded(2);

:: JORDAN2C:th 131
theorem
for b1 being Element of the carrier of TOP-REAL 2 holds
   south_halfline b1 is not Bounded(2);

:: JORDAN2C:funcreg 7
registration
  let a1 be compact Element of bool the carrier of TOP-REAL 2;
  cluster UBD a1 -> non empty;
end;

:: JORDAN2C:th 132
theorem
for b1 being compact Element of bool the carrier of TOP-REAL 2 holds
   UBD b1 is_a_component_of b1 `;

:: JORDAN2C:th 133
theorem
for b1 being compact Element of bool the carrier of TOP-REAL 2
for b2 being connected Element of bool the carrier of TOP-REAL 2
      st b2 is not Bounded(2) & b2 misses b1
   holds b2 c= UBD b1;

:: JORDAN2C:th 134
theorem
for b1 being compact Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st west_halfline b2 misses b1
   holds west_halfline b2 c= UBD b1;

:: JORDAN2C:th 135
theorem
for b1 being compact Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st east_halfline b2 misses b1
   holds east_halfline b2 c= UBD b1;

:: JORDAN2C:th 136
theorem
for b1 being compact Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st south_halfline b2 misses b1
   holds south_halfline b2 c= UBD b1;

:: JORDAN2C:th 137
theorem
for b1 being compact Element of bool the carrier of TOP-REAL 2
for b2 being Element of the carrier of TOP-REAL 2
      st north_halfline b2 misses b1
   holds north_halfline b2 c= UBD b1;