SAT เป็นปัญหาในการพิจารณาว่านิพจน์บูลีนสามารถทำให้เป็นจริงได้หรือไม่ ตัวอย่างเช่น (A) สามารถทำให้เป็นจริงได้โดยการตั้งค่า A = TRUE แต่ (A&&! A) จะไม่เป็นจริง ปัญหานี้เป็นที่รู้จักกันว่าเป็นปัญหาสมบูรณ์ ดูแบบบูล Satisfiability

งานของคุณคือการเขียนโปรแกรมสำหรับ SAT ที่ดำเนินการในเวลาพหุนาม แต่อาจไม่สามารถแก้ทุกกรณี

สำหรับตัวอย่างบางเหตุผลที่มันไม่ได้จริงๆพหุนามอาจเป็นเพราะ:

1. มีกรณีขอบที่ไม่ชัดเจน แต่มีรันไทม์ไม่ดี
2. อัลกอริทึมล้มเหลวในการแก้ปัญหาในบางกรณีที่ไม่คาดคิด
3. คุณลักษณะบางอย่างของภาษาการเขียนโปรแกรมที่คุณใช้จริง ๆ แล้วมีรันไทม์นานกว่าที่คุณคาดไว้
4. รหัสของคุณทำสิ่งที่แตกต่างจากที่มันทำอยู่

คุณสามารถใช้ภาษาการเขียนโปรแกรมใด ๆ (หรือการรวมกันของภาษา) ที่คุณต้องการ คุณไม่จำเป็นต้องแสดงหลักฐานอย่างเป็นทางการเกี่ยวกับความซับซ้อนของอัลกอริทึมของคุณ แต่อย่างน้อยคุณควรให้คำอธิบาย

เกณฑ์หลักในการตัดสินควรเป็นวิธีการที่ทำให้เชื่อมั่นรหัสได้อย่างไร

นี่คือการประกวดความนิยมดังนั้นคำตอบที่ได้รับคะแนนสูงสุดในหนึ่งสัปดาห์จะชนะ

C #

งานของคุณคือการเขียนโปรแกรมสำหรับ SAT ที่ดูเหมือนว่าจะทำงานในเวลาพหุนาม

"ปรากฏ" ไม่จำเป็น ฉันสามารถเขียนโปรแกรมที่ทำงานจริง ๆ ในเวลาพหุนามเพื่อแก้ปัญหา SAT อันที่จริงแล้วค่อนข้างตรงไปตรงมา

โบนัส MEGA: ถ้าคุณเขียน SAT-solver ที่ทำงานจริงในเวลาพหุนามคุณจะได้รับหนึ่งล้านเหรียญ! แต่โปรดใช้แท็กสปอยเลอร์เพื่อให้ผู้อื่นสามารถสงสัยได้

น่ากลัว โปรดส่งล้านดอลลาร์ให้ฉัน อย่างจริงจังฉันมีโปรแกรมที่นี่ที่จะแก้ SAT ด้วย polynomial runtime

ให้ฉันเริ่มต้นด้วยการระบุว่าฉันจะแก้ปัญหาความผันแปรของปัญหา SAT ผมจะแสดงให้เห็นถึงวิธีการเขียนโปรแกรมที่แสดงถึงวิธีการแก้ปัญหาที่ไม่ซ้ำกันของปัญหาใด ๆ 3 SAT การประเมินค่าตัวแปรบูลีนแต่ละค่านั้นไม่ซ้ำกันสำหรับนักแก้ปัญหาของฉันในการทำงาน

เราเริ่มต้นด้วยการประกาศวิธีการและตัวช่วยแบบง่าย ๆ สองสามอย่าง:

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) { }

ตอนนี้ลองเลือกปัญหา 3-SAT เพื่อแก้ปัญหา สมมติว่า

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

ลองวงเล็บกันอีกหน่อย

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

เราเข้ารหัสสิ่งนี้:

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))))))));
}

และแน่นอนเมื่อเรารันโปรแกรมเราได้คำตอบสำหรับ 3-SAT ในเวลาพหุนาม ในความเป็นจริงรันไทม์เป็นเส้นตรงในขนาดของปัญหา !

x1: false
x2: true
x3: false

คุณบอกว่าพหุนามรันไทม์ คุณบอกว่าไม่มีอะไรเกี่ยวกับพหุนามรวบรวมเวลา โปรแกรมนี้บังคับให้คอมไพเลอร์ C # ลองชุดผสมประเภทที่เป็นไปได้ทั้งหมดสำหรับ x1, x2 และ x3 และเลือกอันที่ไม่ซ้ำกันซึ่งไม่พบข้อผิดพลาดประเภท คอมไพเลอร์ทำงานทั้งหมดดังนั้นรันไทม์ไม่จำเป็นต้อง ฉันแสดงเนื้อหาที่น่าสนใจนี้เป็นครั้งแรกในบล็อกของฉันในปี 2007: http://blogs.msdn.com/b/ericlippert/archive/2007/03/28/lambda-expressions-vs-anonymous-methods-part-five.aspxหมายเหตุ ตัวอย่างนี้แสดงให้เห็นว่าการแก้ปัญหาการโอเวอร์โหลดใน C # เป็นอย่างน้อย NP-HARD ไม่ว่าจะเป็น NP-HARD หรือไม่สามารถตัดสินใจได้จริง ขึ้นอยู่กับรายละเอียดที่ลึกซึ้งในการทำงานของการเปลี่ยนรูปแบบในการปรากฏตัวของความแตกต่างทั่วไป แต่นั่นเป็นเรื่องสำหรับวันอื่น

หลายภาษา (1 ไบต์)

โปรแกรมต่อไปนี้สามารถใช้ได้ในหลายภาษาซึ่งส่วนใหญ่ใช้งานได้และลึกลับจะให้คำตอบที่ถูกต้องสำหรับปัญหา SAT จำนวนมากและมีความซับซ้อนคงที่ (!!!):

0

น่าประหลาดใจที่โปรแกรมต่อไปจะให้คำตอบที่ถูกต้องสำหรับปัญหาที่เหลืออยู่ทั้งหมดและมีความซับซ้อนเหมือนกัน ดังนั้นคุณต้องเลือกโปรแกรมที่ถูกต้องและคุณจะได้คำตอบที่ถูกต้องในทุกกรณี!

1

JavaScript

โดยใช้การวนซ้ำแบบไม่ซ้ำซ้อน SAT สามารถแก้ไขได้ในเวลาพหุนาม!

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;
}

ตัวอย่างการใช้งาน:

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

อัลกอริทึมนี้เพียงตรวจสอบสูตรบูลีนที่กำหนดเป็นพันครั้งด้วยอินพุตแบบสุ่ม เกือบจะใช้งานได้กับอินพุตขนาดเล็ก แต่ก็มีความน่าเชื่อถือน้อยกว่าเมื่อมีการแนะนำตัวแปรเพิ่มเติม

โดยวิธีการที่ผมภูมิใจที่ผมได้มีโอกาสที่จะใช้สองของคุณสมบัติที่ป้อแป้ที่สุดของ JavaScript ขวาถัดจากแต่ละอื่น ๆและevalwith

การคำนวณทางคณิตศาสตร์ + ควอนตัม

คุณอาจไม่รู้ว่า Mathematica มาพร้อมกับคอมพิวเตอร์ควอนตัมบนเรือ

Needs["Quantum`Computing`"];

Quantum Adiabatic Commputing เข้ารหัสปัญหาที่จะแก้ไขใน Hamiltonian (ผู้ประกอบการพลังงาน) ในลักษณะที่ว่าสถานะของพลังงานขั้นต่ำ ("สถานะพื้น") หมายถึงการแก้ปัญหา ดังนั้นวิวัฒนาการของอะเดียแบติกของระบบควอนตัมไปสู่สถานะพื้นของมิลโตเนียนและการวัดที่ตามมาจะช่วยแก้ปัญหา

เรากำหนด subhamiltonian ที่สอดคล้องกับ||ส่วนต่าง ๆ ของการแสดงออกด้วยการผสมผสานที่เหมาะสมของตัวดำเนินการ Pauli สำหรับตัวแปรและการปฏิเสธ

ที่ไหนสำหรับการแสดงออกเช่นนี้

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

อาร์กิวเมนต์ควรมีลักษณะเช่นนี้

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

นี่คือรหัสในการสร้างอาร์กิวเมนต์ดังกล่าวจากนิพจน์บูล:

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

ตอนนี้เราสร้างแฮมิลตันเต็มรูปแบบโดยสรุปผลรวมของ subhamiltonians (ผลรวมสอดคล้องกับ&&ส่วนของการแสดงออก)

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

และมองหาสถานะพลังงานต่ำสุด

QuantumEigensystemForm[H, -1]

ถ้าเรามีค่าไอเคิลเป็นศูนย์แล้วไอเกนเวกเตอร์ก็คือคำตอบ

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

น่าเสียดายที่เว็บไซต์ทางการของส่วนเสริม "Quantum Computing" ไม่ทำงานและฉันไม่สามารถหาที่ดาวน์โหลดได้ฉันยังคงติดตั้งไว้ในคอมพิวเตอร์ของฉัน ส่วนเสริมยังมีเอกสารวิธีแก้ไขปัญหา SAT ซึ่งฉันใช้รหัสของฉัน

สามแนวทางในที่นี้ทั้งหมดเกี่ยวข้องกับการลดลงของ SAT เป็นภาษาศาสตร์เรขาคณิต 2 มิติของมัน: ปริศนาลอจิกแบบ nonogram เซลล์ในปริศนาตรรกะสอดคล้องกับตัวแปร SAT ข้อ จำกัด ในส่วนคำสั่ง

สำหรับคำอธิบายแบบเต็ม (และโปรดตรวจสอบรหัสของฉันเพื่อหาจุดบกพร่อง!) ฉันได้โพสต์ข้อมูลเชิงลึกเกี่ยวกับรูปแบบภายในพื้นที่การแก้ปัญหาของ nonogram แล้ว ดูhttps://codereview.stackexchange.com/questions/43770/nonogram-puzzle-solution-space. การแจกแจงโซลูชั่นปริศนากว่า 4 พันล้านชิ้นและการเข้ารหัสเพื่อให้พอดีกับตารางความจริงแสดงให้เห็นถึงรูปแบบเศษส่วน - ความเหมือนตนเองและโดยเฉพาะอย่างยิ่งความสัมพันธ์ การเลียนแบบซ้ำซ้อนนี้แสดงให้เห็นถึงโครงสร้างภายในปัญหาซึ่งเป็นประโยชน์ในการลดทรัพยากรการคำนวณที่จำเป็นในการสร้างโซลูชัน นอกจากนี้ยังแสดงให้เห็นถึงความต้องการข้อเสนอแนะที่วุ่นวายในอัลกอริทึมที่ประสบความสำเร็จ มีอำนาจอธิบายในพฤติกรรมการเปลี่ยนเฟสที่อินสแตนซ์ "ง่าย" คือสิ่งที่อยู่ตามโครงสร้างหยาบในขณะที่อินสแตนซ์ "ยาก" ต้องการการทำซ้ำในรายละเอียดเพิ่มเติมค่อนข้างซ่อนจากฮิวริสติกปกติ หากคุณต้องการซูมเข้าไปที่มุมของภาพที่ไม่มีที่สิ้นสุด (ทั้งหมด <= 4x4 ปริศนาที่เข้ารหัสอินสแตนซ์) ดูhttp://re-curse.github.io/visualizing-intractability/nonograms_zoom/nonograms.html

วิธีที่ 1ประเมินเงาของพื้นที่ที่ไม่ใช่สารละลายโดยใช้แผนที่ที่วุ่นวายและการเรียนรู้ของเครื่อง (คิดว่าฟังก์ชั่นที่เหมาะสมคล้ายกับที่สร้างชุด Mandelbrot)

นี่คือหลักฐานการเหนี่ยวนำด้วยภาพ หากคุณสามารถสแกนสี่ภาพจากซ้ายไปขวาและคิดว่าคุณมีความคิดที่ดีในการสร้างภาพที่ขาดหายไปลำดับที่ 5 ... 6 ... ฯลฯ จากนั้นฉันเพิ่งตั้งโปรแกรมให้คุณเป็น NP oracle สำหรับปัญหาการตัดสินใจของโซลูชัน nonogram การดำรงอยู่ โปรดก้าวออกไปรับรางวัลของคุณในฐานะซูเปอร์คอมพิวเตอร์ที่ทรงพลังที่สุดในโลก ฉันจะให้อาหารคุณไฟฟ้า jolts ทุกขณะแล้วในขณะที่โลกขอบคุณสำหรับการสนับสนุนการคำนวณของคุณ

วิธีที่ 2ใช้การแปลงฟูริเยร์ในอินพุทอิมเมจบูลีน FFT ให้ข้อมูลทั่วโลกเกี่ยวกับความถี่และตำแหน่งภายในอินสแตนซ์ ในขณะที่ส่วนขนาดควรใกล้เคียงกันระหว่างคู่อินพุทข้อมูลเฟสของมันแตกต่างกันอย่างสิ้นเชิง - มีข้อมูลการกำหนดทิศทางเกี่ยวกับการฉายโซลูชันตามแกนที่ระบุ หากคุณฉลาดพอคุณอาจสร้างอิมเมจเฟสของโซลูชันขึ้นใหม่โดยใช้การซ้อนทับแบบพิเศษของอิมเมจเฟสอินพุท จากนั้นจึงแปลงเฟสและขนาดทั่วไปกลับเป็นโดเมนเวลาของโซลูชัน

วิธีนี้อธิบายอะไรได้บ้าง มีพีชคณิตมากมายของรูปภาพบูลีนที่มีช่องว่างที่ยืดหยุ่นระหว่างการวิ่งต่อเนื่องกัน สิ่งนี้ช่วยให้การแมประหว่างอินพุต -> โซลูชันดูแลหลายหลากขณะที่ยังคงคุณสมบัติของ FFTs ของการแมปสองทิศทางที่ไม่ซ้ำกันระหว่างโดเมนเวลา <-> (ความถี่เฟส) มันก็หมายความว่าไม่มีสิ่งเช่น "แก้ปัญหา" สิ่งที่จะกล่าวคือในกรณีอย่างต่อเนื่องมีคำตอบแบบสีเทาที่คุณไม่ได้พิจารณาเมื่อดูภาพ bilevel ของการแก้ปริศนา nonogram แบบดั้งเดิม

ทำไมคุณไม่ทำมัน มันเป็นวิธีที่น่ากลัวในการคำนวณจริงเนื่องจาก FFTs ในโลกจุดลอยตัวในวันนี้จะไม่ถูกต้องอย่างมากกับกรณีขนาดใหญ่ ความแม่นยำเป็นปัญหาใหญ่และการสร้างภาพใหม่จากขนาดเชิงควอนตัมและรูปภาพเฟสมักจะสร้างวิธีแก้ปัญหาที่ใกล้เคียงกันมากถึงแม้ว่าอาจจะไม่สามารถมองเห็นได้ด้วยตามนุษย์ นอกจากนี้ยังยากมากที่จะเกิดขึ้นกับธุรกิจการซ้อนทับกันนี้เนื่องจากฟังก์ชั่นประเภทที่ใช้งานจริงนั้นไม่เป็นที่รู้จักในปัจจุบัน มันจะเป็นรูปแบบการหาค่าเฉลี่ยอย่างง่ายหรือไม่? อาจไม่ได้และไม่มีวิธีการค้นหาที่เฉพาะเจาะจงในการค้นหายกเว้นสัญชาตญาณ

วิธีที่ 3ค้นหากฎออโตมาตาเซลลูล่าร์ (จากตารางกฎประมาณ 4 พันล้านที่เป็นไปได้สำหรับกฎฟอนนอยมันน์ 2 สถานะ) ที่แก้ปัญหาสมการของโนมอลปริศนาที่ไม่ใช่สมมาตร คุณใช้การฝังปัญหาโดยตรงลงในเซลล์ดังที่แสดงไว้ที่นี่

นี่อาจเป็นวิธีที่สง่างามที่สุดในแง่ของความเรียบง่ายและเอฟเฟกต์ที่ดีสำหรับอนาคตของการคำนวณ การมีอยู่ของกฎนี้ไม่ได้พิสูจน์ แต่ฉันมีลางสังหรณ์อยู่ นี่คือเหตุผล:

Nonograms ต้องการความคิดเห็นที่วุ่นวายในอัลกอริทึมเพื่อแก้ไขอย่างแน่นอน สิ่งนี้สร้างขึ้นโดยรหัสกำลังดุร้ายที่เชื่อมโยงกับการตรวจสอบรหัส CA เป็นเพียงภาษาที่มีความสามารถมากที่สุดในการเขียนโปรแกรมป้อนกลับวุ่นวาย

มันดูถูกต้อง กฎจะวิวัฒนาการผ่านการฝัง, การเผยแพร่ข้อมูลในแนวนอนและแนวตั้ง, รบกวน, จากนั้นทำให้เสถียรเพื่อแก้ปัญหาที่รักษาจำนวนเซลล์ที่ตั้งไว้ เส้นทางการสนับสนุนนี้ตามเส้นทาง (ข้างหลัง) ที่คุณมักนึกถึงเมื่อฉายเงาของวัตถุทางกายภาพในการกำหนดค่าดั้งเดิม Nonograms เกิดจากกรณีพิเศษของเอกซ์เรย์ที่ไม่ต่อเนื่องดังนั้นให้จินตนาการว่านั่งอยู่พร้อมกันในเครื่องสแกน CT ของคิตตี้ที่มีมุมสองด้าน .. นี่คือวิธีที่รังสีเอกซ์ แน่นอนว่ามีปัญหาเกี่ยวกับขอบเขต - ขอบของเอกภพ CA ไม่สามารถให้ข้อมูลที่เกินขอบเขตได้เว้นแต่ว่าคุณจะอนุญาตให้มีเอกภพรูปวงแหวน สิ่งนี้จะปลดเปลื้องปริศนาเป็นปัญหาค่าขอบเขตเป็นระยะ

มันอธิบายถึงวิธีการแก้ปัญหาหลายอย่างที่เป็นสถานะชั่วคราวในผลกระทบอย่างต่อเนื่องระหว่างการสลับเอาท์พุทเป็นอินพุตและในทางกลับกัน มันอธิบายถึงอินสแตนซ์ที่ไม่มีวิธีแก้ปัญหาเช่นเดียวกับการกำหนดค่าดั้งเดิมที่ไม่ประหยัดจำนวนเซลล์ที่ตั้งค่าไว้ ขึ้นอยู่กับผลลัพธ์ที่แท้จริงของการค้นหากฎดังกล่าวมันอาจถึงอินสแตนซ์ที่ไม่สามารถแก้ไขได้ด้วยโซลูชันที่ปิดซึ่งเซลล์ของรัฐจะได้รับการอนุรักษ์

C ++

นี่คือทางออกที่รับประกันว่าจะทำงานในเวลาพหุนาม: มันทำงานในO(n^k)ที่ที่nมีจำนวนบูลลีนและkเป็นค่าคงที่ที่คุณเลือก

เป็นวิธีแก้ปัญหาที่ถูกต้องซึ่งฉันเชื่อว่าเป็น CS-speak สำหรับ "มันให้คำตอบที่ถูกต้องเกือบตลอดเวลาด้วยโชคเล็กน้อย" (และในกรณีนี้มีค่ามากพอสมควรk- แก้ไขจริง ๆ แล้วเกิดกับฉันว่า สำหรับการแก้ไขใด ๆ ที่nคุณสามารถตั้งค่าkเช่นนั้นn^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;
  }
}

ruby / gnuplot 3d surface

(การแข่งขันที่รุนแรงโอ้!) ... ยังไงก็ตาม ... รูปภาพที่มีค่าหนึ่งพันคำ? สิ่งเหล่านี้คือ 3 แปลงพื้นผิวแยกที่สร้างขึ้นใน gnuplot ของจุดเปลี่ยน SAT แกน (x, y) เป็นส่วนคำสั่ง & จำนวนตัวแปรและความสูง z คือจำนวนทั้งหมดของการโทรซ้ำในตัวแก้ไข รหัสที่เขียนในทับทิม มันตัวอย่าง 10x10 คะแนนที่ 100 ตัวอย่างต่อคน มันแสดงให้เห็น / ใช้หลักการพื้นฐานของสถิติและเป็นจำลอง Monte Carlo

โดยทั่วไปแล้วมันเป็นขั้นตอนวิธีเดวิสพัทวิ่งบนอินสแตนซ์สุ่มที่สร้างขึ้นในรูปแบบ DIMACS นี่คือประเภทของการออกกำลังกายที่ควรจะทำในชั้นเรียน CS ทั่วโลกเพื่อให้นักเรียนสามารถเรียนรู้พื้นฐานแต่เกือบจะไม่ได้สอนอย่างเฉพาะเจาะจงเลย ... บางทีอาจเป็นเหตุผลว่าทำไมมีปลอมมากมายP? = หลักฐานพิสูจน์ NP ? ไม่มีบทความวิกิพีเดียที่ดีที่อธิบายปรากฏการณ์จุดเปลี่ยน (ผู้รับใด ๆ ?) ซึ่งเป็นหัวข้อที่โดดเด่นมากในวิชาฟิสิกส์เชิงสถิติและเป็นกุญแจสำคัญใน CS ด้วย [a] [b] มีเอกสารจำนวนมากใน CS ที่จุดเปลี่ยน อย่างไรก็ตามมีน้อยมากที่แสดงการแปลงพื้นผิว! (โดยทั่วไปจะแสดงชิ้น 2d แทน)

เพิ่มขึ้นชี้แจงใน runtime คือชัดเจนใน 1 ^{เซนต์}พล็อต อานวิ่งผ่านกลาง 1 ^{เซนต์}พล็อตเป็นจุดเปลี่ยนแปลง 2 ^{ครั้ง}และ 3 ^ถแปลงแสดงการเปลี่ยนแปลงพอใจ%

[a] พฤติกรรมการเปลี่ยนเฟสใน CS ppt Toby Walsh
[b] ความน่าจะเป็นเชิงประจักษ์ของ k-SAT ความพึงพอใจ tcs.se
[c] ช่วงเวลาที่ยอดเยี่ยมในเชิงประจักษ์ / การทดลองทางคณิตศาสตร์ / (T) CS / SAT , บล็อก TMachine

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
}