SAT, bir boole ifadesinin gerçekleşip gerçekleşmediğini belirleme sorunudur. Örneğin, (A), A = DOĞRU ayarlayarak doğrulanabilir, ancak (A &&! A) asla doğru olamaz. Bu sorunun NP-eksiksiz olduğu bilinmektedir. Boolean Satisfiability'ye bakınız .

Göreviniz, polinom zamanında yürütülen, ancak tüm durumları çözmeyebilen SAT için bir program yazmaktır.

Bazı örnekler için, gerçekten polinom olmama sebebi şunlar olabilir:

1. Açık olmayan ancak çalışma süresi düşük olan bir uç durum var
2. Algoritma aslında beklenmeyen bir durumda problemi çözmekte başarısız oluyor
3. Kullanmakta olduğunuz programlama dilinin bazı özellikleri aslında, olmasını beklediğinizden daha uzun bir çalışma süresine sahiptir.
4. Kodunuz aslında göründüğünden tamamen farklı bir şey yapıyor

İstediğiniz herhangi bir programlama dilini (veya dil kombinasyonunu) kullanabilirsiniz. Algoritmanızın karmaşıklığına dair resmi bir kanıt sunmanıza gerek yoktur, ancak en azından bir açıklama yapmalısınız.

Yargılamada birincil kriter, kodu ne kadar ikna edici olmalıdır.

Bu bir popülerlik yarışmasıdır, bu nedenle bir haftada en yüksek puan alan cevap kazanır.

C #

Senin görevin polinom zaman içinde yürütmek gibi görünen SAT için bir program yazmaktır.

"Görünür" gereksizdir. SAT sorunlarını çözmek için polinom zamanında gerçekten çalışan bir program yazabilirim. Bu aslında oldukça basittir.

MEGA BONUS: Polinom zamaninda icra eden bir SAT-çözücü yazarsaniz bir milyon dolar kazanirsiniz! Ama yine de bir spoiler etiketi kullanın, böylece diğerleri merak edebilir.

Muhteşem. Lütfen bana milyon doları gönderin. Cidden, burada SAT'ı polinom çalışma zamanı ile çözecek bir programım var.

SAT problemindeki bir varyasyonu çözeceğimi söyleyerek başlayayım. Herhangi bir 3-SAT probleminin benzersiz çözümünü gösteren bir program yazmayı göstereceğim . Her Boolean değişkeninin değerlemesi, çözücümün çalışması için benzersiz olmalıdır .

Birkaç basit yardımcı yöntem ve tür bildirerek başlıyoruz:

class MainClass
{
    class T { }
    class F { }
    delegate void DT(T t);
    delegate void DF(F f);
    static void M(string name, DT dt)
    {
        System.Console.WriteLine(name + ": true");
        dt(new T());
    }
    static void M(string name, DF df)
    {
        System.Console.WriteLine(name + ": false");
        df(new F());
    }
    static T Or(T a1, T a2, T a3) { return new T(); }
    static T Or(T a1, T a2, F a3) { return new T(); }
    static T Or(T a1, F a2, T a3) { return new T(); }
    static T Or(T a1, F a2, F a3) { return new T(); }
    static T Or(F a1, T a2, T a3) { return new T(); }
    static T Or(F a1, T a2, F a3) { return new T(); }
    static T Or(F a1, F a2, T a3) { return new T(); }
    static F Or(F a1, F a2, F a3) { return new F(); }
    static T And(T a1, T a2) { return new T(); }
    static F And(T a1, F a2) { return new F(); }
    static F And(F a1, T a2) { return new F(); }
    static F And(F a1, F a2) { return new F(); }
    static F Not(T a) { return new F(); }
    static T Not(F a) { return new T(); }
    static void MustBeT(T t) { }

Şimdi çözmek için bir 3-SAT problemi seçelim. Diyelimki

(!x3) & 
(!x1) & 
(x1 | x2 | x1) & 
(x2 | x3 | x2)

Bunu biraz daha parantez edelim.

(!x3) & (
    (!x1) & (
        (x1 | x2 | x1) & 
        (x2 | x3 | x2)))

Bunu şu şekilde kodladık:

static void Main()
{
    M("x1", x1 => M("x2", x2 => M("x3", x3 => MustBeT(
      And(
        Not(x3),
        And(
          Not(x1),
          And(
            Or(x1, x2, x1),
            Or(x2, x3, x2))))))));
}

Programı çalıştırdığımızda, polinom zamanında 3-SAT'a bir çözüm bulduk. Aslında çalışma zamanı problemin boyutunda lineerdir !

x1: false
x2: true
x3: false

Polinom çalışma zamanı dedin . Polinom derleme zamanı hakkında hiçbir şey söylemedin . Bu program C # derleyicisini x1, x2 ve x3 için mümkün olan tüm tip kombinasyonlarını denemeye zorlar ve hiçbir tip hatası göstermeyen benzersiz olanı seçer. Derleyici tüm işi yapar, bu yüzden çalışma zamanı gerekmez. Bu ilginç teknolojiyi ilk olarak 2007'de blogumda sergiledim: http://blogs.msdn.com/b/ericlippert/archive/2007/03/28/lambda-expressions-vs-anonymous-methods-part-five.aspx Not Tabii ki bu örnek, C # 'daki aşırı yük çözünürlüğünün en azından NP-HARD olduğunu göstermektedir. NP-HARD mı yoksa gerçekten kararsız mı olduğu Tip dönüştürülebilirliğin jenerik kontravaryans varlığında nasıl çalıştığı konusundaki bazı ince ayrıntılara dayanır, ancak bu başka bir gün için bir konudur.

Çok dilli (1 bayt)

Pek çok dilde geçerli olan, çoğunlukla işlevsel ve ezoterik olan aşağıdaki program, çok sayıda SAT sorununa doğru cevap verecek ve sürekli karmaşıklığa (!!!) sahip olacaktır:

0

Şaşırtıcı bir şekilde, bir sonraki program kalan tüm sorunlara doğru cevap verecektir ve aynı karmaşıklığa sahiptir. Bu yüzden sadece doğru programı seçmeniz gerekir ve her durumda doğru cevabı bulursunuz!

1

JavaScript

Yinelemeli determinizmi kullanarak, SAT polinom sürede çözülebilir!

function isSatisfiable(bools, expr) {
    function verify() {
        var values = {};
        for(var i = 0; i < bools.length; i++) {
            values[bools[i]] = nonDeterministicValue();
        }
        with(values) {
            return eval(expr);
        }
    }
    function nonDeterministicValue() {
        return Math.random() < 0.5 ? !0 : !1;
    }

    for(var i = 0; i < 1000; i++) {
        if(verify(bools, expr)) return true;
    }
    return false;
}

Örnek kullanım:

isSatisfiable(["a", "b"], "a && !a || b && !b") //returns 'false'

Bu algoritma sadece verilen boole formülünü bin kere rasgele girdilerle kontrol eder. Neredeyse her zaman küçük girişler için çalışır, ancak daha fazla değişken sunulduğunda daha az güvenilirdir.

Bu arada, JavaScript’in en az kullanılan iki özelliğini yan yana kullanma fırsatım olduğu için gurur duyuyorum: evalve with.

Mathematica + Kuantum Hesaplama

Mathematica'nın gemiye kuantum bilgisayarla geldiğini bilemezsiniz.

Needs["Quantum`Computing`"];

Kuantum Adyabatik Commputing, bir Hamiltonian'da (enerji operatörü) asgari enerji durumunun ("temel durum") çözümü temsil ettiği şekilde çözülmesi gereken bir sorunu kodlar. Bu nedenle, kuantum sisteminin Hamiltoniyenin temel durumuna adyabatik olarak evrimi ve ardından yapılan ölçüm soruna çözüm getirir.

||Değişkenler ve olumsuzlaması için Pauli operatörlerinin uygun bir kombinasyonu ile, ifadenin bölümlerine karşılık gelen bir subhamiltonian tanımlarız.

Böyle bir ifade için nerede

expr = (! x3) && (! x1) && (x1 || x2 || x1) && (x2 || x3 || x2);

argüman benzemeli

{{{1, x3}}, {{1, x1}}, {{0, x1}, {0, x2}, {0, x1}}, {{0, x2}, {0, x3}, {0, x2}}}

İşte bool ifadesinden böyle bir argüman oluşturmak için kod:

arg = expr /. {And -> List, Or -> List, x_Symbol :> {0, x}, 
    Not[x_Symbol] :> {1, x}};
If[Depth[arg] == 3, arg = {arg}];
arg = If[Depth[#] == 2, {#}, #] & /@ arg

Şimdi, subhamiltonianları özetleyen tam bir Hamiltonyen inşa ediyoruz (toplama &&ifadenin bölümlerine karşılık geliyor ).

H = h /@ arg /. List -> Plus;

Ve en düşük enerji durumuna bakın

QuantumEigensystemForm[H, -1]

Eğer sıfır bir özdeğer elde edersek, özvektör özümdür

expr /. {x1 -> False, x2 -> True, x3 -> False}
> True

Maalesef "Quantum Computing" eklentisi için resmi site etkin değil ve indirmek için bir yer bulamıyorum, hala bilgisayarıma yükledim. Eklenti ayrıca, kodumu temel aldığım SAT sorununa belgelenmiş bir çözüme sahiptir.

Buradaki üç yaklaşım, hepsi SAT'ın 2B geometrik lingua franca'sına indirgenmesini içeriyor: nonogram mantık bulmacaları. Mantık bulmacasındaki hücreler, SAT değişkenlerine, cümlecik kısıtlamalara karşılık gelir.

Tam bir açıklama için (ve lütfen hata kodumu inceleyin!) Program dışı çözüm alanındaki kalıplar hakkında bazı bilgiler edindim. Bkz. Https://codereview.stackexchange.com/questions/43770/nonogram-puzzle-solution-space. > 4 milyardan fazla bulmaca çözümü sıralamak ve bunları bir doğruluk tablosuna sığdırmak için kodlamak fraktal desenleri gösterir - kendi kendine benzerlik ve özellikle kendi kendine afinite. Bu yakınlık fazlalığı, çözüm üretmek için gereken hesaplama kaynaklarını azaltmak için kullanılabilecek, problemin içindeki yapıyı gösterir. Ayrıca, başarılı bir algoritma içerisinde kaotik geri beslemeye ihtiyaç duyulduğunu da gösterir. “Kolay” örneklerin kaba yapı boyunca uzanan olanlar olduğu aşama geçiş davranışında açıklayıcı bir güç vardır; “sert” örnekler ise normal sezgiselden oldukça gizli olan ince ayrıntılara daha fazla yineleme gerektirir. Bu sonsuz görüntünün köşesine yakınlaştırmak istiyorsanız (kodlanmış tüm <= 4x4 bulmaca örnekleri) http://re-curse.github.io/visualizing-intractability/nonograms_zoom/nonograms.html adresini ziyaret edin.

Yöntem 1. Kaotik haritalar ve makine öğrenmesi kullanarak nonogram çözüm uzay gölgesini hesaplayın (Mandelbrot Kümesini oluşturanlara benzer uydurma işlevlerini düşünün).

İşte indüksiyonun görsel bir kanıtı. Bu dört görüntüyü soldan sağa tarayabilir ve eksik olan 5. ... 6.… vb. Görüntüleri oluşturmak için iyi bir fikriniz olduğunu düşünürseniz, o zaman ben sizi nonogram çözümünün karar sorunu için NP kahinesi olarak programladım. varlığı. Lütfen ödülünüzü dünyanın en güçlü süper bilgisayarı olarak kabul etmek için adım atın. Her gün ve sonra dünya size hesapsal katkılarınız için teşekkür ederken, size elektrik sarsıntısı besleyeceğim.

Yöntem 2. Kullanın girişlerin boolean versiyonunda Fourier Transforms. FFT'ler bir örnek içindeki sıklık ve konum hakkında küresel bilgi sağlar. Büyüklük kısmı giriş çifti arasında benzer olsa da, faz bilgileri tamamen farklıdır - belirli bir eksen boyunca bir çözüm projeksiyonu hakkında yönlendirilmiş bilgi içerir. Yeterince akıllıysanız, çözümün faz görüntüsünü giriş fazı görüntülerinin bazı özel süperpozisyonları ile yeniden yapılandırabilirsiniz . Daha sonra ters faz ve ortak büyüklüğü çözümün zaman alanına geri dönüştürün.

Bu yöntem ne açıklayabilir? Boolean görüntülerin bitişik hareketler arasında esnek bir dolguyla birçok permütasyonu vardır. Bu, FFT'lerin zaman alanı <-> (frekans, faz) arasındaki çift yönlü, benzersiz haritalama özelliğini korurken, çokluğa özen gösteren girdi -> çözümü arasında bir eşlemeye izin verir. Aynı zamanda “çözüm yok” diye bir şey olmadığı anlamına da gelir. Söyleyeceği şey, sürekli bir durumda, geleneksel nonogram bulmacanın bilevel görüntüsüne bakarken göz önünde bulundurmayacağınız gri tonlamalı çözümler olmasıdır.

Neden yapmıyorsun Bugünün kayan nokta dünyasındaki FFT'ler büyük örneklerle oldukça yanlış olacağından, aslında hesaplamanın korkunç bir yolu. Hassasiyet çok büyük bir sorundur ve niceliksel büyüklük ve faz görüntülerinden görüntüleri yeniden oluşturmak, genellikle görsel olarak insan gözü eşikleri için olmasa da, çok yaklaşık çözümler oluşturur . Aynı zamanda bu üst üste binme işini yapmak çok zordur, çünkü şu anda bunu yapan işlevin türü bilinmemektedir. Basit bir ortalama şeması olur mu? Muhtemelen hayır ve sezgi dışında bulmak için belirli bir arama yöntemi yoktur.

Yöntem 3. Hücre dışı bir otomat kuralını bulun (von Neumann 2 durumlu kurallar için muhtemel ~ 4 milyar kural tablosundan) ve nonogram bulmacanın simetrik bir versiyonunu çözer. Sorunun, burada gösterilen hücrelere doğrudan gömülmesini kullanıyorsunuz.

Bu muhtemelen bilgisayar kullanımı için basitlik ve iyi etkiler açısından en zarif yöntemdir. Bu kuralın varlığı kanıtlanmamıştır, ancak onun var olduğuna dair bir fikrim var. İşte nedeni:

Nonogramlar, algoritmanın tam olarak çözülmesi için çok fazla kaotik geribildirim gerektirir. Bu Kod İnceleme ile bağlantılı kaba kuvvet kodu ile kurulur. CA, kaotik geri bildirimleri programlamanın en yetenekli dilidir.

O görünüyor görsel, doğru. Kural bir gömme yoluyla gelişir, bilgiyi yatay ve dikey olarak ilerletir, müdahale eder, daha sonra ayarlanan hücrelerin sayısını koruyan bir çözelti haline gelir. Bu ilerleme yolu, fiziksel bir nesnenin gölgesini orijinal yapılandırmaya yansıtırken normalde düşündüğünüz yolu (geriye doğru) izler. Nonogramlar özel bir ayrık tomografi olgusundan kaynaklanmaktadır, bu nedenle iki kitty-köşeli CT tarayıcıda eşzamanlı oturduğunuzu hayal edin. Elbette, sınır sorunları var - CA evreninin kenarları, bir toroidal evrene izin vermediğiniz sürece, bilgiyi sınırların ötesinde ilerletmeye devam edemez. Bu aynı zamanda bulmacayı periyodik sınır değer problemi olarak ortaya koyar.

Geçiş halindeki çoklu çözümleri, girdiler olarak takas çıktıları arasında sürekli salınan bir etki olarak ve bunun tersi olarak açıklar. Ayarlanan hücrelerin sayısını korumayan orijinal konfigürasyonlarda çözümü olmayan örnekleri açıklar. Böyle bir kural bulma gerçek sonuca bağlı olarak, hatta cep devletler yakından çözeltisi ile çözülemeyen örneklerini yaklaşımda bulunabilirler edilir korunmuş.

C ++

İşte polinom zamanda çalışacağı kesin bir çözümdür ve çalışan O(n^k)nereye nboole sayısıdır ve kseçeceğiniz bir sabittir.

Sezgisel olarak doğrudur, çünkü CS-konuşmasının "çoğu zaman doğru cevabı verir, biraz şansla" dır (ve bu durumda, uygun bir şekilde büyük bir düzenlemek - aslında benim için meydana geldi. Herhangi bir sabit için böyle ayarlayabilirsiniz - bu hile nedir?).nkn^k > 2^n

#include <iostream>  
#include <cstdlib>   
#include <time.h>    
#include <cmath>     
#include <vector>    

using std::cout;     
using std::endl;     
typedef std::vector<bool> zork;

// INPUT HERE:

const int n = 3; // Number of bits
const int k = 4; // Runtime order O(n^k)

bool input_expression(const zork& x)
{
  return 
  (!x[2]) && (
    (!x[0]) && (
      (x[0] || x[1] || x[0]) &&
      (x[1] || x[2] || x[1])));
}

// MAGIC HAPPENS BELOW:    

 void whatever_you_do(const zork& minefield)
;void always_bring_a_towel(int value, zork* minefield);

int main()
{
  const int forty_two = (int)pow(2, n) + 1;
  int edition = (int)pow(n, k);
  srand(time(6["times7"]));

  zork dont_panic(n);
  while(--edition)
  {
    int sperm_whale = rand() % forty_two;
    always_bring_a_towel(sperm_whale, &dont_panic);

    if(input_expression(dont_panic))
    {
      cout << "Satisfiable: " << endl;
      whatever_you_do(dont_panic);
      return 0;
    }
  }

  cout << "Not satisfiable?" << endl;
  return 0;
}
void always_bring_a_towel(int value, zork* minefield)
{
  for(int j = 0; j < n; ++j, value >>= 1)
  {
    (*minefield)[j] = (value & 1);
  }
}

void whatever_you_do(const zork& minefield)
{
  for(int j = 0; j < n; ++j) 
  {
    cout << (char)('A' + j) << " = " << minefield[j] << endl;
  }
}

yakut / gnuplot 3d yüzey

(ooh sert rekabet!) ... neyse ... bin kelimelik bir resim mi? bunlar SAT geçiş noktasının gnuplot'unda yapılan 3 ayrı yüzey grafiğidir. (x, y) eksenleri cümle ve değişken sayımıdır ve z yüksekliği çözücüdeki toplam özyinelemeli çağrı sayısıdır. Ruby'de yazılmış kod. her biri 100 numunede 10x10 puan örnekler. istatistiklerin temel prensiplerini gösterir / kullanır ve bir Monte Carlo simülasyonudur .

temelde bir DIMACS formatında üretilen rastgele örneklerde çalışan bir davis putnam algoritması. Bu, dünyanın her yerindeki CS derslerinde ideal olarak yapılabilecek egzersiz türüdür, böylece öğrenciler temelleri öğrenebilir, ancak neredeyse hiç özel olarak öğretilmemiştir ... belki de neden bu kadar çok sahte P ? İstatistik fiziğinde çok öne çıkan bir konu olan geçiş noktası fenomenini (herhangi bir alıcı?) açıklayan iyi bir wikipedia makalesi bile yok ve CS'de de anahtar rol oynuyor. [a] [b] Geçiş noktasında CS hakkında çok sayıda makale var. bununla birlikte çok azının yüzey grafikleri gösterdiği görülüyor! (bunun yerine tipik olarak 2d dilimleri gösterir.)

Çalışma zamanında üstel artış 1'de açıkça bellidir ^st arsa. 1 ortasından geçen eyer ^st arsa geçiş noktasıdır. 2 ^nci ve 3 ^üncü araziler% karşılanabilir geçişi göstermektedir.

[a] CS ppt Toby Walsh'da faz geçiş davranışı
[b] k-SAT karşılanabilirliğinin ampirik olasılığı tcs.se
[c] ampirik / deneysel matematikte harika anlar / (T) CS / SAT , TMachine blog

P =? NP QED!

#!/usr/bin/ruby1.8

def makeformula(clauses)
    (1..clauses).map \
    {
            vars2 = $vars.dup
            (1..3).map { vars2.delete_at(rand(vars2.size)) * [-1, 1][rand(2)] }.sort_by { |x| x.abs }
    }

end

def solve(vars, formula, assign)

    $counter += 1
    vars2 = []
    formula.each { |x| vars2 |= x.map { |y| y.abs } }
    vars &= vars2

    return [false] if (vars.empty?)
    v = vars.shift
    [v, -v].each \
    {
            |v2|
            f2 = formula.map { |x| x.dup }
            f2.delete_if \
            {
                    |x|
                    x.delete(-v2)
                    return [false] if (x.empty?)
                    x.member?(v2)
            }
            return [true, assign + [v2]] if (f2.empty?)
            soln = solve(vars.dup, f2, assign + [v2])
            return soln if (soln[0])
    }
    return [false]
end

def solve2(formula)
    $counter = 0
    soln = solve($vars.dup, formula, [])
    return [$counter, {false => 0, true => 1}[soln[0]]]
end


c1 = 10
c2 = 100
nlo, nhi = [3, 10]
mlo, mhi = [1, 50]
c1.times \
{
    |n|
    c1.times \
    {
            |m|
            p1 = nlo + n.to_f / c1 * (nhi - nlo)
            p2 = mlo + m.to_f / c1 * (mhi - mlo)
            $vars = (1..p1.to_i).to_a
            z1 = 0
            z2 = 0
            c2.times \
            {
                    f = makeformula(p2.to_i)
                    x = solve2(f.dup)
                    z1 += x[0]
                    z2 += x[1]
            }
#           p([p1, p2, z1.to_f / c2, z2.to_f / c2]) # raw
#           p(z1.to_f / c2)                         # fig1
#           p(0.5 - (z2.to_f / c2 - 0.5).abs)       # fig2
            p(z2.to_f / c2)                         # fig3
    }
    puts
}