Geçenlerde Haskell ve Agda (bağımlı yazılan işlevsel bir programlama dili) özellikli, ve eğer kombinatoriyel mantık ile bu lambda calculus değiştirmek mümkün olup olmadığını merak ediyorum hangi üniversite programı tamamlandı. Haskell ile bu mümkün S ve K combinators kullanarak, böylece nokta-ücretsiz yapmak gibi görünüyor. Eşdeğer Agda için ne olduğunu merak ediyordum. I. e., bir bağımlı olarak yazılan işlevsel bir programlama dili Agda eşdeğer herhangi bir değişken kullanmadan yapabilir miyim?

Ayrıca, bir şekilde combinators ölçümü ile değiştirmek mümkün mü? Bu bir tesadüf ama örneğin evrensel ölçümü tip bir imza lambda ifadesi gibi kalır mı bilmiyorum. Bir şekilde anlamını değiştirmeden tür bir imza evrensel ölçümü kaldırmak için var? E. g. içinde:

forall a : Int -> a < 0 -> a   a < a

Aynı şeyi bir şeyler kullanmadan ifade edilebilir?

Biraz daha ve biraz ilerleme hakkında düşündüm. İşte kombinatoriyel bir tarzda Martin-Löf (ama) tutarsız nefis basit Set : Set kodlama sistemi ilk başta bir bıçak. Bitirmek için iyi bir yol değil, ama başlamak için en kolay yer. Bu tür bir teori sadece sözdizimi lambda-calculus tür ek açıklamaları, Pı-tip, ve evrenin bir dizi olduğunu.

Hedef Türü Teori

Bütünlüğü hatırına, kuralları sunacağız. İçerik geçerliliği sadece bitişik taze değişkenleri Sets yapılar boş bağlamlarda inşa edebilirsiniz diyor.

                     G |- valid   G |- S : Set
--------------     ----------------------------- x fresh for G
  . |- valid         G, x:S |- valid

Ve şimdi herhangi bir bağlamda terimleri tür sentez, ve bir şey türünü içerdiği terimlerin sayısal davranışı değiştirmek için ne söyleyebiliriz.

  G |- valid             G |- S : Set   G |- T : Pi S \ x:S -> Set
------------------     ---------------------------------------------
  G |- Set : Set         G |- Pi S T : Set

  G |- S : Set   G, x:S |- t : T x         G |- f : Pi S T   G |- s : S
------------------------------------     --------------------------------
  G |- \ x:S -> t : Pi S T                 G |- f s : T s

  G |- valid                  G |- s : S   G |- T : Set
-------------- x:S in G     ----------------------------- S ={beta} T
  G |- x : S                  G |- s : T

Orijinalden küçük bir değişiklik olarak, lambda sadece bağlama operatörü yaptım, Pi sayısının ikinci değişkeni giriş bağlıdır, bir işlevi şekilde işlem yapılmalıdır. Kongre tarafından (örneğin Agda, ama ne yazık ki değil Haskell), kapsam lambda uzatır sağa doğru mümkün olduğunca, bu yüzden sık sık terk soyutlamalar unbracketed zaman onlar en son bağımsız değişken bir üst düzey operatör: gördüm o Pi. Agda tip 23* *Pi S \ x:S -> T olur.

(Anlatılanlar. Lambda tür açıklamalar eğer muktedir istiyorsanız gerekli değildirsentezsoyutlamaların yazın. Eğer türüne geçiş yapınkontrolmodus operandi senin gibi, hala ek açıklamalar bütün bu parçaları türlerini tahmin etmek imkansız gibi (\ x -> t) s gibi beta-redex bir kontrol etmek lazım. Modern tasarımcılar türlerini kontrol edin ve çok sözdizimi beta-redexes çıkarmak için tavsiye ediyorum.)

(Anlatılanlar. Bu sistem Set:Set çeşitli kodlama sağlar gibi tutarsız "yalancı paradoksları". -Martin Löf kendi tutarsız Sistemini U. onu bir kodlama gönderilen Girard bu teori, önerilen sonraki paradoks Hurkens nedeniyle biliyoruz etkileyicisi zehirli yapımı.)

Sözdizimi ve Normalleştirme kombinatorik

Neyse, biz iki ekstra semboller, Pi ve Set, bu yüzden biz de belki de yönetmek Bir kombinatoriyel çeviri ile S, K ve iki ekstra semboller: seçtim U için evren ve P ürünü.

Şimdi yazılmamış kombinatoriyel sözdizimi (serbest değişkenleri ile) tanımlayabiliriz:

data SKUP = S | K | U | P deriving (Show, Eq)

data Unty a
  = C SKUP
  | Unty a :. Unty a
  | V a
  deriving (Functor, Eq)
infixl 4 :.

Ücretsiz değişkenler bu sözdizimini yazın a tarafından temsil vardır demektir ekledim unutmayın. Olması dışında bir refleks benim için (her sözdizimi layık adıdır ücretsiz bir monad return gömme değişkenler ve >>= perfoming ikame) olacak kullanışlı temsil Ara aşamalarında sürecin dönüştürme açısından bağlayıcı kendi kombinatoriyel formu.

Burada normalleştirme:

norm :: Unty a -> Unty a
norm (f :. a)  = norm f $. a
norm c         = c

($.) :: Unty a -> Unty a -> Unty a        -- requires first arg in normal form
C S :. f :. a $. g  = f $. g $. (a :. g)  -- S f a g = f g (a g)   share environment
C K :. a $. g       = a                   -- K a g = a             drop environment
n $. g              = n :. norm g         -- guarantees output in normal form
infixl 4 $.

(Okuyucu için bir egzersiz tam olarak normal formlar için bir tür tanımlayabilir ve bu işlemlerin türleri netleştirmek için.)

Yazın Kuramı Temsil Eden

Şimdi yazın teorimiz için bir sözdizimi tanımlayabiliriz.

data Tm a
  = Var a
  | Lam (Tm a) (Tm (Su a))    -- Lam is the only place where binding happens
  | Tm a :$ Tm a
  | Pi (Tm a) (Tm a)          -- the second arg of Pi is a function computing a Set
  | Set
  deriving (Show, Functor)
infixl 4 :$

data Ze
magic :: Ze -> a
magic x = x `seq` error "Tragic!"

data Su a = Ze | Su a deriving (Show, Functor, Eq)

Bellegarde ve Kanca şekilde de Bruijn indeks gösterimi Kuş ve Paterson tarafından popüler olarak kullanıyorum. Türü Su a tek bir eleman daha a ve kullanıyoruz o tür değişkenleri altında bir cilt, Ze olarak yeni bir bağımlı değişken ve Su x olmak kaymıştır temsil eski serbest değişken x.

Combinators için Şartlar çevriliyor

Bu iş, her zamanki çeviri konusunda bilgi sahibidirsek soyutlama.

tm :: Tm a -> Unty a
tm (Var a)    = V a
tm (Lam _ b)  = bra (tm b)
tm (f :$ a)   = tm f :. tm a
tm (Pi a b)   = C P :. tm a :. tm b
tm Set        = C U

bra :: Unty (Su a) -> Unty a               -- binds a variable, building a function
bra (V Ze)      = C S :. C K :. C K        -- the variable itself yields the identity
bra (V (Su x))  = C K :. V x               -- free variables become constants
bra (C c)       = C K :. C c               -- combinators become constant
bra (f :. a)    = C S :. bra f :. bra a    -- S is exactly lifted application

Bu Combinators yazarak

Çeviri bize çeşitleri ne olması gerektiği hakkında çok ipucu verir combinators, kullandığımız yol gösterir. U P sadece kurucular ayarlayın, untranslated türleri yazılı ve izin "Agda gösterimi" Pi için yapmalıyız

U : Set
P : (A : Set) -> (B : (a : A) -> Set) -> Set

K kombinatorik başka tür G üzerinde sürekli bir fonksiyon için 43* *bazı tür bir değeri kaldırmak için kullanılır.

  G : Set   A : Set
-------------------------------
  K : (a : A) -> (g : G) -> A

S kombinatorik üzerine tüm parçaların bağlı olabilir, bir tür uygulamaları kaldırmak için kullanılır.

  G : Set
  A : (g : G) -> Set
  B : (g : G) -> (a : A g) -> Set
----------------------------------------------------
  S : (f : (g : G) ->    (a : A g) -> B g a   ) ->
      (a : (g : G) ->    A g                  ) ->
           (g : G) ->    B g (a g)

S, türü bakarsanız tam olarak bildiren göreceksinizcontextualiseduygulama tipi teorisinin kural, bu uygun bir uygulama inşa yansıtacak şekilde yapıyor. Bu onun işi!

Biz o zaman sadece kapalı şeyler için bir uygulama var

  f : Pi A B
  a : A
--------------
  f a : B a

Ama bir sorun var. Sıradan bir tip, teoride combinators, kombinatoriyel türü teori değil türlerini yazdım. Neyse ki, çeviri yapacak bir makine var.

Kombinatoriyel Tür Bir Sistem

---------
  U : U

---------------------------------------------------------
  P : PU(S(S(KP)(S(S(KP)(SKK))(S(KK)(KU))))(S(KK)(KU)))

  G : U
  A : U
-----------------------------------------
  K : P[A](S(S(KP)(K[G]))(S(KK)(K[A])))

  G : U
  A : P[G](KU)
  B : P[G](S(S(KP)(S(K[A])(SKK)))(S(KK)(KU)))
--------------------------------------------------------------------------------------
  S : P(P[G](S(S(KP)(S(K[A])(SKK)))(S(S(KS)(S(S(KS)(S(KK)(K[B])))(S(KK)(SKK))))
      (S(S(KS)(KK))(KK)))))(S(S(KP)(S(S(KP)(K[G]))(S(S(KS)(S(KK)(K[A])))
      (S(S(KS)(KK))(KK)))))(S(S(KS)(S(S(KS)(S(KK)(KP)))(S(KK)(K[G]))))
      (S(S(KS)(S(S(KS)(S(KK)(KS)))(S(S(KS)(S(S(KS)(S(KK)(KS)))
      (S(S(KS)(S(KK)(KK)))(S(KK)(K[B])))))(S(S(KS)(S(S(KS)(S(KK)(KS)))(S(KK)(KK))))
      (S(KK)(KK))))))(S(S(KS)(S(S(KS)(S(KK)(KS)))(S(S(KS)(S(KK)(KK)))
      (S(S(KS)(KK))(KK)))))(S(S(KS)(S(S(KS)(S(KK)(KS)))(S(KK)(KK))))(S(KK)(KK)))))))

  M : A   B : U
----------------- A ={norm} B
  M : B

İşte buyrun, tüm okunamayan zafer: Set:Set kombinatoriyel bir sunum!

Hala bir sorun var. Sistem sözdizimi K açısından sadece S ve benzer G, A ve B parametreleri tahmin etmeye imkan verir. Buna bağlı olarak, teyit edebilirizyazarak elde edilmelerialgoritmik, ama sadece orijinal sistem ile mümkün olduğunca kombinatorik açısından typecheck edemeyiz. İşe yarayabilecek ne typechecker giriş S ve K kullanır tür ek açıklamaları, etkili türetme kayıt ayı gerektirir. Ama solucanlar bir kutu

Bu başlangıç için oldukça şık oldum durdurmak için iyi bir yerdir. Gerisi "perde" şeyler. arkasında

Bu Combinators Türleri oluşturuluyor

Bu kombinatoriyel türleri ilgili tip teorisi parantez soyutlama çeviri terimleri kullanarak oluşturdum. Nasıl yaptığımı göstermek ve bu yazı tamamen anlamsız değil, o benim ekipman önereyim.

Aşağıdaki gibi combinators, tamamen kendi parametreleri içinde soyutlanmış, türleri yazabilirim. Pi ve lambda birleştiren pil kullanışlı benim işlevi, etki alanı türü tekrarlamaktan kaçınmak için yapıyorum ve oldukça yardımsever bana bind değişkenleri için Haskell'ın fonksiyon alanı kullanmak için izin verir. Belki de aşağıdaki okuyabilirsiniz neredeyse!

pTy :: Tm a
pTy = fmap magic $
  pil Set $ \ _A -> pil (pil _A $ \ _ -> Set) $ \ _B -> Set

kTy :: Tm a
kTy = fmap magic $
  pil Set $ \ _G -> pil Set $ \ _A -> pil _A $ \ a -> pil _G $ \ g -> _A

sTy :: Tm a
sTy = fmap magic $
  pil Set $ \ _G ->
  pil (pil _G $ \ g -> Set) $ \ _A ->
  pil (pil _G $ \ g -> pil (_A :$ g) $ \ _ -> Set) $ \ _B ->
  pil (pil _G $ \ g -> pil (_A :$ g) $ \ a -> _B :$ g :$ a) $ \ f ->
  pil (pil _G $ \ g -> _A :$ g) $ \ a ->
  pil _G $ \ g -> _B :$ g :$ (a :$ g)

Bu tanımlı ile ilgili elde ettimaçınsubterms ve çeviri denedik.

De Bruijn Kodlama bir Araç

pil inşa etmek. Öncelikle, ben Finite setleri, değişkenler için kullanılan bir sınıf tanımlayın. Her böyle ayarlanmış bir kurucu-koruma embedding içine set üstünde, artı yeni top öğesi, ve sen-ebilmek söylemek onları ayrı: embd fonksiyon size, eğer bir değer görüntünün emb.

class Fin x where
  top :: Su x
  emb :: x -> Su x
  embd :: Su x -> Maybe x

, Ze Fin Suc oluşturmak tabii ki mümkün

instance Fin Ze where
  top = Ze              -- Ze is the only, so the highest
  emb = magic
  embd _ = Nothing      -- there was nothing to embed

instance Fin x => Fin (Su x) where
  top = Su top          -- the highest is one higher
  emb Ze     = Ze            -- emb preserves Ze
  emb (Su x) = Su (emb x)    -- and Su
  embd Ze      = Just Ze           -- Ze is definitely embedded
  embd (Su x)  = fmap Su (embd x)  -- otherwise, wait and see

Şimdi bir daha-veya-eşittir tanımlayabilirim, bir ilezayıflamasıoperasyon.

class (Fin x, Fin y) => Le x y where
  wk :: x -> y

wk işlevi x öğeleri gömmek gerekiren büyüky 73 *ekstra şeyler o kadar elemanları daha küçük, ve böylece de Bruijn Endeksi açısından, daha yerel olarak bağlı.

instance Fin y => Le Ze y where
  wk = magic    -- nothing to embed

instance Le x y => Le (Su x) (Su y) where
  wk x = case embd x of
    Nothing  -> top          -- top maps to top
    Just y   -> emb (wk y)   -- embedded gets weakened and embedded

Ve bu dizildi var sonra, rütbe-n skullduggery biraz rest.

lam :: forall x. Tm x -> ((forall y. Le (Su x) y => Tm y) -> Tm (Su x)) -> Tm x
lam s f = Lam s (f (Var (wk (Ze :: Su x))))
pil :: forall x. Tm x -> ((forall y . Le (Su x) y => Tm y) -> Tm (Su x)) -> Tm x
pil s f = Pi s (lam s f)

-Sipariş yüksek fonksiyon sadece bir terim değişkeni temsil eden vermez, sana bir şey veriraşırı yüklühangi şey değişken görünür olduğu herhangi bir kapsam değişken gösterimini doğru olur. Yani, farklı kapsamları ayırt bela gidiyorum aslındaTürüne göreHaskell kayması hesaplamak için yeterli bilgi de Bruijn temsil çeviri için gerekli typechecker verir. Neden bir köpek tutmak ve kendinizi bark?