cring.h

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// Computation of the cohomology ring.
///
/////////////////////////////////////////////////////////////////////////////

// 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: September 17, 2015.


#ifndef _CHAINCON_CRING_H_
#define _CHAINCON_CRING_H_


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

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

// include relevant local header files
#include "chaincon/chain.h"
#include "chaincon/linmap.h"
#include "chaincon/pair.h"
#include "chaincon/awdiag.h"


// --------------------------------------------------
// ---------------- cohomology ring -----------------
// --------------------------------------------------

/// Computes the cohomology ring, given a minimal model
/// and cohomology representants.
/// Please, make sure to include the appropriate header file with the
/// definition of the Alexander-Whitney diagonal for the cells in use
/// before including the header file containing this procedure.
template <class CellT, class CoefT>
inline void cring (const std::vector<std::vector<CellT> > &cohomRepresentants,
        const tLinMap<CellT,CellT,CoefT> &pi,
        const tLinMap<CellT,CellT,CoefT> &incl,
        chomp::homology::hashedset<tPair<CellT,CellT> > &cellPairs,
        chomp::homology::multitable<tChain<CellT,CoefT> > &cupProducts)
{
        typedef tPair<CellT,CellT> CellPair;

        int maxDim = cohomRepresentants. size ();
        for (int dim = 0; dim < maxDim; ++ dim)
        {
                // take all the "big" cells of the given dimension
                int size = cohomRepresentants [dim]. size ();
                for (int i = 0; i < size; ++ i)
                {
                        // take a cohomology representant cell
                        const CellT &cell = cohomRepresentants [dim] [i];
                //      sbug << "DEBUG: cell " << cell << ".\n";

                        // compute the cycle chain that corresponds
                        // to this representant
                        tChain<CellT,CoefT> chain (incl (cell));

                        // compute the A-W diagonal of this cycle
                        tTensor<CellT,CellT,CoefT> awdiagFull;
                        AWdiagonal (chain, awdiagFull);
                //      sbug << "DEBUG: awdiagFull = " << awdiagFull << ".\n";

                        // project the computed tensor to the model
                        tTensor<CellT,CellT,CoefT> awdiag (pi (awdiagFull));
                        int_t awdiagSize = awdiag. size ();
                //      sbug << "DEBUG: awdiag = " << awdiag << ".\n";

// CODE Version 1:
                        // consider all the cohomology representants
                        // that may have the big cell in their cup product
                        for (int dim1 = 0; dim1 <= dim; ++ dim1)
                        {
                                int dim2 = dim - dim1;
                                int size1 = cohomRepresentants [dim1]. size ();
                                int size2 = cohomRepresentants [dim2]. size ();
                                for (int i1 = 0; i1 < size1; ++ i1)
                                {
                                        const CellT &cell1 =
                                                cohomRepresentants [dim1] [i1];
                                        for (int i2 = 0; i2 < size2; ++ i2)
                                        {
                                                const CellT &cell2 =
                                                        cohomRepresentants [dim2] [i2];
                                                for (int_t j = 0; j < awdiagSize; ++ j)
                                                {
                                                        if (!(awdiag. left (j) == cell1))
                                                                continue;
                                                        if (!(awdiag. right (j) == cell2))
                                                                continue;
                                                        CoefT coef (awdiag. coef (j));
                                                        if (coef == 0)
                                                                continue;
                                                        int_t n = cellPairs. add
                                                                (CellPair (cell1, cell2));
                                                        cupProducts [n]. add (cell, coef);
                                                }
                                        }
                                }
                        }
/*
// CODE Version 2:
                        // update the cup products of all the pairs
                        // of cohomology representants
                        // in which the big cell appears
                        for (int_t j = 0; j < awdiagSize; ++ j)
                        {
                                // make sure that the coefficient is nonzero
                                CoefT coef (awdiag. coef (j));
                                if (coef == 0)
                                        continue;

                                // make sure that both cells appear
                                // in the lists of cohomology representants
                                // (otherwise ignore this product)
                                int foundCount (0);
                                for (int c = 0; c < 2; ++ c)
                                {
                                        const CellT &cell1 = c ?
                                                awdiag. left (j) :
                                                awdiag. right (j);
                                        int dim1 = cell1. dim ();
                                        int size0 (cohomRepresentants. size ());
                                        if (dim1 >= size0)
                                                throw "Cell1 dim out of range.";
                                        int size1 = cohomRepresentants [dim1]. size ();
                                        bool found (false);
                                        for (int i1 = 0; i1 < size1; ++ i1)
                                        {
                                                if (cohomRepresentants [dim1] [i1] == cell1)
                                                {
                                                        found = true;
                                                        ++ foundCount;
                                                        break;
                                                }
                                        }
                                        if (found)
                                                continue;
                                //      throw "A wrong cohomology representant "
                                //              "in cup product detected.";
                                }
                                if (foundCount < 2)
                                        continue;

                                int_t n = cellPairs. add
                                        (CellPair (awdiag. left (j),
                                        awdiag. right (j)));
                                cupProducts [n]. add (cell, coef);
                        }
*/
                }
        }
        return;
} /* cring */


#endif // _CHAINCON_CRING_H_