Article NECKLA_3, MML version 4.99.1005

:: NECKLA_3:th 1
theorem
for b1, b2 being set holds
(id b1) | b2 = (id b1) /\ [:b2,b2:];

:: NECKLA_3:th 2
theorem
for b1, b2, b3, b4 being set holds
id {b1,b2,b3,b4} = {[b1,b1],[b2,b2],[b3,b3],[b4,b4]};

:: NECKLA_3:th 3
theorem
for b1, b2, b3, b4, b5, b6, b7, b8 being set holds
[:{b1,b2,b3,b4},{b5,b6,b7,b8}:] = {[b1,b5],[b1,b6],[b2,b5],[b2,b6],[b1,b7],[b1,b8],[b2,b7],[b2,b8]} \/ {[b3,b5],[b3,b6],[b4,b5],[b4,b6],[b3,b7],[b3,b8],[b4,b7],[b4,b8]};

:: NECKLA_3:condreg 1
registration
  let a1, a2 be trivial set;
  cluster -> trivial (Relation of a1,a2);
end;

:: NECKLA_3:th 4
theorem
for b1 being trivial set
for b2 being Relation of b1,b1
      st b2 is not empty
   holds ex b3 being set st
      b2 = {[b3,b3]};

:: NECKLA_3:condreg 2
registration
  let a1 be trivial set;
  cluster -> reflexive symmetric strongly_connected transitive trivial (Relation of a1,a1);
end;

:: NECKLA_3:th 5
theorem
for b1 being non empty trivial set
for b2 being Relation of b1,b1 holds
   b2 is_symmetric_in b1;

:: NECKLA_3:exreg 1
registration
  cluster non empty finite strict symmetric irreflexive RelStr;
end;

:: NECKLA_3:condreg 3
registration
  let a1 be irreflexive RelStr;
  cluster full -> irreflexive (SubRelStr of a1);
end;

:: NECKLA_3:condreg 4
registration
  let a1 be symmetric RelStr;
  cluster full -> symmetric (SubRelStr of a1);
end;

:: NECKLA_3:th 6
theorem
for b1 being symmetric irreflexive RelStr
      st Card the carrier of b1 = 2
   holds ex b2, b3 being set st
      the carrier of b1 = {b2,b3} &
       (the InternalRel of b1 = {[b2,b3],[b3,b2]} or the InternalRel of b1 = {});

:: NECKLA_3:funcreg 1
registration
  let a1 be non empty RelStr;
  let a2 be RelStr;
  cluster union_of(a1,a2) -> non empty strict;
end;

:: NECKLA_3:funcreg 2
registration
  let a1 be non empty RelStr;
  let a2 be RelStr;
  cluster sum_of(a1,a2) -> non empty strict;
end;

:: NECKLA_3:funcreg 3
registration
  let a1 be RelStr;
  let a2 be non empty RelStr;
  cluster union_of(a1,a2) -> non empty strict;
end;

:: NECKLA_3:funcreg 4
registration
  let a1 be RelStr;
  let a2 be non empty RelStr;
  cluster sum_of(a1,a2) -> non empty strict;
end;

:: NECKLA_3:funcreg 5
registration
  let a1, a2 be finite RelStr;
  cluster union_of(a1,a2) -> finite strict;
end;

:: NECKLA_3:funcreg 6
registration
  let a1, a2 be finite RelStr;
  cluster sum_of(a1,a2) -> finite strict;
end;

:: NECKLA_3:funcreg 7
registration
  let a1, a2 be symmetric RelStr;
  cluster union_of(a1,a2) -> strict symmetric;
end;

:: NECKLA_3:funcreg 8
registration
  let a1, a2 be symmetric RelStr;
  cluster sum_of(a1,a2) -> strict symmetric;
end;

:: NECKLA_3:funcreg 9
registration
  let a1, a2 be irreflexive RelStr;
  cluster union_of(a1,a2) -> strict irreflexive;
end;

:: NECKLA_3:th 7
theorem
for b1, b2 being irreflexive RelStr
      st the carrier of b1 misses the carrier of b2
   holds sum_of(b1,b2) is irreflexive;

:: NECKLA_3:th 8
theorem
for b1, b2 being RelStr holds
union_of(b1,b2) = union_of(b2,b1) & sum_of(b1,b2) = sum_of(b2,b1);

:: NECKLA_3:th 9
theorem
for b1 being irreflexive RelStr
for b2, b3 being RelStr
      st (b1 = union_of(b2,b3) or b1 = sum_of(b2,b3))
   holds b2 is irreflexive & b3 is irreflexive;

:: NECKLA_3:th 10
theorem
for b1 being non empty RelStr
for b2, b3 being RelStr
      st the carrier of b2 misses the carrier of b3 &
         (RelStr(#the carrier of b1,the InternalRel of b1#) = union_of(b2,b3) or RelStr(#the carrier of b1,the InternalRel of b1#) = sum_of(b2,b3))
   holds b2 is full SubRelStr of b1 & b3 is full SubRelStr of b1;

:: NECKLA_3:th 11
theorem
the InternalRel of ComplRelStr Necklace 4 = {[0,2],[2,0],[0,3],[3,0],[1,3],[3,1]};

:: NECKLA_3:funcreg 10
registration
  let a1 be RelStr;
  cluster ComplRelStr a1 -> strict irreflexive;
end;

:: NECKLA_3:funcreg 11
registration
  let a1 be symmetric RelStr;
  cluster ComplRelStr a1 -> strict symmetric;
end;

:: NECKLA_3:th 12
theorem
for b1 being RelStr holds
   the InternalRel of b1 misses the InternalRel of ComplRelStr b1;

:: NECKLA_3:th 13
theorem
for b1 being RelStr holds
   id the carrier of b1 misses the InternalRel of ComplRelStr b1;

:: NECKLA_3:th 14
theorem
for b1 being RelStr holds
   [:the carrier of b1,the carrier of b1:] = ((id the carrier of b1) \/ the InternalRel of b1) \/ the InternalRel of ComplRelStr b1;

:: NECKLA_3:th 15
theorem
for b1 being strict irreflexive RelStr
      st b1 is trivial
   holds ComplRelStr b1 = b1;

:: NECKLA_3:th 16
theorem
for b1 being strict irreflexive RelStr holds
   ComplRelStr ComplRelStr b1 = b1;

:: NECKLA_3:th 17
theorem
for b1, b2 being RelStr
      st the carrier of b1 misses the carrier of b2
   holds ComplRelStr union_of(b1,b2) = sum_of(ComplRelStr b1,ComplRelStr b2);

:: NECKLA_3:th 18
theorem
for b1, b2 being RelStr
      st the carrier of b1 misses the carrier of b2
   holds ComplRelStr sum_of(b1,b2) = union_of(ComplRelStr b1,ComplRelStr b2);

:: NECKLA_3:th 19
theorem
for b1 being RelStr
for b2 being full SubRelStr of b1 holds
   the InternalRel of ComplRelStr b2 = (the InternalRel of ComplRelStr b1) |_2 the carrier of ComplRelStr b2;

:: NECKLA_3:th 20
theorem
for b1 being non empty irreflexive RelStr
for b2 being Element of the carrier of b1
for b3 being Element of the carrier of ComplRelStr b1
      st b2 = b3
   holds ComplRelStr subrelstr (([#] b1) \ {b2}) = subrelstr (([#] ComplRelStr b1) \ {b3});

:: NECKLA_3:condreg 5
registration
  cluster non empty trivial strict -> N-free (RelStr);
end;

:: NECKLA_3:th 21
theorem
for b1 being reflexive antisymmetric RelStr
for b2 being RelStr holds
      ex b3 being Function-like quasi_total Relation of the carrier of b1,the carrier of b2 st
         for b4, b5 being Element of the carrier of b1 holds
            [b4,b5] in the InternalRel of b1
         iff
            [b3 . b4,b3 . b5] in the InternalRel of b2
   iff
      b2 embeds b1;

:: NECKLA_3:th 22
theorem
for b1 being non empty RelStr
for b2 being non empty full SubRelStr of b1 holds
   b1 embeds b2;

:: NECKLA_3:th 23
theorem
for b1 being non empty RelStr
for b2 being non empty full SubRelStr of b1
      st b1 is N-free
   holds b2 is N-free;

:: NECKLA_3:th 24
theorem
for b1 being non empty irreflexive RelStr holds
      b1 embeds Necklace 4
   iff
      ComplRelStr b1 embeds Necklace 4;

:: NECKLA_3:th 25
theorem
for b1 being non empty irreflexive RelStr holds
      b1 is N-free
   iff
      ComplRelStr b1 is N-free;

:: NECKLA_3:modenot 1
definition
  let a1 be RelStr;
  mode path of a1 is RedSequence of the InternalRel of a1;
end;

:: NECKLA_3:attrnot 1 => NECKLA_3:attr 1
definition
  let a1 be RelStr;
  attr a1 is path-connected means
    for b1, b2 being set
          st b1 in the carrier of a1 & b2 in the carrier of a1 & b1 <> b2 & not the InternalRel of a1 reduces b1,b2
       holds the InternalRel of a1 reduces b2,b1;
end;

:: NECKLA_3:dfs 1
definiens
  let a1 be RelStr;
To prove
     a1 is path-connected
it is sufficient to prove
  thus for b1, b2 being set
          st b1 in the carrier of a1 & b2 in the carrier of a1 & b1 <> b2 & not the InternalRel of a1 reduces b1,b2
       holds the InternalRel of a1 reduces b2,b1;

:: NECKLA_3:def 1
theorem
for b1 being RelStr holds
      b1 is path-connected
   iff
      for b2, b3 being set
            st b2 in the carrier of b1 & b3 in the carrier of b1 & b2 <> b3 & not the InternalRel of b1 reduces b2,b3
         holds the InternalRel of b1 reduces b3,b2;

:: NECKLA_3:condreg 6
registration
  cluster empty -> path-connected (RelStr);
end;

:: NECKLA_3:condreg 7
registration
  cluster non empty connected -> path-connected (RelStr);
end;

:: NECKLA_3:th 26
theorem
for b1 being non empty reflexive transitive RelStr
for b2, b3 being Element of the carrier of b1
      st the InternalRel of b1 reduces b2,b3
   holds [b2,b3] in the InternalRel of b1;

:: NECKLA_3:condreg 8
registration
  cluster non empty reflexive transitive path-connected -> connected (RelStr);
end;

:: NECKLA_3:th 27
theorem
for b1 being symmetric RelStr
for b2, b3 being set
      st b2 in the carrier of b1 & b3 in the carrier of b1 & the InternalRel of b1 reduces b2,b3
   holds the InternalRel of b1 reduces b3,b2;

:: NECKLA_3:attrnot 2 => NECKLA_3:attr 1
definition
  let a1 be RelStr;
  attr a1 is path-connected means
    for b1, b2 being set
          st b1 in the carrier of a1 & b2 in the carrier of a1 & b1 <> b2
       holds the InternalRel of a1 reduces b1,b2;
end;

:: NECKLA_3:dfs 2
definiens
  let a1 be symmetric RelStr;
To prove
     a1 is path-connected
it is sufficient to prove
  thus for b1, b2 being set
          st b1 in the carrier of a1 & b2 in the carrier of a1 & b1 <> b2
       holds the InternalRel of a1 reduces b1,b2;

:: NECKLA_3:def 2
theorem
for b1 being symmetric RelStr holds
      b1 is path-connected
   iff
      for b2, b3 being set
            st b2 in the carrier of b1 & b3 in the carrier of b1 & b2 <> b3
         holds the InternalRel of b1 reduces b2,b3;

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

:: NECKLA_3:def 3
theorem
for b1 being RelStr
for b2 being Element of the carrier of b1 holds
   component b2 = Class(EqCl the InternalRel of b1,b2);

:: NECKLA_3:funcreg 12
registration
  let a1 be non empty RelStr;
  let a2 be Element of the carrier of a1;
  cluster component a2 -> non empty;
end;

:: NECKLA_3:th 29
theorem
for b1 being RelStr
for b2 being Element of the carrier of b1
for b3 being set
      st b3 in component b2
   holds [b2,b3] in EqCl the InternalRel of b1;

:: NECKLA_3:th 30
theorem
for b1 being RelStr
for b2 being Element of the carrier of b1
for b3 being set holds
      b3 = component b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            [b2,b4] in EqCl the InternalRel of b1;

:: NECKLA_3:th 31
theorem
for b1 being non empty symmetric irreflexive RelStr
      st b1 is not path-connected
   holds ex b2, b3 being non empty strict symmetric irreflexive RelStr st
      the carrier of b2 misses the carrier of b3 &
       RelStr(#the carrier of b1,the InternalRel of b1#) = union_of(b2,b3);

:: NECKLA_3:th 32
theorem
for b1 being non empty symmetric irreflexive RelStr
      st ComplRelStr b1 is not path-connected
   holds ex b2, b3 being non empty strict symmetric irreflexive RelStr st
      the carrier of b2 misses the carrier of b3 &
       RelStr(#the carrier of b1,the InternalRel of b1#) = sum_of(b2,b3);

:: NECKLA_3:th 33
theorem
for b1 being irreflexive RelStr
      st b1 in fin_RelStr_sp
   holds ComplRelStr b1 in fin_RelStr_sp;

:: NECKLA_3:th 34
theorem
for b1 being symmetric irreflexive RelStr
      st Card the carrier of b1 = 2 & the carrier of b1 in FinSETS
   holds RelStr(#the carrier of b1,the InternalRel of b1#) in fin_RelStr_sp;

:: NECKLA_3:th 35
theorem
for b1 being RelStr
      st b1 in fin_RelStr_sp
   holds b1 is symmetric;

:: NECKLA_3:th 36
theorem
for b1 being RelStr
for b2, b3 being non empty RelStr
for b4 being Element of the carrier of b2
for b5 being Element of the carrier of b3
      st b1 = union_of(b2,b3) & the carrier of b2 misses the carrier of b3
   holds not [b4,b5] in the InternalRel of b1;

:: NECKLA_3:th 37
theorem
for b1 being RelStr
for b2, b3 being non empty RelStr
for b4 being Element of the carrier of b2
for b5 being Element of the carrier of b3
      st b1 = sum_of(b2,b3)
   holds not [b4,b5] in the InternalRel of ComplRelStr b1;

:: NECKLA_3:th 38
theorem
for b1 being non empty symmetric RelStr
for b2 being Element of the carrier of b1
for b3, b4 being non empty RelStr
      st the carrier of b3 misses the carrier of b4 &
         subrelstr (([#] b1) \ {b2}) = union_of(b3,b4) &
         b1 is path-connected
   holds ex b5 being Element of the carrier of b3 st
      [b5,b2] in the InternalRel of b1;

:: NECKLA_3:th 39
theorem
for b1 being non empty symmetric irreflexive RelStr
for b2, b3, b4, b5 being Element of the carrier of b1
for b6 being Element of bool the carrier of b1
      st b6 = {b2,b3,b4,b5} & b2,b3,b4,b5 are_mutually_different & [b2,b3] in the InternalRel of b1 & [b3,b4] in the InternalRel of b1 & [b4,b5] in the InternalRel of b1 & not [b2,b4] in the InternalRel of b1 & not [b2,b5] in the InternalRel of b1 & not [b3,b5] in the InternalRel of b1
   holds subrelstr b6 embeds Necklace 4;

:: NECKLA_3:th 40
theorem
for b1 being non empty symmetric irreflexive RelStr
for b2 being Element of the carrier of b1
for b3, b4 being non empty RelStr
      st the carrier of b3 misses the carrier of b4 &
         subrelstr (([#] b1) \ {b2}) = union_of(b3,b4) &
         b1 is not trivial &
         b1 is path-connected &
         ComplRelStr b1 is path-connected
   holds b1 embeds Necklace 4;

:: NECKLA_3:th 41
theorem
for b1 being non empty finite strict symmetric irreflexive RelStr
      st b1 is N-free & the carrier of b1 in FinSETS
   holds RelStr(#the carrier of b1,the InternalRel of b1#) in fin_RelStr_sp;