Tavi 1

prologis zogadi aRwera

ამ თავში კონკრეტული პროგრამის მაგალითზე განიხილება

პროლოგის ძირითადი მექანიზმები.
1.1. პროგრამის მაგალითი: ნათესავური
დამოკიდებულებები.
პროლოგი წარმოადგენს პროგრამირების ენას სიმბოლური,
არარიცხვითი ინფორმაციის დასამუშავებლად. ის განსაკუთრებით
კარგად ხსნის ისეთ ამოცანებს, რომლებშიც ფიგურირებენ ობიექტები და
მათ შორის კავშირები. ნახ.1.1-ზე გამოსახულია მაგალითი-ნათესავური
დამოკიდებულებები.

nana rezo

gია lali
 ლია ია

gogi

nax.1.1. naTesavuri damokidebulebebis xe

ის ფაქტი, რომ რეზო გია-ს მშობელია, პროლოგში შეიძლება

ჩაიწეროს ასე:
mshobeli(rezo, gia).

აქ ჩვენ mshobeli ავირჩიეთ მიმართების სახელად, ხოლო rezo და gia-ამ

მიმართების არგუმენტებად. სახელები gია, rezo უნდა ჩავწეროთ პატარა
ასოებით (პროგრამის წერა ხდება ლათინური ანბანით-rezo, gia), თუ
რატომ, გავარკვევთ მოგვიანებით. ნახ. 1.1-ზე ნაჩვენები მთელი ხე
აღიწერება შემდეგი პროლოგ-პროგრამით:

mshobeli(nana, gia).
mshobeli(rezo, gia).
mshobeli(rezo, lali).
mshobeli(gia, lia).
mshobeli(gia, ia).
mshobeli(ia, gogi).
 ეს პროგრამა შეიცავს ექვს წინადადებას. თითოეული წინადადება
აკეთებს განაცხადს ერთი ისეთი ფაქტის არსებობაზე, რომელიც შეიცავს
მიმართებას mshobeli. მაგალითად, არის თუ არა gია ია-ს მშობელი? ეს
კითხვა შეიძლება გადავცეთ პროლოგ-სისტემას თუ კლავიატურაზე
ავკრიბავთ:

?- mshobeli(gია, ia).

მონახავს რა ამ ფაქტს პროგრამაში, სისტემა გვიპასუხებს:

yes (დიახ)

შემდეგი კითხვა შეიძლება იყოს ასეთი:

?- mshobeli(lali, ia).

სისტემა გვიპასუხებს
no (არა)
რადგანაც პროგრამაში არაფერია ნათქვამი იმაზე, რომ lali ია-ს მშობელია.
პროგრამა გვიპასუხებს “არა” შემდეგ კითხვაზეც:

?- mshobeli(rezo, valeri).

იმიტომ, რომ სახელი ვალერი პროგრამაში საერთოდ არ არის ნახსენები.

შეიძლება დავსვათ უფრო საინტერესო კითხვებიც. მაგალითად,
„ვინ არიან ლალის მშობლები?“

?- mshobeli(X, lali).

ამ კითხვაზე სისტემა გვიპასუხებს არა უბრალოდ „დიახ“ ან „არა“,

არამედ გვეტყვის როგორი უნდა იყოს უცნობი X-ის მნიშვნელობა, რომ
ზემოთმოყვანილი მტკიცებულება იყოს ჭეშმარიტი. მივიღებთ პასუხს:

X = rezo
აუცილებელია აღინიშნოს, რომ პროლოგის ზოგიერთ რეალიზაციაში
ცვლადის გამოტანისათვის საჭიროა დამატებითი ბრძანებების მიცემა,
მაგალითად:

?- mshobeli(X, lali), write(X), nl, k.

აქ write(X) ნიშნავს “დაბეჭდე X”, k – ყველა პასუხი, nl – თითოეული

პასუხი დაბეჭდე ახალ ხაზზე.
კითხვა „ვინ არიან გიას შვილები?“ პროლოგ-სისტემაში ყალიბდება
შემდეგი ფორმით:

?- mshobeli(gia, X).

ამ შემთხვევაში შესაძლებელია რამოდენიმე პასუხი. სისტემა ჯერ

გვაცნობებს პირველ ამოხსნას:

X = lia

თუ ჩვენ მოვინდომებთ სხვა შვილების ჩამოთვლასაც, ეს სურვილი

შეგვიძლია ვამცნოთ სისტემას (პროლოგის ბევრ რეალიზაციაში
ამისათვის უნდა ავკრიბოთ წერტილმძიმე ან ნებისმიერი პატარა ასო), და
ის მონახავს მეორე პასუხს:

X = ia

თუ მოვითხოვთ სხვა პასუხებსაც, სისტემა გვიპასუხებს ”არა”, რადგანაც

ყველა პასუხი ამოწურულია.
ჩვენს პროგრამას შეიძლება დავუსვათ უფრო ზოგადი კითხვებიც:
”ვინ ვისი მშობელია?”. მოვიყვანოთ ამ კითხვის სხვანაირი
ფორმულირება:
მოვნახოთ ისეთი X და Y, რომ X-არის მშობელი Y-ის.
პროლოგზე ეს ჩაიწერება ასე:

?- mshobeli( X, Y).
სისტემა რიგ-რიგობით მონახავს ”მშობელი-შვილი” სახის ყველა წყვილს.
პასუხები გამოვა შემდეგნაირად:

X = nana
Y = gia

X = rezo
Y = gia

X = rezo
Y = lali

...

ჩვენ შეგვიძლია შევაჩეროთ ამოხსნათა ნაკადი თუ ავკრიბავთ,

მაგალითად, წერტილს წერტილმძიმის მაგივრად (კონკრეტული
სიმბოლოს შერჩევა დამოკიდებულია პროლოგის რეალიზაციის ტიპზე).
ჩვენს პროგრამას შეიძლება დავუსვათ კიდევ უფრო რთული
კითხვებიც, ვთქვათ, ვინ არის გოგის მშობლის მშობელი? რადგანაც ჩვენს
პროგრამაში პირდაპირ არ არის განსაზღვრული თუ რას წარმოადგენს
მიმართება mshobeliსmshobeli, ასეთი კითხვა უნდა დაისვას ორ ეტაპად,
როგორც ეს ნაჩვენებია ნახ. 1.2-ზე
1. ვინ არის გოგის მშობელი? ვთქვათ ეს არის ვინმე Y.
2. ვინ არის Y -ის მშობელი? ვთქვათ ეს არის ვინმე X.
 X

mSobeli

Y
mSobelismSobeli

mSobeli

gogi

nax. 1.2 ori mimarTeba mSobeli-T gamoxatuli mimarTeba

mSobelismSobeli

ასეთი შედგენილი კითხვა პროლოგზე ჩაიწერება ორი მარტივი

კითხვის მიმდევრობით:

?- mshobeli(Y, gogi), mshobeli(X,Y).

პასუხი იქნება:

X = gia
Y = ia

ჩვენს შედგენილ კითხვას შეიძლება მივცეთ ასეთი ფორმა:

”მოვნახოთ ისეთი X და Y, რომლებიც დააკმაყოფილებენ შემდეგ ორ
მოთხოვნას”:

mshobeli(Y, gogi) და mshobeli(X,Y).

ამ ორი მოთხოვნის რიგითობის შეცვლით ლოგიკური აზრი არ იცვლება:

mshobeli(X,Y) და mshobeli(Y, gogi).

ეს კითხვა პროლოგ-სისტემას შეიძლება დავუსვათ შემდეგი ფორმით:

?- mshobeli(X,Y), mshobeli(Y, gogi).

შედეგი იქნება იგივე. ასევე შეიძლება ვიკითხოთ: “ვინ არიან რეზოს

შვილიშვილები?”

?- mshobeli(rezo, X), mshobeli(X,Y).

სისტემა გვიპასუხებს ასე:

X = gia
Y = lia

X = gia
Y = ia

შემდეგი კითხვა შეიძლება იყოს: ”ყავს თუ არა ლიას და იას საერთო

მშობელი?” ეს კითხვაც გამოისახება ორ ეტაპად:
1. რომელი X არის ლიას მშობელი?
2. არის თუ არა (იგივე) X იას მშობელი?
პროლოგ-სისტემაში ეს კითხვა ასე გამოიყურება:

?- mshobeli(X, lia), mshobeli(X, ia).

პასუხი:

X = gia

ჩვენმა შედგენილმა პროგრამამ ილუსტრაცია გაუკეთა რამოდენიმე

საჭირო მომენტს:
  პროლოგზე საკმაოდ მარტივად განისაზღვრება mshobeli-ს
მსგავსი მიმართებები ისეთი n ობიექტებისათვის,
რომელთათვისაც ეს მიმართება სრულდება.
 მომხმარებელს მარტივად შეუძლია დაუსვას პროლოგ-
სისტემას კითხვები, რომლებიც ეხება პროგრამაში
განსაზღვრულ მიმართებებს.
 პროლოგ-პროგრამა შედგება წინადადებებისაგან. თითოეული
წინადადება მთავრდება წერტილით.
 მიმართებათა არგუმენტები შეიძლება იყოს: კონკრეტული
ობიექტები, ან მუდმივები (ისეთები, როგორიცაა rezo და lია),
ან აბსტრაქტული ობიექტები, როგორიცაა X და Y. პირველი
ტიპის ობიექტებს ეწოდებათ ატომები, ხოლო მეორეს -
ცვლადები.
 სისტემის მიმართ დასმული კითხვები შეიძლება შედგებოდეს
ერთი ან რამოდენიმე მიზნობრივი მტკიცებულებებისაგან (ან
მოკლედ მიზნებისაგან). მიზნების ისეთი მიმდევრობა,
როგორიცაა:

mshobeli(X, lia), mshobeli(X, ia).

აღნიშნავს ამ მიზნობრივი მტკიცებულებების კონიუნქციას:

X – ლიას მშობელი და
X – იას მშობელი
პროლოგ-სისტემა კითხვებს განიხილავს როგორც მიზნებს,
რომელთაც უნდა მივაღწიოთ.
 პასუხი კითხვაზე შეიძლება იყოს დადებითი ან უარყოფითი,
იმის მიხედვით მიღწეულია თუ არა შესაბამისი მიზანი.
დადებითი პასუხის შემთხვევაში ვამბობთ, რომ შესაბამისი
მიზანი მიღწევადია და წარმატებულია. წინააღმდეგ
შემთხვევაში მიზანი მიუღწევადია და წარუმატებელი.
 თუ კითხვაზე არსებობს რამოდენიმე პასუხი, პროლოგ-
სისტემა მონახავს იმდენს, რამდენსაც მოისურვებს
მომხმარებელი.

სავარჯიშო
 1.1. ჩავთვალოთ, რომ მიმართება mshobeli განსაზღვრულია
როგორც ზემოთ (იხილეთ ნახ. 1.1). მონახეთ პროლოგ-
სისტემის პასუხები შემდეგ კითხვებზე:

? – mshobeli(gogi, X).
? – mshobeli(X, gogi).
? – mshobeli(nana, X), mshobeli(X, ia).
? – mshobeli(nana, X), mshobeli(X, Y).

1.2. ჩაწერეთ პროლოგზე შემდეგი კითხვები:

ა) ვინ არის იას მშობელი?
ბ) ყავს თუ არა ლალის შვილი?
გ) ვინ არის იას მშობლის მშობელი ?

1.2. პროგრამის გაფართოება წესების საშუალებით

ჩვენი პროგრამა შეიძლება იოლად გავაფართოვოთ მრავალი

საინტერესო ხერხით. მოდით პირველად დავამატოთ ინფორმაცია თუ
როგორია მიმართება mshobeli-ში მონაწილე ადამიანების სქესი. ამის
გაკეთება შეიძლება შემდეგი პროგრამაში ფაქტების დამატებით:

kaci(gogi).
kaci (rezo).
kaci (gia).
qali(lali).
qali (ia).
qali (lia).
qali (nana).

აქ ჩვენ შემოვიტანეთ ორი ახალი მიმართება qali და kaci. ეს

მიმართებები – უნარულია (ერთადგილიანი). ბინარული მიმართება,
როგორიცაა Bmshobeli, განსაზღვრავს დამოკიდებულებას ორ ობიექტს
შორის, ხოლო უნარული მიმართება გამოიყენება ობიექტის მარტივი
თვისებების გამოსაცხადებლად. პირველი წინადადება იკითხება ასე: ნანა
– ქალია. ამ ორი უნარული მიმართებით (qali და kaci) მოცემული
ინფორმაცია შეიძლება გადმოცემული იქნეს ერთი ბინარული მიმართება
sqesi-ს საშუალებით. მაშინ ჩვენი პროგრამის ახალ ფრაგმენტს ექნება
სახე:

sqesi(nana, mdedrobiti).
sqesi(rezo, mamrobiti).
sqesi(gია, mamrobiti).
...

პროგრამის შემდეგი გაფართოებისათვის შემოვიტანოთ

მიმართება shvili, რომელიც მიმართება mshobeli-ს შებრუნებულია.
შეგვეძლო shvili განგვესაზღვრა იგივე მეთოდით, როგორც mshobeli, ანუ
წარმოვადგინოთ ობიექტების კონკრეტული წყვილების იმ მიმართებათა
უბრალო ფაქტების სია. მაგალითად:

shvili (lali, rezo).

მაგრამ ეს მიმართება შეიძლება განვსაზღვროთ გაცილებით

ელეგანტურად, თუ გამოვიყენებთ იმ ფაქტს, რომ მიმართება shvili
შებრუნებულია მიმართება mshobeli-ს, რომელიც უკვე განსაზღვრულია.
ეს მეთოდი ემყარება შემდეგ ლოგიკურ მტკიცებულებას:

ყველა X და Y – სათვის
Y არის X – ის შვილი, თუ
X არის Y – ის მშობელი

ეს წინადადება პროლოგზე ჩაიწერება შემდეგნაირად:

shvili (Y, X) :- mshobeli (X,Y).

ეს წინადადება შეიძლება წავიკითხოთ შემდეგნაირადაც:

ყველა X და Y – სათვის
თუ X არის Y – ის მშობელია, მაშინ
Y არის X – ის შვილი.
 ასეთ წინადადებებს პროლოგში წესები ეწოდება. ფაქტებსა და
წესებს შორის არსებითი განსხვავებაა. ფაქტი

mshobeli(rezo, lali).

ყოველთვის ჭეშმარიტია. წესები კი აღწერენ მტკიცებულებებს,

რომლებიც შეიძლება იყოს ჭეშმარიტი მხოლოდ გარკვეული პირობის
შესრულებისას. ამიტომ შეიძლება ითქვას, რომ წესებს გააჩნიათ
 პირობითი ნაწილი (წესის მარჯვენა ნახევარი)
და
 დასკვნა (წესის მარცხენა ნახევარი).
დასკვნას აგრეთვე უწოდებენ წინადადების თავს, ხოლო პირობით
ნაწილს – მის ტანს. მაგალითად:

shvili (Y, X) :- mshobeli (X,Y).

თავი ტანი

თუ პირობა mshobeli (X,Y). სრულდება (ჭეშმარიტია), მაშინ მისგან

ლოგიკურად გამოდის მტკიცებულება shvili (Y, X).
ქვემოთ მოყვანილ მაგალითზე ვნახოთ როგორ იყენებს
სინამდვილეში წესებს პროლოგი. ვკითხოთ პროგრამას, არის თუ არა lali
rezoს შვილი:

?- shvili(lali, rezo).

პროგრამაში არ არის ფაქტები შვილებზე, ამიტომ ასეთ კითხვაზე

პასუხის გასაცემად ერთადერთი ხერხია მათზე წესის გამოყენება. წესი
უნივერსალურია იმ მხრივ, რომ ის გამოყენებადია ნებისმიერ X და Y
ობიექტებისათვის, შესაბამისად ის შეიძლება გამოვიყენოთ ისეთ
კონკრეტულ ობიექტებზე, როგორიცაა lali და rezo. ეს რომ გავაკეთოთ
საჭიროა Y – ს მაგივრად ჩავსვათ lali, ხოლო X – ს მაგივრად rezo. ამ
შემთხვევაში ამბობენ, რომ ცვლადები X და Y დაკონკრეტდნენ:

X = rezo და Y = lali
 დაკონკრეტების შემდეგ ჩვენ მივიღებთ კონკრეტულ შემთხვევას
ზოგადი წესიდან. აი ისიც:

shvili (lali, rezo) :- mshobeli(rezo, lali).

პირობითმა ნაწილმა მიიღო სახე:

mshobeli(rezo, lali)

ახლა პროლოგ-სისტემა შეეცდება გაარკვიოს, სრულდება თუ არა ეს

პირობა (არის თუ არა ის ჭეშმარიტი). ამისათვის ძირითადი მიზანი

shvili (lali, rezo)

იცვლება ქვემიზნით

mshobeli(rezo, lali)

ეს (ახალი) მიზანი მიიღწევა ტრივიალურად, რადგანაც ასეთი ფაქტი

შეიძლება მოინახოს პროგრამაში. ეს ნიშნავს, რომ მტკიცებულება
რომელსაც შეიცავს წესის დასკვნა, ასევე ჭეშმარიტია და სისტემა
კითხვაზე გვიპასუხებს yes (დიახ).
ახლა ჩვენს პროგრამას დავუმატოთ კიდევ რამოდენიმე
ნათესავური დამოკიდებულება. მიმართება deda შეიძლება დაეფუძნოს
შემდეგ ლოგიკურ მტკიცებულებას:

ყველა X და Y- სათვის
X არის Y – ის დედა, თუ
X არის Y – ის მშობელი და
X – ქალია.

პროლოგზე ეს მიიღებს შემდეგი წესის სახეს:

deda (X,Y) :- mshobeli (X,Y), qali(X).

ორ პირობას შორის მძიმე მიგვითითებს პირობათა კონიუნქციაზე. ეს
ნიშნავს, რომ ისინი ორთავე ერთდროულად უნდა შესრულდნენ.
ისეთი მიმართებები, როგორიცაა mshobeli, shvili და deda შეიძლება
გამოვსახოთ დიაგრამით (ნახ. 1.3).

qali
X X X

mSobeli
mSobeli
mSobeli
deda
Svili
mSobeli Y
mSobelis
mSobeli
mSobeli
Y Y
Z

nax. 1.3. sxva mimarTebebiT gansazRvruli mSobelismSobeli – is, deda – s

da Svili – s mimarTebaTa grafebi.

ისინი გამოსახულია შემდეგი შეთანხმებების გათვალისწინებით :

გრაფების წვეროები შეესაბამებიან ობიექტებს, ანუ მიმართებათა
არგუმენტებს. წვეროებს შორის რკალები შეესაბამებიან ბინარულ
(ორადგილიან) მიმართებებს. რკალები მიმართულია პირველი
არგუმენტიდან მეორისკენ. უნარული მიმართებები დიაგრამაზე
გამოისახება შესაბამისი ობიექტის მიმართების სახელის აღნიშვნით.
მიმართებები, რომლებიც განისაზღვრება სხვა მიმართებებით,
წარმოდგენილია წყვეტილი რკალებით. ამრიგად, ნებისმიერი დიაგრამა
შეიძლება გავიგოთ ასე: თუ შესრულებულია უწყვეტი რკალებით
შესრულებული მიმართებები, მაშინ შესრულებულია წყვეტილი
რკალებით გამოსახული მიმართებებიც. ნახ. 1.3 – ის შესაბამისი
მიმართება mshobeliსmshobeli შეიძლება პირდაპირ ჩავწეროთ
პროლოგზე:

mshobeliსmshobeli(X,Z) :- mshobeli(X,Y),
mshobeli(Y,Z).

აქ საჭიროა გავაკეთოთ რამოდენიმე შენიშვნა ჩვენი პროგრამის

გარეგნულ სახეზე. პროლოგი გვაძლევს ფურცელზე ტექსტის
განთავსების თითქმის სრულ თავისუფლებას. შეგვიძლია ჩვენი
გემოვნების მიხედვით ტექსტის ნებისმიერ ადგილზე ჩავსვათ ჰარი და
გადავიდეთ ახალ ხაზზე. საერთოდ ისე უნდა გავაკეთოთ, რომ პროგრამა
ლამაზი იყოს, და რაც მთავარია ადვილად იკითხებოდეს. ამისათვის ჩვენ
ხშირად მოვათავსებთ წინადადების თავს და თითოეულ მიზანს
ცალცალკე სტრიქონზე. ამასთან მიზანი ჩავწეროთ აბზაცით, რათა
გამოვყოთ განსხვავება თავსა და მიზანს შორის. მაგალითად, წესი
mshobeliსmshobeli ამ წესების შესაბამისად ჩაიწერება:
mshobeliსmshobeli(X,Y) :-
mshobeli(X,Y),
mshobeli(Y,Z).

ნახ. 1.4 – ზე ნაჩვენებია მიმართება da.

ნებისმიერი X და Y – სათვის
X არის Y - ს და, თუ
1. X - ს და Y – ს ჰყავთ საერთო მშობელი, და
2. X - ქალია.
 Z

mSobeli mSobeli

qali X Y
da

nax. 1.4. mimarTeba da – s ganmarteba

ამ ნახაზზე გამოსახული გრაფი პროლოგზე გადაითარგმნება ასე:

da(X, Y) :-
mshobeli(Z,X),
mshobeli(Z,Y),
qali(X).

მიაქციეთ ყურადღება ხერხს, რომლის საშუალებითაც

გამოსახულია მოთხოვნა „X და Y – ს ჰყავს საერთო მშობელი“. აქ
გამოყენებულია შემდეგი ლოგიკური ფორმულირება: „რომელიღაც Z
უნდა იყოს X – ის მშობელი და იგივე Z უნდა იყოს Y – ის მშობელი“.
ახლა შეიძლება ვიკითხოთ:

?- da(lia,X).

სისტემა მონახავს ორ პასუხს, რომელთაგან ერთი შეიძლება

მოგვეჩვენოს მოულოდნელად:

X = lia
X = ia
 გამოდის, რომ ია თავისი თავის დაა? როცა ჩვენ განვსაზღვრეთ
მიმართება და, ეს მხედველობაში არ მიგვიღია. მაგრამ პროლოგის
პასუხი სრულიად ლოგიკურია, რადგანაც ის ხელმძღვანელობდა ჩვენი
წესით, ეს წესი კი არაფერს არ ამბობს იმის შესახებ,რომ თუ X – Y – ის
დაა, მაშინ X და Y ერთმანეთს არ უნდა დაემთხვეს. პროლოგი (სრული
უფლებით) თვლის, რომ X და Y შეიძლება იყოს ერთი და იგივე ობიექტი
და აქედან გამომდინარე აკეთებს დასკვნას, რომ ნებისმიერი ქალი,
რომელსაც ჰყავს მშობელი, არის თავისი თავის და.
რომ გამოვასწოროთ წესი დებზე, ის უნდა შევავსოთ
მტკიცებულებით, რომ X და Y ერთმანეთისაგან უნდა
განსხვავდებოდნენ. შემდეგ თავებში ჩვენ ვნახავთ, რომ ამის გაკეთება
შეიძლება, ამ მომენტში კი ვივარაუდოთ, რომ მიმართება gansxvavebuli
პროლოგ-სისტემისთვის უკვე ცნობილია და მიზანი

gansxvavebuli (X,Y)

მიიღწევა მაშინ და მხოლოდ მაშინ, როცა X და Y არ არის ტოლი. მაშინ

გაუმჯობესებული წესი მიმართებისათვის და გამოიყურება ასე:

da(X, Y) :-
mshobeli(Z,X),
mshobeli(Z,Y),
qali(X),
gansxvavebuli (X,Y).

ამ პარაგრაფის ზოგიერთი საჭირო მომენტები: დასკვნები

 პროლოგ-პროგრამები შეიძლება გავაფართოვოთ ახალი
წინადადებების დამატებით.
 პროლოგში არსებობს სამი ტიპის წინადადებები: ფაქტები, წესები
და კითხვები.
 ფაქტები შეიცავენ მტკიცებულებებს, რომლებიც ყოველთვის
ჭეშმარიტია.
 წესები შეიცავენ მტკიცებულებებს, რომელთა ჭეშმარიტება
დამოკიდებულია ზოგიერთი პირობის შესრულებაზე.
  კითხვების საშუალებით მომხმარებელს შეუძლია კითხოს
სისტემას, თუ რომელი მტკიცებულებებია ჭეშმარიტი.
 პროლოგის წინადადებები შედგებიან თავისა და ტანისაგან. ტანი –
მძიმეებით გამოყოფილი მიზნების სიაა. მძიმე აღნიშნავს
კონიუნქციას.
 ფაქტები – წინადადებებია ცარიელი ტანით. კითხვებს აქვთ
მხოლოდ ტანი. წესებს აქვთ თავი და (არაცარიელი) ტანი.
 გამოთვლების დროს ცვლადის მაგივრად შეიძლება ჩაისვას სხვა
ობიექტი. ამ შემთხვევაში ვამბობთ, რომ ცვლადი დაკონკრეტდა.
 იგულისხმება, რომ ცვლადებზე მოქმედებს საყოველთაობის
კვანტორი, რომელიც იკითხება, მაგალითად, ასე „ყველა X –
ისათვის“. მაგრამ ცვლადებისათვის, რომლებიც მხოლოდ ტანში
არიან, შესაძლოა სხვა ფორმულირებებიც. მაგალითად:

hyavsshvili(X) :- mshobeli(X,Y).

შეიძლება წავიკითხოთ ორნაირად:

a. ყველა X და Y – ისათვის,
თუ X არის Y – ის მამა, მაშინ
X – ს ჰყავს შვილი.
b. ყველა X – ისათვის,
X – ს ჰყავს შვილი, თუ
არსებობს რომელიმე ისეთი Y , რომ
X არის Y – ის mshobeli.

სავარჯიშო

1.3. გაუკეთეთ ტრანსლიაცია შემდეგ წესებს პროლოგზე:

a. ყველა, ვისაც ჰყავს შვილი – ბედნიერია (შემოიტანეთ
ერთ არგუმენტიანი მიმართება bednieri).
b. ყველა X – ს, რომელსაც ჰყავს შვილი და ამ შვილს ჰყავს
და,
ჰყავს ორი შვილი (შემოიტანეთ ახალი მიმართება
hyavsorishvili).
1.4. გამოიყენეთ მიმართება mshobeli და განსაზღვრეთ მიმართება
 shvilishvili. იგი ჰგავს მიმართებას mshobeliსmshobeli (იხილეთ
ნახ. 1.3).
1.5. გამოიყენეთ მიმართება mshobeli და da. განსაზღვრეთ
მიმართება
deida(X, Y).

1.3. წესების რეკურსიული განსაზღვრა

დავამატოთ ჩვენს პროგრამას კიდევ ერთი მიმართება cinapari და

იგი განვსაზღვროთ მიმართებით mshobeli. მიმართება შეიძლება
გამოვსახოთ ორი წესის საშუალებით. პირველი წესი განსაზღვრავს
უახლოეს წინაპრებს, ხოლო მეორე – შორეულებს. ვამბობთ, რომ ვინმე X
არის რომელიმე Z – ის შორეული წინაპარი, თუ X – ს და Z – ს შორის
არსებობს ადამიანების ჯაჭვი, რომლებიც ერთმანეთთან
დაკავშირებულნი არიან მიმართებით მშობელი– შვილი, როგორც ეს
ნაჩვენებია ნახ. 1.5 – ზე. ჩვენს მაგალითში ნახ. 1.1 – ზე რეზო – ლალის
უახლოესი წინაპარია, ხოლო იას – შორეული.
პირველი წესი მარტივია და მისი ფორმულირება ასეთია:
ყველა X და Z – ისთვის,
X არის Z – ის წინაპარი, თუ
X არის Z – ის მშობელი.
ეს პროლოგზე გადაითარგმნება ასე:
 cinapari(X,Z) :-
mshobeli(X,Z).

X X

mSobeli
mSobeli
winapari

Z winapari
mSobeli

(a)

mSobeli

Z
(b)

nax. 1.5. mimarTeba winapari – s magaliTi:

(a) X aris Z – is axlo winapari;
(b) X aris Z – is Soreuli winapari.

მეორე წესი უფრო რთულია, რადგანაც მიმართებით mshobeli – ს

ჯაჭვის აგებამ შეიძლება გამოიწვიოს სირთულეები. ერთ–ერთი ხერხი
ასეთი შორეული ნათესავების განსასაზღვრად მოცემულია ნახ. 1.6 – ზე
და მასთან შესაბამისად მიმართება cinapari განისაზღვრება
წინადადებათა შემდეგი სიმრავლით:

cinapari (X,Z) :-
mshobeli(X,Z)
cinapari (X,Z) :-
mshobeli(X,Y),
mshobeli(Y,Z).
 cinapari (X,Z) :-
mshobeli(X,Y1),
mshobeli(Y1,Y2),
mshobeli(Y2,Z).
cinapari (X,Z) :-
mshobeli(X,Y1),
mshobeli(Y1,Y2),
mshobeli(Y2,Y3),
mshobeli(Y3,Z).
. . .

X X

mSobeli
mSobeli
winapari
Y1
Y winapari
mSobeli

mSobeli
Y2

Z mSobeli

nax. 1.6. sxvadasxva raodenobis TaobebiT gayofili wyvilebi winapari –

STamomavali.

ეს პროგრამა გრძელია და, რაც უფრო საჭიროა მუშაობს მხოლოდ

გარკვეულ საზღვრებში. ის განსაზღვრავს წინაპრებს მხოლოდ
საგვარეულო ხის მხოლოდ გარკვეულ სიღრმემდე, რადგანაც წინაპარსა
და შთამომავალს შორის ადამიანების ჯაჭვის სიგრძე შემოსაზღვრულია
ჩვენი წინადადებების რაოდენობით მიმართებათა განსაზღვრისას.
მაგრამ არსებობს მიმართება cinapari–ს კორექტული და
ელეგანტური ფორმულირება იმ გაგებით, რომ ის მუშაობს წინაპართა
ნებისმიერ სიღრმეზე. ძირითადი იდეა მდგომარეობს იმაში, რომ
განისაზღვროს მიმართება cinapari თვითონ მისით (ნახ. 1.7).

ყველა X და Z – ისთვის,
X არის Z – ის წინაპარი, თუ
არსებობს ისეთი Y, რომ
(1) X არის Y – ის მშობელი და
(2) Y არის Z – ის წინაპარი.

ჩავწეროთ ეს წინადადება პროლოგზე:

cinapari (X,Z) :-
mshobeli(X,Y),
cinapari (Y,Z).

ახლა ჩვენ ავაგეთ მიმართება cinapari – ს სრული პროგრამა,

რომელიც შეიცავს ორ წესს: ერთი ახლო წინაპრებისთვის და მეორე
შორეული წინაპრებისთვის. მოვიყვანოთ ორთავე წესი ერთად:

cinapari (X,Z) :-
mshobeli(X,Z).

cinapari (X,Z) :-
mshobeli(X,Y),
cinapari (Y,Z).

ძირითადი მომენტი მოცემულ ფორმულირებაში არის თავად

მიმართება cinapari – ს გამოყენება მისსავე განსაზღვრაში. ასეთმა
განსაზღვრებამ შეიძლება გაგვაკვირვოს – დასაშვებია კი რაიმე ცნების
განსაზღვრისას გამოვიყენოთ თავად ეს ცნება, ის ხომ ჯერ კიდევ არ არის
ბოლომდე განსაზღვრული. ასეთ განსაზღვრებებს უწოდებენ
რეკურსიულს. ლოგიკურად ისინი სრულიად კორექტული და გასაგებია;
ინტუიციურად ეს ნათელია, თუ დავაკვირდებით ნახ. 1.7 – ს. მაგრამ
გამოიყენებს კი პროლოგ – სისტემა რეკურსიულ წესებს? აღმოჩნდა, რომ
პროლოგ – სისტემა ძალიან ადვილად ამუშავებს რეკურსიულ
განსაზღვრებებს. სინამდვილეში რეკურსია ერთ – ერთი
ფუნდამენტალური ხერხია პროლოგზე პროგრამირებაში. რეკურსიის
გარეშე შეუძლებელია ამოვხსნათ ოდნავ მაინც საგრძნობი სირთულის
ამოცანები.
ახლა დავუბრუნდეთ ჩვენს პროგრამას, რომელსაც შეიძლება
დავუსვათ კითხვა: “ვინ არიან ნანას შთამომავლები?” ანუ : “ვინ არიან ის
ადამიანები ვისი წინაპარიცაა ნანა?”
?- cinapari (nana, X).

X= gia
X= lia
X= ia
X= gogi
 X

mSobeli

winapari

winapari

. . .

nax. 1.7. mimarTeba winapari – s rekursiuli formulireba

სისტემის პასუხები, რა თქმა უნდა, სწორია და ისინი ლოგიკურად

გამომდინარეობენ მიმართებების cinapari–ს და mshobeli – ს
განსაზღვრებებიდან. მაგრამ შეიძლება წარმოიშვას კითხვა:
“სინამდვილეში როგორ იყენებს სისტემა პროგრამას ამ პასუხების
მისაღებად?”
 არაფორმალური ახსნა იმისა, თუ როგორ აკეთებს ამას სისტემა,
მოყვანილია შემდეგ პარაგრაფში. მაგრამ მოდით ჯერ გავაერთიანოთ
ყველა ფრაგმენტი ჩვენი პროგრამისა, რომელიც თანდათანობით
ფართოვდებოდა მასში ახალი ფაქტებისა და წესების შეტანით.
პროგრამის საბოლოო სახე მოცემულია ნახ. 1.8 – ზე.
ამ ნახაზის განხილვისას მხედველობაში უნდა მივიღოთ ორი
მომენტი: პირველი ეხება ცნებას “პროცედურა”, მეორე – კომენტარებს
პროგრამაში. პროგრამა, რომელიც მოყვანილია ნახ. 1.8 – ზე
განსაზღვრავს რამოდენიმე მიმართებას – mshobeli, kaci, qali, shvili,
cinapari და ა.შ. მაგალითად, მიმართება cinapari განსაზღვრულია ორი
წინადადების საშუალებით. ვთქვათ, რომ ეს ორი წინადადება შედის
მიმართება cinapari შემადგენლობაში. ზოგჯერ მოსახერხებელია
მთლიანობაში განვიხილოთ ერთ მიმართებაში შემავალი წინადადებების
მთელი სიმრავლე. ასეთ სიმრავლეს პროცედურა ეწოდება.

mshobeli(nana, gია). % ნანა არის გიას მშობელი

mshobeli(rezo, gია).
mshobeli(rezo, lali).
mshobeli(gია, ლია).
mshobeli(gია, ია).
mshobeli(ია, gogi).

kaci(rezo). % რეზო– კაცია

kaci (gია).
kaci (gogi).
qali(nana). % ნანა - ქალია
qali (lali).
qali (ia).
qali (lia).

shvili(Y, X) :- % Y არის X – ის შვილი, თუ

mshobeli (X,Y). % X არის Y – ის მშობელი.

deda(X,Y) :- % X არის Y – ის დედა, თუ

mshobeli (X,Y), % X არის Y – ის მშობელიდა
 qali (X). % X – ქალია.

mshobeliსmshobeli(X,Z) :- % X არის Z–ის მშობელისმშობელი, თუ

mshobeli(X,Y), % X არის Y – ის მშობელი და
mshobeli(Y,Z). % Y არის Z – ის მშობელი.

da(X, Y) :- % X არის Y - ს და, თუ

mshobeli(Z,X), % X - ს და Y – ს ჰყავთ საერთო
mshobeli(Z,Y), % მშობელი, და
qali(X), % X - ქალია და
gansxvavebuliX,Y). % X განსხვავებულია Y–საგან.

cinapari(X,Z) :- % წესი წ1: X არის Z – ის წინაპარი

mshobeli(X,Z).

cinapari(X,Z) :- % წესი წ2: X არის Z – ის წინაპარი

mshobeli(X,Y),
cinapari(Y,Z). 

ნახ. 1.8. ნათესავური დამოკიდებულებების პროგრამა.

ნახ. 1.8 – ზე ორი წინადადება, რომლებიც შედიან მიმართება

cinapari-ში, გამოყოფილია სახელებით “წ1” და “წ2” და, რომლებიც
დამატებულია პროგრამაში კომენტარების სახით. ეს სახელები
მომავალშიც იქნება გამოყენებული მითითებისათვის შესაბამის წესებზე.
საერთოდ უნდა ითქვას, რომ პროლოგ – სისტემა კომენტარებს
იგნორირებას უკეთებს. ისინი საჭიროა მხოლოდ პროგრამის
წამკითხველი ადამიანისთვის. პროლოგში კომენტარები ძირითადი
ტექსტიდან გამოყოფილია სპეციალური ფრჩხილებით “ /* ” და
“ */”. ამრიგად პროლოგის კომენტარები ასე გამოიყურება:

/* ეს კომენტარია */

მეორე, უფრო პრაქტიკული ხერხი მოკლე კომენტარებისათვის

არის პროცენტის სიმბოლოს % გამოყენება. ყველაფერი, რაც
მოთავსებულია % - სა და სტრიქონის ბოლოს შორის ითვლება
კომენტარად:

% ესეც კომენტარია.

სავარჯიშო

1.6. განვიხილოთ მიმართება წინაპარი – ს მეორე ვარიანტი:

cinapari (X,Z) :-
mshobeli(X,Z).

cinapari (X,Z) :-
mshobeli(Y,Z),
cinapari (X,Y).

სწორია თუ არა ასეთი განსაზღვრა? შეძლებთ თუ არა შეცვალოთ

დიაგრამა ნახ. 1.7 – ზე ისე, რომ ის შეესაბამებოდეს ახალ
განსაზღვრებას ?
DA

1.4. როგორ პასუხობს კითხვებზე პროლოგ – სისტემა.

ამ პარაგრაფში მოყვანილია არაფორმალური ახსნა იმისა, თუ

როგორ პასუხობს კითხვებზე პროლოგ – სისტემა.
სისტემისათვის დასმული კითხვა ყოველთვის წარმოადგენს
მიმდევრობას, რომელიც შედგება ერთი ან რამოდენიმე მიზნისაგან.
იმისათვის, რომ უპასუხოს კითხვას, სისტემა ცდილობს მიაღწიოს ყველა
მიზანს. რას ნიშნავს მიაღწიოს მიზანს? მიაღწიოს მიზანს – ნიშნავს
აჩვენოს, რომ მტკიცებულებები, რომლებსაც შეიცავს კითხვა, ჭეშმარიტია
იმ მხრივ, რომ პროგრამის ყველა მიმართება ჭეშმარიტია. სხვა
სიტყვებით, მიაღწიოს მიზანს – ეს ნიშნავს ვაჩვენოთ, რომ იგი
ლოგიკურად გამომდინარეობს პროგრამის ფაქტებიდან და წესებიდან.
თუ კითხვა შეიცავს ცვლადებს, სისტემამ უნდა მონახოს კონკრეტული
ობიექტები, რომლებიც (ჩავსვავთ რა მათ ცვლადების ნაცვლად)
უზრუნველყოფენ მიზნის მიღწევას. მონახული კონკრეტიზაციები
ეცნობება მომხმარებელს. თუ ზოგიერთი კონკრეტიზაციებისათვის
სისტემას არ შეუძლია მიაღწიოს მიზანს პროგრამის დანარჩენი
წინადადებებიდან გამომდინარე, მაშინ მისი პასუხი კითხვაზე იქნება
„არა“.
ამრიგად, მათემატიკური ტერმინებით პროლოგ – სისტემის
შესაბამისი ინტერპრეტაცია ასე გამოიყურება: პროლოგ – სისტემა
ფაქტებს და წესებს განიხილავს, როგორც აქსიომების სიმრავლეს, ხოლო
მომხმარებლის კითხვას, როგორც თეორემას, შემდეგ კი ცდილობს
დაამტკიცოს ეს თეორემა, ანუ აჩვენოს, რომ ის შეიძლება ლოგიკურად
გამოვიყვანოთ აქსიომებიდან.
გავუკეთოთ ილუსტრირება ამ მიდგომას კლასიკურ მაგალითზე.
ვთქვათ გვაქვს შემდეგი აქსიომები:

ყველა ადამიანი მოკვდავია.

სოკრატე - ადამიანია.

ამ ორი აქსიომიდან ლოგიკურად გამოდის თეორემა:

სოკრატე მოკვდავია.

ზემოთ მოყვანილი აქსიომებიდან პირველი შეიძლება ჩავწეროთ ასე:

ყველა X –სათვის, თუ X – ადამიანია, მაშინ X მოკვდავია.

შესაბამისად ჩვენი მაგალითი პროლოგზე ჩაიწერება ასე:

mokvdavi(X) :- adamiani(X). B% ყველა ადამიანი მოკვდავია.

adamiani (sokrate). % საკრატე ადამიანია.
?- mokvdavi (sokrate). % სოკრატე მოკვდავია?
yes % დიახ
 უფრო რთულია მაგალითი პროგრამიდან ”ნათესავური
დამოკიდებულებები” (ნახ. 1.8):

?- cinapari(rezo, ia).

ჩვენ ვიცით, რომ mshobeli(gia, ia) – ფაქტია. გამოვიყენებთ რა ამ

ფაქტს და წ1 – ს, შეგვიძლია გავაკეთოთ დასკვნა, რომ მტკიცებულება
cinapari (rezo, ia) ჭეშმარიტია. ეს ფაქტი მიღებულია დასკვნის
საფუძველზე – მისი მონახვა უშუალოდ პროგრამაში შეუძლებელია,
მაგრამ შეიძლება მისი გამოყვანა პროგრამაში არსებული ფაქტების და
წესების გამოყენებით. დასკვნის შესაბამისი ბიჯი შეიძლება მოკლედ ასე
ჩაიწეროს:

cinapari (rezo, ia)==> cinapari (gia, ia).

ეს ჩანაწერი შეიძლება ასე წავიკითხოთ: mshobeli(gia,ia) – დან, წ1 – ის

საფუძველზე, გამოდის cinapari(gია, ია). შემდგომ, ჩვენთვის ცნობილია
ფაქტი mshobeli(rezo,gia). ამ და გამოყვანილი cinapari(gia,ia) ფაქტების
საფუძველზე შეგვიძლია დავასკვნათ, რომ წ2 – ს თანახმად, ჩვენი
მიზნობრივი მტკიცებულება ჭეშმარიტია. ორი ბიჯისაგან შემდგარი
დასკვნის პროცესი შეიძლება ჩაიწეროს ასე:

mshobeli(gia,ia) ==> cinapari(gia, ia).

mshobeli(rezo,gia) და cinapari(gia, ia) ==> cinapari(rezo, ia)
 ამრიგად, ჩვენ ვაჩვენეთ თუ როგორი შეიძლება იყოს ბიჯთა
მიმდევრობა მიზნის მისაღწევად, ანუ მიზნობრივი მტკიცებულების
ჭეშმარიტების დემონსტრაციისათვის. ამ მიმდევრობას დავარქვათ
მტკიცებულების ჯაჭვი. მაგრამ ჩვენ ჯერ არ გვიჩვენებია სინამდვილეში
როგორ აგებს პროლოგ – სისტემა ასეთ ჯაჭვს.
პროლოგ – სისტემა მტკიცებულების ჯაჭვს აგებს იმ მეთოდის
შებრუნებული მიმართულებით, რომელიც ჩვენ ახლახან გამოვიყენეთ.
იმის მაგივრად, რომ დაიწყოს პროგრამაში მოყვანილი უბრალო
ფაქტებით, სისტემა იწყებს მიზნებით და, იყენებს რა წესებს, ცვლის
მიმდინარე მიზნებს ახლით, მანამდე, სანამ ეს ახალი მიზნები არ
აღმოჩნდებიან უბრალო ფაქტები. თუ დასმულია კითხვა:

?- cinapari(rezo, ia).

სისტემა შეეცდება მიაღწიოს ამ მიზანს. ამისათვის ის ცდის პროგრამაში

მონახოს ისეთი წინადადება, რომლისგანაც დაუყოვნებლივ გამოდის
ხსენებული მიზანი. ნათელია, რომ ამისათვის ერთადერთი შესაფერისი
წინადადებებია წ1 და
წ2. ეს წესები შედიან მიმართება წინაპარში. ვამბობთ, რომ ამ წესების
თავები შეპირისპირებულია მიზანთან.
 winapari(rezo, ია)

wesi w1 – s mixedviT

mSobeli(gია, ია)

nax. 1.9. gamoTvlis pirveli biji. zeda mizani WeSmaritია, Tu

WeSmaritია qveda.

ორი წინადადება წ1 და წ2 აღწერენ პროლოგ – სისტემის

მსჯელობის ორ ვარიანტს. სისტემა ჯერ ცდის წინადადებას, რომელიც
დგას პროგრამაში პირველი:

cinapari (X,Z) :- mshobeli(X,Z).

რადგანაც მიზანია – cinapari(rezo,ia), ცვლადებს მნიშვნელობები უნდა

მიენიჭოთ შემდეგნაირად:

X = rezo, Z = ia
საწყისი მიზანი cinapari(rezo,ia) იცვლება ახალი მიზნით

mshobeli(rezo,ia)

ერთი მიზნის მეორეთი შეცვლის ასეთი მოქმედება რომელიმე წესის

საფუძველზე ნაჩვენებია ნახ.1.9 – ზე. პროგრამაში არ არის წესი, რომლის
თავი შეპირისპირებული იყოს მიზანთან mshobeli(rezo,ia), ამიტომ ასეთი
მიზანი წარუმატებელი აღმოჩნდება. ახლა სისტემა აკეთებს დაბრუნებას
საწყის მიზანთან, რომ სცადოს მაღალი დონის მიზნის წინაპარი(rezo,ia)
მიღების მეორე ვარიანტი. ანუ ცდის წესს წ2:

cinapari (X,Z) :-
mshobeli(X,Y),
cinapari (Y,Z). 

როგორც ადრე, ცვლადებს X და Z – ს ენიჭებათ მნიშვნელობები:

X = rezo, Z =ia

ამ მომენტში ცვლად Y – ს ჯერ კიდევ არა აქვს მინიჭებული არავითარი

მნიშვნელობა. მაღალი დონის მიზანი cinapari(rezo,ia) იცვლება ორი
მიზნით:

mshobeli(rezo,Y),
cinapari (Y,ia). 
გამოთვლის ეს ბიჯი ნაჩვენებია ნახ. 1.10 – ზე, რომელიც წარმოადგენს
ნახ. 1.9 –ზე გამოსახული სიტუაციის გაგრძელებას.

winapari(rezo, ია)

wesi w1-s mixedviT wesi w2-s mixedviT

mSobeli(rezo, ია) mSobeli(rezo,Y)

winapari(Y,ია)

(ara)

nax. 1.10. nax. 1.9 –ze gamosaxuli gamoTvlis procesis gagrZeleba.

ახლა, გვაქვს რა ორი მიზანი, სისტემა შეეცდება მიაღწიოს ორთავეს იმ

რიგითობის მიხედვით, როგორი რიგითაც არიან ისინი ჩაწერილი.
პირველის მიღწევა ადვილია, რადგანაც ის შეესაბამება პროგრამაში
მოცემულ ფაქტს. შესაბამისობის დადგენის პროცესი – შეპირისპირება
(უნიფიკაცია) იწვევს ცვლადზე Y მნიშვნელობა gia – ს მინიჭებას. ამით
მიიღწევა პირველი მიზანი, ხოლო დარჩენილი გარდაიქმნება შემდეგ
მიზანში

cinapari (gia,ia)
ამ მიზნის მისაღწევად ისევ გამოიყენება წესი წ1. შევნიშნოთ, რომ წესის
ეს (მეორედ) გამოყენება არაფრით არ არის დაკავშირებული მის პირველ
გამოყენებასთან. ამიტომ წესის ყოველი ახალი გამოყენებისას სისტემა
იყენებს წესების ცვლადების ახალ სიმრავლეებს. ამაზე რომ
მივუთითოთ, წესი წ1 – ს ცვლადებს ჩვენ შემდეგნაირად გადავარქვათ
სახელები:

cinapari (X’,Z’) :-
mshobeli(X’,Y’).

ამ წესის თავი უნდა შეესაბამებოდეს ჩვენს მიმდინარე მიზანს cinapari

(gia,ia). ამიტომ

X’ = gia, Z’ = ia

მიმდინარე მიზანი იცვლება შემდეგ მიზანზე:

mshobeli(gia, ia)

ახლა მიზანი დაუყოვნებლივ მიიღწევა, რადგანაც იგი პროგრამაში

გვხვდება ფაქტის სახით. ეს ბიჯი ამთავრებს გამოთვლას, რაც
გრაფიკულად ნაჩვენებია ნახ. 1.11 – ზე.
ნახ. 1.11 – ზე წარმოდგენილ გამოთვლების ბიჯთა გრაფიკულ
სურათს აქვს ხის ფორმა. ხის წვეროები შეესაბამება მისაღწევ მიზნებს ან
მიზანთა სიებს. წვეროებს შორის რკალები შეესაბამება პროგრამის
(ალტერნატიული) წინადადებების გამოყენებას, რომლებიც ერთი წვეროს
შესაბამის მიზანს გარდაქმნიან მეორე წვეროს შესაბამის მიზანში.
ძირითადი (ზედა დონის) მიზანი მიიღწევა მაშინ, როცა მოინახება
„დიახ“ ნიშნით მონიშნული გზა ხის ძირიდან (ზედა წვერო) მის
ფოთლამდე. ფოთოლი ინიშნება ნიშნით „დიახ“, თუ ის წარმოადგენს
ფაქტს.
 winapari(rezo, ია)

wesi w1-s mixedviT wesi w2-s mixedviT

mSobeli(rezo, ია) mSobeli(rezo, Y)

winapari(Y, ია)

(ara)

faqtidan Y = gია
mSobeli(rezo,gია)

winapari(gია, ია)

wesi w1-s mixedviT

mSobeli(gია, ია)

(dიაx)

nax. 1.11. miznis winapari(rezo, ია) - s miRwevis yvela biji.

marjvena Sto demonstrirebas ukeTebs miznis miRwevas.
 პროლოგ – პროგრამის შესრულება შედგება ასეთი გზების
ძიებისაგან. ასეთი ძიების პროცესში პროგრამა შეიძლება შევიდეს
წარუმატებლობის მომტან შტოებში. იმ მომენტში, როცა პროგრამა
აღმოაჩენს, რომ შტოს არ მივყავართ წარმატებამდე, ხდება ავტომატური
დაბრუნება წინა წვეროსთან და ამას მოსდევს ალტერნატიული
წინადადების გამოყენების ცდა.

სავარჯიშო

1.5. შეეცადეთ გაიგოთ, ნახ. 1.8 – ზე მოცემული პროგრამის

გამოყენებით, როგორ გამოყავს პროლოგ – სისტემას
პასუხები ქვემოთ მოცემულ კითხვებზე. შეეცადეთ
დახაზოთ ნახ. 1.9 – ნახ. 1.11 – ს მსგავსი დიაგრამები. იქნება
თუ არა დაბრუნებები საჭირო რომელიმე ქვემოთ მოყვანილ
კითხვაზე პასუხის მისაღებად?
a. ?- mshobeli(nana, gia).
b. ?- deda(nana, gia).
გ. ?- mshobelismshobeli(nana, lia).
დ. ?- mshobelismshobeli(gia, gogi).

1.5. პროგრამის დეკლარაციული და პროცედურული არსი.

აქამდე ჩვენს მიერ მოყვანილ ყველა მაგალითში ყოველთვის
შეგვეძლო გაგვეგო პროგრამის მუშაობის შედეგები ისე, რომ ზუსტად არ
ვიცოდით სინამდვილეში როგორ მიიღო ისინი სისტემამ. ამიტომ ღირს,
რომ განვასხვავოთ პროლოგ – პროგრამის არსის ორი დონე:
 დეკლარაციული არსი
 პროცედურული არსი.
დეკლარაციული არსი ეხება მხოლოდ პროგრამაში განსაზღვრულ
მიმართებებს. ამრიგად დეკლარაციული არსი განსაზღვრავს რა უნდა
იყოს პროგრამის მუშაობის შედეგი. მეორეს მხრივ, პროცედურული არსი
განსაზღვრავს როგორ იქნა ეს შედეგი მიღებული, ანუ, სინამდვილეში,
რეალურად როგორ ამუშავებს პროლოგ – სისტემა მიმართებებს.
პროლოგ – სისტემის შესაძლებლობა, დამოუკიდებლად
დაამუშავოს მრავალი პროცედურული დეტალი, ითვლება პროლოგის
ერთ-ერთ სპეციფიურ უპირატესობად. ეს თვისება პროგრამისტს
აღუძრავს სურვილს პროცედურული არსისაგან შედარებით
დამოუკიდებლად განიხილოს პროგრამის დეკლარაციული არსი.
რადგანაც პროგრამის მუშაობის შედეგები პრინციპში განისაზღვრება
მისი დეკლარაციული არსით, ეს უკანასკნელი (პრინციპში) საკმარისია
პროგრამის დასაწერად. ამ ფაქტს გააჩნია პრაქტიკული მნიშვნელობა,
რადგანაც პროგრამის დეკლარაციული ასპექტები, ჩვეულებრივ, უფრო
ადვილია გასაგებად, ვიდრე პროცედურული დეტალები. ამიტომ
პროგრამისტმა რაც შეიძლება მეტი ყურადღება უნდა მიაქციოს
დეკლარაციულ არსს და არ უნდა გადაერთოს გამოთვლის პროცესის
დეტალებზე. ეს უკანასკნელი სჯობს მივანდოთ თავად პროლოგ –
სისტემას.
 ასეთი დეკლარაციული მიდგომა მართლაც უფრო ამარტივებს
პროლოგზე პროგრამირებას, ვიდრე ისეთ ტიპიურ პროცედურულ –
ორიენტირებულ ენებზე, როგორიცაა პასკალი. სამწუხაროდ
დეკლარაციული მიდგომა ყოველთვის არ არის საკმარისი. შემდგომში
ნათელი გახდება, რომ, განსაკუთრებით დიდ პროგრამებში,
პროგრამისტს გამოთვლების ეფექტურობის თვალსაზრისით არ შეუძლია
პროცედურული ასპექტების სრული იგნორირება. მიუხედავად ამისა,
პროლოგ – პროგრამების წერისას, საჭიროა წავახალისოთ აზროვნების
დეკლარაციული სტილი, ხოლო პროცედურულ ასპექტებს იგნორირება
გავუკეთოთ იმ ფარგლებში, რომლებიც დადგენილია პრაქტიკული
შეზღუდვებით.
რეზიუმე
 პროლოგზე პროგრამირება შედგება მიმართებების
განსაზღვრისაგან და ისეთი კითხვების დასმისაგან,
რომლებიც ეხებიან ამ მიმართებებს.
 პროგრამა შედგება წინადადებებისაგან. არსებობს სამი ტიპის
წინადადება: ფაქტები, წესები და კითხვები.
 მიმართება შეიძლება განისაზღვროს ფაქტებით, ისეთი n
ობიექტებისათვის, რომელთათვისაც ეს მიმართება
სრულდება, ან იგივე მიმართება შეიძლება განისაზღვროს
წესებით.
 პროცედურა არის წინადადებათა სიმრავლე ერთი და იგივე
მიმართების შესახებ.
 კითხვა ძალიან ჰგავს რაიმე მონაცემთა ბაზისათვის
მოთხოვნას. სისტემის პასუხი კითხვაზე წარმოადგენს
ობიექტთა სიმრავლეს, რომლებიც აკმაყოფილებენ
მოთხოვნას.
 პროცესი, რომლის შედეგადაც პროლოგ – სისტემა ადგენს
აკმაყოფილებს თუ არა ობიექტი მოთხოვნას, ხშირად
საკმაოდ რთულია და შეიცავს ლოგიკურ დასკვნას, სხვა და
სხვა ვარიანტების კვლევას და, შესაძლოა, დაბრუნებებს.
ყველაფერი ეს ავტომატურად სრულდება თავად პროლოგ –
სისტემის მიერ და უმეტეს წილად დაფარულია
მომხმარებლისთვის.
 განასხვავებენ პროლოგ – პროგრამის არსის ორ ტიპს:
დეკლარაციული და პროცედურული. პროგრამირების
კუთხით დეკლარაციული მიდგომა უმჯობესია.
მიუხედავად ამისა, პროგრამისტმა ხშირად უნდა
გაითვალისწინოს პროცედურული დეტალებიც.
 ამ თავში შემოტანილი იქნა შემდეგი ცნებები:
წინადადება, ფაქტი, წესი, კითხვა
წინადადების თავი, წინადადების ტანი
რეკურსიული წესი
რეკურსიული განსაზღვრება
პროცედურა
ატომი, ცვლადი
 ცვლადის კონკრეტიზაცია
მიზანი
მიზანი მიღწევადია, მიზანი წარმატებულია
მიზანი მიუღწევადია, მიზანი წარუმატებელია
მიზანი განიცდის წარუმატებლობას
დაბრუნება
დეკლარაციული არსი, პროცედურული არსი.

Tavi 2

prolog programebis sintaqsi da semantika

ამ თავში მოცემული იქნება პროლოგის ძირითადი ცნებების
სინტაქსი და სემანტიკა. აგრეთვე შემოტანილი იქნება მონაცემთა
სტრუქტურული ობიექტები. განიხილება შემდეგი თემები:
  მონაცემთა მარტივი ობიექტები (ატომები, რიცხვები,
ცვლადები)
 სტრუქტურული ობიექტები
 შეპირისპირება, როგორც ობიექტებზე ძირითადი ოპერაცია
 პროგრამების დეკლარაციული (არაპროცედურული)
სემანტიკა
 პროგრამების დეკლარაციულ და პროცედურულ არსებს
შორის ურთიერთკავშირი
 პროცედურული არსის შეცვლა წინადადებების და მიზნების
მიმდევრობის რიგის ცვლილებით
ჩამოთვლილთა დიდ ნაწილს უკვე შევეხეთ პირველ თავში. ახლა
მათი გადმოცემა მიიღებს უფრო ფორმალურ და დეტალურ ხასიათს.

2.1. მონაცემთა ობიექტები

ნახ. 2.1–ზე მოყვანილია პროლოგის მონაცემთა ობიექტების

კლასიფიკაცია. პროლოგ – სისტემა ობიექტის ტიპს პროგრამის ტექსტში
ცნობს მისი სინტაქსური ფორმით.
ეს შესაძლებელია იმის გამო, რომ პროლოგის სინტაქსი მონაცემთა
ობიექტების სხვადასხვა ტიპისათვის ადგენს სხვადასხვა ფორმის
ჩანაწერს. პირველ თავში ჩვენ უკვე ვნახეთ ატომების ცვლადებისაგან
გარჩევის ხერხი: ატომები იწყება პატარა ასოებით, ხოლო ცვლადები –
დიდით. იმისათვის, რომ პროლოგ – სისტემამ გაარჩიოს ობიექტის ტიპი,
მას არ სჭირდება არავითარი დამატებითი ინფორმაცია (მაგალითად,
როგორიცაა მონაცემთა ტიპის გამოცხადება).
 monacemTa obieqtebi

martivi obieqtebi struqturebi

konstantebi cvladebi

atomebi ricxvebi

nax. 2.1 prologis monacemTa obieqtebi

2.1.1. ატომები და რიცხვები

პირველ თავში ჩვენ ვნახეთ ატომების და ცვლადების რამოდენიმე

მარტივი მაგალითი. საერთოდ კი მათ შეუძლიათ მიიღონ უფრო რთული
ფორმები, კეძოდ კი შემდეგი სიმბოლოების ჯაჭვს:
 დიდი ასოები A, B, . . . , Z
 პატარა ასოები a, b, . . . , z
 ციფრები 0, 1, 2, . . . , 9
 სპეციალური სიმბოლოები, როგორიცაა + - * / = : . & _ ~
ატომები შეიძლება შეიქმნას სამი ხერხით:
(1) პატარა ასოთი დაწყებული ასოების, ციფრების და გახაზვის
სიმბოლოთი ( _ ) შედგენილი ჯაჭვით:
nana
 gia
x_34
z25
s__78DT
x_
gama_beta_ rom
kargi_Gia
(2) სპეციალური სიმბოლოებისაგან:
<--->
======>
...
.
::=
ატომების ასეთი ფორმით სარგებლობისას ფრთხილად უნდა
ვიყოთ, რადგანაც ჯაჭვის სპეციალური სიმბოლოების ნაწილს
პროლოგში გარკვეული აზრი გააჩნიათ (მაგალითად, :-).
(3) ერთეულოვან ბრჭყალებში ჩასმული სიმბოლოების
ჯაჭვისაგან. ეს ძალიან მოსახერხებელია, თუ ჩვენ გვინდა
გვქონდეს ატომი, რომელიც იწყება დიდი ასოთი:

‘Tomi’
‘Goga Asatიაni’
‘Saqartvelo_Imereti’

რიცხვები პროლოგში შეიძლება იყოს მთელი და ნამდვილი.

მთელი რიცხვების სინტაქსი მარტივია. ეს კარგად ჩანს შემდეგი
მაგალითებიდან: 1, 2473, 0, -68. მთელი რიცხვების დიაპაზონი
ყოველთვის განსაზღვრულია ინტერვალით რაღაც მინიმალური და
მაქსიმალური რიცხვებით და პროლოგის კონკრეტულ რეალიზაციებში
ის სხვადასხვაა. ჩვეულებრივ რეალიზაციაში დაშვებულია -16383 – დან
16383 – მდე, ხშირად კი დიაპაზონი მნიშვნელოვნად უფრო ფართოა.
ნამდვილი რიცხვების სინტაქსი დამოკიდებულია კონკრეტულ
რეალიზაციაზე. ჩვენ მივიღოთ უბრალო წესები, რომლებიც კარგად ჩანს
შემდეგი მაგალითებიდან: 3.14, -0.0035, 120.4. პროლოგზე ჩვეულებრივი
პროგრამირებისას ნამდვილი რიცხვები იშვიათად გამოიყენება. ამის
მიზეზი ისაა, რომ პროლოგი პირველ რიგში გამოიყენება სიმბოლური და
არა რიცხვითი ინფორმაციის დასამუშავებლად. სიმბოლური
ინფორმაციის დასამუშავებლად კი ხშირად გამოიყენება მთელი
რიცხვები, ხოლო ნამდვილი რიცხვების საჭიროება ნაკლებია.
გარდა იმისა, რომ ჩვეულებრივ პროლოგის გამოყენებისას არ
არსებობს ნამდვილი რიცხვების გამოყენების საჭიროება, არსებობს
მათდამი მორიდების მეორე მიზეზი. ჩვენ ყოველთვის ვესწრაფვით, რომ
ჩვენს პროგრამებს ჰქონდეს ისეთი სახე, რომ მათი არსი იყოს რაც
შეიძლება ნათელი. ნამდვილი რიცხვების შემოტანა კი, არითმეტიკული
მოქმედებებისას დამრგვალების მიზეზით გამოწვეული შეცდომების
არსებობის გამო, ამის საშუალებას არ გვაძლევს. მაგალითად,
გამოსახულების 10000 + 0.0001 – 10000 გამოთვლისას დამრგვალებით
შეიძლება მივიღოთ 0, ნაცვლად 0.0001 – სა.

2.1.2. ცვლადები

ცვლადები – ჯაჭვებია, რომლებიც შედგებიან ასოებისაგან,

ციფრებისაგან და გახაზვის სიმბოლოებისაგან. ისინი იწყება დიდი
ასოებისაგან ან გახაზვის სიმბოლოსაგან:

X
Rezult
Object2
Gიაs_deda
NivtebisSია
_z76
_68

თუ ცვლადი წინადადებაში მხოლოდ ერთხელ გვხვდება, არ არის

აუცილებელი მას დავარქვათ სახელი. შეიძლება გამოვიყენოთ ე.წ.
“ანონიმური” ცვლადი, რომელიც იწერება ერთი სიმბოლოთი – გახაზვის
სიმბოლოთი ( _ ). მაგალითად, განვიხილოთ შემდეგი წესი:

hyavsshvili(X) :- mshobeli(X,Y).

ეს წესი გვეუბნება: ”ნებისმიერი X – სათვის, X – ს ჰყავს შვილი, თუ

X არის რომელიმე Y – ს mshobeli”. აქ ჩვენ ვსაზღვრავთ თვისებას
Bჰყავსშვილი ისე, რომ ის არ არის დამოკიდებული შვილის სახელზე.
შესაბამისად, ამ შემთხვევაში შეიძლება ვისარგებლოთ ანონიმური
ცვლადით. ამიტომ ეს წესი შეიძლება გადავწეროთ შემდეგნაირად:

hyavsshvili(X) :- mshobeli(X, _).

ყოველთვის როცა წინადადებაში გამოჩნდება გახაზვის

ერთადერთი სიმბოლო, ის აღნიშნავს ანონიმურ ცვლადს. მაგალითად,
შეიძლება ითქვას,რომ არსებობს ვიღაც, ვისაც ჰყავს შვილი, თუ არსებობს
ორი ისეთი ობიექტი, რომელთაგან ერთ-ერთი არის მეორის mshobeli:

vigac_hyavs_shvili :- mshobeli(_, _).

ეს წინადადება ექვივალენტურია შემდეგი წინადადებისა:

vigac_hyavs_shvili :- mshobeli(X,Y).

მაგრამ მას სრულიად სხვა აზრი აქვს, ვიდრე წინადადებას

vigac_hyavs_shvili :- mshobeli(X,X).

თუ ანონიმური ცვლადი გვხვდება კითხვაში, მაშინ მასზე

პასუხისას სისტემა მის მნიშვნელობას არ გამოიტანს. თუ ჩვენ
გვაინტერესებს ადამიანები, რომელთაც ჰყავთ შვილები, მაგრამ არა ამ
შვილების სახელები, მაშინ შეგვიძლია უბრალოდ ვკითხოთ:

?-mshobeli(X, _).

სახელის ლექსიკური დიაპაზონი – ერთი წინადადებაა. ეს ნიშნავს,

რომ თუ, მაგალითად, სახელი X15 გვხვდება ორ წინადადებაში, ისინი
აღნიშნავენ ორ სხვადასხვა ცვლადს. მაგრამ ერთ წინადადებაში ყოველი
მისი გამოჩენა ნიშნავს ერთი და იგივე ცვლადს. კონსტანტებისათვის
სულ სხვა სიტუაციაა: ერთი და იგივე ატომი ნებისმიერ წინადადებაში,
ანუ მთელ პროგრამაში, აღნიშნავს ერთი და იგივე ობიექტს.