hom.cpp

#include <fstream>
#include <iostream>
#include "algebras.H"
#include "homfinder.H"
#include "cmdline.H"
using namespace std;

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

  // read the descriptions of the formal ring of sw classes and the
  // cohomology ring from files, according to the command line

  CommandLine::init(argc, argv);
  string name= CommandLine::parameters[0];
  string source= name + ".W";
  string target= name + ".cohomology.mod2";

  UnstableAlgebra A;            // the source: W_F^*(G)
  GradedAlgebra<F_2>  B;        // the target: H^*(G)

  ifstream my_source(source.c_str());
  if(my_source.fail()){
    cout << "could not read file" << source << endl;
    return 10;
  }
  else
    my_source >> A;
  my_source.close();

  ifstream my_target(target.c_str());
  if(my_target.fail()){ 
    cout << "could not read file" << target << endl;
    return 10;
  }
  else
    my_target >> B;
  my_target.close();

  // create a HomFinder, a class with methods which help find the
  // homomorphisms between A and B
  HomFinder myfinder(&A, &B);

  // set the "verbosity" (amount of information printed) according to
  // the options on the command line
  myfinder.very_verbose= myfinder.verbose= true;

  if(CommandLine::has_tag("-quiet")) 
    myfinder.very_verbose= false;
  if(CommandLine::has_tag("-silent"))
    myfinder.very_verbose= myfinder.verbose= false;

  // put A and B in the right form
  A.find_grobner_basis();
  A.find_redundancies();
  B.find_grobner_basis();

  if(myfinder.very_verbose)  
    cout << "Here's the formal ring of SW classes: "
         << endl << "(with a minimal set of relations"
         << " extracted from a reduced Grobner basis)"
         << endl << A << endl
         << "and here is the cohomology: " << endl
         << "(with a Grobner basis)" << endl
         << B << endl;

  // Step 1: variables of degree 1 //////////////

  // this sets up many things: the variables are sorted into the
  // t_i's, the q_i's and p_i's, for example -- see the
  // documentation. Eventually Step 1 is completed, that is we have a
  // list of all consistent choices for the degree 1 variables.
  myfinder.init();
    
  // Step 2: the q_i's //////////////////////////
  
  if(myfinder.verbose)
    cout << endl << "*** Step 2:" << endl;

  // Normal procedure: this step is lengthy. When we've completed it,
  // we save the results to a file so that a subsequent run can look
  // for the solutions rather than start from scratch.
  string sol_file= name + ".solutions";  
  ifstream my_in(sol_file.c_str());
  
  if(my_in.fail()){
    // the "start" method does all the work. See documentation.
    myfinder.start();
    ofstream my_out(sol_file.c_str());
    myfinder.write_solutions_to(my_out); 
  }
  else{
    if(myfinder.verbose)
      cout << "found solution file " << sol_file
           << endl;
    myfinder.read_solutions_from(my_in);
  }

  if(myfinder.verbose)
    cout << "Total: "
         << myfinder.solution_count
         << " possibilities after Steps 1 & 2"
         << endl;

  // Step 3 and Test 1 ///////////////////////////

  if(CommandLine::has_tag("-brute")){

    if(myfinder.verbose)
      cout << endl << "*** Step 3 (exhaustive version) & Test 1" << endl;
    // find the possibilities for the polynomial variables, and keep
    // only those which turn B into a finitely generated A-module
    myfinder.define_polynomial_variables_brutally();

  }
  else{
      
    if(myfinder.verbose)
      cout << endl << "*** Step 3 & Test 1" << endl;
    // find the possibilities for the polynomial variables, and keep
    // only those which turn B into a finitely generated A-module
    myfinder.define_polynomial_variables();
  }

  // Test 2 //////////////////////////////////////
  if(CommandLine::has_tag("-brute")){

      if(myfinder.verbose)
        cout << endl << "*** Test 2 skipped, just computing all kernels" 
             << endl;
      
      myfinder.compute_all_kernels();
    }
    else{

      if(myfinder.verbose)
        cout << endl << "*** Test 2" << endl;
      
      if( !myfinder.polynomial_test() ){
        cout << "Test 2 failed, giving up!" << endl;
        return 2;
      }
      else
        if(myfinder.verbose)
          cout << "Passed !" << endl;
    }
    
  // Count equivalence classes ///////////////////

  //we shall use this over and over
  list< AffineHomomorphism<F_2> > backup= myfinder.solutions;
  //keep only one solution in each equivalence class:
  if(myfinder.verbose)
    cout << endl << "*** We count the equivalence classes so far:" << endl;

  myfinder.identify();

  if(myfinder.verbose)
    cout << myfinder.solution_count << " classes" << endl;

  // Test 3: Steenrod ////////////////////////////


  if( myfinder.solution_count > 1){ //more than one ?
  
    if(myfinder.verbose)  
      cout << "*** Test 3" << endl;
    
    myfinder.test_steenrod();

    if(myfinder.verbose)
      cout << "Done, " << myfinder.solution_count 
           << " classes kept" << endl;
  }

  // Test 4: restrictions to elemabs //////////////

  if( myfinder.solution_count > 1){ //more than one ?

    if(myfinder.verbose)  
      cout << "*** Test 4" << endl;
    
    string res_name= name + ".W.res.elemab";
    ifstream res_file(res_name.c_str());
    
    myfinder.restrict_to_elemab( res_file );

    if(myfinder.verbose)  
      cout << "Done, " << myfinder.solution_count
           << " classes kept" << endl;
  }

  // Conclusions ///////////////////////////////////

  if( myfinder.solution_count > 1){ //more than one ?
    cout << endl << myfinder.solution_count
         << " equivalence classes, giving up!"
         << endl;
      return 1;
    }

  //we look at the solutions in 'backup' and select
  //the ones which are in the equivalence class
  //which we have now isolated (in many cases, all
  //the homomorphisms in backup are equivalent anyway)
  AffineHomomorphism<F_2> f= *myfinder.solutions.begin();
  myfinder.get_equivalence_class(backup, f);
  // now we extend these (getting f+ from f)
  long new_vars;
  new_vars= myfinder.extend_all();
  //let's see if we have added any:
  if( new_vars > 0 ) {

    if(myfinder.verbose)
      cout << endl << "*** There are variables which are not SW classes, "
           << endl << "we check if the extended homomorphisms are equivalent"
           << endl;

    myfinder.identify();

    if( myfinder.solution_count > 1){ //more than one ?
      cout << endl << myfinder.solution_count
           << " equivalence classes, giving up!"
           << endl;
      return 3;
    }
  }
  //if new_vars is 0, we have added nothing to the solution
  //homomorphisms, so that they are all equivalent, as we already
  //know. In this case myfinder.solutions is a whole list, whereas if
  //new_vars > 0 we have reduced it to a single solution.
 
  // add the relations to A and save to disk /////
  if(myfinder.verbose)
    cout << endl << "*** Done ! solution completely determined !"
         << endl;


  AbstractHomomorphism<F_2> reduc;
  list< Polynomial<F_2> >::iterator gen;

  f= *myfinder.solutions.begin(); // this is the solution !

  if(myfinder.verbose)
    cout << f << endl;

  for(gen= f.kernel.generators.begin();
      gen != f.kernel.generators.end();
      gen++)
    A.add_relation(*gen);

  A.split_and_sort_relations();


  if(new_vars == 0){ //no new variables added ?
    reduc= A.saturate_and_reduce(); //still have steenrod info
    if(myfinder.verbose)
      A.display();
  } 
  else{
    reduc= A.find_redundancies();
    A.write_trivial_steenrod_operations();
    //we set to zero the unknown steenrod operations
    if(myfinder.verbose)
      cout << A << endl;

  }

  string output_name= name + ".final";
  ofstream output(output_name.c_str());

  output << A;
  output << reduc;
  output << f;

  return 0;
}

 

---