homcohom.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// Computation of the (co)homology groups of an algebraic minimal model.
///
/////////////////////////////////////////////////////////////////////////////

// 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 March 24, 2009. Last revision: January 13, 2013.


#ifndef _CHAINCON_HOMCOHOM_H_
#define _CHAINCON_HOMCOHOM_H_


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

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


// --------------------------------------------------
// -------------------- homology --------------------
// --------------------------------------------------

/// Computes Betti numbers and torsion coefficients for (co)homology
/// from an algebraic minimal model (set "cohomology" to "false"
/// for homology and to "true" for cohomology).
/// Saves representant cells (first for the free part, then for torsion)
/// unless the pointer is NULL.
template <class CellT, class CoefT, class CellArray1, class CellArray2,
        class CellArray3, class CoefArray>
void getHomCohom (const CellArray1 &H, const CellArray2 &A,
        const CellArray3 &B, const CoefArray &Q,
        std::vector<std::vector<CellT> > *representants,
        std::vector<int> *bettiNumbers,
        std::vector<std::vector<CoefT> > *torsion,
        bool cohomology)
{
        // analyze the homology generators not related to torsion first
        int_t Hsize = H. size ();
        for (int_t i = 0; i < Hsize; ++ i)
        {
                // determine the dimension of the representant cell
                int dim = H [i]. dim ();

                if (representants)
                {
                        // extend the vector for representants if necessary
                        while (static_cast<int> ((*representants). size ())
                                <= dim)
                        {
                                std::vector<CellT> empty;
                                (*representants). push_back (empty);
                        }

                        // append the (co)homology generator representant
                        (*representants) [dim]. push_back (H [i]);
                }

                if (bettiNumbers)
                {
                        // extend the array of Betti numbers if necessary
                        while (static_cast<int> ((*bettiNumbers). size ())
                                <= dim)
                        {
                                (*bettiNumbers). push_back (0);
                        }

                        // increase the relevant Betti number
                        ++ (*bettiNumbers) [dim];
                }
        }

        // gather the torsion information
        int_t Bsize = B. size ();
        if ((Bsize != static_cast<int_t> (A. size ())) ||
                (Bsize != static_cast<int_t> (Q. size ())))
        {
                throw "Mismatched sizes of torsion arrays.";
        }
        for (int_t i = 0; i < Bsize; ++ i)
        {
                // determine the dimension of the representant cell
                int dim = cohomology ? A [i]. dim () : B [i]. dim ();

                if (representants)
                {
                        // extend the vector for representants if necessary
                        while (static_cast<int> ((*representants). size ())
                                <= dim)
                        {
                                std::vector<CellT> empty;
                                (*representants). push_back (empty);
                        }

                        // append the homology generator representant
                        (*representants) [dim]. push_back
                                (cohomology ? A [i] : B [i]);
                }

                if (torsion)
                {
                        // extend the vector for torsion if necessary
                        while (static_cast<int> ((*torsion). size ()) <= dim)
                        {
                                std::vector<CoefT> empty;
                                (*torsion). push_back (empty);
                        }

                        // append the torsion coefficient
                        (*torsion) [dim]. push_back (Q [i]);
                }
        }

        return;
} /* getHomCohom */

/// Returns a text description of one (co)homology group.
/// Torsion coefficients can be either shown using subscripts
/// after the ring symbol, e.g. Z_p, or as quotient rings, e.g. Z/pZ,
/// depending on the option selected.
template <class CoefT>
std::string homcohom2text (int bettiNumber,
        const std::vector<CoefT> &torsion, bool torsion_subscript)
{
        // return the zero group if this is the case
        if (!bettiNumber && !torsion. size ())
                return std::string ("0");

        // prepare variables
        std::ostringstream s;
        std::string ring (CoefT::ringsymbol ());

        // output the free part
        if (bettiNumber == 1)
                s << ring;
        else if (bettiNumber > 1)
                s << ring << "^" << bettiNumber;

        // output the torsion part
        if (torsion. size ())
        {
                int size = torsion. size ();
                for (int i = 0; i < size; ++ i)
                {
                        if (bettiNumber || i)
                                s << " + ";
                        if (torsion_subscript)
                                s << ring << "_" << torsion [i];
                        else
                                s << ring << "/" << torsion [i] << ring;
                }
        }

        return s. str ();
} /* homcohom2text */

/// Returns a text description of all the homology groups
/// of an algebraic minimal model.
/// Torsion coefficients can be either shown as subscript of the ring symbol,
/// e.g. Z_p, or as a quotient, e.g. Z/pZ, depending on the option selected.
template <class CoefT>
std::string homcohom2text (const std::vector<int> &bettiNumbers,
        const std::vector<std::vector<CoefT> > &torsion,
        const std::string &symbol, bool torsion_subscript)
{
        std::ostringstream s;
        int maxCounter = std::max (bettiNumbers. size (), torsion. size ());
        std::vector<CoefT> empty;
        for (int dim = 0; dim < maxCounter; ++ dim)
        {
                int bettiNumber ((static_cast<int> (bettiNumbers. size ())
                        <= dim) ? 0 : bettiNumbers [dim]);
                const std::vector<CoefT> &tor
                        ((static_cast<int> (torsion. size ()) <= dim) ?
                        empty : torsion [dim]);
                s << symbol << dim << " = " << homcohom2text
                        (bettiNumber, tor, torsion_subscript) << "\n";
        }
        return s. str ();
} /* homcohom2text */


#endif // _CHAINCON_HOMCOHOM_H_