ssqcomp.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A generic procedure for the computation of the Steenrod squares
/// for an algebraic topological model.
/// This is a complete procedure good for simplicial, cubical,
/// or other complexes.
///
/////////////////////////////////////////////////////////////////////////////

// Copyright (C) 2009-2016 by Pawel Pilarczyk.
//
// This file is part of my research software package. This is free software:
// you can redistribute it and/or modify it under the terms of the GNU
// General Public License as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// This software is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this software; see the file "license.txt". If not,
// please, see <http://www.gnu.org/licenses/>.

// Started on July 4, 2013. Last revision: January 23, 2016.


#ifndef _SSQCOMP_H_
#define _SSQCOMP_H_


// include some standard C++ header files
#include <istream>
#include <ostream>
#include <string>

// include the string hashing definitions (before including "hashsets.h")
#include "chaincon/stringhash.h"

// include selected header files from the CHomP library
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/system/arg.h"
#include "chomp/struct/hashsets.h"

// include relevant local header files
#include "chaincon/chain.h"
#include "chaincon/linmap.h"
//#include "chaincon/cellnames.h"
#include "chaincon/homcohom.h"
#include "chaincon/pair.h"
#include "chaincon/cring.h"


// --------------------------------------------------
// ------------ compute Steenrod squares ------------
// --------------------------------------------------

/// Computes the Steenrod squares, given an AT model of a cell complex.
template <class SimCellT, class CoefT, class CellArray1, class CellArray2,
        class CellArray3, class CoefArray, class CellNames>
inline void computeSteenrodSquares (const CellArray1 &H,
        const CellArray2 &A, const CellArray3 &B, const CoefArray &Q,
        const tLinMap<SimCellT,SimCellT,CoefT> &pi,
        const tLinMap<SimCellT,SimCellT,CoefT> &incl,
        CellNames &cohomCellNames, int ssquareVersion, bool verify)
{
        using chomp::homology::timeused;
        using chomp::homology::sout;
        using chomp::homology::sbug;
        using chomp::homology::hashedset;
        using chomp::homology::multitable;

        // determine cohomology generators
        sout << "Determining cohomology generators "
                "from the algebraic topological model...\n";
        std::vector<std::vector<SimCellT> > cohomRepresentants;
        std::vector<int> cohomBettiNumbers;
        std::vector<std::vector<CoefT> > cohomTorsion;
        getHomCohom (H, A, B, Q, &cohomRepresentants, &cohomBettiNumbers,
                &cohomTorsion, true);

        // prepare correct cell names (in case it was not done before)
        sout << "Setting up names of the representants...\n";
        int cohomReprSize = cohomRepresentants. size ();
        for (int dim = 0; dim < cohomReprSize; ++ dim)
        {
                int size = cohomRepresentants [dim]. size ();
                for (int i = 0; i < size; ++ i)
                        cohomCellNames (cohomRepresentants [dim] [i]);
        }

        // ==========================================

#if CUBES_NOT_SIMPLICES && !DIRECT_CUBICAL_FORMULA
#else
        sout << "\nComputing the cup products...\n";

        // prepare a time measurement object
        timeused cupCompTime;
        cupCompTime = 0;

        // prepare a data structure for the cup products
        typedef tPair<SimCellT,SimCellT> CellPair;
        hashedset<CellPair> cellPairs;
        multitable<tChain<SimCellT,CoefT> > cupProducts;

        // compute all the cup products
        cring (cohomRepresentants, pi, incl, cellPairs, cupProducts);

        // show the computed nonzero cup products
        // in the ascending order by the dimension of the "big" cells
        bool cupNonzeroFound = false;
        int_t cupSize = cellPairs. size ();
        for (int_t n = 0; n < cupSize; ++ n)
        {
                if (cupProducts [n]. empty ())
                        continue;
                if (!cupNonzeroFound)
                {
                        sout << "The computed nonzero cup products are:\n";
                        cupNonzeroFound = true;
                }
                sout << cohomCellNames (cellPairs [n]. left) << " u " <<
                        cohomCellNames (cellPairs [n]. right) << " = " <<
                        cells2names (cupProducts [n], cohomCellNames) << ".\n";
        }
        if (!cupNonzeroFound)
                sout << "All the computed cup products are trivial.\n";

        // show information on the total computation time
        sout << "The cup products were computed in " << cupCompTime << ".\n";
#endif

        // ==========================================

        sout << "\nComputing the Steenrod squares...\n";

        // prepare a time measurement object
        timeused compTime;
        compTime = 0;

        // prepare an array for the results
        typedef tPair<SimCellT,int> CellSquareT;
        hashedset<CellSquareT> cellsSquares;
        multitable<tChain<SimCellT,CoefT> > squareValues;

        // for each of the cohomology generators,
        // compute all of its Steenrod squares
        switch (ssquareVersion)
        {
                case 1:
                        ssquares1 (cohomRepresentants, pi, incl,
                                cellsSquares, squareValues);
                        break;
                case 2:
                        ssquares2 (cohomRepresentants, pi, incl,
                                cellsSquares, squareValues);
                        break;
                default:
                        throw "Invalid algorithm version "
                                "for Steenrod squares requested.";
        }

        // show the computed nonzero Steenrod squares
        bool nonzeroFound = false;
        int_t size = cellsSquares. size ();
        for (int_t n = 0; n < size; ++ n)
        {
                if (squareValues [n]. empty ())
                        continue;
                if (!nonzeroFound)
                {
                        sout << "The nonzero Steenrod squares are:\n";
                        nonzeroFound = true;
                }
                sout << "Sq^" << cellsSquares [n]. right << " (" <<
                        cohomCellNames (cellsSquares [n]. left) << ") = " <<
                        cells2names (squareValues [n], cohomCellNames) <<
                        ".\n";
        }
        if (!nonzeroFound)
                sout << "All the computed Steenrod squares are trivial.\n";

        // show information on the total computation time
        sout << "The Steenrod squares were computed in " << compTime <<
                ".\n";

        return;
} /* computeSteenrodSquares */


#endif // _SSQCOMP_H_