to-presentation.hpp

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2023-2026 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
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>;

  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);
  }

  // Kambites -> Presentation

  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());
  }

  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();
  }

  // ToddCoxeter -> Presentation

  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());
  }

  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();
  }

  // Congruence -> Presentation

  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());
  }

  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();
  }

  // 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);
  }

  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);
  }

  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
  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);
  }
}  // namespace libsemigroups
 
#include "to-presentation.tpp"
 
#endif  // LIBSEMIGROUPS_TO_PRESENTATION_HPP_