to-presentation.hpp

//
// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2023-2025 James D. Mitchell
//
// 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...
 
#include "detail/knuth-bendix-impl.hpp"  // for KnuthBendixImpl
 
namespace libsemigroups {



  // 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 <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);
  }
  auto to(KnuthBendix<Word, Rewriter, ReductionOrder>& kb) {…}

  // Presentation + function -> Presentation

  template <typename Result, typename Word, typename Func>
  auto to(Presentation<Word> const& p, Func&& f) -> std::enable_if_t<
      std::is_same_v<Presentation<typename Result::word_type>, Result>,
      Result>;

  // InversePresentation + function -> InversePresentation

  template <typename Result, typename Word, typename Func>
  auto to(InversePresentation<Word> const& ip, Func&& f) -> std::enable_if_t<
      std::is_same_v<InversePresentation<typename Result::word_type>, Result>,
      Result>;

  // Presentation -> Presentation

  template <typename Result, typename Word>
  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>;
 
  // This function is documented above because Doxygen conflates these two
  // functions.
  template <typename Result, typename Word>
  auto to(Presentation<Word> const& p) noexcept
      -> std::enable_if_t<std::is_same_v<Presentation<Word>, Result>,
                          Result const&> {
    return p;
  }
  auto to(Presentation<Word> const& p) noexcept {…}

  // InversePresentation -> InversePresentation

  template <typename Result, typename Word>
  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> {
    using WordOutput = typename Result::word_type;
    return to<InversePresentation<WordOutput>>(ip, [&ip](auto val) {
      return words::human_readable_letter<WordOutput>(ip.index(val));
    });
  }
  auto to(InversePresentation<Word> const& ip) noexcept -> std::enable_if_t< {…}
 
  // This function is documented above because Doxygen conflates these two
  // functions.
  template <typename Result, typename Word>
  auto to(InversePresentation<Word> const& ip) noexcept
      -> std::enable_if_t<std::is_same_v<InversePresentation<Word>, Result>,
                          Result const&> {
    return 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> cont& p) -> std::enable_if_t<
      std::is_same_v<InversePresentation<Word>, Thing<Word>>,
      InversePresentation<Word>>;
#else
  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>>;
#endif
 
}  // namespace libsemigroups
 
#include "to-presentation.tpp"
 
#endif  // LIBSEMIGROUPS_TO_PRESENTATION_HPP_