rebuilding site Thu 23 Mar 2023 14:32:43 GMT

Author: james-d-mitchell

_sources/changelog.rst.txt

@@ -7,6 +7,16 @@
 Changelog
 =========
 
+v0.10.0 (released 23/03/2023)
+-----------------------------
+
+This is a minor release adding some new functionality from ``libsemigroups``:
+
+* ukkonen: add support for ``Ukkonen`` + helpers by @james-d-mitchell in
+  https://github.com/libsemigroups/libsemigroups_pybind11/pull/132
+* present: add further manip. funcs by @james-d-mitchell in 
+  https://github.com/libsemigroups/libsemigroups_pybind11/pull/136
+
 v0.9.2 (released 22/03/2023)
 ----------------------------
 

_sources/index.rst.txt

@@ -1,5 +1,5 @@
-libsemigroups_pybind11 - Version 0.9.2
-======================================
+libsemigroups_pybind11 - Version 0.10.0
+=======================================
 
 python bindings for the C++ library libsemigroups
 -------------------------------------------------

_sources/install.rst.txt

@@ -4,7 +4,7 @@
 
    The full license is in the file LICENSE, distributed with this software.
 
-.. |libsemigroups-pybind11-version| replace:: 0.9.2
+.. |libsemigroups-pybind11-version| replace:: 0.10.0
 
 Installation
 ============

_sources/misc.rst.txt

@@ -14,3 +14,4 @@ In this section we describe some miscellaneous functionality in
    :maxdepth: 1
 
    report
+   ukkonen/index

_sources/presentations/present-helpers.rst.txt

@@ -54,6 +54,10 @@ Contents
      - Greedily reduce the length of the presentation using
        :py:func:`longest_common_subword`.
 
+   * - :py:func:`is_strongly_compressible`
+     - Returns ``True`` if a :math:`1`-relation presentation can be strongly
+       compressed.
+
    * - :py:func:`length`
      - Return the sum of the lengths of the rules.
 
@@ -85,6 +89,10 @@ Contents
        \rvert < \lvert v \rvert`, then replace :math:`u = v` with :math:`u =
        w`.
 
+   * - :py:func:`reduce_to_2_generators`
+     - Reduce the number of generators in a :math:`1`-relation presentation to
+       ``2``.
+
    * - :py:func:`redundant_rule`
      - Returns the index of the left hand side of a redundant rule.
 
@@ -120,6 +128,9 @@ Contents
      - Sort the rules :math:`u_1 = v_1, \ldots, u_n = v_n` so that :math:`u_1
        v_1 < \cdots < u_n v_n`, where :math:`<` is the shortlex order.
 
+   * - :py:func:`strongly_compress`
+     - Strongly compress a :math:`1`-relation presentation.
+
 Full API
 --------
 
@@ -367,6 +378,28 @@ Full API
      if :py:func:`longest_common_subword` or :py:func:`replace_word` does.
 
 
+.. py:function:: is_strongly_compressible(p: Presentation) -> bool
+
+   Returns ``True`` if the :math:`1`-relation presentation can be strongly
+   compressed.
+
+   A :math:`1`-relation presentation is *strongly compressible* if both
+   relation words start with the same letter and end with the same letter.
+   In other words, if the alphabet of the presentation ``p`` is :math:`A` and
+   the relation words are of the form :math:`aub = avb` where :math:`a, b\in A`
+   (possibly :math:`a = b`) and :math:`u, v\in A^*`, then ``p`` is strongly
+   compressible. See `Section 3.2`_ for details.
+
+   .. _Section 3.2: https://doi.org/10.1007/s00233-021-10216-8
+
+   :param p:  the presentation
+   :type p: Presentation
+
+   :returns: A value of type ``bool``.
+
+   .. seealso:: :py:func:`strongly_compress`
+
+
 .. py:function:: length(p: Presentation) -> int
 
    Return the sum of the lengths of the rules.
@@ -534,6 +567,35 @@ Full API
       ['a', 'aaa', 'a', 'aaaaa']
 
 
+.. py:function:: reduce_to_2_generators(p: Presentation) -> None
+
+     Reduce the number of generators in a :math:`1`-relation presentation to
+     ``2``.
+
+     Returns ``True`` if the :math:`1`-relation presentation ``p`` has been
+     modified and ``False`` if not.
+
+     A :math:`1`-relation presentation is *left cycle-free* if the relation
+     words start with distinct letters. In other words, if the alphabet of the
+     presentation ``p`` is :math:`A` and the relation words are of the form
+     :math:`au = bv` where :math:`a, b\in A` with :math:`a \neq b` and
+     :math:`u, v \in A^*`, then ``p`` is left cycle-free. The word problem for
+     a left cycle-free :math:`1`-relation monoid is solvable if the word
+     problem for the modified version obtained from this function is solvable.
+
+     :param p:  the presentation
+     :type p: Presentation
+     :param x:
+       determines the choice of letter to use, ``0`` uses
+       ``p.rules[0].front()`` and ``1`` uses ``p.rules[1].front()`` (defaults to:
+       ``0``).
+     :type x: int
+
+     :returns: A value of type ``bool``.
+
+     :raises RuntimeError: if ``index`` is not ``0`` or ``1``.
+
+
 .. py:function:: redundant_rule(p: Presentation, t: datetime.timedelta) -> int
 
    Return the index of the the left hand side of a redundant rule.
@@ -573,9 +635,9 @@ Full API
       >>> presentation.add_rule(p, "ab", "ba")
       >>> presentation.add_rule(p, "bab", "abb")
       >>> t = timedelta(seconds = 1)
-      >>> p.rules  
+      >>> p.rules
       ['ab', 'ba', 'bab', 'abb']
-      >>> presentation.redundant_rule(p, t) 
+      >>> presentation.redundant_rule(p, t)
       2
 
 
@@ -770,3 +832,19 @@ Full API
    :type p: Presentation
 
    :returns: None
+
+
+.. py:function:: strongly_compress(p: Presentation) -> None
+
+   Strongly compress a :math:`1`-relation presentation.
+
+   Returns ``True`` if the :math:`1`-relation presentation ``p`` has been
+   modified and ``False`` if not. The word problem is solvable for the input
+   presentation if it is solvable for the modified version.
+
+   :param p:  the presentation
+   :type p: Presentation
+
+   :returns: A value of type ``bool``.
+
+   .. seealso:: :py:func:`is_strongly_compressible`

_sources/ukkonen/index.rst.txt

@@ -0,0 +1,18 @@
+.. Copyright (c) 2023, J. D. Mitchell
+
+   Distributed under the terms of the GPL license version 3.
+
+   The full license is in the file LICENSE, distributed with this software.
+
+Ukkonen
+=======
+
+This page describes the functionality related to Ukkonen's algorithm and
+generalised suffix trees in ``libsemigroups_pybind11``.
+
+
+.. toctree::
+   :maxdepth: 1
+
+   ukkonen
+   ukkonen-helpers

_sources/ukkonen/ukkonen-helpers.rst.txt

@@ -0,0 +1,81 @@
+.. Copyright (c) 2023, J. D. Mitchell
+
+   Distributed under the terms of the GPL license version 3.
+
+   The full license is in the file LICENSE, distributed with this software.
+
+.. currentmodule:: _libsemigroups_pybind11
+
+Ukkonen helper functions
+========================
+
+This page contains the documentation for various helper functions for
+manipulating ``Ukkonen`` objects. All such functions are contained in the
+submodule ``libsemigroups_pybind11.ukkonen``.
+
+Contents
+--------
+
+.. list-table::
+   :widths: 50 50
+   :header-rows: 0
+
+   * - :py:func:`add_words_no_checks`
+     - Add all words in a ``list`` to a :py:class:`Ukkonen` object.
+   * - :py:func:`add_words`
+     - Add all words in a ``list`` to a :py:class:`Ukkonen` object.
+   * - :py:func:`dot`
+     - Returns a string containing a `GraphViz <https://graphviz.org>`_
+       representation of a suffix tree.
+   * - :py:func:`is_piece_no_checks`
+     - Check if a word is a piece.
+   * - :py:func:`is_piece`
+     - Check if a word is a piece.
+   * - :py:func:`is_subword_no_checks`
+     - Check if a word is a subword of any word in a suffix tree.
+   * - :py:func:`is_subword`
+     - Check if a word is a subword of any word in a suffix tree.
+   * - :py:func:`is_suffix_no_checks`
+     - Check if a word is a suffix of any word in a suffix tree.
+   * - :py:func:`is_suffix`
+     - Check if a word is a suffix of any word in a suffix tree.
+   * - :py:func:`maximal_piece_prefix_no_checks`
+     - Find the maximal piece prefix of a word.
+   * - :py:func:`maximal_piece_prefix`
+     - Find the maximal piece prefix of a word.
+   * - :py:func:`maximal_piece_suffix_no_checks`
+     - Find the maximal piece suffix of a word.
+   * - :py:func:`maximal_piece_suffix`
+     - Find the maximal piece suffix of a word.
+   * - :py:func:`number_of_distinct_subwords`
+     - Returns the number of distinct subwords of the words in a suffix tree.
+   * - :py:func:`number_of_pieces_no_checks`
+     - Find the number of pieces in a decomposition of a word (if any).
+   * - :py:func:`number_of_pieces`
+     - Find the number of pieces in a decomposition of a word (if any).
+   * - :py:func:`pieces_no_checks`
+     - Find the pieces in a decomposition of a word (if any).
+   * - :py:func:`pieces`
+     - Find the pieces in a decomposition of a word (if any).
+
+Full API
+--------
+
+.. autofunction:: add_words_no_checks
+.. autofunction:: add_words
+.. autofunction:: libsemigroups_pybind11.ukkonen.dot
+.. autofunction:: is_piece_no_checks
+.. autofunction:: is_piece
+.. autofunction:: is_subword_no_checks
+.. autofunction:: is_subword
+.. autofunction:: is_suffix_no_checks
+.. autofunction:: is_suffix
+.. autofunction:: maximal_piece_prefix_no_checks
+.. autofunction:: maximal_piece_prefix
+.. autofunction:: maximal_piece_suffix_no_checks
+.. autofunction:: maximal_piece_suffix
+.. autofunction:: number_of_distinct_subwords
+.. autofunction:: number_of_pieces_no_checks
+.. autofunction:: number_of_pieces
+.. autofunction:: pieces_no_checks
+.. autofunction:: pieces

_sources/ukkonen/ukkonen.rst.txt

@@ -0,0 +1,42 @@
+.. Copyright (c) 2023, J. D. Mitchell
+
+   Distributed under the terms of the GPL license version 3.
+
+   The full license is in the file LICENSE, distributed with this software.
+
+.. currentmodule:: _libsemigroups_pybind11
+
+Ukkonen
+=======
+
+This page describes the functionality in the ``Ukkonen`` class.
+
+``Ukkonen`` instance can be used to construction generalised suffix trees using
+Ukkonen's algorithm. Some related functionality is available in
+``libsemigroups_pybind11.ukkonen``.
+
+Contents
+--------
+
+.. autosummary::
+   :nosignatures:
+
+   ~Ukkonen
+   Ukkonen.add_word
+   Ukkonen.add_word_no_checks
+   Ukkonen.is_unique_letter
+   Ukkonen.length_of_distinct_words
+   Ukkonen.length_of_words
+   Ukkonen.max_word_length
+   Ukkonen.multiplicity
+   Ukkonen.number_of_distinct_words
+   Ukkonen.number_of_words
+   Ukkonen.unique_letter
+   Ukkonen.validate_word
+   Ukkonen.word_index
+
+Full API
+--------
+
+.. autoclass:: Ukkonen
+   :members:

_static/documentation_options.js

@@ -1,6 +1,6 @@
 var DOCUMENTATION_OPTIONS = {
     URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
-    VERSION: '0.9.2',
+    VERSION: '0.10.0',
     LANGUAGE: 'python',
     COLLAPSE_INDEX: false,
     BUILDER: 'html',

api/PPerm.html

@@ -4,7 +4,7 @@
   <meta charset="utf-8" /><meta name="generator" content="Docutils 0.17.1: http://docutils.sourceforge.net/" />
 
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>Partial perms &mdash; libsemigroups_pybind11 0.9.2 documentation</title>
+  <title>Partial perms &mdash; libsemigroups_pybind11 0.10.0 documentation</title>
       <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
       <link rel="stylesheet" href="../_static/css/theme.css" type="text/css" />
       <link rel="stylesheet" href="../_static/copybutton.css" type="text/css" />
@@ -37,7 +37,7 @@
             <a href="../index.html" class="icon icon-home"> libsemigroups_pybind11
           </a>
               <div class="version">
-                0.9.2
+                0.10.0
               </div>
 <div role="search">
   <form id="rtd-search-form" class="wy-form" action="../search.html" method="get">