lyndon-words 0.2.0__tar.gz

lyndon_words-0.2.0/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Report incorrect output or an unexpected error
+labels: bug
+---
+
+**Function called**
+<!-- e.g. factorize("banana") or de_bruijn(alphabet_size=2, length=3) -->
+
+**Input**
+<!-- The word, alphabet_size, and length you passed -->
+
+**Expected output**
+<!-- What you expected -->
+
+**Actual output**
+<!-- What you got -->
+
+**Python version**
+<!-- e.g. 3.11.4 -->
+
+**lyndon-words version**
+<!-- e.g. 0.1.0 -->

lyndon_words-0.2.0/.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,14 @@
+---
+name: Feature request
+about: Suggest a new algorithm or combinatorics-on-words primitive
+labels: enhancement
+---
+
+**What would you like?**
+<!-- Describe the feature -->
+
+**Reference**
+<!-- If it's a published algorithm or definition, please cite the source -->
+
+**Example**
+<!-- Show a concrete input/output example -->

lyndon_words-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install -e ".[dev]"
+      - run: ruff check .
+      - run: mypy src
+      - run: pytest -q

lyndon_words-0.2.0/.gitignore

@@ -0,0 +1,18 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+dist/
+build/
+*.egg
+.venv/
+venv/
+env/
+.env
+*.so
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.hypothesis/
+uv.lock
+*.dist-info/

lyndon_words-0.2.0/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
+adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Planned
+- PyPI release (pending new-project quota reset)
+
+## [0.2.0] - 2026-06-17
+
+### Added
+- `lyndon_array(word)`: for each index `i` of the input, returns the length of
+  the longest Lyndon word that is a prefix of the suffix `word[i:]`. The result
+  has the same length as the input; every entry satisfies `1 <= result[i] <= n - i`.
+- The first entry `lyndon_array(word)[0]` equals the length of the first factor
+  in the Chen-Fox-Lyndon factorization of `word`.
+
+### Notes
+- PyPI publish is queued behind the new-project quota limit. Install from source
+  or from the GitHub release until the quota resets.
+
+## [0.1.0] - 2026-06-17
+
+### Added
+- `is_lyndon(word)`: test whether a word is a Lyndon word, via Duval's algorithm.
+- `factorize(word)`: Duval's O(n) Chen-Fox-Lyndon factorization into non-increasing
+  Lyndon factors.
+- `enumerate_necklaces(*, alphabet_size, length)`: FKM enumeration of rotation-class
+  representatives in lexicographic order.
+- `enumerate_bracelets(*, alphabet_size, length)`: enumeration of dihedral-class
+  (rotation and reflection) representatives in lexicographic order.
+- `de_bruijn(*, alphabet_size, length)`: De Bruijn sequence B(k, n) via the FKM
+  construction.

lyndon_words-0.2.0/CLAUDE.md

@@ -0,0 +1,50 @@
+# lyndon-words
+
+Pure-Python combinatorics on words: Lyndon words, Duval factorization, necklace and
+bracelet enumeration, De Bruijn sequences. Zero runtime dependencies.
+
+## Commands
+
+- Create env and install: `uv venv && uv pip install -e ".[dev]"`
+- Test: `uv run pytest -q`
+- Lint: `uv run ruff check .` (format with `uv run ruff format .`)
+- Types: `uv run mypy src`
+- Build: `uv build` (then `uv run --with twine twine check dist/*` before publishing)
+
+## Architecture
+
+`src/lyndon_words/`:
+- `lyndon.py`: `is_lyndon` and `factorize` (Duval's Chen-Fox-Lyndon factorization).
+- `necklaces.py`: `enumerate_necklaces`, `enumerate_bracelets`, `_euler_phi`, `_divisors`.
+- `debruijn.py`: `de_bruijn` (FKM construction).
+- `__init__.py`: public surface.
+
+See `docs/architecture.md` for precise definitions and references (Duval 1983, FKM).
+
+## Conventions
+
+- Words over an integer alphabet are `tuple[int, ...]`. `is_lyndon` and `factorize`
+  accept any comparable `Sequence` (str, list, tuple).
+- Enumeration and generation functions take keyword-only `alphabet_size` and `length`
+  with no default values. The positional `word` argument is fine for word predicates.
+- Pure functions, strict typing, zero runtime dependencies (standard library only).
+- Validate inputs and raise clear ValueError messages.
+
+## Testing rules
+
+- Golden values for Lyndon tests and small enumerations.
+- Necklace counts cross-checked against the cycle-index formula and a brute-force scan.
+- Bracelet and De Bruijn results cross-checked against brute force.
+- Factorization invariants: each factor is Lyndon, non-increasing, concatenates to input.
+- Bug fixes start with a failing test.
+
+## Release
+
+- Semantic versioning; update CHANGELOG.md and __version__.
+- Gates: `uv run pytest && uv run ruff check . && uv run mypy src && uv build && uv run --with twine twine check dist/*`.
+- Do NOT publish to PyPI (pending quota reset). Tag vX.Y.Z and GitHub release.
+
+## Style
+
+- No em dash characters in docs, comments, or commit messages.
+- Comments explain non-obvious reasoning only.

lyndon_words-0.2.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,37 @@
+# Code of Conduct
+
+## Our pledge
+
+We as members, contributors, and maintainers pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our standards
+
+Examples of behavior that contributes to a positive environment:
+
+- Showing empathy and kindness toward other people.
+- Being respectful of differing opinions, viewpoints, and experiences.
+- Giving and gracefully accepting constructive feedback.
+- Focusing on what is best for the community.
+
+Examples of unacceptable behavior:
+
+- Harassment, insulting or derogatory comments, and personal or political attacks.
+- Public or private harassment.
+- Publishing others' private information without explicit permission.
+- Other conduct which could reasonably be considered inappropriate.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the maintainer at amaar2cool@gmail.com. All complaints will be
+reviewed and investigated promptly and fairly.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org),
+version 2.1.

lyndon_words-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,33 @@
+# Contributing to lyndon-words
+
+Thanks for your interest. This project values correctness, precise definitions, and zero
+runtime dependencies.
+
+## Development
+
+```sh
+uv venv
+uv pip install -e ".[dev]"
+uv run pytest -q
+uv run ruff check .
+uv run mypy src
+```
+
+A standard virtual environment with `pip install -e ".[dev]"` works the same way.
+
+## Guidelines
+
+- No runtime dependencies. The standard library is enough.
+- Functions are pure. Enumeration and generation functions use keyword-only parameters
+  with no default values.
+- Every function needs exact-value tests plus structural invariants, cross-checked against
+  a brute-force reference where practical.
+- A bug fix starts with a failing test.
+- Run `uv run ruff format .` before committing.
+- Commit messages follow `type(scope): description`.
+- No em dash characters in code, comments, or commit messages.
+
+## Reporting issues
+
+Open an issue with the word or parameters, the function called, and what you expected
+versus what you observed.

lyndon_words-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Amaar Chughtai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lyndon_words-0.2.0/PKG-INFO

@@ -0,0 +1,184 @@
+Metadata-Version: 2.4
+Name: lyndon-words
+Version: 0.2.0
+Summary: Lyndon words, Duval factorization, necklace and bracelet enumeration, and De Bruijn sequences in pure Python.
+Project-URL: Homepage, https://github.com/amaar-mc/lyndon-words
+Project-URL: Repository, https://github.com/amaar-mc/lyndon-words
+Project-URL: Issues, https://github.com/amaar-mc/lyndon-words/issues
+Project-URL: Changelog, https://github.com/amaar-mc/lyndon-words/blob/main/CHANGELOG.md
+Author: Amaar Chughtai
+License: MIT License
+        
+        Copyright (c) 2026 Amaar Chughtai
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: combinatorics,combinatorics-on-words,de-bruijn,lyndon-words,necklaces,strings
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# lyndon-words
+
+<p align="center">
+  <img src="assets/logo.png" alt="lyndon-words logo" width="160">
+</p>
+
+[![CI](https://github.com/amaar-mc/lyndon-words/actions/workflows/ci.yml/badge.svg)](https://github.com/amaar-mc/lyndon-words/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE)
+
+Combinatorics on words in pure Python with zero dependencies: Lyndon-word testing, Duval's
+Chen-Fox-Lyndon factorization, necklace and bracelet enumeration, and De Bruijn sequences.
+
+## What is this?
+
+A **Lyndon word** is a non-empty word that is strictly smaller than all of its rotations.
+Lyndon words are the building blocks of combinatorics on words: every word factors uniquely
+into a non-increasing concatenation of Lyndon words (the Chen-Fox-Lyndon theorem), and
+Lyndon words index the necklaces (rotation classes) and the De Bruijn sequences over an
+alphabet.
+
+This library implements the classic algorithms directly, with no dependencies and strict
+typing.
+
+## Install
+
+```sh
+pip install lyndon-words
+```
+
+> PyPI release pending. Install from source:
+> ```sh
+> git clone https://github.com/amaar-mc/lyndon-words
+> cd lyndon-words
+> pip install -e .
+> ```
+
+## Quick start
+
+```python
+from lyndon_words import is_lyndon, factorize, enumerate_necklaces, enumerate_bracelets, de_bruijn, lyndon_array
+
+# Lyndon-word test (accepts str, list, or tuple)
+is_lyndon("aab")     # True
+is_lyndon("aba")     # False
+is_lyndon((0, 0, 1)) # True
+
+# Duval's Chen-Fox-Lyndon factorization (non-increasing Lyndon factors)
+factorize("banana")  # ['b', 'an', 'an', 'a']
+factorize("aababab") # ['aabab', 'ab']
+
+# Necklaces: rotation-class representatives over {0, 1} of length 3
+list(enumerate_necklaces(alphabet_size=2, length=3))
+# [(0, 0, 0), (0, 0, 1), (0, 1, 1), (1, 1, 1)]
+
+# Bracelets: rotation + reflection classes over {0, 1} of length 4
+list(enumerate_bracelets(alphabet_size=2, length=4))
+# [(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 1), (0, 1, 0, 1), (0, 1, 1, 1), (1, 1, 1, 1)]
+
+# De Bruijn sequence B(2, 3): every length-3 binary word appears once cyclically
+de_bruijn(alphabet_size=2, length=3)
+# (0, 0, 0, 1, 0, 1, 1, 1)
+
+# Lyndon array: longest Lyndon prefix length at each position
+lyndon_array("banana")   # [1, 2, 1, 2, 1, 1]
+lyndon_array("abcd")     # [4, 3, 2, 1]   (entire increasing suffix is Lyndon)
+lyndon_array("aaaa")     # [1, 1, 1, 1]   (all equal, no run > 1 is Lyndon)
+lyndon_array("0010011")  # [7, 2, 1, 4, 3, 1, 1]
+```
+
+## Word representation
+
+Words over an integer alphabet are represented as `tuple[int, ...]`, for example
+`(0, 0, 1)` for a 3-symbol word over `{0, 1}`. This is the canonical type, and every
+enumeration and generation function (`enumerate_necklaces`, `enumerate_bracelets`,
+`de_bruijn`) yields or returns tuples of ints.
+
+The word predicates `is_lyndon` and `factorize` are generic over any comparable
+`Sequence`, so `str`, `list`, and `tuple` all work. The factors returned by `factorize`
+have the same type as the input: pass a `str` and you get a list of `str` factors, pass a
+`tuple` and you get a list of `tuple` factors. String examples like `"aab"` behave exactly
+like integer tuples because string comparison is lexicographic.
+
+## API
+
+Enumeration and generation functions take keyword-only `alphabet_size` and `length`.
+
+| Function | Description |
+|---|---|
+| `is_lyndon(word)` | True iff `word` is non-empty and strictly smaller than all proper rotations |
+| `factorize(word)` | Duval's O(n) Chen-Fox-Lyndon factorization into non-increasing Lyndon factors |
+| `lyndon_array(word)` | For each index `i`, the length of the longest Lyndon prefix of `word[i:]` |
+| `enumerate_necklaces(*, alphabet_size, length)` | FKM enumeration of rotation classes, lexicographic order |
+| `enumerate_bracelets(*, alphabet_size, length)` | Enumeration of rotation + reflection classes, lexicographic order |
+| `de_bruijn(*, alphabet_size, length)` | De Bruijn sequence B(alphabet_size, length) via FKM |
+
+`alphabet_size >= 1` and `length >= 1` are required; otherwise a `ValueError` is raised.
+
+## Definitions
+
+**Lyndon word.** A non-empty word strictly smaller, in lexicographic order, than every one
+of its proper rotations (equivalently, every proper suffix). Lyndon words are aperiodic.
+
+**Chen-Fox-Lyndon factorization.** Every non-empty word factors uniquely into Lyndon words
+`l_1 >= l_2 >= ... >= l_m`. Duval's algorithm computes this in O(n) time and O(1) extra
+space.
+
+**Necklace.** A rotation-equivalence class of length-`n` words. The representative is the
+lexicographically least rotation. The count is
+`(1/n) * sum over d dividing n of phi(d) * k^(n/d)`.
+
+**Bracelet.** An equivalence class under rotation and reflection (the dihedral group). The
+representative is the lexicographically least element of the orbit.
+
+**Lyndon array.** For a word `s` of length `n`, the Lyndon array is the integer array
+`L` where `L[i]` is the length of the longest Lyndon word that is a prefix of `s[i:]`.
+Every entry satisfies `1 <= L[i] <= n - i`. The first entry `L[0]` equals the length of
+the first (leftmost) factor in the Chen-Fox-Lyndon factorization of `s`: that factor is
+the unique longest Lyndon prefix of the entire word.
+
+**De Bruijn sequence.** A cyclic sequence `B(k, n)` of length `k^n` in which every
+length-`n` word appears exactly once as a contiguous cyclic subword. The FKM construction
+concatenates, in lexicographic order, every Lyndon word whose length divides `n`.
+
+## References
+
+- Duval, J.-P. (1983). Factorizing words over an ordered alphabet. Journal of Algorithms.
+- Chen, K.-T., Fox, R. H., Lyndon, R. C. (1958). Free differential calculus IV. Annals of Mathematics.
+- Fredricksen, H., Maiorana, J. (1978). Necklaces of beads in k colors and k-ary de Bruijn sequences. Discrete Mathematics.
+- Fredricksen, H., Kessler, I. J. (1986). An algorithm for generating necklaces of beads in two colors. Discrete Mathematics.
+- Ruskey, F. (2003). Combinatorial Generation. University of Victoria.
+
+## License
+
+MIT. Copyright (c) 2026 Amaar Chughtai.

lyndon_words-0.2.0/README.md

@@ -0,0 +1,134 @@
+# lyndon-words
+
+<p align="center">
+  <img src="assets/logo.png" alt="lyndon-words logo" width="160">
+</p>
+
+[![CI](https://github.com/amaar-mc/lyndon-words/actions/workflows/ci.yml/badge.svg)](https://github.com/amaar-mc/lyndon-words/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](./LICENSE)
+
+Combinatorics on words in pure Python with zero dependencies: Lyndon-word testing, Duval's
+Chen-Fox-Lyndon factorization, necklace and bracelet enumeration, and De Bruijn sequences.
+
+## What is this?
+
+A **Lyndon word** is a non-empty word that is strictly smaller than all of its rotations.
+Lyndon words are the building blocks of combinatorics on words: every word factors uniquely
+into a non-increasing concatenation of Lyndon words (the Chen-Fox-Lyndon theorem), and
+Lyndon words index the necklaces (rotation classes) and the De Bruijn sequences over an
+alphabet.
+
+This library implements the classic algorithms directly, with no dependencies and strict
+typing.
+
+## Install
+
+```sh
+pip install lyndon-words
+```
+
+> PyPI release pending. Install from source:
+> ```sh
+> git clone https://github.com/amaar-mc/lyndon-words
+> cd lyndon-words
+> pip install -e .
+> ```
+
+## Quick start
+
+```python
+from lyndon_words import is_lyndon, factorize, enumerate_necklaces, enumerate_bracelets, de_bruijn, lyndon_array
+
+# Lyndon-word test (accepts str, list, or tuple)
+is_lyndon("aab")     # True
+is_lyndon("aba")     # False
+is_lyndon((0, 0, 1)) # True
+
+# Duval's Chen-Fox-Lyndon factorization (non-increasing Lyndon factors)
+factorize("banana")  # ['b', 'an', 'an', 'a']
+factorize("aababab") # ['aabab', 'ab']
+
+# Necklaces: rotation-class representatives over {0, 1} of length 3
+list(enumerate_necklaces(alphabet_size=2, length=3))
+# [(0, 0, 0), (0, 0, 1), (0, 1, 1), (1, 1, 1)]
+
+# Bracelets: rotation + reflection classes over {0, 1} of length 4
+list(enumerate_bracelets(alphabet_size=2, length=4))
+# [(0, 0, 0, 0), (0, 0, 0, 1), (0, 0, 1, 1), (0, 1, 0, 1), (0, 1, 1, 1), (1, 1, 1, 1)]
+
+# De Bruijn sequence B(2, 3): every length-3 binary word appears once cyclically
+de_bruijn(alphabet_size=2, length=3)
+# (0, 0, 0, 1, 0, 1, 1, 1)
+
+# Lyndon array: longest Lyndon prefix length at each position
+lyndon_array("banana")   # [1, 2, 1, 2, 1, 1]
+lyndon_array("abcd")     # [4, 3, 2, 1]   (entire increasing suffix is Lyndon)
+lyndon_array("aaaa")     # [1, 1, 1, 1]   (all equal, no run > 1 is Lyndon)
+lyndon_array("0010011")  # [7, 2, 1, 4, 3, 1, 1]
+```
+
+## Word representation
+
+Words over an integer alphabet are represented as `tuple[int, ...]`, for example
+`(0, 0, 1)` for a 3-symbol word over `{0, 1}`. This is the canonical type, and every
+enumeration and generation function (`enumerate_necklaces`, `enumerate_bracelets`,
+`de_bruijn`) yields or returns tuples of ints.
+
+The word predicates `is_lyndon` and `factorize` are generic over any comparable
+`Sequence`, so `str`, `list`, and `tuple` all work. The factors returned by `factorize`
+have the same type as the input: pass a `str` and you get a list of `str` factors, pass a
+`tuple` and you get a list of `tuple` factors. String examples like `"aab"` behave exactly
+like integer tuples because string comparison is lexicographic.
+
+## API
+
+Enumeration and generation functions take keyword-only `alphabet_size` and `length`.
+
+| Function | Description |
+|---|---|
+| `is_lyndon(word)` | True iff `word` is non-empty and strictly smaller than all proper rotations |
+| `factorize(word)` | Duval's O(n) Chen-Fox-Lyndon factorization into non-increasing Lyndon factors |
+| `lyndon_array(word)` | For each index `i`, the length of the longest Lyndon prefix of `word[i:]` |
+| `enumerate_necklaces(*, alphabet_size, length)` | FKM enumeration of rotation classes, lexicographic order |
+| `enumerate_bracelets(*, alphabet_size, length)` | Enumeration of rotation + reflection classes, lexicographic order |
+| `de_bruijn(*, alphabet_size, length)` | De Bruijn sequence B(alphabet_size, length) via FKM |
+
+`alphabet_size >= 1` and `length >= 1` are required; otherwise a `ValueError` is raised.
+
+## Definitions
+
+**Lyndon word.** A non-empty word strictly smaller, in lexicographic order, than every one
+of its proper rotations (equivalently, every proper suffix). Lyndon words are aperiodic.
+
+**Chen-Fox-Lyndon factorization.** Every non-empty word factors uniquely into Lyndon words
+`l_1 >= l_2 >= ... >= l_m`. Duval's algorithm computes this in O(n) time and O(1) extra
+space.
+
+**Necklace.** A rotation-equivalence class of length-`n` words. The representative is the
+lexicographically least rotation. The count is
+`(1/n) * sum over d dividing n of phi(d) * k^(n/d)`.
+
+**Bracelet.** An equivalence class under rotation and reflection (the dihedral group). The
+representative is the lexicographically least element of the orbit.
+
+**Lyndon array.** For a word `s` of length `n`, the Lyndon array is the integer array
+`L` where `L[i]` is the length of the longest Lyndon word that is a prefix of `s[i:]`.
+Every entry satisfies `1 <= L[i] <= n - i`. The first entry `L[0]` equals the length of
+the first (leftmost) factor in the Chen-Fox-Lyndon factorization of `s`: that factor is
+the unique longest Lyndon prefix of the entire word.
+
+**De Bruijn sequence.** A cyclic sequence `B(k, n)` of length `k^n` in which every
+length-`n` word appears exactly once as a contiguous cyclic subword. The FKM construction
+concatenates, in lexicographic order, every Lyndon word whose length divides `n`.
+
+## References
+
+- Duval, J.-P. (1983). Factorizing words over an ordered alphabet. Journal of Algorithms.
+- Chen, K.-T., Fox, R. H., Lyndon, R. C. (1958). Free differential calculus IV. Annals of Mathematics.
+- Fredricksen, H., Maiorana, J. (1978). Necklaces of beads in k colors and k-ary de Bruijn sequences. Discrete Mathematics.
+- Fredricksen, H., Kessler, I. J. (1986). An algorithm for generating necklaces of beads in two colors. Discrete Mathematics.
+- Ruskey, F. (2003). Combinatorial Generation. University of Victoria.
+
+## License
+
+MIT. Copyright (c) 2026 Amaar Chughtai.

lyndon_words-0.2.0/SECURITY.md

@@ -0,0 +1,18 @@
+# Security Policy
+
+## Scope
+
+`lyndon-words` is a pure computation library with no runtime dependencies, no network
+access, and no file system access. The attack surface is limited to incorrect results from
+malformed input, which the library guards against with explicit validation.
+
+## Reporting a vulnerability
+
+If you find a security issue, please email amaar2cool@gmail.com with details and steps to
+reproduce. Please do not open a public issue for security reports. You can expect an
+initial response within a few days.
+
+## Supported versions
+
+The latest published minor version receives fixes. Pre-1.0 releases may introduce breaking
+changes in minor versions, as allowed by semantic versioning.