Main Page | Class Hierarchy | Class List | File List | Class Members | File Members | Related Pages

Exponentiator< K > Class Template Reference

#include <exp_classes.H>

List of all members.

Detailed Description

template<class K>
class Exponentiator< K >

Exponentiator class -- computes Chern/Stiefel-Whitney classes.

An exponentiator takes a representation ring and creates an associated graded algebra, the "exp" ring. In the comments, we say exp-classes for either Chern or Stiefel-Whitney classes.

Strongly recommended: you should read the comments to start() first.

Definition at line 24 of file exp_classes.H.

Public Member Functions

virtual void create_regular_variables (string prefix)
 creates the variables in *target
void create_extra_variables (string prefix)
 creates a bunch of temporary variables
void kill_extra_variables ()
 as it says, really.
void clean_up_equations ()
 cleaned up equations
Polynomial< K > compute_tensor_relation (long max_dim1, long max_dim2)
 computes the universal polynomial for the exp classes of a tensor product
void write_lambda_factors (list< Polynomial< K > > &result, long ext, long first, long last)
 internal use only -- used by compute_lambda_relation()
Polynomial< K > compute_lambda_relation (long ext, long dim)
 computes the universal polynomial for the exp classes of an external power
void exp_classes_after_tensoring (const Polynomial< K > &exp, long dim, const PowProd &pow, Polynomial< K > &result)
 recursively compute the exp classes of a tensor product
Polynomial< K > exp_classes_of_ext_power (long thevar, long ext)
 compute the exp classes of an exterior power of a representation
void compute_exp_relations ()
 translate the equations in *source into equations in *target
void split_and_sort ()
void add_relations ()
 adds the relations to *target from exp_relations
void start (RepresentationRing *thesource, GradedAlgebra< K > *thetarget, string prefix, long thefactor)
 gets the computation going

Public Attributes

RepresentationRing * source
 the representation ring
GradedAlgebra< K > * target
 the outcome - a graded algebra
long last_actual_variable
 remembers the number of "regular" variables.
long max_dim
 largest dimension of a rep among the variables in *source
long max_dim_rel
 largest dimension of a rep among the relations in *source
Table< Polynomial< K > > var
 the "regular" variables created in *target, as polynomials
Tuple< Polynomial< K > > a
 the "extra" variables, as polynomials
Tuple< Polynomial< K > > b
 the "extra" variables, as polynomials
Tuple< Polynomial< K > > s
 the "extra" variables, as polynomials
Tuple< Polynomial< K > > sp
 the "extra" variables, as polynomials
list< pair< Polynomial< QQ >,
Polynomial< QQ > > > 		equations
 cleaned up equations
list< Polynomial< K > > total_relations
 all resulting total relations between exp classes
list< Polynomial< K > > exp_relations
 same as total_relations, only homogeneous and sorted by degree
long factor
 typically 2 for Chern classes, 1 for SW
map< pair< long, long >, Polynomial<
K > > 		univ_computed
 universal polynomials for tensor products
map< pair< long, long >, Polynomial<
K > > 		lambda_univ_computed
 universal polynomial for lambda operations

Member Function Documentation

template<class K>
void Exponentiator< K >::add_relations (   )  [inline]
 

adds the relations to *target from exp_relations

Then we release some memory by clearing exp_relations and total_relations.

Definition at line 791 of file exp_classes.H.

template<class K>
void Exponentiator< K >::clean_up_equations (   )  [inline]
 

cleaned up equations

in *source we have equations of the form P=0, where P has rational coefficients. We transform this into LHS = RHS, where each side has positive, integer coefficients. Also, all coeffs on both sides are coprime (taken together). In principle the rep rings we shall use do not involve fractions or equations that have non-coprime coefficients, but we check this to be on the safe side.

Definition at line 249 of file exp_classes.H.

template<class K>
void Exponentiator< K >::compute_exp_relations (   )  [inline]
 

translate the equations in *source into equations in *target

This method examines the cleaned-up equations, and turns them into relations between the exp classes.

It uses the fact that the total exp class of a sum is the product of the total classes, and the "formula" for the exp_classes of a tensor product. In order to iterate this formula, we rely on exp_classes_after_tensoring().

Next, this method examines the lambda operations in *source, and translates these into relations between the exp classes as well. It relies on exp_classes_of_ext_power().

The total relations thus obtained are then split into homogeneous parts and added to exp_relations, and sorted in passing according to their homogeneous degree.

Definition at line 635 of file exp_classes.H.

template<class K>
Polynomial<K> Exponentiator< K >::compute_lambda_relation (  long  ext,
long  dim
)  [inline]
 

computes the universal polynomial for the exp classes of an external power

This is very similar in spirit to compute_tensor_relation().

Definition at line 448 of file exp_classes.H.

template<class K>
Polynomial<K> Exponentiator< K >::compute_tensor_relation (  long  max_dim1,
long  max_dim2
)  [inline]
 

computes the universal polynomial for the exp classes of a tensor product

So far, this requires the LEX term order.

We use the splitting principle, which says that one ought to look at the polynomial

\[P= \prod_{1\le i \le maxdim1,\\ 1\le j \le maxdim2} (1 + a_i + b_j) \]

which is graded (a_i and b_j having degree 1), and express it as

\[ P=Q(\sigma_1, \sigma_2, \ldots, \sigma'_1, \sigma'_2, \ldots) \]

where $ \sigma_k $ is the k-th symmetric function in the a_i's (resp ... obvious). Then, Q(w_i, w'_j) is the total exp class of the tensor product of the two representations with exp classes w_i and w'_j respectively.

Returns:
Q, as a polynomial in the 'variables' s[i] and sp[j]. Further substitutions need to be made in order to obtain the exp classes of the product of two specific representations.

Definition at line 322 of file exp_classes.H.

template<class K>
void Exponentiator< K >::create_extra_variables (  string  prefix  )  [inline]
 

creates a bunch of temporary variables

we shall need to compute the exp-classes of a tensor product. So we need a bunch of new indeterminates just for this, as well as the "roots" needed to apply the splitting principle. We add these to *target rather than work in a separate algebra. It will be convenient that the variables are independant from all the other ones in *target, when we make some substitutions (we can then proceed one variable at a time).

Definition at line 188 of file exp_classes.H.

template<class K>
virtual void Exponentiator< K >::create_regular_variables (  string  prefix  )  [inline, virtual]
 

creates the variables in *target

Say prefix is "c" and factor is 2. Then for each variable in *source, call it x, of augmentation n, we create variables c_1(x) of degree 2, c_2(x) of degree 4, ..., c_n(x) of degree 2n, in *target.

Reimplemented in Chern_Maker, and SW_Maker.

Definition at line 142 of file exp_classes.H.

template<class K>
void Exponentiator< K >::exp_classes_after_tensoring (  const Polynomial< K > &  exp,
long  dim,
const PowProd &  pow,
Polynomial< K > &  result
)  [inline]
 

recursively compute the exp classes of a tensor product

Parameters:
exp : the total exp class of a representation, call it r
dim : the dimension of r
pow : a powerproduct, of which we think as a tensor product of representations.
result : after execution, this will hold the total exp classe of the tensor product of r with the representations described by pow.
This is recursive, and in order to compute the exp classes of a pow, one may use 
 exp_classes_after_tensoring(target->one(),
                             1, // trivial rep of dim 1
                             pow, result);
Note: The formulae use universal polynomials, one for each pair of integers. They are computed by compute_tensor_relation(). This may take time, so w store the universal polynomials which have already been computed in univ_computed.
See also:
univ_computed, compute_tensor_relation()

Definition at line 540 of file exp_classes.H.

Referenced by SW_Maker::translate_homomorphism().

template<class K>
Polynomial<K> Exponentiator< K >::exp_classes_of_ext_power (  long  thevar,
long  ext
)  [inline]
 

compute the exp classes of an exterior power of a representation

This method is to compute_lambda_relation() very much what exp_classes_after_tensoring() is to compute_tensor_relation(), namely a convenient interface to it. It includes a mechanism for storing the universal polynomials which have already been computed.

Parameters:
thevar : the variable, that is, the representation
ext : the desired exterior power
Returns:
the total exp class of thevar, as a graded polynomial in *target.

Definition at line 599 of file exp_classes.H.

template<class K>
void Exponentiator< K >::kill_extra_variables (   )  [inline]
 

as it says, really.

Definition at line 224 of file exp_classes.H.

template<class K>
void Exponentiator< K >::start (  RepresentationRing *  thesource,
GradedAlgebra< K > *  thetarget,
string  prefix,
long  thefactor
)  [inline]
 

gets the computation going

This is the first thing to read in the comments. This method calls all the others in a precise order. It is possible to use some of the methods independantly, but mostly they should be use only in this order (follow the links to find out what each method does):

  • First there is a call to create_regular_variables(). Note that this sets up max_dim, and populates var.
    See also:
    max_dim, var
  • Then clean_up_equations() is invoked. This is the time when max_dim_rel is computed.
    See also:
    max_dim_rel
  • Next we call create_extra_variables(), which needs to know max_dim_rel and max_dim. It populates a, b, s and sp.
    See also:
    a, b, s, sp (follow this link for a summary of all the variables created.)
  • Then comes compute_exp_relations(), doing the actual work. This fills total_relations (see note 2 below).
  • split_and_sort() is here next, to split the relations into homogeneous parts and add them to exp_relations in nondecreasing order of degree.
  • We kill the temporary variables which were needed before, using kill_extra_variables().
  • Finally, add_relations() takes the relations in exp_relations, adds them to *target and releases some memory..
Note 1: After all this, you may want to run target->find_redundancies() in order to simplify the presentation.

Note 2: It is not expected that total_relations is empty before we start. Indeed, the class SW_Maker, which inherits from Exponentiator<F_2>, exploits this by adding some total relations before things get started (in turn, these are relations coming from another Exponentiator<F_2>, namely Chern_Maker).

Definition at line 841 of file exp_classes.H.

Referenced by SW_Maker::start().

template<class K>
void Exponentiator< K >::write_lambda_factors (  list< Polynomial< K > > &  result,
long  ext,
long  first,
long  last
)  [inline]
 

internal use only -- used by compute_lambda_relation()

This writes in the list 'result' a collection of polynomials of the form I + a[i] + a[j]. The product of all these terms is the universal polynomial for lambda operations (or rather, it will be so when written as a polynomial in the elementary symmetric functions).

Definition at line 416 of file exp_classes.H.

Member Data Documentation

template<class K>
Tuple< Polynomial<K> > Exponentiator< K >::a
 

the "extra" variables, as polynomials

Here's a summary of all the variables created:

  • The variables numbered 1 to last_actual_variable are the exp classes of the variables in *source. They are stored as var[i,j].
    See also:
    var.
  • The variables last_actual_variable + 1 to last_actual_variable + max_dim are formal "roots" needed for the splitting principle, and they are stored as polynomials under a[1], a[2], ..., a[max_dim].
  • Similarly, the next variables are roots, stored as b[1], b[2], ..., b[max_dim_rel].
  • The next variables (max_dim of them) are used as generic exp classes, stored as s[1], ..., s[max_dim], and we think of s[i] as the i-th symmetric function in the a[j]'s.
  • Likewise for the final set of variables, stored as sp[1], ..., sp[max_dim_rel], (sp for s prime), thought of as symmetric functions in the b[j]'s.

Definition at line 88 of file exp_classes.H.

template<class K>
Tuple< Polynomial<K> > Exponentiator< K >::b
 

the "extra" variables, as polynomials

Here's a summary of all the variables created:

  • The variables numbered 1 to last_actual_variable are the exp classes of the variables in *source. They are stored as var[i,j].
    See also:
    var.
  • The variables last_actual_variable + 1 to last_actual_variable + max_dim are formal "roots" needed for the splitting principle, and they are stored as polynomials under a[1], a[2], ..., a[max_dim].
  • Similarly, the next variables are roots, stored as b[1], b[2], ..., b[max_dim_rel].
  • The next variables (max_dim of them) are used as generic exp classes, stored as s[1], ..., s[max_dim], and we think of s[i] as the i-th symmetric function in the a[j]'s.
  • Likewise for the final set of variables, stored as sp[1], ..., sp[max_dim_rel], (sp for s prime), thought of as symmetric functions in the b[j]'s.

Definition at line 88 of file exp_classes.H.

template<class K>
list< pair< Polynomial<QQ>, Polynomial<QQ> > > Exponentiator< K >::equations
 

cleaned up equations

in *source we have equations of the form P=0, where P has rational coefficients. We transform this into LHS = RHS, where each side has positive, integer coefficients. It is convenient, however, to store these as Polynomial<QQ> rather than Polynomial<ZZ>.

Definition at line 100 of file exp_classes.H.

template<class K>
list< Polynomial<K> > Exponentiator< K >::exp_relations
 

same as total_relations, only homogeneous and sorted by degree

Definition at line 104 of file exp_classes.H.

template<class K>
long Exponentiator< K >::factor
 

typically 2 for Chern classes, 1 for SW

Definition at line 108 of file exp_classes.H.

template<class K>
map< pair<long, long> , Polynomial<K> > Exponentiator< K >::lambda_univ_computed
 

universal polynomial for lambda operations

Definition at line 123 of file exp_classes.H.

template<class K>
long Exponentiator< K >::last_actual_variable
 

remembers the number of "regular" variables.

we shall temporarily create lots of "extra" variables in *target before eventually killing them. See comments on variables a, b, s, sp for more. Set up during create_extra_variables().

Definition at line 42 of file exp_classes.H.

template<class K>
long Exponentiator< K >::max_dim
 

largest dimension of a rep among the variables in *source

Computed during create_regular_variables(). Needed in order to put a bound on the number of "extra" variables.

Definition at line 48 of file exp_classes.H.

template<class K>
long Exponentiator< K >::max_dim_rel
 

largest dimension of a rep among the relations in *source

Each power product in the relations is thought of as a representation (tensor product of the reps corresponding to the variables). We need to find an upper bound (not exactly sharp, but it does not matter) on the dimension of these reps. This will put an upper bound on the "extra" variables which need to be created. This is computed during clean_up_equations().

Definition at line 60 of file exp_classes.H.

template<class K>
Tuple< Polynomial<K> > Exponentiator< K >::s
 

the "extra" variables, as polynomials

Here's a summary of all the variables created:

  • The variables numbered 1 to last_actual_variable are the exp classes of the variables in *source. They are stored as var[i,j].
    See also:
    var.
  • The variables last_actual_variable + 1 to last_actual_variable + max_dim are formal "roots" needed for the splitting principle, and they are stored as polynomials under a[1], a[2], ..., a[max_dim].
  • Similarly, the next variables are roots, stored as b[1], b[2], ..., b[max_dim_rel].
  • The next variables (max_dim of them) are used as generic exp classes, stored as s[1], ..., s[max_dim], and we think of s[i] as the i-th symmetric function in the a[j]'s.
  • Likewise for the final set of variables, stored as sp[1], ..., sp[max_dim_rel], (sp for s prime), thought of as symmetric functions in the b[j]'s.

Definition at line 88 of file exp_classes.H.

template<class K>
RepresentationRing* Exponentiator< K >::source
 

the representation ring

Definition at line 29 of file exp_classes.H.

template<class K>
Tuple< Polynomial<K> > Exponentiator< K >::sp
 

the "extra" variables, as polynomials

Here's a summary of all the variables created:

  • The variables numbered 1 to last_actual_variable are the exp classes of the variables in *source. They are stored as var[i,j].
    See also:
    var.
  • The variables last_actual_variable + 1 to last_actual_variable + max_dim are formal "roots" needed for the splitting principle, and they are stored as polynomials under a[1], a[2], ..., a[max_dim].
  • Similarly, the next variables are roots, stored as b[1], b[2], ..., b[max_dim_rel].
  • The next variables (max_dim of them) are used as generic exp classes, stored as s[1], ..., s[max_dim], and we think of s[i] as the i-th symmetric function in the a[j]'s.
  • Likewise for the final set of variables, stored as sp[1], ..., sp[max_dim_rel], (sp for s prime), thought of as symmetric functions in the b[j]'s.

Definition at line 88 of file exp_classes.H.

template<class K>
GradedAlgebra<K>* Exponentiator< K >::target
 

the outcome - a graded algebra

Definition at line 31 of file exp_classes.H.

Referenced by SW_Maker::translate_homomorphism().

template<class K>
list< Polynomial<K> > Exponentiator< K >::total_relations
 

all resulting total relations between exp classes

Definition at line 102 of file exp_classes.H.

template<class K>
map< pair<long, long> , Polynomial<K> > Exponentiator< K >::univ_computed
 

universal polynomials for tensor products

The exp classes of a tensor products are computed by means of universal polynomials. Here they are computed by compute_tensor_relation(long, long). In order to compute each of these only once, we store the universal polynomials needed in the following map. The two integers are the dimensions of the two reps.

Definition at line 121 of file exp_classes.H.

template<class K>
Table< Polynomial<K> > Exponentiator< K >::var
 

the "regular" variables created in *target, as polynomials

var(i,j) will contain the j-th exp-class (chern or sw...) of variable #i, as a Polynomial<K>.

Definition at line 67 of file exp_classes.H.

The documentation for this class was generated from the following file:
Generated on Wed Jun 18 17:22:44 2008 for Pierre Guillot by  doxygen 1.3.9.1