chromatic-matroids 0.0.1__tar.gz

chromatic_matroids-0.0.1/.gitignore

@@ -0,0 +1 @@
+chromatic_matroids/dist/*

chromatic_matroids-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

chromatic_matroids-0.0.1/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: chromatic_matroids
+Version: 0.0.1
+Summary: A package that exposes some matroid operation and creations
+Project-URL: Homepage, https://github.com/raulpenaguiao/chromatic-matroids/chromatic-matroids
+Project-URL: Issues, https://github.com/raulpenaguiao/chromatic-matroids/chromatic-matroids/issues
+Author: Sophie Rehberg
+Author-email: Raul Penaguiao <raul.penaguiao@proton.me>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Matroid Package
+
+
+This is a simple matroid package that contains constructor functions for basic combinatorial structures like set compositions, complext structures like matroids and algebraic structure like word quasisymmetric functions.
+This builds up for the construction of chromatic invariants on matroids.
+
+This abstracts away all the intricacies of matroid operations in order to compute the chromatic invariants.
+
+
+## Packages
+
+### Compositions
+
+This package implements a construction of compositions:
+
+```
+print("Composition Construction")
+comp1 = Composition([1, 2, 1])
+comp2 = Composition([2, 1])
+print(f"Example 5: Basic compositions: {comp1}, {comp2}")
+print("\n")
+
+print("Composition Operations")
+print(f"Rest of {comp1}: {comp1.rest()}")
+print(f"Prepending 3 to {comp2}: {comp2.prepend(3)}")
+print("\n")
+
+print("Generate All Compositions")
+comps3 = Composition.generate_all_composition(3)
+print(f"All compositions of 3: {comps3}\n")
+print("\n")
+```
+
+
+### Set compositions
+
+This package implements a construction of set compositions.
+For a construction example, run the following:
+
+```
+print("Example 13: SetComposition Operations")
+set_comp1 = SetComposition([[1, 2], [3, 4], [5]])
+set_comp2 = SetComposition([[1], [2, 3]])
+print(f"\nSet Compositions: {set_comp1}, {set_comp2}")
+```
+
+
+### Quasi-symmetric functions
+
+This package implements a construction of quasi-symmetric functions.
+For a construction example, run the following:
+```
+print("Construct QSymFunction from a dictionary of monomial bases")
+qsym_from_dict = QSymFunction(monomial_basis={"(1,2,1)": 2, "(2,1)": -1})
+print("QSymFunction from dictionary:")
+print(f"coefficients: {qsym_from_dict.coefficients}")
+```
+
+### Word quasi-symmetric functions
+
+This package implements a construction of word quasi-symmetric functions.
+For a construction example, run the following:
+```
+print("Construct NCQSymFunctions from a dictionary of monomial bases")
+nc_f = NCQSymFunction(monomial_basis=set_comp1)
+nc_g = NCQSymFunction(monomial_basis=set_comp2)
+nc_sum = nc_f + nc_g
+print("Sum of NCQSymFunctions:")
+print(f"nc_f: {nc_f.coefficients}")
+print(f"nc_g: {nc_g.coefficients}")
+print(f"nc_f + nc_g: {nc_sum.coefficients}")
+```
+
+### Graphs
+This package implements a construction of graphs from edge list.
+
+### Matroids
+
+This package implements a construction of matroids from base list.
+It also implements construction of *Schubert matroids*, *graphical matroids*, *uniform matroids*, and *nested matroids.
+
+
+### Chromatic functions on matroids
+
+This package implements a construction of chromatic invariants on matroids.
+
+
+
+# To do
+
+## Test cases
+
+We are still building up our unit test library
+
+## Efficiency
+
+We are improving the construction of some methods related to computing stability of some set compositions with memorization.

chromatic_matroids-0.0.1/README.md

@@ -0,0 +1,97 @@
+# Matroid Package
+
+
+This is a simple matroid package that contains constructor functions for basic combinatorial structures like set compositions, complext structures like matroids and algebraic structure like word quasisymmetric functions.
+This builds up for the construction of chromatic invariants on matroids.
+
+This abstracts away all the intricacies of matroid operations in order to compute the chromatic invariants.
+
+
+## Packages
+
+### Compositions
+
+This package implements a construction of compositions:
+
+```
+print("Composition Construction")
+comp1 = Composition([1, 2, 1])
+comp2 = Composition([2, 1])
+print(f"Example 5: Basic compositions: {comp1}, {comp2}")
+print("\n")
+
+print("Composition Operations")
+print(f"Rest of {comp1}: {comp1.rest()}")
+print(f"Prepending 3 to {comp2}: {comp2.prepend(3)}")
+print("\n")
+
+print("Generate All Compositions")
+comps3 = Composition.generate_all_composition(3)
+print(f"All compositions of 3: {comps3}\n")
+print("\n")
+```
+
+
+### Set compositions
+
+This package implements a construction of set compositions.
+For a construction example, run the following:
+
+```
+print("Example 13: SetComposition Operations")
+set_comp1 = SetComposition([[1, 2], [3, 4], [5]])
+set_comp2 = SetComposition([[1], [2, 3]])
+print(f"\nSet Compositions: {set_comp1}, {set_comp2}")
+```
+
+
+### Quasi-symmetric functions
+
+This package implements a construction of quasi-symmetric functions.
+For a construction example, run the following:
+```
+print("Construct QSymFunction from a dictionary of monomial bases")
+qsym_from_dict = QSymFunction(monomial_basis={"(1,2,1)": 2, "(2,1)": -1})
+print("QSymFunction from dictionary:")
+print(f"coefficients: {qsym_from_dict.coefficients}")
+```
+
+### Word quasi-symmetric functions
+
+This package implements a construction of word quasi-symmetric functions.
+For a construction example, run the following:
+```
+print("Construct NCQSymFunctions from a dictionary of monomial bases")
+nc_f = NCQSymFunction(monomial_basis=set_comp1)
+nc_g = NCQSymFunction(monomial_basis=set_comp2)
+nc_sum = nc_f + nc_g
+print("Sum of NCQSymFunctions:")
+print(f"nc_f: {nc_f.coefficients}")
+print(f"nc_g: {nc_g.coefficients}")
+print(f"nc_f + nc_g: {nc_sum.coefficients}")
+```
+
+### Graphs
+This package implements a construction of graphs from edge list.
+
+### Matroids
+
+This package implements a construction of matroids from base list.
+It also implements construction of *Schubert matroids*, *graphical matroids*, *uniform matroids*, and *nested matroids.
+
+
+### Chromatic functions on matroids
+
+This package implements a construction of chromatic invariants on matroids.
+
+
+
+# To do
+
+## Test cases
+
+We are still building up our unit test library
+
+## Efficiency
+
+We are improving the construction of some methods related to computing stability of some set compositions with memorization.

chromatic_matroids-0.0.1/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "chromatic_matroids"
+version = "0.0.1"
+authors = [
+  { name="Raul Penaguiao", email="raul.penaguiao@proton.me" },
+  { name="Sophie Rehberg", email="" },
+]
+description = "A package that exposes some matroid operation and creations"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+
+[project.urls]
+Homepage = "https://github.com/raulpenaguiao/chromatic-matroids/chromatic-matroids"
+Issues = "https://github.com/raulpenaguiao/chromatic-matroids/chromatic-matroids/issues"

chromatic_matroids-0.0.1/src/chromatic_matroids/chromatic.py

@@ -0,0 +1,55 @@
+# matroid_chromatic/chromatic.py
+from typing import Dict
+from matroid_chromatic import Matroid
+
+
+
+def compute_chromatic_noncommutative_qsym_function(matroid: Matroid) -> dict:
+    """
+    Compute the non commutative qsym function as a dictionary that matches a 
+    """
+
+
+
+def compute_chromatic_polynomial(matroid: Matroid) -> list:
+    """
+    Compute the chromatic polynomial as a list of coefficients.
+    
+    Args:
+        matroid: The matroid
+    
+    Returns:
+        Value of chromatic polynomial at q
+    """
+    def mobius_function(X: frozenset, Y: frozenset) -> int:
+        """Compute the Möbius function value."""
+        if X == Y:
+            return 1
+        if not X.issubset(Y):
+            return 0
+        
+        result = 0
+        for Z in range_sets[len(X):len(Y)]:
+            if X.issubset(Z) and Z.issubset(Y):
+                result -= mobius_function(X, Z)
+        return result
+    
+    # Generate all sets between empty set and ground set
+    range_sets = []
+    for i in range(len(matroid.ground_set) + 1):
+        current_level = set()
+        for ind_set in matroid.independent_sets():
+            if len(ind_set) == i:
+                current_level.add(ind_set)
+        range_sets.append(current_level)
+    
+    # Compute chromatic polynomial using Möbius inversion
+    result = [0 for _ in range(len(matroid.ground_set) + 1)]
+    empty_set = frozenset()
+    ground_set = frozenset(matroid.ground_set)
+    
+    for X in matroid.independent_sets():
+        coeff = mobius_function(empty_set, X)
+        result[len(X)] += coeff
+    
+    return result

chromatic_matroids-0.0.1/src/chromatic_matroids/chromatic_statistics_matorids.py

@@ -0,0 +1,27 @@
+# matroid_chromatic/chromatic_statistics_matorids.py
+from matroid_chromatic import Matroid
+from matroid_chromatic import SetComposition
+from matroid_chromatic import Composition
+from matroid_chromatic import QSymFunction
+from matroid_chromatic import NCQSymFunction
+from matroid_chromatic import stable_matroids_setcompositions
+
+def chromatic_quasisymmetric_function(matroid: Matroid) -> QSymFunction:
+    """
+    Compute the chromatic quasisymmetric function of a matroid
+    """
+    return NCQSymFunction.comu(chromatic_non_commutative_quasisymmetric_function(matroid))
+
+
+def chromatic_non_commutative_quasisymmetric_function(matroid: Matroid) -> NCQSymFunction:
+    """
+    Compute the chromatic non-commutative quasisymmetric function of a matroid
+    """
+    ground_list = list(matroid.ground_set)
+    relabeling_map = {i+1: ground_list[i] for i in range(len(ground_list))}
+    all_set_compositions = [opi.relabel(relabeling_map) for opi in SetComposition.generate_all_setcompositions(len(ground_list))]
+    coeffs = {str(opi): 1 for opi in all_set_compositions
+                if stable_matroids_setcompositions(matroid, opi)}
+    return NCQSymFunction(monomial_basis=coeffs)
+
+

chromatic_matroids-0.0.1/src/chromatic_matroids/compositions.py

@@ -0,0 +1,229 @@
+# matroid_chromatic/compositions.py
+from typing import Set, List, Tuple
+
+class Composition:
+    """
+    A class representing compositions of integers as an imutable class. This means no methods change self.
+    A composition of n is a way of writing n as a sum of positive integers.
+    For example, [2,1,3] is a composition of 6.
+
+    This class implements quasi-shuffles of compositions
+    """
+    # Class variables for memoization of quasi-shuffle computations
+    _PREGEN = 4
+    _all_generated_compositions_size = 0  # Limit for precomputation
+    _all_generated_compositions_list = [] # Cache for precomputed results
+    _qshuffle_precomputation_dictionary = {}  # Cache for precomputed results
+    
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize a composition of integers
+        
+        Args:
+            *args: Variable length argument list. Can be a list or a tuple of positive integers
+            **kwargs: Arbitrary keyword arguments (reserved for future use)
+            
+        Raises:
+            TypeError: If any argument is not an integer
+            ValueError: If any integer is not positive
+        """
+        # Check if args is a single list/tuple
+        if len(args) == 0:#Composition() = [] the unique composition of 0
+            self.parts = []
+        elif len(args) == 1:
+            if isinstance(args[0], (list, tuple)):
+                self.parts = list(args[0]) # Convert to list to ensure mutability
+            elif isinstance(args[0], str):
+                if args[0] == "()":
+                    self.parts = []#Composition('()') = [] the unique composition of 0
+                else:
+                    try:
+                        self.parts = [int(i) for i in args[0][1:-1].split(",")]#Composition('(2,1,3)') = [2,1,3]
+                    except:
+                        raise Exception(f"Composition input malformed, expected a string of the form '(2,1,3)', got {args[0]}")
+            else:
+                raise Exception("")
+        else:
+            raise Exception("")
+        # Validate all arguments are positive integers
+        for part in self.parts:
+            if not isinstance(part, int):
+                raise TypeError(f"All parts must be integers, got {type(part)}")
+            if part <= 0:
+                raise ValueError(f"All parts must be positive integers, got {part}")
+        
+        self.nparts = len(self.parts)  # Number of parts in the composition
+        self.n = sum(self.parts)  # Total sum of all parts
+    
+    def __str__(self) -> str:
+        """
+        String representation of the composition using | as separator
+        
+        Returns:
+            str: Composition parts joined by '|' character
+        """
+        return "(" + ",".join([str(i) for i in self.parts]) + ")"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __eq__(self, other) -> bool:
+        if not self.n == other.n:
+            return False
+        if not self.nparts == other.nparts:
+            return False
+        for a, b in zip(self.parts, other.parts):
+            if not a == b:
+                return False
+        return True
+
+    def rest(self) -> 'Composition':
+        """
+        Returns a new Composition object containing all but the first part
+        of this composition.
+        
+        Returns:
+            Composition: A new composition without the first part
+        """
+        if len(self.parts) == 0:
+            raise Exception("Empty composition cannot be rest-ed")
+        return Composition(self.parts[1:])
+        
+    def prepend(self, a: int) -> 'Composition':
+        """
+        Computes a new composition with a prepend element
+        Does not change self
+
+        Args:
+            self (Composition): a composition
+            a (int): term to prepend
+        
+        Returns:
+            Composition: A new composition with a prepend element
+        """
+        return Composition([a] + self.parts)
+
+    @staticmethod
+    def generate_all_composition(n: int) -> list['Composition']:
+        """
+        Computes all compositions of a given size iteratively with memoization
+        
+        Args:
+            n (int): The positive integer to generate compositions for
+        
+        Returns:
+            list: A list of all compositions of n, ordered lexicographically
+                 For example, generate_all_composition(3) returns:
+                 [[3], [2,1], [1,2], [1,1,1]]
+        
+        Note:
+            Uses memoization to avoid recomputing previously generated compositions.
+            Results are stored in _all_generated_compositions_list for future use.
+        """
+        # Check if these compositions were already generated
+        if n < Composition._all_generated_compositions_size:
+            if n < 0:
+                return []  # No compositions for negative numbers
+            return Composition._all_generated_compositions_list[n]
+        
+        # Start with the trivial composition [n]
+        answer = [Composition([n])]
+
+        # Generate all compositions by breaking off initial parts
+        for k in range(1, n):
+            # For each k from 1 to n-1:
+            # Take each composition of k and prepend (n-k) to it
+            # This systematically generates all possible compositions
+            smaller_compositions = Composition.generate_all_composition(k)
+            for alpha in smaller_compositions:
+                answer.append(alpha.prepend(n-k))
+        
+        # Update the memoization cache
+        Composition._all_generated_compositions_size = n + 1
+        Composition._all_generated_compositions_list += [answer]
+        return answer
+
+    @staticmethod
+    def quasi_shuffles(q: 'Composition', t: 'Composition') -> dict[str:int]:
+        """
+        Compute all possible quasi-shuffles of two compositions.
+        A quasi-shuffle combines two compositions allowing both interleaving and addition 
+        of corresponding terms.
+        
+        For example, quasi-shuffling [1,2] and [3,1] could give:
+        - [1,3,2,1] (interleaving)
+        - [4,2,1] (adding first terms)
+        - [1,5,1] (adding first and second terms)
+        And other combinations...
+        
+        Args:
+            q (Composition): First composition
+            t (Composition): Second composition
+            
+        Returns:
+            dict: Dictionary mapping resulting compositions to their coefficients.
+                 The coefficients track how many ways that composition can be formed.
+        
+        Note:
+            Uses the recursive formula:
+            qs(a·q, b·t) = a·qs(q, bt) + b·qs(aq, t) + (a+b)·qs(q, t)
+            where a·q means composition q with 'a' prepended
+        """
+        # Check memoization cache
+        if str(q) in Composition._qshuffle_precomputation_dictionary:
+            if str(t) in Composition._qshuffle_precomputation_dictionary[str(q)]:
+                return Composition._qshuffle_precomputation_dictionary[str(q)][str(t)]
+        
+        # Base cases: if either composition is empty, return the other
+        if q.n == 0:
+            return {str(t): 1}
+        if t.n == 0:
+            return {str(q): 1}
+
+        # Get the first terms and rest of each composition
+        a = q.parts[0]
+        b = t.parts[0]
+        qrest = q.rest()
+        trest = t.rest()
+
+        answer = {}
+        
+        # Case 1: Take 'a' from first composition > a·qs(q, bt) 
+        qsh1 = Composition.quasi_shuffles(qrest, t)
+        for alphas in qsh1:
+            newqs = str(Composition(alphas).prepend(a))
+            if not(newqs in answer):
+                answer[newqs] = 0
+            answer[newqs] += qsh1[alphas]
+        
+        # Case 2: Take 'b' from second composition > + b·qs(aq, t)
+        qsh2 = Composition.quasi_shuffles(q, trest)
+        for alphas in qsh2:
+            newqs = str(Composition(alphas).prepend(b))
+            if not(newqs in answer):
+                answer[newqs] = 0
+            answer[newqs] += qsh2[alphas]
+        
+        # Case 3: Take both first terms and add them together > (a+b)·qs(q, t)
+        qsh3 = Composition.quasi_shuffles(qrest, trest)
+        for alphas in qsh3:
+            newqs = str(Composition(alphas).prepend(a + b))
+            if not(newqs in answer):
+                answer[newqs] = 0
+            answer[newqs] += qsh3[alphas]
+
+        
+        if not str(q) in Composition._qshuffle_precomputation_dictionary:
+            Composition._qshuffle_precomputation_dictionary[str(q)] = {}
+        Composition._qshuffle_precomputation_dictionary[str(q)][str(t)] = answer
+        return answer
+
+
+Composition._all_generated_compositions_list = [[Composition()]]
+# Pregenerate all compositions and qshuffles up to size PREGEN
+Composition.generate_all_composition(Composition._PREGEN)
+for comp_list1 in Composition._all_generated_compositions_list:
+    for comp1 in comp_list1:        
+        for comp_list2 in Composition._all_generated_compositions_list:
+            for comp2 in comp_list2:
+                Composition.quasi_shuffles(comp1, comp2)