repring.cpp

#include "repring.H"
#include "my_gmp.H"
using namespace std;

// methods for (complex) representation rings *******************************
//***************************************************************************

RepresentationRing::RepresentationRing(){

  base_field= "complex";
}


// as usual, we need to rewrite the following
Polynomial<QQ> RepresentationRing::new_variable(const string& name, 
                                                const QQ& aug, 
                                                long index){
  Polynomial<QQ> ans;

  ans= AugmentedAlgebra<QQ>::new_variable(name, aug);
  schur_indices[this->var_in_use]= index;

  return ans;
}

void RepresentationRing::swap_variables_order(long i, long j,
                                              list< Polynomial<QQ> >& polys){
  Tuple< Polynomial<QQ> > dummy;
  long a, b;

  AugmentedAlgebra<QQ>::swap_variables_order(i,j,polys);
  dummy.steal(lambda_operations[i]);
  lambda_operations[i].steal(lambda_operations[j]);
  lambda_operations[j].steal(dummy);

  // now parse through the polynomials in
  // the lambda operations and swap
  for(a=1; a<= var_in_use; a++)
    for(b= 2; b<= epsilon[a]; b++)
      lambda_operations[a][b].swap_variables(i, j);
  // deal with the schur indices
 long dummy_s;

  dummy_s= schur_indices[i];
  schur_indices[i]= schur_indices[j];
  schur_indices[j]= dummy_s;

}


void RepresentationRing::swap_variables_order(long i, long j){
  list< Polynomial<QQ> > empty_list;
  
  this->swap_variables_order(i,j,empty_list);
}

void RepresentationRing::kill_top_variable(const Polynomial<QQ>& replacement,
                                           list< Polynomial<QQ> >& polys){
  long i, j;  


  AugmentedAlgebra<QQ>::kill_top_variable(replacement,polys);
  schur_indices.erase(this->var_in_use + 1);
  lambda_operations.erase(this->var_in_use + 1);
  // now we need to make the substitutions in the lambda-operations
  for(i=1; i<= var_in_use; i++)
    for(j= 2; j<= epsilon[i]; j++)
      lambda_operations[i][j].substitute_variable(var_in_use + 1, replacement);
}

void RepresentationRing::kill_top_variable(const Polynomial<QQ>& replacement){
  list< Polynomial<QQ> > empty_list;
  
  this->kill_top_variable(replacement,empty_list);
}

// ok! now the interesting new methods

long RepresentationRing::read_variables(ifstream& thefile, Tuple< Polynomial<QQ> >& thevars){
  long n, i, index;  
  string buf;
  ostringstream autoname;

  /* careful!  GAP produces n representations, the first one being the
   trivial one (normally...). So the others are numbered 2, 3, ...,
   n. (Lists in GAP start from 1, not 0.) However the name of variable
   #i is r_{i-1} ie the names are r_1, r_2, ..., r_{n-1}.
   */

  thefile >> n;
  thevars.resize(n+1);
  thevars[1]=one(); // drop thevars[0]...
  for(i=2; i <= n; i++){
    thefile >> index;
    thefile >> buf; //reads the degree of the rep
    autoname.str("");
    autoname << "r_" << i-1;
    thevars[i]= new_variable(autoname.str(),QQ(buf), index);
  }

  return n;


}

bool RepresentationRing::read_from_GAP_file(const string& name){
  ifstream in_file(name.c_str());
  long n,i,j,k,nb_relations, current_relation,var, dim;
  string buf;
  Tuple< Polynomial<QQ> > vars;
  Polynomial<QQ> rel;
  //list < Polynomial<QQ> > structure_constants;
  list< Polynomial<QQ> >::iterator it,itprime; 
  // bool grobner_done;

  if( in_file.fail() ){
    cout << "Unable to read from file " << string(name) << endl;
    return false;
  }

  // read the varibles
  // *****************
  n= this->read_variables(in_file,vars);


  // read the relations
  // ******************

  relations.generators.clear();

  nb_relations= 0;
  for(i= 2; i<= n; i++)
    for(j= i; j<= n; j++){
      rel= vars[i] * vars[j] * (-1);
      for(k=1; k<= n; k++){
        in_file >> buf;
        rel+= vars[k] * QQ(buf);
      }
      relations.generators.push_back(rel);
      nb_relations++;
      //      add_relation(rel);
    }

  // read the lambda operations
  // **************************

  for(i= 1; i< n; i++){
    dim= ZZtolong(epsilon[i]);// dim of the rep
    lambda_operations[i].resize(dim+1);
    for(j=2; j <= dim; j++){
      rel.sets_to_zero();
      for(k= 1; k<= n; k++){
        in_file >> buf;  
        rel+= vars[k] * QQ(buf);
      }
      lambda_operations[i][j]= rel;
    }
  }

  // now we cut down the relations and variables
  // *******************************************

  //  grobner_done= false;

  if(verbose){
    cout << "Original presentation:" << endl << endl;
    cout << var_in_use << " variables, "
         << nb_relations << " relations" << endl << endl;
  }

  //  cout << *((RealRepresentationRing *) this) << endl;
  /*
    nb_relations= 0;
    current_relation= 1;
  
  for(it= structure_constants.begin(); 
   it!= structure_constants.end();){
      
      if( (var= it->has_lonely_variable(rel)) > 0 ){
     if(verbose)
       cout << "relation " << current_relation
         << " yields a variable redundancy: $"
         << vars[var+1] << " = " << rel 
         << "$" << endl << endl;
         it= structure_constants.erase(it);
         kill_variable(var, rel, structure_constants);
         grobner_done= false;
         }
         else{
         
         if( !grobner_done ){
         find_grobner_basis();
         grobner_done= true;
         }
         rel= reduced_form( *it );
         if( !rel.is_zero() ){
         nb_relations++;
         if(very_verbose)
         cout << "adding relation " << current_relation
           << " (total " << nb_relations << " relations added): "
                << "$" << rel << "$" << endl << endl;
                add_relation(rel);
                grobner_done= false;
                it++;
         }
         else{
         if(very_verbose)
         cout << "relation " << current_relation << " redundant"
         << endl << endl;
         it= structure_constants.erase(it);
         }
         }
         current_relation++;
         }
         //cut_down_variables();
         if(verbose)
         cout << "{\\bf Final presentation: }" 
         << var_in_use << " variables kept, " << endl
         << nb_relations << " relations kept" 
         << endl << endl;
         
         // having selected the non-redudant structure constants,
         // and replaced the redundant variables by their expression
         // in terms of the others, we can take the structure
         // constants as generators for the ideal of relations,
         // rather than the current generators which may only be
         // generators over QQ.
         
         relations.generators= structure_constants;
  */
   return true;
}


ostream& operator<<(ostream& os, const RepresentationRing& R){

  map< long, Tuple< Polynomial<QQ> > >::const_iterator it_lambda;
  map<long, string>::const_iterator it_gen;
  map<long, QQ>::const_iterator it_aug;
  list< Polynomial<QQ> >::const_iterator it_rel;
  map<long, long>::const_iterator it_schur;
  long j;
    
  os << "generators:" << endl << endl;
  for(  it_gen= R.names.begin(), 
          it_aug= R.epsilon.begin(), 
          it_schur= R.schur_indices.begin(); 
        it_gen!= R.names.end(); 
        it_gen++, it_aug++, it_schur++){
    
    os << "$" << it_gen->second << "$";
    switch(it_schur->second){
    case 1:
      cout << " of real type";
      break;
    case 2:
      cout << " of complex type";
      break;
    case 4:
      cout << " of quaternion type";
      break;
    }
    cout << ", its " << R.base_field
         << " dimension is "
         << it_aug->second << endl << endl;    
  }  

  os << "relations:" << endl << endl;
  for(it_rel=R.relations.generators.begin(); 
      it_rel!= R.relations.generators.end(); it_rel++)
    os << "$" << *it_rel << "$" << endl << endl;

  os << endl << "lambda operations:" << endl << endl;
  for(it_lambda= R.lambda_operations.begin(), it_gen= R.names.begin();
      it_lambda != R.lambda_operations.end();
      it_lambda++, it_gen++)

    for(j=2; j< it_lambda->second.size(); j++)
      cout << "$\\lambda^" << j << "("
           << it_gen->second << ") = "
           << it_lambda->second[j] << "$"
           << endl << endl;

  
  return os;

}





// methods for real representation rings *************************************
// ***************************************************************************

RealRepresentationRing::RealRepresentationRing(){

  base_field= "real";
}



long RealRepresentationRing::read_variables(ifstream& thefile, Tuple< Polynomial<QQ> >& thevars){
  long n, i, buf2, added;  
  string buf1;
  ostringstream autoname, autoname2;

  /* careful!  GAP produces n representations, the first one being the
   trivial one (normally...). So the others are numbered 2, 3, ...,
   n. (Lists in GAP start from 1, not 0.) However the name of variable
   #i is r_{i-1} ie the names are r_1, r_2, ..., r_{n-1}.
   */

  added= 1;
  thefile >> n;
  thevars.resize(n+1);
  thevars[1]=one(); // drop thevars[0]...
  for(i=2; i <= n; i++){
    thefile >> buf2; //reads the schur index
    thefile >> buf1; //reads the degree of the rep

    autoname.str(""); 
    autoname << "r_" << i-1;


    if( buf2 > 0 ){ // buf2==0 means this is the complex conjugate
      added++;      // of some rep already added
      thevars[added]= new_variable(autoname.str(), QQ(buf1), buf2);
    }
    else{  // we register the conjugacy
      autoname2.str("");
      autoname2 << "r_" << ZZ(buf1)-1;// in this case buf1 gives the conjugate
      conjugates[autoname.str()]= autoname2.str(); //not the degree
    }
    
  }

  return added;
}

/*
  ostream& operator<<(ostream& os, const RealRepresentationRing& R){
  
  map< long, Tuple< Polynomial<QQ> > >::const_iterator it_lambda;
  map<long, string>::const_iterator it_gen;
  map<long, QQ>::const_iterator it_aug;
  list< Polynomial<QQ> >::const_iterator it_rel;
  map<long, long>::const_iterator it_schur;
  long j;
  
  os << "generators:" << endl << endl;
  for(  it_gen= R.names.begin(), 
  it_aug= R.epsilon.begin(), 
  it_schur= R.schur_indices.begin(); 
  it_gen!= R.names.end(); 
  it_gen++, it_aug++, it_schur++){
  
  os << "$" << it_gen->second << "$";
  switch(it_schur->second){
  case 1:
  cout << " of real type";
  break;
  case 2:
  cout << " of complex type";
  break;
  case 4:
  cout << " of quaternion type";
  break;
  }
  cout << ", its real dimension is "
  << it_aug->second << endl << endl;    
  }  
  
  os << "relations:" << endl << endl;
  for(it_rel=R.relations.generators.begin(); 
  it_rel!= R.relations.generators.end(); it_rel++)
  os << "$" << *it_rel << "$" << endl << endl;
  
  os << endl << "lambda operations:" << endl << endl;
  for(it_lambda= R.lambda_operations.begin(), it_gen= R.names.begin();
  it_lambda != R.lambda_operations.end();
  it_lambda++, it_gen++)
  
  for(j=2; j< it_lambda->second.size(); j++)
  cout << "$\\lambda^" << j << "("
  << it_gen->second << ") = "
  << it_lambda->second[j] << "$"
  << endl << endl;
  
  
  return os;
  
  }*/

---