Article DYNKIN, MML version 4.99.1005

:: DYNKIN:th 1
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1
for b3 being set holds
      b3 in proj2 b2
   iff
      ex b4 being Element of NAT st
         b2 . b4 = b3;

:: DYNKIN:th 2
theorem
for b1 being Element of NAT holds
   b1 is finite;

:: DYNKIN:funcreg 1
registration
  let a1 be Element of NAT;
  cluster Segm a1 -> finite;
end;

:: DYNKIN:funcnot 1 => DYNKIN:func 1
definition
  let a1, a2, a3 be set;
  func (A1,A2)followed_by A3 -> set equals
    (NAT --> a3) +* ((0,1)-->(a1,a2));
end;

:: DYNKIN:def 1
theorem
for b1, b2, b3 being set holds
(b1,b2)followed_by b3 = (NAT --> b3) +* ((0,1)-->(b1,b2));

:: DYNKIN:funcreg 2
registration
  let a1, a2, a3 be set;
  cluster (a1,a2)followed_by a3 -> Relation-like Function-like;
end;

:: DYNKIN:funcnot 2 => DYNKIN:func 2
definition
  let a1 be non empty set;
  let a2, a3, a4 be Element of a1;
  redefine func (a2,a3)followed_by a4 -> Function-like quasi_total Relation of NAT,a1;
end;

:: DYNKIN:funcnot 3 => DYNKIN:func 3
definition
  let a1 be non empty set;
  let a2, a3, a4 be Element of bool a1;
  redefine func (a2,a3)followed_by a4 -> Function-like quasi_total Relation of NAT,bool a1;
end;

:: DYNKIN:th 5
theorem
for b1, b2, b3 being set holds
((b1,b2)followed_by b3) . 0 = b1 &
 ((b1,b2)followed_by b3) . 1 = b2 &
 (for b4 being Element of NAT
       st b4 <> 0 & b4 <> 1
    holds ((b1,b2)followed_by b3) . b4 = b3);

:: DYNKIN:th 6
theorem
for b1 being non empty set
for b2, b3 being Element of bool b1 holds
union proj2 ((b2,b3)followed_by {}) = b2 \/ b3;

:: DYNKIN:funcnot 4 => DYNKIN:func 4
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of NAT,bool a1;
  let a3 be Element of bool a1;
  func seqIntersection(A3,A2) -> Function-like quasi_total Relation of NAT,bool a1 means
    for b1 being Element of NAT holds
       it . b1 = a3 /\ (a2 . b1);
end;

:: DYNKIN:def 2
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1
for b3 being Element of bool b1
for b4 being Function-like quasi_total Relation of NAT,bool b1 holds
      b4 = seqIntersection(b3,b2)
   iff
      for b5 being Element of NAT holds
         b4 . b5 = b3 /\ (b2 . b5);

:: DYNKIN:attrnot 1 => DYNKIN:attr 1
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of NAT,bool a1;
  redefine attr a2 is disjoint_valued means
    for b1, b2 being Element of NAT
          st b1 < b2
       holds a2 . b1 misses a2 . b2;
end;

:: DYNKIN:dfs 3
definiens
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of NAT,bool a1;
To prove
     a1 is disjoint_valued
it is sufficient to prove
  thus for b1, b2 being Element of NAT
          st b1 < b2
       holds a2 . b1 misses a2 . b2;

:: DYNKIN:def 3
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1 holds
      b2 is disjoint_valued
   iff
      for b3, b4 being Element of NAT
            st b3 < b4
         holds b2 . b3 misses b2 . b4;

:: DYNKIN:th 7
theorem
for b1 being non empty set
for b2 being set holds
      b2 c= meet b1
   iff
      for b3 being Element of b1 holds
         b2 c= b3;

:: DYNKIN:attrnot 2 => FINSUB_1:attr 2
notation
  let a1 be set;
  synonym intersection_stable for cap-closed;
end;

:: DYNKIN:funcnot 5 => DYNKIN:func 5
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of NAT,bool a1;
  let a3 be natural set;
  func disjointify(A2,A3) -> Element of bool a1 equals
    (a2 . a3) \ union proj2 (a2 | a3);
end;

:: DYNKIN:def 5
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1
for b3 being natural set holds
   disjointify(b2,b3) = (b2 . b3) \ union proj2 (b2 | b3);

:: DYNKIN:funcnot 6 => DYNKIN:func 6
definition
  let a1 be non empty set;
  let a2 be Function-like quasi_total Relation of NAT,bool a1;
  func disjointify A2 -> Function-like quasi_total Relation of NAT,bool a1 means
    for b1 being natural set holds
       it . b1 = disjointify(a2,b1);
end;

:: DYNKIN:def 6
theorem
for b1 being non empty set
for b2, b3 being Function-like quasi_total Relation of NAT,bool b1 holds
   b3 = disjointify b2
iff
   for b4 being natural set holds
      b3 . b4 = disjointify(b2,b4);

:: DYNKIN:th 8
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1
for b3 being natural set holds
   (disjointify b2) . b3 = (b2 . b3) \ union proj2 (b2 | b3);

:: DYNKIN:th 9
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1 holds
   disjointify b2 is disjoint_valued;

:: DYNKIN:th 10
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1 holds
   union proj2 disjointify b2 = union proj2 b2;

:: DYNKIN:th 11
theorem
for b1 being non empty set
for b2, b3 being Element of bool b1
      st b2 misses b3
   holds (b2,b3)followed_by {} b1 is disjoint_valued;

:: DYNKIN:th 12
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1
   st b2 is disjoint_valued
for b3 being Element of bool b1 holds
   seqIntersection(b3,b2) is disjoint_valued;

:: DYNKIN:th 13
theorem
for b1 being non empty set
for b2 being Function-like quasi_total Relation of NAT,bool b1
for b3 being Element of bool b1 holds
   b3 /\ Union b2 = Union seqIntersection(b3,b2);

:: DYNKIN:modenot 1 => DYNKIN:mode 1
definition
  let a1 be non empty set;
  mode Dynkin_System of A1 -> Element of bool bool a1 means
    (for b1 being Function-like quasi_total Relation of NAT,bool a1
           st proj2 b1 c= it & b1 is disjoint_valued
        holds Union b1 in it) &
     (for b1 being Element of bool a1
           st b1 in it
        holds b1 ` in it) &
     {} in it;
end;

:: DYNKIN:dfs 6
definiens
  let a1 be non empty set;
  let a2 be Element of bool bool a1;
To prove
     a2 is Dynkin_System of a1
it is sufficient to prove
  thus (for b1 being Function-like quasi_total Relation of NAT,bool a1
           st proj2 b1 c= a2 & b1 is disjoint_valued
        holds Union b1 in a2) &
     (for b1 being Element of bool a1
           st b1 in a2
        holds b1 ` in a2) &
     {} in a2;

:: DYNKIN:def 7
theorem
for b1 being non empty set
for b2 being Element of bool bool b1 holds
      b2 is Dynkin_System of b1
   iff
      (for b3 being Function-like quasi_total Relation of NAT,bool b1
             st proj2 b3 c= b2 & b3 is disjoint_valued
          holds Union b3 in b2) &
       (for b3 being Element of bool b1
             st b3 in b2
          holds b3 ` in b2) &
       {} in b2;

:: DYNKIN:condreg 1
registration
  let a1 be non empty set;
  cluster -> non empty (Dynkin_System of a1);
end;

:: DYNKIN:th 14
theorem
for b1 being non empty set holds
   bool b1 is Dynkin_System of b1;

:: DYNKIN:th 15
theorem
for b1, b2 being non empty set
      st for b3 being set
              st b3 in b1
           holds b3 is Dynkin_System of b2
   holds meet b1 is Dynkin_System of b2;

:: DYNKIN:th 16
theorem
for b1 being non empty set
for b2, b3 being Element of bool b1
for b4 being non empty Element of bool bool b1
      st b4 is Dynkin_System of b1 & b4 is cap-closed & b2 in b4 & b3 in b4
   holds b2 \ b3 in b4;

:: DYNKIN:th 17
theorem
for b1 being non empty set
for b2, b3 being Element of bool b1
for b4 being non empty Element of bool bool b1
      st b4 is Dynkin_System of b1 & b4 is cap-closed & b2 in b4 & b3 in b4
   holds b2 \/ b3 in b4;

:: DYNKIN:th 18
theorem
for b1 being non empty set
for b2 being non empty Element of bool bool b1
   st b2 is Dynkin_System of b1 & b2 is cap-closed
for b3 being finite set
      st b3 c= b2
   holds union b3 in b2;

:: DYNKIN:th 19
theorem
for b1 being non empty set
for b2 being non empty Element of bool bool b1
   st b2 is Dynkin_System of b1 & b2 is cap-closed
for b3 being Function-like quasi_total Relation of NAT,bool b1
      st proj2 b3 c= b2
   holds proj2 disjointify b3 c= b2;

:: DYNKIN:th 20
theorem
for b1 being non empty set
for b2 being non empty Element of bool bool b1
   st b2 is Dynkin_System of b1 & b2 is cap-closed
for b3 being Function-like quasi_total Relation of NAT,bool b1
      st proj2 b3 c= b2
   holds union proj2 b3 in b2;

:: DYNKIN:th 21
theorem
for b1 being non empty set
for b2 being Dynkin_System of b1
for b3, b4 being Element of b2
      st b3 misses b4
   holds b3 \/ b4 in b2;

:: DYNKIN:th 22
theorem
for b1 being non empty set
for b2 being Dynkin_System of b1
for b3, b4 being Element of b2
      st b3 c= b4
   holds b4 \ b3 in b2;

:: DYNKIN:th 23
theorem
for b1 being non empty set
for b2 being non empty Element of bool bool b1
      st b2 is Dynkin_System of b1 & b2 is cap-closed
   holds b2 is non empty compl-closed sigma-multiplicative Element of bool bool b1;

:: DYNKIN:funcnot 7 => DYNKIN:func 7
definition
  let a1 be non empty set;
  let a2 be Element of bool bool a1;
  func generated_Dynkin_System A2 -> Dynkin_System of a1 means
    a2 c= it &
     (for b1 being Dynkin_System of a1
           st a2 c= b1
        holds it c= b1);
end;

:: DYNKIN:def 8
theorem
for b1 being non empty set
for b2 being Element of bool bool b1
for b3 being Dynkin_System of b1 holds
      b3 = generated_Dynkin_System b2
   iff
      b2 c= b3 &
       (for b4 being Dynkin_System of b1
             st b2 c= b4
          holds b3 c= b4);

:: DYNKIN:funcnot 8 => DYNKIN:func 8
definition
  let a1 be non empty set;
  let a2 be set;
  let a3 be Element of bool a1;
  func DynSys(A3,A2) -> Element of bool bool a1 means
    for b1 being Element of bool a1 holds
          b1 in it
       iff
          b1 /\ a3 in a2;
end;

:: DYNKIN:def 9
theorem
for b1 being non empty set
for b2 being set
for b3 being Element of bool b1
for b4 being Element of bool bool b1 holds
      b4 = DynSys(b3,b2)
   iff
      for b5 being Element of bool b1 holds
            b5 in b4
         iff
            b5 /\ b3 in b2;

:: DYNKIN:funcnot 9 => DYNKIN:func 9
definition
  let a1 be non empty set;
  let a2 be Dynkin_System of a1;
  let a3 be Element of a2;
  redefine func DynSys(a3,a2) -> Dynkin_System of a1;
end;

:: DYNKIN:th 24
theorem
for b1 being non empty set
for b2 being Element of bool bool b1
for b3, b4 being Element of bool b1
      st b3 in b2 & b4 in generated_Dynkin_System b2 & b2 is cap-closed
   holds b3 /\ b4 in generated_Dynkin_System b2;

:: DYNKIN:th 25
theorem
for b1 being non empty set
for b2 being Element of bool bool b1
for b3, b4 being Element of bool b1
      st b3 in generated_Dynkin_System b2 & b4 in generated_Dynkin_System b2 & b2 is cap-closed
   holds b3 /\ b4 in generated_Dynkin_System b2;

:: DYNKIN:th 26
theorem
for b1 being non empty set
for b2 being Element of bool bool b1
      st b2 is cap-closed
   holds generated_Dynkin_System b2 is cap-closed;

:: DYNKIN:th 27
theorem
for b1 being non empty set
for b2 being Element of bool bool b1
   st b2 is cap-closed
for b3 being Dynkin_System of b1
      st b2 c= b3
   holds sigma b2 c= b3;