cubsimprod.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// An experimental program for the computation of certain invariants
/// of cubical sets represented by means of simplicial product sets.
///
/////////////////////////////////////////////////////////////////////////////

// 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: June 10, 2015.


// 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/linmap.h"
#include "chaincon/ringzp.h"
#include "chaincon/cellnames.h"
#include "chaincon/simplex.h"
#include "chaincon/cubcell.h"
#include "chaincon/emptycell.h"
#include "chaincon/wrapping.h"
#include "chaincon/prodcell.h"
#include "chaincon/cubproduct.h"
#include "chaincon/setfilter.h"
//#define SPACE_WRAPPING
#include "chaincon/awdiagsimgen.h"
#include "chaincon/ez_aw.h"
#include "chaincon/ez_eml.h"
#include "chaincon/ez_shi.h"
#include "ammodcomp.h"
#include "cringcomp.h"


// --------------------------------------------------
// -------------------- OVERTURE --------------------
// --------------------------------------------------

/// The title of the program and licensing information.
const char *title = "\
* * * UNDER CONSTRUCTION * * *\n\
Certain experimental computations of cubical sets by means of their\n\
simplicial subdivision.\n\
Version 0.00 (June 10, 2015). Copyright (C) 1997-2016 by Pawel Pilarczyk.\n\
This is free software. No warranty. Consult 'license.txt' for details.";

/// Brief help information on the program's usage.
const char *helpinfo = "\
This program does some experimental computations on cubical sets\n\
using their representation by means of the Cartesian product\n\
of the simplicial sets that correspond to the faces of the cubes.\n\
The ring of coefficients for cohomology computation can be either set to Z\n\
or to Z_p (the integers modulo prime number p).\n\
Call with:\n\
filename - the name of a file that contains a list of cubical cells,\n\
Switches and additional arguments:\n\
-pN - selection of the coefficients: p=0 for Z, p>1 for Z_p (default: 0);\n\
\tnote: one should use p <= 181,\n\
-dpi, -dincl, -dphi - display the computed maps: pi, incl, phi,\n\
-dd - display the boundary map in the minimal model (the nontrivial part),\n\
--verify - do additional verification of the computed maps,\n\
--log filename - save the output to a file (without progress indicators),\n\
--quiet - suppress data output to the screen (whcih can be still logged),\n\
--help - display this brief help information only and exit.\n\
For more information please consult the accompanying documentation\n\
or ask the program's author at http://www.PawelPilarczyk.com/.";


// --------------------------------------------------
// ---------------------- main ----------------------
// --------------------------------------------------

/// The main procedure of the program.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
int main (int argc, char *argv [])
{
        using namespace chomp::homology;

        // prepare the types for coordinates, cubes, and simplices
        typedef short int CoordT;
        typedef tCubCell<CoordT,SettableWrapping<CoordT>,SettableEmptyCell>
                CubCellT;
        typedef tProdCell<tSimplex<CoordT,SettableEmptyCell> > CellT;

        // turn on a message that will appear if the program does not finish
        program_time = "Aborted after";

        // prepare user-configurable data
        char *Xname = 0;
        char *Aname = 0;
        int p = 0;
        bool reduced = false;
        bool displayPi = false;
        bool displayIncl = false;
        bool displayPhi = false;
        bool displayD = false;
        bool verify = false;
#ifdef SPACE_WRAPPING
        const int maxWrapping = 100;
        char *wrapping [maxWrapping];
        int nWrapping = 0;
#endif

        // analyze the command line
        arguments a;
        arg (a, NULL, Xname);
        arg (a, NULL, Aname);
        arg (a, "p", p);
#ifdef SPACE_WRAPPING
        arg (a, "w", wrapping, nWrapping, maxWrapping);
#endif
        argswitch (a, "r", reduced, true);
        argswitch (a, "dpi", displayPi, true);
        argswitch (a, "dincl", displayIncl, true);
        argswitch (a, "dphi", displayPhi, true);
        argswitch (a, "dd", displayD, true);
        argswitch (a, "-verify", verify, true);
        arghelp (a);

        argstreamprepare (a);
        int argresult = a. analyze (argc, argv);
        argstreamset ();

        // show the program's title
        if (argresult >= 0)
                sout << title << '\n';

        // if something was incorrect, show an additional message and exit
        if (argresult < 0)
        {
                sout << "Call with '--help' for help.\n";
                return 2;
        }

        // if help requested or no filename present, show help information
        if ((argresult > 0) || !Xname || (p < 0))
        {
                sout << helpinfo << '\n';
                return 1;
        }

        // try running the main function and catch an error message if thrown
        try
        {
                if (Aname)
                        throw "Relative chains not supported yet.";

                // set the existence of the empty cell if desired
                if (reduced)
                {
                        throw "Reduced homology not supported yet.";
                //      CubCellT::EmptyType::setExistence (true);
                }

#ifdef SPACE_WRAPPING
                if (nWrapping)
                        throw "Space wrapping not supported yet.";

                // set wrapping as desired
                for (int i = 0; i < nWrapping; ++ i)
                {
                        setWrapping<typename CubCellT::WrapType>
                                (std::string (wrapping [i]));
                }
#endif

                // prepare the ring of coefficients
                typedef tZp<short> CoefT;
                CoefT::setp (p);
                p = CoefT::getp ();

                // read the cubical set
                sout << "Reading cubical cells from '" << Xname << "'...\n";
                hashedset<CubCellT> Xcubes;
                std::ifstream in (Xname);
                if (!in)
                        fileerror (Xname);
                in >> Xcubes;
                in. close ();
                if (Xcubes. empty ())
                        throw "No cubical cells read from the input file.";
                sout << Xcubes. size () << " cubical cells read.\n";

                // transform the cubes into products of simplices
                sout << "Transforming the cubical cells into products "
                        "of simplices...\n";
                tSimplSet<CellT> Xsimpl;
                for (int_t i = 0; i < Xcubes. size (); ++ i)
                        cube2product (Xcubes [i], Xsimpl);
                sout << Xsimpl. size () << " products created.\n";
        //      sbug << "DEBUG: Xsimpl:\n" << Xsimpl;

                // add faces of all the cells in the product
        //      sout << "Adding faces of cells in the product...\n";
        //      int_t nAddedFaces = Xsimpl. addFaces ();
        //      sout << nAddedFaces << " faces added.\n";

                // normalize the constructed simplicial set
                sout << "Normalizing the constructed simplicial set...\n";
                int_t nDegenerate = Xsimpl. normalize ();
                sout << nDegenerate << " degenerate cells removed.\n";
        //      sbug << "DEBUG: Xsimpl:\n" << Xsimpl;

                // transform the simplicial set to a filtered complex
                sout << "Transforming the simplicial set "
                        "into a filtered complex...\n";
                tFilteredComplex<CellT> K;
                set2filter (Xsimpl, K, Xsimpl. dim ());
        //      sbug << "DEBUG: K:\n" << K;

                // prepare the data for storing the result of computations
                chomp::homology::hashedset<CellT> H, A, B;
                std::vector<CoefT> Q;

                // compute the homology groups and generators
                sout << "Carrying out computations in the ring " <<
                        CoefT::ringsymbol () << ".\n";
                tLinMap<CellT,CellT,CoefT> pi, incl, phi;
                tCellNames<CellT> dummyCellNames;
                tCellNames<CellT> cellNames;
        //      cellNames. setPrefix ("g");

                sout << "=== Computing the minimal model ===\n";
                computeAlgMinModel (K, false, H, A, B, Q, pi, incl, phi,
                        dummyCellNames, cellNames,
                        displayPi, displayIncl, displayPhi, displayD,
                        verify);

                sout << "=== Computing the cohomology ring ===\n";
                computeCohomRing (H, A, B, Q, pi, incl, cellNames, verify);

                program_time = "Total time used:";
                program_time = 1;
                return 0;
        }
        catch (const char *msg)
        {
                sout << "ERROR: " << msg << '\n';
                return -1;
        }
        catch (const std::exception &e)
        {
                sout << "ERROR: " << e. what () << '\n';
                return -1;
        }
        catch (...)
        {
                sout << "ABORT: An unknown error occurred.\n";
                return -1;
        }
} /* main */