Document Sample
concept Powered By Docstoc
                       Formal Concept
      What is a concept?
           Traditionally, a question for philosphers.
           We seek a mathematical answer
      Concept: A group of set of objects with shared properties
           Man
           Hat
      Extent of a concept: the set of objects (within a given
      Intent of a concept: the set of attributes (within a given
      Context- restricting the domain of interest to:
           Certain properties
           Certain objects

sd                                                                  ‫נ ן‬
                          Concept Example
     Characterization of People
                          Self   My Ideal   Father   Mother   Sister   Brother
        vulnerable          x        x        x        x        x
        reserved            x                 x        x
        self-confident      x        x                                    x
        dutiful                      x        x        x                  x
        happy               x        x        x        x                  x
        difficult           x                 x        x
        attentive           x        x        x        x                  x
        easily offended                       x
        easy going          x        x        x        x
        anxious             x                 x        x
        talkative                                                         x
        superficial                           x        x                  x
        sensitive           x        x        x        x        x
        ambitious           x        x        x        x        x         x

sd                                                                               ‫נ ן‬
                  Programming Languages

     Characetristic Fortran ISO    Turbo    Modula 2   Ada C    C++ Smalltalk
                            Pascal Pascal
     encapsulation     x              x        x        x   x    x        x
     instantiation                                               x        x
     inheritnace                                                 x        x
     dynamic                                   x        x        x        x
     storage                                                     x        x

sd                                                                              ‫נ ן‬
        Components of a Formal Concept
      Context: a triple <G,M,I>
         G (Gegenst‫ה‬nde) set of objects
         M (Merkmale) set of attributes
         IG  M incidence relation
            (g,m) I object g has attribute m
      For AָG and BָM define
          A'  {m  M |( g  A)( g , m)  I }
          B '  {g  G|( m  B )( g , m)  I }
      Concept: a pair (A,B), Aֽ G (extent), Bֽ G (intent)
       such that
           A’ = B
           B’ = A

sd                                                           ‫נ ן‬
                   Finding the Concepts
 Fundamental Lemma: For all AָG and BָM
     A’ = A’’’
     B’ = B’’’
 Corrolary: a concept encompasses all objects that conform to
  its attributes and all attributes which hold for all of its objects.
 Concept Generation:
      From Objects:
          Start from any set of objects A*
          Find B = A*’, the set of all attributes that hold for this set
          Find all objects A = B’ = A*’’, the set of all objects that conform
           with B
      From Attributes:
          Start from any set of attributes B*
          Find A = B*’, the set of all objects that match this attribute
          Find all attributes B = A’ = B*’’, the set of all attributes that hold
           for this set of objects.
sd                                                                                  ‫נ ן‬
       Formal Context Theory vs. Design
      Which context to use?
          Which are the “right” sample object
          Which are the “right” attributes
      Which concepts to use?
          The number of concepts is usually exponential in the
           number of attributes
      Dual question: which concepts have meaningful
          Hypothesis: If something has a name then it must be
          Problem: if something is meaningful, then it must have a
           good name

sd                                                                    ‫נ ן‬
                    The Right Attributes
      Number of values
          Two (binary, boolean): perfect for finding attribute
          Small (enumerated type): can be coerced into boolean
             Is it green?
          Large (integer, character): ?
          Continous (real, complex): ??
          String (first name): ???
          With parameters (book reservation record): ????
      Life time:
          Permanent: legitimate
          Transient: ????
      Orthogonal:
          If an attribute is reasonalby orthogonal to all others, then
           it should not be used for conceptualization
          Example: gender
sd                                                                        ‫נ ן‬
       Techniques for Finding Concepts
      Classical categorization: find a distinguishing
       property. Usually, such a property should have a small
       and discrete range of values.
           Examples: martial status, gender
           Non-Examples: size, color
       If using a set of properties, their values should be
       either totally correlated, or orthogonal.
      Conceptual clustering: Start from a concept, and
       throw objects into it.
           Example: marriage, sit-com, permission
      Prototype theory: Start from a specimen, and build a
       family of resemblense around it.
           Examples: chair, game, cat, man

sd                                                              ‫נ ן‬
           Problems in Finding Concepts
      Birds: which are the unifying properties (the set B)
             Flight: ostrich cannot fly
             Feathers: plucked chicken
             Eggs: lizard
             Alive: toy bird
      Conclusion: many concepts are not well-defined
      Basic recipe (which does not help much)
           Start from properties
           If they fail, revert to
                Prototypes
                Conceptual clustering

sd                                                            ‫נ ן‬
 Lattice: a partially ordered set L that satisfies
      Supremum property: For every a,bL there exists an element
       cL (sometimes written as a⊓b) such that
          c≥b
          c≥a
          Minimality of c: for every other c’L, such that c≥a and c≥b, it
           also holds that c’≥c.
      Infimum property: For every a,bL there exists an element c  S
       (sometimes written as a⊔b) such that
          c≤b
          c≤a
          Minimality of c: for every other c’L, such that c’≤a and c’≤b, it
           also holds that c’≤c
 By induction: every finite subset SL has a superemum
  ⊓S and an infimum ⊔ S. If L is finite, then we also have:
      The superemum of L, ⊓ L exists and is called the top of the
      The infimum of L, ⊔L exists and is called the bottom of the
sd     lattice.                                                                 ‫נ ן‬
      Set Inclusion: L=P(S), for any set S. Order relation is
       set inclusion. Supremum is set union, infimum is set
       intersection. Bottom is ∅. Top is S.
      Divides relationship: L={1,…,}. Order relation is
       “divides”. Supremum is set lcm, infimum is gcd. Bottom
       is 1. Top does not exist.
      Not lattices:
           {1, 2, 3, 4, 5, 6} with the “divides” partial order
               3 5 does not exist
           A tree, with the “parent of” partial order
               If a and b are imcomparable then a b does not exist
           The following inheritance graph:
                                                    a           b
                                                        c             d
sd                                                                        ‫נ ן‬
Example: Smalltalk-80 Collection Library
                  Collection   Set   Bag   Sequenceable   Dictionary Linked Array
                                           Collection                List
     isEmpty           x        x     x           x            x        x     x
     size              x        x     x           x            x        x     x
     includes          x        x     x           x            x        x     x
     add                        x     x                        x        x
     remove                     x     x                                 x
     minus                      x
     add With                         x
     at                                         x             x        x      x
     at put                                                   x               x
     atAllput                                                                 x
     first                                      x                      x      x
     last                                       x                      x      x
     addFirst                                                          x
     addLast                                                           x
     keys                                                     x
     values                                                   x

sd                                                                                  ‫נ ן‬
Concept Lattice for Smalltalk Collections
                                                              {C, A,, D, LL, B, S, SC}
                                                               {isEmpty, Size, includes}

                                   {A, D, LL, SC}                                                 {D, LL, B, S}
                              {isEmpty, size, includes, at}                                {isEmpty, size, includes, add}

          {A,D}                         {D,LL}                      {D, LL, SC}                       {D,S}                       {LL, B, S}
 {isEmpty, size, includes,      {isEmpty, size,includes,       {isEmpty, size,includes,      {isEmpty, size,includes,       {isEmpty, size, includes
        at, atPut}                     at, add}                     at, first, last}              add, minus}                    add, remove}

            {A}                           {D}                            {LL}                           {S}                           {B}
 {isEmpty, size, includes,      {isEmpty, size,includes,        {isEmpty, size,includes,     {isEmpty, size,includes,       {isEmpty, size,includes,
          at, atPut,              at, atPut, add, minus,           at, add, first, last,          add, minus,                    add, remove,
    atAllPut, first, lastt}            keys, values}          remove, addFirst, addLast}            remove}                   addWithOccurences}

                                                                    {all methods}

sd                                                                                                                                                ‫נ ן‬
           The Fundamental Theorem of
             Formal Concept Analysis
      The structure induced by any context is a lattice
      There is context that induces any finite lattice

sd                                                         ‫נ ן‬
              Removing Redundancies
      Redundancies: for a concept C=(A,B)
          The attributes A will appear in every descendant of C
          The objects in B will appear in every ancestor of C
      Normalization process:
          Show only attributes that do not appear in any ancestor
          Show only objects that do not appear in any descendant

sd                                                                   ‫נ ן‬
                  Inheritance Concept Lattice
                                        {isEmpty, Size, includes}

                           {}                                         {}
                          {at}                                       {add}

         {}                {}         {SequenceableCollection}        {}              {}
      {atPut}              {}                  { first, last}       {minus}        {remove}

     {Array}         {Dictionary}            {LinkedList}           {Set}           {Bag}
     {atAllPut}      {keys, values}       {addFirst, addLast}         {}      {addWithOccurences}


sd                                                                                             ‫נ ן‬
                      Kinds of Concepts
      Connector concepts: have no incremental value
           Attributes: union of ancestors
           Objects: union of descendants
      Abstract concepts: have no objects of their own
           Objects: union of descendants
      Intersect Concepts: have no attributes of their own, but
       do have have objects
           Attributes: union of ancestors
      Concrete concepts: have both attributes and objects of
       their own

                                  Abstract          Intersect
                                  Concepts          Concepts

sd                                                                ‫נ ן‬
            Kinds of Concrete Concepts
      Singletons: concrete concept with exactly one
       incremental objects.

sd                                                     ‫נ ן‬
                  Removing Connectors
                                     {isEmpty, Size, includes}


         {}                        {SequenceableCollection}        {}              {}
      {atPut}                               { first, last}       {minus}        {remove}

     {Array}      {Dictionary}            {LinkedList}           {Set}           {Bag}
     {atAllPut}   {keys, values}       {addFirst, addLast}         {}      {addWithOccurences}

sd                                                                                          ‫נ ן‬
                    Naming Concepts
      Singeltons: if a concepts has only one (incremental)
       object, then its name should be the name of that object
      Connector concepts: removed (bottom and top are
       always connectors if the context is normalized)
      Abstract concepts: if a concept has no incremental
       objects, then its name should be derived from the set
       of its incremental attributes
      Intersect concepts: name should be derived from the
       set of incremental objects

sd                                                               ‫נ ן‬
                       Naming Abstract Classes

                                           {isEmpty, Size, includes}


UpdateableCollection                      SequenceableCollection       SubtractableCollection   RemovableCollection
       {atPut}                                    { first, last}              {minus}                 {remove}

       Array              Dictionary             LinkedList                     Set                     Bag
      {atAllPut}         {keys, values}      {addFirst, addLast}                 {}              {addWithOccurences}

sd                                                                                                                 ‫נ ן‬

Shared By: