การเขียนโปรแกรมเชิงตรรกะ (Logic programming)คือ กระบวนทัศน์ การเขียนโปรแกรมฐานข้อมูลและการแสดงความรู้ที่อิงตามตรรกะเชิงรูปธรรมโปรแกรมเชิงตรรกะคือชุดประโยคในรูปแบบตรรกะ ซึ่งแสดงถึงความรู้เกี่ยวกับโดเมนปัญหาบางอย่าง การคำนวณจะดำเนินการโดยการใช้เหตุผลเชิงตรรกะกับความรู้นั้น เพื่อแก้ปัญหาในโดเมนนั้น ตระกูลภาษาการเขียนโปรแกรมเชิงตรรกะที่สำคัญ ได้แก่Prolog , Answer Set Programming (ASP) และDatalogในภาษาเหล่านี้ทั้งหมด กฎจะถูกเขียนในรูปแบบของอนุประโยค :

A :- B1, ..., Bn.

และอ่านได้เหมือนประโยคบอกเล่าในรูปแบบตรรกะ:

A if B1 and ... and Bn.

Aเรียกว่าส่วนหัวของกฎ , ..., เรียกว่าส่วนเนื้อหาและเรียกว่าค่าคงที่หรือเงื่อนไข เมื่อ n = 0 กฎนั้นเรียกว่าข้อเท็จจริงและเขียนในรูปแบบที่ลดรูปแล้ว: B1BnBi

A.

คำถาม (หรือเป้าหมาย) มีไวยากรณ์เหมือนกับส่วนเนื้อหาของกฎ และโดยทั่วไปจะเขียนในรูปแบบ:

?- B1, ..., Bn.

ในกรณีที่ง่ายที่สุดของประโยคฮอร์น (หรือประโยค "แน่นอน") นั้น A, B ₁ , ..., B _n ทั้งหมด เป็นสูตรอะตอมิกในรูปแบบ p(t ₁ ,..., t _m ​​) โดยที่ p เป็นสัญลักษณ์ภาคแสดงที่ระบุความสัมพันธ์ เช่น "ความเป็นแม่" และ t _iเป็นเทอมที่ระบุวัตถุ (หรือบุคคล) เทอมเหล่านี้รวมถึงสัญลักษณ์คงที่ เช่น "ชาร์ลส์" และตัวแปร เช่น X ซึ่งขึ้นต้นด้วยตัวอักษรพิมพ์ใหญ่

ตัวอย่างเช่น ลองพิจารณาโปรแกรม Horn clause ต่อไปนี้:

แม่ลูก( เอ ลิซาเบธ, ชาร์ลส์) พ่อลูก (ชาร์ลส์, วิลเลียม) พ่อลูก ( ชาร์ลส์, แฮร์รี่) พ่อแม่ลูก( X , Y ) : - แม่ลูก( X , Y ) พ่อแม่ลูก( X , Y ) : - พ่อลูก ( X , Y ) ปู่ย่าตายาย ลูก( X , Y ) :- พ่อแม่ลูก( X , Z ), พ่อแม่ลูก( Z , Y )

เมื่อได้รับคำถาม โปรแกรมจะสร้างคำตอบ ตัวอย่างเช่น สำหรับคำถามหนึ่ง ?- parent_child(X, william)คำตอบเดียวคือ

X = ชาร์ลส์

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

grandparent_child ( X , william ). X = elizabeth?- grandparent_child ( elizabeth , Y ). Y = william ; Y = harry .?- ปู่ย่าตายาย_ลูก( X , Y ). X = elizabeth Y = william ; X = elizabeth Y = harry .?- ปู่ย่าตายาย_ลูก( วิลเลียม, แฮร์รี่) ไม่?- ปู่ย่าตายาย_ลูก( เอลิซาเบธ, แฮร์รี่) ใช่

แม้ว่าโปรแกรมตรรกะข้อความฮอร์นจะสมบูรณ์แบบทัวริง [ ^{1 ] [ 2 ] สำหรับ}การใช้งานจริงส่วนใหญ่ โปรแกรมข้อความฮอร์นจำเป็นต้องขยายไปเป็นโปรแกรมตรรกะ "ปกติ" ที่มีเงื่อนไขเชิงลบ ตัวอย่างเช่น นิยามของพี่น้องใช้เงื่อนไขเชิงลบ โดยที่ภาคแสดง = ถูกกำหนดโดยข้อความ X = X :

พี่น้อง( X , Y ) :- พ่อแม่ลูก( Z , X ), พ่อแม่ลูก( Z , Y ), ไม่ใช่( X = Y )

ภาษาการเขียนโปรแกรมเชิงตรรกะที่รวมเงื่อนไขเชิงลบไว้ด้วย มีความสามารถในการแสดงความรู้แบบตรรกะที่ไม่เป็นไปตามลำดับ (non-monotonic logic )

ใน ASP และ Datalog โปรแกรมตรรกะมี การตีความ แบบประกาศ เท่านั้น และการดำเนินการจะทำโดยใช้กระบวนการพิสูจน์หรือตัวสร้างแบบจำลอง ซึ่งพฤติกรรมของตัวสร้างแบบจำลองนั้นไม่ได้มีไว้ให้โปรแกรมเมอร์ควบคุม อย่างไรก็ตาม ในตระกูลภาษา Prolog โปรแกรมตรรกะยังมี การตีความแบบ ขั้นตอนในรูปแบบของกระบวนการลดเป้าหมาย จากมุมมองนี้ ข้อความ A :- B ₁ ,...,B _nจะถูกเข้าใจดังนี้:

เพื่อแก้ปัญหาAแก้ปัญหาและ... และแก้ปัญหาB1Bn

เงื่อนไขเชิงลบในเนื้อหาของประโยคยังมีการตีความเชิงกระบวนการที่เรียกว่าการปฏิเสธในฐานะความล้มเหลว : ข้อความเชิงลบ not Bจะถือว่าถูกต้องก็ต่อเมื่อข้อความเชิงบวก Bไม่เป็นไปตามเงื่อนไข เท่านั้น

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

การใช้ตรรกะทางคณิตศาสตร์เพื่อแสดงและดำเนินการโปรแกรมคอมพิวเตอร์เป็นคุณลักษณะหนึ่งของแคลคูลัสแลมบ์ดาซึ่งพัฒนาโดยAlonzo Churchในช่วงทศวรรษ 1930 อย่างไรก็ตาม ข้อเสนอแรกในการใช้รูป แบบ ตรรกะแบบข้อความเพื่อแสดงโปรแกรมคอมพิวเตอร์นั้นมาจากCordell Green [ ^{3 ] ซึ่ง}ใช้การกำหนดสัจพจน์ของเซตย่อยของLISPร่วมกับการแสดงความสัมพันธ์ระหว่างอินพุตและเอาต์พุต เพื่อคำนวณความสัมพันธ์โดยการจำลองการดำเนินการของโปรแกรมใน LISP ในทางกลับกัน Absys ของ Foster และ Elcock ใช้การผสมผสานระหว่างสมการและแคลคูลัสแลมบ์ดาในภาษาการเขียนโปรแกรมเชิงยืนยันที่ไม่มีข้อจำกัดเกี่ยวกับลำดับการดำเนินการ^{[ 4 ]}

การเขียนโปรแกรมเชิงตรรกะ ด้วยไวยากรณ์ปัจจุบันของข้อเท็จจริงและกฎ สามารถสืบย้อนไปถึงการถกเถียงในช่วงปลายทศวรรษ 1960 และต้นทศวรรษ 1970 เกี่ยวกับการแสดงความรู้แบบประกาศเทียบกับแบบขั้นตอนในปัญญาประดิษฐ์ผู้สนับสนุนการแสดงความรู้แบบประกาศนั้นทำงานอยู่ที่มหาวิทยาลัยสแตนฟอร์ดโดยเกี่ยวข้องกับJohn McCarthy , Bertram Raphaelและ Cordell Green และที่เอดินบะระโดยมีJohn Alan Robinson (นักวิชาการผู้มาเยือนจากมหาวิทยาลัย Syracuse ), Pat HayesและRobert Kowalskiผู้สนับสนุนการแสดงความรู้แบบขั้นตอนส่วนใหญ่อยู่ที่MITภายใต้การนำของMarvin MinskyและSeymour Papert ^{[ 5 ]}

แม้ว่าจะอิงตามวิธีการพิสูจน์ของตรรกะ แต่Plannerซึ่งพัฒนาโดยCarl Hewittที่ MIT ก็เป็นภาษาแรกที่เกิดขึ้นภายในกระบวนทัศน์เชิงกระบวนการนี้^{[ 6 ]} Planner มีคุณสมบัติการเรียกใช้แผนเชิงกระบวนการที่กำหนดโดยรูปแบบจากเป้าหมาย (เช่น การลดเป้าหมายหรือการเชื่อมโยงย้อนกลับ ) และจากการยืนยัน (เช่นการเชื่อมโยงไปข้างหน้า ) การใช้งาน Planner ที่มีอิทธิพลมากที่สุดคือส่วนย่อยของ Planner ที่เรียกว่า Micro-Planner ซึ่งใช้งานโดยGerry Sussman , Eugene CharniakและTerry Winograd Winograd ใช้ Micro-Planner ในการใช้งานโปรแกรม SHRDLUซึ่งเป็นโปรแกรมสำคัญในการทำความเข้าใจภาษาธรรมชาติ[ ^{7 ] เพื่อ}ประสิทธิภาพ Planner ใช้โครงสร้างควบคุมการย้อนกลับเพื่อให้ต้องจัดเก็บเส้นทางการคำนวณที่เป็นไปได้เพียงเส้นทางเดียวในแต่ละครั้ง Planner ก่อให้เกิดภาษาโปรแกรมQA4 [ ^{8 ]} Popler ^{[ 9 ]} Conniver ^{[ 10 ]} QLISP ^{[ 11 ] และภาษา แบบ}ขนาน Ether ^{[ 12 ]}

เฮย์สและโควาลสกีในเอดินบะระพยายามประสานแนวทางการประกาศเชิงตรรกะในการแสดงความรู้เข้ากับแนวทางเชิงกระบวนการของ Planner เฮย์ส (1973) ได้พัฒนาภาษาสมการ Golux ซึ่งสามารถได้รับขั้นตอนต่างๆ โดยการเปลี่ยนแปลงพฤติกรรมของตัวพิสูจน์ทฤษฎีบท^{[ 13 ]}

ในขณะเดียวกันAlain Colmerauerในมาร์เซย์กำลังทำงานเกี่ยวกับการทำความเข้าใจภาษาธรรมชาติโดยใช้ตรรกะเพื่อแสดงความหมายและใช้การแก้ปัญหาเพื่อตอบคำถาม ในช่วงฤดูร้อนปี 1971 Colmerauer ได้เชิญ Kowalski มาที่มาร์เซย์ และพวกเขาร่วมกันค้นพบว่ารูปแบบประโยคของตรรกะสามารถใช้เพื่อแสดงไวยากรณ์ที่เป็นทางการได้และตัวพิสูจน์ทฤษฎีบทการแก้ปัญหาสามารถใช้สำหรับการวิเคราะห์ไวยากรณ์ได้ พวกเขาสังเกตว่าตัวพิสูจน์ทฤษฎีบทบางตัว เช่น hyper-resolution ^{[ 14 ]}ทำงานเหมือนตัววิเคราะห์ไวยากรณ์แบบ bottom-up และตัวอื่นๆ เช่นSL resolution (1971) ^{[ 15 ]}ทำงานเหมือนตัววิเคราะห์ไวยากรณ์แบบ top-down

ในช่วงฤดูร้อนปี 1972 โควาลสกีได้ทำงานร่วมกับโคลเมอราเออร์อีกครั้ง และได้พัฒนาการตีความเชิงกระบวนการของนัยยะในรูปแบบประโยค นอกจากนี้ยังเป็นที่ชัดเจนว่าประโยคดังกล่าวสามารถจำกัดได้เฉพาะประโยคที่ระบุเจาะจงหรือประโยคฮอร์นและการแก้ปัญหา SL สามารถจำกัด (และขยายความ) ไปสู่การแก้ปัญหา SLDได้ การตีความเชิงกระบวนการและ SLD ของโควาลสกีได้รับการอธิบายไว้ในบันทึกช่วยจำปี 1973 ซึ่งตีพิมพ์ในปี 1974 ^{[ 16 ]}

Colmerauer ร่วมกับ Philippe Roussel ใช้การตีความเชิงกระบวนการเป็นพื้นฐานของ Prolog ซึ่งถูกนำไปใช้ในช่วงฤดูร้อนและฤดูใบไม้ร่วงของปี 1972 โปรแกรม Prolog ตัวแรก ซึ่งเขียนขึ้นในปี 1972 และนำไปใช้ในมาร์เซย์ คือระบบตอบคำถามภาษาฝรั่งเศส การใช้ Prolog เป็นภาษาโปรแกรมเชิงปฏิบัติได้รับแรงผลักดันอย่างมากจากการพัฒนาคอมไพเลอร์โดยDavid HD Warrenในเอดินบะระในปี 1977 การทดลองแสดงให้เห็นว่า Edinburgh Prolog สามารถแข่งขันกับความเร็วในการประมวลผลของ ภาษา โปรแกรมเชิงสัญลักษณ์ อื่นๆ เช่นLispได้^{[ 17 ]} Edinburgh Prolog กลายเป็น มาตรฐาน โดยพฤตินัยและมีอิทธิพลอย่างมากต่อการกำหนด มาตรฐาน ISO Prolog

การเขียนโปรแกรมเชิงตรรกะได้รับความสนใจในระดับนานาชาติในช่วงทศวรรษ 1980 เมื่อ กระทรวงการค้าและอุตสาหกรรมระหว่างประเทศ ของญี่ปุ่นเลือกใช้ เพื่อพัฒนาซอฟต์แวร์สำหรับ โครงการ ระบบคอมพิวเตอร์ยุคที่ห้า (FGCS) โครงการ FGCS มีเป้าหมายที่จะใช้การเขียนโปรแกรมเชิงตรรกะเพื่อพัฒนา แอปพลิ เคชันปัญญาประดิษฐ์ ขั้นสูง บนคอมพิวเตอร์แบบขนาน ขนาดใหญ่ แม้ว่าในตอนแรกโครงการจะสำรวจการใช้ Prolog แต่ต่อมาก็ได้นำการเขียนโปรแกรมเชิงตรรกะแบบขนาน มาใช้ เนื่องจากมีความสอดคล้องกับสถาปัตยกรรมคอมพิวเตอร์ FGCS มากกว่า

อย่างไรก็ตาม คุณสมบัติการเลือกที่แน่วแน่ของการเขียนโปรแกรมตรรกะแบบขนานขัดขวางความหมายเชิงตรรกะของภาษา^{[ 18 ]}และความเหมาะสมสำหรับการแสดงความรู้และการแก้ปัญหา นอกจากนี้ ระบบคอมพิวเตอร์แบบขนานที่พัฒนาขึ้นในโครงการนี้ไม่สามารถแข่งขันกับความก้าวหน้าที่เกิดขึ้นในการพัฒนาคอมพิวเตอร์ทั่วไปแบบดั้งเดิมได้ ปัญหาทั้งสองนี้ส่งผลให้โครงการ FGCS ล้มเหลวในการบรรลุวัตถุประสงค์ ความสนใจในการเขียนโปรแกรมตรรกะและ AI ทั่วโลกจึงลดลง^{[ 19 ]}

ในขณะเดียวกัน แนวทางการเขียนโปรแกรมเชิงตรรกะแบบประกาศมากขึ้น รวมถึงแนวทางที่ใช้ Prolog ก็ยังคงก้าวหน้าต่อไปโดยอิสระจากโครงการ FGCS โดยเฉพาะอย่างยิ่ง แม้ว่า Prolog จะถูกพัฒนาขึ้นเพื่อรวมการแสดงความรู้แบบประกาศและแบบขั้นตอนเข้าด้วยกัน แต่การตีความเชิงประกาศของโปรแกรมตรรกะก็กลายเป็นจุดสนใจสำหรับการประยุกต์ใช้งานในสาขาฐานข้อมูลแบบนิรนัยงานในสาขานี้เริ่มโดดเด่นขึ้นราวปี 1977 เมื่อ Hervé Gallaire และJack Minkerจัดการประชุมเชิงปฏิบัติการเกี่ยวกับตรรกะและฐานข้อมูลในเมืองตูลูส^{[ 20 ]}ในที่สุดสาขานี้ก็ได้รับการเปลี่ยนชื่อเป็น Datalog

การมุ่งเน้นไปที่การอ่านเชิงตรรกะและการประกาศของโปรแกรมตรรกะได้รับแรงผลักดันเพิ่มเติมจากการพัฒนาการเขียนโปรแกรมตรรกะแบบมีข้อจำกัดในช่วงทศวรรษ 1980 และการเขียนโปรแกรมชุดคำตอบในช่วงทศวรรษ 1990 นอกจากนี้ยังได้รับการเน้นย้ำอีกครั้งในแอปพลิเคชัน Prolog ในปัจจุบัน^{[ 21 ]}

สมาคมการเขียนโปรแกรมเชิงตรรกะ (ALP) ก่อตั้งขึ้นในปี 1986 เพื่อส่งเสริมการเขียนโปรแกรมเชิงตรรกะ วารสารอย่างเป็นทางการของสมาคมจนถึงปี 2000 คือThe Journal of Logic Programmingบรรณาธิการบริหารผู้ก่อตั้งคือJ. Alan Robinson [ ^{22 ] ใน} ปี 2001 วารสารนี้ได้รับการเปลี่ยนชื่อเป็นThe Journal of Logic and Algebraic Programmingและวารสารอย่างเป็นทางการของ ALP กลายเป็นTheory and Practice of Logic Programmingซึ่งตีพิมพ์โดยสำนักพิมพ์มหาวิทยาลัยเคมบริดจ์

โปรแกรมเชิงตรรกะมีรูปแบบความหมายและวิธีการแก้ปัญหาที่หลากหลาย รวมถึงการประยุกต์ใช้งานในวงกว้างในด้านการเขียนโปรแกรม ฐานข้อมูล การแสดงความรู้ และการแก้ปัญหา

การตีความเชิงขั้นตอนของโปรแกรมตรรกะ ซึ่งใช้การให้เหตุผลย้อนกลับเพื่อลดเป้าหมายลงเป็นเป้าหมายย่อย เป็นกรณีพิเศษของการใช้กลยุทธ์การแก้ปัญหาเพื่อควบคุมการใช้ การแสดงความรู้ เชิง ตรรกะแบบประกาศ เพื่อให้ได้พฤติกรรมของอัลกอริทึมโดยทั่วไปแล้ว กลยุทธ์การแก้ปัญหาที่แตกต่างกันสามารถนำไปใช้กับการแสดงความรู้เชิงตรรกะเดียวกันเพื่อให้ได้อัลกอริทึมที่แตกต่างกัน หรืออีกทางหนึ่ง อัลกอริทึมที่แตกต่างกันสามารถได้มาด้วยกลยุทธ์การแก้ปัญหาที่กำหนดโดยใช้การแสดงความรู้เชิงตรรกะที่แตกต่างกัน^{[ 23 ]}

กลยุทธ์หลักสองประการในการแก้ปัญหาคือการใช้เหตุผลย้อนกลับ (การลดเป้าหมาย) และการใช้เหตุผลไปข้างหน้าซึ่งเรียกอีกอย่างว่าการใช้เหตุผลจากบนลงล่างและจากล่างขึ้นบน ตามลำดับ

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

สามารถใช้กลยุทธ์การค้นหาใดก็ได้ในการค้นหาพื้นที่นี้ Prolog ใช้กลยุทธ์แบบลำดับ เข้าหลังออกก่อน และย้อนกลับ โดยจะพิจารณาเพียงทางเลือกเดียวและเป้าหมายย่อยเดียวในแต่ละครั้ง ตัวอย่างเช่น สามารถแก้ปัญหาเป้าหมายย่อยได้พร้อมกัน และสามารถลองใช้ข้อความย่อยได้พร้อมกันเช่นกัน กลยุทธ์แรกเรียกว่าและขนานและกลยุทธ์ที่สองเรียกว่าหรือขนานกลยุทธ์การค้นหาอื่นๆ เช่น การย้อนกลับอย่างชาญฉลาด ^{[ 24 ]}หรือการค้นหาแบบ best-first เพื่อหาวิธีแก้ปัญหาที่เหมาะสมที่สุด ^{[ 25 ]}ก็เป็นไปได้เช่นกัน

ในกรณีทั่วไปที่ไม่ใช่เชิงประพจน์ ซึ่งเป้าหมายย่อยสามารถใช้ตัวแปรร่วมกันได้ สามารถใช้กลยุทธ์อื่นได้ เช่น การเลือกเป้าหมายย่อยที่มีอินสแตนซ์สูงสุดหรือมีอินสแตนซ์เพียงพอเพื่อให้มีเพียงขั้นตอนเดียวที่ใช้ได้^{[ 26 ]}กลยุทธ์ดังกล่าวถูกนำมาใช้ ตัวอย่างเช่น ใน การ เขียน โปรแกรมตรรกะแบบขนาน

โดยส่วนใหญ่แล้ว การใช้เหตุผลย้อนกลับจากคำถามหรือเป้าหมายจะมีประสิทธิภาพมากกว่าการใช้เหตุผลไปข้างหน้า แต่บางครั้งใน Datalog และ Answer Set Programming อาจไม่มีคำถามใดที่แยกออกจากชุดของข้อความทั้งหมด และการสร้างข้อเท็จจริงทั้งหมดที่สามารถอนุมานได้จากข้อความเหล่านั้นก็เป็นกลยุทธ์การแก้ปัญหาที่สมเหตุสมผล นี่คืออีกตัวอย่างหนึ่งที่การใช้เหตุผลไปข้างหน้ามีประสิทธิภาพมากกว่าการใช้เหตุผลย้อนกลับในงานคำนวณทั่วไป ซึ่งเป้าหมาย?- fibonacci(n, Result)คือการหา จำนวนฟิโบนาชชีลำดับ ^{ที่ n} :

ฟีโบนัชชี( 0 , 0 ) ฟีโบนัชชี( 1 , 1 )ฟิโบนาชชี( N , ผลลัพธ์) :- N > 1 , N1 คือN - 1 , N2 คือN - 2 , ฟิโบนาชชี( N1 , F1 ), ฟิโบนาชชี( N2 , F2 ) , ผลลัพธ์คือF1 + F2

ในที่นี้ ความสัมพันธ์fibonacci(N, M)หมายถึงฟังก์ชันfibonacci(N) = MและภาคแสดงN is Expressionคือสัญกรณ์โปรล็อกสำหรับภาคแสดงที่กำหนดค่าตัวแปรNให้มีค่าExpressionเท่ากับ

เมื่อกำหนดเป้าหมายในการคำนวณเลขฟิโบนาชชีของnn การให้เหตุผลแบบย้อนกลับจะลดเป้าหมายลงเหลือเป้าหมายย่อยสองเป้าหมาย คือ การคำนวณเลขฟิโบนาชชีของ n-1 และ n-2 ซึ่งจะลดเป้าหมายย่อยของการคำนวณเลขฟิโบนาชชีของ n-1 ลงเหลือเป้าหมายย่อยสองเป้าหมาย คือ การคำนวณเลขฟิโบนาชชีของ n-2 และ n-3 โดยเป็นการคำนวณเลขฟิโบนาชชีของ n-2 ซ้ำซ้อน กระบวนการลดเป้าหมายย่อยฟิโบนาชชีหนึ่งเป้าหมายลงเหลือสองเป้าหมายย่อยนี้จะดำเนินต่อไปจนกว่าจะถึงเลข 0 และ 1 ความซับซ้อนของกระบวนการนี้อยู่ในลำดับ 2^ⁿ ในทางตรงกันข้าม การให้เหตุผลแบบไปข้างหน้าจะสร้างลำดับของเลขฟิโบนาชชีโดยเริ่มจาก 0 และ 1 โดยไม่ต้องคำนวณซ้ำ และความซับซ้อนของกระบวนการนี้เป็นเชิงเส้นเมื่อเทียบกับ n

Prolog ไม่สามารถทำการให้เหตุผลไปข้างหน้าโดยตรงได้ แต่สามารถบรรลุผลของการให้เหตุผลไปข้างหน้าภายในบริบทของการให้เหตุผลย้อนกลับได้โดยใช้ตาราง : เป้าหมายย่อยจะถูกเก็บรักษาไว้ในตารางพร้อมกับวิธีแก้ปัญหา หากพบเป้าหมายย่อยอีกครั้ง จะสามารถแก้ไขได้โดยตรงโดยใช้วิธีแก้ปัญหาที่มีอยู่แล้วในตาราง แทนที่จะแก้ไขเป้าหมายย่อยซ้ำซ้อน^{[ 27 ]}

การเขียนโปรแกรมเชิงตรรกะสามารถมองได้ว่าเป็นการวางนัยทั่วไปของการเขียนโปรแกรมเชิงฟังก์ชัน ซึ่งฟังก์ชันเป็นกรณีพิเศษของความสัมพันธ์^{[ 28 ]} ตัวอย่างเช่น ฟังก์ชัน mother(X) = Y (X ทุกตัวมีแม่ Y เพียงตัวเดียว) สามารถแสดงได้ด้วยความสัมพันธ์ mother(X, Y) ในแง่นี้ โปรแกรมเชิงตรรกะจึงคล้ายกับฐานข้อมูลเชิงสัมพันธ์ซึ่งแสดงฟังก์ชันเป็นความสัมพันธ์เช่นกัน

เมื่อเปรียบเทียบกับไวยากรณ์เชิงสัมพันธ์ ไวยากรณ์เชิงฟังก์ชันจะกระชับกว่าสำหรับฟังก์ชันที่ซ้อนกัน ตัวอย่างเช่น ในไวยากรณ์เชิงฟังก์ชัน นิยามของยายสามารถเขียนในรูปแบบที่ซ้อนกันได้ดังนี้:

ยายของแม่( X ) = แม่( แม่( X ))

นิยามเดียวกันในรูปแบบความสัมพันธ์เชิงตรรกะ จำเป็นต้องเขียนในรูปแบบที่ไม่ซ้อนกันและเรียบง่าย:

ยาย( X , Y ) :- แม่( X , Z ), แม่( Z , Y )

อย่างไรก็ตาม ไวยากรณ์แบบซ้อนกันสามารถถือได้ว่าเป็นไวยากรณ์ที่ช่วยให้เขียนง่ายขึ้นสำหรับไวยากรณ์แบบไม่ซ้อนกัน ตัวอย่างเช่น Ciao Prolog แปลงไวยากรณ์เชิงฟังก์ชันให้เป็นรูปแบบเชิงสัมพันธ์และดำเนินการโปรแกรมตรรกะที่ได้โดยใช้กลยุทธ์การดำเนินการมาตรฐานของ Prolog ^{[ 29 ]}ยิ่งไปกว่านั้น การแปลงแบบเดียวกันนี้สามารถใช้เพื่อดำเนินการความสัมพันธ์แบบซ้อนกันที่ไม่ใช่เชิงฟังก์ชันได้ ตัวอย่างเช่น:

ปู่ย่าตายาย( X ) := พ่อแม่( พ่อแม่( X )) พ่อแม่( X ) := แม่( X ) พ่อแม่( X ) := พ่อ( X )แม่( ชาร์ลส์) := เอลิซาเบธพ่อ( ชาร์ลส์) := ฟิลลิปแม่( แฮร์รี่) := ไดอาน่าพ่อ( แฮร์รี่) := ชาร์ลส์?- ปู่ย่าตายาย( X , Y ). X = แฮร์รี่, Y = เอลิซาเบธ. X = แฮร์รี่, Y = ฟิลลิป.

คำว่าการเขียนโปรแกรมเชิงสัมพันธ์ถูกใช้เพื่อครอบคลุมภาษาการเขียนโปรแกรมที่หลากหลายซึ่งถือว่าฟังก์ชันเป็นกรณีพิเศษของความสัมพันธ์ ภาษาเหล่านี้บางภาษา เช่นminiKanren ^{[ 28 ]} และการเขียนโปรแกรมเชิงเส้นเชิงสัมพันธ์^{[ 30 ]} เป็นภาษาการเขียนโปรแกรมเชิงตรรกะในความหมายของบทความนี้

อย่างไรก็ตาม ภาษาเชิงสัมพันธ์ RML เป็นภาษาการเขียนโปรแกรมเชิงคำสั่ง ^{[ 31 ]}ซึ่งโครงสร้างหลักคือการแสดงออกเชิงสัมพันธ์ ซึ่งคล้ายกับการแสดงออกในตรรกะเชิงประพจน์ลำดับแรก

ภาษาการเขียนโปรแกรมเชิงสัมพันธ์อื่นๆ นั้นมีพื้นฐานมาจากแคลคูลัสเชิงสัมพันธ์^{[ 32 ]}หรือพีชคณิตเชิงสัมพันธ์^{[ 33 ]}

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

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

แนวทางอื่นในการทำความเข้าใจความหมายเชิงประกาศของโปรแกรมแบบ Horn clause คือความหมายเชิงความพึงพอใจซึ่งเข้าใจว่าการแก้ปัญหาเป้าหมายคือการแสดงให้เห็นว่าเป้าหมายนั้นเป็นจริง (หรือได้รับการตอบสนอง) ในแบบจำลองที่ตั้งใจไว้ (หรือแบบจำลองมาตรฐาน)ของโปรแกรม สำหรับโปรแกรมแบบ Horn clause นั้น จะมีแบบจำลองมาตรฐานดังกล่าวอยู่เสมอ นั่นคือแบบจำลองขั้นต่ำสุด เพียงหนึ่งเดียว ของโปรแกรม

กล่าวโดยไม่เป็นทางการ โมเดลขั้นต่ำคือโมเดลที่เมื่อมองว่าเป็นเซตของข้อเท็จจริงทั้งหมด (ที่ปราศจากตัวแปร) ที่เป็นจริงในโมเดลแล้ว จะไม่มีเซตของข้อเท็จจริงที่เล็กกว่าซึ่งเป็นโมเดลของโปรแกรมอีกด้วย

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

แม่ลูก( เอลิซาเบธ, ชาร์ลส์) พ่อลูก( ชาร์ลส์, วิลเลียม) พ่อลูก ( ชาร์ ล ส์, แฮร์รี่ ) พ่อ แม่ลูก ( เอลิซา เบธ, ชาร์ลส์) พ่อแม่ลูก (ชาร์ลส์, วิลเลียม) พ่อแม่ลูก( ชาร์ลส์, แฮร์รี่) ปู่ย่าตายายลูก( เอลิซาเบธ, วิลเลียม) ปู่ย่าตายายลูก( เอลิซาเบธ, แฮร์รี่)

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

ที่น่าทึ่งคือ วิธีการแก้ปัญหาแบบเดียวกันของการให้เหตุผลไปข้างหน้าและย้อนกลับ ซึ่งเดิมพัฒนาขึ้นสำหรับความหมายของผลลัพธ์เชิงตรรกะ สามารถนำไปใช้กับความหมายของความพึงพอใจได้เช่นกัน: การให้เหตุผลไปข้างหน้าสร้างแบบจำลองขั้นต่ำของโปรแกรมข้อความ Horn โดยการอนุมานข้อเท็จจริงใหม่จากข้อเท็จจริงที่มีอยู่ จนกว่าจะไม่มีข้อเท็จจริงเพิ่มเติมใหม่ใด ๆ ที่สามารถสร้างขึ้นได้อีก การให้เหตุผลย้อนกลับ ซึ่งประสบความสำเร็จโดยการลดเป้าหมายลงเป็นเป้าหมายย่อย จนกว่าเป้าหมายย่อยทั้งหมดจะได้รับการแก้ไขด้วยข้อเท็จจริง ทำให้มั่นใจได้ว่าเป้าหมายนั้นเป็นจริงในแบบจำลองขั้นต่ำ โดยไม่ต้องสร้างแบบจำลองอย่างชัดเจน^{[ 34 ]}

ความแตกต่างระหว่างความหมายเชิงประกาศทั้งสองแบบสามารถเห็นได้จากนิยามของการบวกและการคูณในเลขคณิตตัวสืบทอดซึ่งแสดงจำนวนธรรมชาติ0, 1, 2, ...เป็นลำดับของพจน์ในรูปแบบ0, s(0), s(s(0)), ...โดยทั่วไป พจน์s(X)จะแทนตัวสืบทอดของX,กล่าวคือ ต่อX + 1.ไปนี้คือนิยามมาตรฐานของการบวกและการคูณในสัญกรณ์เชิงฟังก์ชัน:

 X + 0 = X. X + s(Y) = s(X + Y) เช่น X + (Y + 1) = (X + Y) + 1 X × 0 = 0. X × s(Y) = X + (X × Y) เช่น X × (Y + 1) = X + (X × Y) 

ต่อไปนี้คือคำจำกัดความเดียวกันกับโปรแกรมตรรกะ โดยใช้add(X, Y, Z)เพื่อแทนX + Y = Z,และmultiply(X, Y, Z)เพื่อแทนX × Y = Z:

เพิ่ม( X , 0 , X ). เพิ่ม( X , s ( Y ), s ( Z )) :- เพิ่ม( X , Y , Z ).คูณ( X , 0 , 0 ). คูณ( X , s ( Y ), W ) :- คูณ( X , Y , Z ), บวก( X , Z , W ).

ความหมายเชิงประกาศทั้งสองแบบให้คำตอบเดียวกันสำหรับการเชื่อมโยงที่มีปริมาณเชิงการมีอยู่ของเป้าหมายการบวกและการคูณ ตัวอย่างเช่น2 × 2 = XมีคำตอบX = 4; และX × X = X + XมีคำตอบสองคำตอบคือX = 0และX = 2:

?- คูณ( s ( s ( 0 )), s ( s ( 0 )), X ). X = s ( s ( s ( s ( 0 )))).?- คูณ( X , X , Y ), บวก( X , X , Y ). X = 0 , Y = 0. X = s ( s ( 0 )), Y = s ( s ( s ( s ( 0 )))).

อย่างไรก็ตาม ในความหมายของผลลัพธ์เชิงตรรกะ มีแบบจำลองโปรแกรมที่ไม่เป็นมาตรฐาน ซึ่งในแบบจำลองเหล่านั้น ตัวอย่างเช่นadd(s(s(0)), s(s(0)), s(s(s(s(s(0)))))),ie 2 + 2 = 5เป็นจริง แต่ในความหมายของความสามารถในการทำให้เป็นจริง มีเพียงแบบจำลองเดียวเท่านั้น นั่นคือแบบจำลองมาตรฐานของเลขคณิต ซึ่ง ie 2 + 2 = 5เป็นเท็จ

ในความหมายทั้งสองแบบ เป้าหมายนั้นล้มเหลว ในความหมายแบบความพึงพอใจ ความล้มเหลวของเป้าหมายหมายความว่าค่าความจริงของเป้าหมายเป็นเท็จ แต่ในความหมายแบบผลลัพธ์เชิงตรรกะ ความล้มเหลวหมายความว่าค่าความจริงของเป้าหมายนั้นไม่เป็นที่ทราบ ?-add(s(s(0)),s(s(0)),s(s(s(s(s(0))))))

การปฏิเสธในฐานะความล้มเหลว (NAF) ซึ่งเป็นวิธีการสรุปว่าเงื่อนไขเชิงลบnot pเป็นจริงโดยการแสดงให้เห็นว่าเงื่อนไขเชิงบวกpไม่เป็นจริงนั้น เป็นคุณลักษณะหนึ่งของระบบ Prolog ในยุคแรกๆ ส่วนขยายของการแก้ปัญหา SLD ที่เกิดขึ้นนี้ เรียกว่าSLDNFโครงสร้างที่คล้ายกันนี้ เรียกว่า "thnot" ก็มีอยู่ในMicro-Plannerเช่น กัน

ความหมายเชิงตรรกะของ NAF ยังไม่ได้รับการแก้ไขจนกระทั่งKeith Clark ^{[ 35 ]}แสดงให้เห็นว่าภายใต้เงื่อนไขธรรมชาติบางประการ NAF เป็นวิธีการให้เหตุผลที่มีประสิทธิภาพ ถูกต้อง (และบางครั้งก็สมบูรณ์) โดยใช้ความหมายเชิงผลลัพธ์เชิงตรรกะโดยใช้การ ทำให้ โปรแกรมตรรกะ สมบูรณ์ ในตรรกะลำดับแรก

โดยคร่าวๆ แล้ว การทำให้เสร็จสมบูรณ์หมายถึงการพิจารณาชุดของข้อความโปรแกรมทั้งหมดที่มีภาคแสดงเดียวกันในส่วนหัว เช่น:

A :- Body1.

...

A :- Bodyk.

ตามคำจำกัดความของภาคแสดง:

A iff (Body1 or ... or Bodyk)

โดยที่iffหมายถึง "ก็ต่อเมื่อ" ความสมบูรณ์ยังรวมถึงสัจพจน์ของความเท่าเทียมกัน ซึ่งสอดคล้องกับการรวมเป็นหนึ่งเดียวคลาร์กแสดงให้เห็นว่าการพิสูจน์ที่สร้างขึ้นโดย SLDNF มีโครงสร้างคล้ายกับการพิสูจน์ที่สร้างขึ้นโดยวิธีการอนุมานแบบธรรมชาติเมื่อโปรแกรมเสร็จสมบูรณ์

ตัวอย่างเช่น ลองพิจารณาโปรแกรมต่อไปนี้:

should_receive_sanction ( X , punishment ) :- is_a_thief ( X ), not should_receive_sanction ( X , rehabilitation ).ควรได้รับการลงโทษ( X , การฟื้นฟู) :- เป็นขโมย( X ), เป็นผู้เยาว์( X ), ไม่ใช่คนรุนแรง( X )เป็นขโมย( ทอม)

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

?- ควรได้รับโทษ( ทอม, โทษ) โทษ= การลงโทษ

เนื่องจากทอมเป็นขโมย และไม่สามารถพิสูจน์ได้ว่าทอมควรได้รับการฟื้นฟู และไม่สามารถพิสูจน์ได้ว่าทอมควรได้รับการฟื้นฟู เพราะไม่สามารถพิสูจน์ได้ว่าทอมเป็นผู้เยาว์

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

เป็นผู้เยาว์( ทอม)?- ควรได้รับโทษ( ทอม, โทษ) โทษ= การฟื้นฟู

คุณสมบัติของการถอนข้อสรุปเมื่อมีการเพิ่มข้อมูลใหม่เข้ามา เรียกว่า ภาวะไม่เป็นไปตามลำดับ (non-monotonicity) และทำให้การเขียนโปรแกรมเชิงตรรกะเป็นตรรกะที่ไม่เป็นไปตามลำดับ (non-monotonic logic )

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

รุนแรง( ทอม)?- ควรได้รับโทษ( ทอม, โทษ) โทษ= การลงโทษ

การสำเร็จหลักสูตรนี้คือ:

should_receive_sanction ( X , Sanction ) iff Sanction = punishment , is_a_thief ( X ), not should_receive_sanction ( X , rehabilitation ) or Sanction = rehabilitation , is_a_thief ( X ), is_a_minor ( X ), not is_violent ( X ).เป็นโจร( X ) ก็ต่อเมื่อX = ทอม. เป็นเยาวชน( X ) ก็ต่อเมื่อX = ทอม. เป็นผู้กระทำความรุนแรง( X ) ก็ต่อเมื่อX = ทอม.

แนวคิดเรื่องความสมบูรณ์มีความเกี่ยวข้องอย่างใกล้ชิดกับ ความหมาย เชิงขอบเขตของ John McCarthy สำหรับการให้เหตุผลเริ่มต้น^{[ 36 ]}และสมมติฐานโลกปิดของRay Reiter ^{[ 37 ]}

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

ในกรณีของโปรแกรมตรรกะที่มีเงื่อนไขเชิงลบ มีรูปแบบหลักสองแบบของความหมายความพึงพอใจ: ในความหมายที่มีพื้นฐานที่ดีโมเดลที่ตั้งใจไว้ของโปรแกรมตรรกะคือโมเดลขั้นต่ำสามค่าที่ไม่ซ้ำกัน ซึ่งมีอยู่เสมอ ความหมายที่มีพื้นฐานที่ดีเป็นการขยายแนวคิดของการนิยามแบบอุปนัยในตรรกะทางคณิตศาสตร์^{[ 38 ]} XSB Prolog ^{[ 39 ]}ใช้ความหมายที่มีพื้นฐานที่ดีโดยใช้การแก้ปัญหา SLG ^{[ 40 ]}

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

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

ควรได้รับการ ลงโทษ ( ทอม, การลงโทษ) เป็นขโมย( ทอม) เป็นผู้เยาว์( ทอม) เป็นคนรุนแรง( ทอม)

ความพยายามที่จะเข้าใจการปฏิเสธในการเขียนโปรแกรมเชิงตรรกะยังส่งผลต่อการพัฒนากรอบการโต้แย้งเชิงนามธรรมอีก ด้วย ^{[ 41 ]}ในการตีความการโต้แย้งของการปฏิเสธ ข้อโต้แย้งเริ่มต้นที่ว่าทอมควรถูกลงโทษเพราะเขาเป็นขโมย ถูกโจมตีด้วยข้อโต้แย้งที่ว่าเขาควรได้รับการฟื้นฟูเพราะเขายังเป็นผู้เยาว์ แต่ข้อเท็จจริงที่ว่าทอมมีพฤติกรรมรุนแรงกลับบั่นทอนข้อโต้แย้งที่ว่าทอมควรได้รับการฟื้นฟู และฟื้นฟูข้อโต้แย้งที่ว่าทอมควรถูกลงโทษ

เมตาโปรแกรมมิง ซึ่งโปรแกรมได้รับการปฏิบัติเสมือนเป็นข้อมูล เป็นคุณลักษณะหนึ่งของการใช้งาน Prolog ในยุคแรกอยู่แล้ว^{[ 42 ] [ 43 ]}ตัวอย่างเช่น การใช้งาน Prolog DEC10 ของ Edinburgh ประกอบด้วย "ตัวแปลและตัวคอมไพเลอร์ ซึ่งเขียนด้วย Prolog เองทั้งคู่" ^{[ 43 ]}เมตาโปรแกรมที่ง่ายที่สุดคือเมตาตัวแปลที่เรียกว่า " วานิลลา "

แก้( จริง) แก้(( B , C )):- แก้( B ), แก้( C ) แก้( A ):- เงื่อนไข( A , B ), แก้( B )

โดยที่ true แทนการเชื่อมประโยคที่ว่างเปล่า และ (B,C) เป็นคำประสมที่แทนการเชื่อมประโยคของ B และ C อนุประโยคภาคแสดง (A,B) หมายความว่ามีอนุประโยคในรูปแบบ A :- B

เมตาโปรแกรมมิง คือการประยุกต์ใช้เมตาตรรกะหรือเมตาภาษา ในเชิงทั่วไป เพื่ออธิบายและให้เหตุผลเกี่ยวกับภาษาอื่น ซึ่งเรียกว่าภาษา เป้าหมาย

การเขียนโปรแกรมเชิงเมตาโลจิกช่วยให้สามารถรวมการแสดงผลระดับวัตถุและระดับเมตาเข้าด้วยกันได้ เช่นเดียวกับในภาษาธรรมชาติ ตัวอย่างเช่น ในโปรแกรมต่อไปนี้ สูตรอะตอมิกattends(Person, Meeting)ปรากฏทั้งในฐานะสูตรระดับวัตถุ และในฐานะอาร์กิวเมนต์ของเมตาเพรดิเคตprohibitedและapproved.

ห้าม( เข้าร่วม( บุคคล, การประชุม)) :- ไม่( อนุมัติ( เข้าร่วม( บุคคล, การประชุม)))ควรได้รับการลงโทษ( บุคคล, การตำหนิ) :- เข้าร่วม( บุคคล, การประชุม), สูงส่ง( บุคคล), ห้าม( เข้าร่วม( บุคคล, การประชุม)) ควรได้รับการลงโทษ( บุคคล, การเนรเทศ) :- เข้าร่วม( บุคคล, การประชุม), ต่ำต้อย( บุคคล), ห้าม( เข้าร่วม( บุคคล, การประชุม))อนุมัติ( เข้าร่วม( อลิซ, งานเลี้ยงน้ำชา)) เข้าร่วม( แมดแฮท เทอร์ , งานเลี้ยงน้ำชา) เข้าร่วม( ดอร์เมาส์, งานเลี้ยงน้ำชา)สูงส่ง( คนบ้าหมวก) ต่ำต้อย( หนูหลับ)?- ควรได้รับการลงโทษ( X , Y ). บุคคล= mad_hatter , การลงโทษ= การตำหนิ. บุคคล= dormouse , การลงโทษ= การเนรเทศ.

ในหนังสือ Introduction to Cognitive Science ที่ได้รับความนิยมของเขา^{[ 44 ]} Paul Thagardได้รวมตรรกะและกฎเกณฑ์ไว้เป็นแนวทางทางเลือกในการจำลองความคิดของมนุษย์ เขาโต้แย้งว่ากฎเกณฑ์ซึ่งมีรูปแบบIF เงื่อนไข THEN การกระทำ นั้น "คล้ายคลึงกันมาก" กับเงื่อนไขเชิงตรรกะ แต่กฎเกณฑ์นั้นง่ายกว่าและมีความสมเหตุสมผลทางจิตวิทยามากกว่า (หน้า 51) ในบรรดาความแตกต่างอื่นๆ ระหว่างตรรกะและกฎเกณฑ์ เขาโต้แย้งว่าตรรกะใช้การอนุมาน แต่กฎเกณฑ์ใช้การค้นหา (หน้า 45) และสามารถใช้ในการให้เหตุผลได้ทั้งไปข้างหน้าหรือย้อนกลับ (หน้า 47) ประโยคในตรรกะ "ต้องถูกตีความว่าเป็นจริงโดยทั่วไป " แต่กฎเกณฑ์สามารถเป็นค่าเริ่มต้นซึ่งยอมรับข้อยกเว้นได้ (หน้า 44)

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

can_go ( you , home ) :- have ( you , bus_fare ), catch ( you , bus ).

ลักษณะทั้งหมดของระบบที่ใช้กฎเกณฑ์ ได้แก่ การค้นหา การให้เหตุผลไปข้างหน้าและย้อนกลับ การให้เหตุผลโดยปริยาย และการลดเป้าหมาย ล้วนเป็นลักษณะเฉพาะของการเขียนโปรแกรมเชิงตรรกะเช่นกัน สิ่งนี้ชี้ให้เห็นว่าข้อสรุปของ Thagard (หน้า 56) ที่ว่า:

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

นอกจากนี้ยังใช้ได้กับการเขียนโปรแกรมเชิงตรรกะด้วย

Keith StenningและMichiel van Lambalgenได้นำเสนอข้อโต้แย้งอื่นๆ ที่แสดงให้เห็นว่าการเขียนโปรแกรมเชิงตรรกะสามารถใช้จำลองแง่มุมต่างๆ ของการคิดของมนุษย์ได้อย่างไรในหนังสือ Human Reasoning and Cognitive Science ของพวกเขา^{[ 45 ]}พวกเขาแสดงให้เห็นว่าลักษณะที่ไม่เป็นไปตามลำดับของโปรแกรมเชิงตรรกะสามารถใช้อธิบายประสิทธิภาพของมนุษย์ในงานทางจิตวิทยาต่างๆ ได้ พวกเขายังแสดงให้เห็น (หน้า 237) ว่า "การให้เหตุผลแบบปิดโลกในรูปแบบของการเขียนโปรแกรมเชิงตรรกะมีการนำไปใช้ในระบบประสาทที่น่าสนใจ ซึ่งแตกต่างจากตรรกะแบบคลาสสิก"

ใน The Proper Treatment of Events ^{[ 46 ]} Michiel van Lambalgen และ Fritz Hamm ได้ตรวจสอบการใช้การเขียนโปรแกรมตรรกะข้อจำกัดเพื่อเขียนโค้ด "แนวคิดเชิงเวลาในภาษาธรรมชาติโดยพิจารณาวิธีที่มนุษย์สร้างเวลา"

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

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

holds ( Fact , Time2 ) :- happens ( Event , Time1 ), Time2 is Time1 + 1 , initiates ( Event , Fact ).holds ( Fact , Time2 ) :- happens ( Event , Time1 ), Time2 is Time1 + 1 , holds ( Fact , Time1 ), not ( terminated ( Fact , Time1 )).ยุติ( ข้อเท็จจริง, เวลา) :- เกิดขึ้น( เหตุการณ์, เวลา), ยุติ( เหตุการณ์, ข้อเท็จจริง)

นี่holdsคือเมตาเพรดิเคทที่คล้ายกับsolveข้างต้น อย่างไรก็ตาม ในขณะที่solveมีอาร์กิวเมนต์เพียงตัวเดียว ซึ่งใช้กับประโยคทั่วไป อาร์กิวเมนต์แรกของholdsเป็นข้อเท็จจริง และอาร์กิวเมนต์ที่สองเป็นเวลา (หรือสถานะ) สูตรอะตอมิกholds(Fact, Time)แสดงว่าFactเป็นจริง ณ เวลาTimeข้อเท็จจริงที่เปลี่ยนแปลงตามเวลาดังกล่าวเรียกว่าฟลูเอน ท์ สูตรอะตอมิกhappens(Event, Time)แสดงว่า เหตุการณ์ เกิดขึ้น ณTimeเวลา

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าสามารถใช้ข้อความเหล่านี้ในการให้เหตุผลเกี่ยวกับความเป็นเหตุเป็นผลในโลกของบล็อก ของเล่น ได้อย่างไร ในที่นี้ ณ เวลา 0 บล็อกสีเขียวอยู่บนโต๊ะและบล็อกสีแดงวางซ้อนอยู่บนบล็อกสีเขียว (เหมือนสัญญาณไฟจราจร) ณ เวลา 0 บล็อกสีแดงถูกย้ายไปที่โต๊ะ ณ เวลา 1 บล็อกสีเขียวถูกย้ายไปวางบนบล็อกสีแดง การเคลื่อนย้ายวัตถุไปยังตำแหน่งใดตำแหน่งหนึ่งจะยุติข้อเท็จจริงที่ว่าวัตถุนั้นอยู่ในตำแหน่งใดตำแหน่งหนึ่ง และเริ่มต้นข้อเท็จจริงที่ว่าวัตถุนั้นอยู่ในตำแหน่งที่มันถูกย้ายไป:

holds ( on ( green_block , table ), 0 ). holds ( on ( red_block , green_block ), 0 ).เกิดขึ้น( ย้าย( บล็อกสีแดง, ตาราง), 0 ) เกิดขึ้น( ย้าย( บล็อกสีเขียว, บล็อกสีแดง), 1 )เริ่มต้น( ย้าย( Object , Place ), บน( Object , Place )) สิ้นสุด( ย้าย( Object , Place2 ), บน( Object , Place1 ))?- ถือ( ข้อเท็จจริง, เวลา)ข้อเท็จจริง= เปิด( บล็อกสีเขียว, ตาราง), เวลา= 0. ข้อเท็จจริง= เปิด( บล็อกสีแดง, บล็อกสีเขียว), เวลา= 0. ข้อเท็จจริง= เปิด( บล็อกสีเขียว, ตาราง) , เวลา= 1. ข้อเท็จจริง= เปิด( บล็อกสีแดง, ตาราง ), เวลา= 1. ข้อเท็จจริง= เปิด( บล็อกสีเขียว, บล็อก สีแดง), เวลา= 2. ข้อเท็จจริง= เปิด( บล็อกสีแดง, ตาราง), เวลา= 2.

การให้เหตุผลไปข้างหน้าและการให้เหตุผลย้อนกลับสร้างคำตอบเดียวกันสำหรับเป้าหมายholds(Fact, Time)แต่การให้เหตุผลไปข้างหน้าสร้างผลลัพธ์ที่คล่องแคล่วตามลำดับเวลา ในขณะที่การให้เหตุผลย้อนกลับสร้างผลลัพธ์ที่คล่องแคล่วแบบถอยหลังเช่นเดียวกับการใช้การถดถอย เฉพาะโดเมน ในแคลคูลัสสถานการณ์^{[ 47 ]}

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

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

เริ่มต้น( การเกิด( บุคคล), พลเมือง( บุคคล, สหราชอาณาจักร)):- เวลาเกิด( การเกิด( บุคคล), เวลา), สถานที่เกิด( การเกิด( บุคคล), สหราช อาณาจักร), พ่อแม่และลูก( บุคคลอื่น, บุคคล), ถือครอง( พลเมือง( บุคคลอื่น, สหราชอาณาจักร), เวลา)

ในอดีต การนำเสนอพระราชบัญญัติสัญชาติอังกฤษส่วนใหญ่ในรูปแบบโปรแกรมตรรกะในช่วงทศวรรษ 1980 ^{[ 49 ]}ถือเป็น "สิ่งที่มีอิทธิพลอย่างมากต่อการพัฒนาการนำเสนอกฎหมายในรูปแบบการคำนวณ โดยแสดงให้เห็นว่าการเขียนโปรแกรมเชิงตรรกะช่วยให้การนำเสนอที่เข้าใจง่ายสามารถนำไปใช้โดยตรงเพื่อสร้างการอนุมานอัตโนมัติได้" ^{[ 50 ]}

เมื่อไม่นานมานี้ ระบบ PROLEG ^{[ 51 ]}ซึ่งริเริ่มในปี 2552 และประกอบด้วยกฎและข้อยกเว้นของประมวลกฎหมายแพ่งและกฎของศาลฎีกาในญี่ปุ่นประมาณ 2,500 ข้อ ได้กลายเป็นฐานกฎหมายที่ใหญ่ที่สุดในโลก^{[ 52 ]}

กฎการอนุมานของการแก้ปัญหา SLD เป็นกลางเกี่ยวกับลำดับในการเลือกเป้าหมายย่อยในเนื้อหาของประโยคย่อยเพื่อหาคำตอบ เพื่อความมีประสิทธิภาพ Prolog จึงจำกัดลำดับนี้ไว้เฉพาะลำดับที่เขียนเป้าหมายย่อยเท่านั้น SLD ยังเป็นกลางเกี่ยวกับกลยุทธ์ในการค้นหาพื้นที่ของการพิสูจน์ SLD ด้วย Prolog ค้นหาพื้นที่นี้จากบนลงล่าง แบบเจาะลึก โดยลองใช้ประโยคย่อยต่างๆ เพื่อแก้ปัญหาเป้าหมาย (ย่อย) เดียวกันตามลำดับที่เขียนประโยคย่อย

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

การย้อนกลับสามารถจำกัดได้โดยใช้เป้าหมายย่อยที่เรียกว่าcutซึ่งเขียนแทนด้วย ! ซึ่งจะสำเร็จเสมอแต่ไม่สามารถย้อนกลับได้ cut สามารถใช้เพื่อเพิ่มประสิทธิภาพได้ แต่ก็อาจรบกวนความหมายเชิงตรรกะของประโยคได้เช่นกัน ในหลายกรณี การใช้ cut สามารถแทนที่ได้ด้วยการปฏิเสธแบบล้มเหลว อันที่จริง การปฏิเสธแบบล้มเหลวสามารถกำหนดได้ใน Prolog โดยใช้ cut ร่วมกับตัวอักษรใดๆ เช่นfailที่รวมเข้ากับส่วนหัวของประโยค no:

ไม่ใช่( P ) :- P , !, ล้มเหลวไม่ใช่( P ) .

นอกจากคำสั่ง cut แล้ว Prolog ยังมีคุณสมบัติอื่นๆ ที่ไม่มีการตีความเชิงตรรกะ เช่น ตัวบ่งชี้ในตัวassertและretractสำหรับการอัปเดตสถานะของโปรแกรมแบบทำลายล้างในระหว่างการทำงานของโปรแกรม

ตัวอย่างเช่นตัวอย่างโลกของบล็อกของเล่นข้างต้นสามารถนำไปใช้ได้โดยไม่ต้องใช้หลักการพื้นฐานของเฟรม โดยใช้การเปลี่ยนแปลงสถานะแบบทำลายล้าง:

บน( บล็อกสีเขียว, ตาราง) บน( บล็อกสีแดง, บล็อกสีเขียว)ย้าย( Object , Place2 ) :- ถอน( บน( Object , Place1 )), ยืนยัน( บน( Object , Place2 ).

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

?- ย้าย( บล็อกสีแดง, โต๊ะ), ย้าย( บล็อกสีเขียว, บล็อกสีแดง), บน( วัตถุ, สถานที่)วัตถุ= บล็อกสีแดง, สถานที่= โต๊ะวัตถุ= บล็อกสีเขียว, สถานที่= บล็อกสีแดง

มีการพัฒนาส่วนขยายต่างๆ ของการเขียนโปรแกรมเชิงตรรกะเพื่อให้กรอบตรรกะสำหรับการเปลี่ยนแปลงสถานะที่ทำลายล้างดังกล่าว^{[ 53 ] [ 54 ] [ 55 ]}

แอปพลิเคชัน Prolog ที่หลากหลาย ทั้งในรูปแบบแยกเดี่ยวและแบบผสมผสานกับภาษาอื่นๆ ได้รับการเน้นย้ำในหนังสือ Year of Prolog ^{[ 21 ]}เพื่อเฉลิมฉลองครบรอบ 50 ปีของ Prolog ในปี 2022

นอกจาก นี้ Prolog ยังมีส่วนช่วยในการพัฒนาภาษาโปรแกรมอื่นๆ อีกหลายภาษา ได้แก่ALF , Fril , Gödel , Mercury , Oz , Ciao , Visual Prolog , XSBและλProlog

การเขียนโปรแกรมเชิงตรรกะแบบมีข้อจำกัด ( Constraint Logic Programmingหรือ CLP) ผสมผสานการเขียนโปรแกรมเชิงตรรกะแบบ Horn clause เข้ากับการแก้ปัญหาข้อจำกัดโดยขยาย Horn clause ด้วยการอนุญาตให้เงื่อนไขบางอย่าง ซึ่งประกาศเป็นเงื่อนไขข้อจำกัด สามารถปรากฏเป็นค่าคงที่ในส่วนเนื้อหาของ clause ได้ เงื่อนไขข้อจำกัดเหล่านี้ไม่ได้ถูกกำหนดโดยข้อเท็จจริงและกฎในโปรแกรม แต่ถูกกำหนดไว้ล่วงหน้าโดยโครงสร้างหรือทฤษฎีแบบจำลองเฉพาะโดเมน

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

ที่น่าสนใจคือ Prolog เวอร์ชันแรกมีเงื่อนไขข้อจำกัด dif(term1, term2) จากวิทยานิพนธ์ปริญญาเอกของ Philippe Roussel ในปี 1972 ซึ่งจะสำเร็จหากอาร์กิวเมนต์ทั้งสองเป็นเทอมที่แตกต่างกัน แต่จะเกิดความล่าช้าหากเทอมใดเทอมหนึ่งมีตัวแปร^{[ 52 ]}

โปรแกรมตรรกะข้อจำกัดต่อไปนี้แสดงถึงฐานข้อมูลเชิงเวลาจำลองของjohn'sประวัติศาสตร์ในฐานะครู:

สอน( จอห์น, ฮาร์ดแวร์, T ) :- 1990 ≤ T , T < 1999 สอน( จอห์น, ซอฟต์แวร์, T ) :- 1999 ≤ T , T < 2005 สอน( จอห์น, ตรรกศาสตร์, T ) :- 2005 ≤ T , T ≤ 2012 ตำแหน่ง( จอห์น, ผู้สอน, T ) :- 1990 ≤ T , T < 2010 ตำแหน่ง( จอห์น, ศาสตราจารย์, T ) :- 2010 ≤ T , T < 2014

ในที่นี้≤และ<เป็นเงื่อนไขข้อจำกัดที่มีความหมายตามปกติ ข้อความเป้าหมายต่อไปนี้จะสอบถามฐานข้อมูลเพื่อหาว่าjohnทั้งlogicและ สอนเมื่อใด professor:

?- สอน( จอห์น, ตรรกศาสตร์, T ), จัดอันดับ( จอห์น, ศาสตราจารย์, T )

วิธีแก้ปัญหานี้ 2010 ≤ T, T ≤ 2012 ได้มาจากการลดความซับซ้อนของข้อจำกัด 2005 ≤ T, T ≤ 2012, 2010 ≤ T, T < 2014.

การเขียนโปรแกรมเชิงตรรกะแบบมีข้อจำกัด (Constraint Logic Programming) ถูกนำมาใช้แก้ปัญหาในสาขาต่างๆ เช่นวิศวกรรมโยธาวิศวกรรมเครื่องกลการตรวจสอบวงจรดิจิทัลการจัดตารางเวลาอัตโนมัติการควบคุมการจราจรทางอากาศและการเงิน โดยมีความเกี่ยวข้องอย่างใกล้ชิดกับการเขียนโปรแกรมเชิงตรรกะแบบอุปนัย (Abductive Logic Programming )

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

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

ในระยะแรกของการพัฒนาฐานข้อมูลเชิงสัมพันธ์ เป็นที่ทราบกันดีว่าการสอบถามแบบเรียกซ้ำไม่สามารถแสดงออกมาได้ทั้งในพีชคณิตเชิงสัมพันธ์หรือแคลคูลัสเชิงสัมพันธ์ และข้อบกพร่องนี้สามารถแก้ไขได้โดยการแนะนำตัวดำเนินการจุดตรึงน้อยที่สุด^{[ 56 ] [ 57 ]}ในทางตรงกันข้าม ความสัมพันธ์แบบเรียกซ้ำสามารถกำหนดได้อย่างเป็นธรรมชาติโดยกฎในโปรแกรมตรรกะ โดยไม่จำเป็นต้องมีตัวเชื่อมหรือตัวดำเนินการตรรกะใหม่ใดๆ

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

ตัวอย่างเช่น ลองพิจารณาฐานข้อมูลครอบครัว:

แม่ลูก( เอ ลิซาเบธ, ชาร์ลส์) พ่อลูก (ชาร์ลส์, วิลเลียม) พ่อลูก ( ชาร์ลส์, แฮร์รี่) พ่อแม่ลูก( X , Y ) : - แม่ลูก( X , Y ) พ่อแม่ลูก( X , Y ) : - พ่อลูก( X , Y ) บรรพบุรุษลูกหลาน ( X, Y) :- พ่อแม่ลูก (X , X ) บรรพบุรุษลูกหลาน( X , Y ) : - บรรพบุรุษลูกหลาน( X , Z ) , บรรพบุรุษลูกหลาน( Z , Y )

การดำเนินการจากล่างขึ้นบนจะสรุปข้อเท็จจริงเพิ่มเติมดังต่อไปนี้และสิ้นสุดลง:

parent_child ( elizabeth , charles ). parent_child ( charles , william ). parent_child ( charles , harry ).บรรพบุรุษ_ลูกหลาน( เอลิซาเบธ, ชาร์ลส์) บรรพบุรุษ_ลูกหลาน( ชาร์ลส์, วิลเลียม) บรรพบุรุษ_ลูกหลาน( ชาร์ลส์, แฮร์รี่)ancestor_descendant ( elizabeth , william ). ancestor_descendant ( elizabeth , harry ).

การดำเนินการจากบนลงล่างให้คำตอบเดียวกันสำหรับคำถาม:

?- บรรพบุรุษ_ลูกหลาน( X , Y ).

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

เช่นเดียวกับ Datalog การเขียนโปรแกรมแบบ Answer Set Programming (ASP) ไม่ใช่เครื่องจักรที่สมบูรณ์แบบตามทฤษฎีบทของ Turing ยิ่งไปกว่านั้น แทนที่จะแยกเป้าหมาย (หรือคำถาม) ออกจากโปรแกรมที่จะใช้ในการแก้ปัญหาเป้าหมาย ASP จะถือว่าโปรแกรมทั้งหมดเป็นเป้าหมาย และแก้ปัญหาเป้าหมายโดยการสร้างแบบจำลองที่เสถียรซึ่งทำให้เป้าหมายเป็นจริง เพื่อจุดประสงค์นี้ ASP ใช้ความหมายของแบบจำลองที่เสถียรซึ่งตามหลักการนี้ โปรแกรมเชิงตรรกะสามารถมีแบบจำลองที่ตั้งใจไว้ได้ศูนย์ หนึ่ง หรือมากกว่านั้น ตัวอย่างเช่น โปรแกรมต่อไปนี้แสดงถึงรูปแบบที่เสื่อมสภาพของปัญหาการระบายสีแผนที่ในการระบายสีสองประเทศเป็นสีแดงหรือสีเขียว:

ประเทศ( oz ) ประเทศ( iz ) ที่อยู่ติดกัน( oz , iz ) สี( C , แดง) :- ประเทศ( C ), ไม่ใช่( สี( C , เขียว)) สี( C , เขียว) :- ประเทศ( C ), ไม่ใช่( สี( C , แดง))

ปัญหาดังกล่าวมีสี่วิธีแก้ ซึ่งแสดงโดยแบบจำลองที่เสถียรสี่แบบ:

ประเทศ( ออนซ์) ประเทศ( อิซ) ที่อยู่ติดกัน( ออนซ์, อิซ) สี( ออนซ์, แดง) สี( อิซ, แดง)ประเทศ( ออนซ์) ประเทศ( อิซ) ที่อยู่ติดกัน( ออนซ์, อิซ) สี( ออนซ์, เขียว) สี( อิซ, เขียว)ประเทศ( ออนซ์) ประเทศ( อิซ) ที่อยู่ติดกัน( ออนซ์, อิซ) สี( ออนซ์, แดง) สี( อิซ, เขียว)ประเทศ( oz ) ประเทศ( iz ) ที่อยู่ติดกัน( oz , iz ) สี( oz , เขียว) สี( iz , แดง)

ในการแสดงเวอร์ชันมาตรฐานของปัญหาการระบายสีแผนที่ เราจำเป็นต้องเพิ่มข้อจำกัดว่าประเทศที่อยู่ติดกันสองประเทศไม่สามารถมีสีเดียวกันได้ ใน ASP ข้อจำกัดนี้สามารถเขียนเป็นข้อความในรูปแบบ:

:- ประเทศ( C1 ), ประเทศ( C2 ), ที่อยู่ติดกัน( C1 , C2 ), สี( C1 , X ), สี( C2 , X )

เมื่อเพิ่มข้อจำกัดนี้เข้าไป ปัญหาจึงเหลือเพียงสองคำตอบเท่านั้น:

ประเทศ( ออนซ์) ประเทศ( อิซ) ที่อยู่ติดกัน( ออนซ์, อิซ) สี( ออนซ์, แดง) สี( อิซ, เขียว)ประเทศ( oz ) ประเทศ( iz ) ที่อยู่ติดกัน( oz , iz ) สี( oz , เขียว) สี( iz , แดง)

การเพิ่มข้อจำกัดในรูปแบบดังกล่าว:- Body.จะขจัดแบบจำลองที่Bodyเป็นจริงออก ไป

ที่น่าสับสนคือข้อจำกัดใน ASPแตกต่างจากข้อจำกัดใน CLPข้อจำกัดใน CLP คือเงื่อนไขที่ใช้ตรวจสอบคำตอบของคำถาม (และวิธีแก้ปัญหาของเป้าหมาย) ในขณะที่ข้อจำกัดใน ASP คือข้อความที่ตัดโมเดลที่อาจตอบโจทย์เป้าหมายได้ ข้อจำกัดใน ASP คล้ายกับข้อจำกัดด้านความสมบูรณ์ในฐานข้อมูล

การผสมผสานระหว่างข้อความการเขียนโปรแกรมตรรกะทั่วไปและข้อความข้อจำกัดนี้แสดงให้เห็นถึงวิธีการสร้างและทดสอบในการแก้ปัญหาใน ASP: ข้อความทั่วไปจะกำหนดพื้นที่การค้นหาของโซลูชันที่เป็นไปได้ และข้อจำกัดจะกรองโซลูชันที่ไม่ต้องการออกไป^{[ 58 ]}

การใช้งาน ASP ส่วนใหญ่จะดำเนินการในสองขั้นตอน: ขั้นแรก พวกเขาจะสร้างอินสแตนซ์ของโปรแกรมในทุกวิถีทางที่เป็นไปได้ ลดทอนให้เป็นโปรแกรมตรรกะเชิงประพจน์ (เรียกว่าgrounding ) จากนั้น พวกเขาจะใช้ตัวแก้ปัญหาตรรกะเชิงประพจน์ เช่นอัลกอริทึม DPLLหรือตัวแก้ปัญหา Boolean SATอย่างไรก็ตาม การใช้งานบางอย่าง เช่น s(CASP) ^{[ 59 ]}ใช้ขั้นตอนการแก้ปัญหา SLD แบบบนลงล่างที่มุ่งเน้นเป้าหมายโดยไม่ต้อง grounding

การเขียนโปรแกรมตรรกะแบบอุปนัย^{[ 60 ]} (ALP) เช่นเดียวกับ CLP ขยายการเขียนโปรแกรมตรรกะปกติโดยอนุญาตให้เนื้อหาของข้อความมีตัวอักษรที่มีภาคแสดงที่ไม่ได้กำหนดโดยข้อความ ใน ALP ภาคแสดงเหล่านี้จะถูกประกาศว่าสามารถอนุมานได้ (หรือสมมติได้ ) และถูกใช้เช่นเดียวกับการให้เหตุผลแบบอุปนัยเพื่ออธิบายการสังเกต หรือโดยทั่วไปเพื่อเพิ่มข้อเท็จจริงใหม่ให้กับโปรแกรม (เป็นสมมติฐาน) เพื่อแก้ปัญหาเป้าหมาย

ตัวอย่างเช่น สมมติว่าเราได้รับสถานะเริ่มต้นที่บล็อกสีแดงวางอยู่บนบล็อกสีเขียวบนโต๊ะ ณ เวลา 0:

holds ( on ( green_block , table ), 0 ). holds ( on ( red_block , green_block ), 0 ).

สมมติว่าเราได้รับเป้าหมายเพิ่มเติมดังนี้:

?- holds ( on ( green_block , red_block ), 3 ), holds ( on ( red_block , table ), 3 ).

เป้าหมายสามารถแสดงถึงการสังเกต ซึ่งในกรณีนี้ วิธีแก้ปัญหาคือคำอธิบายของการสังเกต หรือเป้าหมายสามารถแสดงถึงสถานการณ์ในอนาคตที่ต้องการ ซึ่งในกรณีนี้ วิธีแก้ปัญหาคือแผนการเพื่อให้บรรลุเป้าหมาย^{[ 61 ]}

เราสามารถใช้กฎของเหตุและผลที่กล่าวถึงไปก่อนหน้านี้เพื่อแก้ปัญหาเป้าหมายได้ โดยถือว่าhappensภาคแสดงสามารถอนุมานได้:

holds ( Fact , Time2 ) :- happens ( Event , Time1 ), Time2 is Time1 + 1 , initiates ( Event , Fact ).holds ( Fact , Time2 ) :- happens ( Event , Time1 ), Time2 is Time1 + 1 , holds ( Fact , Time1 ), not ( terminated ( Fact , Time1 )).ยุติ( ข้อเท็จจริง, เวลา) :- เกิดขึ้น( เหตุการณ์, เวลา), ยุติ( เหตุการณ์, ข้อเท็จจริง)เริ่มต้น( ย้าย( Object , Place ), บน( Object , Place )) สิ้นสุด( ย้าย( Object , Place2 ), บน( Object , Place1 ))

ALP แก้ปัญหาโดยใช้เหตุผลย้อนกลับและเพิ่มสมมติฐานลงในโปรแกรม เพื่อแก้ปัญหาเป้าหมายย่อยที่สามารถอนุมานได้ ในกรณีนี้มีวิธีแก้ปัญหาทางเลือกมากมาย รวมถึง:

เกิดขึ้น( ย้าย( บล็อกสีแดง, ตาราง), 0 ) เกิดขึ้น( ติ๊ก, 1 ) เกิดขึ้น( ย้าย( บล็อกสีเขียว, บล็อกสีแดง), 2 )

เกิดขึ้น( ติ๊ก, 0 ) เกิดขึ้น( ย้าย( บล็อกสีแดง, ตาราง), 1 ) เกิดขึ้น( ย้าย( บล็อกสีเขียว, บล็อกสีแดง), 2 )

เกิดขึ้น( ย้าย( บล็อกสีแดง, ตาราง), 0 ) เกิดขึ้น( ย้าย( บล็อกสีเขียว, บล็อกสีแดง), 1 ) เกิดขึ้น( ติ๊ก, 2 )

นี่tickคือเหตุการณ์ที่บ่งบอกถึงการผ่านไปของเวลาโดยไม่เริ่มต้นหรือยุติความสัมพันธ์ใดๆ

นอกจากนี้ยังมีกรณีที่moveเหตุการณ์ทั้งสองเกิดขึ้นพร้อมกัน ตัวอย่างเช่น:

เกิดขึ้น( ย้าย( บล็อกสีแดง, ตาราง), 0 ) เกิดขึ้น( ย้าย( บล็อกสีเขียว, บล็อกสีแดง), 0 ) เกิดขึ้น( ติ๊ก, 1 ) เกิดขึ้น( ติ๊ก, 2 )

หากไม่ต้องการใช้โซลูชันดังกล่าว สามารถลบออกได้โดยการเพิ่มข้อจำกัดด้านความสมบูรณ์ ซึ่งคล้ายกับข้อกำหนดข้อจำกัดใน ASP:

:- เกิดขึ้น( ย้าย( บล็อก1 , สถานที่), เวลา), เกิดขึ้น( ย้าย( บล็อก2 , บล็อก1 ), เวลา)

การเขียนโปรแกรมตรรกะแบบอุปนัยถูกนำมาใช้สำหรับการวินิจฉัยข้อผิดพลาด การวางแผน การประมวลผลภาษาธรรมชาติ และการเรียนรู้ของเครื่อง นอกจากนี้ยังถูกนำมาใช้เพื่อตีความการปฏิเสธว่าเป็นความล้มเหลวในรูปแบบของการให้เหตุผลแบบอุปนัย^{[ 62 ]}

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

ILP คล้ายกับ ALP ตรงที่ทั้งสองสามารถมองได้ว่าเป็นการสร้างสมมติฐานเพื่ออธิบายการสังเกต และใช้ข้อจำกัดเพื่อตัดสมมติฐานที่ไม่พึงประสงค์ออกไป แต่ใน ALP สมมติฐานเป็นข้อเท็จจริงที่ไม่มีตัวแปร ในขณะที่ใน ILP สมมติฐานเป็นกฎทั่วไป^{[ 63 ] [ 64 ]}

ตัวอย่างเช่น เมื่อพิจารณาเพียงความรู้พื้นฐานเกี่ยวกับความสัมพันธ์ระหว่างแม่กับลูกและพ่อกับลูก และตัวอย่างที่เหมาะสมของความสัมพันธ์ระหว่างปู่ย่าตายายกับลูก ระบบ ILP ปัจจุบันสามารถสร้างคำจำกัดความของความสัมพันธ์ระหว่างปู่ย่าตายายกับลูกได้ โดยการสร้างภาคแสดงเสริม ซึ่งสามารถตีความได้ว่าเป็นความสัมพันธ์ระหว่างพ่อแม่กับลูก: ^{[ 65 ]}

ปู่ย่าตายาย_ลูก( X , Y ):- ผู้ช่วย( X , Z ), ผู้ช่วย( Z , Y ). ผู้ช่วย( X , Y ):- แม่_ลูก( X , Y ). ผู้ช่วย( X , Y ):- พ่อ_ลูก( X , Y ).

Stuart Russell ^{[ 66 ]}ได้อ้างถึงการประดิษฐ์แนวคิดใหม่ดังกล่าวว่าเป็นขั้นตอนที่สำคัญที่สุดที่จำเป็นต่อการบรรลุถึงปัญญาประดิษฐ์ในระดับมนุษย์

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

การเขียนโปรแกรมเชิงตรรกะแบบขนานเป็นการผสานรวมแนวคิดของการเขียนโปรแกรมเชิงตรรกะเข้ากับการเขียนโปรแกรมแบบขนานการพัฒนาได้รับแรงผลักดันอย่างมากในช่วงทศวรรษ 1980 จากการเลือกใช้เป็นภาษาการเขียนโปรแกรมระบบของโครงการรุ่นที่ห้าของญี่ปุ่น (FGCS ⁾ [ ^{67 ]}

โปรแกรมตรรกะแบบขนาน คือ ชุดของข้อความฮอร์น ที่มีเงื่อนไข ซึ่งมีรูปแบบดังนี้:

H :- G1, ..., Gn | B1, ..., Bn.

คำสันธานนี้เรียกว่าตัวป้องกันของประโยค และ|คือตัวดำเนินการยืนยัน ในทางตรรกะ ประโยคฮอร์นที่มีตัวป้องกันจะถูกอ่านเหมือนกับการบ่งชี้เชิงตรรกะทั่วไป: G1, ... , Gn

H if G1 and ... and Gn and B1 and ... and Bn.

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

ตัวอย่างเช่น โปรแกรมตรรกะแบบขนานต่อไปนี้กำหนด述语 (predicate shuffle(Left, Right, Merge)) ซึ่งสามารถใช้เพื่อสลับลำดับของรายการสองรายการLeftและRightโดยรวมเข้าเป็นรายการเดียวMergeที่ยังคงรักษาลำดับของรายการทั้งสองLeftไว้Right:

สับเปลี่ยน([], [], []). สับเปลี่ยน( ซ้าย, ขวา, รวม) :- ซ้าย= [ แรก| ที่เหลือ] | รวม= [ แรก| รวมแบบสั้น], สับเปลี่ยน( ที่เหลือ, ขวา, รวมแบบสั้น). สับเปลี่ยน( ซ้าย, ขวา, รวม) :- ขวา= [ แรก| ที่เหลือ] | รวม= [ แรก| รวมแบบสั้น], สับเปลี่ยน( ซ้าย, ที่เหลือ, รวมแบบสั้น).

ในที่นี้[]แทนรายการว่าง และ[Head | Tail]แทนรายการที่มีองค์ประกอบแรกHeadตามด้วยรายการTailเหมือนในภาษาโปรล็อก (โปรดสังเกตว่า| ตัวแรกในประโยคที่สองและสามคือตัวสร้างรายการ ในขณะที่ |ตัวที่สองคือตัวดำเนินการยืนยัน) โปรแกรมนี้สามารถใช้เพื่อสลับลำดับรายการได้ เช่น[ace, queen, king]โดย[1, 4, 2]การเรียกใช้ประโยคเป้าหมาย:

สับเปลี่ยน([ เอซ, ควีน, คิง], [ 1 , 4 , 2 ], รวม)

โปรแกรมจะสร้างคำตอบเดียวแบบไม่แน่นอน ตัวอย่างMerge = [ace, queen, 1, king, 4, 2]เช่น

Carl Hewittได้โต้แย้ง^{[ 68 ]}ว่าเนื่องจากความไม่แน่นอนของการคำนวณพร้อมกันการเขียนโปรแกรมตรรกะพร้อมกันจึงไม่สามารถดำเนินการพร้อมกันทั่วไปได้ อย่างไรก็ตาม ตามความหมายเชิงตรรกะ ผลลัพธ์ใดๆ ของการคำนวณของโปรแกรมตรรกะพร้อมกันถือเป็นผลลัพธ์เชิงตรรกะของโปรแกรม แม้ว่าผลลัพธ์เชิงตรรกะทั้งหมดจะไม่สามารถอนุมานได้ก็ตาม

การเขียนโปรแกรมตรรกะข้อจำกัดแบบพร้อมกัน^{[ 69 ]}ผสมผสานการเขียนโปรแกรมตรรกะแบบพร้อมกันและการเขียนโปรแกรมตรรกะข้อจำกัดโดยใช้ข้อจำกัดเพื่อควบคุมการทำงานพร้อมกัน ข้อความสามารถมีตัวป้องกัน ซึ่งเป็นชุดของข้อจำกัดที่อาจบล็อกการใช้งานของข้อความ เมื่อตัวป้องกันของข้อความหลายข้อความเป็นไปตามเงื่อนไข การเขียนโปรแกรมตรรกะข้อจำกัดแบบพร้อมกันจะเลือกใช้เพียงข้อความเดียวเท่านั้น

นักวิจัยหลายคนได้ขยายการเขียนโปรแกรมเชิงตรรกะด้วย^{คุณสมบัติ}การเขียนโปรแกรมลำดับสูงที่ได้มาจากตรรกะลำดับสูงเช่น ตัวแปรภาคแสดง ภาษาดังกล่าวรวมถึงส่วนขยาย Prolog อย่างHiLog ^{[ 70 ]}และλProlog [ ^{71 ]}

การใช้ตรรกะเชิงเส้นเป็นพื้นฐานในการเขียนโปรแกรมเชิงตรรกะส่งผลให้มีการออกแบบภาษาการเขียนโปรแกรมเชิงตรรกะที่มีความสามารถในการแสดงออกมากกว่าภาษาที่ใช้ตรรกะแบบคลาสสิกอย่างมาก โปรแกรม Horn clause สามารถแสดงการเปลี่ยนแปลงสถานะได้โดยการเปลี่ยนแปลงอาร์กิวเมนต์ของเพรดิเคตเท่านั้น ในการเขียนโปรแกรมเชิงตรรกะเชิงเส้น เราสามารถใช้ตรรกะเชิงเส้นโดยรอบเพื่อสนับสนุนการเปลี่ยนแปลงสถานะได้ การออกแบบภาษาการเขียนโปรแกรมเชิงตรรกะในยุคแรกๆ ที่ใช้ตรรกะเชิงเส้น ได้แก่ LO ^{[ 72 ]} Lolli ^{[ 73 ]} ACL ^{[ 74 ]}และ Forum ^{[ 75 ]} Forum ให้การตีความตรรกะเชิงเส้นทั้งหมดที่มุ่งเน้นเป้าหมาย

F-logic ^{[ 76 ]}ขยายการเขียนโปรแกรมเชิงตรรกะด้วยวัตถุและไวยากรณ์เฟรม

Logtalk ^{[ 77 ]}ขยายภาษาการเขียนโปรแกรม Prolog ด้วยการสนับสนุนวัตถุ โปรโตคอล และแนวคิด OOP อื่นๆ โดยรองรับระบบ Prolog ที่สอดคล้องกับมาตรฐานส่วนใหญ่ในฐานะคอมไพเลอร์แบ็กเอนด์

ตรรกะธุรกรรม^{[ 53 ]}เป็นส่วนขยายของการเขียนโปรแกรมเชิงตรรกะด้วยทฤษฎีเชิงตรรกะของการอัปเดตที่ปรับเปลี่ยนสถานะ มีทั้งความหมายเชิงทฤษฎีแบบจำลองและความหมายเชิงกระบวนการ การใช้งานชุดย่อยของตรรกะธุรกรรมมีอยู่ใน ระบบ Flora-2 ^{[ 78 ]}ต้นแบบอื่นๆ ก็มีให้ใช้งานเช่น กัน

• การพิสูจน์ทฤษฎีบทอัตโนมัติ
• ปัญหาความพึงพอใจแบบบูลีน
• การเขียนโปรแกรมตรรกะแบบมีข้อจำกัด
• ทฤษฎีการควบคุม
• บันทึกข้อมูล
• ฟริล
• การเขียนโปรแกรมเชิงฟังก์ชัน
• ตรรกะคลุมเครือ
• การเขียนโปรแกรมเชิงตรรกะแบบอุปนัย
• ตรรกะเชิงเส้น
• ตรรกศาสตร์ในวิทยาการคอมพิวเตอร์ (รวมถึงวิธีการเชิงรูปธรรม )
• ภาษาการเขียนโปรแกรมเชิงตรรกะ
• ตัวควบคุมลอจิกแบบโปรแกรมได้
• อาร์++
• ระบบการให้เหตุผล
• การเรียนรู้ของเครื่องจักรแบบใช้กฎเกณฑ์
• ความพึงพอใจ
• ไวยากรณ์และความหมายของการเขียนโปรแกรมเชิงตรรกะ

• Baral, C.; Gelfond, M. (1994). "การเขียนโปรแกรมเชิงตรรกะและการแสดงความรู้" (PDF)วารสารการเขียนโปรแกรมเชิงตรรกะ 19–20 : 73–148 . doi : 10.1016 /0743-1066(94) 90025-6
• Kowalski, RA (1988). "ช่วงปีแรก ๆ ของการเขียนโปรแกรมเชิงตรรกะ" (PDF) . Communications of the ACM . 31 : 38– 43. doi : 10.1145/35043.35046 . S2CID  12259230 .[1]
• ลอยด์, เจดับบลิว (1987). พื้นฐานของการเขียนโปรแกรมเชิงตรรกะ (ฉบับที่ 2). สปริงเกอร์-เวอร์แลก.

• จอห์น แมคคาร์ธี. "โปรแกรมที่มีสามัญสำนึก" . การประชุมสัมมนาเรื่องการใช้กลไกในการคิด . ห้องปฏิบัติการฟิสิกส์แห่งชาติ. เทดดิงตัน, อังกฤษ. 1958.
• Miller, Dale; Nadathur, Gopalan; Pfenning, Frank; Scedrov, Andre (1991). "การพิสูจน์แบบเอกภาพเป็นรากฐานสำหรับการเขียนโปรแกรมเชิงตรรกะ" . Annals of Pure and Applied Logic . 51 ( 1– 2): 125– 157. doi : 10.1016/0168-0072(91)90068-W .
• เอฮุด ชาปิโร (บรรณาธิการ). Concurrent Prolog . สำนักพิมพ์ MIT. 1987.
• เจมส์ สเลเกิล. "การทดลองกับโปรแกรมตอบคำถามแบบนิรนัย" . CACM. ธันวาคม 1965.
• Gabbay, Dov M. ; Hogger, Christopher John; Robinson, JA, บรรณาธิการ (1993–1998). คู่มือตรรกศาสตร์ในปัญญาประดิษฐ์และการเขียนโปรแกรมเชิงตรรกศาสตร์เล่ม 1–5, สำนักพิมพ์มหาวิทยาลัยออกซ์ฟอร์ด

• คาร์ล ฮิววิตต์. " การฝังความรู้เชิงกระบวนการในโปรแกรมวางแผน ". IJCAI 1971.
• คาร์ล ฮิววิตต์. " การล่มสลายซ้ำแล้วซ้ำเล่าของการเขียนโปรแกรมเชิงตรรกะและเหตุใดมันจึงจะกลับมาเกิดใหม่ ". การประชุมสัมมนาฤดูใบไม้ผลิของ AAAI: อะไรผิดพลาดและเพราะเหตุใด: บทเรียนจากการวิจัยและการประยุกต์ใช้ AIปี 2006: 2–9.
• Evgeny Dantsin, Thomas Eiter, Georg Gottlob, Andrei Voronkov: ความซับซ้อนและพลังการแสดงออกของการเขียนโปรแกรมเชิงตรรกะ ACM Comput. Surv. 33(3): 374–425 (2001)
• อูล์ฟ นิลส์สัน และ แยน มาลูซินสกี, ตรรกศาสตร์, การเขียนโปรแกรม และ Prolog

วิกิมีเดียคอมมอนส์มีสื่อที่เกี่ยวข้องกับ การ เขียนโปรแกรมเชิงตรรกะ

• รายการในห้องสมุดเสมือนจริงด้านการเขียนโปรแกรมเชิงตรรกะ
• บรรณานุกรมเกี่ยวกับการเขียนโปรแกรมเชิงตรรกะเก็บถาวรเมื่อวันที่ 4 ธันวาคม 2008 ที่Wayback Machine
• สมาคมการเขียนโปรแกรมเชิงตรรกะ (ALP)
• ทฤษฎีและการปฏิบัติของการเขียนโปรแกรมเชิงตรรกะ (วารสาร)
• การเขียนโปรแกรมเชิงตรรกะในภาษา C++ โดยใช้ Castor
• การเขียนโปรแกรมเชิงตรรกะเก็บถาวรเมื่อ 2011-09-03 ที่Wayback Machineในออสเตรเลีย
• ศูนย์พัฒนาโปรล็อก
• Racklog: การเขียนโปรแกรมเชิงตรรกะในภาษา Racket