GAP (ref) - Chapter 74: Unknowns

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

74 Unknowns
74.1 More about Unknowns
74.1-1 Unknown
74.1-2 LargestUnknown
74.1-3 IsUnknown
74.1-4 Comparison of Unknowns
74.1-5 Arithmetical Operations for Unknowns

### 74 Unknowns

Sometimes the result of an operation does not allow further computations with it. In many cases, then an error is signalled, and the computation is stopped.

This is not appropriate for some applications in character theory. For example, if one wants to induce a character of a group to a supergroup (see `InducedClassFunction` (72.9-3)) but the class fusion is only a parametrized map (see Chapter 73), there may be values of the induced character which are determined by the fusion map, whereas other values are not known.

For this and other situations, GAP provides the data type unknown. An object of this type, further on called an unknown, may stand for any cyclotomic (see Chapter 18), in particular its family (see 13.1) is `CyclotomicsFamily`.

Unknowns are parametrized by positive integers. When a GAP session is started, no unknowns exist.

The only ways to create unknowns are to call the function `Unknown` (74.1-1) or a function that calls it, or to do arithmetical operations with unknowns.

GAP objects containing unknowns will contain fixed unknowns when they are printed to files, i.e., function calls `Unknown(`n`)` instead of `Unknown()`. So be careful to read files printed in different GAP sessions, since there may be the same unknown at different places.

The rest of this chapter contains information about the unknown constructor, the category, and comparison of and arithmetical operations for unknowns. More is not known about unknowns in GAP.

#### 74.1 More about Unknowns

##### 74.1-1 Unknown

`‣ Unknown`( [n] ) | ( operation )

Called without argument, `Unknown` returns a new unknown value, i.e., the first one that is larger than all unknowns which exist in the current GAP session.

Called with a positive integer n, `Unknown` returns the n-th unknown; if this did not exist yet, it is created.

##### 74.1-2 LargestUnknown

`‣ LargestUnknown` | ( global variable )

`LargestUnknown` is the largest n that is used in any `Unknown( n )` in the current GAP session. This is used in `Unknown` (74.1-1) which increments this value when asked to make a new unknown.

##### 74.1-3 IsUnknown

`‣ IsUnknown`( obj ) | ( category )

is the category of unknowns in GAP.

    gap> Unknown();  List( [ 1 .. 20 ], i -> Unknown() );;
    Unknown(1)
    gap> Unknown();   # note that we have already created 21 unknowns.
    Unknown(22)
    gap> Unknown(2000);  Unknown();
    Unknown(2000)
    Unknown(2001)
    gap> LargestUnknown;
    2001
    gap> IsUnknown( Unknown );  IsUnknown( Unknown() );
    false
    true

##### 74.1-4 Comparison of Unknowns

Unknowns can be compared via `=` and `<` with all cyclotomics and with certain other GAP objects (see 4.12). We have `Unknown( n ) >= Unknown( m )` if and only if `n >= m` holds, unknowns are larger than all cyclotomics that are not unknowns.

    gap> Unknown() >= Unknown();  Unknown(2) < Unknown(3);
    false
    true
    gap> Unknown() > 3;  Unknown() > E(3);
    true
    true
    gap> Unknown() > Z(8);  Unknown() > [];
    false
    false

##### 74.1-5 Arithmetical Operations for Unknowns

The usual arithmetic operations `+`, `-`, `*` and `/` are defined for addition, subtraction, multiplication and division of unknowns and cyclotomics. The result will be a new unknown except in one of the following cases.

Multiplication with zero yields zero, and multiplication with one or addition of zero yields the old unknown. Note that division by an unknown causes an error, since an unknown might stand for zero.

As unknowns are cyclotomics, dense lists of unknowns and other cyclotomics are row vectors and they can be added and multiplied in the usual way. Consequently, lists of such row vectors of equal length are (ordinary) matrices (see `IsOrdinaryMatrix` (24.2-2)).

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 Bib Ind

generated by GAPDoc2HTML