[CRISP] 2 Set theoretical classes

[Up] [Previous] [Next] [Index]

# 2 Set theoretical classes

### Sections

1. Creating set theoretical classes
2. Properties of classes
3. Lattice operations for classes

In CRISP, a class (in the set-theoretical sense) is usually represented by an algorithm which decides membership in that class. Wherever this makes sense, sets (see Set in the GAP reference manual) may also be used as classes.

## 2.1 Creating set theoretical classes

- `IsClass(`C`) C`

  returns true if C is a class object. The category of class objects is a subcategory of the category `IsListOrCollection`.

- `Class(`rec`) O`
- `Class(`func`) O`

  returns a class C. In the first form, rec must be a record having a component `\in` and an optional component `name`. The values of these components, if present, are bound to the attributes `MemberFunction` and `Name` (see Name) of the class created. The value bound to `\in` must be a function func which returns `true` if a GAP object belongs to C, and `false` otherwise; cf. MemberFunction below. The second form is equivalent to `Class(rec(\in :=` func`))`. It is the user's responsibility to ensure that func returns the same result for different GAP objects representing the same mathematical object (or element, in the GAP sense; see objects and elements in the GAP reference manual).

      gap> RequirePackage ("crisp");

                   _____  ___    __  ____   ___
                  / ___/ / _ \  / / / __/  / _ \
                 / /__  /   _/ / / _\_ \  / ___/
                 \___/ /_/\_\ /_/ /____/ /_/

                       A GAP 4 package for
                Computing with Radicals, Injectors
                  Schunck classes and Projectors
                    of finite solvable groups

                      By Burkhard H\"ofling

                      For help, type ?CRISP

      true
      gap> FermatPrimes := Class (p -> IsPrime (p) and p = 2^LogInt (p, 2) + 1);
      Class (in:=function( p ) ... end)

- `View(`class`)`

  If the class does not have a name, this produces a brief description of the information defining class which has been supplied by the user. If the class has a name, only its name will be printed.

      gap> View (FermatPrimes);
      Class (in:=function( p ) ... end)

- `Print(`class`)`

  `Print` behaves very similarly to `View`, except that the defining information is being printed in a more explicit way if possible.

      gap> Print (FermatPrimes);
      Class (rec ( in = function ( p )
          return IsPrime( p ) and p = 2 ^ LogInt( p, 2 ) + 1;
      end))

- `Display(`class`)`

  For classes, `Display` works exactly as `Print`.

- ``obj`in` class``

  not. If obj can store attributes, the outcome of the membership test is stored in an attribute `ComputedIsMembers` of obj.

- ``C1`=` C2``

  Since it is not possible to compare classes given by membership algorithms, two classes are equal in GAP if and only if they are the same GAP object (see IsIdenticalObj in the GAP reference manual).

- ``C1`<` C2``

  The operation `<` for classes has no mathematical meaning; it only exists so that one can form sorted lists of classes.

  ## 2.2 Properties of classes

- `IsEmpty(`C`) P`

  This property may be set to `true` or `false` if the class C is empty resp. not empty.

- `MemberFunction(`C`) A`

  This attribute, if bound, stores a function with one argument, obj, which decides if obj belongs to C or not, and returns `true` and `false` accordingly. If present, this function is called by the default method for `\in`. `MemberFunction` is part of the definition of C and should not be called directly by the user.

  ## 2.3 Lattice operations for classes

- `Complement(`C`) O`

  returns the unary complement of the class C, that is, the class consisting of all objects not in C. C may also be a set.

      gap> cmpl := Complement([1,2]);
      Complement ([ 1, 2 ])
      gap> Complement (cmpl);
      [ 1, 2 ]

- `Intersection(`list`) F`
- `Intersection(`C1`,` C2`, ...) F`

  returns the intersection of the groups in list, resp. of the classes C1, C2, .... If one of the classes is a list with fewer than `INTERSECTION_LIMIT` elements, then the result will be a sublist of that list. By default, `INTERSECTION_LIMIT` is 1000.

      gap> Intersection (Class (IsPrimeInt), [1..10]);
      [ 2, 3, 5, 7 ]
      gap> Intersection (Class (IsPrimeInt), Class (n -> n = 2^LogInt (n+1, 2) - 1));
      Intersection ([ Class (in:=function( n ) ... end),
        Class (in:=function( n ) ... end) ])

- `Union(`C`,` D`) F`

  returns the union of C and D.

      gap> Union (Class (n -> n mod 2 = 0), Class (n -> n mod 3 = 0));
      Union ([ Class (in:=function( n ) ... end), Class (in:=function( n ) ... end)
       ])

- `Difference(`C`,` D`) O`

  returns the difference of C and D. If C is a list, then the result will be a sublist of C.

      gap> Difference (Class (IsPrimePowerInt), Class (IsPrimeInt));
      Intersection ([ Class (in:=function( n ) ... end),
        Complement (Class (in:=function( n ) ... end)) ])
      gap> Difference ([1..10], Class (IsPrimeInt));
      [ 1, 4, 6, 8, 9, 10 ]

  [Up] [Previous] [Next] [Index]