sw_maker.cpp

#include "sw_maker.H"
using namespace std;




void SW_Maker::start(RealRepresentationRing *thesource, 
                     GradedAlgebra<F_2> *thetarget,
                     GradedAlgebra<F_2> *the_chern_ring){

  chern_ring= the_chern_ring;
  Exponentiator<F_2>::start((RepresentationRing *) thesource, thetarget, string("w"), 1);
}


void SW_Maker::create_regular_variables(string prefix){
  long i, j, k, dim;
  QQ d;
  Polynomial<F_2> zero_poly;
  ostringstream autoname;
  RealRepresentationRing *realsource;
  map< long, pair< long, long > > corresp;
  
  // looks for the largest dimension
  dim= 0;
  for(i=1; i <= source->variables_in_use(); i++){
    d= source->epsilon[i];
    if( d > dim)
      dim= ZZtolong(d);
  }
  
  max_dim= dim;
  
  var.resize(source->variables_in_use() +1, dim+1);
  zero_poly.alphabet= target;
  zero_poly.sets_to_zero();
  realsource= (RealRepresentationRing *) source;
  
  //now create the variables and populate var
  //takes the schur indices into account
  k= 0;
  corresp.clear();
  for(i=1; i <= source->variables_in_use(); i++){
    dim= ZZtolong( source->epsilon[i] );
    for(j=1; j<= dim; j++){ 
      // we need to take the schur index into account
      if( (j % realsource->schur_indices[i]) == 0 ){
        autoname.str("");
        autoname << prefix << "_" << j
                 << "(" << source->nameof(i) << ")";
        var(i,j)= target->new_variable(autoname.str(), factor*j);
        k++;
        corresp[k]= make_pair(i,j);
      }
      else
        var(i,j)= zero_poly;
    }// for j
  }// for i

  //now write the steenrod relations, using Wu's formula
  
  UnstableAlgebra *A;
  A= (UnstableAlgebra *) target;
  A->write_trivial_steenrod_operations();
  Polynomial<F_2> P= target->one();
  long s, thevar;
  
  for(thevar=1; thevar <= target->variables_in_use(); thevar++){
    i=  corresp[thevar].first;
    j=  corresp[thevar].second;
    dim = ZZtolong( source->epsilon[i] );
    
    //    cout << "i= " << i << " j= " << j << " dim= " << dim << endl;
    
    for(k=1; k<j; k++){   //Sq^k w_j (i-eme rep)
      P.sets_to_zero();
      for(s= k; s >= 1 && j+k-s <= dim; s--){
        P+= var(i,s)*var(i,j+k-s)*comb(k-j, k-s);//Wu's formula
      }
      if(j+k <= dim)
        P+= var(i, j+k)*comb(k-j, k); //case s==0 slightly different
      //now Sq^k w_j (r_i)= P
      A->steenrod[thevar][k]= P;
      
      
    }//for k
  }//for the var
  
  // add the complex relations, if a pointer
  // has been supplied to the chern ring
  if(chern_ring != 0)
    add_complex_relations();

}

void SW_Maker::add_complex_relations(){
  long i,j;
  string name, nameconj;
  long index;
  list< Polynomial<F_2> >::iterator it;
  Polynomial<F_2> P;
  RealRepresentationRing *realsource;

  realsource= (RealRepresentationRing *) source;

  // translate the chern classes (ie generators
  // of *chern_ring) into polynomials in sw classes
  for(i=1; i <= chern_ring->variables_in_use(); i++){
    name= name_of_rep(chern_ring->nameof(i));
    index= index_of_chern_class(chern_ring->nameof(i));
    // let's look for 'name' in *source
    for(j=1; j<= source->variables_in_use(); j++)
      if( source->nameof(j) == name )
        break;
    
    if(j <= source->variables_in_use() ){ // found ?
      if(target->very_verbose)
        cout << "found variable "
             << source->nameof(j)
             << " in the real representation ring" 
             << endl;
      
      //examine type
      if( source->schur_indices[j] == 1 ) // real ?
        chern_sw.set_image(i, var(j,index) * var(j,index) ); // c_idx=w_idx 2
      else
        chern_sw.set_image(i, var(j, 2*index) ); //c_idx = w_2idx
      
    }
    else{
      nameconj= realsource->conjugates[name];
      if(target->very_verbose)
        cout << name
             << " is conjugate to "
             << nameconj << endl;
      // so let's find it...
      for(j=1; j<= source->variables_in_use(); j++)
        if( source->nameof(j) == nameconj )
          break;
      // must be complex
      chern_sw.set_image(i, var(j, 2*index) );  
    }
    /*    if(target->very_verbose)
      cout << "will substitute "
           << chern_ring->nameof(i)
           << " by " << chern_sw.images[i] //error here !
           << endl;*/
    
  }

  // ok ! now we browse through the equations in chern_ring
  // and make the substitutions
  for(it= chern_ring->relations.generators.begin();
      it != chern_ring->relations.generators.end();
      it++){
    P= *it;

    if(target->very_verbose)
      cout << "we look at complex relation " 
           << P << " ..." << endl;

    P= chern_sw.of( P );
    /*
    P.shift_variables( target->variables_in_use()  );
    for(i=1; i <= chern_ring->variables_in_use(); i++) 
    P.substitute_variable( target->variables_in_use() + i, chern_sw[i] );*/
    P.alphabet= target;
    if(target->very_verbose)
      cout << "and turn it into " << P << endl;
    total_relations.push_back(P);

  }
}


string SW_Maker::name_of_rep(const string& name_chern){
  string::size_type leftpar, rightpar;

  leftpar= name_chern.find("(") + 1;
  rightpar= name_chern.find(")");
  return name_chern.substr(leftpar, rightpar-leftpar);
}

long SW_Maker::index_of_chern_class(const string& name_chern){
  string::size_type underscore, leftpar;
  ZZ i;

  underscore= name_chern.find("_") + 1;
  leftpar= name_chern.find("(");
  i= ZZ(name_chern.substr(underscore, leftpar-underscore));
  return ZZtolong(i);
}
/*
  string SW_Maker::index_of_rep(const string& name_chern){
  string::size_type underscore;
  string name= name_of_rep(name_chern);
  ZZ i;
  
  underscore= name.find("_") + 1;
  leftpar= name_chern.find("(");
  i= ZZ(name.substr(underscore));
  return ZZtolong(i);
  }
*/



F_2 SW_Maker::comb(long n, long i){
  long num, den, k;

  if(i==0)
    return 1;

  for(num=1, k=n-i+1; k <= n; k++)
    num*= k;

  for(den=1, k=1; k<=i; k++)
    den*= k;

  return F_2( num/den );
}



AffineHomomorphism<F_2> SW_Maker::translate_homomorphism(const AffineHomomorphism<QQ>& r,
                                                         SW_Maker& sw){
  AffineHomomorphism<F_2> ans(target, sw.target);
  long i, j, dim, index=0;
  Polynomial<QQ> image;
  Polynomial<F_2> exp_image, P= sw.target->one();//for the alphabet;
  map< PowProd, QQ >::iterator it;


  for(i=1; i<= source->variables_in_use(); i++){

    image= r.of_generator(i);

    //first, we translate 'image' into its sw classes,
    //and store in exp_image.
    exp_image= sw.target->one();    
    for(it= image.coeffs.begin(); it!=image.coeffs.end(); it++){
      sw.exp_classes_after_tensoring(sw.target->one(), 1, it->first, P);
      //multiply exp_image by P^it->second
      for(j=0; j < ZZtolong(it->second); j++)
        exp_image *= P;
    }//done!!

    //now we browse the sw classes of rep #i, see which
    //are nonzero (cf schur indices!) and set ans( w_j )= j-th homogeneous part
    //of exp_image.
    dim= ZZtolong(source->epsilon.find(i)->second);//dim= dim of rep i
    for(j=1; j<= dim; j++){
      P= this->var(i,j);//w_j(r_i)
      if( !P.is_zero() ){
        index++;
        ans.set_image(index, sw.target->hom_part_of(exp_image, j));
      }
    }
  }

  return ans;
}

---