rep.cpp

#include <fstream>
#include <iostream>
#include "cmdline.H"
#include "my_gmp.H"
#include "algebras.H"
#include "repring.H"
#include "ftwo.H"
#include "exp_classes.H"
#include "sw_maker.H"
#include "chern_maker.H"
using namespace std;


int main(int argc, char** argv){

  CommandLine::init(argc, argv);
  // if no parameter is given, display this and exit
  if(CommandLine::parameters.size() != 1){
    cout << "Usage: rep <name> [options]" << endl
         << "This will create 'name.W' and "
         << "'name.W.res.elemab' based on " << endl
         << "information contained in 'name.gaprep', "
         << "'name.gaprep.real', " << endl 
         <<"and 'name.res.elemab'."
         << endl
         << "Options:" << endl
         << "         -quiet: displays less messages" 
         << endl
         << "         -silent: displays no " 
         << "messages at all."
         << endl;
    return 1;
  }

  RepresentationRing R_CG;
  RealRepresentationRing R_RG;  
  
  // checks if the file name is valid
  string name= CommandLine::parameters[0];
  
  // sets up the order
  PowProd::use_order(LEX);

  // sets verbosity
  R_CG.verbose= R_RG.verbose= true;
  R_CG.very_verbose= R_RG.very_verbose= true;
  if(CommandLine::has_tag("-quiet")) 
    R_CG.very_verbose= R_RG.very_verbose= false;
  if(CommandLine::has_tag("-silent")){
    R_CG.verbose= R_RG.verbose= false;
    R_CG.very_verbose= R_RG.very_verbose= false;
  }
  
  // part one: read info on the reprings //////
  
  if(R_CG.verbose)
    cout << "\\bigskip {\\large\\bf Computing a presentation"
         << " of the complex representation ring}"
         << endl << endl;
  
  
  R_CG.read_from_GAP_file(name + ".gaprep");
  
  
  // finally display the thing
  if(R_CG.very_verbose)
    cout << endl << "Current presentation:" 
         << endl << endl
         << R_CG << endl;
  
  if(R_CG.verbose)
    cout << "\\bigskip {\\large\\bf Computing a presentation"
         << " of the real representation ring}"
         << endl << endl;

  
  R_RG.read_from_GAP_file(name + ".gaprep.real");
  //R_RG.find_unitary_redundancies();

  // finally display the thing
  if(R_CG.very_verbose)
    cout << endl << "Current presentation:" 
         << endl << endl
         << R_RG << endl;


  
  // part two: computing exp classes ////////

  GradedAlgebra<F_2> H_ch;  //chern ring
  UnstableAlgebra H_sw; // stiefel whitney ring
  Chern_Maker chern;
  SW_Maker sw;
  // verbosity according to that of A
  H_ch.verbose= H_sw.verbose= R_CG.verbose;
  H_ch.very_verbose= H_sw.very_verbose= R_CG.very_verbose;
  
  if(R_CG.verbose)
    cout << "\\bigskip {\\large\\bf Computing"
         << " Chern classes}"
         << endl << endl;
  //this computes the formal ring of Chern classes
  //and writes the answer in H_ch  
  chern.start(&R_CG, &H_ch);

  if(R_CG.very_verbose)
    cout << H_ch << endl;
  
  if(R_CG.verbose)
    cout << "\\bigskip {\\large\\bf Computing"
         << " Stiefel-Whitney classes}"
         << endl << endl;
  //this computes the formal ring of sw classes,
  //taking H_ch into account, and writes the
  //answer in H_sw
  sw.start(&R_RG, &H_sw, &H_ch);
  //sw.start(&R_RG, &H_sw, 0);
  

  //f is the natural homomorphisms from the chern ring
  // to the sw ring.
  AffineHomomorphism<F_2> f( &H_ch, &H_sw );
  // in fact f has been computed by the SW_Maker sw
  // during start(), and stored as an AbstractHomomorphism<F_2>
  // in sw.chern_sw
  f.get_data_from(sw.chern_sw);
  
  if(R_CG.very_verbose)
    cout << "Correspondence between Chern and " 
         <<"Stiefel-Whitney classes: " 
         << endl << f << endl;

  
  // part three: reduction homomorphisms ///////
  
  //H_reduced will be defined from H_sw by saturating
  //the ideal of relations with respect to Steenrod
  //operations, and also finding a minimal presentation.
  UnstableAlgebra H_reduced;
  H_reduced= H_sw;
  H_reduced.fix_alphabets();
  //in order to save memory, we erase the relations in H_sw
  H_sw.relations.generators.clear();
  //the following does the reduction and creates the
  //reduction homomorphism in g
  AffineHomomorphism<F_2> g( &H_sw, &H_reduced);
  g.get_data_from( H_reduced.saturate_and_reduce() );
  f= g * f;
  
  if(R_CG.verbose){
    H_reduced.display();
    cout << "Reduction homomorphism: " << endl
         << g << endl;
    
    cout << "Chern classes in the reduced ring: " << endl
         <<  f << endl;
  }

  // write to files ///////
  string out_W= name + ".W";
  ofstream W_file(out_W.c_str());
  W_file << H_reduced;

  string out_sw= name + ".sw";
  ofstream sw_file(out_sw.c_str());
  sw_file << H_sw;
  sw_file << g;

  string out_chern= name + ".chern";
  ofstream chern_file(out_chern.c_str());
  chern_file << H_ch;
  chern_file << f;

  
  //it will be convenient to compute a "section" s for
  //g. Explanation: in most cases, g is an isomorphism
  //and s is going to be its inverse. However if the 
  //Steenrod operations have added relations in H_reduced
  //which were not present in H_sw, then s will be a
  //homomorphism from H_reduced to H_sw such that g*s=id,
  //and which... is mathematically ill-defined !! in the
  //sense that s(relation) != 0 for some relation. This is
  //not important, as s will be well-defined when we compose
  //it with the restriction homomorphisms H_sw -> H_sw(subgroup)
  //that we care about.
  AffineHomomorphism<F_2> s(&H_reduced, &H_sw);
  long i, j;
  Tuple< Polynomial<F_2> > var= H_sw.get_variables();

  for(i=1; i<= H_reduced.variables_in_use(); i++){
    //we look for a variable in H_sw with the right name
    for(j=1; j<= H_sw.variables_in_use(); j++)
      if( H_sw.nameof(j) == H_reduced.nameof(i) )
        break;//done!
    s.set_image(i, var[j] );
  }

  //  cout << "section found: " << endl << s << endl;  

  // part four: reduction to elementary abelian subgroups // 

  if(R_CG.verbose)
    cout << "Computing the restrictions to "
         << "elementary abelian subgroups" << endl;



  //the information on this is in the following file:
  string res_name= name + ".res.elemab";// produced by GAP
  string save_name=name + ".W.res.elemab"; //this will be the output
  ifstream res_file(res_name.c_str());
  ofstream save_res(save_name.c_str());
  long nb_elemab;
  string rank, prev_rank;;
  RealRepresentationRing R_elemab, empty_ring;
  UnstableAlgebra H_elemab, H_elemab_red, empty_unstable;
  AffineHomomorphism<QQ> res_hom(&R_RG, &R_elemab);
  AffineHomomorphism<F_2> restriction( &H_sw, &H_elemab);
  AffineHomomorphism<F_2> reduc( &H_elemab, &H_elemab_red);
//final answer which will be saved:
  AffineHomomorphism<F_2> save_hom(&H_reduced, &H_elemab_red);
  SW_Maker sw_elemab, sw_empty;;

  res_file >> nb_elemab;
  save_res << nb_elemab << " ";

  prev_rank="";

  for(i=0; i< nb_elemab; i++){
    res_file >> rank;
    save_res << rank << " ";

    if( rank != prev_rank ){
      res_name= "elemab-rank" + rank + ".gaprep.real";
      R_elemab= empty_ring; //quickest way to erase data
      R_elemab.read_from_GAP_file(res_name);
      sw_elemab= sw_empty; //ditto
      H_elemab= empty_unstable; //ditto
      sw_elemab.start(&R_elemab, &H_elemab);
      H_elemab_red= H_elemab;
      H_elemab_red.fix_alphabets();
      reduc.get_data_from( H_elemab_red.find_redundancies() );
    }
    prev_rank= rank;
    res_hom.read_from_GAP_file(res_file); // !

    //    cout << R_elemab << endl;
    //cout << res_hom << endl;

    restriction= sw.translate_homomorphism(res_hom, sw_elemab); // !!!
    //now we have the restriction homomorphisms
    //display it, save it, etc...
    save_hom= reduc * restriction * s; 

    if(R_CG.very_verbose){
      cout << "restriction to elementary abelian subgroup "
           << i << endl;
      cout << save_hom << endl;
    }
    save_res << save_hom;
  }

  
  /*
    cout << "debug: what we read from the file" << endl;
    sw_out.close();
    ifstream debug(out_name.c_str());
    debug >> H_reduced;
    H_reduced.display();
  */
  
  return 0;
}

---