experiment2.cpp

Go to the documentation of this file.

/////////////////////////////////////////////////////////////////////////////
///
/// \file
///
/// A program for experimentation with the formulas
/// for the E-Z chain contraction: AW, EML, SHI.
///
/////////////////////////////////////////////////////////////////////////////

// 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: December 4, 2014.


// the choice of cubes or simplices
//#define CUBES_NOT_SIMPLICES
#ifdef CUBES_NOT_SIMPLICES
#define SPACE_WRAPPING
#endif

// 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/cubcell.h"
#include "chaincon/awdiagcub.h"
#include "chaincon/simplex.h"
#include "chaincon/awdiagsim.h"
#include "chaincon/emptycell.h"
#include "chaincon/chain.h"
#include "chaincon/linmap.h"
#include "chaincon/comblinmap.h"
#include "chaincon/ringzp.h"
#include "chaincon/cellnames.h"
#include "chaincon/awdiag.h"
#include "chaincon/boundary.h"
#include "chaincon/ez_aw.h"
#include "chaincon/ez_eml.h"
#include "chaincon/ez_shi.h"
#ifdef SPACE_WRAPPING
#include "chaincon/wrapping.h"
#endif


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

/// The title of the program and licensing information.
const char *title = "\
Experimentation with the formulas for the E-Z chain contraction.\n\
Version 0.00 (Dec 4, 2014). 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 computations to experiment with the Eilenberg-Zilber\n\
chain contraction.\n\
The ring of coefficients is Z or Z_p (the integers modulo prime number p).\n\
Call with:\n\
filename - the name of a file that contains a list of cells for the test,\n\
Switches and additional arguments:\n\
-pN - selection of the coefficients: p=0 for Z, p=1 unsupported in this\n\
\tprogram, p > 1 for Z_p (default: p=2); please, use p <= 181,\n\
-r - compute reduced homology (with the empty set as a cell of dim -1),\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/.";


// --------------------------------------------------
// ------------------- experiment -------------------
// --------------------------------------------------

/// Runs the experimental calculations.
template <class CellT, class CoefT>
inline void experiment (const char *Xname)
{
        using chomp::homology::sout;
        using chomp::homology::ignorecomments;
        typedef tProdCell<CellT> ProdT;
        typedef tChain<tProdCell<CellT>,CoefT> ChainT;
        typedef tTensor<tProdCell<CellT>,tProdCell<CellT>,CoefT> TensorProdT;
        typedef tTensor<CellT,CellT,CoefT> TensorCellT;

        sout << "Checking the experimental formulas...\n";

        // open the input file
        std::ifstream in (Xname);
        if (!in)
                throw "Can't open the input file.";

        // go through all the cells in the input file
        int counter (0);
        ignorecomments (in);
        while (!in. eof ())
        {
                // read the two cells
                CellT x;
                in >> x;
                ignorecomments (in);
                if (in. eof ())
                        break;
                CellT y;
                in >> y;
                ignorecomments (in);
                ++ counter;

                // prepare the product of the two cells
                ProdT product (x, y);

                // prepare the tensor of the two cells
                TensorCellT tensor;
                tensor. add (x, y, CoefT (1));
                TensorProdT tensorProd;
                tensorProd. add (ProdT (x), ProdT (y), CoefT (1));

                // show the operators applied to the two cells
                TensorCellT resultAW;
                EZ_AW (x, y, resultAW);
                sout << "AW (" << x << " X " << y << ") = " <<
                        resultAW << ".\n";
                ChainT resultEML;
                EZ_EML (x, y, resultEML);
                sout << "EML (" << x << " x " << y << ") = " <<
                        resultEML << ".\n";
                ChainT resultSHI;
                EZ_SHI (x, y, resultSHI);
                sout << "SHI (" << x << " X " << y << ") = " <<
                        resultSHI << ".\n";

                // check if SHI EML (x, y) = 0
                ChainT result1a;
                EZ_EML (tensor, result1a);
                ChainT result1b;
                EZ_SHI (result1a, result1b);
                if (result1b. empty ())
                {
                        sout << "Verified: SHI EML (" << x << " x " << y <<
                                ") = 0.\n";
                }
                else
                {
                        sout << "PROBLEM: SHI EML (" << x << " x " << y <<
                                ") is nonzero: " << result1b << ".\n";
                }

                // check if SHI SHI (x, y) = 0
                ChainT result2a;
                EZ_SHI (product, result2a);
                ChainT result2b;
                EZ_SHI (result2a, result2b);
                if (result2b. empty ())
                {
                        sout << "Verified: SHI SHI (" << x << " X " << y <<
                                ") = 0.\n";
                }
                else
                {
                        sout << "PROBLEM: SHI SHI (" << x << " X " << y <<
                                ") is nonzero: " << result2b << ".\n";
                }

                // check if AW SHI (x, y) = 0
                ChainT result3a;
                EZ_SHI (product, result3a);
                TensorProdT result3b;
                EZ_AW (result3a, result3b);
                if (result3b. empty ())
                {
                        sout << "Verified: AW SHI (" << x << " X " << y <<
                                ") = 0.\n";
                }
                else
                {
                        sout << "PROBLEM: AW SHI (" << x << " X " << y <<
                                ") is nonzero: " << result3b << ".\n";
                }

                // check if AW EML (x, y) = 0
                ChainT result4a;
                EZ_EML (tensor, result4a);
                TensorProdT result4b;
                EZ_AW (result4a, result4b);
                if (result4b == tensorProd)
                {
                        sout << "Verified: AW EML (" << x << " x " << y <<
                                ") = " << x << " x " << y << ".\n";
                }
                else
                {
                        sout << "PROBLEM: AW EML (" << x << " x " << y <<
                                ") differs from " << x << " x " << y <<
                                ": " << result4b << ".\n";
                }

                // compute a formula for I - d SHI
                ChainT result5a;
                EZ_SHI (product, result5a);
                ChainT result5b;
                computeBoundary (result5a, result5b, Unrestricted ());
                result5b. negate ();
                result5b. add (product, CoefT (1));
                sout << "(I - d SHI) (" << x << " X " << y << ") = " <<
                        result5b << ".\n";

                // compute a formula for I - SHI d
                ChainT prodChain;
                prodChain. add (product, CoefT (1));
                ChainT result6a;
                computeBoundary (prodChain, result6a, Unrestricted ());
                ChainT result6b;
                EZ_SHI (result6a, result6b);
                result6b. negate ();
                result6b += prodChain;
                sout << "(I - SHI d) (" << x << " X " << y << ") = " <<
                        result6b << ".\n";

                // check 1 - d SHI - SHI d
                // TODO
        }
        in. close ();
        sout << counter << " pair" << ((counter == 1) ? "" : "s") <<
                " of cells have been tested.\n";
        return;
} /* experiment */


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

/// The main procedure of the program.
/// Returns: 0 = Ok, -1 = Error, 1 = Help displayed, 2 = Wrong arguments.
int main (int argc, char *argv [])
{
#ifdef CUBES_NOT_SIMPLICES
        typedef tCubCell<int_t,SettableWrapping<int_t>,
                SettableEmptyCell> CellT;
#else
        typedef tSimplex<int_t,SettableEmptyCell> CellT;
#endif
        typedef tZp<short> CoefT;
//      typedef tLinMap<CellT,CellT,CoefT> MapT;

        using namespace chomp::homology;

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

        // prepare user-configurable data
        char *Xname = 0;
        int p = 0;
        bool reduced = 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, "p", p);
#ifdef SPACE_WRAPPING
        arg (a, "w", wrapping, nWrapping, maxWrapping);
#endif
        argswitch (a, "r", reduced, 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
        {
                // set up the ring of coefficients and make a correction to p
                CoefT::setp (p);
                p = CoefT::getp ();
                sout << "Carrying out computations in the ring " <<
                        CoefT::ringsymbol () << ".\n";

                // set the existence of the empty cell if desired
                if (reduced)
                        CellT::EmptyType::setExistence (true);

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

                // verify the experimental formulas
                experiment<CellT,CoefT> (Xname);

                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 */