FiniteCategories 0.6.2.0 → 0.6.3.0

raw patch · 4 files changed

+76/−3 lines, 4 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

+ Math.Categories.ConeCategory: completeCocone :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cocone c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c2 m2 o2

+ Math.Categories.ConeCategory: completeCone :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cone c1 m1 o1 c2 m2 o2 -> Cone c1 m1 o1 c2 m2 o2

+ Math.Categories.ConeCategory: postcomposeCoconeWithMorphism :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cocone c1 m1 o1 c2 m2 o2 -> m2 -> Cocone c1 m1 o1 c2 m2 o2

+ Math.Categories.ConeCategory: postcomposeConeWithFunctor :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Category c2 m2 o2, Morphism m2 o2, Eq c2, Eq m2, Eq o2, Morphism m3 o3) => Cone c1 m1 o1 c2 m2 o2 -> Diagram c2 m2 o2 c3 m3 o3 -> Cone c1 m1 o1 c3 m3 o3

+ Math.Categories.ConeCategory: precomposeCoconeWithFunctor :: (Category c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, FiniteCategory c2 m2 o2, Morphism m2 o2, Eq c2, Eq m2, Eq o2, Morphism m3 o3, Eq c3, Eq m3, Eq o3) => Cocone c2 m2 o2 c3 m3 o3 -> Diagram c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c3 m3 o3

+ Math.Categories.ConeCategory: precomposeConeWithMorphism :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cone c1 m1 o1 c2 m2 o2 -> m2 -> Cone c1 m1 o1 c2 m2 o2

+ Math.Categories.FunctorCategory: indexingCategory :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => NaturalTransformation c1 m1 o1 c2 m2 o2 -> c1

Files

CHANGELOG.md +5/−1
FiniteCategories.cabal +1/−1
src/Math/Categories/ConeCategory.hs +65/−1
src/Math/Categories/FunctorCategory.hs +5/−0

CHANGELOG.md view

@@ -46,4 +46,8 @@ 
 ## 0.6.2.0 -- 2024-01-24
 
-* Add mapOnObjects2 and mapOnArrows2+* Add mapOnObjects2 and mapOnArrows2
+
+## 0.6.3.0 -- 2024-02-05
+
+* Add helpers for cones and cocones

FiniteCategories.cabal view

@@ -14,7 +14,7 @@ -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             0.6.2.0
+version:             0.6.3.0
 
 -- A short (one-line) description of the package.
 synopsis: Finite categories and usual categorical constructions on them.

src/Math/Categories/ConeCategory.hs view

@@ -19,12 +19,15 @@     -- ** Cone construcion
     cone,
     unsafeCone,
+    completeCone,
     -- ** Helper functions
     apex,
     baseCone,
     legsCone,
     universeCategoryCone,
     indexingCategoryCone,
+    precomposeConeWithMorphism,
+    postcomposeConeWithFunctor,
     topInjectionsCone,
     -- * Cone Morphism
     ConeMorphism,
@@ -40,12 +43,15 @@     -- ** Cocone construction
     cocone,
     unsafeCocone,
+    completeCocone,
     -- ** Helper functions
     nadir,
     baseCocone,
     legsCocone,
     universeCategoryCocone,
     indexingCategoryCocone,
+    precomposeCoconeWithFunctor,
+    postcomposeCoconeWithMorphism,
     bottomInjectionsCocone,
     -- * Cocone Morphism
     CoconeMorphism,
@@ -99,9 +105,26 @@             result = unsafeCommaObject apex One nat
             
     -- | Constructs a 'Cone' from an apex and a 'NaturalTransformation'. Does NOT check if the source of the 'NaturalTransformation' is a constant diagram on the apex. You may use this function at your own risk, consider using 'cone' if you are not sure.
+    --
+    -- If you give an incomplete natural transformation to this function, you can use 'completeCone' to complete the natural transformation.
     unsafeCone :: o2 -> NaturalTransformation c1 m1 o1 c2 m2 o2 -> Cone c1 m1 o1 c2 m2 o2
     unsafeCone apex nat = unsafeCommaObject apex One nat
     
+    -- | Given a cone with a partial underlying natural transformation, tries to complete it. You can use 'checkNaturalTransformation.legsCone' to check that the cone was correctly completed. 
+    completeCone :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cone c1 m1 o1 c2 m2 o2 -> Cone c1 m1 o1 c2 m2 o2
+    completeCone c = unsafeCommaObject (apex c) One newNat
+        where
+            nat = legsCone c
+            prevComp = components nat
+            validArrowOnTop x = [f | f <- arTo (indexingCategory nat) x, (source f) `Set.isIn` (keys' prevComp)]
+            comp x
+                | not $ null $ prevComp |?| x = prevComp |?| x
+                | not $ Set.null $ validArrowOnTop x = Just $ ((target nat) ->£ (anElement $ validArrowOnTop x)) @ (prevComp |!| (source (anElement $ validArrowOnTop x)))
+                | otherwise = Nothing
+            newComp = weakMapFromSet $ Set.catMaybes [sequence (x,comp x) | x <- ob (indexingCategory nat)]
+            newNat = unsafeNaturalTransformation (source nat) (target nat) newComp
+    
+    
     -- | Return the apex of a `Cone`.
     apex :: Cone c1 m1 o1 c2 m2 o2 -> o2
     apex = indexSource
@@ -187,7 +210,19 @@             doms = possibleDomainsTopContained $ indexingCategoryCone c1
             maps = Set.concat2 [enumerateInjectiveMaps (\x y -> legsCone c1 =>$ x == legsCone c2 =>$ y) (set dom) (ob (indexingCategoryCone c2)) | dom <- doms]
     
+    -- | Precompose a cone with a morphism going to the apex. (Does not check that the morphism has the apex as target.)
+    precomposeConeWithMorphism :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,
+                                                        Morphism m2 o2) => 
+        Cone c1 m1 o1 c2 m2 o2 -> m2 -> Cone c1 m1 o1 c2 m2 o2
+    precomposeConeWithMorphism c m = unsafeCommaObject (source m) One (unsafeNaturalTransformation (source $ legsCone c) (target $ legsCone c) ((@ m) <$> (components $ legsCone c)))
     
+    -- | Postcompose a cone with a functor going from the base. 
+    postcomposeConeWithFunctor :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,
+                                     Category c2 m2 o2, Morphism m2 o2, Eq c2, Eq m2, Eq o2,
+                                                        Morphism m3 o3) => 
+        Cone c1 m1 o1 c2 m2 o2 -> Diagram c2 m2 o2 c3 m3 o3 -> Cone c1 m1 o1 c3 m3 o3
+    postcomposeConeWithFunctor c f = unsafeCommaObject (f ->$ (apex c)) One (f <-@<= (legsCone c))
+    
     -- -- --------------------------------
     -- -- Cocone related functions and types.
     -- -- --------------------------------
@@ -213,9 +248,25 @@             result = unsafeCommaObject One nadir nat
             
     -- | Constructs a 'Cocone' from a nadir and a 'NaturalTransformation'. Does NOT check if the target of the 'NaturalTransformation' is a constant diagram on the nadir. You may use this function at your own risk, consider using 'cocone' if you are not sure.
+    --
+    -- If you give an incomplete natural transformation to this function, you can use 'completeCocone' to complete the natural transformation.
     unsafeCocone :: o2 -> NaturalTransformation c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c2 m2 o2
     unsafeCocone nadir nat = unsafeCommaObject One nadir nat
     
+    -- | Given a cocone with a partial underlying natural transformation, tries to complete it. You can use 'checkNaturalTransformation.legsCocone' to check that the cocone was correctly completed. 
+    completeCocone :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => Cocone c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c2 m2 o2
+    completeCocone cc = unsafeCommaObject One (nadir cc) newNat
+        where
+            nat = legsCocone cc
+            prevComp = components nat
+            validArrowOnBottom x = [f | f <- arFrom (indexingCategory nat) x, (target f) `Set.isIn` (keys' prevComp)]
+            comp x
+                | not $ null $ prevComp |?| x = prevComp |?| x
+                | not $ Set.null $ validArrowOnBottom x = Just $ (prevComp |!| (target (anElement $ validArrowOnBottom x))) @ ((source nat) ->£ (anElement $ validArrowOnBottom x))
+                | otherwise = Nothing
+            newComp = weakMapFromSet $ Set.catMaybes [sequence (x,comp x) | x <- ob (indexingCategory nat)]
+            newNat = unsafeNaturalTransformation (source nat) (target nat) newComp
+    
     -- | Return the nadir of a `Cocone`.
     nadir :: Cocone c1 m1 o1 c2 m2 o2 -> o2
     nadir = indexTarget
@@ -314,4 +365,17 @@         | otherwise = set []
         where
             doms = possibleDomainsBottomContained $ indexingCategoryCocone cc1
-            maps = Set.concat2 [enumerateInjectiveMaps (\x y -> legsCocone cc1 =>$ x == legsCocone cc2 =>$ y) (set dom) (ob (indexingCategoryCocone cc2)) | dom <- doms]+            maps = Set.concat2 [enumerateInjectiveMaps (\x y -> legsCocone cc1 =>$ x == legsCocone cc2 =>$ y) (set dom) (ob (indexingCategoryCocone cc2)) | dom <- doms]
+            
+     -- | Precompose a cocone with a functor going to the base.
+    precomposeCoconeWithFunctor :: (      Category c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,  
+                              FiniteCategory c2 m2 o2, Morphism m2 o2, Eq c2, Eq m2, Eq o2,
+                                                       Morphism m3 o3, Eq c3, Eq m3, Eq o3) =>
+        Cocone c2 m2 o2 c3 m3 o3 -> Diagram c1 m1 o1 c2 m2 o2 -> Cocone c1 m1 o1 c3 m3 o3
+    precomposeCoconeWithFunctor cc f = unsafeCommaObject One (nadir cc) ((legsCocone cc) <=@<- f)
+    
+    -- | Postcompose a cone with a morphism going from the nadir. (Does not check that the morphism has the nadir as source.)
+    postcomposeCoconeWithMorphism :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1,
+                                                         Morphism m2 o2) =>
+        Cocone c1 m1 o1 c2 m2 o2 -> m2 -> Cocone c1 m1 o1 c2 m2 o2
+    postcomposeCoconeWithMorphism cc m = unsafeCommaObject One (target m) (unsafeNaturalTransformation (source $ legsCocone cc) (target $ legsCocone cc) ((m @) <$> (components $ legsCocone cc)))

src/Math/Categories/FunctorCategory.hs view

@@ -72,6 +72,8 @@     leftWhiskering,
     (<-@<=),
     rightWhiskering,
+    -- ** Misc
+    indexingCategory,
     -- * Functor categories
     FunctorCategory(..),
     PrecomposedFunctorCategory(..),
@@ -420,6 +422,9 @@     -- Use this constructor only if the 'NaturalTransformation' is necessarily well formed.
     unsafeNaturalTransformation :: Diagram c1 m1 o1 c2 m2 o2 -> Diagram c1 m1 o1 c2 m2 o2 -> Map o1 m2 -> NaturalTransformation c1 m1 o1 c2 m2 o2
     unsafeNaturalTransformation s t c = NaturalTransformation{srcNT = s, tgtNT = t, components = c}
+    
+    indexingCategory :: (FiniteCategory c1 m1 o1, Morphism m1 o1, Eq c1, Eq m1, Eq o1, Morphism m2 o2) => NaturalTransformation c1 m1 o1 c2 m2 o2 -> c1
+    indexingCategory = src.source
     
     -- Functor Category