affhom.H

#ifndef _AFFHOM_H_
#define _AFFHOM_H_

#include "algebras.H"
using namespace std;




template <class K>
class AffineHomomorphism : public AbstractHomomorphism<K> {
 public:
  const AffineAlgebra<K> *source, *target;
  Ideal<K> kernel;

  AffineAlgebra<K> assoc_alg;
  
  // constructors///////////////////////////////////////////////////////

  AffineHomomorphism() : AbstractHomomorphism<K>::AbstractHomomorphism(){
    
    source= target= 0;
  }

  AffineHomomorphism(const AffineAlgebra<K> *thesource, 
                     const AffineAlgebra<K> *thetarget) : AbstractHomomorphism<K>::AbstractHomomorphism() {

    source= thesource;
    target= thetarget;
  }

  //little things /////////////////////////////////////////////////////////

  void make_identity(const AffineAlgebra<K> *ptr){

    source= target= ptr;
    AbstractHomomorphism<K>::make_identity(ptr->variables_in_use());
    fix_alphabets();
  }
  void fix_alphabets(){
    typename map< long, Polynomial<K> >::iterator it;

    for(it= this->images.begin(); it!= this->images.end(); it++)
      it->second.alphabet= (Alphabet *) target;
  }

  void remove_extra_data(){
    typename map< long, Polynomial<K> >::iterator it, itp;
    
    //undefine some images:
    for(it= this->images.begin(); it!= this->images.end();)
      if( it->first > source->variables_in_use() ){
        itp= it;
        itp++;
        this->images.erase(it->first);
        it= itp;
      }
      else
        it++;
    
    //now take care of the kernel
    typename list< Polynomial<K> >::iterator itker;

    for(itker= this->kernel.generators.begin();
        itker != this->kernel.generators.end();
        ){
      if( itker->nvars() > source->variables_in_use() ){
        itker= this->kernel.generators.erase( itker );
      }
      else
        itker++;
    }
  }

  bool fill_zeroes() 
  {
    long i;
    bool ans= false;
    Polynomial<K> P=target->one();
    
    P.sets_to_zero();
        
    for(i=1; i<= source->variables_in_use(); i++)
      if( !this->has_image_set(i) ){
        ans= true;
        this->set_image(i, P);
      }
    
    return ans;
  }
  

  void get_data_from(const AbstractHomomorphism<K>& f){
    AbstractHomomorphism<K> *ptr;

    ptr= (AbstractHomomorphism<K> *) this; //need to proceed this
    *ptr = f; //way in order to copy the protected data !!
    fix_alphabets();
    remove_extra_data();
  }

  bool is_well_defined() const {
    typename list< Polynomial<K> >::const_iterator it;

    for(it= source->relations.generators.begin();
        it != source->relations.generators.end();
        it++)
      if( !target->reduced_form( this->of(*it) ).is_zero() )
        return false;

    return true;
  }


  AffineHomomorphism<K> simple_section() const {
    AffineHomomorphism<K> ans;
    long i, j;
    Tuple< Polynomial<K> > x;

    ans.source= this->target;
    ans.target= this->source;
    x= source->get_variables();
    for(i=1; i<= target->variables_in_use(); i++) {
      for(j=1; j<= source->variables_in_use(); j++)
        if( source->nameof(j) == target->nameof(i) )
          break;
      ans.set_image(i, x[j]);
    }

    return ans;
  }


  void read_from_GAP_file(ifstream& file) {
    long i, j;
    Polynomial<K> P= target->one();
    K coeff;

    this->images.clear();
    for(i=1; i<= source->variables_in_use(); i++){
      P.sets_to_zero();
      for(j=0; j<= target->variables_in_use(); j++) {
        file >> coeff;
        P.add_term( PowProd(j), coeff);
      }
      this->set_image(i, P);
    }
  }



  //methods related to the kernel ////////////////////////////////////


  void compute_kernel() 
  {
    AffineAlgebra<K> alg;
    long i;
    Tuple< Polynomial<K> > vars= source->get_variables();
    Polynomial<K> P;
        
    alg= *source;
    alg.relations.generators.clear();
    alg.tensor_with(*target);
    for(i=1; i<= source->variables_in_use(); i++){
      P= this->of_generator(i);
      P.shift_variables( source->variables_in_use() );
      P*= -1;
      alg.add_relation( vars[i] + P);
    }
    

    alg.find_grobner_basis();
    alg.reduce_grobner_basis();

    

    kernel.generators.clear();
    typename list< Polynomial<K> >::iterator it;
    for(it= alg.relations.generators.begin();
        it!= alg.relations.generators.end();
        it++)
      if( it->nvars() <= source->variables_in_use() ){
        P= *it;
        P.alphabet= (Alphabet *) source;
        kernel.generators.push_back( P );
      }
  }

  void populate_associated_algebra() 
  {
    long i;
    Tuple< Polynomial<K> > vars= source->get_variables();
    Polynomial<K> P;
        
    assoc_alg= *source;
    assoc_alg.relations.generators.clear();
    assoc_alg.tensor_with(*target);
    for(i=1; i<= source->variables_in_use(); i++){
      P= this->of_generator(i);
      P.shift_variables( source->variables_in_use() );
      P*= -1;
      assoc_alg.add_relation( vars[i] + P);
    }
    

    assoc_alg.find_grobner_basis();

    kernel.generators.clear();
    typename list< Polynomial<K> >::iterator it;
    for(it= assoc_alg.relations.generators.begin();
        it!= assoc_alg.relations.generators.end();
        it++)
      if( it->nvars() <= source->variables_in_use() ){
        P= *it;
        P.alphabet= (Alphabet *) source;
        kernel.generators.push_back( P );
      }
  }

  bool maps_onto(const Polynomial<K>& P) const {
    Polynomial<K> Q;

    Q= P;
    Q.shift_variables( source->variables_in_use() );
    Q= assoc_alg.reduced_form( Q );
    return ( Q.nvars() <= source->variables_in_use() );
  }

  bool maps_onto(const Polynomial<K>& P,
                 Polynomial<K>& pre_image) const {

    pre_image= P;
    pre_image.shift_variables( source->variables_in_use() );
    pre_image= assoc_alg.reduced_form( pre_image );
    if(pre_image.nvars() <= source->variables_in_use() ){
      pre_image.alphabet= (Alphabet *) source;
      return true;
    }
    else
      return false;
  }


  bool factors_through(const Ideal<K>& J) const 
  {
    list< Polynomial<K> > kernel;
    typename list< Polynomial<K> >::const_iterator it;
    
    for(it= J.generators.begin();
        it!= J.generators.end();
        it++)
      if( !target->reduced_form( this->of(*it) ).is_zero() ) 
          return false;
          
    return true;
  }
  

  // methods related to the image ///////////////////////////////////


  bool is_finite() const 
  {
    AffineAlgebra<K> A;
    long i;
        

    A= *target;
    A.fix_alphabets();
        
    for(i=1; i<= source->variables_in_use(); i++)
      A.add_relation( this->images.find(i)->second );
      

    A.find_grobner_basis();
    A.reduce_grobner_basis();
    
    return A.is_finite_dimensional();
  }

  bool is_essentially_surjective() const 
  {
    AffineAlgebra<K> A;
    long i;
        

    A= *target;
    A.fix_alphabets();
        
    for(i=1; i<= source->variables_in_use(); i++)
      A.add_relation( this->images.find(i)->second );
      

    A.find_grobner_basis();
    A.reduce_grobner_basis();
    
    
    Polynomial<K> P;
    
    for(i=1; i<= A.variables_in_use(); i++){
      P= Polynomial<K>( PowProd(i) );
      //      P.alphabet= &A;
      if( !A.reduced_form(P).is_zero() ){
        //cout << P << " not in the image" << endl;
        
        return false;
      }
      
    }
    
    return true;
    
  }
  bool is_essentially_contained_in(const AffineHomomorphism<K>& g) const 
  {
    AffineAlgebra<K> alg;
    long i;
    
    alg= *target;
    for(i=1; i<= source->variables_in_use(); i++)
        alg.add_relation( g.of_generator(i) );
    alg.fix_alphabets();      
    alg.find_grobner_basis();
    
    for(i=1; i<= source->variables_in_use(); i++)
      if( !alg.reduced_form( this->of_generator(i) ).is_zero() )
        break;

    return (i == source->variables_in_use()+1 );
  }


  //a bunch of operators ///////////////////////////////////////////
  
  
  AffineHomomorphism<K>& operator*=(const AffineHomomorphism<K>& f){
    AbstractHomomorphism<K> *a= this;
    const AbstractHomomorphism<K> *b= &f;

    *a *= *b; // *this has now the right "data"
    source= f.source;

    return *this;
  }


  AffineHomomorphism<K> operator*(const AffineHomomorphism<K>& f) const {
    AffineHomomorphism<K> ans;
    const AbstractHomomorphism<K> *a= this;
    const AbstractHomomorphism<K> *b= &f;

    ans.source= f.source;
    ans.target= this->target;
    ans.get_data_from( *a * *b );

    return ans;
  }

  friend ostream& operator<<(ostream& os, const AffineHomomorphism<K>& f){
    typename map< long, Polynomial<K> >::const_iterator it;
    
    for(it= f.images.begin(); it!= f.images.end(); it++)
      os << f.source->nameof(it->first) 
         <<" --> " << it->second 
         << endl << endl;
    
    return os;
  }

  friend ofstream& operator<<(ofstream& file, AffineHomomorphism<K>& f){
    AbstractHomomorphism<K> *g;
    
    g=(AbstractHomomorphism<K> *) &f;
    file << *g;
    return file;
  }
  
  friend void operator>>(ifstream& file, AffineHomomorphism<K>& f){
    AbstractHomomorphism<K> *g;
    
    g=(AbstractHomomorphism<K> *) &f;
    file >> *g;
    f.fix_alphabets();
    
  }




};












#endif

---