02 10 13 Лекция 3 Предикатное программирование

02. 10. 13 Лекция 3 Предикатное программирование Математические основы Отношения порядка Наименьшая неподвижная точка Язык исчисления вычислимых предикатов (прод. ) Типы. Рекурсивные определения типов Логическая и операционная семантика Вызов предиката Оператор суперпозиции Параллельный оператор Условный оператор Конструктор предиката Конструктор массива Программа на языке CCP

4. Математические основы 4. 1. Отношения порядка 4. 2. Наименьшая неподвижная точка

Отношения порядка (D, R) ― отношение порядка R D D; a R b (a, b) R a D. a R a ― рефлексивность a D. a R a ― иррефлексивность a, b D. a R b b R a ― симметричность a, b D. a R b & b R a a = b ― антисимметричность a, b, c D. a R b & b R c a R c ― транзитивность (D, ⊑) ― частично упорядоченное множество (чум) ⊑ - рефлексивно, антисимметрично, транзитивно; ⊑ - частичный порядок Частичный порядок ⊑ линейный (или тотальный) a, b D. (a ⊑ b b ⊑ a). ⊏ - строгий частичный порядок ⊏ - иррефлексивно, антисимметрично, транзитивно. (D, ⊑) ― предпорядок ⊑ - рефлексивно и транзитивно (D, R) ― отношение эквивалентности R рефлексивно, симметрично и транзитивно

a S ― наименьший (наибольший) элемент S D s S. a⊑s ( s S. s⊑a ) ⊥ (bottom) и ⊤ (top) a D ― верхняя грань S D s S. s⊑a a D ― наименьшая верхняя грань S D b D. (b ― верхняя грань a⊑b) a = lub(S) least upper bound a S ― минимальный элемент S D b S. (b⊑a b=a) нижняя грань, наибольшая нижняя грань, максимальный элемент нижняя полурешетка ч у м с нижней гранью полная решетка ч у м с нижней и верхней гранью Лемма 4. 1. Нижняя (верхняя) полурешетка является полной решеткой. вполне упорядоченное множество ― всякое подмножество имеет нижнюю грань ч у м со свойством обрыва бесконечно убывающих цепей (well-founded partial order) ― всякое подмножество имеет минимальный элемент

Наименьшая неподвижная точка (D, ⊑, ⊥) ― частично упорядоченное множество с нижней гранью: a D. ⊥⊑a - нижняя полурешетка Последовательность {am}m 0 является возрастающей цепью, если a 0 ⊑ a 1 ⊑ … ⊑ am ⊑ …. F: D→D ― монотонная функция a, b D. a⊑b F(a)⊑F(b) Лемма 4. 2. {Fn(⊥)}n≥ 0 ― для монотонной функции F определяют возрастающую цепь: ⊥⊑F(⊥)⊑F 2(⊥)⊑…⊑Fn(⊥)⊑… Лемма 4. 3. Если F ― монотонна и a 0⊑a 1⊑a 2⊑… ― возрастающая цепь, то F(a 0)⊑F(a 1)⊑F(a 2)⊑… ― также возрастающая цепь

m 0 am lub {am}m 0 ― наименьшая верхняя грань цепи F: D→D ― непрерывная функция возрастающей цепи {am}m 0. F( m 0 am) = m 0 F( am) Лемма 4. 4. Непрерывная функция является монотонной. x = F(x) ― решением этого уравнения является неподвижная точка функции F Теорема 4. 1 Клини. F ― непрерывна. Тогда n 0{Fn(⊥)} ― наименьшая неподвижная точка F

3. Теория программ-функций. Язык исчисления вычислимых предикатов (прод 1)

Рекурсивные типы данных Z = Subset(T, x, P, d) (1) Z = X Y (2) Z = X + Y (3) Z = Set(X) (4) Z = Pred(D: E) (5) типовый терм φ(X, Y) Xk = φk(X 1, X 2, …, Xn, T 1, T 2, …, Ts ); k = 1, …, n; n > 0, s≥ 0 (3. 8) ― система типовых уравнений X = (X 1, X 2, …, Xn), φ = (φ1, φ2, …, φn) X = φ(X) ― векторная форма (3. 9) (Γ, , ) ― множество типов; Z Γ. Z ― нижняя грань Вектора типов X ⊑ Y k=1. . n (Xk Yk) = ( , , …, ) ― нижняя грань (Φ, ⊑, ) ― множество векторов типов Лемма. (Φ, ⊑, ) является нижней полурешеткой

X 0 = , Xm+1 = φ(Xm), m 0. (3. 10) Лемма. {Ym}m 0 возрастающая цепь типов. a m 0 Ym ( k. n>k. a Yn) Лемма. Произведение Y Z и объединение Y + Z непрерывны относительно вхождений компонентных типов Y и Z. {Ym}m 0 и {Zm}m 0 возрастающие цепи типов. m 0(Ym Zm) = ( m 0 Ym) ( m 0 Zm). Лемма 3. 1. Функция φ системы (3. 9) определений рекурсивных типов X = φ(X) является непрерывной относительно произведения и объединения. По теореме Клини решением системы X = φ(X) является наименьшая неподвижная точка, определяемая как m 0 Xm, при условии, что рекурсия реализуется через произведение и объединение

Запрещается рекурсия Y = Q(Subset(H(Y))) Z = Q(Set(H(Z))) A = Q(PRED(H(A), …: …) B = Q(PRED(…: H(B), …), где Q и H ― некоторые функционалы, представленные типовыми термами

Логическая и операционная семантика Программа ― оператор S(x: y) на языке CCP x и y наборы переменных, аргументы и результаты. Логика программы ― предикат L(S(x: y)) Корректность логики программы (согласованность логической и операционной семантики): x, y. L(S(x: y)) исполнение оператора S. исполнение завершается & значения при завершении есть x и y RUN(S(x: y)) Необходимо построить формальную операционную и логическую семантику языка CCP и определить условия однозначности программ.

Структура программы на языке CCP Программа ─ набор определений предикатов Определение A K предикат A , оператор K параллельный оператор, оператор суперпозиции, условный оператор Вызов предиката (d 1, d 2, …, dn : e 1, e 2, …, em) (3. 1) φ ─ имя предиката или переменной предикатного типа, n 0, m > 0, d 1, d 2, …, dn ─ имена переменных ─ аргументы вызова, e 1, e 2, …, em ─ результаты вызова Вычисление предиката Вызов φ(d: e), где d = d 1, d 2, …, dn, e = e 1, e 2, …, em – наборы переменных n = 0 – вызов предикта соответствует константе Значение φ(d) φ(d: b) , где b ─ переменная логического типа Определение предиката A(x: y) K(x: y) (3. 2) A имя предиката; набор x аргументы предиката, набор y результаты предиката, K(x: y) – оператор. Предикат – определяемый, базисный, значение переменной. Тип данных определяет набор базисных предикатов со значениями типа Система типов определяет совокупность всех базисных предикатов

Логическая семантика вызова и определения предиката : L(φ(d: e)) φ(d, e) , где φ ─ имя предиката L( A(x: y) K(x: y) ) A(x, y) L(K(x: y)) Операционная семантика: метапрограмма Метаязык. Память – набор секций. Секция памяти – набор переменных и их значений: аргументы, результаты, локалы. s[a] – значение переменной с именем a в секции s s[x] – набор значений для набора имен x в секции s s[a] : = v – оператор присваивания значения v переменной a в секции s s[x] : = w – групповое присваивание набора значений w набору переменных x в секции s s = new. Sect(A) – создание в памяти новой секции s для определения предиката с именем A run. Call(s, φ(d: e)) – исполнение вызова φ(d: e) run. Stat(s, K(x: y)) – исполнение оператора K(x: y) правой части Значение переменной предикатного типа – (имя предиката, набор значений части аргументов) Например, (A, z~), для A(z, t: y) K(z, t: y), где t не пусто.

s[C] = (A, z~) предикат A является заместителем переменной C предикатного типа. subs(C) множество заместителей переменной C. A subs(C) H(x: y) есть вызов предиката или оператор. RUN(H, x, y) любое исполнение H(x: y) для значений набора x завершается со значениями набора y. Свойство согласованности Cons(H) x y L(H(x: y)) RUN(H, x, y) (4. 11) Предикат A обладает свойством согласованности Cons(A) если любой его вызов обладает свойством согласованности

Вызов предиката Вызов A(z: u) A(x: y) K(x: y) (3. 12) (3. 13) q текущая секция Процедура run. Call(q, A(z: u)) абстрактного процессора: s = new. Sect(A); (3. 14) s[x] : = q[z]; run. Stat(s, K(x: y)); q[u] : = s[y]; Свойства: x = z & u = y (3. 15) Лемма 3. 2. Пусть имеется определение (3. 13) для предиката A. Тогда Cons(K) Cons(A). Доказательство проводится для вызова A(z: u). Пусть истинно Cons(K). Докажем истинность Cons(A). Зафиксируем значения наборов z и u. Пусть истинно A(z: u).

Пусть истинно A(z: u). Тогда в соответствии с определением A(x: y) K(x: y) истинна формула K(z: u). Из этого следует, что все исполнения K(z: u) для набора z завершаются получением набора u. Рассмотрим исполнение A(z: u) по программе (3. 14). В соответствии с (3. 15) справедливы равенства x = z и u = y. Поэтому все исполнения K(x: y) завершаются получением y. Тогда исполнение последовательности (3. 14), а значит и исполнение A(z: u), завершается получением значений набора u, что доказывает первую часть свойства Cons(A). Пусть исполнение A(z: u) для набора z завершается получением набора u. Тогда завершается исполнение тела (3. 14), в частности, исполнение K(x: y) завершается получением y. Поскольку в соответствии с (3. 15) реализуется x = z и u = y, то исполнение K(z: u) завешается вычислением набора u. Из Cons(K) следует, что K(z: u) истинно. Тогда из определения A(x: y) K(x: y) следует истинность A(z: u), что доказывает вторую часть свойства Cons(A). □

Оператор суперпозиции A(x: y) B(x: z); C(z: y) (3. 16) L(B(x: z); C(z: y)) z. (B(x, z) & C(z, y)) (3. 17) Процедура run. Stat(s, K(x: y)) абстрактного процессора: run. Call(s, B(x: z)); (3. 18) run. Call(s, C(z: y)) z набор локальных переменных секции s Лемма 3. 3 Cons(B) & Cons(C) Cons(H), где H обозначает B(x: z); C(z: y). Доказательство. Пусть истинно Cons(B) и Cons(C). Докажем истинность Cons(H). Зафиксируем значения x и y. Пусть истинна H(x: y), т. е. истинна правая часть (3. 17). Для некоторого z будут истинны B(x: z) и C(z: y). Из Cons(B) и Cons(C) следует, что исполнение B(x: z) завершается получением набора z, а исполнение C(z: y) вычислением набора y. Поэтому исполнение операторов (3. 18), а значит и H(x: y), завершается вычислением y. Это доказывает первую часть истинности Cons(H).

Допустим, исполнение H(x: y) завершается вычислением y. Докажем истинность H(x: y). Исполнение пары операторов (3. 18) завершается вычислением y. В частности, завершается первый оператор run. Call(s, B(x: z)). Тогда существует некоторый набор z, являющийся результатом исполнения. Таким образом, для некоторого z исполняются вызовы B(x: z) и C(z: y). Из Cons(B) и Cons(C) следует истинность B(x: z) и C(z: y). Следовательно, истинна правая часть (3. 18) и H(x: y). □

Параллельный оператор A(x: y, z) B(x: y) || C(x: z) (3. 19) x, y и z произвольные непересекающиеся наборы переменных, причем x может быть пустым. Если B или C есть имя переменной предикатного типа, то это имя входит в набор x. Логическая семантика параллельного оператора: L(B(x: y) || C(x: z)) B(x, y) & C(x, z) Процедура run. Stat(s, K(x: y)) абстрактного процессора: run. Call(s, B(x: y)) || run. Call(s, C(x: z)) Лемма 3. 4. Cons(B) & Cons(C) Cons(H), где H обозначает B(x: y) || C(x: z).

Условный оператор A(b, x: y) if (b) B(x: y) else C(x: y) (3. 20) L(if (b) B(x: y) else C(x: y)) (b B(x, y)) ( b C(x, y)) (3. 21) Процедура run. Stat(s, K(x: y)) абстрактного процессора: if (s[b]) run. Call(s, B(x: y)) else run. Call(s, C(x: y)) (3. 22) Лемма 3. 5. Cons(B) & Cons(C) Cons(H), где H(b, x: y) обозначает if (b) B(x: y) else C(x: y). Доказательство. Пусть истинно Cons(B) и Cons(C). Докажем истинность Cons(H). Зафиксируем значения b, x и y. Пусть истинна H(b, x: y). Тогда в соответствии с (3. 21) истинны формулы b B(x, y) и b C(x, y). Рассмотрим случай, когда значение b истинно. Тогда истинна формула B(x, y). Из Cons(B) следует, что исполнение вызова B(x: y) завершается получением набора y. Поэтому исполнение оператора (3. 22), а значит и H(b, x: y), завершается вычислением y. Это доказывает первую часть свойства Cons(H) для истинного значения b. Доказательство в случае ложного значения b проводится аналогично.

Допустим, исполнение H(b, x: y) завершается вычислением y, т. е. исполнение оператора (3. 22) завершается вычислением y. Докажем истинность H(b, x: y). Пусть b истинно. Тогда исполнение вызова B(x: y) завершается получением набора y. Из Cons(B) следует истинность B(x: y). Тогда истинны формулы b B(x, y) и b C(x, y), поскольку b истинно. Следовательно, истинна правая часть (3. 21) и H(b, x: y). Доказательство истинности H(b, x: y) в случае ложного значения b проводится аналогично. □

Конструктор предиката Базисный предикат Cons. Pred(x, B: A), x набор переменных, B имя предиката, A имя переменной предикатного типа. B не Cons. Pred и не Cons. Array L(Cons. Pred(x, B: A)) y z. (L(A(y: z)) L(B(x, y: z))) (3. 23) Процедура run. Call(s, Cons. Pred(x, B: A)) абстрактного процессора: s[A] : = p. Val(B, s[x]) (3. 24) p. Val(B, x~) = (C, (t~, x~)) (3. 25) где s[B] = (C, t~) для переменной B; C=B и t~ = для имени предиката B Пусть q[A]=(D, p). Операционная семантика A(y: z) : run. Call(q, A(y: z)) run. Call(q, D(p, y: z)). Лемма 3. 6. Cons(B) Cons(Cons. Pred). Доказательство. L(A(y: z)) L(B(x, y: z)) L(C(t~, x, y: z)) RUN(C(t~, x, y: z)) RUN(B( x, y: z)) RUN(A(y: z))

Лемма 3. 7. Пусть имеется вызов Cons. Pred(x, B: A), причем Cons(B) истинно. Тогда истинно Cons(A). Доказательство. □

Конструктор массива Базисный предикат Cons. Array(x, B: A), x набор переменных, B имя предиката, A имя переменной предикатного типа. B не Cons. Pred и не Cons. Array L(Cons. Array(x, B: A)) y z. (L(A(y: z)) L(B(x, y: z))) (3. 27) Кодирование массива A(y: z) A~[y] = z (3. 28) Процедура run. Call(s, Cons. Array(x, B: A)) абстрактного процессора: s[A] = new. Array(Y, Z); // Y, Z - списки типов y, z (3. 29) for. All y Y do run. Call(s, B(x, y: s[A][y])) end S(y: z) F(y). Тогда for. All y Y do S(y: z) end y Y. F(y) (3. 30) Лемма 3. 8. Cons(A). Доказательство непосредственно следует из соотношения (3. 28). □ Лемма 3. 9. Допустим, предикат B(x, y: z) определяет однозначную всюду определенную функцию по x и y, т. е. истинно условие: x y Y ! z B(x, y: z) (3. 31) Тогда Cons(B) Cons(Cons. Array)

Доказательство. Пусть истинно Cons(B). Зафиксируем x. В соответствии с (3. 30) после исполнение оператора for. All из (3. 29) будет истинной формула: y Y. B(x, y: A~[y]). Пусть z тот единственный набор, для которого истинно B(x, y: z) в соотношении (3. 31). Тогда A~[y] = z. Из (3. 28) следует истинность A(y: z). В итоге, после исполнения тела for. All будет истинно y Y. B(x, y: z) & A(y: z). Поскольку z единственно для B(x, y: z) и A(y: z), то будет истинным y Y. B(x, y: z) A(y: z). Дальнейшее доказательство очевидно. □ Допустим, в секции s исполняется вызов предиката A(u: v), где A является переменной предикатного типа, а значением A является массив. Секция s содержит переменную A и наборы u и v. Исполнение вызова A(u: v) реализуется следующим оператором: s[v] : = s[A] [u] Для исполнения вызова A(u: v) принято обозначение run. Call(s, A(u: v)).

Программа на языке CCP Определение предиката. В правой части ― оператор суперпозиции, параллельный оператор или условный оператор. Первичные конструкции ― вызовы предикатов. Имя предиката: • • имя базисного предиката; имя предиката, имеющего определение в программе; аргумент предиката имя переменной предикатного типа; в правой части определения предиката встречается данный вызов; имя переменной предикатного типа, являющейся результатом вызова Cons. Pred или Cons. Array, находящегося в правой части того же определения, что и данный вызов. Программа ― замкнутый набор определений предикатов ― вызываемые предикаты либо базисные, либо имеют определение в программе.

Исполнение программы: исполнение вызова A(z: u) s = new. Sect(z, u); input(s[z]); run. Call(s, A(z: u)); output(s[u]) (3. 32) Предикаты в качестве параметров предикатов Генератор CONS(x, B: A) CONS есть Cons. Pred или Cons. Array Лемма 3. 11. Имеется вызов A(z: u), где A переменная предикатного типа. Тогда: ( B subs(A). cons(B)) cons(A). Доказательство следует из лемм 3. 7, 3. 8. □