Article ARMSTRNG, MML version 4.99.1005

:: ARMSTRNG:th 1
theorem
for b1 being set
   st b1 is cap-closed
for b2 being set
for b3 being finite Element of bool bool b2
      st b2 in b1 & b3 c= b1
   holds Intersect b3 in b1;

:: ARMSTRNG:exreg 1
registration
  cluster non empty Relation-like reflexive antisymmetric transitive set;
end;

:: ARMSTRNG:th 2
theorem
for b1 being non empty Relation-like antisymmetric transitive set
for b2 being finite Element of bool field b1
      st b2 <> {}
   holds ex b3 being Element of b2 st
      b3 is_maximal_wrt b2,b1;

:: ARMSTRNG:sch 1
scheme ARMSTRNG:sch 1
{F1 -> set}:
for b1, b2 being Element of bool F1()
      st (for b3 being set holds
               b3 in b1
            iff
               P1[b3]) &
         (for b3 being set holds
               b3 in b2
            iff
               P1[b3])
   holds b1 = b2


:: ARMSTRNG:funcnot 1 => ARMSTRNG:func 1
definition
  let a1 be set;
  let a2 be Relation-like set;
  func A2 Maximal_in A1 -> Element of bool a1 means
    for b1 being set holds
          b1 in it
       iff
          b1 is_maximal_wrt a1,a2;
end;

:: ARMSTRNG:def 1
theorem
for b1 being set
for b2 being Relation-like set
for b3 being Element of bool b1 holds
      b3 = b2 Maximal_in b1
   iff
      for b4 being set holds
            b4 in b3
         iff
            b4 is_maximal_wrt b1,b2;

:: ARMSTRNG:prednot 1 => ARMSTRNG:pred 1
definition
  let a1, a2 be set;
  pred A1 is_/\-irreducible_in A2 means
    a1 in a2 &
     (for b1, b2 being set
           st b1 in a2 & b2 in a2 & a1 = b1 /\ b2 & a1 <> b1
        holds a1 = b2);
end;

:: ARMSTRNG:dfs 2
definiens
  let a1, a2 be set;
To prove
     a1 is_/\-irreducible_in a2
it is sufficient to prove
  thus a1 in a2 &
     (for b1, b2 being set
           st b1 in a2 & b2 in a2 & a1 = b1 /\ b2 & a1 <> b1
        holds a1 = b2);

:: ARMSTRNG:def 2
theorem
for b1, b2 being set holds
   b1 is_/\-irreducible_in b2
iff
   b1 in b2 &
    (for b3, b4 being set
          st b3 in b2 & b4 in b2 & b1 = b3 /\ b4 & b1 <> b3
       holds b1 = b4);

:: ARMSTRNG:prednot 2 => not ARMSTRNG:pred 1
notation
  let a1, a2 be set;
  antonym a1 is_/\-reducible_in a2 for a1 is_/\-irreducible_in a2;
end;

:: ARMSTRNG:funcnot 2 => ARMSTRNG:func 2
definition
  let a1 be non empty set;
  func /\-IRR A1 -> Element of bool a1 means
    for b1 being set holds
          b1 in it
       iff
          b1 is_/\-irreducible_in a1;
end;

:: ARMSTRNG:def 3
theorem
for b1 being non empty set
for b2 being Element of bool b1 holds
      b2 = /\-IRR b1
   iff
      for b3 being set holds
            b3 in b2
         iff
            b3 is_/\-irreducible_in b1;

:: ARMSTRNG:sch 2
scheme ARMSTRNG:sch 2
{F1 -> non empty finite set}:
for b1 being set
      st b1 in F1()
   holds P1[b1]
provided
   for b1 being set
         st b1 is_/\-irreducible_in F1()
      holds P1[b1]
and
   for b1, b2 being set
         st b1 in F1() & b2 in F1() & P1[b1] & P1[b2]
      holds P1[b1 /\ b2];


:: ARMSTRNG:th 3
theorem
for b1 being non empty finite set
for b2 being Element of b1 holds
   ex b3 being non empty Element of bool b1 st
      b2 = meet b3 &
       (for b4 being set
             st b4 in b3
          holds b4 is_/\-irreducible_in b1);

:: ARMSTRNG:attrnot 1 => ARMSTRNG:attr 1
definition
  let a1 be set;
  let a2 be Element of bool bool a1;
  attr a2 is (B1) means
    a1 in a2;
end;

:: ARMSTRNG:dfs 4
definiens
  let a1 be set;
  let a2 be Element of bool bool a1;
To prove
     a2 is (B1)
it is sufficient to prove
  thus a1 in a2;

:: ARMSTRNG:def 4
theorem
for b1 being set
for b2 being Element of bool bool b1 holds
      b2 is (B1)(b1)
   iff
      b1 in b2;

:: ARMSTRNG:attrnot 2 => FINSUB_1:attr 2
notation
  let a1 be set;
  synonym (B2) for cap-closed;
end;

:: ARMSTRNG:exreg 2
registration
  let a1 be set;
  cluster cap-closed (B1) Element of bool bool a1;
end;

:: ARMSTRNG:th 4
theorem
for b1 being set
for b2 being non empty Element of bool bool b1
   st b2 is cap-closed
for b3 being Element of b2
   st b3 is_/\-irreducible_in b2 & b3 <> b1
for b4 being finite Element of bool bool b1
      st b4 c= b2 & b3 = Intersect b4
   holds b3 in b4;

:: ARMSTRNG:condreg 1
registration
  let a1, a2 be non empty set;
  let a3 be Element of NAT;
  cluster Function-like quasi_total -> FinSequence-yielding (Relation of a1,a3 -tuples_on a2);
end;

:: ARMSTRNG:funcreg 1
registration
  let a1 be Relation-like Function-like FinSequence-yielding set;
  let a2 be set;
  cluster a1 . a2 -> FinSequence-like;
end;

:: ARMSTRNG:funcnot 3 => ARMSTRNG:func 3
definition
  let a1 be Element of NAT;
  let a2, a3 be Element of a1 -tuples_on BOOLEAN;
  func A2 '&' A3 -> Element of a1 -tuples_on BOOLEAN means
    for b1 being set
          st b1 in Seg a1
       holds it . b1 = (a2 /. b1) '&' (a3 /. b1);
  commutativity;
::  for a1 being Element of NAT
::  for a2, a3 being Element of a1 -tuples_on BOOLEAN holds
::  a2 '&' a3 = a3 '&' a2;
end;

:: ARMSTRNG:def 5
theorem
for b1 being Element of NAT
for b2, b3, b4 being Element of b1 -tuples_on BOOLEAN holds
   b4 = b2 '&' b3
iff
   for b5 being set
         st b5 in Seg b1
      holds b4 . b5 = (b2 /. b5) '&' (b3 /. b5);

:: ARMSTRNG:th 5
theorem
for b1 being Element of NAT
for b2 being Element of b1 -tuples_on BOOLEAN holds
   (b1 -BinarySequence 0) '&' b2 = b1 -BinarySequence 0;

:: ARMSTRNG:th 6
theorem
for b1 being Element of NAT
for b2 being Element of b1 -tuples_on BOOLEAN holds
   ('not' (b1 -BinarySequence 0)) '&' b2 = b2;

:: ARMSTRNG:th 8
theorem
for b1, b2 being Element of NAT
      st b2 < b1
   holds (b1 -BinarySequence (2 to_power b2)) . (b2 + 1) = 1 &
    (for b3 being Element of NAT
          st b3 in Seg b1 & b3 <> b2 + 1
       holds (b1 -BinarySequence (2 to_power b2)) . b3 = 0);

:: ARMSTRNG:structnot 1 => ARMSTRNG:struct 1
definition
  struct() DB-Rel(#
    Attributes -> non empty finite set,
    Domains -> non-empty ManySortedSet of the Attributes of it,
    Relationship -> Element of bool product the Domains of it
  #);
end;

:: ARMSTRNG:attrnot 3 => ARMSTRNG:attr 2
definition
  let a1 be DB-Rel;
  attr a1 is strict;
end;

:: ARMSTRNG:exreg 3
registration
  cluster strict DB-Rel;
end;

:: ARMSTRNG:aggrnot 1 => ARMSTRNG:aggr 1
definition
  let a1 be non empty finite set;
  let a2 be non-empty ManySortedSet of a1;
  let a3 be Element of bool product a2;
  aggr DB-Rel(#a1,a2,a3#) -> strict DB-Rel;
end;

:: ARMSTRNG:selnot 1 => ARMSTRNG:sel 1
definition
  let a1 be DB-Rel;
  sel the Attributes of a1 -> non empty finite set;
end;

:: ARMSTRNG:selnot 2 => ARMSTRNG:sel 2
definition
  let a1 be DB-Rel;
  sel the Domains of a1 -> non-empty ManySortedSet of the Attributes of a1;
end;

:: ARMSTRNG:selnot 3 => ARMSTRNG:sel 3
definition
  let a1 be DB-Rel;
  sel the Relationship of a1 -> Element of bool product the Domains of a1;
end;

:: ARMSTRNG:modenot 1
definition
  let a1 be set;
  mode Subset-Relation of a1 is Relation of bool a1,bool a1;
end;

:: ARMSTRNG:modenot 2
definition
  let a1 be set;
  mode Dependency-set of a1 is Relation of bool a1,bool a1;
end;

:: ARMSTRNG:exreg 4
registration
  let a1 be set;
  cluster non empty Relation-like finite Relation of bool a1,bool a1;
end;

:: ARMSTRNG:funcnot 4 => ARMSTRNG:func 4
definition
  let a1 be set;
  func Dependencies A1 -> Relation of bool a1,bool a1 equals
    [:bool a1,bool a1:];
end;

:: ARMSTRNG:def 7
theorem
for b1 being set holds
   Dependencies b1 = [:bool b1,bool b1:];

:: ARMSTRNG:modenot 3
definition
  let a1 be set;
  mode Dependency of a1 is Element of Dependencies a1;
end;

:: ARMSTRNG:funcreg 2
registration
  let a1 be set;
  cluster Dependencies a1 -> non empty;
end;

:: ARMSTRNG:modenot 4 => ARMSTRNG:mode 1
definition
  let a1 be set;
  let a2 be non empty Relation of bool a1,bool a1;
  redefine mode Element of a2 -> Element of Dependencies a1;
end;

:: ARMSTRNG:th 9
theorem
for b1, b2 being set holds
   b2 in Dependencies b1
iff
   ex b3, b4 being Element of bool b1 st
      b2 = [b3,b4];

:: ARMSTRNG:th 10
theorem
for b1, b2 being set
for b3 being Relation of bool b1,bool b1
      st b2 in b3
   holds ex b4, b5 being Element of bool b1 st
      b2 = [b4,b5];

:: ARMSTRNG:prednot 3 => ARMSTRNG:pred 2
definition
  let a1 be DB-Rel;
  let a2, a3 be Element of bool the Attributes of a1;
  pred A2 >|> A3,A1 means
    for b1, b2 being Element of the Relationship of a1
          st b1 | a2 = b2 | a2
       holds b1 | a3 = b2 | a3;
end;

:: ARMSTRNG:dfs 7
definiens
  let a1 be DB-Rel;
  let a2, a3 be Element of bool the Attributes of a1;
To prove
     a2 >|> a3,a1
it is sufficient to prove
  thus for b1, b2 being Element of the Relationship of a1
          st b1 | a2 = b2 | a2
       holds b1 | a3 = b2 | a3;

:: ARMSTRNG:def 8
theorem
for b1 being DB-Rel
for b2, b3 being Element of bool the Attributes of b1 holds
   b2 >|> b3,b1
iff
   for b4, b5 being Element of the Relationship of b1
         st b4 | b2 = b5 | b2
      holds b4 | b3 = b5 | b3;

:: ARMSTRNG:prednot 4 => ARMSTRNG:pred 2
notation
  let a1 be DB-Rel;
  let a2, a3 be Element of bool the Attributes of a1;
  synonym a2,a3 holds_in a1 for a2 >|> a3,a1;
end;

:: ARMSTRNG:funcnot 5 => ARMSTRNG:func 5
definition
  let a1 be DB-Rel;
  func Dependency-str A1 -> Relation of bool the Attributes of a1,bool the Attributes of a1 equals
    {[b1,b2] where b1 is Element of bool the Attributes of a1, b2 is Element of bool the Attributes of a1: b1 >|> b2,a1};
end;

:: ARMSTRNG:def 9
theorem
for b1 being DB-Rel holds
   Dependency-str b1 = {[b2,b3] where b2 is Element of bool the Attributes of b1, b3 is Element of bool the Attributes of b1: b2 >|> b3,b1};

:: ARMSTRNG:th 12
theorem
for b1 being DB-Rel
for b2, b3 being Element of bool the Attributes of b1 holds
   [b2,b3] in Dependency-str b1
iff
   b2 >|> b3,b1;

:: ARMSTRNG:prednot 5 => ARMSTRNG:pred 3
definition
  let a1 be set;
  let a2, a3 be Element of Dependencies a1;
  pred A2 >= A3 means
    a2 `1 c= a3 `1 & a3 `2 c= a2 `2;
  reflexivity;
::  for a1 being set
::  for a2 being Element of Dependencies a1 holds
::     a2 >= a2;
end;

:: ARMSTRNG:dfs 9
definiens
  let a1 be set;
  let a2, a3 be Element of Dependencies a1;
To prove
     a2 >= a3
it is sufficient to prove
  thus a2 `1 c= a3 `1 & a3 `2 c= a2 `2;

:: ARMSTRNG:def 10
theorem
for b1 being set
for b2, b3 being Element of Dependencies b1 holds
   b2 >= b3
iff
   b2 `1 c= b3 `1 & b3 `2 c= b2 `2;

:: ARMSTRNG:prednot 6 => ARMSTRNG:pred 3
notation
  let a1 be set;
  let a2, a3 be Element of Dependencies a1;
  synonym a3 <= a2 for a2 >= a3;
end;

:: ARMSTRNG:prednot 7 => ARMSTRNG:pred 3
notation
  let a1 be set;
  let a2, a3 be Element of Dependencies a1;
  synonym a2 is_at_least_as_informative_as a3 for a2 >= a3;
end;

:: ARMSTRNG:th 13
theorem
for b1 being set
for b2, b3 being Element of Dependencies b1
      st b3 >= b2 & b2 >= b3
   holds b2 = b3;

:: ARMSTRNG:th 14
theorem
for b1 being set
for b2, b3, b4 being Element of Dependencies b1
      st b3 >= b2 & b4 >= b3
   holds b4 >= b2;

:: ARMSTRNG:funcnot 6 => ARMSTRNG:func 6
definition
  let a1 be set;
  let a2, a3 be Element of bool a1;
  redefine func [a2, a3] -> Element of Dependencies a1;
end;

:: ARMSTRNG:th 15
theorem
for b1 being set
for b2, b3, b4, b5 being Element of bool b1 holds
   [b2,b3] >= [b4,b5]
iff
   b2 c= b4 & b5 c= b3;

:: ARMSTRNG:funcnot 7 => ARMSTRNG:func 7
definition
  let a1 be set;
  func Dependencies-Order A1 -> Relation of Dependencies a1,Dependencies a1 equals
    {[b1,b2] where b1 is Element of Dependencies a1, b2 is Element of Dependencies a1: b2 >= b1};
end;

:: ARMSTRNG:def 11
theorem
for b1 being set holds
   Dependencies-Order b1 = {[b2,b3] where b2 is Element of Dependencies b1, b3 is Element of Dependencies b1: b3 >= b2};

:: ARMSTRNG:th 16
theorem
for b1, b2 being set holds
   b2 in Dependencies-Order b1
iff
   ex b3, b4 being Element of Dependencies b1 st
      b2 = [b3,b4] & b4 >= b3;

:: ARMSTRNG:th 17
theorem
for b1 being set holds
   dom Dependencies-Order b1 = [:bool b1,bool b1:];

:: ARMSTRNG:th 18
theorem
for b1 being set holds
   rng Dependencies-Order b1 = [:bool b1,bool b1:];

:: ARMSTRNG:th 19
theorem
for b1 being set holds
   field Dependencies-Order b1 = [:bool b1,bool b1:];

:: ARMSTRNG:funcreg 3
registration
  let a1 be set;
  cluster Dependencies-Order a1 -> non empty;
end;

:: ARMSTRNG:funcreg 4
registration
  let a1 be set;
  cluster Dependencies-Order a1 -> total reflexive antisymmetric transitive;
end;

:: ARMSTRNG:attrnot 4 => RELAT_2:attr 8
notation
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  synonym (F2) for transitive;
end;

:: ARMSTRNG:attrnot 5 => RELAT_2:attr 8
notation
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  synonym (DC1) for transitive;
end;

:: ARMSTRNG:attrnot 6 => ARMSTRNG:attr 3
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (F1) means
    for b1 being Element of bool a1 holds
       [b1,b1] in a2;
end;

:: ARMSTRNG:dfs 11
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (F1)
it is sufficient to prove
  thus for b1 being Element of bool a1 holds
       [b1,b1] in a2;

:: ARMSTRNG:def 12
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (F1)(b1)
   iff
      for b3 being Element of bool b1 holds
         [b3,b3] in b2;

:: ARMSTRNG:attrnot 7 => ARMSTRNG:attr 3
notation
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  synonym (DC2) for (F1);
end;

:: ARMSTRNG:th 20
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is transitive
   iff
      for b3, b4, b5 being Element of bool b1
            st [b3,b4] in b2 & [b4,b5] in b2
         holds [b3,b5] in b2;

:: ARMSTRNG:attrnot 8 => ARMSTRNG:attr 4
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (F3) means
    for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b1,b2] >= [b3,b4]
       holds [b3,b4] in a2;
end;

:: ARMSTRNG:dfs 12
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (F3)
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b1,b2] >= [b3,b4]
       holds [b3,b4] in a2;

:: ARMSTRNG:def 13
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (F3)(b1)
   iff
      for b3, b4, b5, b6 being Element of bool b1
            st [b3,b4] in b2 & [b3,b4] >= [b5,b6]
         holds [b5,b6] in b2;

:: ARMSTRNG:attrnot 9 => ARMSTRNG:attr 5
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (F4) means
    for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b3,b4] in a2
       holds [b1 \/ b3,b2 \/ b4] in a2;
end;

:: ARMSTRNG:dfs 13
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (F4)
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b3,b4] in a2
       holds [b1 \/ b3,b2 \/ b4] in a2;

:: ARMSTRNG:def 14
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (F4)(b1)
   iff
      for b3, b4, b5, b6 being Element of bool b1
            st [b3,b4] in b2 & [b5,b6] in b2
         holds [b3 \/ b5,b4 \/ b6] in b2;

:: ARMSTRNG:th 21
theorem
for b1 being set holds
   Dependencies b1 is (F1)(b1) & Dependencies b1 is transitive & Dependencies b1 is (F3)(b1) & Dependencies b1 is (F4)(b1);

:: ARMSTRNG:exreg 5
registration
  let a1 be set;
  cluster non empty Relation-like transitive (F1) (F3) (F4) Relation of bool a1,bool a1;
end;

:: ARMSTRNG:attrnot 10 => ARMSTRNG:attr 6
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is full_family means
    a2 is (F1)(a1) & a2 is transitive & a2 is (F3)(a1) & a2 is (F4)(a1);
end;

:: ARMSTRNG:dfs 14
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is full_family
it is sufficient to prove
  thus a2 is (F1)(a1) & a2 is transitive & a2 is (F3)(a1) & a2 is (F4)(a1);

:: ARMSTRNG:def 15
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is full_family(b1)
   iff
      b2 is (F1)(b1) & b2 is transitive & b2 is (F3)(b1) & b2 is (F4)(b1);

:: ARMSTRNG:exreg 6
registration
  let a1 be set;
  cluster Relation-like full_family Relation of bool a1,bool a1;
end;

:: ARMSTRNG:modenot 5
definition
  let a1 be set;
  mode Full-family of a1 is full_family Relation of bool a1,bool a1;
end;

:: ARMSTRNG:th 22
theorem
for b1 being finite set
for b2 being Relation of bool b1,bool b1 holds
   b2 is finite;

:: ARMSTRNG:exreg 7
registration
  let a1 be finite set;
  cluster Relation-like finite full_family Relation of bool a1,bool a1;
end;

:: ARMSTRNG:condreg 2
registration
  let a1 be finite set;
  cluster -> finite (Relation of bool a1,bool a1);
end;

:: ARMSTRNG:condreg 3
registration
  let a1 be set;
  cluster full_family -> transitive (F1) (F3) (F4) (Relation of bool a1,bool a1);
end;

:: ARMSTRNG:condreg 4
registration
  let a1 be set;
  cluster transitive (F1) (F3) (F4) -> full_family (Relation of bool a1,bool a1);
end;

:: ARMSTRNG:attrnot 11 => ARMSTRNG:attr 7
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (DC3) means
    for b1, b2 being Element of bool a1
          st b2 c= b1
       holds [b1,b2] in a2;
end;

:: ARMSTRNG:dfs 15
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (DC3)
it is sufficient to prove
  thus for b1, b2 being Element of bool a1
          st b2 c= b1
       holds [b1,b2] in a2;

:: ARMSTRNG:def 16
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (DC3)(b1)
   iff
      for b3, b4 being Element of bool b1
            st b4 c= b3
         holds [b3,b4] in b2;

:: ARMSTRNG:condreg 5
registration
  let a1 be set;
  cluster (F1) (F3) -> (DC3) (Relation of bool a1,bool a1);
end;

:: ARMSTRNG:condreg 6
registration
  let a1 be set;
  cluster transitive (DC3) -> (F1) (F3) (Relation of bool a1,bool a1);
end;

:: ARMSTRNG:exreg 8
registration
  let a1 be set;
  cluster non empty Relation-like transitive (F4) (DC3) Relation of bool a1,bool a1;
end;

:: ARMSTRNG:th 23
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1
      st b2 is (DC3)(b1) & b2 is transitive
   holds b2 is (F1)(b1) & b2 is (F3)(b1);

:: ARMSTRNG:th 24
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1
      st b2 is (F1)(b1) & b2 is (F3)(b1)
   holds b2 is (DC3)(b1);

:: ARMSTRNG:condreg 7
registration
  let a1 be set;
  cluster (F1) -> non empty (Relation of bool a1,bool a1);
end;

:: ARMSTRNG:th 25
theorem
for b1 being DB-Rel holds
   Dependency-str b1 is full_family(the Attributes of b1);

:: ARMSTRNG:th 26
theorem
for b1 being set
for b2 being Element of bool b1 holds
   {[b3,b4] where b3 is Element of bool b1, b4 is Element of bool b1: (b2 c= b3 or b4 c= b3)} is full_family Relation of bool b1,bool b1;

:: ARMSTRNG:funcnot 8 => ARMSTRNG:func 8
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  func Maximal_wrt A2 -> Relation of bool a1,bool a1 equals
    (Dependencies-Order a1) Maximal_in a2;
end;

:: ARMSTRNG:def 17
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
   Maximal_wrt b2 = (Dependencies-Order b1) Maximal_in b2;

:: ARMSTRNG:th 27
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
   Maximal_wrt b2 c= b2;

:: ARMSTRNG:prednot 8 => ARMSTRNG:pred 4
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  let a3, a4 be set;
  pred A3 ^|^ A4,A2 means
    [a3,a4] in Maximal_wrt a2;
end;

:: ARMSTRNG:dfs 17
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  let a3, a4 be set;
To prove
     a3 ^|^ a4,a2
it is sufficient to prove
  thus [a3,a4] in Maximal_wrt a2;

:: ARMSTRNG:def 18
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1
for b3, b4 being set holds
   b3 ^|^ b4,b2
iff
   [b3,b4] in Maximal_wrt b2;

:: ARMSTRNG:th 28
theorem
for b1 being finite set
for b2 being Element of Dependencies b1
for b3 being Relation of bool b1,bool b1
      st b2 in b3
   holds ex b4, b5 being Element of bool b1 st
      [b4,b5] in Maximal_wrt b3 & [b4,b5] >= b2;

:: ARMSTRNG:th 29
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1
for b3, b4 being Element of bool b1 holds
   b3 ^|^ b4,b2
iff
   [b3,b4] in b2 &
    (for b5, b6 being Element of bool b1
          st [b5,b6] in b2 & (b3 = b5 implies b4 <> b6)
       holds not [b5,b6] >= [b3,b4]);

:: ARMSTRNG:attrnot 12 => ARMSTRNG:attr 8
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (M1) means
    for b1 being Element of bool a1 holds
       ex b2, b3 being Element of bool a1 st
          [b2,b3] >= [b1,b1] & [b2,b3] in a2;
end;

:: ARMSTRNG:dfs 18
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (M1)
it is sufficient to prove
  thus for b1 being Element of bool a1 holds
       ex b2, b3 being Element of bool a1 st
          [b2,b3] >= [b1,b1] & [b2,b3] in a2;

:: ARMSTRNG:def 19
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (M1)(b1)
   iff
      for b3 being Element of bool b1 holds
         ex b4, b5 being Element of bool b1 st
            [b4,b5] >= [b3,b3] & [b4,b5] in b2;

:: ARMSTRNG:attrnot 13 => ARMSTRNG:attr 9
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (M2) means
    for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b3,b4] in a2 & [b1,b2] >= [b3,b4]
       holds b1 = b3 & b2 = b4;
end;

:: ARMSTRNG:dfs 19
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (M2)
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b3,b4] in a2 & [b1,b2] >= [b3,b4]
       holds b1 = b3 & b2 = b4;

:: ARMSTRNG:def 20
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (M2)(b1)
   iff
      for b3, b4, b5, b6 being Element of bool b1
            st [b3,b4] in b2 & [b5,b6] in b2 & [b3,b4] >= [b5,b6]
         holds b3 = b5 & b4 = b6;

:: ARMSTRNG:attrnot 14 => ARMSTRNG:attr 10
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (M3) means
    for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b3,b4] in a2 & b3 c= b2
       holds b4 c= b2;
end;

:: ARMSTRNG:dfs 20
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (M3)
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b3,b4] in a2 & b3 c= b2
       holds b4 c= b2;

:: ARMSTRNG:def 21
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (M3)(b1)
   iff
      for b3, b4, b5, b6 being Element of bool b1
            st [b3,b4] in b2 & [b5,b6] in b2 & b5 c= b4
         holds b6 c= b4;

:: ARMSTRNG:th 30
theorem
for b1 being non empty finite set
for b2 being full_family Relation of bool b1,bool b1 holds
   Maximal_wrt b2 is (M1)(b1) & Maximal_wrt b2 is (M2)(b1) & Maximal_wrt b2 is (M3)(b1);

:: ARMSTRNG:th 31
theorem
for b1 being finite set
for b2, b3 being Relation of bool b1,bool b1
      st b2 is (M1)(b1) &
         b2 is (M2)(b1) &
         b2 is (M3)(b1) &
         b3 = {[b4,b5] where b4 is Element of bool b1, b5 is Element of bool b1: ex b6, b7 being Element of bool b1 st
            [b6,b7] >= [b4,b5] & [b6,b7] in b2}
   holds b2 = Maximal_wrt b3 &
    b3 is full_family(b1) &
    (for b4 being full_family Relation of bool b1,bool b1
          st b2 = Maximal_wrt b4
       holds b4 = b3);

:: ARMSTRNG:funcreg 5
registration
  let a1 be non empty finite set;
  let a2 be full_family Relation of bool a1,bool a1;
  cluster Maximal_wrt a2 -> non empty;
end;

:: ARMSTRNG:th 32
theorem
for b1 being finite set
for b2 being Relation of bool b1,bool b1
for b3 being Element of bool b1
      st b2 = {[b4,b5] where b4 is Element of bool b1, b5 is Element of bool b1: (b3 c= b4 or b5 c= b4)}
   holds {[b3,b1]} \/ {[b4,b4] where b4 is Element of bool b1: not b3 c= b4} = Maximal_wrt b2;

:: ARMSTRNG:funcnot 9 => ARMSTRNG:func 9
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  func saturated-subsets A2 -> Element of bool bool a1 equals
    {b1 where b1 is Element of bool a1: ex b2 being Element of bool a1 st
       b2 ^|^ b1,a2};
end;

:: ARMSTRNG:def 22
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
   saturated-subsets b2 = {b3 where b3 is Element of bool b1: ex b4 being Element of bool b1 st
      b4 ^|^ b3,b2};

:: ARMSTRNG:funcnot 10 => ARMSTRNG:func 9
notation
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  synonym closed_attribute_subset a2 for saturated-subsets a2;
end;

:: ARMSTRNG:funcreg 6
registration
  let a1 be set;
  let a2 be finite Relation of bool a1,bool a1;
  cluster saturated-subsets a2 -> finite;
end;

:: ARMSTRNG:th 33
theorem
for b1, b2 being set
for b3 being Relation of bool b1,bool b1 holds
      b2 in saturated-subsets b3
   iff
      ex b4, b5 being Element of bool b1 st
         b2 = b4 & b5 ^|^ b4,b3;

:: ARMSTRNG:th 34
theorem
for b1 being non empty finite set
for b2 being full_family Relation of bool b1,bool b1 holds
   saturated-subsets b2 is (B1)(b1) & saturated-subsets b2 is cap-closed;

:: ARMSTRNG:funcnot 11 => ARMSTRNG:func 10
definition
  let a1, a2 be set;
  func A1 deps_encl_by A2 -> Relation of bool a1,bool a1 equals
    {[b1,b2] where b1 is Element of bool a1, b2 is Element of bool a1: for b3 being set
          st b3 in a2 & b1 c= b3
       holds b2 c= b3};
end;

:: ARMSTRNG:def 23
theorem
for b1, b2 being set holds
b1 deps_encl_by b2 = {[b3,b4] where b3 is Element of bool b1, b4 is Element of bool b1: for b5 being set
      st b5 in b2 & b3 c= b5
   holds b4 c= b5};

:: ARMSTRNG:th 35
theorem
for b1 being set
for b2 being Element of bool bool b1
for b3 being Relation of bool b1,bool b1 holds
   b1 deps_encl_by b2 is full_family(b1);

:: ARMSTRNG:th 36
theorem
for b1 being non empty finite set
for b2 being Element of bool bool b1 holds
   b2 c= saturated-subsets (b1 deps_encl_by b2);

:: ARMSTRNG:th 37
theorem
for b1 being non empty finite set
for b2 being Element of bool bool b1
      st b2 is (B1)(b1) & b2 is cap-closed
   holds b2 = saturated-subsets (b1 deps_encl_by b2) &
    (for b3 being full_family Relation of bool b1,bool b1
          st b2 = saturated-subsets b3
       holds b3 = b1 deps_encl_by b2);

:: ARMSTRNG:funcnot 12 => ARMSTRNG:func 11
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  func enclosure_of A2 -> Element of bool bool a1 equals
    {b1 where b1 is Element of bool a1: for b2, b3 being Element of bool a1
          st [b2,b3] in a2 & b2 c= b1
       holds b3 c= b1};
end;

:: ARMSTRNG:def 24
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
   enclosure_of b2 = {b3 where b3 is Element of bool b1: for b4, b5 being Element of bool b1
         st [b4,b5] in b2 & b4 c= b3
      holds b5 c= b3};

:: ARMSTRNG:th 38
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1 holds
   enclosure_of b2 is (B1)(b1) & enclosure_of b2 is cap-closed;

:: ARMSTRNG:th 39
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1 holds
   b2 c= b1 deps_encl_by enclosure_of b2 &
    (for b3 being Relation of bool b1,bool b1
          st b2 c= b3 & b3 is full_family(b1)
       holds b1 deps_encl_by enclosure_of b2 c= b3);

:: ARMSTRNG:funcnot 13 => ARMSTRNG:func 12
definition
  let a1 be non empty finite set;
  let a2 be Relation of bool a1,bool a1;
  func Dependency-closure A2 -> full_family Relation of bool a1,bool a1 means
    a2 c= it &
     (for b1 being Relation of bool a1,bool a1
           st a2 c= b1 & b1 is full_family(a1)
        holds it c= b1);
end;

:: ARMSTRNG:def 25
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1
for b3 being full_family Relation of bool b1,bool b1 holds
      b3 = Dependency-closure b2
   iff
      b2 c= b3 &
       (for b4 being Relation of bool b1,bool b1
             st b2 c= b4 & b4 is full_family(b1)
          holds b3 c= b4);

:: ARMSTRNG:th 40
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1 holds
   Dependency-closure b2 = b1 deps_encl_by enclosure_of b2;

:: ARMSTRNG:th 41
theorem
for b1 being set
for b2 being Element of bool b1
for b3 being Element of bool bool b1
      st b3 = {b1} \/ {b4 where b4 is Element of bool b1: not b2 c= b4}
   holds b3 is (B1)(b1) & b3 is cap-closed;

:: ARMSTRNG:th 42
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1
for b3 being Element of bool b1
      st b2 = {[b4,b5] where b4 is Element of bool b1, b5 is Element of bool b1: (b3 c= b4 or b5 c= b4)}
   holds {b1} \/ {b4 where b4 is Element of bool b1: not b3 c= b4} = saturated-subsets b2;

:: ARMSTRNG:th 43
theorem
for b1 being finite set
for b2 being Relation of bool b1,bool b1
for b3 being Element of bool b1
      st b2 = {[b4,b5] where b4 is Element of bool b1, b5 is Element of bool b1: (b3 c= b4 or b5 c= b4)}
   holds {b1} \/ {b4 where b4 is Element of bool b1: not b3 c= b4} = saturated-subsets b2;

:: ARMSTRNG:prednot 9 => ARMSTRNG:pred 5
definition
  let a1, a2 be set;
  let a3 be Element of bool bool a1;
  pred A2 is_generator-set_of A3 means
    a2 c= a3 &
     a3 = {Intersect b1 where b1 is Element of bool bool a1: b1 c= a2};
end;

:: ARMSTRNG:dfs 25
definiens
  let a1, a2 be set;
  let a3 be Element of bool bool a1;
To prove
     a2 is_generator-set_of a3
it is sufficient to prove
  thus a2 c= a3 &
     a3 = {Intersect b1 where b1 is Element of bool bool a1: b1 c= a2};

:: ARMSTRNG:def 26
theorem
for b1, b2 being set
for b3 being Element of bool bool b1 holds
      b2 is_generator-set_of b3
   iff
      b2 c= b3 &
       b3 = {Intersect b4 where b4 is Element of bool bool b1: b4 c= b2};

:: ARMSTRNG:th 44
theorem
for b1 being non empty finite set
for b2 being Element of bool bool b1 holds
   b2 is_generator-set_of saturated-subsets (b1 deps_encl_by b2);

:: ARMSTRNG:th 45
theorem
for b1 being non empty finite set
for b2 being full_family Relation of bool b1,bool b1 holds
   ex b3 being Element of bool bool b1 st
      b3 is_generator-set_of saturated-subsets b2 & b2 = b1 deps_encl_by b3;

:: ARMSTRNG:th 46
theorem
for b1 being set
for b2 being non empty finite Element of bool bool b1
      st b2 is (B1)(b1) & b2 is cap-closed
   holds /\-IRR b2 is_generator-set_of b2;

:: ARMSTRNG:th 47
theorem
for b1, b2 being set
for b3 being non empty finite Element of bool bool b1
      st b3 is (B1)(b1) & b3 is cap-closed & b2 is_generator-set_of b3
   holds /\-IRR b3 c= b2 \/ {b1};

:: ARMSTRNG:th 48
theorem
for b1 being non empty finite set
for b2 being full_family Relation of bool b1,bool b1 holds
   ex b3 being DB-Rel st
      the Attributes of b3 = b1 &
       (for b4 being Element of b1 holds
          (the Domains of b3) . b4 = INT) &
       b2 = Dependency-str b3;

:: ARMSTRNG:funcnot 14 => ARMSTRNG:func 13
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  func candidate-keys A2 -> Element of bool bool a1 equals
    {b1 where b1 is Element of bool a1: [b1,a1] in Maximal_wrt a2};
end;

:: ARMSTRNG:def 27
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
   candidate-keys b2 = {b3 where b3 is Element of bool b1: [b3,b1] in Maximal_wrt b2};

:: ARMSTRNG:th 49
theorem
for b1 being finite set
for b2 being Relation of bool b1,bool b1
for b3 being Element of bool b1
      st b2 = {[b4,b5] where b4 is Element of bool b1, b5 is Element of bool b1: (b3 c= b4 or b5 c= b4)}
   holds candidate-keys b2 = {b3};

:: ARMSTRNG:attrnot 15 => XBOOLE_0:attr 1
notation
  let a1 be set;
  antonym (C1) for empty;
end;

:: ARMSTRNG:attrnot 16 => ARMSTRNG:attr 11
definition
  let a1 be set;
  attr a1 is without_proper_subsets means
    for b1, b2 being set
          st b1 in a1 & b2 in a1 & b1 c= b2
       holds b1 = b2;
end;

:: ARMSTRNG:dfs 27
definiens
  let a1 be set;
To prove
     a1 is without_proper_subsets
it is sufficient to prove
  thus for b1, b2 being set
          st b1 in a1 & b2 in a1 & b1 c= b2
       holds b1 = b2;

:: ARMSTRNG:def 28
theorem
for b1 being set holds
      b1 is without_proper_subsets
   iff
      for b2, b3 being set
            st b2 in b1 & b3 in b1 & b2 c= b3
         holds b2 = b3;

:: ARMSTRNG:attrnot 17 => ARMSTRNG:attr 11
notation
  let a1 be set;
  synonym (C2) for without_proper_subsets;
end;

:: ARMSTRNG:th 50
theorem
for b1 being DB-Rel holds
   candidate-keys Dependency-str b1 is not empty & candidate-keys Dependency-str b1 is without_proper_subsets;

:: ARMSTRNG:th 51
theorem
for b1 being finite set
for b2 being Element of bool bool b1
      st b2 is not empty & b2 is without_proper_subsets
   holds ex b3 being full_family Relation of bool b1,bool b1 st
      b2 = candidate-keys b3;

:: ARMSTRNG:th 52
theorem
for b1 being finite set
for b2 being Element of bool bool b1
for b3 being set
      st b2 is not empty &
         b2 is without_proper_subsets &
         b3 = {b4 where b4 is Element of bool b1: for b5 being Element of bool b1
               st b5 in b2
            holds not b5 c= b4}
   holds b2 = candidate-keys (b1 deps_encl_by b3);

:: ARMSTRNG:th 53
theorem
for b1 being non empty finite set
for b2 being Element of bool bool b1
      st b2 is not empty & b2 is without_proper_subsets
   holds ex b3 being DB-Rel st
      the Attributes of b3 = b1 & b2 = candidate-keys Dependency-str b3;

:: ARMSTRNG:attrnot 18 => ARMSTRNG:attr 12
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (DC4) means
    for b1, b2, b3 being Element of bool a1
          st [b1,b2] in a2 & [b1,b3] in a2
       holds [b1,b2 \/ b3] in a2;
end;

:: ARMSTRNG:dfs 28
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (DC4)
it is sufficient to prove
  thus for b1, b2, b3 being Element of bool a1
          st [b1,b2] in a2 & [b1,b3] in a2
       holds [b1,b2 \/ b3] in a2;

:: ARMSTRNG:def 29
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (DC4)(b1)
   iff
      for b3, b4, b5 being Element of bool b1
            st [b3,b4] in b2 & [b3,b5] in b2
         holds [b3,b4 \/ b5] in b2;

:: ARMSTRNG:attrnot 19 => ARMSTRNG:attr 13
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (DC5) means
    for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b2 \/ b3,b4] in a2
       holds [b1 \/ b3,b4] in a2;
end;

:: ARMSTRNG:dfs 29
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (DC5)
it is sufficient to prove
  thus for b1, b2, b3, b4 being Element of bool a1
          st [b1,b2] in a2 & [b2 \/ b3,b4] in a2
       holds [b1 \/ b3,b4] in a2;

:: ARMSTRNG:def 30
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (DC5)(b1)
   iff
      for b3, b4, b5, b6 being Element of bool b1
            st [b3,b4] in b2 & [b4 \/ b5,b6] in b2
         holds [b3 \/ b5,b6] in b2;

:: ARMSTRNG:attrnot 20 => ARMSTRNG:attr 14
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  attr a2 is (DC6) means
    for b1, b2, b3 being Element of bool a1
          st [b1,b2] in a2
       holds [b1 \/ b3,b2] in a2;
end;

:: ARMSTRNG:dfs 30
definiens
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
To prove
     a2 is (DC6)
it is sufficient to prove
  thus for b1, b2, b3 being Element of bool a1
          st [b1,b2] in a2
       holds [b1 \/ b3,b2] in a2;

:: ARMSTRNG:def 31
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (DC6)(b1)
   iff
      for b3, b4, b5 being Element of bool b1
            st [b3,b4] in b2
         holds [b3 \/ b5,b4] in b2;

:: ARMSTRNG:th 54
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (F1)(b1) & b2 is transitive & b2 is (F3)(b1) & b2 is (F4)(b1)
   iff
      b2 is transitive & b2 is (DC3)(b1) & b2 is (F4)(b1);

:: ARMSTRNG:th 55
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (F1)(b1) & b2 is transitive & b2 is (F3)(b1) & b2 is (F4)(b1)
   iff
      b2 is transitive & b2 is (DC3)(b1) & b2 is (DC4)(b1);

:: ARMSTRNG:th 56
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
      b2 is (F1)(b1) & b2 is transitive & b2 is (F3)(b1) & b2 is (F4)(b1)
   iff
      b2 is (F1)(b1) & b2 is (DC5)(b1) & b2 is (DC6)(b1);

:: ARMSTRNG:funcnot 15 => ARMSTRNG:func 14
definition
  let a1 be set;
  let a2 be Relation of bool a1,bool a1;
  func charact_set A2 -> set equals
    {b1 where b1 is Element of bool a1: ex b2, b3 being Element of bool a1 st
       [b2,b3] in a2 & b2 c= b1 & not b3 c= b1};
end;

:: ARMSTRNG:def 32
theorem
for b1 being set
for b2 being Relation of bool b1,bool b1 holds
   charact_set b2 = {b3 where b3 is Element of bool b1: ex b4, b5 being Element of bool b1 st
      [b4,b5] in b2 & b4 c= b3 & not b5 c= b3};

:: ARMSTRNG:th 57
theorem
for b1, b2 being set
for b3 being Relation of bool b1,bool b1
      st b2 in charact_set b3
   holds b2 is Element of bool b1 &
    (ex b4, b5 being Element of bool b1 st
       [b4,b5] in b3 & b4 c= b2 & not b5 c= b2);

:: ARMSTRNG:th 58
theorem
for b1 being set
for b2 being Element of bool b1
for b3 being Relation of bool b1,bool b1
      st ex b4, b5 being Element of bool b1 st
           [b4,b5] in b3 & b4 c= b2 & not b5 c= b2
   holds b2 in charact_set b3;

:: ARMSTRNG:th 59
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1 holds
   (for b3, b4 being Element of bool b1 holds
       [b3,b4] in Dependency-closure b2
    iff
       for b5 being Element of bool b1
             st b3 c= b5 & not b4 c= b5
          holds b5 in charact_set b2) &
    saturated-subsets Dependency-closure b2 = (bool b1) \ charact_set b2;

:: ARMSTRNG:th 60
theorem
for b1 being non empty finite set
for b2, b3 being Relation of bool b1,bool b1
      st charact_set b2 = charact_set b3
   holds Dependency-closure b2 = Dependency-closure b3;

:: ARMSTRNG:th 61
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1 holds
   charact_set b2 = charact_set Dependency-closure b2;

:: ARMSTRNG:prednot 10 => ARMSTRNG:pred 6
definition
  let a1, a2 be set;
  let a3 be Relation of bool a1,bool a1;
  pred A2 is_p_i_w_ncv_of A3 means
    (for b1 being Element of bool a1
           st a2 c= b1 & b1 <> a1
        holds b1 in charact_set a3) &
     (for b1 being set
           st b1 c< a2
        holds ex b2 being Element of bool a1 st
           b1 c= b2 & b2 <> a1 & not b2 in charact_set a3);
end;

:: ARMSTRNG:dfs 32
definiens
  let a1, a2 be set;
  let a3 be Relation of bool a1,bool a1;
To prove
     a2 is_p_i_w_ncv_of a3
it is sufficient to prove
  thus (for b1 being Element of bool a1
           st a2 c= b1 & b1 <> a1
        holds b1 in charact_set a3) &
     (for b1 being set
           st b1 c< a2
        holds ex b2 being Element of bool a1 st
           b1 c= b2 & b2 <> a1 & not b2 in charact_set a3);

:: ARMSTRNG:def 33
theorem
for b1, b2 being set
for b3 being Relation of bool b1,bool b1 holds
      b2 is_p_i_w_ncv_of b3
   iff
      (for b4 being Element of bool b1
             st b2 c= b4 & b4 <> b1
          holds b4 in charact_set b3) &
       (for b4 being set
             st b4 c< b2
          holds ex b5 being Element of bool b1 st
             b4 c= b5 & b5 <> b1 & not b5 in charact_set b3);

:: ARMSTRNG:th 62
theorem
for b1 being non empty finite set
for b2 being Relation of bool b1,bool b1
for b3 being Element of bool b1 holds
      b3 in candidate-keys Dependency-closure b2
   iff
      b3 is_p_i_w_ncv_of b2;