{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE RequiredTypeArguments #-}
{-# OPTIONS_GHC -Wno-unused-foralls #-}

-- | Star-autonomous categories: dialogue categories ("Proarrow.Category.Monoidal.Dialogue") whose
-- dualizing functor 'Dual' is an involution, so that double negation @'Dual' ('Dual' a) ≅ a@
-- ('doubleNeg') and 'dual' is bijective on hom-sets ('dualInv'). They are closed, with an internal
-- hom @'ExpSA' a b = 'Dual' (a ** Dual b)@, and are the categorical semantics of multiplicative
-- linear logic.
module Proarrow.Category.Monoidal.StarAutonomous where

import Data.Kind (Constraint)
import Prelude (($))
import Prelude qualified as P

import Proarrow.Category.Instance.Bool (BOOL (..), Booleans (..))
import Proarrow.Category.Instance.Free
  ( Elems
  , FREE (..)
  , Free (..)
  , HasStructure (..)
  , IsFreeOb (..)
  , Lower
  , WithShow
  , withLowerOb
  )
import Proarrow.Category.Instance.Product ((:**:) (..))
import Proarrow.Category.Instance.Unit qualified as U
import Proarrow.Category.Monoidal (Monoidal (..), MonoidalProfunctor (..), SymMonoidal (..))
import Proarrow.Category.Monoidal.Closed (Closed (..))
import Proarrow.Category.Monoidal.Dialogue (Dialogue (..), DualF, dualObj)
import Proarrow.Core (CAT, CategoryOf (..), Kind, Profunctor (..), Promonad (..), obj)
import Proarrow.Optic (PIso, iso)
import Proarrow.Tools.Laws (Bijection (..), Inverses (..), Laws (..), bijection, inverses)

-- | A *-autonomous category: a dialogue category whose dual is an involution, so that
-- @Hom(a '**' b, 'Dual' c)@ is symmetric in its three arguments.
--
-- __Laws:__ those of 'Dialogue', and
--
-- * 'dual' and 'dualInv' are mutually inverse bijections on hom-sets:
--   @'dualInv' ('dual' f) = f@ and @'dual' ('dualInv' g) = g@
-- * 'doubleNeg' and 'doubleNegInv' are mutually inverse, so @'Dual' ('Dual' a) ≅ a@
--
-- Stated as code by the 'Proarrow.Tools.Laws.Laws' instance for 'StarAutonomousStructures', and
-- checked by @Proarrow.Testing.Laws.testStarAutonomous@.
class (Dialogue k, Closed k) => StarAutonomous k where
  -- | Inverse to 'dual' on hom-sets: recovers the undualized arrow.
  dualInv :: (Ob (a :: k), Ob b) => Dual a ~> Dual b -> b ~> a

  -- | Double-negation elimination. Defaults to 'doubleNegDefault'; an instance whose double dual
  -- is the object itself can say so directly.
  doubleNeg :: (Ob (a :: k)) => Dual (Dual a) ~> a
  doubleNeg @a = forall (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
forall {k} (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNegDefault @a

-- | 'doubleNeg' from the rest of the structure: 'dualInv' of 'doubleNegInv' at the dual.
doubleNegDefault :: forall {k} (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNegDefault :: forall {k} (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNegDefault = forall k (a :: k) (b :: k).
(StarAutonomous k, Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv @k @a (forall k (a :: k). (Dialogue k, Ob a) => a ~> Dual (Dual a)
doubleNegInv @k @(Dual a)) ((Ob (Dual (Dual a)), Ob (Dual (Dual a))) => Dual (Dual a) ~> a)
-> (Dual (Dual a) ~> Dual (Dual a)) -> Dual (Dual a) ~> a
forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ forall (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
forall {k} (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
dualObj @(Dual a) ((Ob (Dual a), Ob (Dual a)) => Dual (Dual a) ~> a)
-> (Dual a ~> Dual a) -> Dual (Dual a) ~> a
forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ forall (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
forall {k} (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
dualObj @a

doubleNegIso
  :: forall {k} (a :: k) (a' :: k). (StarAutonomous k, Ob a, Ob a') => PIso a a' (Dual (Dual a)) (Dual (Dual a'))
doubleNegIso :: forall {k} (a :: k) (a' :: k).
(StarAutonomous k, Ob a, Ob a') =>
PIso a a' (Dual (Dual a)) (Dual (Dual a'))
doubleNegIso = (a ~> Dual (Dual a))
-> (Dual (Dual a') ~> a')
-> Optic_ (OPT (Dual (Dual a)) (Dual (Dual a'))) (OPT a a')
forall {j} {k} (c :: (j +-> k) -> Constraint) (s :: k) (t :: j)
       (a :: k) (b :: j).
(CategoryOf j, CategoryOf k) =>
(s ~> a) -> (b ~> t) -> Optic c s t a b
iso a ~> Dual (Dual a)
forall (a :: k). Ob a => a ~> Dual (Dual a)
forall k (a :: k). (Dialogue k, Ob a) => a ~> Dual (Dual a)
doubleNegInv Dual (Dual a') ~> a'
forall (a :: k). Ob a => Dual (Dual a) ~> a
forall k (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNeg

type ExpSA a b = Dual (a ** Dual b)

currySA :: forall {k} (a :: k) b c. (StarAutonomous k, Ob a, Ob b) => a ** b ~> c -> a ~> ExpSA b c
currySA :: forall {k} (a :: k) (b :: k) (c :: k).
(StarAutonomous k, Ob a, Ob b) =>
((a ** b) ~> c) -> a ~> ExpSA b c
currySA (a ** b) ~> c
f = forall k (a :: k) (b :: k) (c :: k).
(Dialogue k, Ob a, Ob b, Ob c) =>
((a ** b) ~> Dual c) -> a ~> Dual (b ** c)
linDist @k @a @b @(Dual c) (forall k (a :: k). (Dialogue k, Ob a) => a ~> Dual (Dual a)
doubleNegInv @k @c (c ~> Dual (Dual c))
-> ((a ** b) ~> c) -> (a ** b) ~> Dual (Dual c)
forall (b :: k) (c :: k) (a :: k). (b ~> c) -> (a ~> b) -> a ~> c
forall {k} (p :: CAT k) (b :: k) (c :: k) (a :: k).
Promonad p =>
p b c -> p a b -> p a c
. (a ** b) ~> c
f) ((Ob (a ** b), Ob c) => a ~> Dual (b ** Dual c))
-> ((a ** b) ~> c) -> a ~> Dual (b ** Dual c)
forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ (a ** b) ~> c
f ((Ob (Dual c), Ob (Dual (a ** b))) => a ~> Dual (b ** Dual c))
-> (Dual c ~> Dual (a ** b)) -> a ~> Dual (b ** Dual c)
forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ ((a ** b) ~> c) -> Dual c ~> Dual (a ** b)
forall (a :: k) (b :: k). (a ~> b) -> Dual b ~> Dual a
forall k (a :: k) (b :: k).
Dialogue k =>
(a ~> b) -> Dual b ~> Dual a
dual (a ** b) ~> c
f

applySA :: forall {k} (b :: k) c. (StarAutonomous k, Ob b, Ob c) => ExpSA b c ** b ~> c
applySA :: forall {k} (b :: k) (c :: k).
(StarAutonomous k, Ob b, Ob c) =>
(ExpSA b c ** b) ~> c
applySA =
  forall k (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNeg @k @c (Dual (Dual c) ~> c)
-> ((Dual (b ** Dual c) ** b) ~> Dual (Dual c))
-> (Dual (b ** Dual c) ** b) ~> c
forall (b :: k) (c :: k) (a :: k). (b ~> c) -> (a ~> b) -> a ~> c
forall {k} (p :: CAT k) (b :: k) (c :: k) (a :: k).
Promonad p =>
p b c -> p a b -> p a c
. forall k (a :: k) (b :: k) r.
(Monoidal k, Ob a, Ob b) =>
(Ob (a ** b) => r) -> r
withOb2 @k @b @(Dual c) (forall k (a :: k) (b :: k) (c :: k).
(Dialogue k, Ob a, Ob b, Ob c) =>
(a ~> Dual (b ** c)) -> (a ** b) ~> Dual c
linDistInv @k @(ExpSA b c) @b @(Dual c) Dual (b ** Dual c) ~> Dual (b ** Dual c)
forall (a :: k). Ob a => a ~> a
forall {k} (p :: CAT k) (a :: k). (Promonad p, Ob a) => p a a
id ((Ob (Dual (b ** Dual c)), Ob (Dual (b ** Dual c))) =>
 (Dual (b ** Dual c) ** b) ~> Dual (Dual c))
-> (Dual (b ** Dual c) ~> Dual (b ** Dual c))
-> (Dual (b ** Dual c) ** b) ~> Dual (Dual c)
forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ forall (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
forall {k} (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
dualObj @(b ** Dual c))
    ((Ob (Dual c), Ob (Dual c)) => (Dual (b ** Dual c) ** b) ~> c)
-> (Dual c ~> Dual c) -> (Dual (b ** Dual c) ** b) ~> c
forall (a :: k) (b :: k) r. ((Ob a, Ob b) => r) -> (a ~> b) -> r
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
\\ forall (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
forall {k} (a :: k). (Dialogue k, Ob a) => Obj (Dual a)
dualObj @c

expSA :: forall {k} (a :: k) b x y. (StarAutonomous k) => b ~> y -> x ~> a -> ExpSA a b ~> ExpSA x y
expSA :: forall {k} (a :: k) (b :: k) (x :: k) (y :: k).
StarAutonomous k =>
(b ~> y) -> (x ~> a) -> ExpSA a b ~> ExpSA x y
expSA b ~> y
f x ~> a
g = ((x ** Dual y) ~> (a ** Dual b))
-> Dual (a ** Dual b) ~> Dual (x ** Dual y)
forall (a :: k) (b :: k). (a ~> b) -> Dual b ~> Dual a
forall k (a :: k) (b :: k).
Dialogue k =>
(a ~> b) -> Dual b ~> Dual a
dual (x ~> a
g (x ~> a) -> (Dual y ~> Dual b) -> (x ** Dual y) ~> (a ** Dual b)
forall (x1 :: k) (x2 :: k) (y1 :: k) (y2 :: k).
(x1 ~> x2) -> (y1 ~> y2) -> (x1 ** y1) ~> (x2 ** y2)
forall {j} {k} (p :: j +-> k) (x1 :: k) (x2 :: j) (y1 :: k)
       (y2 :: j).
MonoidalProfunctor p =>
p x1 x2 -> p y1 y2 -> p (x1 ** y1) (x2 ** y2)
** (b ~> y) -> Dual y ~> Dual b
forall (a :: k) (b :: k). (a ~> b) -> Dual b ~> Dual a
forall k (a :: k) (b :: k).
Dialogue k =>
(a ~> b) -> Dual b ~> Dual a
dual b ~> y
f)

instance StarAutonomous () where
  dualInv :: forall (a :: ()) (b :: ()).
(Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv Dual a ~> Dual b
Unit '() '()
U.Unit = b ~> a
Unit '() '()
U.Unit
  doubleNeg :: forall (a :: ()). Ob a => Dual (Dual a) ~> a
doubleNeg = Dual (Dual a) ~> a
Unit '() '()
U.Unit

instance StarAutonomous BOOL where
  dualInv :: forall (a :: BOOL) (b :: BOOL).
(Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv @a @b Dual a ~> Dual b
f = case (forall {k} (a :: k). (CategoryOf k, Ob a) => Obj a
forall (a :: BOOL). (CategoryOf BOOL, Ob a) => Obj a
obj @a, forall {k} (a :: k). (CategoryOf k, Ob a) => Obj a
forall (a :: BOOL). (CategoryOf BOOL, Ob a) => Obj a
obj @b, Dual a ~> Dual b
Booleans (Not a) (Not b)
f) of
    (Booleans a a
Fls, Booleans b b
Fls, Booleans 'TRU 'TRU
Booleans (Not a) (Not b)
Tru) -> b ~> a
Booleans 'FLS 'FLS
Fls
    (Booleans a a
Tru, Booleans b b
Fls, Booleans 'FLS 'TRU
Booleans (Not a) (Not b)
F2T) -> b ~> a
Booleans 'FLS 'TRU
F2T
    (Booleans a a
Tru, Booleans b b
Tru, Booleans 'FLS 'FLS
Booleans (Not a) (Not b)
Fls) -> b ~> a
Booleans 'TRU 'TRU
Tru
    (Booleans a a
Fls, Booleans b b
Tru, Booleans (Not a) (Not b)
f') -> case Booleans (Not a) (Not b)
f' of {}
  doubleNeg :: forall (a :: BOOL). Ob a => Dual (Dual a) ~> a
doubleNeg @a = case forall {k} (a :: k). (CategoryOf k, Ob a) => Obj a
forall (a :: BOOL). (CategoryOf BOOL, Ob a) => Obj a
obj @a of Obj a
Booleans a a
Fls -> Dual (Dual a) ~> a
Booleans 'FLS 'FLS
Fls; Obj a
Booleans a a
Tru -> Dual (Dual a) ~> a
Booleans 'TRU 'TRU
Tru

-- BOOL is not CompactClosed

instance (StarAutonomous j, StarAutonomous k) => StarAutonomous (j, k) where
  dualInv :: forall (a :: (j, k)) (b :: (j, k)).
(Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv (a1 ~> b1
f :**: a2 ~> b2
g) = (Dual (Fst @ a) ~> Dual (Fst @ b)) -> (Fst @ b) ~> (Fst @ a)
forall (a :: j) (b :: j).
(Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
forall k (a :: k) (b :: k).
(StarAutonomous k, Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv a1 ~> b1
Dual (Fst @ a) ~> Dual (Fst @ b)
f ((Fst @ b) ~> (Fst @ a))
-> ((Snd @ b) ~> (Snd @ a))
-> (:**:) (~>) (~>) '(Fst @ b, Snd @ b) '(Fst @ a, Snd @ a)
forall {j1} {k1} {j2} {k2} (c :: j1 +-> k1) (a1 :: k1) (b1 :: j1)
       (d :: j2 +-> k2) (a2 :: k2) (b2 :: j2).
c a1 b1 -> d a2 b2 -> (:**:) c d '(a1, a2) '(b1, b2)
:**: (Dual (Snd @ a) ~> Dual (Snd @ b)) -> (Snd @ b) ~> (Snd @ a)
forall (a :: k) (b :: k).
(Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
forall k (a :: k) (b :: k).
(StarAutonomous k, Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv a2 ~> b2
Dual (Snd @ a) ~> Dual (Snd @ b)
g
  doubleNeg :: forall (a :: (j, k)). Ob a => Dual (Dual a) ~> a
doubleNeg @'(a, b) = forall k (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNeg @j @a (Dual (Dual (Fst @ a)) ~> (Fst @ a))
-> (Dual (Dual (Snd @ a)) ~> (Snd @ a))
-> (:**:)
     (~>)
     (~>)
     '(Dual (Dual (Fst @ a)), Dual (Dual (Snd @ a)))
     '(Fst @ a, Snd @ a)
forall {j1} {k1} {j2} {k2} (c :: j1 +-> k1) (a1 :: k1) (b1 :: j1)
       (d :: j2 +-> k2) (a2 :: k2) (b2 :: j2).
c a1 b1 -> d a2 b2 -> (:**:) c d '(a1, a2) '(b1, b2)
:**: forall k (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNeg @k @b

-- | The structures the free category needs for 'StarAutonomous', and those its laws are stated for.
type StarAutonomousStructures :: [Kind -> Constraint]
type StarAutonomousStructures = '[Monoidal, SymMonoidal, Closed, Dialogue, StarAutonomous]

instance
  (StarAutonomousStructures `Elems` cs)
  => HasStructure cs (p :: CAT k) StarAutonomous
  where
  data Struct StarAutonomous a b where
    DualInv :: (Ob a, Ob b) => DualF a ~> DualF b -> Struct StarAutonomous b a
  foldStructure :: forall {k'} (f :: k +-> k') (a :: FREE cs p) (b :: FREE cs p).
(StarAutonomous k', All cs k', Representable f) =>
(forall (x :: FREE cs p) (y :: FREE cs p).
 (x ~> y) -> Lower f x ~> Lower f y)
-> Struct StarAutonomous a b -> Lower f a ~> Lower f b
foldStructure @f forall (x :: FREE cs p) (y :: FREE cs p).
(x ~> y) -> Lower f x ~> Lower f y
go (DualInv @a @b DualF b ~> DualF a
g) =
    forall {k} {k'} {cs :: [Type -> Constraint]} {p :: CAT k}
       (f :: k +-> k') (a :: FREE cs p) r.
(IsFreeOb a, Representable f, All cs k') =>
(Ob (Lower f a) => r) -> r
forall (f :: k +-> k') (a :: FREE cs p) r.
(IsFreeOb a, Representable f, All cs k') =>
(Ob (Lower f a) => r) -> r
withLowerOb @f @a (forall {k} {k'} {cs :: [Type -> Constraint]} {p :: CAT k}
       (f :: k +-> k') (a :: FREE cs p) r.
(IsFreeOb a, Representable f, All cs k') =>
(Ob (Lower f a) => r) -> r
forall (f :: k +-> k') (a :: FREE cs p) r.
(IsFreeOb a, Representable f, All cs k') =>
(Ob (Lower f a) => r) -> r
withLowerOb @f @b (forall k (a :: k) (b :: k).
(StarAutonomous k, Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv @_ @(Lower f a) @(Lower f b) ((DualF b ~> DualF a) -> Lower f (DualF b) ~> Lower f (DualF a)
forall (x :: FREE cs p) (y :: FREE cs p).
(x ~> y) -> Lower f x ~> Lower f y
go DualF b ~> DualF a
g)))
instance (WithShow a) => P.Show (Struct StarAutonomous a b) where
  showsPrec :: Int -> Struct StarAutonomous a b -> ShowS
showsPrec Int
d (DualInv DualF b ~> DualF a
f) = Bool -> ShowS -> ShowS
P.showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
P.> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
P.$ String -> ShowS
P.showString String
"dualInv " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
forall {k} (p :: CAT k) (b :: k) (c :: k) (a :: k).
Promonad p =>
p b c -> p a b -> p a c
. Int -> Free (DualF b) (DualF a) -> ShowS
forall a. Show a => Int -> a -> ShowS
P.showsPrec Int
11 DualF b ~> DualF a
Free (DualF b) (DualF a)
f

instance
  (StarAutonomousStructures `Elems` cs)
  => StarAutonomous (FREE cs (p :: CAT k))
  where
  dualInv :: forall (a :: FREE cs p) (b :: FREE cs p).
(Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv @a @b Dual a ~> Dual b
f = Struct StarAutonomous b a -> Free b b -> Free b a
forall {k} {cs :: [Type -> Constraint]} {p :: CAT k}
       (c :: Type -> Constraint) (a1 :: FREE cs p) (b :: FREE cs p)
       (a :: FREE cs p).
(HasStructure cs p c, Ob a1, Ob b) =>
Struct c a1 b -> Free a a1 -> Free a b
St (forall {k} {cs :: [Type -> Constraint]} {p :: CAT k}
       (a :: FREE cs p) (b :: FREE cs p).
(Ob a, Ob b) =>
(DualF a ~> DualF b) -> Struct StarAutonomous b a
forall (a :: FREE cs p) (b :: FREE cs p).
(Ob a, Ob b) =>
(DualF a ~> DualF b) -> Struct StarAutonomous b a
DualInv @a @b Dual a ~> Dual b
DualF a ~> DualF b
f) Free b b
forall {k} {cs :: [Type -> Constraint]} {p :: CAT k}
       (a :: FREE cs p).
Ob a =>
Free a a
Nil ((Ob (DualF a), Ob (DualF b)) => Free b a)
-> Free (DualF a) (DualF b) -> Free b a
forall {j} {k} (p :: j +-> k) (a :: k) (b :: j) r.
Profunctor p =>
((Ob a, Ob b) => r) -> p a b -> r
forall (a :: FREE cs p) (b :: FREE cs p) r.
((Ob a, Ob b) => r) -> Free a b -> r
\\ Dual a ~> Dual b
Free (DualF a) (DualF b)
f

-- | 'dual' is bijective on hom-sets with inverse 'dualInv', and 'doubleNeg' is an isomorphism.
-- The rest is in the laws of 'Proarrow.Category.Monoidal.Dialogue.DialogueStructures'.
instance Laws StarAutonomousStructures where
  laws :: [Law StarAutonomousStructures]
laws =
    String
-> BijectionBody StarAutonomousStructures
-> [Law StarAutonomousStructures]
forall (cs :: [Type -> Constraint]).
String -> BijectionBody cs -> [Law cs]
bijection
      String
"dual"
      ( \ @a @b forall (x :: k) (y :: k). (Ob x, Ob y) => String -> m (x ~> y)
mor ->
          forall k (a :: k) r. (Dialogue k, Ob a) => (Ob (Dual a) => r) -> r
withObDual @_ @a ((Ob (Dual a) => Bijection m k) -> Bijection m k)
-> (Ob (Dual a) => Bijection m k) -> Bijection m k
forall a b. (a -> b) -> a -> b
$
            forall k (a :: k) r. (Dialogue k, Ob a) => (Ob (Dual a) => r) -> r
withObDual @_ @b ((Ob (Dual b) => Bijection m k) -> Bijection m k)
-> (Ob (Dual b) => Bijection m k) -> Bijection m k
forall a b. (a -> b) -> a -> b
$
              m (a ~> b)
-> m (Dual b ~> Dual a)
-> ((a ~> b) -> Dual b ~> Dual a)
-> ((Dual b ~> Dual a) -> a ~> b)
-> Bijection m k
forall {k} (m :: Type -> Type) (a :: k) (b :: k) (c :: k) (d :: k).
m (a ~> b)
-> m (c ~> d)
-> ((a ~> b) -> c ~> d)
-> ((c ~> d) -> a ~> b)
-> Bijection m k
Bijection (forall (x :: k) (y :: k). (Ob x, Ob y) => String -> m (x ~> y)
mor @a @b String
"f") (forall (x :: k) (y :: k). (Ob x, Ob y) => String -> m (x ~> y)
mor @(Dual b) @(Dual a) String
"g") (a ~> b) -> Dual b ~> Dual a
forall (a :: k) (b :: k). (a ~> b) -> Dual b ~> Dual a
forall k (a :: k) (b :: k).
Dialogue k =>
(a ~> b) -> Dual b ~> Dual a
dual (forall k (a :: k) (b :: k).
(StarAutonomous k, Ob a, Ob b) =>
(Dual a ~> Dual b) -> b ~> a
dualInv @_ @b @a)
      )
      [Law StarAutonomousStructures]
-> [Law StarAutonomousStructures] -> [Law StarAutonomousStructures]
forall a. [a] -> [a] -> [a]
P.++ String
-> PureLawBody StarAutonomousStructures Inverses
-> [Law StarAutonomousStructures]
forall (cs :: [Type -> Constraint]).
String -> PureLawBody cs Inverses -> [Law cs]
inverses String
"doubleNeg" \ @a -> (a ~> Dual (Dual a)) -> (Dual (Dual a) ~> a) -> Inverses k
forall {k} (a :: k) (b :: k). (a ~> b) -> (b ~> a) -> Inverses k
Inverses (forall k (a :: k). (Dialogue k, Ob a) => a ~> Dual (Dual a)
doubleNegInv @_ @a) (forall k (a :: k). (StarAutonomous k, Ob a) => Dual (Dual a) ~> a
doubleNeg @_ @a)