Eğer bir şey basitse, o zaman birkaç kelimeyle tamamen açıklanmalıdır. Bu λ-calculus için yapılabilir:

Cal hesabı, azaltma kuralına sahip bir sözdizimsel dilbilgisidir (temel olarak bir yapı) (yani, bu tür bir düzen bulunmayana kadar belirli bir desenin her oluşumuna bir arama / değiştirme prosedürü tekrar tekrar uygulanır).

Dilbilgisi:

Term = (Term Term) | (λ Var . Term) | Var

Azaltma kuralı:

((λ var body) term) -> SUBS(body,var,term)
    where `SUBS` replaces all occurrences of `var`
    by `term` in `body`, avoiding name capture.

Örnekler:

(λ a . a)                             -> (λ a a)
((λ a . (λ b . (b a))) (λ x . x))     -> (λ b . (b (λ x x)))
((λ a . (a a)) (λ x . x))             -> (λ x . x)
((λ a . (λ b . ((b a) a))) (λ x . x)) -> (λ b . ((b (λ x . x)) (λ x . x)))
((λ x . (x x)) (λ x . (x x)))         -> never halts

Bir şekilde gayrı resmi olsa da, bunun normal bir insan için-hesabı hesaplamasını bir bütün olarak anlayabilmesi için yeterince bilgilendirici olduğu söylenebilir - ve bu 22 satırlık bir işaretleme gerektirir. Idris / Agda ve benzeri projeler tarafından kullanılan saf / bağımlı tip sistemleri anlamaya çalışıyorum , ancak bulabildiğim kısa açıklama Basitçe Kolaydı - harika bir makale, ancak bu daha önce birçok bilgiyi varsayar (Haskell, endüktif tanımları) bende yok. Daha az zengin, daha az zengin bir şeyin bu engelleri ortadan kaldırabileceğini düşünüyorum. Böylece,

Yukarıda λ-calculus'u sunduğum biçimde, saf / bağımlı tip sistemler hakkında kısa ve eksiksiz bir açıklama yapmak mümkün müdür?

feragat

İstediğiniz gibi bu çok gayrı resmi.

Gramer

Bağımlı olarak yazılmış bir dilde, tür düzeyinde ve değer düzeyinde bir ciltleyicimiz vardır:

Term = * | (∀ (Var : Term). Term) | (Term Term) | (λ Var. Term) | Var

İyi yazılmış terim, ekli türden bir terimdir, yazacağız t ∈ σveya

σ
t

terim olduğunu belirtmek için ttürü vardır σ.

Yazma kuralları

Basitlik uğruna λ v. t ∈ ∀ (v : σ). τher ikisinde de aynı değişkene ihtiyacımız var λve bu ∀değişkeni aynı vdurumda bağlarız.

Kurallar:

t ∈ σ is well-formed if σ ∈ * and t is in normal form (0)

*            ∈ *                                                 (1)
∀ (v : σ). τ ∈ *             -: σ ∈ *, τ ∈ *                     (2)
λ v. t       ∈ ∀ (v : σ). τ  -: t ∈ τ                            (3)
f x          ∈ SUBS(τ, v, x) -: f ∈ ∀ (v : σ). τ, x ∈ σ          (4)
v            ∈ σ             -: v was introduced by ∀ (v : σ). τ (5)

Bu nedenle, *"her türlü tipi" (1) olup, ∀tip (2), lambda soyutlamalardan formları türleri pi-tipleri (3) ve varsa vile sokulur ∀ (v : σ). τ, daha sonra vtürü vardır σ(5).

"normal formda", azaltma kuralını kullanarak mümkün olduğunca fazla azaltma yaptığımız anlamına gelir:

"" "İndirim kuralı

(λ v. b ∈ ∀ (v : σ). τ) (t ∈ σ) ~> SUBS(b, v, t) ∈ SUBS(τ, v, t)
    where `SUBS` replaces all occurrences of `v`
    by `t` in `τ` and `b`, avoiding name capture.

Veya iki boyutlu sözdiziminde

σ
t

anlamı t ∈ σ:

(∀ (v : σ). τ) σ    SUBS(τ, v, t)
                 ~>
(λ  v     . b) t    SUBS(b, v, t)

Bir terimi bir lambda soyutlamasının, bir terim ilişkili forall niceleyicideki değişkenle aynı tipte olduğu zaman uygulamak mümkündür. Daha sonra hem lambda soyutlamasını hem de forall niceleyicisini daha önce saf lambda hesabındakiyle aynı şekilde azaltırız. Değer seviyesi kısmını çıkardıktan sonra (4) yazım kuralını elde ederiz.

Bir örnek

İşte fonksiyon uygulama operatörü:

∀ (A : *) (B : A -> *) (f : ∀ (y : A). B y) (x : A). B x
λ  A       B            f                    x     . f x

(biz kısaltmak ∀ (x : σ). τiçin σ -> τeğer τsöz etmez x)

fdöner B ybir öngörülen yÇeşidi A. Biz uygulamak fiçin xdoğru cins olan Ave yerine yilişkin xde ∀sonrasÖ .böylece f x ∈ SUBS(B y, y, x)~> f x ∈ B x.

Şimdi işlev uygulama operatörünü kısaltalım appve bunu kendimize uygulayalım:

∀ (A : *) (B : A -> *). ?
λ  A       B          . app ? ? (app A B)

?Sağlamamız gereken şartlara yer veriyorum. Öncelikle açıkça tanıtmak ve örneklemek Ave B:

∀ (f : ∀ (y : A). B y) (x : A). B x
app A B

Şimdi sahip olduklarımızı birleştirmeliyiz

∀ (f : ∀ (y : A). B y) (x : A). B x

hangisi aynı

(∀ (y : A). B y) -> ∀ (x : A). B x

ve ne app ? ?alır

∀ (x : A'). B' x

Bu sonuçlanır

A' ~ ∀ (y : A). B y
B' ~ λ _. ∀ (x : A). B x -- B' ignores its argument

(ayrıca bkz. Tahmini nedir? )

İfademiz (bazı adlandırmalardan sonra)

∀ (A : *) (B : A -> *). ?
λ  A       B          . app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) (app A B)

Herhangi yana A, Bve f(burada f ∈ ∀ (y : A). B y)

∀ (y : A). B y
app A B f

somutlaştırabilir Ave Belde edebiliriz ( fuygun türdeki herhangi biri için)

∀ (y : ∀ (x : A). B x). ∀ (x : A). B x
app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) f

ve tür imzası eşittir (∀ (x : A). B x) -> ∀ (x : A). B x.

Tüm ifade

∀ (A : *) (B : A -> *). (∀ (x : A). B x) -> ∀ (x : A). B x
λ  A       B          . app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) (app A B)

yani

∀ (A : *) (B : A -> *) (f : ∀ (x : A). B x) (x : A). B x
λ  A       B            f                    x     .
    app (∀ (x : A). B x) (λ _. ∀ (x : A). B x) (app A B) f x

Bu değer seviyesindeki tüm düşüşlerden sonra aynı şeyi appgeri verir .

O olsun saf lambda hesabi sadece birkaç adım gerektirir Yani süre appgelen app appbir Yazılan ortamda, biz de birleşme önemsemelisin ve işler hatta bazı tutarsız kolaylık (ile daha karmaşık hale (ve özellikle bir bağımlı daktilo) * ∈ *).

Kontrol türü

• Eğer tbir *daha sonra t ∈ *(1)
• Eğer tbir ∀ (x : σ) τ, σ ∈? *, τ ∈? *(yaklaşık nota bakın ∈?aşağıda) daha sonra t ∈ *(2) tarafından
• Eğer tolduğu f x, f ∈ ∀ (v : σ) τbazıları için σve τ, x ∈? σdaha sonra t ∈ SUBS(τ, v, x)tarafından (4)
• Eğer tbir değişkendir v, vtarafından tanıtılan ∀ (v : σ). τsonra t ∈ σ(5)

Bunların hepsi çıkarım kurallarıdır, ancak lambdalar için aynı şeyi yapamayız (tür çıkarımı bağımlı türler için kararsızdır). Bu nedenle, lambdalar için t ∈? σçıkarımdan ziyade kontrol ederiz ( ):

• Eğer tedilir λ v. bve karşı kontrol ∀ (v : σ) τ, b ∈? τdaha sonrat ∈ ∀ (v : σ) τ
• Başka tbir şey varsa ve kontrol edildiyse , yukarıdaki işlevi kullanmanın σtürünü yazın tve olup olmadığını kontrol edin.σ

Türleri için kontrol Eşitlik yüzden karar vermek normal formlarda olmalarını gerektirir ttip vardır σİlk kontrolü σtürüne sahip *. Öyleyse σ, normalleştirilebilir (modulo Girard'ın paradoksu) ve normalleşir (dolayısıyla σ(0) ile iyi biçimlendirilir). SUBSayrıca korumak için ifadeleri normalleştirir (0).

Buna çift yönlü tip kontrolü denir. Bununla birlikte, her lambdaya bir tür ek açıklama eklememiz gerekmez: eğer f xtüründe fbiliniyorsa, o zaman çıkarılan ve eşitlik için karşılaştırılmış olmak yerine xalınan argüman türüne karşı kontrol edilir f(aynı zamanda daha az verimlidir). Fakat eğer fbir lambda ise , açık bir tür ek açıklama gerektirir (ek açıklamalar gramerde ve her yerde atlanır, eklenebilir Ann Term Termveya λ' (σ : Term) (v : Var)yapıcılara eklenebilir ).

Ayrıca, daha basit, daha kolay bir göz atın ! Blog yazısı.

Hadi gidelim. Girard'ın paradoksunu rahatsız etmeyeceğim, çünkü merkezi fikirlerden rahatsız ediyor. Yargılamalar ve türevlerle ilgili bazı sunum makinelerini tanıtmam gerekecek.

Dilbilgisi

Terim :: = (Elim) | * | (Var: Terim) → Terim | λVar↦Term

Elim :: = Dönem: Dönem | Var | Elim Terimi

Dilbilgisi, karşılıklı olarak tanımlanmış iki biçime sahiptir: * (türlerin türü), bağımlı fonksiyon türlerinin ve lambda-soyutlamaların dahil olduğu genel kavram ("şeyler", "şeyler", "terimler") Sonuçta fonksiyon pozisyonunda olan şeyin değişken veya türü ile açıklamalı bir terim olduğu iç içe geçmiş uygulamalardır.

Azaltma Kuralları

(:y xt: (x: S) → T) s ↝ t [s: S / y]: T [s: S / x]

(t: T)

İkame işlemi t [e / x], x değişkeninin her oluşumunu, elemenin önlenmesiyle değiştirir ve ad yakalamayı önler. Düşürebilecek bir uygulama oluşturmak için, bir lambda terimi türünün kaldırılması için türüne göre belirtilmelidir . Tip ek açıklaması lambda-soyutlamasına bir çeşit "reaktivite" verir ve uygulamanın ilerlemesini sağlar. Başka uygulamanın olmadığı ve aktif t: T'nin sözdizimi terimine gömülmekte olduğu noktaya ulaştığımızda, tür ek açıklamasını düşürebiliriz.

↝ İndirgeme ilişkisini yapısal kapatma ile uzatalım: Kurallar, terimler ve her yerde sol tarafla eşleşen bir şey bulabileceğiniz elemeler için geçerlidir. ↝ 'in dönüşlü geçişli (0 veya daha fazla adım) kapanması için ↝ * yazın. Ortaya çıkan indirgeme sistemi bu anlamda birleştiğinde:

Eğer s ↝ * p ve s ↝ * q ise, p p * r ve q ↝ * r olacak şekilde r vardır.

Bağlam

Bağlam :: = | Bağlam, Var: Terim

Bağlamlar, değişkenlere türler atayan, sağda büyüyen, "yerel" uç olarak düşündüğümüz, bize en son bağlanan değişkenleri anlatan dizilerdir. Bağlamların önemli bir özelliği, bağlamda kullanılmamış bir değişkeni seçmenin daima mümkün olmasıdır. Değişkenleri, bağlamda atfedilen değişkenlerin farklı olduğu konusunda koruruz.

Kararlar

Yargı :: = Bağlam ⊢ Terim Vade | Bağlam ⊢ Elim Terimdir

Bu, kararların dilbilgisidir, ama nasıl okunur? Başlangıç ​​için ⊢, varsayımları sonuçlardan ayıran geleneksel "turnike" sembolüdür: resmi olmayan bir şekilde "söylediği gibi" okuyabilirsiniz.

G ⊢ T var

G bağlamında, T türünün t terimini kabul ettiği anlamına gelir;

G ⊢ e S

G bağlamında, E'ye e türünün verildiğini belirtir.

Yargılamalar ilginç bir yapıya sahiptir: sıfır veya daha fazla girdi , bir veya daha fazla konu , sıfır veya daha fazla çıktı .

INPUTS                   SUBJECT        OUTPUTS
Context |- Term   has    Term
Context |-               Elim      is   Term

Yani, terim türlerini önceden teklif etmeli ve sadece onları kontrol etmeliyiz, ancak eleme türlerini sentezleriz .

Yazma Kuralları

Bunları belli belirsiz bir Prolog tarzında sunuyorum, J -: P1; ...; Pn, P1'den Pn'ye kadar olan binaların da geçerli olması durumunda, J kararının geçerli olduğunu belirtmek için. Bir öncül başka bir yargı veya azaltma konusunda bir iddia olacaktır.

şartlar

G ⊢ T, t -: T ↝ R; G ⊢ R

G ⊢ * vardır *

G ⊢ * var (x: S) → T -: G ⊢ * S; G, z: S! - * T [z / x] değerine sahiptir

G ⊢ (x: S) → T değeri :yt -: G, z: S ⊢ T [z / x] değeri t [z / y]

G ⊢ T var (e) -: G ⊢ e T

Eliminasyon

G ⊢ e R -: G G e S; S ↝ R

G, x: S, G 'xx S

G ⊢ fs, T [s: S / x] -: G ⊢ f'dir (x: S) → T; G ⊢ S

Ve bu kadar!

Yalnızca iki kural sözdizimine yönelik değildir : "bir terimi kontrol etmek için kullanmadan önce bir türü azaltabilirsiniz" diyen kural ve "bir elemeden sentezledikten sonra bir türü azaltabilirsiniz" yazan kural. Uygulanabilir stratejilerden biri, en üst yapıcıyı gösterene kadar türleri azaltmaktır.

Bu sistem güçlü bir şekilde normalleşmiyor (kendi kendine referansın yalancı tarzı bir paradoksu olan Girard'ın Paradoksundan dolayı), ancak * düşük seviyelerde türleri içeren herhangi bir değerin kendisini içerdiği "evren seviyelerine" bölünerek güçlü şekilde normalleştirilebilir. Kendi kendine referansı önleyen tipler daha yüksek seviyelerdedir.

Bununla birlikte, bu sistem bu anlamda bir tür koruma özelliğine sahiptir.

Eğer G ⊢ T t ve G ↝ * D ve T ↝ * R ve t ↝ r ise, o zaman D ⊢ R vardır.

Eğer G ⊢ e S ve G ↝ * D ve e ↝ f ise, o zaman S ↝ * R ve D R. f R olacak şekilde R vardır.

Bağlamlar, içerdikleri terimleri hesaplamaya izin vererek hesaplayabilir. Yani, eğer bir yargılama şimdi geçerliyse, girdilerini istediğiniz kadar ve konusunu bir adımda hesaplayabilirsiniz ve sonuçta ortaya çıkan kararın geçerli kaldığından emin olmak için çıktılarını bir şekilde hesaplamak mümkün olacaktır. Kanıt, -> * 'nın birleştiğinden dolayı, türetme işlemlerinde basit bir indüksiyondur.

Tabii ki, burada sadece işlevsel çekirdeği sundum, ancak uzantılar oldukça modüler olabilir. İşte çiftler.

Terim :: = ... | (x: S) * T | s, t

Elim :: = ... | e.head | e.tail

(s, t: (x: S) * T) .head: s: S

(s, t: (x: S) * T) .tail ↝ t: T [s: S / x]

G * * (x: S) * T -: G * * S; G, z: S ⊢ *, T [z / x] değerine sahiptir

G ⊢ (x: S) * T s, t -: G ⊢ S s; G ⊢ T [s: S / x] değeri t

G ⊢ e.head S -: G ⊢ e (x: S) * T

G ⊢ e.tail, T [e.head / x] -: G ⊢ e (x: S) * T

Curry-Howard yazışmaları mantıkta tip sistemleri ile prova sistemleri arasında sistematik bir yazışma olduğunu söylüyor . Bunun programcı merkezli bir görüntüsünü alarak, şu şekilde yeniden yapabilirsin:

• Mantıksal kanıt sistemleri programlama dilleridir.
• Bu diller statik olarak yazılmıştır.
• Bu tip bir dilde tip sistemin sorumluluğu, sağlam olmayan kanıtlar inşa edecek programları yasaklamaktır.

Bu açıdan bakıldığında:

• Özetlediğiniz yazılmamış lambda hesabı önemli bir tip sisteme sahip değildir, bu yüzden üzerine kurulu ispat sistemi sağlam olmaz.
• Basitçe yazılan lambda hesabı, mantıksal mantıkta ses provaları oluşturmak için gerekli tüm tiplere sahip bir programlama dilidir ("eğer / sonra", "ve", "veya", "değil"). Ancak türleri nicelleştiricileri içeren delilleri kontrol etmek için yeterince iyi değil (“tüm x,…” için; “öyle bir x var ...”).
• Bağımlı olarak yazılan lambda matematiğinin, mantıksal mantığı ve birinci dereceden niceleyicileri değerleri (değerler üzerinden niceleme).

İşte gelen bir diyagram kullanılarak birinci dereceden mantık için doğal kesinti kuralları vardır doğal kesinti Wikipedia girişi . Bunlar temelde asgari derecede bağımlı tipte bir lambda hesabının da kurallarıdır.

Kuralların içinde lambda terimlerinin olduğunu unutmayın. Bunlar, türleriyle temsil edilen cümlelerin ispatlarını oluşturan programlar olarak okunabilir (veya daha kısaca, biz sadece programların ispat ). Verdiğiniz benzer indirgeme kuralları bu lambda terimlerine uygulanabilir.

Bunu neden umursuyoruz? Öncelikle, çünkü provalar programlamada faydalı bir araç olabilir ve birinci sınıf nesneler olarak provalarla çalışabilen bir dilin olması birçok cadde açar. Örneğin, işleviniz bir önkoşul içeriyorsa, yorum olarak yazmak yerine, bir argüman olarak bunun kanıtını isteyebilirsiniz.

İkincisi, niceleyicileri işlemek için gereken tip sistem makinelerinin bir programlama bağlamında başka kullanımları olabilir. Özellikle, bağımlı olarak yazılan diller, evrensel niceleyicileri ("tüm x, ..."), bağımlı işlev türleri olarak adlandırılan bir kavramı kullanarak işler - sonucun statik türünün çalışma zamanı değerine bağlı olabileceği bir işlev , bağımsız değişkenin .

Bunun çok yaya bir uygulamasını vermek için tek tip yapıdaki kayıtlardan oluşan Avro dosyalarını okumak zorunda olan her zaman kod yazıyorum - hepsi aynı alan adlarını ve türlerini paylaşıyor. Bu da beni gerektirir:

1. Programdaki kayıtların yapısını bir kayıt tipi olarak kodlayın.
   • Avantajları: Kod basittir ve derleyici kodumdaki hataları yakalayabilir
   • Dezavantaj: Program, kayıt türüne uygun dosyaları okumak için kodlanmıştır.
2. Çalışma zamanında verilerin şemasını okuyun, veriyi genel olarak veri yapısı olarak gösterin ve kayıtları genel olarak işlemek için kullanın
   • Avantajlar: Programım yalnızca bir dosya türüne kodlanmış değil
   • Dezavantajları: Derleyici kadar hata yakalayamaz.

Avro Java eğitim sayfasında gördüğünüz gibi , kütüphaneyi bu iki yaklaşıma göre nasıl kullanacağınızı gösterirler.

Bağımlı fonksiyon tipleriyle daha karmaşık tip bir sistem pahasına pastanızı alabilir ve yiyebilirsiniz. Bir Avro dosyasını okuyan, şemayı çıkartan ve dosyanın içeriğini , statik türü dosyada depolanan şemaya bağlı olan bir kayıt akışı olarak döndüren bir işlev yazabilirsiniz . Derleyici, örneğin çalışma zamanında işleyeceği dosyaların kayıtlarında bulunmayan adlandırılmış bir alana erişmeye çalıştığım hataları yakalayabilecekti. Tatlı ha?