Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/GAP/pkg/semigroups/libsemigroups/tests/ (Algebra von RWTH Aachen Version 4.15.1^©) Datei vom 18.5.2025 mit Größe 42 kB

Quelle test-fpsemi-examples-1.cpp Sprache: C

// libsemigroups - C++ library for semigroups and monoids
// Copyright (C) 2022 Murray T. Whyte
//
// 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/>.
//

// This file is the first of three containing tests for the fpsemi-examples
// functions. The presentations here define finite semigroups, and we use
// ToddCoxeter in testing them. Exceptions and defaults are also checked in this
// file.

// #define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER

#include "catch.hpp"      // for REQUIRE, REQUIRE_NOTHROW, REQUIRE_THROWS_AS
#include "test-main.hpp"  // for LIBSEMIGROUPS_TEST_CASE

#include "libsemigroups/fpsemi-examples.hpp"  // for the presentations
#include "libsemigroups/report.hpp"           // for ReportGuard
#include "libsemigroups/todd-coxeter.hpp"     // for ToddCoxeter
#include "libsemigroups/types.hpp"            // for word_type

namespace libsemigroups {
  struct LibsemigroupsException;
  constexpr bool REPORT = false;

  using fpsemigroup::author;
  using fpsemigroup::make;

  using fpsemigroup::alternating_group;
  using fpsemigroup::chinese_monoid;
  using fpsemigroup::cyclic_inverse_monoid;
  using fpsemigroup::dual_symmetric_inverse_monoid;
  using fpsemigroup::fibonacci_semigroup;
  using fpsemigroup::full_transformation_monoid;
  using fpsemigroup::monogenic_semigroup;
  using fpsemigroup::order_preserving_cyclic_inverse_monoid;
  using fpsemigroup::order_preserving_monoid;
  using fpsemigroup::orientation_preserving_monoid;
  using fpsemigroup::orientation_reversing_monoid;
  using fpsemigroup::partial_isometries_cycle_graph_monoid;
  using fpsemigroup::partial_transformation_monoid;
  using fpsemigroup::partition_monoid;
  using fpsemigroup::plactic_monoid;
  using fpsemigroup::rectangular_band;
  using fpsemigroup::rook_monoid;
  using fpsemigroup::singular_brauer_monoid;
  using fpsemigroup::stellar_monoid;
  using fpsemigroup::stylic_monoid;
  using fpsemigroup::symmetric_group;
  using fpsemigroup::symmetric_inverse_monoid;
  using fpsemigroup::temperley_lieb_monoid;
  using fpsemigroup::uniform_block_bijection_monoid;

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "049",
                          "test default values",
                          "[fpsemi-examples][quick]") {
    // author defaults
    REQUIRE(symmetric_group(4) == symmetric_group(4, author::Carmichael));
    REQUIRE(alternating_group(4) == alternating_group(4, author::Moore));
    REQUIRE(full_transformation_monoid(4)
            == full_transformation_monoid(4, author::Iwahori));
    REQUIRE(partial_transformation_monoid(4)
            == partial_transformation_monoid(4, author::Sutov));
    REQUIRE(symmetric_inverse_monoid(4)
            == symmetric_inverse_monoid(4, author::Sutov));
    REQUIRE(dual_symmetric_inverse_monoid(4)
            == dual_symmetric_inverse_monoid(
                4, author::Easdown + author::East + author::FitzGerald));
    REQUIRE(uniform_block_bijection_monoid(4)
            == uniform_block_bijection_monoid(4, author::FitzGerald));
    REQUIRE(partition_monoid(4) == partition_monoid(4, author::East));
    REQUIRE(cyclic_inverse_monoid(4)
            == cyclic_inverse_monoid(4, author::Fernandes));

    // index defaults
    REQUIRE(symmetric_group(4, author::Moore)
            == symmetric_group(4, author::Moore, 0));
    REQUIRE(cyclic_inverse_monoid(4, author::Fernandes)
            == cyclic_inverse_monoid(4, author::Fernandes, 1));
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "002",
                          "full_transformation_monoid author except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(full_transformation_monoid(5, author::Burnside),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "003",
                          "full_transformation_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(full_transformation_monoid(3, author::Iwahori),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "005",
                          "partial_transformation_monoid author except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(partial_transformation_monoid(4, author::Burnside),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "006",
                          "partial_transformation_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(partial_transformation_monoid(3, author::Sutov),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "008",
                          "symmetric_group auth except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(symmetric_group(9, author::Sutov),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "009",
                          "symmetric_group degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(symmetric_group(3, author::Carmichael),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "064",
                          "symmetric_group index except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(symmetric_group(5, author::Moore, 2),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(symmetric_group(5, author::Carmichael, 1),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "012",
                          "dual_symmetric_inverse_monoid auth except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(dual_symmetric_inverse_monoid(9, author::East),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "013",
                          "dual_symmetric_inverse_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(
        dual_symmetric_inverse_monoid(
            2, author::Easdown + author::East + author::FitzGerald),
        LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "015",
                          "uniform_block_bijection_monoid auth except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(uniform_block_bijection_monoid(9, author::Burnside),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "016",
                          "uniform_block_bijection_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(uniform_block_bijection_monoid(2, author::FitzGerald),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "019",
                          "partition_monoid auth except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(partition_monoid(3, author::Burnside),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(partition_monoid(5, author::Machine),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "020",
                          "partition_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(partition_monoid(4, author::Machine),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(partition_monoid(3, author::East),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "036",
                          "alternating_group auth except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(alternating_group(5, author::Sutov),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "037",
                          "alternating_group degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(alternating_group(3, author::Moore),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "039",
                          "chinese_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(chinese_monoid(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(chinese_monoid(0), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "040",
                          "monogenic_semigroup degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(monogenic_semigroup(0, 0), LibsemigroupsException);
    REQUIRE_THROWS_AS(monogenic_semigroup(5, 0), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "041",
                          "rectangular_band degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(rectangular_band(0, 0), LibsemigroupsException);
    REQUIRE_THROWS_AS(rectangular_band(1, 0), LibsemigroupsException);
    REQUIRE_THROWS_AS(rectangular_band(0, 1), LibsemigroupsException);
    REQUIRE_THROWS_AS(rectangular_band(0, 100), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "042",
                          "stellar_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(stellar_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(stellar_monoid(1), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "043",
                          "plactic_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(plactic_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(plactic_monoid(1), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "044",
                          "stylic_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(stylic_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(stylic_monoid(1), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "045",
                          "temperley_lieb_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(temperley_lieb_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(temperley_lieb_monoid(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(temperley_lieb_monoid(2), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "046",
                          "singular_brauer_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(singular_brauer_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(singular_brauer_monoid(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(singular_brauer_monoid(2), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "047",
                          "orientation_preserving_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(orientation_preserving_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(orientation_preserving_monoid(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(orientation_preserving_monoid(2), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "048",
                          "orientation_reversing_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(orientation_reversing_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(orientation_reversing_monoid(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(orientation_reversing_monoid(2), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "055",
                          "order_preserving_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(order_preserving_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(order_preserving_monoid(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(order_preserving_monoid(2), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "061",
                          "cyclic_inverse_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(0, author::Fernandes, 0),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(1, author::Fernandes, 0),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(2, author::Fernandes, 0),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(0, author::Fernandes, 1),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(1, author::Fernandes, 1),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(2, author::Fernandes, 1),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "062",
                          "cyclic_inverse_monoid author except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(5, author::Burnside, 0),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(cyclic_inverse_monoid(5, author::Fernandes, 3),
                      LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "063",
                          "order_preserving_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(order_preserving_monoid(0), LibsemigroupsException);
    REQUIRE_THROWS_AS(order_preserving_monoid(1), LibsemigroupsException);
    REQUIRE_THROWS_AS(order_preserving_monoid(2), LibsemigroupsException);
  }

  LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                          "069",
                          "partial_isometries_cycle_graph_monoid degree except",
                          "[fpsemi-examples][quick]") {
    auto rg = ReportGuard(REPORT);
    REQUIRE_THROWS_AS(partial_isometries_cycle_graph_monoid(0),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(partial_isometries_cycle_graph_monoid(1),
                      LibsemigroupsException);
    REQUIRE_THROWS_AS(partial_isometries_cycle_graph_monoid(2),
                      LibsemigroupsException);
  }

  namespace congruence {
    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "001",
                            "full_transformation_monoid(5) Iwahori",
                            "[fpsemi-examples][standard]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = full_transformation_monoid(n, author::Iwahori);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n + 1);
      presentation::replace_word(p, word_type({}), {n});
      presentation::add_identity_rules(p, n);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n + 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 3125);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "004",
                            "partial_transformation_monoid(5) Sutov",
                            "[fpsemi-examples][standard]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = partial_transformation_monoid(n, author::Sutov);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n + 2);
      presentation::replace_word(p, word_type({}), {n + 1});
      presentation::add_identity_rules(p, n + 1);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n + 2);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 7776);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "038",
                            "partial_transformation_monoid(3) Machine",
                            "[fpsemi-examples][quick]") {
      auto rg = ReportGuard(REPORT);
      auto s  = partial_transformation_monoid(3, author::Machine);
      auto p  = make<Presentation<word_type>>(s);
      p.alphabet(5);
      presentation::replace_word(p, word_type({}), {4});
      presentation::add_identity_rules(p, 4);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(5);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 64);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "007",
                            "symmetric_inverse_monoid(5)",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = symmetric_inverse_monoid(n, author::Sutov);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n + 1);
      presentation::replace_word(p, word_type({}), {n});
      presentation::add_identity_rules(p, n);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n + 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 1546);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "010",
                            "symmetric_group(6) Burnside + Miller",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 6;
      auto   s  = symmetric_group(n, author::Burnside + author::Miller);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n);
      presentation::replace_word(p, word_type({}), {n - 1});
      presentation::add_identity_rules(p, n - 1);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 720);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "031",
                            "symmetric_group(6) Carmichael",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 6;
      auto   s  = symmetric_group(n, author::Carmichael);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n);
      presentation::replace_word(p, word_type({}), {n - 1});
      presentation::add_identity_rules(p, n - 1);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 720);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "032",
                            "symmetric_group(6) Moore index 0",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 6;
      auto   s  = symmetric_group(n, author::Moore);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(3);
      presentation::replace_word(p, word_type({}), {2});
      presentation::add_identity_rules(p, 2);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(3);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 720);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "065",
                            "symmetric_group(7) Moore index 1",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 7;
      auto   s  = symmetric_group(n, author::Moore, 1);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n);
      presentation::replace_word(p, word_type({}), {n - 1});
      presentation::add_identity_rules(p, n - 1);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 5040);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "033",
                            "symmetric_group(6) Coxeter + Moser",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 6;
      auto   s  = symmetric_group(n, author::Coxeter + author::Moser);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n);
      presentation::replace_word(p, word_type({}), {n - 1});
      presentation::add_identity_rules(p, n - 1);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 720);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "011",
                            "dual_symmetric_inverse_monoid(5)",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = dual_symmetric_inverse_monoid(
          n, author::Easdown + author::East + author::FitzGerald);
      auto p = make<Presentation<word_type>>(s);
      p.validate();
      auto        m = p.alphabet().size();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 6721);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "014",
                            "uniform_block_bijection_monoid(5)",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = uniform_block_bijection_monoid(n, author::FitzGerald);
      auto   p  = make<Presentation<word_type>>(s);
      p.validate();
      auto        m = p.alphabet().size();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 1496);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "017",
                            "partition_monoid(5)",
                            "[fpsemi-examples][standard]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = partition_monoid(n, author::East);
      auto   p  = make<Presentation<word_type>>(s);
      p.validate();
      auto        m = p.alphabet().size();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 115975);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "018",
                            "partition_monoid(3)",
                            "[fpsemi-examples][standard]") {
      auto rg = ReportGuard(REPORT);
      auto s  = partition_monoid(3, author::Machine);
      auto p  = make<Presentation<word_type>>(s);
      p.validate();
      ToddCoxeter tc(congruence_kind::twosided);
      auto        m = p.alphabet().size();
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 203);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "021",
                            "rectangular_band(5, 9)",
                            "[fpsemi-examples][standard]") {
      auto rg = ReportGuard(REPORT);
      auto s  = rectangular_band(5, 9);
      auto p  = make<Presentation<word_type>>(s);
      p.validate();
      auto m = p.alphabet().size();
      p.validate();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 45);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "022",
                            "monogenic_semigroup(4, 9)",
                            "[fpsemi-examples][quick]") {
      auto rg = ReportGuard(REPORT);
      auto s  = monogenic_semigroup(4, 9);
      auto p  = make<Presentation<word_type>>(s);
      p.validate();
      auto m = p.alphabet().size();
      p.validate();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 12);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "023",
                            "fibonacci_semigroup(2, 5)",
                            "[fpsemi-examples][quick]") {
      auto rg = ReportGuard(REPORT);
      auto s  = fibonacci_semigroup(2, 5);
      auto p  = make<Presentation<word_type>>(s);
      p.validate();
      auto m = p.alphabet().size();
      p.validate();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 11);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "024",
                            "temperley_lieb_monoid(10)",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 10;
      auto   s  = temperley_lieb_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n);
      presentation::add_identity_rules(p, n - 1);
      p.validate();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 16796);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "025",
                            "singular_brauer_monoid(6)",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 6;
      auto   s  = singular_brauer_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.validate();
      auto        m = p.alphabet().size();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 9675);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "026",
                            "orientation_preserving_monoid(6)",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 6;
      auto   s  = orientation_preserving_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.validate();
      auto        m = p.alphabet().size();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 2742);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "027",
                            "orientation_reversing_monoid(5)",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = orientation_reversing_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.validate();
      auto        m = p.alphabet().size();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 1015);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "034",
                            "test for the rook monoid",
                            "[fpsemi-examples][quick]") {
      auto rg = ReportGuard(REPORT);
      auto s  = rook_monoid(4, 1);
      auto p  = make<Presentation<word_type>>(s);
      p.validate();
      auto        m = p.alphabet().size();
      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(m);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 209);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "035",
                            "alternating_group(7) Moore",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 7;
      auto   s  = alternating_group(n, author::Moore);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n - 1);
      presentation::replace_word(p, word_type({}), {n - 2});
      presentation::add_identity_rules(p, n - 2);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n - 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 2520);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "050",
                            "full_transformation_monoid(4) Aizenstat",
                            "[fpsemi-examples][standard]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 4;
      auto   s  = full_transformation_monoid(n, author::Aizenstat);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(4);
      presentation::replace_word(p, word_type({}), {3});
      presentation::add_identity_rules(p, 3);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(4);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 256);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "053",
                            "order_preserving_monoid(5)",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = order_preserving_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(2 * n - 1);
      presentation::add_identity_rules(p, 2 * n - 2);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(2 * n - 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 126);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "054",
                            "order_preserving_monoid(10)",
                            "[fpsemi-examples][standard]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 10;
      auto   s  = order_preserving_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(2 * n - 1);
      presentation::add_identity_rules(p, 2 * n - 2);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(2 * n - 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 92'378);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "056",
                            "cyclic_inverse_monoid(4) Fernandes 1",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 4;
      auto   s  = cyclic_inverse_monoid(n, author::Fernandes, 1);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(3);
      presentation::replace_word(p, word_type({}), {2});
      presentation::add_identity_rules(p, 2);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(3);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 61);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "057",
                            "cyclic_inverse_monoid(8) Fernandes index 1",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 8;
      auto   s  = cyclic_inverse_monoid(n, author::Fernandes, 1);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(3);
      presentation::replace_word(p, word_type({}), {2});
      presentation::add_identity_rules(p, 2);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(3);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 2041);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "058",
                            "cyclic_inverse_monoid Fernandes index 0",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto rg = ReportGuard(REPORT);
      for (size_t n = 3; n < 10; ++n) {
        auto p = make<Presentation<word_type>>(
            fpsemigroup::cyclic_inverse_monoid(n, author::Fernandes, 0));
        REQUIRE(p.rules.size() == (n * n + 3 * n + 4));
        p.alphabet(n + 2);
        presentation::replace_word(p, word_type({}), {n + 1});
        presentation::add_identity_rules(p, n + 1);
        p.alphabet_from_rules();
        p.validate();

        ToddCoxeter tc(congruence_kind::twosided);
        tc.set_number_of_generators(n + 2);
        for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
          tc.add_pair(p.rules[i], p.rules[i + 1]);
        }
        REQUIRE(tc.number_of_classes() == n * std::pow(2, n) - n + 1);
      }
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "059",
                            "order_preserving_cyclic_inverse_monoid(4)",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 4;
      auto   s  = order_preserving_cyclic_inverse_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n + 1);
      presentation::replace_word(p, word_type({}), {n});
      presentation::add_identity_rules(p, n);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n + 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 38);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "060",
                            "order_preserving_cyclic_inverse_monoid(10)",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 11;
      auto   s  = order_preserving_cyclic_inverse_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n + 1);
      presentation::replace_word(p, word_type({}), {n});
      presentation::add_identity_rules(p, n);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n + 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 6120);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "066",
                            "order_preserving_cyclic_inverse_monoid(10)",
                            "[fpsemi-examples][quick][no-valgrind]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 11;
      auto   s  = order_preserving_cyclic_inverse_monoid(n);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n + 1);
      presentation::replace_word(p, word_type({}), {n});
      presentation::add_identity_rules(p, n);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n + 1);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 6120);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "067",
                            "partial_isometries_cycle_graph_monoid(5)",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 5;
      auto   s  = partial_isometries_cycle_graph_monoid(n);
      REQUIRE(s.size() == 16);
      auto p = make<Presentation<word_type>>(s);
      p.alphabet(4);
      presentation::replace_word(p, word_type({}), {3});
      presentation::add_identity_rules(p, 3);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(4);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 286);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "070",
                            "partial_isometries_cycle_graph_monoid(4)",
                            "[fpsemi-examples][quick]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 4;
      auto   s  = partial_isometries_cycle_graph_monoid(n);
      REQUIRE(s.size() == 13);
      auto p = make<Presentation<word_type>>(s);
      p.alphabet(4);
      presentation::replace_word(p, word_type({}), {3});
      presentation::add_identity_rules(p, 3);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(4);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 97);
    }

    LIBSEMIGROUPS_TEST_CASE(
        "fpsemi-examples",
        "068",
        "partial_isometries_cycle_graph_monoid(10)",
        "[fpsemi-examples][quick][no-valgrind][no-coverage]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 10;
      auto   s  = partial_isometries_cycle_graph_monoid(n);
      REQUIRE(s.size() == 52);
      auto p = make<Presentation<word_type>>(s);
      p.alphabet(4);
      presentation::replace_word(p, word_type({}), {3});
      presentation::add_identity_rules(p, 3);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(4);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 20'311);
    }

    LIBSEMIGROUPS_TEST_CASE("fpsemi-examples",
                            "051",
                            "not_symmetric_group(4)",
                            "[fpsemi-examples][standard]") {
      auto   rg = ReportGuard(REPORT);
      size_t n  = 4;
      auto   s  = not_symmetric_group(n,
                                   author::Guralnick + author::Kantor
                                       + author::Kassabov + author::Lubotzky);
      auto   p  = make<Presentation<word_type>>(s);
      p.alphabet(n);
      presentation::replace_word(p, word_type({}), {n - 1});
      presentation::add_identity_rules(p, n - 1);
      p.validate();

      ToddCoxeter tc(congruence_kind::twosided);
      tc.set_number_of_generators(n);
      for (size_t i = 0; i < p.rules.size() - 1; i += 2) {
        tc.add_pair(p.rules[i], p.rules[i + 1]);
      }
      REQUIRE(tc.number_of_classes() == 72);
    }

  }  // namespace congruence
}  // namespace libsemigroups

quality86%

¤ Dauer der Verarbeitung: 0.27 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.