Logika dla informatyków/Logika w informatyce: Różnice pomiędzy wersjami
Nie podano opisu zmian |
Nie podano opisu zmian |
||
Linia 1: | Linia 1: | ||
Wykład 13 (link z wykł. 3) | Wykład 13 (link z wykł. 3) | ||
==Logika w informatyce== | |||
W tym rozdziale naszkicujemy skrótowo kilka nie wspomnianych | |||
dotychczas zagadnień logiki, które wiążą ją z informatyką. Wybór jest | |||
dość arbitralny, a opisy niezbyt wyczerpujące. Stanowią one raczej | |||
zaproszenie do dalszych, własnych poszukiwań, niż zamknięty wykład | |||
prezentowanych zagadnień. | |||
===Zdaniowe logiki trójwartościowe=== | |||
Logika klasyczna, o której mowa w Wykładzie 1, jest \textit{logiką | |||
dwuwartościową}. | |||
Pierwsze \textit{logiki trójwartościowe} skonstruowali niezależnie od | |||
siebie polski logik Jan Łukasiewicz i amerykański \begin{eqnarray*}ale\boldsymbol{s}}\def\blank{\hbox{\sf Brodzony w | |||
Augustowie\end{eqnarray*} logik i matematyk Emil Post. Motywacje Posta były raczej | |||
kombinatoryczne, natomiast Łukasiewicz swoją konstrukcję poparł | |||
głębokim wywodem filozoficznym. Argumentował między innymi, że zdania | |||
o przyszłości, typu ,,jutro pójdę do kina'', nie są dzisiaj jeszcze | |||
ani prawdziwe, ani fałszywe, bo przypisanie im którejś z tych wartości | |||
zaprzeczałoby istnieniu wolnej woli. | |||
\iffalse Podobnie, przypisanie | |||
już dziś prawdy lub fałszu zdaniu ,,Obraz, który namaluję jutro będzie | |||
piękny'' przeczyłoby naszej zdolności do tworzenia, bo skoro już dziś | |||
można ocenić to, co stworzymy dopiero jutro, to znaczy że nie będziemy | |||
tworzyć, tylko odtwarzać coś już zdeterminowanego. | |||
Łukasiewicz wierzył głęboko w wolną wolę i twórczość, więc\boldsymbol{s}}\def\blank{\hbox{\sf Bważał, że | |||
\fi | |||
Aby logika mogła jakoś zdać sprawę ze statusu zdań o przyszłości, | |||
musi im przypisać inną, trzecią wartość logiczną. | |||
Trzeba tu zaznaczyć, że zupełnie inną propozycją rozwiązania tego | |||
samego problemu jest stworzona przez Brouwera logika | |||
intuicjonistyczna, którą poznaliśmy w Wykładzie [[#logint]]. | |||
Zanim przejdziemy do części trochę bardziej formalnej, rozważmy | |||
jeszcze dwa przykłady wzięte z żywej informatyki, gdzie także | |||
naturalnie pojawia się trzecia wartość logiczna. | |||
{{przyklad||paskal| | |||
Rozważmy dwie deklaracje funkcji w Pascalu: | |||
'''function''' f(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
'''function''' g(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
a następnie ich\boldsymbol{s}}\def\blank{\hbox{\sf Bżycie | |||
'''function''' f(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
'''function''' g(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
'''if''' f(x,y) '''and''' g(x,y) '''then''' ... '''else''' ...; | |||
Wydaje się na pierwszy rzut oka, że to sytuacja rodem z logiki | |||
klasycznej, ale nie: przecież i \verb+f+ i \verb+g+ mogą dać w wyniku | |||
obliczenia wartości \verb+true+, \verb+false+ lub się zapętlić, które | |||
to zdarzenie jest formą trzeciej wartości logicznej. Sposób, w jaki | |||
się z nią obejdzie funkcja \verb+and+ zależy od wyboru programisty: | |||
może on zastosować albo krótkie albo długie wyliczenie w swoim | |||
programie. | |||
}} | |||
{{przyklad||| | |||
Inna sytuacja to tabela stworzona za pomocą następującej instrukcji SQL | |||
w relacyjnej bazie danych: | |||
'''function''' f(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
'''function''' g(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
'''if''' f(x,y) '''and''' g(x,y) '''then''' ... '''else''' ...; | |||
CREATE TABLE A ( | |||
id INTEGER PRIMARY KEY auto_increment, | |||
... | |||
valid BOOLEAN, | |||
... | |||
); | |||
Przy takiej deklaracji, tabela \verb+A+ będzie mogła w kolumnie | |||
\verb+valid+ zawierać \textit{trzy} wartości logiczne: \verb+TRUE+, | |||
\verb+FALSE+ i \verb+NULL+, a logika trójwartościowa objawi swoje | |||
działanie przy wykonaniu np.\ zapytania | |||
'''function''' f(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
'''function''' g(x,y:boolean):boolean; | |||
'''begin''' | |||
... | |||
end; | |||
'''if''' f(x,y) '''and''' g(x,y) '''then''' ... '''else''' ...; | |||
CREATE TABLE A ( | |||
id INTEGER PRIMARY KEY auto_increment, | |||
... | |||
valid BOOLEAN, | |||
... | |||
); | |||
SELECT * | |||
FROM A AS A1, A AS A2 | |||
WHERE A1.valid '''and''' A2.valid | |||
}} | |||
{{definicja||zesiesmieliJ| | |||
\textit{Zbiór formuł zdaniowej logiki trójwartościowej} to zbiór tych | |||
formuł zdaniowej logiki klasycznej \begin{eqnarray*}patrz Definicja [[#radamalpa]], w | |||
których występują tylko spójniki <math>\lnot,\lor</math> i <math>\land.</math> | |||
Wywołane w ten sposób zawężenie składni zrekompensujemy niezwłocznie | |||
po stronie semantyki. | |||
Przez ''trójwartościowanie zdaniowe\/'' rozumiemy dowolną | |||
funkcję <math>\varrho:\\mbox{\small ZZ}\to\{0,\frac12,1\}</math>, | |||
która zmiennym zdaniowym przypisuje wartości logiczne 0, | |||
<math>\frac12</math> i 1. | |||
''Wartość formuły\/'' zdaniowej <math>\alpha</math> przy | |||
trójwartościowaniu <math>\varrho</math> oznaczamy przez <math>\wfz\alpha\varrho</math> i | |||
określamy przez indukcję: | |||
*<math>\wf\prooftree p \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=\varrho\begin{eqnarray*}p\end{eqnarray*}</math>, gdy <math>p</math> jest symbolem zdaniowym; | |||
*<math>\wfz{\neg\alpha}\varrho=F_\lnot\begin{eqnarray*}\wfz{\alpha}\varrho\end{eqnarray*}</math>; | |||
*</math>\wf\prooftree \alpha\lor\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=F_\land\begin{eqnarray*}\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree, | |||
\wf\prooftree \beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\end{eqnarray*}</math>; | |||
*</math>\wf\prooftree \alpha\land\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=F_\lor\begin{eqnarray*}\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree, | |||
\wf\prooftree \beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\end{eqnarray*}</math>; | |||
*<math>\wf\prooftree \lnot\alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=F_\lnot\begin{eqnarray*}\wfz\alpha\varrho\end{eqnarray*}.</math> | |||
}} | |||
Różne wybory funkcji | |||
<math>F_\lor,F_\land:\{0,{\frac12},1\}\times\{0,{\frac12},1\}\to\{0,{\frac12},1\}</math> | |||
i <math>F_\lnot:\{0,{\frac12},1\}\to\{0,{\frac12},1\}</math> prowadzą do różnych | |||
logik trójwartościowych. | |||
Zaczniemy od logiki najstarszej, zwanej dziś logiką | |||
Heytinga-Kleene-Łukasiewicza: | |||
<span id=""/> <math> \conn{F_\land}0000\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}\ \ | |||
\conn{F_\lor}0\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}11\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}1\ \ \ | |||
{\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline | |||
\multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline | |||
1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} | |||
</math> | |||
Jest to logika niewątpliwie nadająca się do rozwiązania zadania, które | |||
sobie Łukasiewicz postawił. Sposób traktowania wartości logicznej | |||
<math>{\frac12}</math> jest taki, że należy ją rozumieć jako ,,jeszcze nie | |||
wiadomo''. | |||
Warto zauważyć, że w przypadku tej logiki zachodzą równości | |||
*<math>\wfz{\neg\alpha}\varrho=1-\wfz{\alpha}\varrho</math>, | |||
*</math>\wf\prooftree \alpha\vee\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=\max\{\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree, | |||
\wf\prooftree \beta \justifies \varrho}\ \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree</math>, | |||
*</math>\wf\prooftree \alpha\wedge\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=\min\{\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree, | |||
\wf\prooftree \beta \justifies \varrho}\ \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree</math>, | |||
znane z Definicji [[#zesiesmieli]], tak więc mozna ją traktować jako | |||
literalne\boldsymbol{s}}\def\blank{\hbox{\sf Bogólnienie logiki klasycznej. | |||
Zachowanie stałych i operacji logicznych w języku SQL rządzi się | |||
właśnie prawami logiki Heytinga-Kleene-Łukasiewicza. | |||
Zupełnie inną logikę zaproponował Bochvar: | |||
<span id=""/> <math> \conn{F_\land}0\mbox{\rm\texttt<}\frac12}0\prooftree \frac12}{\frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}\mbox{\rm\texttt>}\endprooftree\ \ \ | |||
\conn{F_\lor}0\mbox{\rm\texttt<}\frac12}1\prooftree \frac12}{\frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}\mbox{\rm\texttt>}\endprooftree\ \ \ | |||
{\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline | |||
\multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline | |||
1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} | |||
</math> | |||
Czytelnik bez trudu rozpozna, że jest logika właściwa dla Przykładu | |||
[[#paskal]], gdy programista wybierze długie wyliczenie wyrażeń | |||
logicznych. W sensie tej logiki stała <math>{\frac12}</math> oznacza awarię lub | |||
błąd. | |||
Dalej mamy dość\Delta\vdashgzotycznie wyglądającą logikę Sobocińskiego: | |||
<span id=""/> <math> \conn{F_\land}00001101\ \ \ \ \conn{F_\lor}01011101\ \ \ \ | |||
{\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline | |||
\multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline | |||
1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} | |||
</math> | |||
Jednak i ona ma swój poważny sens. W niej stała logiczna <math>{\frac12}</math> | |||
oznacza ,,nie dotyczy'' lub ,,nieistotne''. Wszyscy odruchowo wręcz | |||
stosujemy tę logikę przy okazji wypełniania różnych formularzy i | |||
kwestionariuszy. Odpowiadając na różne pytania sformułowane ,,tak lub | |||
nie'' w niektórych polach na odpowiedzi\boldsymbol{s}}\def\blank{\hbox{\sf Bmieszczamy ,,nie dotyczy'' a | |||
potem podpisujemy się pod dokumentem mimo ostrzeżenia ,,Świadomy/ma | |||
odpowiedzialności karnej za składanie fałszywych zeznań \dots | |||
oświadczam że wszystkie odpowiedzi w tym formularzu są zgodne ze | |||
stanem faktycznym.'' Po prostu stosujemy tu logikę Sobocińskiego, w | |||
której koniunkcja kilku wyrazów o wartości 1 i kilku wyrazów o | |||
wartości <math>{\frac12}</math> daje wynik 1. Na szczęście, organy kontrolne | |||
chyba też znają ten rachunek zdań i stosują go do oceny naszych | |||
zeznań\dots | |||
Przechodząc do logik wyglądających na pierwszy rzut oka jeszcze | |||
niezwyklej, natrafiamy na logikę z nieprzemienną koniunkcją i | |||
alternatywą, która opisuje spójniki logiczne w Pascalu, wyliczane w | |||
sposób krótki: | |||
<span id=""/> <math> \conn{F_\land}0000\prooftree \frac12}{\frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\ \ \ | |||
\conn{F_\lor}0\mbox{\rm\texttt<}\frac12}11\prooftree \frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}\mbox{\rm\texttt>}\endprooftree\ \ \ | |||
{\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline | |||
\multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline | |||
1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} | |||
</math> | |||
Dla każdego z powyższych rachunków logicznych zasadne i interesujące | |||
są pytania o to czym jest tautologia, o aksjomatyzacje i systemy | |||
dowodzenia. Tak samo jest z innymi logikami wielowartościowymi, bo | |||
Czytelnik juz zapewne zauważył, że o ile jest jedna sensowna logika | |||
dwuwartościowa i kilka, wzajemnie konkurencyjnych sensownych logik | |||
trójwartościowych, to zapewne przy wzroście liczby wartości | |||
logicznych, liczba sensownych logik też rośnie. Tytułem przykładu: | |||
można sobie bez trudu wyobrazić logikę, w której chcielibyśmy mieć | |||
jednocześnie dwie różne stałe odpowiadające ,,nie wiadomo'' i ,,nie | |||
dotyczy''. Taka logika miałaby więc co najmniej cztery wartości | |||
logiczne. Jak łatwo się domyślić, ogromnym obszarem zastosowań logik | |||
wielowartościowych jest sztuczna inteligencja i reprezentacja wiedzy. | |||
Logika intucjonistyczna też może być w pewnych sytuacjach traktowana | |||
jako logika wielowartościowa. W tym przypadku potrzeba tych wartości | |||
nieskończenie wiele. Odpowiednio staranne spojrzenie na Definicję | |||
Twierdzenie [[#zwawo]] pozwala w nim dojrzeć właśnie opis zbioru | |||
tautologii zdaniowej logiki intucjonistycznej jako zbioru tautologii | |||
logiki nieskończeniewielo\-war\-toś\-ciowej, w której zbiór wartości | |||
logicznych to rodzina podzbiorów otwartych <math>\mathbb{R}</math>. Trzeba | |||
jednak zaznaczyć, że podejście to zatraca pewne istotne intuicje. | |||
===Tw. Codda=== | |||
Twierdzenie Codda łączy ze sobą świat logiki i świat relacyjnych baz | |||
danych. Zostanie ono sformułowane i dowiedzione w tym | |||
rozdziale. Orzeka ono, że logika pierwszego rzędu i algebra relacyjna, | |||
znana z wykładu baz danych, są wzajemnie na siebie przekładalne, przy | |||
założeniu dla logiki pierwszego rzędu tzw. semantyki dziedziny | |||
aktywnej. | |||
Na potrzeby niniejszego rozważania zakładamy i\boldsymbol{s}}\def\blank{\hbox{\sf Bstalamy skończoną | |||
sygnaturę <math>\Sigma,</math> złożoną wyłącznie z symboli relacji i stałych, jak | |||
to zwykle ma miejsce w bazach danych. | |||
{{definicja||| | |||
Tytułem przypomnienia \begin{eqnarray*}Czytelnik powinien znać algebrę relacyjną z | |||
wykładu baz danych\end{eqnarray*} i dla ustalenia notacji, definiujemy | |||
\textit{składnię algebry relacyjnej} AR nad <math>\Sigma</math>. | |||
*Każdy symbol relacji <math>n</math>-argumentowej z <math>\Sigma</math> z wyjątkiem | |||
równości jest <math>n</math>-argumentowym wyrażeniem AR. | |||
*Jeśli </math>E<math> i </math>F<math> są </math>n<math>-argumentowymi wyrażeniami AR, to </math>E\cup | |||
F, E-F</math> też są <math>n</math>-argumentowymi wyrażeniami AR. | |||
*Jeśli </math>E<math> i </math>F<math> są </math>n<math>-argumentowymi wyrażeniami AR, to </math>E\cup | |||
F, E-F</math> też są <math>n</math>-argumentowymi wyrażeniami AR. | |||
*Jeśli <math>E</math> jest <math>n</math>-argumentowym wyrażeniem AR oraz | |||
<math>i_1,\dots,i_k</math> jest ciągiem różnych ale niekoniecznie wszystkich | |||
\Delta\vdashlementów zbioru <math>\{1,\dots,n\}</math>, to <math>\pi_{i_1,\dots,i_k} E</math> jest | |||
<math>k</math>-argumentowym wyrażeniem AR. W szczególności ciąg ten może być | |||
pusty, zaś <math>\pi E</math> jest wyrażeniem \mbox{0-argumentowym}. | |||
*Jeśli <math>E</math> jest <math>n</math>-argumentowym, zaś <math>F</math> jest <math>m</math>-argumentowym | |||
wyrażeniem AR, to <math>E\times F</math> jest <math>n+m</math>-argumentowym wyrażeniem AR. | |||
*Jeśli <math>E</math> jest <math>n</math>-argumentowym wyrażeniem AR oraz <math>\theta</math> jest | |||
zbiorem równości postaci `<math>i=j</math>' lub `<math>i=c</math>', gdzie | |||
<math>i,j\in\{1,\dots,n\}</math> zaś <math>c</math> należy do zbioru symboli stałych | |||
z sygnatury <math>\Sigma,</math> to <math>\sigma_\theta E</math> jest <math>n</math>-argumentowym | |||
wyrażeniem AR. | |||
Semantyka algebry relacyjnej | |||
jest następująca: dla danej struktury | |||
<math>\strA</math> nad <math>\Sigma,</math> każdemu <math>n</math>-ar\-gu\-men\-to\-we\-mu wyrażeniu <math>E</math> algebry | |||
relacyjnej przypisujemy <math>n</math>-argumentową relację <math>\\\seml E \semr</math> w <math>A.</math> | |||
Definicja oczywiście przebiega indukcyjnie względem budowy <math>E.</math> | |||
*Jeśli <math>R</math> należy do <math>\Sigma,</math> to <math>\\\seml R \semr=R^\strA.</math> | |||
*<math>\\\seml E\cup F \semr=\\\seml E \semr\cup\\\seml F \semr</math> oraz <math>\\\seml E-F \semr=\\\seml E \semr-\\\seml F \semr</math>. | |||
*</math>\\\seml \pi_{i_1,\dots,i_k \semr | |||
E}=\{\<a_{i_1},\dots,a_{i_k}\> | \<a_1,\dots,a_k\>\in\\\seml E}\ \semr.</math> | |||
*</math>\\\seml E\times F \semr=\\\seml E \semr\times\\\seml F \semr= | |||
\{\<a_1,\dots,a_n,b_1\dots,b_m\> | \<a_1,\dots,a_n\>\in\\\seml E \semr\text{ i | |||
%%oraz | |||
}\<b_1\dots,b_m\>\in\\\seml F}\ \semr</math>. | |||
*</math>\\\seml \sigma_\theta E \semr=\{\<a_1,\dots,a_n\>\in\\\seml E \semr | | |||
a_i=a_j,\ \mbox{gdy}\ \begin{eqnarray*}i=j\end{eqnarray*}\in\theta\ \mbox{oraz}\ a_i=c^\strA | |||
,\ \mbox{gdy}\ \begin{eqnarray*}i=c\end{eqnarray*}\in\theta\}.</math> | |||
Warto zauważyć, że <math>\\\seml \pi E}=\{\<\>\ \semr,</math> czyli jet zbiorem złożonym z | |||
ciągu pustego, gdy <math>\wf E</math> jest niepusty, oraz jest pusty w przeciwnym | |||
wypadku. Z kolei <math>\\\seml \sigma_\emptyset E \semr=\\\seml E \semr.</math> | |||
}} | |||
Jak wiadomo, AR jest teoretycznym modelem języka zapytań do | |||
relacyjnych baz danych. Pokażemy teraz, że algebra relacyjna jest | |||
ściśle powiązana z logiką pierwszego rzędu, a we wszystkich sytuacjach | |||
naturalnych z punktu widzenia teorii baz danych, jest jej nawet | |||
równoważna. | |||
Dla danej formuły <math>\alpha</math> logiki pierwszego rzędu takiej, że | |||
<math>\fv{\alpha}=\{x_{i_1},\dots x_{i_n}\}</math>, oraz struktury | |||
<math>\strA=\<A,\dots\></math> określimy interpretację tej formuły w <math>\strA</math>, | |||
oznaczaną <math>\\\seml \alpha \semr</math>, jak następuje: | |||
<span id=""/> <math> \\\seml \alpha \semr=\{\<a_1,\dots,a_n\>\in | |||
</math> | |||
Intuicyjnie, <math>\wf\alpha</math> to relacja definiowana przez formułę <math>\alpha</math> | |||
w danej strukturze. | |||
{{definicja||| | |||
\textit{Aktywną dziedziną} struktury <math>\strA</math> nazwiemy podzbiór | |||
<math>ad\begin{eqnarray*}\strA\end{eqnarray*}\subseteq A</math> jej\boldsymbol{s}}\def\blank{\hbox{\sf Bniwersum, złożony z wszystkich\Delta\vdashlementów | |||
które są wartościami stałych z sygnatury bądź występują jako | |||
współrzędna w co najmniej jednej krotce należącej do interpretacji | |||
jakiegoś symbolu relacyjnego z sygnatury. | |||
}} | |||
Jak łatwo zauważyć, | |||
interpretacje wszystkich wyrażeń algebry relacyjnej obliczane w | |||
<math>\strA</math> są w istocie relacjami w dziedzinie aktywnej. | |||
Inaczej jest w logice pierwszego rzędu:\boldsymbol{s}}\def\blank{\hbox{\sf Bżycie negacji prowadzi | |||
natychmiast do formuł, których interpretacje zawierają\Delta\vdashlementy spoza | |||
aktywnej dziedziny. | |||
Zatem w pełnej ogólności są formuły logiki pierwszego rzędu, dla | |||
których nie istnieje wyrażenie algebry relacyjnej o tej samej | |||
interpretacji w każdej strukturze. | |||
Jednak gdy założymy, że <math>A=ad\begin{eqnarray*}\strA\end{eqnarray*},</math> to sytuacja sie | |||
zmienia. Wyrazem tego jest poniższe twierdzenie. | |||
{{twierdzenie|Codd|| | |||
# | |||
Dla każdego wyrażenia <math>E</math> algebry relacyjnej istnieje taka formuła | |||
<math>\alpha_E</math> logiki pierwszego rzędu, że dla każdej struktury <math>\strA</math> | |||
spełniającej <math>A=ad\begin{eqnarray*}\strA\end{eqnarray*},</math> zachodzi <math>\\\seml \alpha \semr=\\\seml E \semr.</math> | |||
# | |||
Dla każdej formuły <math>\alpha</math> logiki pierwszego rzędu istnieje wyrażenie | |||
<math>E_\alpha</math> algebry relacyjnej takie, że dla każdej struktury <math>\strA</math> | |||
spełniającej <math>A=ad\begin{eqnarray*}\strA\end{eqnarray*},</math> zachodzi <math>\\\seml E \semr=\\\seml \alpha \semr.</math> | |||
}} | |||
{{dowod|| | |||
Obu części twierdzenia będziemy dowodzić przez indukcję ze względu na | |||
budowę: w pierwszym punkcie wyrażenia <math>E</math>, a w drugim formuły | |||
<math>\alpha.</math> | |||
Przy konstrukcji <math>\alpha_E</math> będziemy dbać o to, żeby | |||
<math>\fv{\alpha_E}=\{x_1,\dots,x_n\},</math> gdzie <math>n</math> to liczba argumentów <math>E.</math> | |||
Gdy <math>E</math> jest <math>n</math>-argumentowym symbolem relacyjnym <math>R</math>, to <math>\alpha_E</math> | |||
ma postać <math>R\begin{eqnarray*}x_1,\dots,x_n\end{eqnarray*},</math> a prawdziwość tezy jest oczywista. | |||
<math>\alpha_{E\cup F}</math> definiujemy jako <math>\alpha_E\lor\alpha_F,</math> zaś | |||
<math>\alpha_{E-F}</math> jako <math>\alpha_E\land\lnot\alpha_F.</math> I w tym przypadku | |||
teza jest oczywista. | |||
Aby skonstruować <math>\alpha_{\pi_{i_1,\dots,i_k}E}</math> tworzymy formułę | |||
<math>\exists x_{j_1}\dots\exists x_{j_{n-k}}\alpha</math>, gdzie | |||
<math>j_1,\dots,j_{n-k}</math> to wypisane w obojętnej kolejności\Delta\vdashlementy zbioru | |||
<math>\{1,\dots,n \}-\{i_1,\dots,i_k\}.</math> Następnie dokonujemy w niej | |||
zamiany nazw zmiennych związanych tak, by ich numery były większe niż | |||
<math>n</math>, a zmienne wolne przemianowujemy z <math>x_{i_j}</math> na <math>y_{i_j}.</math> Niech | |||
<math>\beta</math> będzie otrzymaną w ten sposób formułą. Wówczas | |||
<math>\alpha_{\pi_{i_1,\dots,i_k}E}</math> definiujemy jako | |||
<math>\beta\begin{eqnarray*}x_1/y_{i_1},\dots,x_k/y_{i_k}\end{eqnarray*}</math>. Widać, że ta formuła spełnia | |||
tezę. | |||
Przy konstrukcji <math>\alpha_{E\times F}</math> postępujemy następująco: | |||
dokonujemy zamiany nazw zmiennych związanych w formule <math>\alpha_F</math> w | |||
ten sposób, by miały one numery większe niż <math>n+m,</math> zaś za zmienne | |||
wolne <math>x_1,\dots,x_m</math> podstawiamy kolejno <math>x_{n+1},\dots, x_{n+m}.</math> | |||
Niech powstała formuła nazywa się <math>\beta_F.</math> Wtedy definiujemy | |||
<math>\alpha_{E\times F}</math> jako <math>\alpha_E\land\beta_F</math>. Oczyiście ta | |||
formuła spełnia tezę. | |||
Na zakończenie tej cześci dowodu określamy formułę | |||
<math>\alpha_{\sigma_\theta E}</math> jako | |||
\[\alpha_E\land\\bigwedge_{\text{`<math>i=j</math>'}\in | |||
\theta}x_i=x_j\land\\bigwedge_{\text{`<math>i=c</math>'}\in \theta}x_i=c.\] | |||
I tym razem sprawdzenie, że ta formuła spełnia tezę indukcyjną jest | |||
natychmiastowe. | |||
Przystępujemy teraz do tłumaczenia formuł logiki pierwszego rzędu na | |||
algebrę relacyjną. W tym celu wygodnie jest założyć, że podstawowymi | |||
spójnikami logiki są <math>\lor,\lnot</math> i <math>\exists,</math> a pozostałe są | |||
zdefiniowane za ich pomocą i mają status skrótów notacyjnych. | |||
Zaczynamy od konstrukcji jednoargumentowego wyrażenia <math>AD</math> takiego, że | |||
dla każdej struktury <math>\strA,</math> mamy <math>\\\seml AD}=ad\begin{eqnarray*}\strA\end{eqnarray* \semr.</math> | |||
Jest ono <math>\cup</math>-sumą wyrażeń <math>\pi_i R</math> dla wszystkich symboli | |||
relacyjnych <math>R</math> w sygnaturze i wszystkich <math>i</math> takich, że <math>R</math> ma co | |||
najmniej <math>i</math> argumentów. | |||
Możemy teraz przystąpić do konstrukcji. Dla każdego zadanego <math>n</math> nie | |||
mniejszego niż wszystkie numery zmiennych wolnych w <math>\alpha</math> | |||
konstruujemy <math>n</math>-argumentowe wyrażenie <math>E_{\alpha;n}</math> takie, że | |||
\[\\\seml E_{\alpha;n} \semr=\{\<a_1,\dots,a_n\>\in | |||
A^n | \begin{eqnarray*}\strA,x_{1}:a_1,\dots,x_{n}:a_n\end{eqnarray*}\models\alpha\}.\] | |||
Oznacza to, że <math>E_{\alpha;n}</math> zawiera dodatkowe współrzędne, które | |||
pozwalają zarejestrować indeksy zmiennych wolnych występujących w | |||
<math>\alpha</math>. Aby otrzymać <math>E_\alpha</math> wystarczy wziąć rzut | |||
<math>\pi_{I}E_{\alpha;n},</math> gdzie <math>I</math> to posortowany rosnąco ciąg numerów | |||
zmiennych wolnych <math>\alpha,</math> co\Delta\vdashliminuje przy okazji zbędne współrzędne. | |||
</math>E_{x_i=x_j;n}<math> to </math>\sigma_{i=j}\begin{eqnarray*}\underbrace{AD\times\dots\times | |||
AD}_{n}\end{eqnarray*}.</math> | |||
<math>E_{R\begin{eqnarray*}x_{i_1},\dots,x_{i_k}\end{eqnarray*};n}</math> jest zdefiniowane jako | |||
<math>\pi_{I}\begin{eqnarray*}R\times\underbrace{AD\times\dots\times AD}_{n-k}\end{eqnarray*},</math> gdzie | |||
<math>I</math> jest taką permutacją <math>\{1,\dots,n\}</math>, która współrzędne <math>R</math> | |||
mieszcza na pozycjach o kolejnych numerach <math>i_1,\dots,i_k.</math> | |||
</math>E_{\alpha\lor\beta;n}<math> jest zdefiniowane jako </math>E_{\alpha;n}\cup | |||
E_{\beta;n},</math> natomiast <math>E_{\lnot\alpha;n}</math> to | |||
<math>\begin{eqnarray*}\underbrace{AD\times\dots\times AD}_{n}\end{eqnarray*}-E_{\alpha;n}.</math> | |||
Wreszcie w wypadku <math>E_{\exists x_i\alpha;n}</math> możemy bez\boldsymbol{s}}\def\blank{\hbox{\sf Btraty | |||
ogólności założyć, że </math>i=n+1<math>. Wtedy </math>E_{\exists | |||
x_i\alpha;n}</math> jest zdefiniowane jako | |||
<math>\pi_{1,\dots,n}E_{\alpha;n+1}.</math> | |||
We wszystkich przypadkach kroki dowodu indukcyjnego są oczywiste. | |||
}} | |||
Twierdzenie Codda jest już w pewnym stopniu częścią folkloru w teorii | |||
baz danych. Dziś wszyscy wiedzą, że algebra relacyjna to właściwie to | |||
samo, co logika pierwszego rzędu. W związku z tym, od wielu lat na | |||
konferencjach naukowych dotyczących teorii baz danych, systematycznie | |||
prezentowane są prace, których tematem jest logika pierwszego rzędu i | |||
nikt się już temu nie dziwi ani niczego nie musi\boldsymbol{s}}\def\blank{\hbox{\sf Bzasadniać. | |||
W szczególności badania dotyczące gier Ehrenfeuchta oraz | |||
charakteryzacji obliczeniowych logiki pierwszego rzędu \begin{eqnarray*}w duchu | |||
twierdzeń B\"uchi i Fagina\end{eqnarray*} są generalnie postrzegane jako wyniki | |||
należące do teorii baz danych. | |||
===Rozstrzygalność i nierozstrzygalność teorii=== | |||
W tym rozdziale przedyskutujemy zagadnienie rozstrzygalności teorii | |||
matematycznych \begin{eqnarray*}rozumianych jako zbiorów zdań\end{eqnarray*}. | |||
Przykładem teorii nierozstrzygalnej jest arytmetyka Peano | |||
\begin{eqnarray*}Twierdzenie [[#przescieradlo]]\end{eqnarray*}. Przykład teorii rozstrzygalnej | |||
prezentujemy poniżej. | |||
{{twierdzenie||| | |||
Teoria gęstych porządków liniowych które nie mają\Delta\vdashlementów | |||
maksymalnych ani minimalnych jest rozstrzygalna. | |||
}} | |||
{{dowod|| | |||
Niech <math>\mathcal{A}</math> będzie klasą wszystkich gęstych porządków | |||
liniowych które nie mają\Delta\vdashlementów maksymalnych ani minimalnych. | |||
Z Wniosku [[#zupa} wiemy, że <math>'''Th]]\begin{eqnarray*}\mathcal{A'''\end{eqnarray*}</math> jest zupełna. | |||
Ponadto zauważmy, że | |||
<math>'''Th}\begin{eqnarray*}\mathcal{A}\end{eqnarray*}=\{\alpha | \Delta\models\alpha\'''</math>, | |||
gdzie <math>\Delta</math> to następujący zbiór zdań: | |||
<!--% --> | |||
\begin{gather*} | |||
\forall x\forall y \ \begin{eqnarray*}x\leq y \land y\leq x\end{eqnarray*}\to x=y\\ | |||
\forall x\forall y \forall z\ \begin{eqnarray*}x\leq y \land y\leq z\end{eqnarray*}\to x\leq z\\ | |||
\forall x\forall y \ x\leq y \lor y\leq x\\ | |||
\forall x\exists y\ x< y\\ | |||
\forall x\exists y\ y< x\\ | |||
\forall x\forall y\ \begin{eqnarray*}x < y\end{eqnarray*}\to \begin{eqnarray*}\exists z\ x < z \land z<y\end{eqnarray*} | |||
\end{gather*} | |||
<!--% --> | |||
gdzie </math>x<y<math> jest oczywistym skrótem notacyjnym dla formuły </math>x\leq y | |||
\land x\neq y.</math> | |||
Na mocy twierdzenia o pełności | |||
<!--% --> | |||
\[\{\alpha | \Delta\models\alpha\}=\{\alpha | \Delta\vdash_H\alpha\}.\] | |||
<!--% --> | |||
Pozostaje więc wykazać rozstrzygalność | |||
<math>\{\alpha | \Delta\vdash_H\alpha\}.</math> | |||
Procedura rozstrzygająca jest następująca: | |||
Dla danej formuły <math>\alpha</math> systematycznie generujemy wszystkie | |||
dowody w systemie Hilberta, | |||
poszukując wśród nich albo dowodu <math>\Delta\vdash_H\alpha,</math> | |||
albo dowodu <math>\Delta\vdash_H\lnot\alpha.</math> Wobec zaobserwowanej | |||
przez nas zupełności, jeden z nich w końcu się znajdzie. Jeśli będzie | |||
to ten pierwszy, to procedura\boldsymbol{s}}\def\blank{\hbox{\sf Bdzieli wówczas odpowiedzi: ,,TAK'', | |||
a jeśli ten drugi, to ,,NIE''. | |||
}} | |||
Przeprowadzony przez nas dowód jest całkiem prosty, ale prowadzi do | |||
algorytmu rozstrzygającego, o którego złożoności nic rozsądnego | |||
powiedzieć nie\boldsymbol{s}}\def\blank{\hbox{\sf Bmiemy. | |||
Istnieją bardziej zaawansowane technicznie metody dowodzenia | |||
rozstrzygalności, które pozwalają oszacować złożoność tworzonych przez | |||
nie algorytmów. Jednak można\boldsymbol{s}}\def\blank{\hbox{\sf Bdowodnić, że żaden taki algorytm nie | |||
może mieć złożoności mniejszej niż {\sc Pspace}, o ile tylko działa | |||
poprawnie dla wszystkich formuł zawierających symbole równości. | |||
{{twierdzenie|Stockmeyer|| | |||
Następujący problem jest {\sc Pspace}-trudny: czy dane zdanie logiki | |||
pierwszego rzędu nad sygnaturą zawierającą wyłącznie symbol równości | |||
jest tautologią? | |||
}} | |||
Wobec naszej wiedzy o klasach złożoności, wątpliwe jest zatem | |||
istnienie algorytmów o wielomianowej złożoności czasowej nawet dla | |||
teorii jeszcze prostszych niż ta rozpatrywana w poprzednim twierdzeniu. | |||
{{dowod|| | |||
Przeprowadzamy redukcję w pamięci logarytmicznej z problemu QBF | |||
\begin{eqnarray*}kwantyfikowanych formuł Boolowskich\end{eqnarray*} do naszego problemu. | |||
Instancjami problemu QBF są zdania postaci | |||
<math>Q_1 p_1\dots Q_n p_n\alpha</math>, gdzie <math>Q_i\in\{\exists,\forall\}</math>, | |||
a <math>\alpha</math> jest formułą zdaniową. | |||
Pojęcie prawdziwości takiego zdania jest definiowane w naturalny sposób. | |||
Problem QBF jest znanym problemem {\sc Pspace}-zupełnym. | |||
Redukcja określona jest jak następuje: w zdaniu powyższym każde | |||
wystąpienie <math>p_i</math> zastępujemy przez <math>x_i=y_i</math>. Teraz po kolei | |||
zastępujemy kwantyfikatory: | |||
* | |||
Każdy kwantyfikator <math>\forall p_i</math> zamieniamy na <math>\forall x_i\forall y_i</math>. | |||
* | |||
Każdy kwantyfikator <math>\exists p_i</math> zamieniamy na <math>\exists x_i\exists y_i</math>. | |||
Niech formułą otrzymana po tych operacjach będzie <math>\alpha'.</math> | |||
Wtedy wynikiem naszej redukcji jest formuła <math>\alpha''</math> | |||
\[\forall x\forall y\begin{eqnarray*} x=y \lor \alpha'\end{eqnarray*}.\] | |||
Jest oczywiste, że <math>\alpha''</math> daje się obliczyć z <math>\alpha</math> w | |||
logarytmicznej pamięci. | |||
Widać, że formuły atomowe <math>x_i=y_i</math> pełnią rolę zmiennych | |||
zdaniowych <math>p_i</math>, przy czym w każdej strukturze o co najmniej dwóch | |||
elementach mogą przyjmować obie wartości logiczne. Kwantyfikatory | |||
<math>\forall x_i\forall y_i</math> i <math>\exists x_i\exists y_i</math> swoją funkcją wiernie | |||
odpowiadają kwantyfikatorom </math>\forall | |||
p_i</math> oraz <math>\exists p_i.</math> Z kolei klauzula <math>\forall x\forall y \begin{eqnarray*}x=y\end{eqnarray*}</math> | |||
czyni <math>\alpha''</math> prawdziwym w strukturach jednoelementowych, | |||
niezależnie od postaci <math>\alpha.</math> | |||
Z tego wynika, że <math>\alpha</math> jest prawdziwe wtedy i tylko wtedy, gdy | |||
<math>\alpha''</math> jest tautologią. | |||
}} | |||
Szczególnie interesujące jest następujące twierdzenie: | |||
{{twierdzenie|Tarski|| | |||
Teoria\boldsymbol{s}}\def\blank{\hbox{\sf Bporządkowanego ciała liczb rzeczywistych, tj. teoria struktury | |||
\mbox{<math>\<\RR,+,*,0,1,\leq\></math>} jest rozstrzygalna. | |||
}} | |||
Jej znaczenie dla informatyki zasadza się na fakcie, że ta teoria to w | |||
istocie znana wszystkim ze szkoły \textit{geometria | |||
analityczna}. Poważną część algorytmicznych badań w zakresie geometrii | |||
obliczeniowej można streścić jako\boldsymbol{s}}\def\blank{\hbox{\sf Blepszanie algorytmu | |||
rozstrzygającego teorię \mbox{<math>\<\RR,+,*,0,1,\leq\></math>} dla różnych | |||
szczególnych klas formuł, pojawiających się w praktyce. | |||
\subsection*{Ćwiczenia}\begin{small} | |||
# | |||
Udowodnić, że logiki trójwartościowe Heytinga-Kleene-Łukasiewicza, | |||
Bochvara i Sobocińskiego spełniają prawa de Morgana. | |||
# | |||
Podać przykład zdania logiki pierwszego rzędu, które nie jest tautologią, | |||
ale jest prawdziwe we | |||
wszystkich strukturach <math>\strA</math> takich, że <math>A=ad\begin{eqnarray*}\strA\end{eqnarray*}.</math> | |||
#<span id="rJ1" \> Udowodnić, że zbiór tautologii logiki pierwszego rzędu nad | |||
sygnaturą składającą się tylko z równości jest rozstrzygalny. | |||
{\em Wskazówka:\/} Niech <math>\alpha</math> będzie formułą o randze | |||
kwantyfikatorowej <math>q</math>. Udowodnić, że każde dwie struktury o mocy co | |||
najmniej <math>q</math> nad powyższą sygnaturą są <math>q</math>-elementarnie równoważne. | |||
Wywnioskować stąd, że aby sprawdzić, czy <math>\alpha</math> jest tautologią | |||
wystarczyć sprawdzić to w strukturach o mocy co najwyżej <math>q.</math> | |||
#Zbadać złożoność obliczeniową algorytmu zaproponowanego powyżej | |||
i\boldsymbol{s}}\def\blank{\hbox{\sf Bdowodnić, że zbiór tautologii logiki pierwszego rzędu nad | |||
sygnaturą składającą się tylko z równości jest {\sc Pspace}-zupełny. | |||
#<span id="rJ2" \> Udowodnić, że zbiór tautologii logiki pierwszego | |||
rzędu nad sygnaturą składającą się tylko z równości i skończenie | |||
wielu symboli stałych jest rozstrzygalny. | |||
{\em Wskazówka:\/} Rozwiązać najpierw zadanie [[#rJ1]], a stałe | |||
zasymulować jako relacje\boldsymbol{s}}\def\blank{\hbox{\sf Bnarne będące singletonami. | |||
\end{small} |
Wersja z 11:34, 22 wrz 2006
Wykład 13 (link z wykł. 3)
Logika w informatyce
W tym rozdziale naszkicujemy skrótowo kilka nie wspomnianych dotychczas zagadnień logiki, które wiążą ją z informatyką. Wybór jest dość arbitralny, a opisy niezbyt wyczerpujące. Stanowią one raczej zaproszenie do dalszych, własnych poszukiwań, niż zamknięty wykład prezentowanych zagadnień.
Zdaniowe logiki trójwartościowe
Logika klasyczna, o której mowa w Wykładzie 1, jest \textit{logiką dwuwartościową}.
Pierwsze \textit{logiki trójwartościowe} skonstruowali niezależnie od siebie polski logik Jan Łukasiewicz i amerykański \begin{eqnarray*}ale\boldsymbol{s}}\def\blank{\hbox{\sf Brodzony w Augustowie\end{eqnarray*} logik i matematyk Emil Post. Motywacje Posta były raczej kombinatoryczne, natomiast Łukasiewicz swoją konstrukcję poparł głębokim wywodem filozoficznym. Argumentował między innymi, że zdania o przyszłości, typu ,,jutro pójdę do kina, nie są dzisiaj jeszcze ani prawdziwe, ani fałszywe, bo przypisanie im którejś z tych wartości zaprzeczałoby istnieniu wolnej woli. \iffalse Podobnie, przypisanie już dziś prawdy lub fałszu zdaniu ,,Obraz, który namaluję jutro będzie piękny przeczyłoby naszej zdolności do tworzenia, bo skoro już dziś można ocenić to, co stworzymy dopiero jutro, to znaczy że nie będziemy tworzyć, tylko odtwarzać coś już zdeterminowanego.
Łukasiewicz wierzył głęboko w wolną wolę i twórczość, więc\boldsymbol{s}}\def\blank{\hbox{\sf Bważał, że \fi Aby logika mogła jakoś zdać sprawę ze statusu zdań o przyszłości, musi im przypisać inną, trzecią wartość logiczną.
Trzeba tu zaznaczyć, że zupełnie inną propozycją rozwiązania tego samego problemu jest stworzona przez Brouwera logika intuicjonistyczna, którą poznaliśmy w Wykładzie #logint.
Zanim przejdziemy do części trochę bardziej formalnej, rozważmy jeszcze dwa przykłady wzięte z żywej informatyki, gdzie także naturalnie pojawia się trzecia wartość logiczna.
Przykład
Rozważmy dwie deklaracje funkcji w Pascalu:
function f(x,y:boolean):boolean;
begin
...
end;
function g(x,y:boolean):boolean;
begin
...
end;
\def\blank{\hbox{\sf Bżycie
function f(x,y:boolean):boolean;
begin
...
end;
function g(x,y:boolean):boolean;
begin
...
end;
if f(x,y) and g(x,y) then ... else ...;
Wydaje się na pierwszy rzut oka, że to sytuacja rodem z logiki
klasycznej, ale nie: przecież i \verb+f+ i \verb+g+ mogą dać w wyniku
obliczenia wartości \verb+true+, \verb+false+ lub się zapętlić, które
to zdarzenie jest formą trzeciej wartości logicznej. Sposób, w jaki
się z nią obejdzie funkcja \verb+and+ zależy od wyboru programisty:
może on zastosować albo krótkie albo długie wyliczenie w swoim
programie.
}}
Przykład
Inna sytuacja to tabela stworzona za pomocą następującej instrukcji SQL w relacyjnej bazie danych:
function f(x,y:boolean):boolean;
begin
...
end;
function g(x,y:boolean):boolean;
begin
...
end;
if f(x,y) and g(x,y) then ... else ...;
CREATE TABLE A (
id INTEGER PRIMARY KEY auto_increment,
...
valid BOOLEAN,
...
);
Przy takiej deklaracji, tabela \verb+A+ będzie mogła w kolumnie
\verb+valid+ zawierać \textit{trzy} wartości logiczne: \verb+TRUE+,
\verb+FALSE+ i \verb+NULL+, a logika trójwartościowa objawi swoje
działanie przy wykonaniu np.\ zapytania
function f(x,y:boolean):boolean;
begin
...
end;
function g(x,y:boolean):boolean;
begin
...
end;
if f(x,y) and g(x,y) then ... else ...;
CREATE TABLE A (
id INTEGER PRIMARY KEY auto_increment,
...
valid BOOLEAN,
...
);
SELECT *
FROM A AS A1, A AS A2
WHERE A1.valid and A2.valid
Definicja
\textit{Zbiór formuł zdaniowej logiki trójwartościowej} to zbiór tych formuł zdaniowej logiki klasycznej \begin{eqnarray*}patrz Definicja #radamalpa, w których występują tylko spójniki i
Wywołane w ten sposób zawężenie składni zrekompensujemy niezwłocznie po stronie semantyki.
Przez trójwartościowanie zdaniowe\/ rozumiemy dowolną funkcję Parser nie mógł rozpoznać (błąd składni): {\displaystyle \varrho:\\mbox{\small ZZ}\to\{0,\frac12,1\}} , która zmiennym zdaniowym przypisuje wartości logiczne 0, i 1.
Wartość formuły\/ zdaniowej przy trójwartościowaniu oznaczamy przez Parser nie mógł rozpoznać (nieznana funkcja „\wfz”): {\displaystyle \wfz\alpha\varrho} i określamy przez indukcję:
- Parser nie mógł rozpoznać (nieznana funkcja „\wf”): {\displaystyle \wf\prooftree p \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=\varrho\begin{eqnarray*}p\end{eqnarray*}} , gdy jest symbolem zdaniowym;
- Parser nie mógł rozpoznać (nieznana funkcja „\wfz”): {\displaystyle \wfz{\neg\alpha}\varrho=F_\lnot\begin{eqnarray*}\wfz{\alpha}\varrho\end{eqnarray*}} ;
- </math>\wf\prooftree \alpha\lor\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*
\endprooftree=F_\land\begin{eqnarray*}\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree,
\wf\prooftree \beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\end{eqnarray*}</math>;
- </math>\wf\prooftree \alpha\land\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=F_\lor\begin{eqnarray*}\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree,
\wf\prooftree \beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\end{eqnarray*}</math>;
- Parser nie mógł rozpoznać (nieznana funkcja „\wf”): {\displaystyle \wf\prooftree \lnot\alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=F_\lnot\begin{eqnarray*}\wfz\alpha\varrho\end{eqnarray*}.}
}}
Różne wybory funkcji
i prowadzą do różnych
logik trójwartościowych.
Zaczniemy od logiki najstarszej, zwanej dziś logiką Heytinga-Kleene-Łukasiewicza:
Parser nie mógł rozpoznać (nieznana funkcja „\conn”): {\displaystyle \conn{F_\land}0000\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}\ \ \conn{F_\lor}0\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}11\mbox{\rm\texttt<}\frac12\mbox{\rm\texttt>}1\ \ \ {\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline \multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline 1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} }
Jest to logika niewątpliwie nadająca się do rozwiązania zadania, które
sobie Łukasiewicz postawił. Sposób traktowania wartości logicznej
jest taki, że należy ją rozumieć jako ,,jeszcze nie
wiadomo.
Warto zauważyć, że w przypadku tej logiki zachodzą równości
- Parser nie mógł rozpoznać (nieznana funkcja „\wfz”): {\displaystyle \wfz{\neg\alpha}\varrho=1-\wfz{\alpha}\varrho} ,
- </math>\wf\prooftree \alpha\vee\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=\max\{\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree,
\wf\prooftree \beta \justifies \varrho}\ \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree</math>,
- </math>\wf\prooftree \alpha\wedge\beta \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree=\min\{\wf\prooftree \alpha \justifies \varrho \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree,
\wf\prooftree \beta \justifies \varrho}\ \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree</math>,
znane z Definicji #zesiesmieli, tak więc mozna ją traktować jako literalne\boldsymbol{s}}\def\blank{\hbox{\sf Bogólnienie logiki klasycznej.
Zachowanie stałych i operacji logicznych w języku SQL rządzi się właśnie prawami logiki Heytinga-Kleene-Łukasiewicza.
Zupełnie inną logikę zaproponował Bochvar:
Parser nie mógł rozpoznać (nieznana funkcja „\conn”): {\displaystyle \conn{F_\land}0\mbox{\rm\texttt<}\frac12}0\prooftree \frac12}{\frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}\mbox{\rm\texttt>}\endprooftree\ \ \ \conn{F_\lor}0\mbox{\rm\texttt<}\frac12}1\prooftree \frac12}{\frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}\mbox{\rm\texttt>}\endprooftree\ \ \ {\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline \multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline 1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} }
Czytelnik bez trudu rozpozna, że jest logika właściwa dla Przykładu #paskal, gdy programista wybierze długie wyliczenie wyrażeń logicznych. W sensie tej logiki stała oznacza awarię lub błąd.
Dalej mamy dość\Delta\vdashgzotycznie wyglądającą logikę Sobocińskiego:
Parser nie mógł rozpoznać (nieznana funkcja „\conn”): {\displaystyle \conn{F_\land}00001101\ \ \ \ \conn{F_\lor}01011101\ \ \ \ {\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline \multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline 1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} }
Jednak i ona ma swój poważny sens. W niej stała logiczna oznacza ,,nie dotyczy lub ,,nieistotne. Wszyscy odruchowo wręcz stosujemy tę logikę przy okazji wypełniania różnych formularzy i kwestionariuszy. Odpowiadając na różne pytania sformułowane ,,tak lub nie w niektórych polach na odpowiedzi\boldsymbol{s}}\def\blank{\hbox{\sf Bmieszczamy ,,nie dotyczy a potem podpisujemy się pod dokumentem mimo ostrzeżenia ,,Świadomy/ma odpowiedzialności karnej za składanie fałszywych zeznań \dots oświadczam że wszystkie odpowiedzi w tym formularzu są zgodne ze stanem faktycznym. Po prostu stosujemy tu logikę Sobocińskiego, w której koniunkcja kilku wyrazów o wartości 1 i kilku wyrazów o wartości daje wynik 1. Na szczęście, organy kontrolne chyba też znają ten rachunek zdań i stosują go do oceny naszych zeznań\dots
Przechodząc do logik wyglądających na pierwszy rzut oka jeszcze niezwyklej, natrafiamy na logikę z nieprzemienną koniunkcją i alternatywą, która opisuje spójniki logiczne w Pascalu, wyliczane w sposób krótki:
Parser nie mógł rozpoznać (nieznana funkcja „\conn”): {\displaystyle \conn{F_\land}0000\prooftree \frac12}{\frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\ \ \ \conn{F_\lor}0\mbox{\rm\texttt<}\frac12}11\prooftree \frac12 \justifies \frac12 \using \textrm{\begin{eqnarray*}W\end{eqnarray*}\mbox{\rm\texttt>}\endprooftree\ \ \ {\begi\prooftree array \justifies |c|c| \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree\hline \multicolum\prooftree 2}{|c| \justifies F_\lnot \using \textrm{\begin{eqnarray*}W\end{eqnarray*}}\endprooftree \\\hline\hline x&\\\hline 0&1\\\hline 1&0\\\hline{\frac12}&{\frac12}\\\hline\end{array}} }
Dla każdego z powyższych rachunków logicznych zasadne i interesujące są pytania o to czym jest tautologia, o aksjomatyzacje i systemy dowodzenia. Tak samo jest z innymi logikami wielowartościowymi, bo Czytelnik juz zapewne zauważył, że o ile jest jedna sensowna logika dwuwartościowa i kilka, wzajemnie konkurencyjnych sensownych logik trójwartościowych, to zapewne przy wzroście liczby wartości logicznych, liczba sensownych logik też rośnie. Tytułem przykładu: można sobie bez trudu wyobrazić logikę, w której chcielibyśmy mieć jednocześnie dwie różne stałe odpowiadające ,,nie wiadomo i ,,nie dotyczy. Taka logika miałaby więc co najmniej cztery wartości logiczne. Jak łatwo się domyślić, ogromnym obszarem zastosowań logik wielowartościowych jest sztuczna inteligencja i reprezentacja wiedzy.
Logika intucjonistyczna też może być w pewnych sytuacjach traktowana jako logika wielowartościowa. W tym przypadku potrzeba tych wartości nieskończenie wiele. Odpowiednio staranne spojrzenie na Definicję Twierdzenie #zwawo pozwala w nim dojrzeć właśnie opis zbioru tautologii zdaniowej logiki intucjonistycznej jako zbioru tautologii logiki nieskończeniewielo\-war\-toś\-ciowej, w której zbiór wartości logicznych to rodzina podzbiorów otwartych . Trzeba jednak zaznaczyć, że podejście to zatraca pewne istotne intuicje.
Tw. Codda
Twierdzenie Codda łączy ze sobą świat logiki i świat relacyjnych baz danych. Zostanie ono sformułowane i dowiedzione w tym rozdziale. Orzeka ono, że logika pierwszego rzędu i algebra relacyjna, znana z wykładu baz danych, są wzajemnie na siebie przekładalne, przy założeniu dla logiki pierwszego rzędu tzw. semantyki dziedziny aktywnej.
Na potrzeby niniejszego rozważania zakładamy i\boldsymbol{s}}\def\blank{\hbox{\sf Bstalamy skończoną sygnaturę złożoną wyłącznie z symboli relacji i stałych, jak to zwykle ma miejsce w bazach danych.
Definicja
Jak wiadomo, AR jest teoretycznym modelem języka zapytań do relacyjnych baz danych. Pokażemy teraz, że algebra relacyjna jest ściśle powiązana z logiką pierwszego rzędu, a we wszystkich sytuacjach naturalnych z punktu widzenia teorii baz danych, jest jej nawet równoważna.
Dla danej formuły logiki pierwszego rzędu takiej, że
Parser nie mógł rozpoznać (nieznana funkcja „\fv”): {\displaystyle \fv{\alpha}=\{x_{i_1},\dots x_{i_n}\}}
, oraz struktury
Parser nie mógł rozpoznać (nieznana funkcja „\strA”): {\displaystyle \strA=\<A,\dots\>}
określimy interpretację tej formuły w Parser nie mógł rozpoznać (nieznana funkcja „\strA”): {\displaystyle \strA}
,
oznaczaną Parser nie mógł rozpoznać (błąd składni): {\displaystyle \\\seml \alpha \semr}
, jak następuje:
Parser nie mógł rozpoznać (błąd składni): {\displaystyle \\\seml \alpha \semr=\{\<a_1,\dots,a_n\>\in }
Intuicyjnie, Parser nie mógł rozpoznać (nieznana funkcja „\wf”): {\displaystyle \wf\alpha} to relacja definiowana przez formułę w danej strukturze.
Definicja
\textit{Aktywną dziedziną} struktury Parser nie mógł rozpoznać (nieznana funkcja „\strA”): {\displaystyle \strA} nazwiemy podzbiór
Parser nie mógł rozpoznać (błąd składni): {\displaystyle ad\begin{eqnarray*}\strA\end{eqnarray*}\subseteq A} jej\boldsymbol{s\def\blank{\hbox{\sf Bniwersum, złożony z wszystkich\Delta\vdashlementów
które są wartościami stałych z sygnatury bądź występują jako współrzędna w co najmniej jednej krotce należącej do interpretacji jakiegoś symbolu relacyjnego z sygnatury. }}
Jak łatwo zauważyć, interpretacje wszystkich wyrażeń algebry relacyjnej obliczane w Parser nie mógł rozpoznać (nieznana funkcja „\strA”): {\displaystyle \strA} są w istocie relacjami w dziedzinie aktywnej.
Inaczej jest w logice pierwszego rzędu:\boldsymbol{s}}\def\blank{\hbox{\sf Bżycie negacji prowadzi natychmiast do formuł, których interpretacje zawierają\Delta\vdashlementy spoza aktywnej dziedziny.
Zatem w pełnej ogólności są formuły logiki pierwszego rzędu, dla
których nie istnieje wyrażenie algebry relacyjnej o tej samej
interpretacji w każdej strukturze.
Jednak gdy założymy, że Parser nie mógł rozpoznać (błąd składni): {\displaystyle A=ad\begin{eqnarray*}\strA\end{eqnarray*},} to sytuacja sie zmienia. Wyrazem tego jest poniższe twierdzenie.
Twierdzenie Codd
Dla każdego wyrażenia algebry relacyjnej istnieje taka formuła logiki pierwszego rzędu, że dla każdej struktury Parser nie mógł rozpoznać (nieznana funkcja „\strA”): {\displaystyle \strA} spełniającej Parser nie mógł rozpoznać (błąd składni): {\displaystyle A=ad\begin{eqnarray*}\strA\end{eqnarray*},} zachodzi Parser nie mógł rozpoznać (błąd składni): {\displaystyle \\\seml \alpha \semr=\\\seml E \semr.}
Dla każdej formuły logiki pierwszego rzędu istnieje wyrażenie algebry relacyjnej takie, że dla każdej struktury Parser nie mógł rozpoznać (nieznana funkcja „\strA”): {\displaystyle \strA} spełniającej Parser nie mógł rozpoznać (błąd składni): {\displaystyle A=ad\begin{eqnarray*}\strA\end{eqnarray*},} zachodzi Parser nie mógł rozpoznać (błąd składni): {\displaystyle \\\seml E \semr=\\\seml \alpha \semr.}
Dowód
\def\blank{\hbox{\sf Btraty
ogólności założyć, że </math>i=n+1E_{\exists x_i\alpha;n}</math> jest zdefiniowane jako
We wszystkich przypadkach kroki dowodu indukcyjnego są oczywiste. }}
Twierdzenie Codda jest już w pewnym stopniu częścią folkloru w teorii baz danych. Dziś wszyscy wiedzą, że algebra relacyjna to właściwie to samo, co logika pierwszego rzędu. W związku z tym, od wielu lat na konferencjach naukowych dotyczących teorii baz danych, systematycznie prezentowane są prace, których tematem jest logika pierwszego rzędu i nikt się już temu nie dziwi ani niczego nie musi\boldsymbol{s}}\def\blank{\hbox{\sf Bzasadniać.
W szczególności badania dotyczące gier Ehrenfeuchta oraz charakteryzacji obliczeniowych logiki pierwszego rzędu \begin{eqnarray*}w duchu twierdzeń B\"uchi i Fagina\end{eqnarray*} są generalnie postrzegane jako wyniki należące do teorii baz danych.
Rozstrzygalność i nierozstrzygalność teorii
W tym rozdziale przedyskutujemy zagadnienie rozstrzygalności teorii matematycznych \begin{eqnarray*}rozumianych jako zbiorów zdań\end{eqnarray*}. Przykładem teorii nierozstrzygalnej jest arytmetyka Peano \begin{eqnarray*}Twierdzenie #przescieradlo\end{eqnarray*}. Przykład teorii rozstrzygalnej prezentujemy poniżej.
Twierdzenie
Teoria gęstych porządków liniowych które nie mają\Delta\vdashlementów maksymalnych ani minimalnych jest rozstrzygalna.
{{dowod||
Niech będzie klasą wszystkich gęstych porządków liniowych które nie mają\Delta\vdashlementów maksymalnych ani minimalnych. Z Wniosku [[#zupa} wiemy, że Parser nie mógł rozpoznać (błąd składni): {\displaystyle '''Th]]\begin{eqnarray*}\mathcal{A'''\end{eqnarray*}} jest zupełna. Ponadto zauważmy, że Parser nie mógł rozpoznać (błąd składni): {\displaystyle '''Th}\begin{eqnarray*}\mathcal{A}\end{eqnarray*}=\{\alpha | \Delta\models\alpha\'''} , gdzie to następujący zbiór zdań: \begin{gather*} \forall x\forall y \ \begin{eqnarray*}x\leq y \land y\leq x\end{eqnarray*}\to x=y\\ \forall x\forall y \forall z\ \begin{eqnarray*}x\leq y \land y\leq z\end{eqnarray*}\to x\leq z\\ \forall x\forall y \ x\leq y \lor y\leq x\\ \forall x\exists y\ x< y\\ \forall x\exists y\ y< x\\ \forall x\forall y\ \begin{eqnarray*}x < y\end{eqnarray*}\to \begin{eqnarray*}\exists z\ x < z \land z<y\end{eqnarray*} \end{gather*} gdzie </math>x<yParser nie mógł rozpoznać (błąd składni): {\displaystyle jest oczywistym skrótem notacyjnym dla formuły } x\leq y \land x\neq y.</math>
Na mocy twierdzenia o pełności \[\{\alpha | \Delta\models\alpha\}=\{\alpha | \Delta\vdash_H\alpha\}.\] Pozostaje więc wykazać rozstrzygalność Parser nie mógł rozpoznać (błąd składni): {\displaystyle \{\alpha | \Delta\vdash_H\alpha\}.}
Procedura rozstrzygająca jest następująca:
Dla danej formuły systematycznie generujemy wszystkie
dowody w systemie Hilberta,
poszukując wśród nich albo dowodu
albo dowodu Wobec zaobserwowanej
przez nas zupełności, jeden z nich w końcu się znajdzie. Jeśli będzie
to ten pierwszy, to procedura\boldsymbol{s}}\def\blank{\hbox{\sf Bdzieli wówczas odpowiedzi: ,,TAK,
a jeśli ten drugi, to ,,NIE.
}}
Przeprowadzony przez nas dowód jest całkiem prosty, ale prowadzi do
algorytmu rozstrzygającego, o którego złożoności nic rozsądnego
powiedzieć nie\boldsymbol{s}}\def\blank{\hbox{\sf Bmiemy.
Istnieją bardziej zaawansowane technicznie metody dowodzenia rozstrzygalności, które pozwalają oszacować złożoność tworzonych przez nie algorytmów. Jednak można\boldsymbol{s}}\def\blank{\hbox{\sf Bdowodnić, że żaden taki algorytm nie może mieć złożoności mniejszej niż {\sc Pspace}, o ile tylko działa poprawnie dla wszystkich formuł zawierających symbole równości.
Twierdzenie Stockmeyer
Następujący problem jest {\sc Pspace}-trudny: czy dane zdanie logiki pierwszego rzędu nad sygnaturą zawierającą wyłącznie symbol równości jest tautologią?
Wobec naszej wiedzy o klasach złożoności, wątpliwe jest zatem istnienie algorytmów o wielomianowej złożoności czasowej nawet dla teorii jeszcze prostszych niż ta rozpatrywana w poprzednim twierdzeniu.
Dowód
Szczególnie interesujące jest następujące twierdzenie:
Twierdzenie Tarski
\def\blank{\hbox{\sf Bporządkowanego ciała liczb rzeczywistych, tj. teoria struktury
\mbox{Parser nie mógł rozpoznać (błąd składni): {\displaystyle \<\RR,+,*,0,1,\leq\>} } jest rozstrzygalna. }}
Jej znaczenie dla informatyki zasadza się na fakcie, że ta teoria to w istocie znana wszystkim ze szkoły \textit{geometria analityczna}. Poważną część algorytmicznych badań w zakresie geometrii obliczeniowej można streścić jako\boldsymbol{s}}\def\blank{\hbox{\sf Blepszanie algorytmu rozstrzygającego teorię \mbox{Parser nie mógł rozpoznać (błąd składni): {\displaystyle \<\RR,+,*,0,1,\leq\>} } dla różnych szczególnych klas formuł, pojawiających się w praktyce.
\subsection*{Ćwiczenia}\begin{small}
Udowodnić, że logiki trójwartościowe Heytinga-Kleene-Łukasiewicza, Bochvara i Sobocińskiego spełniają prawa de Morgana.
Podać przykład zdania logiki pierwszego rzędu, które nie jest tautologią, ale jest prawdziwe we wszystkich strukturach Parser nie mógł rozpoznać (nieznana funkcja „\strA”): {\displaystyle \strA} takich, że Parser nie mógł rozpoznać (błąd składni): {\displaystyle A=ad\begin{eqnarray*}\strA\end{eqnarray*}.}
- Udowodnić, że zbiór tautologii logiki pierwszego rzędu nad
sygnaturą składającą się tylko z równości jest rozstrzygalny.
{\em Wskazówka:\/} Niech będzie formułą o randze kwantyfikatorowej . Udowodnić, że każde dwie struktury o mocy co najmniej nad powyższą sygnaturą są -elementarnie równoważne. Wywnioskować stąd, że aby sprawdzić, czy jest tautologią wystarczyć sprawdzić to w strukturach o mocy co najwyżej
- Zbadać złożoność obliczeniową algorytmu zaproponowanego powyżej
i\boldsymbol{s}}\def\blank{\hbox{\sf Bdowodnić, że zbiór tautologii logiki pierwszego rzędu nad sygnaturą składającą się tylko z równości jest {\sc Pspace}-zupełny.
- Udowodnić, że zbiór tautologii logiki pierwszego
rzędu nad sygnaturą składającą się tylko z równości i skończenie wielu symboli stałych jest rozstrzygalny.
{\em Wskazówka:\/} Rozwiązać najpierw zadanie #rJ1, a stałe zasymulować jako relacje\boldsymbol{s}}\def\blank{\hbox{\sf Bnarne będące singletonami.
\end{small}