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.
  
    Example  
    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.13). We have Unknown( n ) >= Unknown( m ) if and
  only  if n >= m holds, unknowns are larger than all cyclotomics that are not
  unknowns.
  
    Example  
    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)).