Article PENCIL_1, MML version 4.99.1005

:: PENCIL_1:th 1
theorem
for b1, b2 being Relation-like Function-like set
      st product b1 = product b2 & b1 is non-empty
   holds b2 is non-empty;

:: PENCIL_1:th 2
theorem
for b1 being set holds
      2 c= Card b1
   iff
      ex b2, b3 being set st
         b2 in b1 & b3 in b1 & b2 <> b3;

:: PENCIL_1:th 3
theorem
for b1 being set
   st 2 c= Card b1
for b2 being set holds
   ex b3 being set st
      b3 in b1 & b2 <> b3;

:: PENCIL_1:th 4
theorem
for b1 being set holds
      2 c= Card b1
   iff
      b1 is not trivial;

:: PENCIL_1:th 5
theorem
for b1 being set holds
      3 c= Card b1
   iff
      ex b2, b3, b4 being set st
         b2 in b1 & b3 in b1 & b4 in b1 & b2 <> b3 & b2 <> b4 & b3 <> b4;

:: PENCIL_1:th 6
theorem
for b1 being set
   st 3 c= Card b1
for b2, b3 being set holds
ex b4 being set st
   b4 in b1 & b2 <> b4 & b3 <> b4;

:: PENCIL_1:modenot 1
definition
  let a1 be TopStruct;
  mode Block of a1 is Element of the topology of a1;
end;

:: PENCIL_1:prednot 1 => PENCIL_1:pred 1
definition
  let a1 be TopStruct;
  let a2, a3 be Element of the carrier of a1;
  pred A2,A3 are_collinear means
    (a2 <> a3) implies ex b1 being Element of the topology of a1 st
       {a2,a3} c= b1;
end;

:: PENCIL_1:dfs 1
definiens
  let a1 be TopStruct;
  let a2, a3 be Element of the carrier of a1;
To prove
     a2,a3 are_collinear
it is sufficient to prove
  thus (a2 <> a3) implies ex b1 being Element of the topology of a1 st
       {a2,a3} c= b1;

:: PENCIL_1:def 1
theorem
for b1 being TopStruct
for b2, b3 being Element of the carrier of b1 holds
   b2,b3 are_collinear
iff
   (b2 <> b3 implies ex b4 being Element of the topology of b1 st
      {b2,b3} c= b4);

:: PENCIL_1:attrnot 1 => PENCIL_1:attr 1
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is closed_under_lines means
    for b1 being Element of the topology of a1
          st 2 c= Card (b1 /\ a2)
       holds b1 c= a2;
end;

:: PENCIL_1:dfs 2
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is closed_under_lines
it is sufficient to prove
  thus for b1 being Element of the topology of a1
          st 2 c= Card (b1 /\ a2)
       holds b1 c= a2;

:: PENCIL_1:def 2
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is closed_under_lines(b1)
   iff
      for b3 being Element of the topology of b1
            st 2 c= Card (b3 /\ b2)
         holds b3 c= b2;

:: PENCIL_1:attrnot 2 => PENCIL_1:attr 2
definition
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
  attr a2 is strong means
    for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds b1,b2 are_collinear;
end;

:: PENCIL_1:dfs 3
definiens
  let a1 be TopStruct;
  let a2 be Element of bool the carrier of a1;
To prove
     a2 is strong
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1
          st b1 in a2 & b2 in a2
       holds b1,b2 are_collinear;

:: PENCIL_1:def 3
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1 holds
      b2 is strong(b1)
   iff
      for b3, b4 being Element of the carrier of b1
            st b3 in b2 & b4 in b2
         holds b3,b4 are_collinear;

:: PENCIL_1:attrnot 3 => PENCIL_1:attr 3
definition
  let a1 be TopStruct;
  attr a1 is void means
    the topology of a1 is empty;
end;

:: PENCIL_1:dfs 4
definiens
  let a1 be TopStruct;
To prove
     a1 is void
it is sufficient to prove
  thus the topology of a1 is empty;

:: PENCIL_1:def 4
theorem
for b1 being TopStruct holds
      b1 is void
   iff
      the topology of b1 is empty;

:: PENCIL_1:attrnot 4 => PENCIL_1:attr 4
definition
  let a1 be TopStruct;
  attr a1 is degenerated means
    the carrier of a1 is Element of the topology of a1;
end;

:: PENCIL_1:dfs 5
definiens
  let a1 be TopStruct;
To prove
     a1 is degenerated
it is sufficient to prove
  thus the carrier of a1 is Element of the topology of a1;

:: PENCIL_1:def 5
theorem
for b1 being TopStruct holds
      b1 is degenerated
   iff
      the carrier of b1 is Element of the topology of b1;

:: PENCIL_1:attrnot 5 => PENCIL_1:attr 5
definition
  let a1 be TopStruct;
  attr a1 is with_non_trivial_blocks means
    for b1 being Element of the topology of a1 holds
       2 c= Card b1;
end;

:: PENCIL_1:dfs 6
definiens
  let a1 be TopStruct;
To prove
     a1 is with_non_trivial_blocks
it is sufficient to prove
  thus for b1 being Element of the topology of a1 holds
       2 c= Card b1;

:: PENCIL_1:def 6
theorem
for b1 being TopStruct holds
      b1 is with_non_trivial_blocks
   iff
      for b2 being Element of the topology of b1 holds
         2 c= Card b2;

:: PENCIL_1:attrnot 6 => PENCIL_1:attr 6
definition
  let a1 be TopStruct;
  attr a1 is identifying_close_blocks means
    for b1, b2 being Element of the topology of a1
          st 2 c= Card (b1 /\ b2)
       holds b1 = b2;
end;

:: PENCIL_1:dfs 7
definiens
  let a1 be TopStruct;
To prove
     a1 is identifying_close_blocks
it is sufficient to prove
  thus for b1, b2 being Element of the topology of a1
          st 2 c= Card (b1 /\ b2)
       holds b1 = b2;

:: PENCIL_1:def 7
theorem
for b1 being TopStruct holds
      b1 is identifying_close_blocks
   iff
      for b2, b3 being Element of the topology of b1
            st 2 c= Card (b2 /\ b3)
         holds b2 = b3;

:: PENCIL_1:attrnot 7 => PENCIL_1:attr 7
definition
  let a1 be TopStruct;
  attr a1 is truly-partial means
    ex b1, b2 being Element of the carrier of a1 st
       not b1,b2 are_collinear;
end;

:: PENCIL_1:dfs 8
definiens
  let a1 be TopStruct;
To prove
     a1 is truly-partial
it is sufficient to prove
  thus ex b1, b2 being Element of the carrier of a1 st
       not b1,b2 are_collinear;

:: PENCIL_1:def 8
theorem
for b1 being TopStruct holds
      b1 is truly-partial
   iff
      ex b2, b3 being Element of the carrier of b1 st
         not b2,b3 are_collinear;

:: PENCIL_1:attrnot 8 => PENCIL_1:attr 8
definition
  let a1 be TopStruct;
  attr a1 is without_isolated_points means
    for b1 being Element of the carrier of a1 holds
       ex b2 being Element of the topology of a1 st
          b1 in b2;
end;

:: PENCIL_1:dfs 9
definiens
  let a1 be TopStruct;
To prove
     a1 is without_isolated_points
it is sufficient to prove
  thus for b1 being Element of the carrier of a1 holds
       ex b2 being Element of the topology of a1 st
          b1 in b2;

:: PENCIL_1:def 9
theorem
for b1 being TopStruct holds
      b1 is without_isolated_points
   iff
      for b2 being Element of the carrier of b1 holds
         ex b3 being Element of the topology of b1 st
            b2 in b3;

:: PENCIL_1:attrnot 9 => PENCIL_1:attr 9
definition
  let a1 be TopStruct;
  attr a1 is connected means
    for b1, b2 being Element of the carrier of a1 holds
    ex b3 being FinSequence of the carrier of a1 st
       b1 = b3 . 1 &
        b2 = b3 . len b3 &
        (for b4 being natural set
           st 1 <= b4 & b4 < len b3
        for b5, b6 being Element of the carrier of a1
              st b5 = b3 . b4 & b6 = b3 . (b4 + 1)
           holds b5,b6 are_collinear);
end;

:: PENCIL_1:dfs 10
definiens
  let a1 be TopStruct;
To prove
     a1 is connected
it is sufficient to prove
  thus for b1, b2 being Element of the carrier of a1 holds
    ex b3 being FinSequence of the carrier of a1 st
       b1 = b3 . 1 &
        b2 = b3 . len b3 &
        (for b4 being natural set
           st 1 <= b4 & b4 < len b3
        for b5, b6 being Element of the carrier of a1
              st b5 = b3 . b4 & b6 = b3 . (b4 + 1)
           holds b5,b6 are_collinear);

:: PENCIL_1:def 10
theorem
for b1 being TopStruct holds
      b1 is connected
   iff
      for b2, b3 being Element of the carrier of b1 holds
      ex b4 being FinSequence of the carrier of b1 st
         b2 = b4 . 1 &
          b3 = b4 . len b4 &
          (for b5 being natural set
             st 1 <= b5 & b5 < len b4
          for b6, b7 being Element of the carrier of b1
                st b6 = b4 . b5 & b7 = b4 . (b5 + 1)
             holds b6,b7 are_collinear);

:: PENCIL_1:attrnot 10 => PENCIL_1:attr 10
definition
  let a1 be TopStruct;
  attr a1 is strongly_connected means
    for b1 being Element of the carrier of a1
    for b2 being Element of bool the carrier of a1
          st b2 is closed_under_lines(a1) & b2 is strong(a1)
       holds ex b3 being FinSequence of bool the carrier of a1 st
          b2 = b3 . 1 &
           b1 in b3 . len b3 &
           (for b4 being Element of bool the carrier of a1
                 st b4 in proj2 b3
              holds b4 is closed_under_lines(a1) & b4 is strong(a1)) &
           (for b4 being natural set
                 st 1 <= b4 & b4 < len b3
              holds 2 c= Card ((b3 . b4) /\ (b3 . (b4 + 1))));
end;

:: PENCIL_1:dfs 11
definiens
  let a1 be TopStruct;
To prove
     a1 is strongly_connected
it is sufficient to prove
  thus for b1 being Element of the carrier of a1
    for b2 being Element of bool the carrier of a1
          st b2 is closed_under_lines(a1) & b2 is strong(a1)
       holds ex b3 being FinSequence of bool the carrier of a1 st
          b2 = b3 . 1 &
           b1 in b3 . len b3 &
           (for b4 being Element of bool the carrier of a1
                 st b4 in proj2 b3
              holds b4 is closed_under_lines(a1) & b4 is strong(a1)) &
           (for b4 being natural set
                 st 1 <= b4 & b4 < len b3
              holds 2 c= Card ((b3 . b4) /\ (b3 . (b4 + 1))));

:: PENCIL_1:def 11
theorem
for b1 being TopStruct holds
      b1 is strongly_connected
   iff
      for b2 being Element of the carrier of b1
      for b3 being Element of bool the carrier of b1
            st b3 is closed_under_lines(b1) & b3 is strong(b1)
         holds ex b4 being FinSequence of bool the carrier of b1 st
            b3 = b4 . 1 &
             b2 in b4 . len b4 &
             (for b5 being Element of bool the carrier of b1
                   st b5 in proj2 b4
                holds b5 is closed_under_lines(b1) & b5 is strong(b1)) &
             (for b5 being natural set
                   st 1 <= b5 & b5 < len b4
                holds 2 c= Card ((b4 . b5) /\ (b4 . (b5 + 1))));

:: PENCIL_1:th 7
theorem
for b1 being non empty set
   st 3 c= Card b1
for b2 being TopStruct
      st the carrier of b2 = b1 &
         the topology of b2 = {b3 where b3 is Element of bool b1: 2 = Card b3}
   holds b2 is not empty & b2 is not void & b2 is not degenerated & b2 is not truly-partial & b2 is with_non_trivial_blocks & b2 is identifying_close_blocks & b2 is without_isolated_points;

:: PENCIL_1:th 8
theorem
for b1 being non empty set
   st 3 c= Card b1
for b2 being Element of bool b1
   st Card b2 = 2
for b3 being TopStruct
      st the carrier of b3 = b1 &
         the topology of b3 = {b4 where b4 is Element of bool b1: 2 = Card b4} \ {b2}
   holds b3 is not empty & b3 is not void & b3 is not degenerated & b3 is truly-partial & b3 is with_non_trivial_blocks & b3 is identifying_close_blocks & b3 is without_isolated_points;

:: PENCIL_1:exreg 1
registration
  cluster non empty strict non void non degenerated with_non_trivial_blocks identifying_close_blocks non truly-partial without_isolated_points TopStruct;
end;

:: PENCIL_1:exreg 2
registration
  cluster non empty strict non void non degenerated with_non_trivial_blocks identifying_close_blocks truly-partial without_isolated_points TopStruct;
end;

:: PENCIL_1:funcreg 1
registration
  let a1 be non void TopStruct;
  cluster the topology of a1 -> non empty;
end;

:: PENCIL_1:prednot 2 => PENCIL_1:pred 1
definition
  let a1 be TopStruct;
  let a2, a3 be Element of the carrier of a1;
  pred A2,A3 are_collinear means
    ex b1 being Element of the topology of a1 st
       {a2,a3} c= b1;
end;

:: PENCIL_1:dfs 12
definiens
  let a1 be without_isolated_points TopStruct;
  let a2, a3 be Element of the carrier of a1;
To prove
     a2,a3 are_collinear
it is sufficient to prove
  thus ex b1 being Element of the topology of a1 st
       {a2,a3} c= b1;

:: PENCIL_1:def 12
theorem
for b1 being without_isolated_points TopStruct
for b2, b3 being Element of the carrier of b1 holds
   b2,b3 are_collinear
iff
   ex b4 being Element of the topology of b1 st
      {b2,b3} c= b4;

:: PENCIL_1:modenot 2
definition
  mode PLS is non empty non void non degenerated with_non_trivial_blocks identifying_close_blocks TopStruct;
end;

:: PENCIL_1:attrnot 11 => PENCIL_1:attr 11
definition
  let a1 be Relation-like set;
  attr a1 is TopStruct-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is TopStruct;
end;

:: PENCIL_1:dfs 13
definiens
  let a1 be Relation-like set;
To prove
     a1 is TopStruct-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is TopStruct;

:: PENCIL_1:def 13
theorem
for b1 being Relation-like set holds
      b1 is TopStruct-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is TopStruct;

:: PENCIL_1:condreg 1
registration
  cluster Relation-like Function-like TopStruct-yielding -> 1-sorted-yielding (set);
end;

:: PENCIL_1:exreg 3
registration
  let a1 be set;
  cluster Relation-like Function-like TopStruct-yielding ManySortedSet of a1;
end;

:: PENCIL_1:exreg 4
registration
  cluster Relation-like Function-like TopStruct-yielding set;
end;

:: PENCIL_1:attrnot 12 => PENCIL_1:attr 12
definition
  let a1 be Relation-like set;
  attr a1 is non-void-yielding means
    for b1 being TopStruct
          st b1 in proj2 a1
       holds b1 is not void;
end;

:: PENCIL_1:dfs 14
definiens
  let a1 be Relation-like set;
To prove
     a1 is non-void-yielding
it is sufficient to prove
  thus for b1 being TopStruct
          st b1 in proj2 a1
       holds b1 is not void;

:: PENCIL_1:def 14
theorem
for b1 being Relation-like set holds
      b1 is non-void-yielding
   iff
      for b2 being TopStruct
            st b2 in proj2 b1
         holds b2 is not void;

:: PENCIL_1:attrnot 13 => PENCIL_1:attr 12
definition
  let a1 be Relation-like set;
  attr a1 is non-void-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is non void TopStruct;
end;

:: PENCIL_1:dfs 15
definiens
  let a1 be Relation-like Function-like TopStruct-yielding set;
To prove
     a1 is non-void-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is non void TopStruct;

:: PENCIL_1:def 15
theorem
for b1 being Relation-like Function-like TopStruct-yielding set holds
      b1 is non-void-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is non void TopStruct;

:: PENCIL_1:attrnot 14 => PENCIL_1:attr 13
definition
  let a1 be Relation-like set;
  attr a1 is trivial-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is trivial;
end;

:: PENCIL_1:dfs 16
definiens
  let a1 be Relation-like set;
To prove
     a1 is trivial-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is trivial;

:: PENCIL_1:def 16
theorem
for b1 being Relation-like set holds
      b1 is trivial-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is trivial;

:: PENCIL_1:attrnot 15 => PENCIL_1:attr 14
definition
  let a1 be Relation-like set;
  attr a1 is non-Trivial-yielding means
    for b1 being 1-sorted
          st b1 in proj2 a1
       holds b1 is not trivial;
end;

:: PENCIL_1:dfs 17
definiens
  let a1 be Relation-like set;
To prove
     a1 is non-Trivial-yielding
it is sufficient to prove
  thus for b1 being 1-sorted
          st b1 in proj2 a1
       holds b1 is not trivial;

:: PENCIL_1:def 17
theorem
for b1 being Relation-like set holds
      b1 is non-Trivial-yielding
   iff
      for b2 being 1-sorted
            st b2 in proj2 b1
         holds b2 is not trivial;

:: PENCIL_1:condreg 2
registration
  cluster Relation-like non-Trivial-yielding -> non-Empty (set);
end;

:: PENCIL_1:attrnot 16 => PENCIL_1:attr 14
definition
  let a1 be Relation-like set;
  attr a1 is non-Trivial-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is non trivial 1-sorted;
end;

:: PENCIL_1:dfs 18
definiens
  let a1 be Relation-like Function-like 1-sorted-yielding set;
To prove
     a1 is non-Trivial-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is non trivial 1-sorted;

:: PENCIL_1:def 18
theorem
for b1 being Relation-like Function-like 1-sorted-yielding set holds
      b1 is non-Trivial-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is non trivial 1-sorted;

:: PENCIL_1:funcnot 1 => PENCIL_1:func 1
definition
  let a1 be non empty set;
  let a2 be TopStruct-yielding ManySortedSet of a1;
  let a3 be Element of a1;
  redefine func a2 . a3 -> TopStruct;
end;

:: PENCIL_1:attrnot 17 => PENCIL_1:attr 15
definition
  let a1 be Relation-like set;
  attr a1 is PLS-yielding means
    for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty non void non degenerated with_non_trivial_blocks identifying_close_blocks TopStruct;
end;

:: PENCIL_1:dfs 19
definiens
  let a1 be Relation-like set;
To prove
     a1 is PLS-yielding
it is sufficient to prove
  thus for b1 being set
          st b1 in proj2 a1
       holds b1 is non empty non void non degenerated with_non_trivial_blocks identifying_close_blocks TopStruct;

:: PENCIL_1:def 19
theorem
for b1 being Relation-like set holds
      b1 is PLS-yielding
   iff
      for b2 being set
            st b2 in proj2 b1
         holds b2 is non empty non void non degenerated with_non_trivial_blocks identifying_close_blocks TopStruct;

:: PENCIL_1:condreg 3
registration
  cluster Relation-like Function-like PLS-yielding -> non-Empty TopStruct-yielding (set);
end;

:: PENCIL_1:condreg 4
registration
  cluster Relation-like Function-like TopStruct-yielding PLS-yielding -> non-void-yielding (set);
end;

:: PENCIL_1:condreg 5
registration
  cluster Relation-like Function-like TopStruct-yielding PLS-yielding -> non-Trivial-yielding (set);
end;

:: PENCIL_1:exreg 5
registration
  let a1 be set;
  cluster Relation-like Function-like PLS-yielding ManySortedSet of a1;
end;

:: PENCIL_1:funcnot 2 => PENCIL_1:func 2
definition
  let a1 be non empty set;
  let a2 be PLS-yielding ManySortedSet of a1;
  let a3 be Element of a1;
  redefine func a2 . a3 -> non empty non void non degenerated with_non_trivial_blocks identifying_close_blocks TopStruct;
end;

:: PENCIL_1:attrnot 18 => PENCIL_1:attr 16
definition
  let a1 be set;
  let a2 be ManySortedSet of a1;
  attr a2 is Segre-like means
    ex b1 being Element of a1 st
       for b2 being Element of a1
             st b1 <> b2
          holds a2 . b2 is not empty & a2 . b2 is trivial;
end;

:: PENCIL_1:dfs 20
definiens
  let a1 be set;
  let a2 be ManySortedSet of a1;
To prove
     a2 is Segre-like
it is sufficient to prove
  thus ex b1 being Element of a1 st
       for b2 being Element of a1
             st b1 <> b2
          holds a2 . b2 is not empty & a2 . b2 is trivial;

:: PENCIL_1:def 20
theorem
for b1 being set
for b2 being ManySortedSet of b1 holds
      b2 is Segre-like(b1)
   iff
      ex b3 being Element of b1 st
         for b4 being Element of b1
               st b3 <> b4
            holds b2 . b4 is not empty & b2 . b4 is trivial;

:: PENCIL_1:funcreg 2
registration
  let a1 be set;
  let a2 be ManySortedSet of a1;
  cluster {a2} -> trivial-yielding;
end;

:: PENCIL_1:th 9
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1
for b3 being Element of b1
for b4 being non trivial set holds
   b2 +*(b3,b4) is not trivial-yielding;

:: PENCIL_1:funcreg 3
registration
  let a1 be non empty set;
  let a2 be ManySortedSet of a1;
  cluster {a2} -> Segre-like;
end;

:: PENCIL_1:th 10
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1
for b3, b4 being set holds
{b2} +*(b3,b4) is Segre-like(b1);

:: PENCIL_1:th 11
theorem
for b1 being non empty set
for b2 being 1-sorted-yielding non-Empty ManySortedSet of b1
for b3 being Element of Carrier b2 holds
   {b3} is ManySortedSubset of Carrier b2;

:: PENCIL_1:exreg 6
registration
  let a1 be non empty set;
  let a2 be 1-sorted-yielding non-Empty ManySortedSet of a1;
  cluster Relation-like non-empty Function-like trivial-yielding Segre-like ManySortedSubset of Carrier a2;
end;

:: PENCIL_1:exreg 7
registration
  let a1 be non empty set;
  let a2 be 1-sorted-yielding non-Trivial-yielding ManySortedSet of a1;
  cluster Relation-like non-empty Function-like non trivial-yielding Segre-like ManySortedSubset of Carrier a2;
end;

:: PENCIL_1:exreg 8
registration
  let a1 be non empty set;
  cluster Relation-like Function-like non trivial-yielding Segre-like ManySortedSet of a1;
end;

:: PENCIL_1:funcnot 3 => PENCIL_1:func 3
definition
  let a1 be non empty set;
  let a2 be non trivial-yielding Segre-like ManySortedSet of a1;
  func indx A2 -> Element of a1 means
    a2 . it is not trivial;
end;

:: PENCIL_1:def 21
theorem
for b1 being non empty set
for b2 being non trivial-yielding Segre-like ManySortedSet of b1
for b3 being Element of b1 holds
      b3 = indx b2
   iff
      b2 . b3 is not trivial;

:: PENCIL_1:th 12
theorem
for b1 being non empty set
for b2 being non trivial-yielding Segre-like ManySortedSet of b1
for b3 being Element of b1
      st b3 <> indx b2
   holds b2 . b3 is not empty & b2 . b3 is trivial;

:: PENCIL_1:condreg 6
registration
  let a1 be non empty set;
  cluster non trivial-yielding Segre-like -> non-empty (ManySortedSet of a1);
end;

:: PENCIL_1:th 13
theorem
for b1 being non empty set
for b2 being ManySortedSet of b1 holds
      2 c= Card product b2
   iff
      b2 is non-empty & b2 is not trivial-yielding;

:: PENCIL_1:funcreg 4
registration
  let a1 be non empty set;
  let a2 be non trivial-yielding Segre-like ManySortedSet of a1;
  cluster product a2 -> non trivial;
end;

:: PENCIL_1:funcnot 4 => PENCIL_1:func 4
definition
  let a1 be non empty set;
  let a2 be non-Empty TopStruct-yielding ManySortedSet of a1;
  func Segre_Blocks A2 -> Element of bool bool product Carrier a2 means
    for b1 being set holds
          b1 in it
       iff
          ex b2 being Segre-like ManySortedSubset of Carrier a2 st
             b1 = product b2 &
              (ex b3 being Element of a1 st
                 b2 . b3 is Element of the topology of a2 . b3);
end;

:: PENCIL_1:def 22
theorem
for b1 being non empty set
for b2 being non-Empty TopStruct-yielding ManySortedSet of b1
for b3 being Element of bool bool product Carrier b2 holds
      b3 = Segre_Blocks b2
   iff
      for b4 being set holds
            b4 in b3
         iff
            ex b5 being Segre-like ManySortedSubset of Carrier b2 st
               b4 = product b5 &
                (ex b6 being Element of b1 st
                   b5 . b6 is Element of the topology of b2 . b6);

:: PENCIL_1:funcnot 5 => PENCIL_1:func 5
definition
  let a1 be non empty set;
  let a2 be non-Empty TopStruct-yielding ManySortedSet of a1;
  func Segre_Product A2 -> non empty TopStruct equals
    TopStruct(#product Carrier a2,Segre_Blocks a2#);
end;

:: PENCIL_1:def 23
theorem
for b1 being non empty set
for b2 being non-Empty TopStruct-yielding ManySortedSet of b1 holds
   Segre_Product b2 = TopStruct(#product Carrier b2,Segre_Blocks b2#);

:: PENCIL_1:th 14
theorem
for b1 being non empty set
for b2 being non-Empty TopStruct-yielding ManySortedSet of b1
for b3 being Element of the carrier of Segre_Product b2 holds
   b3 is ManySortedSet of b1;

:: PENCIL_1:th 15
theorem
for b1 being non empty set
for b2 being non-Empty TopStruct-yielding ManySortedSet of b1
      st ex b3 being Element of b1 st
           b2 . b3 is not void
   holds Segre_Product b2 is not void;

:: PENCIL_1:th 16
theorem
for b1 being non empty set
for b2 being non-Empty TopStruct-yielding ManySortedSet of b1
      st for b3 being Element of b1 holds
           b2 . b3 is not degenerated &
            (ex b4 being Element of b1 st
               b2 . b4 is not void)
   holds Segre_Product b2 is not degenerated;

:: PENCIL_1:th 17
theorem
for b1 being non empty set
for b2 being non-Empty TopStruct-yielding ManySortedSet of b1
      st for b3 being Element of b1 holds
           b2 . b3 is with_non_trivial_blocks &
            (ex b4 being Element of b1 st
               b2 . b4 is not void)
   holds Segre_Product b2 is with_non_trivial_blocks;

:: PENCIL_1:th 18
theorem
for b1 being non empty set
for b2 being non-Empty TopStruct-yielding ManySortedSet of b1
      st for b3 being Element of b1 holds
           b2 . b3 is identifying_close_blocks &
            b2 . b3 is with_non_trivial_blocks &
            (ex b4 being Element of b1 st
               b2 . b4 is not void)
   holds Segre_Product b2 is identifying_close_blocks;

:: PENCIL_1:funcnot 6 => PENCIL_1:func 6
definition
  let a1 be non empty set;
  let a2 be PLS-yielding ManySortedSet of a1;
  redefine func Segre_Product a2 -> non empty non void non degenerated with_non_trivial_blocks identifying_close_blocks TopStruct;
end;

:: PENCIL_1:th 19
theorem
for b1 being TopStruct
for b2 being Element of bool the carrier of b1
      st b2 is trivial
   holds b2 is strong(b1) & b2 is closed_under_lines(b1);

:: PENCIL_1:th 20
theorem
for b1 being identifying_close_blocks TopStruct
for b2 being Element of the topology of b1
for b3 being Element of bool the carrier of b1
      st b3 = b2
   holds b3 is closed_under_lines(b1);

:: PENCIL_1:th 21
theorem
for b1 being TopStruct
for b2 being Element of the topology of b1
for b3 being Element of bool the carrier of b1
      st b3 = b2
   holds b3 is strong(b1);

:: PENCIL_1:th 22
theorem
for b1 being non void TopStruct holds
   [#] b1 is closed_under_lines(b1);

:: PENCIL_1:th 23
theorem
for b1 being non empty set
for b2 being non trivial-yielding Segre-like ManySortedSet of b1
for b3, b4 being ManySortedSet of b1
   st b3 in product b2 & b4 in product b2
for b5 being set
      st b5 <> indx b2
   holds b3 . b5 = b4 . b5;

:: PENCIL_1:th 24
theorem
for b1 being non empty set
for b2 being PLS-yielding ManySortedSet of b1
for b3 being set holds
      b3 is Element of the topology of Segre_Product b2
   iff
      ex b4 being non trivial-yielding Segre-like ManySortedSubset of Carrier b2 st
         b3 = product b4 &
          b4 . indx b4 is Element of the topology of b2 . indx b4;

:: PENCIL_1:th 25
theorem
for b1 being non empty set
for b2 being PLS-yielding ManySortedSet of b1
for b3 being ManySortedSet of b1
   st b3 is Element of the carrier of Segre_Product b2
for b4 being Element of b1
for b5 being Element of the carrier of b2 . b4 holds
   b3 +*(b4,b5) is Element of the carrier of Segre_Product b2;

:: PENCIL_1:th 26
theorem
for b1 being non empty set
for b2, b3 being non trivial-yielding Segre-like ManySortedSet of b1
      st 2 c= Card ((product b2) /\ product b3)
   holds indx b2 = indx b3 &
    (for b4 being set
          st b4 <> indx b2
       holds b2 . b4 = b3 . b4);

:: PENCIL_1:th 27
theorem
for b1 being non empty set
for b2 being non trivial-yielding Segre-like ManySortedSet of b1
for b3 being non trivial set holds
   b2 +*(indx b2,b3) is Segre-like(b1) & b2 +*(indx b2,b3) is not trivial-yielding;

:: PENCIL_1:th 28
theorem
for b1 being non empty non void identifying_close_blocks without_isolated_points TopStruct
      st b1 is strongly_connected
   holds b1 is connected;

:: PENCIL_1:th 29
theorem
for b1 being non empty set
for b2 being PLS-yielding ManySortedSet of b1
for b3 being Element of bool the carrier of Segre_Product b2 holds
      b3 is not trivial & b3 is strong(Segre_Product b2) & b3 is closed_under_lines(Segre_Product b2)
   iff
      ex b4 being non trivial-yielding Segre-like ManySortedSubset of Carrier b2 st
         b3 = product b4 &
          (for b5 being Element of bool the carrier of b2 . indx b4
                st b5 = b4 . indx b4
             holds b5 is strong(b2 . indx b4) & b5 is closed_under_lines(b2 . indx b4));