Prolog। हम मशीनों को प्रोग्राम करते हैं

प्रोलॉग के बारे में एक लेख पढ़ने के बाद, मैंने 2 छोटे कार्यों के रूप में इसके लिए एक छोटा सा अतिरिक्त लिखने का फैसला किया।
यहाँ वे हैं:
1. दिमागी भाषा की व्याख्या करनेवाला
2. ट्यूरिंग मशीन

पहले हमें SWI- प्रोलॉग और कुछ खाली समय चाहिए।

कार्य 1. दिमागी भाषा दुभाषिया

चलिए शुरुआत करते हैं विकिपीडिया से कॉपी-पेस्ट से।
Brainfuck सबसे प्रसिद्ध गूढ़ प्रोग्रामिंग भाषाओं में से एक है, जिसे 1993 में अर्बन मुलर द्वारा मनोरंजन के लिए बनाया गया था। भाषा में आठ कमांड होते हैं, जिनमें से प्रत्येक एक चरित्र में लिखा जाता है। ब्रेनफैक कार्यक्रम के लिए स्रोत कोड बिना किसी अतिरिक्त वाक्यविन्यास के इन वर्णों का एक क्रम है।
ब्रेनफक कमांड द्वारा नियंत्रित एक मशीन में कोशिकाओं का एक क्रमबद्ध सेट और वर्तमान सेल के लिए एक पॉइंटर होता है, जो ट्यूरिंग मशीन के टेप और सिर जैसा दिखता है। इसके अलावा, यह इनपुट स्ट्रीम और आउटपुट स्ट्रीम के माध्यम से बाहरी दुनिया के साथ संचार करने के लिए एक उपकरण का अर्थ है (आदेश देखें।)।

कमांड और उनका विवरण:

• > अगली सेल पर जाएं
• <पिछली सेल पर जाएं
• + वर्तमान सेल में 1 से मान बढ़ाएं
• - वर्तमान सेल में मूल्य 1 से घटाएं
• । वर्तमान सेल से प्रिंट मूल्य
• , बाहर से मान दर्ज करें और वर्तमान सेल में सहेजें
• [यदि वर्तमान सेल का मान शून्य है, तो प्रोग्राम पाठ में सेल से संबंधित उसी के बाद आगे बढ़ें] (नेस्टिंग सहित)
• ] यदि वर्तमान सेल का मान शून्य नहीं है, तो प्रोग्राम टेक्स्ट के माध्यम से प्रतीक पर वापस जाएं [(खाते में घोंसले का शिकार करना)

टेप को डेटाबेस के रूप में प्रस्तुत किया जाता है
डेटा (पता, मान)।
सेल एड्रेस द्वारा दर्शाया गया हेड
स्थिति (पता)।

वास्तव में टिप्पणी के साथ कोड:

% , cout:- %    pos(Addr), %  data(Addr,Value), %    put_char([Value]). % . cin:- %    pos(Addr), %    retract(data(Addr,_)), %  get_single_char(Value), %    assert(data(Addr,Value)). % + - add(AddValue):- %  pos(Addr), %  retract(data(Addr,Value)), %   1 NewValue is Value+AddValue, %   assert(data(Addr,NewValue)). % > < addr(Side):- %   retract(pos(Addr)), %   NewAddr is Addr+Side, %     assert(pos(NewAddr)), %       (data(NewAddr,_),!;assert(data(NewAddr,0))). % ] goto:- %  pos(Addr), %      0 data(Addr,Value),Value==0,!, % 0,        retract(circle([_|L])), %  assert(circle(L)). goto:- %     circle([[N,_]|_]), seeing(Stream), seek(Stream,N,bof,_). % [ loop:- %       retract(circle(L)), seeing(Stream), %    character_count(Stream,Pos), %   %(  = 0,     ) pos(Addr), data(Addr,Value), assert(circle([[Pos,Value]|L])). do:- %  get_char(X), %  step(X), %    not(at_end_of_stream),!, do. do:- % ,    seeing(Stream), close(Stream), seen. step('['):-loop,!. step(']'):-goto,!. %    " " %(       ) step(_):-circle([[_,StartValue]|_]),StartValue==0,!. step('>'):-addr( 1),!. step('<'):-addr(-1),!. step(','):-cin,!. step('.'):-cout,!. step('+'):-add( 1),!. step('-'):-add(-1),!. step(_). run(Path):- see(Path), %  (    ) retractall(pos(_)), retractall(data(_,_)), retractall(circle(_)), %    assert(pos(1)), %  0 assert(data(1,0)), assert(circle([])),do. 

टर्मिनल में जाँच करने के लिए, लिखें:

freest @ PC: $ swipl -s <path.tofile>
? -रुण ('पाथ.टो.ब्रेनफक.कोड')।

हम विकी से एक उदाहरण पर परीक्षण करेंगे।

नमस्ते विश्व! दिमाग पर

+++++++++++ [> ++++++++++++++++++++++++++++ <<<< -]> ++
।>। +। ++++++++ +++। ++ ++। << +++++++++++++++++++। ++ ++।
------.-------->> +>।

कुछ इस तरह से सामने आना चाहिए:

freest @ PC: / मीडिया / C6984667984655D9 $ swipl -s bf.pro
% पुस्तकालय (swi_hooks) pce_swi_hooks में संकलित 0.00 सेकंड, 2,224 बाइट्स
% /मीडिया / C6984667984655D9/bf.pro संकलित 0.00 सेकंड, 4,676 बाइट्स
स्व-प्रोलॉग में आपका स्वागत है (बहु-थ्रेडेड, 32 बिट्स, संस्करण 5.10.4)
कॉपीराइट © 1990-2011 एम्स्टर्डम विश्वविद्यालय, VU एम्स्टर्डम
SWI- प्रोलॉग ABSOLUTELY NO WARRANTY के साथ आता है। यह मुफ्त सॉफ्टवेयर है,
और आपको कुछ शर्तों के तहत इसका पुनर्वितरण करने का स्वागत है
जानकारी के लिए कृपया www.swi-prolog.org पर जाएं।

मदद के लिए, उपयोग? - मदद (विषय)। या? - एप्रोपोस (शब्द)।

? - भागो ('a.txt')।
नमस्ते विश्व!
सच।

- -

समस्या 2. ट्यूरिंग मशीन

फिर विकी से थोड़ा सिद्धांत
ट्यूरिंग मशीन (MT) - एब्सट्रैक्ट परफ़ॉर्मर (अमूर्त कंप्यूटिंग मशीन)। यह 1936 में एलन ट्यूरिंग द्वारा एक एल्गोरिथ्म की अवधारणा को औपचारिक रूप देने के लिए प्रस्तावित किया गया था।
ट्यूरिंग मशीन एक परिमित राज्य मशीन का एक विस्तार है और चर्च के अनुसार - ट्यूरिंग थीसिस, अन्य सभी कलाकारों (संक्रमण नियमों को निर्धारित करके) का अनुकरण करने में सक्षम है जो किसी भी तरह चरण-दर-चरण गणना प्रक्रिया को लागू करते हैं जिसमें गणना का प्रत्येक चरण काफी प्राथमिक होता है।
एक विशिष्ट ट्यूरिंग मशीन को वर्णमाला ए के अक्षरों के सेट के तत्वों को सूचीबद्ध करके परिभाषित किया जाता है, राज्यों का सेट क्यू और नियमों का सेट जिसके द्वारा मशीन काम करती है। उनके पास फॉर्म है: qiaj → qi1aj1dk (यदि सिर क्यूई अवस्था में है और अक्षर aj को मॉनिटर किए गए सेल में लिखा गया है, तो सिर qi1 स्थिति में चला जाता है, aj1 aj के बजाय सेल में लिखा जाता है, सिर aj dk बनाता है, जिसमें तीन विकल्प होते हैं: सेल से बाईं ओर के तीन विकल्प। (L), सेल से दाईं ओर ®, जगह (N) पर रहें। प्रत्येक संभावित कॉन्फ़िगरेशन के लिए <qi, aj> बिल्कुल एक नियम है। केवल अंतिम स्थिति के लिए कोई नियम नहीं हैं, जिसमें एक बार मशीन बंद हो जाती है। इसके अलावा, अंतिम और प्रारंभिक राज्यों, टेप पर प्रारंभिक कॉन्फ़िगरेशन और मशीन के प्रमुख के स्थान को इंगित करना आवश्यक है।

हम वीका द्वारा प्रस्तावित एमटी का उपयोग करेंगे

q0 * → q0 * R
q01 → q01R
q0 × → q1 × R
q11 → q2aR
q21 → q21L
q2a → q2aL
q2 = → q2 = L
q2 × → q3 × L
q31 → q4aR
q3a → q3aL
क्यू 3 * → क्यू 6 * आर
q4 × → q4 × R
q4a → q4aR
q4 = → q4 = R
q41 → q41R
q4 * → q51R
q5 * → q2 * L
q6a → q61R
q6 × → q7 × R
q7a → q7aR
q71 → q2aR
q7 = → q8 = L
q8a → q81L
q8 × → q9H

डेटा (एल, वी, आर) - टेप का प्रतिनिधित्व (एल - बाईं ओर, आर - दाएं, वी - वर्तमान सेल)।
... [१] [२] [३] [ ४ ] [५] [६] [2] ...
L = [3,2,1] V = 4 R = [5,6,7]
खाली सेल मान - *

 %  revers([],R,R):-!. revers([H|T],L,R):-revers(T,[H|L],R). %    l:- %  (retract(data([Hl|Tl],V,R)),!; %    ,         (*) retract(data([],V,R)),Hl=(*),Tl=[]), %    assert(data(Tl,Hl,[V|R])). r:- %  (retract(data(L,V,[Hr|Tr])),!; %    ,         (*) retract(data(L,V,[])),Hr=(*),Tr=[]), %    assert(data([V|L],Hr,Tr)). %      n. % . %revers      (  data). initData(L,V,R):- % (   ) retractall(data(_,_,_)), %  (   ) revers(L,[],Lr), %    . assert(data(Lr,V,R)). %   input(Value):- %    ,      . retract(data(L,_,R)), %      . assert(data(L,Value,R)). %    info(Q:A:Qn:An:D):- %   write(Q:A),nl, write(Qn:An:D),nl, %    « » data(L,Value,R),revers(L,[],Lr),append(Lr,[[Value]|R],Data), write(Data),nl. %  %(, ,  , ). %        q0(*,q0,*,r). q0(1,q0,1,r). q0(x,q1,x,r). q1(1,q2,a,r). q2(1,q2,1,l). q2(a,q2,a,l). q2(=,q2,=,l). q2(x,q3,x,l). q3(1,q4,a,r). q3(a,q3,a,l). q3(*,q6,*,r). q4(x,q4,x,r). q4(a,q4,a,r). q4(=,q4,=,r). q4(1,q4,1,r). q4(*,q5,1,r). q5(*,q2,*,l). q6(a,q6,1,r). q6(x,q7,x,r). q7(a,q7,a,r). q7(1,q2,a,r). q7(=,q8,=,l). q8(a,q8,1,l). q8(x,e,x,n). %e —  . start(e):-write(end),!. %   Q start(Q):- %   data(_,A,_), %   apply(Q,[A,Qn,An,D]), %  info(Q:A:Qn:An:D), %  input(An), %  call(D), %    start(Qn). 

हम एमटी लॉन्च करते हैं

$ स्वाइल -s 1.pro
? - initData ([], *, [1,1,1, x, 1,1, =, *]]।
? - प्रारंभ (q0)।

और यहाँ परिणाम है।

$ स्वाइल -s 1.pro
...
? - initData ([], *, [1,1,1, x, 1,1, =, *]]।
सच।

? - प्रारंभ (q0)।
q0: (*)
q0: (*): आर
[[*], ११,११, x, ११, =, *]
q0: 1
q0: 1: r
[*, [१], ११, x, ११, =, *]
....
....
....
q8: ए
q8: 1: l
[*, 1,1,1, x, [a], १, =, १,१,१,१,१,१,१, *]
q8: x
ई: एक्स: एन
[*, 1,1,1, [x], 1,1, =, 1,1,1,1,1,1, *]
अंत
सच।

सूत्रों का कहना है:

1. Brainfuck
2. ट्यूरिंग मशीन
3. Prolog