module NCILL.Sequent where

open import Data.List

open import NCILL.Types
open import NCILL.Ctx

-- SEQUENT
------------------------------------------------------------------------

infix 4 _⊢_

data _⊢_ : Ctx  Ty  Set where

  var :  {A}

  ---------------
     [ A ]  A


  impl-R :  {Γ A B}

     A  Γ  B
  --------------------
     Γ  (A  B)


  impl-L :  {Γ} Δ₁ {Δ₂ A B C}

     Γ  A     Δ₁ ++ B  Δ₂  C
  ---------------------------------
     Δ₁ ++ Γ ++ A  B  Δ₂  C


  impl-Rʳ :  {Γ A B}

     Γ ++ [ A ]  B
  --------------------
     Γ  (A ⊸ʳ B)


  impl-Lʳ :  {Γ} (Δ₁ : Ctx)   {Δ₂ A B C}

     Γ  A     Δ₁ ++ B  Δ₂  C
  ---------------------------------
     Δ₁ ++ A ⊸ʳ B  Γ ++ Δ₂  C


  times-R :  {Γ Δ A B}

     Γ  A     Δ  B
  ----------------------
     Γ ++ Δ  A  B


  times-L :  Δ₁ {Δ₂ A B C}

     Δ₁ ++ A  B  Δ₂  C
 ---------------------------
     Δ₁ ++ A  B  Δ₂  C


  plus-R₁ :  {Γ A B}

     Γ  A
  ---------------
     Γ  A  B


  plus-R₂ :  {Γ A B}

     Γ  B
  ---------------
     Γ  A  B


  plus-L :  Δ₁ {Δ₂ A B C}

     Δ₁ ++ A  Δ₂  C     Δ₁ ++ B  Δ₂  C
  --------------------------------------------
     Δ₁ ++ A  B  Δ₂  C


  with-R :  {Γ A B}

     Γ  A     Γ  B
  ----------------------
     Γ  A & B


  with-L₁ :  Δ₁ {Δ₂ A B C}

     Δ₁ ++ A  Δ₂  C
  --------------------------
     Δ₁ ++ A & B  Δ₂  C


  with-L₂ :  Δ₁ {Δ₂ A B C}

     Δ₁ ++ B  Δ₂  C
 ---------------------------
     Δ₁ ++ A & B  Δ₂  C

  unit-R :

  -----------
    []  ♯1


  unit-L :  Δ₁ {Δ₂ A}

     Δ₁ ++ Δ₂  A
  -----------------------
     Δ₁ ++ ♯1  Δ₂  A


  zero-L :  Δ₁ {Δ₂ A}

  -------------------------
     Δ₁ ++ ♯0  Δ₂  A


  top-R :  {Γ}

  ------------
     Γ  ♯⊤

-- For backwards compatibility
Sqnt : Ctx  Ty  Set
Sqnt Γ A = Γ  A

app :  {Γ} Δ₁ {Δ₂ A B C}

   Γ  A     Δ₁ ++ B  Δ₂  C
---------------------------------
   Δ₁ ++ A ⊸ʳ B  Γ ++ Δ₂  C

app = impl-Lʳ


lam :  {Γ A B}

   Γ ++ [ A ]  B
--------------------
   Γ  (A ⊸ʳ B)

lam = impl-Rʳ