45186 (664345), страница 6
Текст из файла (страница 6)
;; В поле context сохраняется текущий контекст
;; анализируемого операнда дизъюнкции.
(deftemplate world
(field tag (type INTEGER) (default 1))
(field scope (type SYMBOL) (default truth))
(field prior (type INTEGER) (default 0))
(field context (type INTEGER) (default 0)
)
Помимо модификации структуры объекта, для выполнения отката потребуется разработать правила для выполнения некоторых ключевых операций. Эти операции перечислены ниже вместе с ключевыми словами, ассоциированными с каждой из них.
-
CHECK. Эта операция реализует нормальный режим выполнения вычислений при анализе предположений о правдивости или лживости.
-
CONTRA. Анализ обнаруженного противоречия. Возникло ли оно между двумя высказываниями в одном и том же «мире»? Возникло ли противоречие между двумя высказываниями в одном и том же «мире», но в разных контекстах, например в разных операндах дизъюнкции? Возникло ли оно между двумя разными «мирами», производными от высказываний разных персонажей?
-
CLEAN. После того, как выявлен характер возникшего противоречия, и перед тем, как выполнить откат в точку возврата, эта операция удаляет все утверждения, созданные в текущем «мире».
-
BACK. Если мы имеем дело с противоречием между текущим «миром» и ранее покинутым, эта операция выполняет возврат в ранее покинутый «мир», в котором не был полностью завершен анализ всех дизъюнктов или не было проанализировано предположение о лживости.
-
QUIT. Нам потребуется обнаружить ситуацию, которая наступает в случае, когда проанализированы все возможные интерпретации множества высказываний, т.е. все дизъюнктивные ветви и все возможные комбинации предположений о правдивости или лживости высказываний. Если при обнаружении такой ситуации не удалось найти непротиворечивую интерпретацию, можно со всей ответственностью утверждать, что условия задачи сами по себе несовместимы, т.е. не существует ее решения в терминах отнесения каждого из персонажей к определенной категории – к лжецам или правдолюбцам.
Еще раз модифицируем определение шаблона объекта world – внесем в него поле TASK, в котором будут представлены перечисленные задачи. Это поле будет использовано правилами, которые нам еще предстоит разработать. Механизм работы с задачами подобен тому, который использовался для манипулирования лексемами управления (control tokens), описанными в главах 5 и 14. Этот механизм активизирует определенные правила. Однако при этом мы не будем использовать стратегию MEA или специальные векторы. Лексемы управления будут просто сохраняться в определенном поле объекта world. Но результат будет тот же – эта лексема будет использована для активизации определенного правила.
;; Объект world представляет контекст,
;; сформированный определенными предположениями
;; о правдивости или лживости высказывания,
;; принадлежащего некоторому персонажу.
;; Объект имеет уникальный идентификатор
;; в поле tag, который соответствует
;; тегу высказывания.
;; Смысл допущения – истинность или лживость –
;; фиксируется в поле scope.
;; Поле TASK содержит одно из перечисленных
;; ниже значений:
;; CHECK – анализ предположений о
;; правдивости или лживости высказывания;
;; CONTRA – анализ обнаруженного противоречия;
;; CLEAN – удаляет все утверждения, созданные
;; в противоречивом мире ;
;; BACK – откат в точку возврата;
;; QUIT – прекращение процесса.
;; Поле prior может содержать идентификатор
;; объекта world, обработанного перед тем,
;; как был создан данный объект, и с которым данный
;; объект может потенциально конфликтовать.
;; В поле context сохраняется текущий контекст
;; анализируемого операнда дизъюнкции.
(deftemplate world
(field tag (type INTEGER) (default 1))
(field scope (type SYMBOL) (default truth))
(field task (type SYMBOL) (default check))
(field prior (type INTEGER) (default 0))
(field context (type INTEGER) (default 0))
)
Теперь разработаем правила, которые будут выполнять перечисленные выше операции. Кроме того, нужно внести некоторые изменения и в правила, разработанные для прежней версии программы.
Выявление противоречий
В процессе решения задач о правдолюбцах и лжецах могут быть обнаружены логические противоречия двух типов:
-
между высказываниями в одном и том же «мире», но , возможно, в разных контекстах дизъюнктивного утверждения;
-
между высказываниями в разных «мирах».
Для анализа вариантов возникновения противоречий целесообразно разработать четыре правила. Разобьем первую из указанных ситуаций на два случая:
-
обнаруживается противоречие между предположением и высказыванием, которые существуют в одном и том же контексте (например, если из предположения Т(А) непосредственно следует заключение F(A), как в заявлении персонажа А: F(A));
-
обнаруживается противоречие между предположением и одним из дизъюнктов составного высказывания, как в заявлении персонажа А: T(B) v F(A).
Ситуацию, когда противоречие существует между высказываниями в разных “мирах”, тоже можно разделить на два случая:
-
текущий “мир” рассматривается в предположении, что персонаж говорит правду (в поле scope объекта world содержится значение truth);
-
текущий «мир» рассматривается в предположении, что персонаж лжет (в поле scope объекта world содержится значение falsity).
Если, предположив правдивость персонажа, программа обнаружит противоречие, она должна проанализировать и следствие из противоположного предположения – что персонаж лжец. И только при условии, что оба варианта предположения приводят к противоречию, нужно выполнить откат.
Анализ каждого из четырех вариантов ситуации выполняется отдельным правилом, программы которых представлены ниже. Обратите внимание, что все правила имеют довольно высокий приоритет (значение параметра salience). Это обеспечивает их первоочередную активизацию механизмом разрешения конфликтов между правилами. Кроме того, правила, анализирующие противоречие в пределах одного и того же «мира», имеют более высокий приоритет, чем правила, анализирующие противоречие между разными «мирами». Тем самым обеспечивается реализация стратегии по возможности избегать откатов в процессе решения проблемы.
;; ЕСЛИ обнаруживается противоречие между предположением
;; и производными от него фактами в пределах одного и
;; того же “мира” и в одном и том же контексте,
;; ТО зафиксировать противоречие и удалить
;; противоречивые утверждения (объекты claim)
;; из базы фактов.
(defrule contradiction
(declare (salience 100))
?W <- (world (tag ?N) (task check) (context ?S)
(prior 0))
?P <- (claim (content ?F ?X) (reason ?N)
(context ?S))
?Q <- (claim (content ?G&: (not (eq ?G ?F)) ?X)
(reason ?N (context ?S))
=>
(printout
t crlf
“CONTRADICTION: “ ?F ?X “ versus “
?G ?X “in world “ ?N
;; “ПРОТИВОРЕЧИЕ между: “ ?F ?X “ и “?G ?X “в мире” ?N
t crlf)
(retract ?P)
(retract ?Q)
(modify ?W (task contra))
)
;; ЕСЛИ обнаруживается противоречие между предположением
;; и производными от него фактами в пределах одного и
;; того же “мира”, но в разных контекстах,
;; ТО зафиксировать противоречие.
(defrule transcontext
(declare (salience 90))
?W <- (world (tag ?N) (task check) (context ?T)
(prior 0))
(claim (content ?F ?X) (reason ?N)
(context ?S&: (< ?S ?T)))
(claim (content ?G&: (not eq ?G ?F)) ?x)
(reason ?N) (context ?T))
=>
(printout t crlf
“TRANSCONTEXT CONTRADICTION: “ ?F ?X ” versus “
?G ?X “ in world “ ?N
;; “ТРАНСКОНТЕКСТНОЕ ПРОТИВОРЕЧИЕ между: “ ?F ?X
;; “ и “ ?G ?X “ в мире “ ?N
t crlf)
(modify ?W (task contra))
)
;; ЕСЛИ обнаруживается противоречие между
;; текущим “миром” в предположении о правдивости
;; и ранее покинутым “миром”,
;; ТО зафиксировать противоречие.
(defrule transworld-truth
(declare (salience 80))
?W <- (world (tag ?N) (scope truth) (task check)
(prior 0))
(claim (content ?F ?X) (reason ?N))
(claim (content ?G&: (not (eq ?G ?F)) ?X)
(reason ?M&: (< ?M ?N)))
=>
(printout
t crlf
“TRANSWORLD CONTRADICTION: “ ?F ?X “ versus “
?G ?X “ in worlds “ ?N “I” ?M
;; “МЕЖМИРОВОЕ ПРОТИВОРЕЧИЕ: “ ?F ?X “ противоречит “
;; ?G ?X “ в мирах “ ?N “I” ?M
t crlf)
(modify ?w (task contra))
)
;; ЕСЛИ обнаружится противоречие между
;; текущим “ миром” в предположении о лживости
;; и ранее покинутым “миром”,
;; ТО подготовиться к выполнению отката в ранее
;; покинутый “мир”.
(defrule transworld-falsity
(declare (salience 80))
?W <- (world (tag ?N) (scope falsity) (task check))
(claim (content ?F ?X) (reason ?N))
(claim (content ?G&: (not (eq ?G ?F)) ?X)
(reason ?M&: (< ?M ?N)))
=>
(printout
t crlf
“TRANSWORLD CONTRADICTION: “ ?F ?X “ versus “
?G ?X “ in worlds “ ?N “I” ?M
;; МЕЖМИРОВОЕ ПРОТИВОРЕЧИЕ: “ ?F ?X “ противоречит “
;; ?G ?X “ в мирах “ ?N “I” ?M
t crlf)
(modify ?W (task contra) (prior ?M))
)
Обращаю ваше внимание на то, что вместе с фиксацией самого факта противоречия в последнем правиле фиксируется и идентификатор ранее покинутого «мира», с которым конфликтует текущий. Эта информация потребует для выполнения отката с помощью правил, которые будут представлены в следующем разделе.
Подготовка рабочей памяти к выполнению отката
При подготовке к откату нужно выполнить одну из двух возможных операций с рабочей памятью:
-
если к противоречию привел выбор определенного дизъюнкта, нужно удалить контекст, созданный в результате этого выбора;
-
если к противоречию привело предположение о правдивости персонажа, нужно удалить соответствующий контекст и проанализировать, к чему приведет противоположное предположение.
В любом случае из рабочей памяти нужно удалить объекты claim. Поскольку откат никогда не выполняется в противоречивом контексте, такое удаление не повлияет на полноту представления информации о задаче. Если потребуется вновь сформировать удаленный контекст при других предположениях, это можно будет выполнить, повторив вычисления с «чистого листа».
;; ЕСЛИ обнаружено противоречие с одним из
;; дизъюнктивных контекстов «мира»,
;; ТО удалить все утверждения (объекты claim)
;; этого контекста.
;; ПРИМЕЧАНИЕ: правило будет активизироваться повторно,
;; пока не будут удалены все ненужный объекты.
(defrule clean-context
(declare (salience 50))
(world (tag ?N) (task contra) (prior 0)
(context ?S&~0))
?F <- (claim (reason ?N) (context ?S))
=>
(retract ?F) )
)
;; ЕСЛИ противоречие обнаружено в текущем “мире” в
;; предположении о правдивости,
;; ТО повторить анализ, предположив лживость персонажа.
(defrule switch-context
(declare (salience 40))
;; Если больше нет правых дизъюнктов,
?W <- (world (tag ?N) (scope truth) (task contra)
(prior 0) (context ?S&~1))
=>
;; изменить предположение и сформировать новый контекст.
(modify ?W (scope falsity) (task check) (context 0))
)
;; Удалить все утверждения (объекты claim),
;; сформированные на основании предположения о
;; правдивости.
;; ПРИМЕЧАНИЕ: правило будет активизироваться повторно,
;; пока не будут удалены все ненужные объекты.
(defrule sweep-truth
(declare (salience 100))
(world (tag ?N) (scope falsity))
?F <- (claim (reason ?N) (scope truth))
=>
(retract ?F)
)
Последнее правило демонстрирует, как с помощью полей reason и scope можно отслеживать объекты claim. В данной программе используется тот же прием, что и в системах обработки правдоподобия, которые были рассмотрены в главе 19.
Теперь можно приступить к разработке правил, выполняющих откат.
Выполнение отката
Каждое отдельное высказывание в задачах рассматриваемого класса формирует свой «мир». Поскольку высказывания обрабатываются последовательно, возможна ситуация, когда «мир», который программа анализирует в текущий момент, вступает в конфликт с одним из «миров», обработанных ранее. Дальнейшие действия в такой ситуации зависят от того, на каких предположениях основаны конфликтующие «миры».
Если текущий «мир» был проанализирован только в предположении о правдивости соответствующего персонажа, то, очевидно, нужно повторить его анализ, но уже в предположении, что персонаж – лжец. Если и в этом случае конфликтная ситуация сохраняется, следовательно, мы исчерпали все возможности ее локального разрешения, поэтому нужно подумать о возврату к анализу ранее покинутого «мира» и повторить его анализ, но уже на основе других предположений.
Но возврат имеет смысл выполнять только в том случае, если в ранее покинутом «мире» не были проанализированы все возможные сочетания предположений и контекстов. Таким образом, одно из условий, при которых целесообразно выполнять откат, состоит в том, что покинутый «мир» был проанализирован только в предположении правдивости соответствующего персонажа и что есть еще возможность проанализировать следствия из противоположного предположения.
Правило undirected-falsity выполняет необходимые для этого подготовительные операции. Смысл слова undirected (ненаправленный) состоит в том, что это правило реализует откат в «хронологическом» порядке создания «миров». В механизме разрешения конфликтов в CLIPS реализовано «хронологическое предпочтение», которое обеспечивает откат к последнему из ранее сформированных «миров», удовлетворяющих заданным условиям. Но при этом не предпринимается никакой попытки локализовать в процессе выбор точки, которая стала причиной конфликта, например выбрать именно тот «мир», с которым конфликтует текущий.
;; Хронологический откат к тому “миру”, который был
;; покинут без выполнения анализа в предположении
;; о лживости (поле scope содержит значение truth,
;; а поле task – значение check).
(defrule undirected-falsity
(world (tag ?N) (scope falsity) (task contra))
?W <- (world (tag ?M&: (< ?M ?N))
(scope truth) (task check))
=>
(modify ?W (task back))
)
Альтернативный сценарий используется в ситуации, когда в ранее покинутом «мире» не были проанализированы все дизъюнкты составного утверждения. «Мир» был покинут, когда обнаружилось, что проанализированный дизъюнкт не противоречит предположению, поэтому прочие дизъюнкты просто не рассматривались. Теперь, когда обнаружилось противоречие с другим «миром», можно вновь вернуться к ранее незавершенному анализу и попробовать, не разрешится ли конфликт в результате исследования другого дизъюнкта.
Приведенное ниже правило undirected-disjunct выполняет подготовку к такому откату в хронологическом порядке.
;; Хронологический откат к тому «миру», который был
;; покинут без завершения анализа дизъюнктов.
(defrule undirected-disjunct
(world (tag ?N) (scope falsity) (task contra))
V <- (world (tag ?M&: (< ?M ?N)) (task check)
(context 1))
claim (content OR ?P ?X ?Q ?Y) (reason ?M)
(scope ?S))
=>
;; Дизъюнкт в ранее покинутом “мире”, анализ которого
;; не был выполнен.
assert (claim (content ?Q ?Y) (reason ?M) (scope ?S)
(context 2)))
;; Зафиксировать необходимость отката в этот “мир”.
Modify ?V (task back))
)
Хронологический откат является не единственной операцией такого рода. Ниже представлены «направленные» (directed) версии соответствующих правил, в которых используется информация о том, в каком именно «мире» имеется утверждение, ставшее причиной конфликта с текущим «миром». Эта информация содержится в слоте prior текущего объекта world.
;; Если обнаружено противоречие между
;; объектами world M и N
;; и объект M создан ранее объекта N,
;; причем анализ M в предположении о лживости
;; соответствующего высказывания не был выполнен,
;; ТО вернуться к анализу объекта M.
(defrule directed-falsity
(world (tag ?N) (scope falsity) (task contra)
(prior ?M&”0))
?W <- (world (tag ?M) (scope truth) (task check))
=>
modify ?W (task back))
)
;; Если обнаружено противоречие между
;; объектами M и N
;; и объект М создан ранее объекта N, причем
;; не был выполнен анализ всех дизъюнктов в M,
;; ТО вернуться к анализу объекта M.
(defrule directed-disjunct
(world (tag ?N) (scope falsity) (task contra)
(prior ?M&~0))
?V <- (world (tag ?M) (task check) (context 1))
(claim (content OR ?P ?X ?Q ?Y) (reason ?M)
(scope ?S))
=>
;; Дизъюнкт в ранее покинутом “мире”, анализ которого
;; не был выполнен.
(assert (claim (content ?Q ?Y) (reason ?M)
(scope ?S) (context 2)))
;; Зафиксировать необходимость отката в этот “мир”.
(modify ?V (task back))
)
Если вы думаете, что эти два правила позволяют справиться со всеми возможными ситуациями, в которых может возникнуть необходимость выполнить откат, то вы ошибаетесь. «Миры» W и V могут конфликтовать, хотя в обоих проанализированы все варианты предположений и все дизъюнкты. А источник конфликта при этом находится в некотором третьем «мире», в котором не был завершен анализ предположений или дизъюнктов. (см. пример 4).
Упражнение 4
Проанализируйте следующую головоломку, в которой участвуют персонажи А, В и С.
А: «В лжец».
В: «С лжец».
С: «В всегда говорит правду».
Как выполнить откат в процессе решения этой задачи. Отыщите «мир», в который нужно выполнить откат, и объясните, почему этот «мир» не удастся определить с помощью приведенных выше правил.
Фактически второе т третье высказывания в этой задаче несовместимы, а потому в ней не существует варианта непротиворечивого распределения ролей между персонажами.
Правила directed- и undirected- можно использовать в комбинации, но с первого взгляда трудно решить, как именно это сделать. Условные части правил undirected-falsity и directed-falsity одинаковы, а потому нам остается только манипулировать значением параметра salience. Обычно «направленные» варианты правил более эффективны, но в результате их применения может пострадать полнота исследования «миров» в особо хитроумных задачах. «Ненаправленные» варианты работают медленнее, но зато обеспечивают исчерпывающий просмотр всех имеющихся в задаче объектов world. Я предлагаю читателям самостоятельно поэкспериментировать с обоими вариантами при решении разных задач рассматриваемого класса. Мы же в дальнейшем будем использовать только «ненаправленные» варианты этих правил.
Восстановление контекста
При восстановлении контекста придется удалить из рабочей памяти все объекты world, созданные после того объекта, к анализу которого программа возвращается. Удаляются и все утверждения, сформированные на основании высказываний, связанных с удаляемыми объектами. Сами же высказывания (объекты statement) должны быть сохранены и при этом помечены признаком, указывающим, что их нужно в дальнейшем анализировать повторно.
;; Удаление объектов world.
;; ЕСЛИ выполняется откат к объекту М,
;; ТО удалить все объекты world,
;; имеющие идентификатор, больший М.
;; ПРИМЕЧАНИЕ: правило может активизироваться
;; несколько раз.
(defrule undo-world
(declare (salience 40))
(world (tag ?M) (task back))
?W ?N ?M)))
?S <- (statement (tag ?N) (done ?X&~0))
=>
(retract ?W)
(modify ?S (done 0))
)
;; Удаление объектов claim.
;; ЕСЛИ выполняется откат к объекту world M,
;; ТО удалить все объекты claim,
;; связанные с удаленными объектами world.
(defrule unclaim
(declare (salience 30))
(world (tag ?M) (task back))
?F ?N ?M)))
=>
(retract ?F)
)
;; Возобновление процесса вычислений
;; начиная с точки возврата.
;; ЕСЛИ все объекты world, созданные
;; после объекта М, удалены,
;; ТО повторно сформировать объект М,
;; предположив лживость высказывания.
(defrule restart
(declare (salience 20) )
?W <- (world (tag ?M) (scope truth)
(task back) (context ?C&~1))
=>
(retract ?W)
(modify ?W (scope falsity) (task check) (context 0))
)
Последнее из приведенных выше правил вновь запускает процесс анализа того объекта world, к которому выполнен откат. Обратите внимание на то, что это правило имеет самый низкий приоритет. В результате правила, уничтожающие ненужные объекты, будут активизированы в первую очередь.
Организация процесса вычислений на основе этих правил позволяет программе продолжать вычисления до тех пор, пока имеются не до конца проанализированные «миры». При использовании «ненаправленных» правил отката программа всегда сможет вернуться к последнему объекту world, предлагающему альтернативный вариант предположения, или к такому объекту, в котором имеются еще не проанализированные дизъюнкты составного утверждения.
Упражнение 5
Проанализируйте следующую головоломку.
Р7. Встретились два человека, А и В, которые заявляют следующее.
А: «В утверждает, что он правдолюбец.»
В: « А утверждает, что он лжец.»
К какой категории следует отнести каждый персонаж? Как следует модифицировать нашу программу, чтобы она могла решать задачи такого вида? Ниже будут высказаны некоторые соображения, которые подскажут вам, как модифицировать модель для таких задач.
В существующей программе мы прежде всего анализировали непротиворечивость каждого из «миров», т.е. внутреннюю непротиворечивость каждого отдельного высказывания. После этого мы анализировали непротиворечивость одного «мира» другому (или другим).
Включение в постановку задачи высказывания о высказывании (назовем его метавысказыванием) несколько усложняет положение дел. В такой постановке высказывание образует «мир», в котором другое высказывание, а не утверждение, может быть истинным или ложным. Это второе, внутреннее, высказывание должно также формировать собственный «мир».
Рассмотрим высказывание
А: «В утверждает, что он правдолюбец.»
Предположив, что А говорит правду, мы сформируем «мир», в котором В действительно утверждает, что он правдолюбец, но внутри этого «мира» существует и другой, в котором В действительно является правдолюбцем. Отслеживать подобного рода связи между внешним высказыванием и «внедренным» в него внутренним высказыванием – одна из новых задач механизма обработки правдоподобия.
А что можно сказать о «мире», в котором А лжет? Мы должны показать, что заявление В о том, что он лжец, приведет к противоречию.
А.4.6. Обработка метавысказываний
Имеяв свом распоряжении программу, снабжённую механизмом реализации откатов, попробуем адаптировать её к работе с метавысказываниями, т.е. высказываниями о высказываниях. Это позволит нам решать задачи, подобные Р7, которая приведена в упр. 5.
Рассмотрим высказывание:
А: «В утверждает, что он правдолюбец».
Мы должны сформировать «мир», в котором В утверждает, что он правдолюбец, а внутри этого «мира» другой, в котором В действительно является правдолюбцем. Также внедренные «миры» образуют отдельное множество зависимостей, которое придётся отслеживать с помощью механизма обработки правдоподобия. Начнём с того, что модифицируем шаблон объекта world и внесём в него информацию о том, является ли данный объект внешним или внутренним, а если внутренним, то какой объект world является для него внешним.
В более сложных сцинариях работы с «мирами» нам потребуется также отслеживать, был ли данный объект world проанализирован полностью. Это упростит выполнение отката.
;; Объект world представляет множество утверждений,
;; сформированных при определённом предположении
;; о правдивости или лживости высказывания,
;; принадлежащего некоторому персонажу.
;; Объект имеет уникальный идентификатор
;; в поле tag, который соответствует
;; тегу высказываний.
;; Смысл допущения – истинность или лживость –
;; фиксируется в поле scope.
;; Поле TASK содержит одно из перечисленных
;; ниже значений:
;; CHECK – анализ предположений о
;; правдивости или лживости высказываний;
;; CONTRA – анализ обнаруженного противоречия;
;; CLEAN – удаляет все утверждения, созданные
;; в противоречивом «мире»;
;; BACK – откат в точку возврата;
;; QUIT – прекращение процесса.
;; Поле prior может содержать идентификатор
;; объекта world, созданного перед тем,
;; как был создан данный объект, и с которым данный
;; объект может потенциально конфликтовать.
;; Поле upper содержит идентификатор другого объекта
;; world, в который внедрён данный объект, если
;; соответствующее высказывание содержит другое
;; высказывание.
;; Например, А говорит, что В сказал, что А – лжец.
;; В поле context сохраняется текущий контекст
;; анализируемого операнда дизъюнкции.
;; Поле done содержит информацию о том, обработано ли
;; уже высказывание, на основании которого создан этот
;; объект.
(deftemplate world
(field tag (type INTEGER) (default 1))
(field scope (type SYMBOL) (default truth))
(field task (type SYMBOL) (default check))
(field prior (type INTEGER) (default (0))
(field upper (type INTEGER) (default 0))
(field context (type INTEGER) (default 0))
(field done (type INTEGER) (default 0))
)
;; Объект statement (высказывание) связан с определённым
;; персонажем (поле speaker).
;; Высказывание содержит утверждение (поле claim).
;; Высказывание имеет основание – причину (поле reason)
;; Если данный объект не является производным от другого
;; объекта statement, в поле reason устанавливается
;; значение 0.
;; В поле tag устанавливается уникальный числовой
;; идентификатор объекта – число, большее 0.
;; В поле DONE устанавливается одно из
;; следующих значений:
;; 0 означает, что объект ещё не обрабатывался;
;; 1 означает, что объект обрабатывался в предположении
;; о правдивости высказывания;
;; 2 означает, что объект обрабатывался в предположении
;; о лживости высказывания.
(deftemplate statement
(field speaker (type SYMBOL))
(multifield claim (type SYMBOL))
(field scope (type SYMBOL) (default truth))
(multifield reason (type INTEGER) (default 0))
(field tag (type INTEGER) (default 0))
(field done (type INTEGER) (default 0))
)
Теперь разработаем правило, которое будет «распаковывать» высказывание о высказывании.
;; ЕСЛИ объект world базируется на предположении о
;; правдивости метавысказывания,
;; ТО прредположить, что персонаж говорит правду и что
;; высказывание истинно.
(defrule unwrap-true-state
?W <- (world (tag ?N) (scope truth) (task check)
(done 0))
?S <- (statement (speaker ?X) (claim SAY ?Z $?Y)
(done 0))
=>
(printout
t crlf
“Assuming “ T ?X “ and “ ?Z “ says “ $?Y
“ in world “ ?N
;; “Предполагается “ Т ?Х “ и “ ? Z “ говорит “ $?Y
;; “ в мире “ ?N
t crlf
)
;; Зафиксировать, что высказывание было распаковано
;; в предложении о его правдивости.
(modify ?S (tag ?N) (done 1))
;; Предположим, что персонаж в текущем «мире» является
;; правдолюбцем.
(assert (claim (content T ?X) (reason ?N)
(scope truth)))
;; Зафиксировать в объекте world для внедрённого
;; высказывания и зафиксировать, что этот объект
;; является внутренним по отношению к объекту ?N.
(assert (world (tag (+ ?N 1)) (scope truth) (upper ?N)))
;; Зафиксировать внедрённое высказывание в новом
;; объекте world.
(assert (statement (speaker ?Z) (claim $?Y)
(reason ?N)))
)
;; ЕСЛИ объект world базируется на предположении о
;; лживости метавысказывания,
;; ТО предложить, что персонаж лжец.
;; Каких-то предположений об истинности
;; утверждения не делается.
(defrule unwrap-false-state
?W <- (world (tag ?N) (scope falsity) (task check))
?S <- (statement (speaker ?X) (claim SAY ?Z $?Y)
(tag ?N) (done 1))
=>
(printout
t crlf
“Assuming “ F “ “?X “ and NOT “ ?Z “ says “ $?Y
“ in world “ ?N
;; “Предполагается “ F “ “ ?X “ и НЕ “ ?Z “ говорит “ $?Y
;; в мире “ ?N
t crlf
)
;; Изменить значения в поле scope текущего объекта
;; world.
(modify ?W (scope falsity) (done 2))
;; Зафиксировать, что высказывание было распаковано
;; в предложении о лживости.
(modify ?S (scope falsity) (done 2))
;; Предположить, что в текущем «мире» персонаж,
;; произнёсший метавысказывание лжец.
(assert (claim (content F ?X) (reason ?N) (scope falsity)))
)
Чтобы облегчить себе жизнь, будем считать, что в метавысказывании не может быть отрицания, т.е. мы не будем рассматривать метавысказывания вида
А: «В не говорил, что он правдолюбец».
Более того, если А говорит, что В заявил нечто, то по условиям, принятым в головоломках этого класса, для того чтобы доказать, что А лжец, требуется только показать, что не существует непротиворечивого «мира», в котором В мог бы сделать правдивое утверждение. Таким образом, нам не придётся обрабатывать отрицания в метавысказываниях и анализировать их непротиворечивость. Указанные условия нашли своё отражение в правиле unwrap-false-state. В этом правиле, которое активизируется, когда предположение о правдивости персонажа не срабатывает, просто предполагается, что этот персонаж лжец, а более глубокий анализ не проводится.
А.4.7. Полный листниг программы
Ниже приведён полный листинг CLIPS-программы, которая обеспечивает обработку составных утверждений и метавысказываний.
Эта программа предназначена для разрешения головоломок о правдолюбцах и лжецах. Программа анализирует наличие логических противоречий и отыскивает первую непротиворечивую интерпретацию.
Программа может обрабатывать конъюнктивные и дизъюнктивные составные утверждения.
Программа может решать задачи с множеством высказываний и метавысказываниями.
;; TEMPLATES
;; Объект CLAIM имеет следующие поля::
;; CONTENT – содержимое утверждения, например,
;; Т А ... означает, что А является правдолюбцем;
;; F А ... означает, что А является лжецом;
;; OR T A F B ... означает, что А является правдолюбцем
;; или В является лжецом, и т.д.
;; REASON указывает, на основании какого высказывания
;; сформировано данное утверждение.
;; Значение этого поля равно идентификатору (полю tag)
;; соответствующего объекта statement (высказывание).
;; CONTEXT ::= 0 / 1 / 2;
;; значение 0 означает глобльный контекст,
;; значение 1 означает локальный контекст левого
;; операнда,
;; значение 2 означает локальный контекст правого
;; операнда дизъюнкции.
(deftemplate claim
(multifield content (type SYMBOL))
(field reason (type INTEGER))
(field scope (type SYMBOL))
(field context (type INTEGER) (default 0))
)
;; Объект statement (высказывание связан с определённым
;; персонажем (поле speaker).
;; Высказывание сожержит утверждение (поле claim).
;; Высказывание имеет основание – причину (поле reason).
;; Если данный объект не является производным от другого
;; объекта statement, в поле reason устанавливается
;; значение 0.
;; В поле tag устанавливается уникальный числовой
;; индентификатор объекта – число, больше 0.
;; В поле DONE устанавливается одно из
;; следующих значений:
;; 0 означает, что объект ещё не обрабатывался;
;; 1 означает, что объект обрабатывался в предположении
;; о правдивости высказывания;
;; 2 означает, что объект обрабатывался в предположении
;; о лживости высказывания.
(deftemplate statement
(field speaker (type SYMBOL))
(multifield claim (type SYMBOL))
(field scope (type SYMBOL) (default truth))
(multifield reason (type INTEGER) (default 0))
(field tag (type INTEGER) (default 0))
(field done (type INTEGER) (default 0))
)
;; Объект world представляет множество утверждений,
;; сформированных при определённом предположении
;; о правдивости или лживости высказывания,
;; принадлежащего некоторому персонажу.
;; Объект имеет уникальный идентификатор
;; в поле tag, который соответствует
;; тегу высказываний.
;; Смысл допущения – истинность или лживость –
;; фиксируется в поле scope.
;; Поле TASK содержит одно из перечисленных
;; ниже значений:
;; CHECK – анализ предположений о
;; правдивости или лживости высказываний;
;; CONTRA – анализ обнаруженного противоречия;
;; CLEAN – удаляет все утверждения, созданные
;; в противоречивом «мире»;
;; BACK – откат в точку возврата;
;; QUIT – прекращение процесса.
;; Поле prior может содержать идентификатор
;; объекта world, созданного перед тем,
;; как был создан данный объект, и с которым данный
;; объект может потенциально конфликтовать.
;; Поле upper содержит идентификатор другого объекта
;; world, в который внедрён данный объект, если
;; соответствующее высказывание содержит другое
;; высказывание.
;; Например, А говорит, что В сказал, что А – лжец.
;; В поле context сохраняется текущий контекст
;; анализируемого операнда дизъюнкции.
;; Поле done содержит информацию о том, обработано ли
;; уже высказывание, на основании которого создан этот
;; объект.
(deftemplate world
(field tag (type INTEGER) (default 1))
(field scope (type SYMBOL) (default truth))
(field task (type SYMBOL) (default check))
(field prior (type INTEGER) (default (0))
(field upper (type INTEGER) (default 0))
(field context (type INTEGER) (default 0))
(field done (type INTEGER) (default 0))
)
;; ФУНКЦИИ
;; Изменяется область определения предиката с T на F
;; и наоборот.
(deffunction flip (?P)
(if (eg ?P T) then F else T)
)
;; ПРАВИЛА
;; Распаковка высказываний
;;----------------------------------------------------------------------
;; ЕСЛИ объект world базируется на предположении о
;; правдивости высказывания,
;; ТО предположить, что персонаж говорит правду и что
;; высказывание истинно.
;; Значение поля TAG объекта statement передаётся в поле
;; reason объектов claim.
;; ПРИМЕЧАНИЕ. Это правило не используется для
;; распаковки метавысказываний.
(defrule unwrap-true
?W <- (world (tag ?N) (scope truth) (task check)
(done 0))
?S <- (statement (speaker ?X)
(claim ?P&: (not (eg ?P SAY)) $?Y)
(done 0))
=>
(printout
t crlf
“Assuming “ T ?X “ and “ ?P $?Y “ in world “ ?N
;; “Предполагается “ N “ ?X “ and “ ?P $?Y “ в мире “ ?N
t crlf
)
;; Зафиксировать, что высказывание было распаковано
;; в предположении о его правдивости.
(modify ?S (tag ?N) (done 1))
;; Зафиксировать в объекте world, что высказывание
;; распаковано.
(modify ?W (done 1))
;; Предположим, что персонаж в текущем «мире» является
;; правдолюбцем.
(assert (claim (content T ?X) (reason (?N)
(scope truth)))
;; Предполагается, что утверждение в высказывании
;; истинно.
(assert (claim (content ?P $?Y) (reason ?N)
(scope truth)))
)
;;----------------------------------------------------------------------
;; ЕСЛИ объект world базируется на предположении о
;; правдивости метавысказывания,
;; ТО прредположить, что персонаж говорит правду и что
;; высказывание истинно.
(defrule unwrap-true-state
?W <- (world (tag ?N) (scope truth) (task check)
(done 0))
?S <- (statement (speaker ?X) (claim SAY ?Z $?Y)
(done 0))
=>
(printout
t crlf
“Assuming “ T ?X “ and “ ?Z “ says “ $?Y
“ in world “ ?N
;; “Предполагается “ Т ?Х “ и “ ? Z “ говорит “ $?Y
;; “ в мире “ ?N
t crlf
)
;; Зафиксировать, что высказывание было распаковано
;; в предложении о его правдивости.
(modify ?S (tag ?N) (done 1))
;; Предположим, что персонаж в текущем «мире» является
;; правдолюбцем.
(assert (claim (content T ?X) (reason ?N)
(scope truth)))
;; Зафиксировать в объекте world для внедрённого
;; высказывания и зафиксировать, что этот объект
;; является внутренним по отношению к объекту ?N.
(assert (world (tag (+ ?N 1)) (scope truth) (upper ?N)))
;; Зафиксировать внедрённое высказывание в новом
;; объекте world.
(assert (statement (speaker ?Z) (claim $?Y)
(reason ?N)))
)
;;----------------------------------------------------------------------
;; ЕСЛИ объект world базируется на предполодении о
;; лживости высказывания,
;; ТО предположить, что персонаж лжёт и что
;; высказывание ложно.
;; ПРИМЕЧАНИЕ. Это правило не используется для
;; распаковки метавысказываний.
(defrule unwrap-false
?W <- (world (tag ?N) (scope falsity) (task check))
?S <- (statement (speaker ?X)
(claim ?P&: (not (eq ?P NOT) (eq ?P SAY))) $?Y)
(tag ?N) (done 1))
=>
(printout
t crlf
“Assuming “ F ?X “ and NOT “ in world “ ?N
;; “ Предполагается “ F ?X “ и НЕ “ ?P $?Y “ в мире “ ?N
t crlf
)
;; Зафиксировать, что высказывание анализируется
;; в предположении о его лживости.
(modify ?S (scope falsity) (done 2))
;; Зафиксировать в объекте world, что анализируется
;; лживость высказывания.
(modify ?W (done 2))
;; Предположим, что персонаж лжец.
(assert (claim (content F ?X) (reason ?N)
(scope falsity)))
;; Сформировать отрицание утверждения.
(assert (claim (content NOT ?P $?Y) (reason ?N)
(scope falsity)))
)
;;----------------------------------------------------------------------
;; ЕСЛИ объект world базируется на предположении о
;; лживости метавысказывания,
;; ТО предложить, что персонаж лжец.
;; Каких-то предположений об истинности
;; утверждения не делается.
;; ПРИМЕЧАНИЕ. Правило используется только для работы с
;; метавысказываниями, которые не содержат отрицаний.
;; Правило не может обрабатывать метавысказывания вида:
;; А: «В говорит, что он лжец.»
;; или А: «В говорит, что он не лжец.»
(defrule unwrap-false-state
?W <- (world (tag ?N) (scope falsity) (task check))
?S <- (statement (speaker ?X) (claim SAY ?Z $?Y)
(tag ?N) (done 1))
=>
(printout
t crlf
“Assuming “ F “ “?X “ and NOT “ ?Z “ says “ $?Y
“ in world “ ?N
;; “Предполагается “ F “ “ ?X “ и НЕ “ ?Z “ говорит “ $?Y
;; в мире “ ?N
t crlf
)
;; Изменить значения в поле scope текущего объекта
;; world.
(modify ?W (scope falsity) (done 2))
;; Зафиксировать, что высказывание было распаковано
;; в предложении о лживости.
(modify ?S (scope falsity) (done 2))
;; Предположить, что в текущем «мире» персонаж,
;; произнёсший метавысказывание лжец.
(assert (claim (content F ?X) (reason ?N) (scope falsity)))
)
;;----------------------------------------------------------------------
;; ЛОГИЧЕСКИЕ ОПЕРАТОРЫ
;; Правила отрицания
;;----------------------------------------------------------------------
;; ЕСЛИ некто не правдолюбец,
;; ТО он лжец.
(defrule not1
(declare (salience 5))
?F <- (claim content NOT T ?P))
=>
(modify ?F (content F ?P))
)
;;----------------------------------------------------------------------
;; ЕСЛИ некто не лжец,
;; ТО он правдолюбец.
(defrule not2
(declare (salience 5))
?F <- (claim content NOT F ?P))
=>
(modify ?F (content T ?P))
)
;;----------------------------------------------------------------------
;; Распространение отрицания на дизъюнкцию.
(defrule not-or
(declare (salience 5))
?F <- (claim (content NOT OR ?P ?X ?Q ?Y))
=>
(modify ?F (content AND (flip ?P) ?X (flip ?Q) ?Y))
)
;;----------------------------------------------------------------------
;; Распространение отрицания на конъюнкцию.
(defrule not-or
(declare (salience 5))
?F <- (claim (content NOT AND ?P ?X ?Q ?Y))
=>
(modify ?F (content OR (flip ?P) ?X (flip ?Q) ?Y))
)
;;----------------------------------------------------------------------
;; Устранение конъюнкции.
(defrule conj
(world (tag ?N) (scope ?V) (task check)
(context ?L))
(claim (content AND ?P ?X ?Q ?Y) (reason ?N)
(scope ?V) (context ?L)
=>
(assert (claim (content ?P ?X) (reason ?N)
(scope ?V) (context ?L))
(assert (claim (content ?Q ?Y) (reason ?N)
(scope ?V) (content ?L))
)
;;----------------------------------------------------------------------
;; ОБРАБОТКА ДИЗЪЮНКТИВНЫХ УТВЕРЖДЕНИЙ
;;----------------------------------------------------------------------
;; ЕСЛИ мы имеем дело с дизъюнктивным утверждением,
;; т.е. context = 0,
;; ТО сначала проанализировать левый дизъюнкт.
;; ПРИМЕЧАНИЕ. Устанавливается значение 1 как в поле
;; context объекта world, так и в поле context нового
;; объекта claim.
(defrule left-disjunct
?W <- (world (tag ?N) (task check) (scope ?V)
(content 0))
(claim (content OR ?P ?X ?Q ?Y) (reason ?N)
(scope ?V) (content 0))
=>
(assert (claim (content ?P ?X) (reason ?N)
(scope ?V) (context 1))
)
;;----------------------------------------------------------------------
;; ЕСЛИ при анализе левого дизъюнкта обнаружено
;; противоречие,
;; ТО проанализировать правый дизъюнкт.
(defrule right-disjunct
?W <- (world (tag ?N) (task contra) (context 1))
(claim (content OR ?P ?X ?Q ?Y) (reason ?N)
(scope ?V))
=>
(assert (claim (content ?Q ?Y) (reason ?N)
(scope ?V) (context 2)))
(modify ?W (task check) (context 2))
)
;;----------------------------------------------------------------------
;; ЕСЛИ выполнен откат к анализу правого дизъюнкта,
;; ТО установить соответствующий контекст.
(defrule resume-disjunct
?W <- (world (tag ?N) (task back) (context 1))
(claim (content OR ?P ?X ?Q ?Y) (reason ?N)
(scope ?V))
=>
(assert (claim (content ?Q ?Y) (reason ?N)
(scope ?V) (context 2)))
(modify ?W (task check) (context 2))
)
;;----------------------------------------------------------------------
;; ЕСЛИ анализ обоих дизъюнктов в предположении о
;; правдивости персонажа привёл к противоречию
;; в том же самом «мире»,
;; ТО выполнить анализ, предполагая, что персонаж лжёт.
(defrule false-disjuncts
?W <- (world (tag ?M) (scope truth) (task contra)
(prior 0) (context 2))
(not (claim (reason ?M) (context 2)))
=>
(modify ?W (scope falsity) (task check) (context 0))
)
;;----------------------------------------------------------------------
;; ЕСЛИ аналих в предположении о правдивости персонажа
;;привёл к противоречию с другим «миром»,
;; ТО выполнить анализ, предполагая, что персонаж лжёт.
(defrule other-world
?W <- (world (tag ?N) (scope truth) (task contra)
(prior ?M&~0) (context 0))
=>
(modify ?W (scope falsity) (task check))
)
;;----------------------------------------------------------------------
;; ОБРАБОТКА ПРОТИВОРЕЧИЙ
;;----------------------------------------------------------------------
;; ЕСЛИ обнаруживается противоречие между предположением
;; и производными от него фактами в пределах одного и
;; того же мира и в одном и том же контексте,
;; ТО зафиксировать противоречия и удалить
;; противоречивые утверждения (объект claim)
;; из базы фактов.
(defrule contradiction
(declare (salience 100))
?W <- (world (tag ?N) (task check) (scope ?V)
(context ?S))
?P <- (claim (content ?F ?X) (scope ?V) (reason ?N)
(context ?S))
?Q <- (claim (content ?G&: (not (eq ?G ?F)) ?X)
(scope ?V) (reason ?N) (context ?S))
=>
(printout
t crlf
“CONTRADICTION: “ ?F ?X “ versus “
?G ?X “ in world “ ?N
;; “ПРОТИВОРЕЧИЕ между: “ ?F ?X “ и “ ?G ?X “ в мире “ ?N
t crlf)
(retract ?P)
(retract ?Q)
(modify ?W (task contra))
)
;;----------------------------------------------------------------------
;; ЕСЛИ обнаруживается противоречие между предположением
;; и производными от него фактами в пределах одного и
;; того же мира, но в разных конекстах,
;; ТО зафиксировать проиворечие.
(defrule transcontext
(declare (salience 90))
?W <- (world (tag ?N) (task check) (scope ?V)
(context ?T))
(claim (content ?F ?X) (scope ?V) (reason ?N)
(context ?S&: (< ?S ?T)))
(claim (content ?G&: (not (eq ?G ?F)) ?X) (scope ?V)
(reason ?N) (context ?T))
=>
(printout t crlf
“TRANSCONTEXT CONTRADICTION: “ ?F ?X “ versus “
?G ?X “ in world “ ?N
;; “ТРАНСКОНТЕКСТНОЕ ПРОТИВОРЕЧИЕ между: “ ?F ?X
;; “ и “ ?G ?X “ в мире “ ?N
t crlf)
(modify ?W (task contra))
)
;;----------------------------------------------------------------------
;; ЕСЛИ обнаруживается противоречие между
;; текущим «миром» в предположении о правдивости
;; и ранее покинутым «миром»,
;; ТО зафиксировать противоречие.
(defrule transworld-truth
(declare (salience 80))
?W <- (world (tag ?N) (scope truth) (task check)
(upper 0))
;; В текущем «мире» имеется утверждение,
;; противоречащее утверждению в другом «мире».
(claim (content ?F ?X) (reason ?N))
;; «Мир», с которым обнаружен конфликт, имеет
;; индентефикатор, меньший, чем текущий «мир»,
;; т.е. сформирован раньше.
(claim (content ?G&: (not (eq ?G ?F)) ?X)
(reason ?M&: (< ?M ?N)))
=>
(printout
t crlf
“TRANSWORLD CONTRADICTION: “ ?F ?X “ versus “
?G ?X “ in world “ ?N “ I “ ?M
;; “МЕЖМИРОВОЕ ПРОТИВОРЕЧИЕ: “ ?F ?X “ противоречит “
;; ?G ?X “ в мирах “ ?N “ I “ ?M
t crlf)
(modify ?W (task contra))
)
;;----------------------------------------------------------------------
;; ЕСЛИ обнаруживается противоречие между
;; текущим «миром» в предположении о лживости
;; и ранее покинутым «миром»,
;; ТО подготовиться к выполнению отката в ранее
;; покинутый «мир».
(defrule transworld-falsity
(declare (salience 80))
?W <- (world (tag ?N) (scope falsity)
(task check) (upper 0))
(claim (content ?F ?X) (reason ?N))
(claim
(content ?G&: (not (eq ?G ?F)) ?X)
(reason (?M&: (< ?M ?N)))
=>
(printout
t crlf
“TRANSWORLD CONTRADICTION: “ ?F ?X “ versus “
?G ?X “ in worlds “ ?N “ I “ ?M
;; “МЕЖМИРОВОЕ ПРОТИВОРЕЧИЕ: “ ?F ?X “ проиворечит “
;; ?G ?X “ в мирах “ ?N “I “ ?M
t crlf
(modify ?W (task contra) (prior ?M))
)
;;----------------------------------------------------------------------
;; ЕСЛИ обнаружено противоречие между внедрённым «миром»
;; метавысказывания и ранее покинутым «миром»,
;; ТО удалить высказывание, связанное с внедрённым «миром».
(defrule upper-world
(declare (salience 80))
?W <- (world (tag ?N) (task check) (upper ?U&~0))
(claim (content ?F ?X) (reason ?N)
(claim
(content ?G&: (not (eq ?G ?F)) ?X)
(reason ?M&: (< ?M ?N)))
?S <- (statement (tag ?N) (reason ?U))
=>
(printout
t crlf
“TRANSWORLD CONTRADICTION: “ ?F ?X “versus “
?G ?X “ in worlds “ ?N “ I “ ?M
;; “МЕЖМИРОВОЕ ПРОТИВОРЕЧИЕ: “ ?F ?X “ проиворечит “
;; ?G ?X “ в мирах “ ?N “ I “ ?M
t crlf)
(retract ?S)
(modify ?W (task contra) (prior ?U))
)
;;----------------------------------------------------------------------
;; ОПЕРАЦИИ УДАЛЕНИЯ
;;----------------------------------------------------------------------
;; Удаление дизъюнкта.
(defrule clean-context
(declare (salience 50))
(world
(tag ?N)
(task ?T&: (or (eq ?T contra) ( eq ?T back))
(context ?S&~0))
?F <- (claim (reason ?N) (context ?S))
=>
(retract ?F)
)
;;----------------------------------------------------------------------
;; ЕСЛИ текущий мир проанализирован только
;; в предположении о правдивости,
;; ТО проанализировать его предполагая
;; лживость персонажа.
(defrule switch-scope
(declare (salience 40))
?W <- (world (tag ?N) (scope truth) (task contra)
(context ?C&~1)
=>
(modify ?W (scope falsity) (task check))
)
;;----------------------------------------------------------------------
;; Удалить все утверждения, сделанные в предположении
;; о правдивости, перед тем как анализировать
;; предположение о лживости.
(defrule sweep-claims
(declare (salience 100))
(world
(tag ?N) (scope truth) (context ?C&~1)
(task ?T&: (or (eq ?T contra) (eq ?T back))))
?F <- (claim (reason ?N) (scope truth (context ?D&~1))
=>
(retract ?F)
)
;;----------------------------------------------------------------------
;; Удалить все объекты statement, основанные на предположении
;; о правдивости, перед тем как анализировать
;; предположение о лживости.
(defrule sweep-statements
(declare (salience 100))
(world
(tag ?N) (task ?T&: (or (eq ?T contra) (eq ?T back)))
(scope truth) (context 0)
?F <- (statement (reason ?N) (scope truth))
=>
(retract ?F)
)
;;----------------------------------------------------------------------
;; Удалить утверждения, связанные с «миром»,
;; в котором обнаружены противоречия.
(defrule kill-claims
(declare (salience 100))
(world (tag ?N) (task clean))
?F <- (claim (reason ?N))
=>
(retract ?F)
)
;;----------------------------------------------------------------------
;; ЕСЛИ все ненужные объекты claim или statement удалены,
;; ТО удалить объект world, которому назначена задача clean.
(defrule stop-killing
(declare (salience 100))
?W <- )world (tag ?N) (task clean))
(not (claim (reason ?N)))
=>
(retract ?W)
)
;;----------------------------------------------------------------------
;; ОПЕРАЦИИ ОТКАТА
;;----------------------------------------------------------------------
;; Хронологический откат к тому «миру», который был
;; покинут без выполнения анализы о предположении
;; о лживости (поле scope содержит значение truth,
;; а поле task – значение check).
(defrule undirected-falsity
(declare (salience 20))
(world (tag ?N) (scope falsity) (task contra))
?W <- (world (tag ?M&: (< ?M ?N))
(scope truth) (task check))
=>
(modify ?W (task back))
)
;;----------------------------------------------------------------------
;; Хронологический откат к тому «миру», который был
;; покинут без завершения анализа дизъюнктов.
(defrule undirected-disjunct
(declare (salience 20))
(world (tag ?N) (scope falsity) (task contra))
?V <- (world (tag ?M&: (< ?M ?N)) (task check)
(context 1))
(claim (content OR ?P ?X ?Q ?Y) (reason ?M)
(scope ?S))
=>
;; Дизъюнкт в ране покинутом «мире», анализ которого
;; не был выполнен.
(assert (claim (content ?Q ?Y) (reason ?M) (scope ?S)
(context 2))
;; Зафиксировать необходимость отката в этот «мир».
(modify ?V (task back))
)
;;----------------------------------------------------------------------
;; Удаление объектов world.
;; ЕСЛИ выполняется откат к объекту М,
;; ТО удалить все объекты world,
;; имеющие идентификатор, больший М.
(defrule undo-world
(declare (salience 50))
(world (tag ?M) (task back))
?W ?N ?M)))
=>
(retract ?W)
)
;;----------------------------------------------------------------------
;; Откат к прежним высказываниям.
(defrule restate
(declare (salience 50))
(world (tag ?M) (task back))
?S ?N ?M))
(reason 0) (done ?X&~0)
=>
(modify ?S (done 0))
)
;;----------------------------------------------------------------------
;; Удаление объектов claim.
;; ЕСЛИ выполняется откат к объекту world M,
;; ТО удалить все объекты claim,
;; связанные с удалёнными объектами world.
(defrule unclaim
(declare (salience 30))
(world (tag ?M) (task back))
?F ?N ?M)))
=>
(retract ?F)
)
;;----------------------------------------------------------------------
;; Возобновление процесса вычислений,
;; начиная с точки возврата.
;; ЕСЛИ все объекты world, созданные
;; после объекта М, удалены,
;; ТО повторно сформировать объект М,
;; предположив лживость высказывания.
(defrule restart
(declare (salience 20))
?W <- (world (tag ?M) (scope truth)
(task back) (context ?C&~1))
=>
(modify ?W (scope falsity) (task check) (context 0))
)
;;----------------------------------------------------------------------
;; ПЕРЕХОД К АНАЛИЗУ СЛЕДУЮЩЕГО «МИРА» И
;; ВЫВОД ОТЧЕТА О РЕЗУЛЬТАТАХ
;;----------------------------------------------------------------------
;; Переход к анализу следующего «мира»,
;; ЕСЛИ никакие другие правила не ожидают активизации,
;; ТО анализ текущего «мира» завершён и
;; можно приступить к формированию нового «мира»,
;; если имеются необработанные высказывания.
;; ПРИМЕЧАНИЕ. Это правило имеет приоритет,
;; более низкий, чем все прочие правила,
;; исключая правило вывода результатов.
(defrule move
(declare (salience -50))
;; Существует «мир», сформированный на основе
;; исходного высказывания.
?W ?N 0)) (task check)
;; В базе фактов отсутствуют объекты world,
;; созданные позже текущего.
(not (world (tag ?T&: (> ?T ?N))))
;; В базе фактов имеется высказывание, подготовленное
;; к созданию нового объекта world.
(statement (reason 0) (done 0))
=>
;; Сформирован новый объект world на основе
;; этого объекта statement.
(assert (world (tag (+ ?N 1))))
)
;;----------------------------------------------------------------------
;; ЕСЛИ отсутствуют противоречия в объектах world,
;; ТО распечатать результаты.
;; ПРИМЕЧАНИЕ. Это правило будет активизироваться
;; повторно до тех пор, пока не будет выведена
;; непротиворечивая интерепритация.
(defrule report-result
(declare (salience -40))
(not (world (task contra)))
(not (statement (reason 0) (done 0)))
(statement (tag ?N) (done ?M&~0))
(claim (content ?P ?X) (reason ?N)
=>
(printout
t crlf
“RESULT: “ ?P ?X “ from statement “ ?N
;; “РЕЩУЛЬТАТ: “ ?P ?X “ из высказывания “ ?N
t crlf)
)
;;----------------------------------------------------------------------
;; ЕСЛИ противоречие остаётся и после анализа всех точек отката
;; и нет больше правил, которые можно было бы активизировать,
;; ТО прекратить процесс вычислений.
(defrule sanity-check
(declare (salience -100))
(world (tag ?N) (task ?T&: (or (eq ?T contra)
(eq ?T back))))
(not (world (tag ?M&: (< ?M ?N)) (scope truth)
(task check)))
=>
(printout
t crlf
“FAIL: Statements inconsistent, detected in world “ ?N
;; “РЕШЕНИЕ НЕ НАЙДЕНО: Высказывания противоречивы,
;; обнаружены в мире “ ?N
t crlf)
(halt)
)
Я не сомневаюсь в том, что эту программу можно совершенствовать и далее. Можно, например, попытаться использовать технологию отката, основанную на комбинировании направленных и хронологических методов пойска точки возврата. Но и в том виде, в каком она здесь представлена, программа справляется со всеми сформулированными в тексте приложения задачами. Анализируя текст программы, вы можете убедиться в том, что язык CLIPS позволяет реализовать многие из описанных в данной книге технологий, в частности:
-
методику прямого логического вывода, которая обеспечивает разрешение конфиликтов;
-
целенаправленный логический вывод с использованием лексем задач;
-
анализ множества контекстов при разных исходных предпроложениях.
На примере этой программы вы также могли убедиться в том, что несмотря на модульную структуру, расширение её функциональных возможностей сопряжено с определённой модификацией ранее разработанных модулей (правил), которые должны учитывать изменения, вносимые в структуру данных.
А.5. СТИЛЬ ПРОГРАММИРОВАНИЯ НА ЯЗЫКЕ CLIPS
В главе 17 был представлен обзор инструментальных средств конструирования экспертных систем и ряд рекомендаций, касающихся методики их проектирования. Многие из описанных в той главе средств имеют функциональные возможности, весьма близкие к тем которые вы можете найти в CLIPS. Большинство рекомендаций, относящихся к методике проектирования систем, основанных на правилах, сохраняют свою силу и при использовании в качестве основного инструмента проектирования языка CLIPS. В частности, работая с CLIPS, нужно стараться так организовать систему правил, чтобы каждое из них было как можно проще. Я бы рекомендовал вновь перечитать главу 17 после того, как вы внимательно проанализируете описанную в этом Приложении программу.
Эта программа является относительно простой и включает всего 35 правил, тогда как в практических экспертных системах их может быть значительно больше. Наприме, в прототипе системы R1/XCON, который был разработан в 1980 году, содержалось около 750 правил, причём по мере совершенствования системы их число росло и к 1984 году достигло 3300. В среднем каждое правило в R1 анализирует шесть условий и выполняет три действия.
Как и при программировании любфх других задач, ключевым условием разработки «хорошого» программного кода является правильный выбор набора абстрактных понятий, которыми должна манипулировать программа, и набора операций, которые она должна выполнять. Первое условие поможет рационально выбрать структуру объектов и форму представления условий в левой части правил, а второе – рационально организовать действия в правой части. Как было сказано в разделе А.3, использование объектов и обработчиков сообщений позволяет успешно решить задачу рациональной организации данных и процедур в программе.
67
![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
