latin-rectangles 0.1.0__py3-none-any.whl

latin_rectangles/__init__.py

@@ -0,0 +1,40 @@
+"""Latin rectangles extension counting algorithms."""
+
+from .derangements import find_cycle_decomposition, generate_random_derangement
+from .extension_counting import count_extensions
+
+
+def count_random_extensions(n: int) -> int:
+    """
+    Generate a random derangement of size n and count its extensions.
+
+    This is a convenience function that combines random derangement generation
+    with extension counting in a single call.
+
+    Args:
+        n: Size of the derangement (must be > 1)
+
+    Returns:
+        Number of extensions for the randomly generated derangement
+
+    Raises:
+        ValueError: If n <= 1 (no derangements exist)
+
+    Example:
+        >>> extensions = count_random_extensions(10)
+        >>> print(f"Random derangement for n=10 has {extensions} extensions")
+    """
+    if n <= 1:
+        raise ValueError("n must be greater than 1 for derangements to exist")
+
+    random_derangement = generate_random_derangement(n)
+    return count_extensions(random_derangement)
+
+
+# Export the main functions
+__all__ = [
+    "count_extensions",
+    "count_random_extensions",
+    "find_cycle_decomposition",
+    "generate_random_derangement",
+]

latin_rectangles/__main__.py

@@ -0,0 +1,186 @@
+"""Entry point for running the latin_rectangles package as a script."""
+
+import argparse
+import sys
+
+from .derangements import find_cycle_decomposition, generate_random_derangement, create_cycle_structure
+from .extension_counting import count_extensions
+
+
+def count_random_extensions(n: int) -> tuple[int, list[int], int]:
+    """
+    Generate a random derangement and count its extensions.
+
+    Args:
+        n: Size of the derangement
+
+    Returns:
+        Tuple of (n, cycle_lengths, extensions_count)
+    """
+    if n <= 1:
+        raise ValueError("n must be greater than 1 for derangements to exist")
+
+    random_p = generate_random_derangement(n)
+    random_cycles = find_cycle_decomposition(random_p)
+    cycle_lengths = sorted([len(c) for c in random_cycles])
+    extensions = count_extensions(random_p)
+
+    return n, cycle_lengths, extensions
+
+
+def count_cycle_structure_extensions(cycle_structure: str) -> tuple[int, list[int], int]:
+    """
+    Create a derangement with specific cycle structure and count its extensions.
+
+    Args:
+        cycle_structure: Comma-separated cycle lengths (e.g., "2,2,4")
+
+    Returns:
+        Tuple of (n, cycle_lengths, extensions_count)
+    """
+    try:
+        cycle_lengths = [int(x.strip()) for x in cycle_structure.split(",")]
+    except ValueError:
+        raise ValueError("Cycle structure must be comma-separated integers")
+    
+    if not cycle_lengths:
+        raise ValueError("Cycle structure cannot be empty")
+    
+    n = sum(cycle_lengths)
+    if n <= 1:
+        raise ValueError("Total size must be greater than 1")
+    
+    p = create_cycle_structure(cycle_lengths)
+    extensions = count_extensions(p)
+    
+    return n, sorted(cycle_lengths), extensions
+
+
+def generate_all_cycle_structures(n: int) -> list[list[int]]:
+    """
+    Generate all valid cycle structures (partitions) for a derangement of size n.
+    Only includes partitions where all parts are ≥ 2 (no 1-cycles).
+
+    Args:
+        n: Size of the derangement
+
+    Returns:
+        List of cycle structures, each as a sorted list of cycle lengths
+    """
+    def partitions_with_min_part(target: int, min_part: int, current: list[int]) -> list[list[int]]:
+        """Generate partitions of target where all parts are >= min_part."""
+        if target == 0:
+            return [current[:]]
+
+        if target < min_part:
+            return []
+
+        result = []
+        for part_size in range(min_part, target + 1):
+            current.append(part_size)
+            result.extend(partitions_with_min_part(target - part_size, part_size, current))
+            current.pop()
+
+        return result
+
+    if n <= 1:
+        return []
+
+    # Generate all partitions where each part is at least 2
+    partitions = partitions_with_min_part(n, 2, [])
+
+    # Sort each partition for consistent output
+    return [sorted(partition) for partition in partitions]
+
+
+def enumerate_all_extensions(n: int) -> list[tuple[list[int], int]]:
+    """
+    Enumerate all possible cycle structures for n and count their extensions.
+
+    Args:
+        n: Size of the derangement
+
+    Returns:
+        List of tuples (cycle_structure, extensions_count) sorted by extensions_count
+    """
+    structures = generate_all_cycle_structures(n)
+    results = []
+
+    for cycle_lengths in structures:
+        p = create_cycle_structure(cycle_lengths)
+        extensions = count_extensions(p)
+        results.append((cycle_lengths, extensions))
+
+    # Sort by extensions count (descending), then by cycle structure
+    results.sort(key=lambda x: (-x[1], x[0]))
+    return results
+
+
+def main() -> None:
+    """Main function with command-line interface for Latin rectangle extension counting."""
+    parser = argparse.ArgumentParser(
+        description="Latin Rectangles Extension Counter",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s --n 42             # Generate random derangement for n=42
+  %(prog)s --c "2,2,4"        # Use specific cycle structure: two 2-cycles and one 4-cycle
+  %(prog)s --c "8"            # Single 8-cycle
+  %(prog)s --c "2,2,2,2"      # Four 2-cycles
+  %(prog)s --n 8 --all        # Enumerate all possible cycle structures for n=8
+        """,
+    )
+    # Add --n option for backward compatibility
+    parser.add_argument("--n", type=int, help="Size of the derangement (must be > 1)")
+    parser.add_argument("--c", type=str, help="Cycle structure as comma-separated integers (e.g., '2,2,4' for two 2-cycles and one 4-cycle)")
+    parser.add_argument("--all", action="store_true", help="Enumerate all possible cycle structures for given n (use with --n)")
+
+    args = parser.parse_args()
+
+    if args.n and args.c:
+        print("❌ Error: Cannot specify both --n and --c arguments", file=sys.stderr)
+        sys.exit(1)
+
+    if args.c and args.all:
+        print("❌ Error: Cannot use --all with --c (use --all with --n)", file=sys.stderr)
+        sys.exit(1)
+
+    if not args.n and not args.c:
+        parser.print_help()
+        sys.exit(1)
+
+    try:
+        if args.n and args.all:
+            # Enumerate all cycle structures mode
+            results = enumerate_all_extensions(args.n)
+            if not results:
+                print(f"❌ No valid cycle structures found for n={args.n}")
+                sys.exit(1)
+
+            print(f"🔍 All Cycle Structures for n={args.n}")
+            print(f"📊 Found {len(results)} possible structures with non-zero extensions:")
+            print()
+
+            for i, (cycle_structure, extensions) in enumerate(results, 1):
+                if extensions > 0:  # Only show structures with non-zero extensions
+                    print(f"{i:2d}. {cycle_structure} → {extensions:,} extensions")
+
+        elif args.n:
+            # Generate random derangement mode
+            n_val, cycle_lengths, extensions = count_random_extensions(args.n)
+            print(f"🎲 Generated Random Derangement for n={n_val}")
+            print(f"📊 Cycle structure: {cycle_lengths}")
+            print(f"🔢 Number of extensions: {extensions:,}")
+        elif args.c:
+            # Specific cycle structure mode
+            n_val, cycle_lengths, extensions = count_cycle_structure_extensions(args.c)
+            print(f"⚙️  Specific Cycle Structure for n={n_val}")
+            print(f"📊 Cycle structure: {cycle_lengths}")
+            print(f"🔢 Number of extensions: {extensions:,}")
+    except ValueError as e:
+        print(f"❌ Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

latin_rectangles/derangements.py

@@ -0,0 +1,107 @@
+"""Functions for generating and working with derangements."""
+
+import random
+
+
+def generate_random_derangement(n: int) -> list[int]:
+    """
+    Quickly generates a random derangement of length n.
+    A derangement is a permutation p of {1, ..., n} such that p[i] != i.
+
+    Args:
+        n: The size of the derangement.
+
+    Returns:
+        A list of length n+1 representing the derangement (1-indexed).
+
+    Raises:
+        ValueError: If n=1 (no derangements exist) or n < 0.
+    """
+    if n == 1:
+        raise ValueError("No derangements exist for n=1.")
+    if n < 0:
+        raise ValueError("n must be non-negative.")
+    if n == 0:
+        return [0]
+
+    while True:
+        # Create a list of numbers from 1 to n
+        p = list(range(1, n + 1))
+        # Shuffle the list to get a random permutation
+        random.shuffle(p)
+
+        # Check if it's a derangement (p[i] != i+1 for 0-indexed list)
+        is_derangement = True
+        for i in range(n):
+            if p[i] == i + 1:
+                is_derangement = False
+                break
+
+        if is_derangement:
+            # Prepend a 0 for 1-based indexing and return
+            return [0, *p]
+
+
+def find_cycle_decomposition(p: list[int]) -> list[list[int]]:
+    """
+    Finds the cycle decomposition of a permutation.
+    Permutation p is 1-indexed, so p[0] is ignored.
+
+    Args:
+        p: 1-indexed permutation where p[0] is ignored.
+
+    Returns:
+        List of cycles, where each cycle is represented as a list of indices.
+    """
+    n = len(p) - 1
+    visited = [False] * (n + 1)
+    cycles = []
+    for i in range(1, n + 1):
+        if not visited[i]:
+            current_cycle = []
+            j = i
+            while not visited[j]:
+                visited[j] = True
+                current_cycle.append(j)
+                j = p[j]
+            cycles.append(current_cycle)
+    return cycles
+
+
+def create_cycle_structure(cycle_lengths: list[int]) -> list[int]:
+    """
+    Create a derangement with a specific cycle structure.
+
+    Args:
+        cycle_lengths: List of desired cycle lengths
+
+    Returns:
+        1-indexed permutation with the specified cycle structure
+
+    Raises:
+        ValueError: If cycle_lengths contains a 1-cycle (would create fixed point)
+    """
+    if 1 in cycle_lengths:
+        raise ValueError("Cycle structure cannot contain 1-cycles (would create fixed points)")
+    
+    n = sum(cycle_lengths)
+    if n == 0:
+        return [0]
+    
+    perm = [0] * (n + 1)  # 1-indexed with 0 at start
+    current_pos = 1
+
+    for cycle_len in cycle_lengths:
+        # Get positions for this cycle
+        cycle_positions = list(range(current_pos, current_pos + cycle_len))
+        
+        # Create the cycle: each position points to the next, last points to first
+        for i in range(cycle_len):
+            perm[cycle_positions[i]] = cycle_positions[(i + 1) % cycle_len]
+        
+        current_pos += cycle_len
+
+    return perm
+
+
+__all__ = ["find_cycle_decomposition", "generate_random_derangement", "create_cycle_structure"]

latin_rectangles/extension_counting.py

@@ -0,0 +1,49 @@
+"""Main extension counting algorithm for Latin rectangles."""
+
+import math
+
+from .derangements import find_cycle_decomposition
+from .rook_polynomials import get_rook_polynomial_for_cycle, multiply_polynomials
+
+
+def count_extensions(permutation: list[int]) -> int:
+    """
+    Calculates the number of ways to extend a 2xn Latin rectangle to a 3xn one.
+    This is the most robust and general implementation.
+
+    Args:
+        permutation: A list representing the second row, assuming the first row is
+                     (1, 2, ..., n). The list should be 1-indexed, so its
+                     length is n+1 and permutation[0] can be a dummy value.
+                     It must be a derangement.
+
+    Returns:
+        The integer number of possible third rows.
+
+    Raises:
+        ValueError: If the input permutation is not a derangement.
+    """
+    n = len(permutation) - 1
+    if any(i == val for i, val in enumerate(permutation[1:], 1)):
+        raise ValueError("Input permutation must be a derangement (p(i) != i).")
+
+    # 1. Find the cycle decomposition of the permutation
+    cycles = find_cycle_decomposition(permutation)
+
+    # 2. Get the total rook polynomial by multiplying the polynomials of the sub-problems
+    total_rook_poly = [1]  # Start with the polynomial "1"
+    for cycle in cycles:
+        k = len(cycle)
+        cycle_rook_poly = get_rook_polynomial_for_cycle(k)
+        total_rook_poly = multiply_polynomials(total_rook_poly, cycle_rook_poly)
+
+    # 3. Apply the Principle of Inclusion-Exclusion to get the final count.
+    total_ways = 0
+    for k, h_k in enumerate(total_rook_poly):
+        term = ((-1) ** k) * h_k * math.factorial(n - k)
+        total_ways += term
+
+    return total_ways
+
+
+__all__ = ["count_extensions"]

latin_rectangles/rook_polynomials.py

@@ -0,0 +1,71 @@
+"""Rook polynomial calculations for Latin rectangles."""
+
+import math
+
+# Memoization cache for rook polynomials to avoid re-computation
+_ROOK_POLY_CACHE: dict[int, list[int]] = {}
+
+
+def get_rook_polynomial_for_cycle(k: int) -> list[int]:
+    """
+    Calculates the rook polynomial for the forbidden board of a k-cycle.
+    The formula for the j-th coefficient is taken from the Menage problem:
+    r_j(k) = (2k / (2k - j)) * C(2k - j, j)
+    where C is the binomial coefficient "n-choose-k".
+
+    Args:
+        k: The cycle length.
+
+    Returns:
+        List of coefficients for the rook polynomial.
+    """
+    if k in _ROOK_POLY_CACHE:
+        return _ROOK_POLY_CACHE[k]
+
+    # The rook polynomial has degree k, so it has k+1 coefficients.
+    coeffs = [0] * (k + 1)
+
+    # r_0 is always 1
+    coeffs[0] = 1
+
+    for j in range(1, k + 1):
+        # This handles the case j=2k, where the denominator would be zero.
+        # In that situation, the binomial coefficient C(0, 2k) is 0 anyway.
+        if (2 * k - j) < j:
+            # C(n, k) is 0 if k > n
+            coeffs[j] = 0
+            continue
+
+        numerator = 2 * k
+        denominator = 2 * k - j
+
+        # We use integer division `//` as the result is always an integer.
+        # This keeps calculations exact and avoids floating point issues.
+        term1 = (numerator * math.comb(denominator, j)) // denominator
+        coeffs[j] = term1
+
+    _ROOK_POLY_CACHE[k] = coeffs
+    return coeffs
+
+
+def multiply_polynomials(poly1: list[int], poly2: list[int]) -> list[int]:
+    """
+    Multiplies two polynomials given as lists of coefficients.
+
+    Args:
+        poly1: First polynomial as list of coefficients.
+        poly2: Second polynomial as list of coefficients.
+
+    Returns:
+        Product polynomial as list of coefficients.
+    """
+    len1, len2 = len(poly1), len(poly2)
+    new_len = len1 + len2 - 1
+    result_poly = [0] * new_len
+    for i in range(len1):
+        for j in range(len2):
+            result_poly[i + j] += poly1[i] * poly2[j]
+    return result_poly
+
+
+__all__ = ["get_rook_polynomial_for_cycle", "multiply_polynomials"]

latin_rectangles-0.1.0.dist-info/METADATA

@@ -0,0 +1,290 @@
+Metadata-Version: 2.4
+Name: latin-rectangles
+Version: 0.1.0
+Summary: Count the number of one-row extensions of Latin rectangles.
+Author-email: Ioannis Michaloliakos <ioannis.michalol@ufl.edu>
+License-File: LICENSE
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# Latin Rectangles Extension Counter
+
+A high-performance Python library for counting the number of ways to extend a 2×n [Latin rectangle](https://en.wikipedia.org/wiki/Latin_rectangle) to a 3×n Latin rectangle using rook polynomial methods and cycle decomposition theory.
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+## Overview
+
+A **Latin rectangle** is an r×n array filled with n different symbols such that each symbol occurs exactly once in each row and at most once in each column.
+
+### Extension Problem
+
+Given a 2×n Latin rectangle:
+
+```text
+1  2  3  4  5  6  7  8
+p[1]  p[2]  p[3]  p[4]  p[5]  p[6]  p[7]  p[8]
+```
+
+where `p` is a [derangement](https://en.wikipedia.org/wiki/Derangement), the problem is to count how many valid third rows can be added such that the resulting 3×n rectangle remains a Latin rectangle. This library provides an efficient algorithm for computing Latin rectangle extensions.
+
+### Key Features
+
+- **High Performance**: Approximate O(n^2) time complexity, tested **up to n=800**.
+- **Memory Efficient**: Approximate O(n^1.36) memory complexity
+- **Mathematically Rigorous**: Based on rook polynomial theory and cycle decomposition
+- **Easy to Use**: Simple command-line interface and Python API
+- **Well Tested**: Comprehensive test suite with complexity analysis
+
+## Installation
+
+```console
+git clone https://github.com/ionmich/latin-rectangles.git
+cd latin-rectangles
+```
+
+## Quick Start
+
+### Command Line (CLI) Usage
+
+Generate random derangement:
+
+```console
+> uv run python -m latin_rectangles --n 42
+🎲 Generated Random Derangement for n=42
+📊 Cycle structure: [2, 2, 4, 8, 26]
+🔢 Number of extensions: 185,566,788,772,996,286,199,647,931,971,186,844,003,087,641,029,824
+```
+
+Use specific cycle structure:
+
+```console
+> uv run python -m latin_rectangles --c "2,2,4"
+⚙️  Specific Cycle Structure for n=8
+📊 Cycle structure: [2, 2, 4]
+🔢 Number of extensions: 4,744
+```
+
+Enumerate all possible cycle structures:
+
+```console
+> uv run python -m latin_rectangles --n 8 --all
+🔍 All Cycle Structures for n=8
+📊 Found 7 possible structures with non-zero extensions:
+
+ 1. [2, 2, 2, 2] → 4,752 extensions
+ 2. [2, 2, 4] → 4,744 extensions
+ 3. [2, 3, 3] → 4,740 extensions
+ 4. [2, 6] → 4,740 extensions
+ 5. [4, 4] → 4,740 extensions
+ 6. [3, 5] → 4,738 extensions
+ 7. [8] → 4,738 extensions
+```
+
+## Get help
+
+```console
+uv run latin-rectangles --help
+```
+
+## Python Library Usage
+
+```python
+from latin_rectangles import count_extensions, count_random_extensions
+from latin_rectangles import generate_random_derangement
+
+# Method 1: One-liner for random derangement
+extensions = count_random_extensions(n=12)
+print(f"Extensions: {extensions:,}")
+
+# Method 2: Step-by-step with custom derangement
+derangement = generate_random_derangement(n=10)
+extensions = count_extensions(derangement)
+print(f"Derangement {derangement[1:]} has {extensions:,} extensions")
+
+# Method 3: With predefined derangement (1-indexed with dummy 0)
+p = [0, 2, 3, 4, 5, 6, 7, 8, 1]  # 8-cycle for n=8
+extensions = count_extensions(p)
+print(f"8-cycle has {extensions:,} extensions")  # Output: 4,738
+```
+
+## Algorithm Details
+
+### Mathematical Foundation
+
+The algorithm leverages **rook polynomial theory** to solve the Latin rectangle extension problem:
+
+1. **Input**: A derangement (permutation with no fixed points) representing the second row
+2. **Cycle Decomposition**: Decompose the derangement into disjoint cycles
+3. **Rook Polynomials**: Compute rook polynomial for each cycle structure
+4. **Polynomial Multiplication**: Combine rook polynomials to get the final count
+
+## API Reference
+
+### Core Functions
+
+#### `count_extensions(permutation: list[int]) -> int`
+
+Counts the number of extensions for a given derangement.
+
+**Parameters:**
+
+- `permutation`: 1-indexed list representing a derangement (p[0] is dummy value)
+
+**Returns:** Integer number of possible third rows
+
+**Raises:** `ValueError` if input is not a derangement
+
+#### `count_random_extensions(n: int) -> int`
+
+Convenience function that generates a random derangement and counts its extensions.
+
+**Parameters:**
+
+- `n`: Size of the derangement (must be > 1)
+
+**Returns:** Number of extensions for the randomly generated derangement
+
+#### `generate_random_derangement(n: int) -> list[int]`
+
+Generates a random derangement of size n.
+
+**Parameters:**
+
+- `n`: Size of the derangement
+
+**Returns:** 1-indexed list representing the derangement
+
+#### `find_cycle_decomposition(permutation: list[int]) -> list[list[int]]`
+
+Finds the cycle decomposition of a permutation.
+
+**Parameters:**
+
+- `permutation`: 1-indexed permutation
+
+**Returns:** List of cycles (each cycle is a list of indices)
+
+## Examples
+
+### Basic Usage Examples
+
+```python
+from latin_rectangles import count_extensions
+
+# Example 1: Single 8-cycle
+p_8_cycle = [0, 2, 3, 4, 5, 6, 7, 8, 1]
+print(f"8-cycle: {count_extensions(p_8_cycle):,} extensions")
+# Output: 8-cycle: 4,738 extensions
+
+# Example 2: Two 4-cycles  
+p_4_4 = [0, 2, 3, 4, 1, 6, 7, 8, 5]
+print(f"4,4-cycles: {count_extensions(p_4_4):,} extensions")
+# Output: 4,4-cycles: 4,740 extensions
+
+# Example 3: Four 2-cycles
+p_2_2_2_2 = [0, 2, 1, 4, 3, 6, 5, 8, 7]
+print(f"2,2,2,2-cycles: {count_extensions(p_2_2_2_2):,} extensions")
+# Output: 2,2,2,2-cycles: 4,752 extensions
+```
+
+### Advanced Usage
+
+```python
+from latin_rectangles import generate_random_derangement, find_cycle_decomposition, count_extensions
+
+# Generate and analyze a random derangement
+n = 15
+derangement = generate_random_derangement(n)
+cycles = find_cycle_decomposition(derangement)
+cycle_lengths = sorted([len(c) for c in cycles])
+extensions = count_extensions(derangement)
+
+print(f"n={n}")
+print(f"Derangement: {derangement[1:]}")
+print(f"Cycle structure: {cycle_lengths}")
+print(f"Extensions: {extensions:,}")
+```
+
+### Batch Processing
+
+```python
+from latin_rectangles import count_random_extensions
+
+# Process multiple sizes
+results = []
+for n in range(5, 21):
+    extensions = count_random_extensions(n)
+    results.append((n, extensions))
+    print(f"n={n:2d}: {extensions:,} extensions")
+
+# Find the size with the most extensions in this batch
+max_n, max_extensions = max(results, key=lambda x: x[1])
+print(f"Maximum: n={max_n} with {max_extensions:,} extensions")
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Run the test suite
+uv run pytest
+
+# Run with coverage
+uv run pytest --cov=latin_rectangles
+
+# Run specific test
+uv run pytest tests/test_main.py -v
+```
+
+### Code Quality
+
+```bash
+# Type checking
+uv run mypy src/
+
+# Linting
+uv run ruff check src/
+
+# Formatting
+uv run ruff format src/
+```
+
+### Benchmarking
+
+```bash
+# Run performance benchmarks
+uv run python benchmark.py
+
+# Analyze complexity
+uv run python complexity_analysis.py
+```
+
+## Contributing
+
+Contributions are welcome! Please see [DEVELOPMENT.md](DEVELOPMENT.md) for development guidelines.
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass
+5. Submit a pull request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Citation
+
+If you use this library in your research, please cite:
+
+```bibtex
+@software{latin_rectangles,
+  title={Latin Rectangles Extension Counter},
+  author={Ioannis Michaloliakos},
+  year={2025},
+  url={https://github.com/ionmich/latin-rectangles}
+}
+```

latin_rectangles-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+latin_rectangles/__init__.py,sha256=1JsPv1Ts57JLS9jBzlddwJlez5Lu_AMZXTs9hHcc_jU,1161
+latin_rectangles/__main__.py,sha256=uudTFbM8QL7i8RELhIAdZSraEF6YrPLWXrG_tK358eQ,6554
+latin_rectangles/derangements.py,sha256=psrC9BffezFnUrc4ls4JDiN8BgmiM_WGKGSfP0tUjA4,3045
+latin_rectangles/extension_counting.py,sha256=aC8Wi3g6AH0w1Guzw3QD1ZV_ZzohxLbefqaOJ3LLDW4,1757
+latin_rectangles/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+latin_rectangles/rook_polynomials.py,sha256=8cCzYevAAhypnAmYgsgDHZtypgYvcWa6f8lMe8hmcPg,2114
+latin_rectangles-0.1.0.dist-info/METADATA,sha256=ur7BUyMCtOTK3fqKw29vdMt63hFrgo7ymP4NM_WU7xA,7798
+latin_rectangles-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+latin_rectangles-0.1.0.dist-info/entry_points.txt,sha256=Y9TXJJPwmtEtDKSTeClqgM-6bYFsviRreYL-R30UUWE,68
+latin_rectangles-0.1.0.dist-info/licenses/LICENSE,sha256=B7vY06ZLK_DfSNp5Pzqi4h5NAPAVzPI8T58yMNr9VDE,1078
+latin_rectangles-0.1.0.dist-info/RECORD,,

latin_rectangles-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

latin_rectangles-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+latin-rectangles = latin_rectangles.__main__:main

latin_rectangles-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ioannis Michaloliakos
+
+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.