to-presentation.hpp

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2023-2025 James D. Mitchell + James W. Swent
//
// This program 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 program 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 program.  If not, see <http://www.gnu.org/licenses/>.
//
 
#ifndef LIBSEMIGROUPS_TO_PRESENTATION_HPP_
#define LIBSEMIGROUPS_TO_PRESENTATION_HPP_
 
#include <algorithm>    // for transform, rotate
#include <string>       // for basic_string
#include <type_traits>  // for is_same_v, ena...
#include <utility>      // for move
#include <vector>       // for vector
 
#include "froidure-pin-base.hpp"   // for FroidurePinBase
#include "knuth-bendix-class.hpp"  // for KnuthBendix
#include "presentation.hpp"        // for Presentation
#include "word-range.hpp"          // for human_readable...
 
// TODO(1): Make as many of these functions const as possible
// TODO(1): Remove the intentional typos from doxygen declarations once
//          issue doxygen issue #11787 is merged into release
namespace libsemigroups {
 
  template <typename>
  class Kambites;  // forward decl
 
  template <typename>
  class ToddCoxeter;  // forward decl
 
  template <typename>
  class Stephen;  // forward decl



  // FroidurePin -> Presentation

  template <typename Result>
  auto to(FroidurePinBase& fp) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>,
      Result>;

  // KnuthBendix -> Presentation

  template <typename Result,
            typename WordIn,
            typename Rewriter,
            typename ReductionOrder>
  auto to(KnuthBendix<WordIn, Rewriter, ReductionOrder>& kb)
      -> std::enable_if_t<
          std::is_same_v<Presentation<typename Result::word_type>, Result>,
          Result>;

#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  // FIXME(1) this is the same hack as elsewhere (deliberately introducing a
  // typo) because Doxygen conflates functions with trailing return type but the
  // same name and signature.
  template <template <typename...> typename Thing,
            typename Word,
            typename Rewriter typename ReductionOrder>
  auto to(KnutBendix<Word, Rewriter, ReductionOrder>& kb)
      -> std::enable_if_t<std::is_same_v<Thing<Word>, Presentation<Word>>,
                          Presentation<Word>>;
#else
  template <template <typename...> typename Thing,
            typename Word,
            typename Rewriter,
            typename ReductionOrder>
  auto to(KnuthBendix<Word, Rewriter, ReductionOrder>& kb)
      -> std::enable_if_t<std::is_same_v<Thing<Word>, Presentation<Word>>,
                          Presentation<Word>> {
    return to<Presentation<Word>>(kb);
  }
#endif

  // Kambites -> Presentation

#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  // FIXME(1) this is the same hack as elsewhere (deliberately introducing a
  // typo) because Doxygen conflates functions with trailing return type but the
  // same name and signature.
  template <typename Result, typename Word>
  auto to(Kambtes<Word>& k) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && !std::is_same_v<typename Result::word_type, Word>,
      Result>;
#else
  template <typename Result, typename Word>
  auto to(Kambites<Word>& k) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && !std::is_same_v<typename Result::word_type, Word>,
      Result> {
    return v4::to<Result>(k.presentation());
  }
 
  // This function is documented above because Doxygen conflates these two
  // functions
  template <typename Result, typename Word>
  auto to(Kambites<Word>& k) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && std::is_same_v<typename Result::word_type, Word>,
      Result const&> {
    return k.presentation();
  }
#endif

  // ToddCoxeter -> Presentation

#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  // FIXME(1) this is the same hack as elsewhere (deliberately introducing a
  // typo) because Doxygen conflates functions with trailing return type but the
  // same name and signature.
  template <typename Result, typename Word>
  auto to(ToddCoxter<Word>& tc) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && !std::is_same_v<typename Result::word_type, Word>,
      Result>;
#else
  template <typename Result, typename Word>
  auto to(ToddCoxeter<Word>& tc) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && !std::is_same_v<typename Result::word_type, Word>,
      Result> {
    return v4::to<Result>(tc.presentation());
  }
 
  // This function is documented above because Doxygen conflates these two
  // functions
  template <typename Result, typename Word>
  auto to(ToddCoxeter<Word>& tc) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && std::is_same_v<typename Result::word_type, Word>,
      Result const&> {
    return tc.presentation();
  }
#endif

  // Congruence -> Presentation

#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  // FIXME(1) this is the same hack as elsewhere (deliberately introducing a
  // typo) because Doxygen conflates functions with trailing return type but the
  // same name and signature.
  template <typename Result, typename Word>
  auto to(Congrence<Word>& c) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && !std::is_same_v<typename Result::word_type, Word>,
      Result>;
#else
  template <typename Result, typename Word>
  auto to(Congruence<Word>& c) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && !std::is_same_v<typename Result::word_type, Word>,
      Result> {
    return v4::to<Result>(c.presentation());
  }
 
  // This function is documented above because Doxygen conflates these two
  // functions
  template <typename Result, typename Word>
  auto to(Congruence<Word>& c) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && std::is_same_v<typename Result::word_type, Word>,
      Result const&> {
    return c.presentation();
  }
#endif

  // Stephen -> Presentation

  template <typename Result, typename PresentationType>
  auto to(Stephen<PresentationType>& s) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>,
      Result> {
    return v4::to<Result>(s.presentation());
  }

  // Presentation + function -> Presentation

  template <typename Result, typename Word, typename Func>
  [[deprecated]] auto to(Presentation<Word> const& p, Func&& f)
      -> std::enable_if_t<
          std::is_same_v<Presentation<typename Result::word_type>, Result>,
          Result> {
    return v4::to<Result>(p, f);
  }

  // InversePresentation + function -> InversePresentation

  template <typename Result, typename Word, typename Func>
  [[deprecated]] auto
  to(InversePresentation<Word> const& ip, Func&& f) -> std::enable_if_t<
      std::is_same_v<InversePresentation<typename Result::word_type>, Result>,
      Result> {
    return v4::to<Result>(ip, f);
  }

  // Presentation -> Presentation

  template <typename Result, typename Word>
  [[deprecated]] auto to(Presentation<Word> const& p) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>
          && !std::is_same_v<typename Result::word_type, Word>,
      Result> {
    return v4::to<Result>(p);
  }
 
  // This function is documented above because Doxygen conflates these two
  // functions.
  template <typename Result, typename Word>
  [[deprecated]] auto to(Presentation<Word> const& p) noexcept
      -> std::enable_if_t<std::is_same_v<Presentation<Word>, Result>,
                          Result const&> {
    return v4::to<Result>(p);
  }

  // InversePresentation -> InversePresentation

  template <typename Result, typename Word>
  [[deprecated]] auto
  to(InversePresentation<Word> const& ip) noexcept -> std::enable_if_t<
      std::is_same_v<InversePresentation<typename Result::word_type>, Result>
          && !std::is_same_v<Word, typename Result::word_type>,
      Result> {
    return v4::to<Result>(ip);
  }
 
  // This function is documented above because Doxygen conflates these two
  // functions.
  template <typename Result, typename Word>
  [[deprecated]] auto to(InversePresentation<Word> const& ip) noexcept
      -> std::enable_if_t<std::is_same_v<InversePresentation<Word>, Result>,
                          Result const&> {
    return v4::to<Result>(ip);
  }

  // Presentation -> InversePresentation

// \note The parameter \p p must not be an `InversePresentation`, otherwise
// a compilation error is thrown.
// NOTE: not sure this is true anymore so just leaving it out
#ifdef LIBSEMIGROUPS_PARSED_BY_DOXYGEN
  // FIXME(1) this is the same hack as elsewhere because Doxygen conflates
  // functions with trailing return type but the same name and signature.
  template <template <typename...> typename Thing, typename Word>
  auto to(Presentation<Word> const& p) -> std::enable_if_t<
      std::is_same_v<InversePresentation<Word>, Thing<Word>>,
      InversePresentation<Word>>;
#else
  template <template <typename...> typename Thing, typename Word>
  [[deprecated]] auto to(Presentation<Word> const& p) -> std::enable_if_t<
      std::is_same_v<InversePresentation<Word>, Thing<Word>>,
      InversePresentation<Word>> {
    return v4::to<InversePresentation>(p);
  }
#endif
}  // namespace libsemigroups
 
#include "to-presentation.tpp"
 
#endif  // LIBSEMIGROUPS_TO_PRESENTATION_HPP_