Bir C uygulamasının maksimum hesaplama gücü

Kitabın önüne geçersek (veya tercih ederseniz dil spesifikasyonunun herhangi bir versiyonunu kullanırsak), bir C uygulamasının ne kadar hesaplama gücü olabilir?

“C uygulaması” nın teknik bir anlamı olduğunu unutmayın: Uygulama-tanımlanmış davranışın belgelendiği C programlama dili spesifikasyonunun özel bir örneğidir. AC uygulamasının gerçek bir bilgisayarda çalışabilmesi gerekmez. Bit-dizili bir temsili olan her nesne ve uygulama-tanımlı boyutta olan türler dahil olmak üzere, tüm dili uygulamak zorundadır.

Bu sorunun amacı için harici depolama yoktur. Yapabileceğiniz tek giriş / çıkış getchar(program girişini okumak için) ve putchar(program çıkışını yazmak için) 'dir. Ayrıca tanımsız davranışı çağıran herhangi bir program geçersizdir: geçerli bir program, C belirtimi ile tanımlanmış davranışı artı uygulamanın Ek J'de listelenen uygulama tanımlı davranışları tanımlamasıyla tanımlamalıdır (C99 için). Standartta belirtilmeyen çağıran kütüphane işlevlerinin tanımsız davranış olduğunu unutmayın.

İlk tepkim, bir C uygulamasının sonlu bir otomattan başka bir şey olmamasıydı, çünkü adreslenebilir bellek miktarını sınırlandırıyordu sizeof(char*) * CHAR_BIT(depolanan bitlerden daha fazlasını ele alamazsınız , çünkü farklı bellek adreslerinin depolandığında farklı bit desenleri olması gerekir) bir bayt işaretçisinde).

Ancak bir uygulamanın bundan daha fazlasını yapabileceğini düşünüyorum. Söyleyebileceğim kadarıyla, standart özyinelemenin derinliğine sınır koymuyor. Böylece istediğiniz kadar özyinelemeli işlev çağrısı yapabilirsiniz, ancak sınırlı sayıda çağrı yalnızca adreslenebilir olmayan ( register) argümanları kullanmalıdır. Böylece, keyfi tekrarlama sağlayan ve registernesne sayısını sınırlamayan bir C uygulaması deterministik aşağı itme otomatlarını kodlayabilir.

Bu doğru mu? Daha güçlü bir C uygulaması bulabilir misiniz? Bir Turing tamamlandı C uygulaması var mı?

Soruda belirtildiği gibi, standart C, her tür değişkenin unsigned chardaima 0 ile UCHAR_MAX arasında bir değer tutacağı şekilde bir UCHAR_MAX değeri olmasını gerektirir . Ayrıca, dinamik olarak tahsis edilen her nesnenin, bir tip gösterici vasıtasıyla tanımlanabilen bir bayt dizisi ile temsil edilmesini unsigned char*ve bu tipteki sizeof(unsigned char*)her göstericinin tip sizeof(unsigned char *)değerleri dizisi ile tanımlanabileceği bir sabit olmasını gerektirir unsigned char. Eş zamanlı olarak dinamik, böylece katı sınırlıdır tahsis edilebilir nesne sayısı . Hiçbir şey bu kadar fazla destek olarak bu sabitlerin değerleri atamak gelen teorik derleyici önleyecek 10 10 10 nesneler, ancak teorik bir perspektiften herhangi varlığı büyük, araçlar şey sonsuz değildir, nasıl olursa olsun bağlanmış.$UCHAR\_MAX ^{sizeof(unsigned\ char*)}$$10^{10^{10}}$

Bir program, yığında tahsis edilen hiçbir şey adresi alınmamışsa, yığın üzerinde sınırsız miktarda bilgi depolayabilir ; Böylece, herhangi bir boyuttaki sonlu otomatlar tarafından yapılamayan bazı şeyleri yapabilen bir C programı olabilir. Bu nedenle, yığın değişkenlerine erişim (veya belki de nedeniyle), dinamik olarak tahsis edilmiş değişkenlere erişimden çok daha sınırlı olsa da, C'yi sonlu bir otomat olmaktan, bir basma otomatına çevirir.

Bununla birlikte, başka bir potansiyel kırışıklık vardır: eğer bir program iki işaretçi ile ilişkili sabit uzunluktaki karakter dizilerini farklı nesnelere incelerse, bu dizilerin benzersiz olması gerekir. Sadece olduğundan $UCHAR\_MAX ^{sizeof(unsigned\ char*)}$karakter değerlerinin muhtemel dizileri, herhangi bir nesneyi aşmak için çok sayıda işaretçi oluşturan herhangi bir program, kodun bu işaretçilerle ilişkili karakterlerin sırasını incelemesi halinde C standardına uymayacaktı . Bununla birlikte, bazı durumlarda bir derleyicinin hiçbir kodun bir imleçle ilişkili karakter sırasını inceleyemeyeceğini belirlemesi mümkün olabilir. Her "karakter" aslında herhangi bir sonlu tamsayıyı tutabilmişse ve makinenin hafızası sayısız tam sayıdaki bir dizilim [sınırsız bant Turing makinesi verildiğinde, gerçekten yavaş olmasına rağmen böyle bir makineyi taklit edebilir ], o zaman C'yi Turing-eksiksiz bir dil yapmak gerçekten mümkün olabilirdi.

C11'in (isteğe bağlı) iş parçacığı kitaplığıyla, sınırsız özyineleme derinliği verilen bir Turing uygulamasının tamamlanması mümkündür.

Yeni bir iş parçacığı oluşturmak, ikinci bir yığın oluşturur; Turing'in eksiksiz olması için iki istif yeterlidir. Bir yığın başın solunda, diğer yığın sağda olanı temsil eder.

Bence Turing tamamlandı : Bu numarayı kullanarak UTM'yi simüle eden bir program yazabiliriz (Kodu el ile hızlı bir şekilde yazdım, bu yüzden muhtemelen bazı sözdizimi hataları olabilir ... ama umarım mantıkta hiçbir büyük hata yoktur. :-)

• Bant gösterimi için çift bağlantılı bir liste olarak kullanılabilecek bir yapı tanımlayabilir.

    typdef struct {
      cell_t * pred; // soldaki hücre
      cell_t * succ; // sağdaki hücre
      int val; // hücre değeri
    } cell_t 

headBir için bir işaretçi olacak cell_tyapı

• Mevcut durumu ve bayrağı depolamak için kullanılabilecek bir yapı tanımlayabilir.

    typedef yapı {
      int devlet;
      int flag;
    } info_t 

• daha sonra, kafa çift bağlantılı listenin sınırları arasındayken bir Universal TM'yi simüle eden tek bir döngü fonksiyonu tanımlayın; baş bir sınıra çarptığında info_t yapısının (HIT_LEFT, HIT_RIGHT) bayrağını ayarlayın ve geri dönün:

geçersiz simulate_UTM (cell_t * head, info_t * info) {
  while (true) {
    head-> val = UTM_nextsymbol [info-> durum, head-> val]; // sembol yaz
    info-> state = UTM_nextstate [bilgi-> durum, baş-> val]; // sonraki durum
    if (info-> state == HALT_STATE) {// kabul ederse yazdır ve programdan çık
       putchar ((bilgi-> durum == ACCEPT_STATE)? '1': '0');
       çıkış (0);
    }
    int move = UTM_nextmove [info-> durum, head-> val];
    eğer (hareket == MOVE_LEFT) {
      head = head-> pred; // Sola hareket et
      if (head == NULL) {info-> flag = HIT_LEFT; dönüş; }
    } Başka {
      head = head-> succ; // sağa hareket et
      if (head == NULL) {info-> flag = HIT_RIGHT; dönüş; }
    }
  } // hala sınırda ... devam et
}

• daha sonra önce simülasyon UTM rutini çağıran ve daha sonra teyp genişletilmesi gerektiğinde kendisini tekrar eden çağıran özyinelemeli bir işlev tanımlayın; bandın üst kısımda genişletilmesi gerektiğinde (HIT_RIGHT) hiç sorun çıkarmaz, alttan kaydırılması gerektiğinde (HIT_LEFT) sadece çift bağlantılı listeyi kullanarak hücrelerin değerlerini yükseltirsiniz:

boşluk istifleyici (cell_t * top, cell_t * alt, cell_t * kafa, info_t * info) {
  simulate_UTM (kafa, bilgi);
  cell_t newcell; // yeni hücre
  newcell.pred = üst; // çift bağlantılı listeyi yeni hücreyle güncelle
  newcell.succ = NULL;
  top-> succ = & newcell;
  newcell.val = EMPTY_SYMBOL;

  anahtarı (info-> hit) {
    vaka HIT_RIGHT:
      istifleyici (& newcell, alt, newcell, bilgi);
      break;
    vaka HIT_BOTTOM:
      cell_t * tmp = newcell;
      while (tmp-> pred! = NULL) {// değerleri yükseltir
        tmp-> val = tmp-> pred-> val;
        tmp = tmp-> pred;
      }
      tmp-> val = EMPTY_SYMBOL;
      istifleyici (& newcell, alt, alt, bilgi);
      break;
  }
}

• İlk bant çift bağlantılı listeyi oluşturan basit bir özyinelemeli fonksiyonla doldurulabilir ve daha sonra stackergiriş bandının son sembolünü okuduğunda fonksiyonu çağırır (readchar kullanarak).

void init_tape (hücre_t * üst, hücre_t * alt, info_t * bilgi) {
  cell_t newcell;
  int c = readchar ();
  eğer (c == END_OF_INPUT) istifleyici (& üst, alt, alt, bilgi); // daha fazla sembol yok, başla
  newcell.pred = üst;
  if (top! = NULL) top.succ = & newcell; başka alt = & newcell;
  init_tape (& newcell, alt, bilgi);
}

EDIT: biraz düşündükten sonra, işaretçilerle ilgili bir sorun var ...

özyinelemeli işlevin her çağrısı, stackerarayanda yerel olarak tanımlanmış bir değişkene geçerli bir gösterici tutabilirse, her şey yolundadır ; Aksi halde algoritmam sınırsız özyinelemede geçerli çift bağlantılı bir liste tutamaz (ve bu durumda özyinelemeyi sınırsız rastgele erişimli depolamayı simüle etmek için kullanmanın bir yolunu göremezsiniz).

Sınırlandırılmamış bir çağrı yığını boyutunuz olduğu sürece, bantınızı çağrı yığınında kodlayabilir ve işlev çağrılarından geri dönmeden yığın işaretçisini geri sararak rastgele erişebilirsiniz.

EDIT : Sadece sonlu olan tokmağı kullanabiliyorsanız, bu yapı artık çalışmaz, bu nedenle aşağıya bakın.

Ancak yığınınızın neden sonsuz olabileceğine dair son derece tartışmalı ama içsel ram değil. Bu yüzden aslında devletlerin sayısı sınırlı olduğu için bütün düzenli dilleri bile tanıyamadığınızı söyleyebilirim (sonsuz yığını kullanmak için yığın-geri sarma numarasını saymazsanız).

Hatta tanıyabileceğiniz dil sayısının sınırlı olduğunu bile söyleyebilirim (dillerin kendisi sınırsız olsa bile, örneğin a*tamamdır, ancak b^kyalnızca sınırlı sayıda ks için çalışır ).

EDIT : Mevcut durumu ekstra fonksiyonlarda kodlayabildiğiniz için bu doğru değildir, böylece TÜM normal dilleri gerçekten tanıyabilirsiniz .

Büyük olasılıkla tüm Tip-2 dillerini aynı nedenden ötürü alabilirsiniz, ancak hem durumu hem de yığın tutarlılığını çağrı yığınına koyabildiğinizden emin değilim . Ancak genel bir notta, her zaman otomat boyutunu ölçekleyebildiğiniz için, koçu etkin bir şekilde unutabilirsiniz; Öyleyse bir TM'yi sadece bir yığınla simüle edebilseydiniz, Tip-2, Tip-0'a eşit olurdu, değil mi?

Bunu bir kez düşündüm ve beklenen anlambilim kullanarak bağlamsız bir dili uygulamaya çalışmaya karar verdim; uygulamanın kilit kısmı aşağıdaki fonksiyondur:

void *it;

void read_triple(void *back)
{
  if(read_a()) read_triple(&back);
  else reject();
  for(it = back; it != NULL; it = *it)
     if(!read_b()) reject();
  if(read_c()) return;
  else reject();
}

$\{a^n b^n c^n\}$

En azından, bunun işe yaradığını düşünüyorum. Yine de bazı temel hatalar yapıyorum olabilir.

Sabit bir versiyon:

void *it;

void read_triple(void *back)
{
  if(read_a()) read_triple(&back);
  else for(it = back; it != NULL; it = * (void **) it)
     if(!read_b()) reject();
  if(read_c()) return;
  else reject();
}

@ Supercat'ın cevabının satırları boyunca:

C'nin eksik olduğu iddiası, farklı nesnelerin farklı adreslere sahip olması gerektiği ve merkezlerin adreslerinin sınırlı olduğu varsayımı etrafında toplanmış gibi görünmektedir. @Supercat'in yazdığı gibi

Soruda belirtildiği gibi, standart C, UCHAR_MAXimzasız char türündeki her değişkenin her zaman 0 ile UCHAR_MAXkapsayıcı arasında bir değer tutacağı bir değer olmasını gerektirir . Ayrıca, dinamik olarak tahsis edilen her nesnenin, imzasız char * tipinde bir işaretçi ile tanımlanabilen bir bayt dizisi ile temsil edilmesini sizeof(unsigned char*)ve bu tipteki her ibrenin sizeof(unsigned char *)işaretsiz tipteki bir değerler dizisi ile tanımlanabileceği bir sabit olmasını gerektirir . Char.

unsigned char*$\mathbb{N}$$\{0, 1\}$sizeof(unsigned char*)$\{0, 1\}^{\operatorname{sizeof}(\mathit{unsigned\ char*})}$$\mathbb{N}$sizeof(unsigned char*)$\mathbb{N}$$\omega$ isterseniz).

Bu noktada, bir kişi C standardının gerçekten buna izin verdiğini kontrol etmelidir.

sizeof$\in \mathbb Z$