Article FIN_TOPO, MML version 4.99.1005

:: FIN_TOPO:th 1
theorem
for b1 being set
for b2 being FinSequence of bool b1
   st for b3 being Element of NAT
           st 1 <= b3 & b3 < len b2
        holds b2 /. b3 c= b2 /. (b3 + 1)
for b3, b4 being Element of NAT
      st b3 <= b4 & 1 <= b3 & b4 <= len b2
   holds b2 /. b3 c= b2 /. b4;

:: FIN_TOPO:th 2
theorem
for b1 being set
for b2 being FinSequence of bool b1
   st for b3 being Element of NAT
           st 1 <= b3 & b3 < len b2
        holds b2 /. b3 c= b2 /. (b3 + 1)
for b3, b4 being Element of NAT
   st b3 < b4 & 1 <= b3 & b4 <= len b2 & b2 /. b4 c= b2 /. b3
for b5 being Element of NAT
      st b3 <= b5 & b5 <= b4
   holds b2 /. b4 = b2 /. b5;

:: FIN_TOPO:sch 1
scheme FIN_TOPO:sch 1
{F1 -> non empty set,
  F2 -> Element of bool F1(),
  F3 -> Element of bool F1(),
  F4 -> Element of bool F1()}:
ex b1 being FinSequence of bool F1() st
   0 < len b1 &
    b1 /. 1 = F3() &
    (for b2 being Element of NAT
          st 0 < b2 & b2 < len b1
       holds b1 /. (b2 + 1) = F4(b1 /. b2)) &
    F4(b1 /. len b1) = b1 /. len b1 &
    (for b2, b3 being Element of NAT
          st 0 < b2 & b2 < b3 & b3 <= len b1
       holds b1 /. b2 c= F2() & b1 /. b2 c< b1 /. b3)
provided
   F2() is finite
and
   F3() c= F2()
and
   for b1 being Element of bool F1()
         st b1 c= F2()
      holds b1 c= F4(b1) & F4(b1) c= F2();


:: FIN_TOPO:exreg 1
registration
  cluster non empty strict RelStr;
end;

:: FIN_TOPO:funcnot 1 => FIN_TOPO:func 1
definition
  let a1 be RelStr;
  let a2 be Element of the carrier of a1;
  func U_FT A2 -> Element of bool the carrier of a1 equals
    Class(the InternalRel of a1,a2);
end;

:: FIN_TOPO:def 1
theorem
for b1 being RelStr
for b2 being Element of the carrier of b1 holds
   U_FT b2 = Class(the InternalRel of b1,b2);

:: FIN_TOPO:funcnot 2 => FIN_TOPO:func 2
definition
  let a1 be set;
  let a2 be Element of bool {a1};
  redefine func a1 .--> a2 -> Function-like quasi_total Relation of {a1},bool {a1};
end;

:: FIN_TOPO:funcnot 3 => FIN_TOPO:func 3
definition
  let a1 be set;
  func SinglRel A1 -> Relation of {a1},{a1} equals
    {[a1,a1]};
end;

:: FIN_TOPO:def 2
theorem
for b1 being set holds
   SinglRel b1 = {[b1,b1]};

:: FIN_TOPO:funcnot 4 => FIN_TOPO:func 4
definition
  func FT{0} -> strict RelStr equals
    RelStr(#{0},SinglRel 0#);
end;

:: FIN_TOPO:def 3
theorem
FT{0} = RelStr(#{0},SinglRel 0#);

:: FIN_TOPO:funcreg 1
registration
  cluster FT{0} -> non empty strict;
end;

:: FIN_TOPO:attrnot 1 => ORDERS_2:attr 3
notation
  let a1 be non empty RelStr;
  synonym filled for reflexive;
end;

:: FIN_TOPO:attrnot 2 => ORDERS_2:attr 3
definition
  let a1 be RelStr;
  attr a1 is filled means
    for b1 being Element of the carrier of a1 holds
       b1 in U_FT b1;
end;

:: FIN_TOPO:dfs 4
definiens
  let a1 be non empty RelStr;
To prove
     a1 is reflexive
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       b1 in U_FT b1;

:: FIN_TOPO:def 4
theorem
for b1 being non empty RelStr holds
      b1 is reflexive
   iff
      for b2 being Element of the carrier of b1 holds
         b2 in U_FT b2;

:: FIN_TOPO:th 7
theorem
FT{0} is reflexive;

:: FIN_TOPO:th 8
theorem
FT{0} is finite;

:: FIN_TOPO:funcreg 2
registration
  cluster FT{0} -> finite strict reflexive;
end;

:: FIN_TOPO:exreg 2
registration
  cluster non empty finite strict reflexive RelStr;
end;

:: FIN_TOPO:prednot 1 => FIN_TOPO:pred 1
definition
  let a1 be 1-sorted;
  let a2 be set;
  pred A2 is_a_cover_of A1 means
    the carrier of a1 c= union a2;
end;

:: FIN_TOPO:dfs 5
definiens
  let a1 be 1-sorted;
  let a2 be set;
To prove
     a2 is_a_cover_of a1
it is sufficient to prove
  thus the carrier of a1 c= union a2;

:: FIN_TOPO:def 6
theorem
for b1 being 1-sorted
for b2 being set holds
      b2 is_a_cover_of b1
   iff
      the carrier of b1 c= union b2;

:: FIN_TOPO:th 9
theorem
for b1 being non empty reflexive RelStr holds
   {U_FT b2 where b2 is Element of the carrier of b1: TRUE} is_a_cover_of b1;

:: FIN_TOPO:funcnot 5 => FIN_TOPO:func 5
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^delta -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: U_FT b1 meets a2 & U_FT b1 meets a2 `};
end;

:: FIN_TOPO:def 7
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^delta = {b3 where b3 is Element of the carrier of b1: U_FT b3 meets b2 & U_FT b3 meets b2 `};

:: FIN_TOPO:th 10
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1 holds
      b2 in b3 ^delta
   iff
      U_FT b2 meets b3 & U_FT b2 meets b3 `;

:: FIN_TOPO:funcnot 6 => FIN_TOPO:func 6
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^deltai -> Element of bool the carrier of a1 equals
    a2 /\ (a2 ^delta);
end;

:: FIN_TOPO:def 8
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^deltai = b2 /\ (b2 ^delta);

:: FIN_TOPO:funcnot 7 => FIN_TOPO:func 7
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^deltao -> Element of bool the carrier of a1 equals
    a2 ` /\ (a2 ^delta);
end;

:: FIN_TOPO:def 9
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^deltao = b2 ` /\ (b2 ^delta);

:: FIN_TOPO:th 11
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^delta = b2 ^deltai \/ (b2 ^deltao);

:: FIN_TOPO:funcnot 8 => FIN_TOPO:func 8
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^i -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: U_FT b1 c= a2};
end;

:: FIN_TOPO:def 10
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^i = {b3 where b3 is Element of the carrier of b1: U_FT b3 c= b2};

:: FIN_TOPO:funcnot 9 => FIN_TOPO:func 9
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^b -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: U_FT b1 meets a2};
end;

:: FIN_TOPO:def 11
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^b = {b3 where b3 is Element of the carrier of b1: U_FT b3 meets b2};

:: FIN_TOPO:funcnot 10 => FIN_TOPO:func 10
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^s -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: b1 in a2 & (U_FT b1) \ {b1} misses a2};
end;

:: FIN_TOPO:def 12
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^s = {b3 where b3 is Element of the carrier of b1: b3 in b2 & (U_FT b3) \ {b3} misses b2};

:: FIN_TOPO:funcnot 11 => FIN_TOPO:func 11
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^n -> Element of bool the carrier of a1 equals
    a2 \ (a2 ^s);
end;

:: FIN_TOPO:def 13
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^n = b2 \ (b2 ^s);

:: FIN_TOPO:funcnot 12 => FIN_TOPO:func 12
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^f -> Element of bool the carrier of a1 equals
    {b1 where b1 is Element of the carrier of a1: ex b2 being Element of the carrier of a1 st
       b2 in a2 & b1 in U_FT b2};
end;

:: FIN_TOPO:def 14
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^f = {b3 where b3 is Element of the carrier of b1: ex b4 being Element of the carrier of b1 st
      b4 in b2 & b3 in U_FT b4};

:: FIN_TOPO:attrnot 3 => FIN_TOPO:attr 1
definition
  let a1 be non empty RelStr;
  attr a1 is symmetric means
    for b1, b2 being Element of the carrier of a1
          st b2 in U_FT b1
       holds b1 in U_FT b2;
end;

:: FIN_TOPO:dfs 14
definiens
  let a1 be non empty RelStr;
To prove
     a1 is symmetric
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b2 in U_FT b1
       holds b1 in U_FT b2;

:: FIN_TOPO:def 15
theorem
for b1 being non empty RelStr holds
      b1 is symmetric
   iff
      for b2, b3 being Element of the carrier of b1
            st b3 in U_FT b2
         holds b2 in U_FT b3;

:: FIN_TOPO:th 12
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1 holds
      b2 in b3 ^i
   iff
      U_FT b2 c= b3;

:: FIN_TOPO:th 13
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1 holds
      b2 in b3 ^b
   iff
      U_FT b2 meets b3;

:: FIN_TOPO:th 14
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1 holds
      b2 in b3 ^s
   iff
      b2 in b3 & (U_FT b2) \ {b2} misses b3;

:: FIN_TOPO:th 15
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1 holds
      b2 in b3 ^n
   iff
      b2 in b3 & (U_FT b2) \ {b2} meets b3;

:: FIN_TOPO:th 16
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1 holds
      b2 in b3 ^f
   iff
      ex b4 being Element of the carrier of b1 st
         b4 in b3 & b2 in U_FT b4;

:: FIN_TOPO:th 17
theorem
for b1 being non empty RelStr holds
      b1 is symmetric
   iff
      for b2 being Element of bool the carrier of b1 holds
         b2 ^b = b2 ^f;

:: FIN_TOPO:attrnot 4 => FIN_TOPO:attr 2
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is open means
    a2 = a2 ^i;
end;

:: FIN_TOPO:dfs 15
definiens
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is open
it is sufficient to prove
  thus a2 = a2 ^i;

:: FIN_TOPO:def 16
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is open(b1)
   iff
      b2 = b2 ^i;

:: FIN_TOPO:attrnot 5 => FIN_TOPO:attr 3
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is closed means
    a2 = a2 ^b;
end;

:: FIN_TOPO:dfs 16
definiens
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is closed
it is sufficient to prove
  thus a2 = a2 ^b;

:: FIN_TOPO:def 17
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is closed(b1)
   iff
      b2 = b2 ^b;

:: FIN_TOPO:attrnot 6 => FIN_TOPO:attr 4
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  attr a2 is connected means
    for b1, b2 being Element of bool the carrier of a1
          st a2 = b1 \/ b2 & b1 <> {} & b2 <> {} & b1 misses b2
       holds b1 ^b meets b2;
end;

:: FIN_TOPO:dfs 17
definiens
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is connected
it is sufficient to prove
  thus for b1, b2 being Element of bool the carrier of a1
          st a2 = b1 \/ b2 & b1 <> {} & b2 <> {} & b1 misses b2
       holds b1 ^b meets b2;

:: FIN_TOPO:def 18
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is connected(b1)
   iff
      for b3, b4 being Element of bool the carrier of b1
            st b2 = b3 \/ b4 & b3 <> {} & b4 <> {} & b3 misses b4
         holds b3 ^b meets b4;

:: FIN_TOPO:funcnot 13 => FIN_TOPO:func 13
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^fb -> Element of bool the carrier of a1 equals
    meet {b1 where b1 is Element of bool the carrier of a1: a2 c= b1 & b1 is closed(a1)};
end;

:: FIN_TOPO:def 19
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^fb = meet {b3 where b3 is Element of bool the carrier of b1: b2 c= b3 & b3 is closed(b1)};

:: FIN_TOPO:funcnot 14 => FIN_TOPO:func 14
definition
  let a1 be non empty RelStr;
  let a2 be Element of bool the carrier of a1;
  func A2 ^fi -> Element of bool the carrier of a1 equals
    union {b1 where b1 is Element of bool the carrier of a1: a2 c= b1 & b1 is open(a1)};
end;

:: FIN_TOPO:def 20
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^fi = union {b3 where b3 is Element of bool the carrier of b1: b2 c= b3 & b3 is open(b1)};

:: FIN_TOPO:th 18
theorem
for b1 being non empty reflexive RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 c= b2 ^b;

:: FIN_TOPO:th 19
theorem
for b1 being non empty RelStr
for b2, b3 being Element of bool the carrier of b1
      st b2 c= b3
   holds b2 ^b c= b3 ^b;

:: FIN_TOPO:th 20
theorem
for b1 being non empty finite reflexive RelStr
for b2 being Element of bool the carrier of b1 holds
      b2 is connected(b1)
   iff
      for b3 being Element of the carrier of b1
            st b3 in b2
         holds ex b4 being FinSequence of bool the carrier of b1 st
            0 < len b4 &
             b4 /. 1 = {b3} &
             (for b5 being Element of NAT
                   st 0 < b5 & b5 < len b4
                holds b4 /. (b5 + 1) = (b4 /. b5) ^b /\ b2) &
             b2 c= b4 /. len b4;

:: FIN_TOPO:th 22
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ` ^i ` = b2 ^b;

:: FIN_TOPO:th 23
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ` ^b ` = b2 ^i;

:: FIN_TOPO:th 24
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^delta = b2 ^b /\ (b2 ` ^b);

:: FIN_TOPO:th 25
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ` ^delta = b2 ^delta;

:: FIN_TOPO:th 26
theorem
for b1 being non empty RelStr
for b2 being Element of the carrier of b1
for b3 being Element of bool the carrier of b1
      st b2 in b3 ^s
   holds not b2 in (b3 \ {b2}) ^b;

:: FIN_TOPO:th 27
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
      st b2 ^s <> {} & Card b2 <> 1
   holds b2 is not connected(b1);

:: FIN_TOPO:th 28
theorem
for b1 being non empty reflexive RelStr
for b2 being Element of bool the carrier of b1 holds
   b2 ^i c= b2;

:: FIN_TOPO:th 30
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
      st b2 is open(b1)
   holds b2 ` is closed(b1);

:: FIN_TOPO:th 31
theorem
for b1 being non empty RelStr
for b2 being Element of bool the carrier of b1
      st b2 is closed(b1)
   holds b2 ` is open(b1);