{-# LANGUAGE AllowAmbiguousTypes #-}

-- | Internal module of "Proarrow.Tools.SMC": index notation for categories whose index types are
-- Frobenius algebras. It exports everything, also what the public module keeps hidden.
module Proarrow.Tools.SMC.Internal.Frobenius where

import GHC.TypeNats (type (+))

import Proarrow.Category.Monoidal (Monoidal (..), MonoidalProfunctor, rightUnitorInvWith)
import Proarrow.Category.Monoidal.Hypergraph (Frobenius, cap)
import Proarrow.Core (Profunctor (..), Promonad (..))
import Proarrow.Monoid (Monoid (..))
import Prelude (type (~))

import Proarrow.Tools.SMC.Internal.Context
import Proarrow.Tools.SMC.Internal.Pattern
import Proarrow.Tools.SMC.Internal.Syntax
import Proarrow.Tools.SMC.Internal.Term

infixl 7 *^
infixl 7 ^*

-- | An index summed over: the binder's variable is fed by the unit of its type's monoid, which,
-- copied to every use, is the sum over all the values the index can take. The body receives the
-- index through a pattern (see /Patterns/).
{-# INLINE sumOver #-}
sumOver
  :: forall {k} {p} (a :: SYN k) d r b t cont
   . (Profunctor p, Frobenius (Interp a), Binds p d r a b t cont)
  => (t -> cont)
  -> TermP p d r b
sumOver :: forall {k} {p :: k +-> k} (a :: SYN k) (d :: Nat) (r :: Ctx k)
       (b :: SYN k) t cont.
(Profunctor p, Frobenius (Interp a), Binds p d r a b t cont) =>
(t -> cont) -> TermP p d r b
sumOver t -> cont
k =
  forall (g :: Ctx k) r.
(KnownCtx g, Monoidal k) =>
(Ob (Interp (Mul g)) => r) -> r
forall {k} (g :: Ctx k) r.
(KnownCtx g, Monoidal k) =>
(Ob (Interp (Mul g)) => r) -> r
withCtxOb @r
    ( forall {k} (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
forall (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
withSynOb @a
        ( p (Interp (Mul r)) (Interp b) -> TermP p d r b
forall {k} (p :: CAT k) (g :: Ctx k) (a :: SYN k) (d :: Nat).
p (Interp (Mul g)) (Interp a) -> TermP p d g a
MkTerm
            ((Interp (Mul r) ~> (Interp (Mul r) ** Interp a))
-> p (Interp (Mul r) ** Interp a) (Interp b)
-> p (Interp (Mul r)) (Interp b)
forall (c :: k) (a :: k) (b :: k). (c ~> a) -> p a b -> p c b
forall {j} {k} (p :: j +-> k) (c :: k) (a :: k) (b :: j).
Profunctor p =>
(c ~> a) -> p a b -> p c b
lmap (forall (a :: k) (b :: k).
(Monoidal k, Ob a) =>
(Unit ~> b) -> a ~> (a ** b)
forall {k} (a :: k) (b :: k).
(Monoidal k, Ob a) =>
(Unit ~> b) -> a ~> (a ** b)
rightUnitorInvWith @(Interp (Mul r)) (forall (m :: k). Monoid m => Unit ~> m
forall {k} (m :: k). Monoid m => Unit ~> m
mempty @(Interp a))) (forall {k} (p :: CAT k) (n :: Nat) (g :: Ctx k) (a :: SYN k)
       (b :: SYN k) t cont.
Binds p n g a b t cont =>
(t -> cont) -> p (Interp (Mul g) ** Interp a) (Interp b)
forall (p :: CAT k) (n :: Nat) (g :: Ctx k) (a :: SYN k)
       (b :: SYN k) t cont.
Binds p n g a b t cont =>
(t -> cont) -> p (Interp (Mul g) ** Interp a) (Interp b)
bound @p @d @r @a @b t -> cont
k))
        )
    )

-- | An index summed over, as 'sumOver', for a body that refers to the index as the variable of id
-- @d@ instead of through a pattern.
{-# INLINE sumVar #-}
sumVar
  :: forall {k} {p} (a :: SYN k) d g' g b
   . (Profunctor p, Frobenius (Interp a), KnownObj a, BindVar d a g' g)
  => TermP p (d + 1) g' b
  -> TermP p d g b
sumVar :: forall {k} {p :: k +-> k} (a :: SYN k) (d :: Nat) (g' :: Ctx k)
       (g :: Ctx k) (b :: SYN k).
(Profunctor p, Frobenius (Interp a), KnownObj a,
 BindVar d a g' g) =>
TermP p (d + 1) g' b -> TermP p d g b
sumVar (MkTerm p (Interp (Mul g')) (Interp b)
body) =
  forall (g :: Ctx k) r.
(KnownCtx g, Monoidal k) =>
(Ob (Interp (Mul g)) => r) -> r
forall {k} (g :: Ctx k) r.
(KnownCtx g, Monoidal k) =>
(Ob (Interp (Mul g)) => r) -> r
withCtxOb @g
    ( forall {k} (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
forall (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
withSynOb @a
        (p (Interp (Mul g)) (Interp b) -> TermP p d g b
forall {k} (p :: CAT k) (g :: Ctx k) (a :: SYN k) (d :: Nat).
p (Interp (Mul g)) (Interp a) -> TermP p d g a
MkTerm ((Interp (Mul g) ~> Interp (Mul g'))
-> p (Interp (Mul g')) (Interp b) -> p (Interp (Mul g)) (Interp b)
forall (c :: k) (a :: k) (b :: k). (c ~> a) -> p a b -> p c b
forall {j} {k} (p :: j +-> k) (c :: k) (a :: k) (b :: j).
Profunctor p =>
(c ~> a) -> p a b -> p c b
lmap (forall (n :: Nat) (a :: SYN k) (g :: Ctx k) (r :: Ctx k).
BindVar n a g r =>
(Interp (Mul r) ** Interp a) ~> Interp (Mul g)
forall {k} (n :: Nat) (a :: SYN k) (g :: Ctx k) (r :: Ctx k).
BindVar n a g r =>
(Interp (Mul r) ** Interp a) ~> Interp (Mul g)
bindVar @d @a @g' @g ((Interp (Mul g) ** Interp a) ~> Interp (Mul g'))
-> (Interp (Mul g) ~> (Interp (Mul g) ** Interp a))
-> Interp (Mul g) ~> Interp (Mul g')
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 (a :: k) (b :: k).
(Monoidal k, Ob a) =>
(Unit ~> b) -> a ~> (a ** b)
forall {k} (a :: k) (b :: k).
(Monoidal k, Ob a) =>
(Unit ~> b) -> a ~> (a ** b)
rightUnitorInvWith @(Interp (Mul g)) (forall (m :: k). Monoid m => Unit ~> m
forall {k} (m :: k). Monoid m => Unit ~> m
mempty @(Interp a))) p (Interp (Mul g')) (Interp b)
body))
    )

-- | The Kronecker delta: the scalar that says two wires of an index type carry the same value. It
-- is the cap of the Frobenius algebra, @'Proarrow.Monoid.counit' . 'Proarrow.Monoid.mappend'@.
{-# INLINE delta #-}
delta
  :: forall {k} {p} (a :: SYN k) d g1 g2
   . (MonoidalProfunctor p, Frobenius (Interp a), KnownObj a, Merge g1 g2)
  => TermP p d g1 a -> TermP p d g2 a -> TermP p d (Union g1 g2) I
delta :: forall {k} {p :: k +-> k} (a :: SYN k) (d :: Nat) (g1 :: Ctx k)
       (g2 :: Ctx k).
(MonoidalProfunctor p, Frobenius (Interp a), KnownObj a,
 Merge g1 g2) =>
TermP p d g1 a -> TermP p d g2 a -> TermP p d (Union g1 g2) I
delta TermP p d g1 a
x TermP p d g2 a
y = (Interp (a :** a) ~> Interp I)
-> TermP p d (Union g1 g2) (a :** a) -> TermP p d (Union g1 g2) I
forall {k} (a :: SYN k) (b :: SYN k) (d :: Nat) (g :: Ctx k)
       (p :: CAT k).
Profunctor p =>
(Interp a ~> Interp b) -> TermP p d g a -> TermP p d g b
rmapT (forall (a :: k). Frobenius a => (a ** a) ~> Unit
forall {k} (a :: k). Frobenius a => (a ** a) ~> Unit
cap @(Interp a)) (TermP p d g1 a
x TermP p d g1 a
-> TermP p d g2 a -> TermP p d (Union g1 g2) (a :** a)
forall {k} (d :: Nat) (g1 :: Ctx k) (g2 :: Ctx k) (a :: SYN k)
       (b :: SYN k) (p :: CAT k).
(MonoidalProfunctor p, Merge g1 g2) =>
TermP p d g1 a
-> TermP p d g2 b -> TermP p d (Union g1 g2) (a :** b)
** TermP p d g2 a
y)

-- | A term multiplied by a scalar on its left. The scalar's type interprets to 'Unit',
-- including both 'I' and @'F' Unit@. At 'I' it is the product of two scalars.
{-# INLINE (*^) #-}
(*^)
  :: forall {k} {p} d g1 g2 (a :: SYN k) s t
   . (MonoidalProfunctor p, KnownObj a, Merge g1 g2, Interp s ~ Unit, ToTerm p t d g1 s)
  => t -> TermP p d g2 a -> TermP p d (Union g1 g2) a
t
s *^ :: forall {k} {p :: k +-> k} (d :: Nat) (g1 :: Ctx k) (g2 :: Ctx k)
       (a :: SYN k) (s :: SYN k) t.
(MonoidalProfunctor p, KnownObj a, Merge g1 g2, Interp s ~ Unit,
 ToTerm p t d g1 s) =>
t -> TermP p d g2 a -> TermP p d (Union g1 g2) a
*^ TermP p d g2 a
x = forall {k} (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
forall (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
withSynOb @a ((Interp (s :** a) ~> Interp a)
-> TermP p d (Union g1 g2) (s :** a) -> TermP p d (Union g1 g2) a
forall {k} (a :: SYN k) (b :: SYN k) (d :: Nat) (g :: Ctx k)
       (p :: CAT k).
Profunctor p =>
(Interp a ~> Interp b) -> TermP p d g a -> TermP p d g b
rmapT (forall k (a :: k). (Monoidal k, Ob a) => (Unit ** a) ~> a
leftUnitor @k @(Interp a)) (forall {k} (p :: CAT k) t (d :: Nat) (g :: Ctx k) (a :: SYN k).
ToTerm p t d g a =>
t -> TermP p d g a
forall (p :: CAT k) t (d :: Nat) (g :: Ctx k) (a :: SYN k).
ToTerm p t d g a =>
t -> TermP p d g a
toTerm @p @t @d @g1 @s t
s TermP p d g1 s
-> TermP p d g2 a -> TermP p d (Union g1 g2) (s :** a)
forall {k} (d :: Nat) (g1 :: Ctx k) (g2 :: Ctx k) (a :: SYN k)
       (b :: SYN k) (p :: CAT k).
(MonoidalProfunctor p, Merge g1 g2) =>
TermP p d g1 a
-> TermP p d g2 b -> TermP p d (Union g1 g2) (a :** b)
** TermP p d g2 a
x))

-- | A term multiplied by a scalar on its right.
{-# INLINE (^*) #-}
(^*)
  :: forall {k} {p} d g1 g2 (a :: SYN k) s t
   . (MonoidalProfunctor p, KnownObj a, Merge g1 g2, Interp s ~ Unit, ToTerm p t d g2 s)
  => TermP p d g1 a -> t -> TermP p d (Union g1 g2) a
TermP p d g1 a
x ^* :: forall {k} {p :: k +-> k} (d :: Nat) (g1 :: Ctx k) (g2 :: Ctx k)
       (a :: SYN k) (s :: SYN k) t.
(MonoidalProfunctor p, KnownObj a, Merge g1 g2, Interp s ~ Unit,
 ToTerm p t d g2 s) =>
TermP p d g1 a -> t -> TermP p d (Union g1 g2) a
^* t
s = forall {k} (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
forall (s :: SYN k) r. KnownObj s => (Ob (Interp s) => r) -> r
withSynOb @a ((Interp (a :** s) ~> Interp a)
-> TermP p d (Union g1 g2) (a :** s) -> TermP p d (Union g1 g2) a
forall {k} (a :: SYN k) (b :: SYN k) (d :: Nat) (g :: Ctx k)
       (p :: CAT k).
Profunctor p =>
(Interp a ~> Interp b) -> TermP p d g a -> TermP p d g b
rmapT (forall k (a :: k). (Monoidal k, Ob a) => (a ** Unit) ~> a
rightUnitor @k @(Interp a)) (TermP p d g1 a
x TermP p d g1 a
-> TermP p d g2 s -> TermP p d (Union g1 g2) (a :** s)
forall {k} (d :: Nat) (g1 :: Ctx k) (g2 :: Ctx k) (a :: SYN k)
       (b :: SYN k) (p :: CAT k).
(MonoidalProfunctor p, Merge g1 g2) =>
TermP p d g1 a
-> TermP p d g2 b -> TermP p d (Union g1 g2) (a :** b)
** forall {k} (p :: CAT k) t (d :: Nat) (g :: Ctx k) (a :: SYN k).
ToTerm p t d g a =>
t -> TermP p d g a
forall (p :: CAT k) t (d :: Nat) (g :: Ctx k) (a :: SYN k).
ToTerm p t d g a =>
t -> TermP p d g a
toTerm @p @t @d @g2 @s t
s))