Глава 5+. SURA и XURA

Глава 5+.
SURA и XURA
Структура курса
Область возможных
новых исследований
Иные
методы
Иные
приложения
Методы
Приложения
Базовые
понятия и методы метавычислений метавычислений
метавычислений
Суперint, SR, ptr
Приложения
компиляция
суперкомпиляции,
scp
в том числе
Окрестностный
анализ
nan
Инверсное
вычисление
ura
Специализация
программ
Инверсное
программирование
Окрестностное
тестирование
Реализация
нестандартных
семантик
[1] С.М.Абрамов «Метавычисления и их применения»
[2] Л.В.Парменова «Метавычисления и их применения. Суперкомпиляция»
5+.1 MGU и
пересечение
классов:
Небольшое
дополнение к
средствам SR
Most General Unifier
Определение: s унификатор для cs1 и cs2
если cs1/.s = cs2/.s
 Обозначим unf(cs1, cs2) — множество всех
унификаторов
 Свойство 1. s
unf(cs1, cs2), s’ Subst:
(s.*.s’) unf(cs1, cs2)
 Свойство 2. Если unf(cs1, cs2) ≠ Ø, то
smgu unf(cs1, cs2):
s unf(cs1, cs2) s’ Subst: s = smgu.*.s’


Термин: smgu наиболее общий унификатор cs1
и cs2 (Most General Unifier, MGU)
unf(cs1, cs2) = {smgu.*.s’ | s’
Subst }
Таблица решений
(кроме случая «л.ч.==п.ч.»)
пр. лев. ч. ’А
ч.
’B
A.j
E.j
(CONS
cy1 cy2)
А.i
E.i
E.i:->пч
Nothing
А.i:->пч
1
5
occ.
check
А.j :->лч
2
6
(CONS
cx1 cx2)
Nothing
7
E.j:->лч,3
occ. check
Nothing
4
E.i:->пч
6
occ.
check
cy1:=:cx1
cy2:=:cx2
8
Алгоритм MGU

mgu :: Clashes -> Maybe Subst
mgu []
= Just []
mgu (eq:eqs) =
case eq of
cx1 :=: cx2 | cx1==cx2
-> mgu eqs
v@(CVE _):=:cx2
-> mgu' [v:->cx2]
`when` (v `notOccursIn` cx2)
cx1:=:v@(CVE _)
-> mgu' [v:->cx1]
`when` (v `notOccursIn` cx1)
(CONS cy1 cy2):=:(CONS cx1 cx2)
-> mgu
[cy1:=:cx1, cy2:=:cx2,]++eqs
(CONS _ _):=:_
-> Nothing
_ :=: (CONS _ _)
-> Nothing
(ATOM_):=:(ATOM_)
-> Nothing
v@(CVA _):=:cx2
-> mgu' [v:->cx2]
cx1:=:v@(CVA _)
-> mgu' [v:->cx1]
where mgu' s = fmap (s.*.) (mgu (eqs/.s))
x `when` p = if p then x else Nothing
v `notOccursIn` ce = v `notElem` (cvars ce)
Пересечение классов
 Пусть
C1 = (cs1, r1), C2 = (cs2, r2)
 Предположим (cvars C1) (cvars C2) = []
 Пусть d
<C1> <C2>.
 s1: cs1/.s1 = d, r1 /.s1 = RESTR[]
s2: cs2/.s2 = d, r2 /.s2 = RESTR[]
 s:
(s= s1++s2)
cs1/.s = d = cs2/.s
r1 /. s = RESTR[], r2 /. s = RESTR[]
(r1 .+ r2) /. s = RESTR[]
Пересечение классов
d
<C1> <C2>.
 s: cs1/.s = d = cs2/.s
r1 /. s = RESTR[], r2 /. s = RESTR[]
(r1 .+ r2) /. s = RESTR[]
 s
unf(cs1, cs2): cs1/.s = d = cs2/.s
(r1 .+ r2) /. s = RESTR[]
 s’ Subst: cs0/.s’=d, r0/.s’=RESTR[]
где
cs0 = cs1/.smgu = cs2/.smgu
r0 = (r1 .+ r2) /. smgu
 d <C0>, где C0 = (cs0, r0)
Пересечение классов
Пусть C1 = (cs1, r1), C2 = (cs2, r2)
 Предположим (cvars C1) (cvars C2) = []
 Тогда <C1> <C2> = <C0>,
где C0 = (cs0, r0),
cs0 = cs1/.smgu = cs2/.smgu
r0 = (r1.+r2)/.smgu =
(r1/.smgu).+(r2/.smgu)
 C0 ≤ C1,
C0 = C1/.(S smgu)/.(R r2’),
где r2’ = r2/.smgu
 C0 ≤ C2,
C0 = C2/.(S smgu)/.(R r1’ ),
где r1’ = r1/.smgu
 C1.^.C2 = [],
если <C1> <C2>=Ø
= [(smgu, r2’)], иначе

Пересечение классов
 (.^.)
:: Class -> Class -> [(Subst, Restr)]
(cs1,r1).^.(cs’,rs’) =
let (cs2,r2) = rename (cs’,rs’) (cs1,r1)
in case mgu (zipWith (:=:) cs1 cs2) of
Nothing
->[ ]
Just s
->
case (r1.+r2)/.s of
INCONSISTENT
->[ ]
_
->[(s,r2/.s)]
Пересечение классов
 rename
:: Class -> Class -> Class
 rename c1 c2 = c1 /. sr where
n = freeindx 0 c2
ns = [ n .. ]
vs = cvars c1
sr = zipWith f vs ns
f v@(CVA i) j = (v :-> (CVA j))
f v@(CVE i) j = (v :-> (CVE j))
5+.2 SURA:
Симметричный
УРА
SURA: Симметричный УРА
 Симметрия
входа-выхода в задаче
инверсного программирования
 f :: A → B:
 f = { …(x, y) … }
A×B, такое, что:
(x, y1)
 Обозначение:
 Обратное
f & (x, y2)
(x, y)
f
f
y1 = y2
f(x)=y
отношение:
f(-1) = { (y, x) | (x, y) f } =
{ (y, x) | f(x) = y }
Инверсное вычисление:
пересечение графика с
множеством поиска
io-класс ( ([E.1], y), RESTR[ ])
график p
допустимые данные для p
Инверсное вычисление:
пересечение графика с
множеством поиска
io-класс <Cio> = < (cxs, y), rs>
tab p на <Cin>
график p на <Cin>
<Cin> = <cxs, rs>
допустимые данные для p
Инверсное вычисление:
вперед к симметрии!
<Cio> = <([E.1], E.1), RESTR[ ]>
график p
допустимые данные для p
Инверсное вычисление:
вперед к симметрии!
<Cio> = <([ce],ce), rs>
tab p на <Cin>
график p на <Cin>
<Cin> = <ce, rs>
допустимые данные для p
Инверсное вычисление:
общий случай
<Cio> = <(cxs,cy), rs>
tab p на <Cin>
график p на <xin>
<Cin> = <cxs, rs>
допустимые данные для p
Инверсное вычисление:
частный случай —
вычисление
<Cio> = <(ds,E.1), RESTR[ ]>
tab p на <Cin>
{ (ds, p ds) }
<Cin> = <ds,RESTR[ ]> = {ds}
допустимые данные
Постановка задачи
URA: построение представления множества:
<x>p-1y = { d | d <x>, p d * y } =
<x> (p-1 y)
где p — TSG-программа, x — класс
(обобщенное данное для p), y EVal — езначение
 SURA: построение представления множества:
{ (d, y) | (d, y) <Cio>, p d * y } =
<Cio> { (d,y) | p d * y }
где p — TSG-программа, Cio = ((cxs,cy), rs) —
io-класс, Cin = (cxs, rs) — обобщенное данное
для p

Структура решения задачи

SURA: Пусть p — TSG-программа, Cio =
((cxs,cy), rs) — io-класс, Cin = (cxs, rs) —
обобщенное данное для p. Интересует
построение представления множества:
{
(d, y) | (d, y)
<Cio>, p d *

{ (d,y) | p d *

{ (d,y) | d <Cin>, p d * y }
<[C1io, C2io, C3io …]> <Cio>

y}
y}=
<Cio> =
где [C1io, C2io, C3io …] = tab p Cin
<Cio> =
запрос на инверсное
вычисление
URA
p
x
ppt
перфектное
дерево
процессов
tree
y
tab’
L
табличное
представление
функции
программы
urac
ans
ответ
на запрос
инверсного
вычисления
запрос на инверсное
вычисление
SURA
p
Cio
Cin
ppt
перфектное
дерево
процессов
tree
tab’
L
график p на
перечисление
[C1io, C2io, …]
Cin,
sura’
ans
ответ,
пересечение
графика и Cio:
[(s1,rs1), (s2,rs2)…]
SURA
 sura
:: ProgR -> IOClass ->
[(Subst,Restr)]
sura p cio@((cxs, cy), rs) =
concat (map f (tab p cin))
where
cin = (cxs, rs)
f ((cxs’,rs’),cy’) =
(cy:cxs, rs).^.(cy’:cxs’, rs’)
5+.3 XURA:
Симметричный
УРА для случая
неплоских языков
NTSG — неплоский TSG
 (define
a2b [x]
(if (cons? x h t )
(if (equ? h ’A)
( ’B :(call a2b [t]))
( h :(call a2b [t])))
[ ]))
 (define
)
f [x]
([x, (call a2b [x])])
Выполнение NTSG-программы
 (a2b
[['A, 'B, 'B, 'A, 'C]])
'B: (a2b [['B, 'B, 'A, 'C]])
'B: 'B: (a2b [['B, 'A, 'C]])
'B: 'B: 'B: (a2b [['A, 'C]])
'B: 'B: 'B: 'B: (a2b [['C]])
'B: 'B: 'B: 'B: 'C: (a2b [[]])
'B: 'B: 'B: 'B: 'C: [] =
['B, 'B, 'B, 'B, 'C]
XURA: симметричный УРА для
неплоского языка
 Неплоский
язык до завершения
вычисления может быть частично
известен результат
 Это
серьезно
(a2b
[['A, 'B, 'B,
'A, 'C]])уменьшить
● возможность
search
у УРА
даже
изменить
'B: (a2b
[['B,
'B, и'A,
'C]])
●space
свойства
терминируемости
'B: 'B: (a2b
[['B, 'A, 'C]])
●
'B: 'B: 'B:
(a2b
[['A,
'C]])
●
 Сохраним
полноту
и
'B: 'B: 'B: 'B: (a2b
[['C]])
●
непротиворечивость.
'B:
'B:
'B:
'B:
(a2b
[[]])
'C:
●
 Не приобретем, но улучшим
'B: 'B: 'B: 'B: 'C: []
терминируемость
Пример 1: ura a2b C0io, где C0io = (([E1], 'B:[ ]), restr[])
Cio =[E(([E
:A*]*], E2:[ ]), restr[E2≠'А]) [E1→ E2 :E3] [([E1→'A:A*], r[ ]),
1→2A
(a2b [E1]), restr[ ]
0
Cio.^.C io=[([E2→'B, E1→'B:A*], restr[ ])]
([E1→'B:A*], r[ ])]
[ ], restr[ ]
(a2b [E2 :E3]), restr[ ]
┐c3
c3 = [E2→'А]
E2 :(a2b [E3]), restr[E2≠'А]
'B: (a2b [E3]), restr[ ]
[E3→ E5 :E6]
[E3→ E5 :E6]
[E3→ A*]
[E3→
Cio = (([A*], [ ]), restr[
]) A*]
Cio~=~=((['A:E
((['A:E:E
'B:E:(a2b
[E])),
])),restr[E
restr[E≠'А])
05:(a2b
5:E
6],
6пересечение
5≠'А])
Cio
],
'B:E
[E
C
.^.
C
=
[
]
—
пусто!
5
6 io
5 io
6
5
*
E2:[restr[E
], restr[E
=((['A:E
((['A:E:E
'B:E:●),
2≠'А]
*C io
5:E
6],
5:●),
5≠'А])
C
=
],
'B:E
restr[E
≠'А])
66], E2:'B:(a2b
5
CioCio~=
(([E
:'A:E
[E6пусто!
])),5 restr[E2≠'А])
'B:[
],.^.C
restr[
] 5] —
0 2=[
пересечение
0 =[
io
io ] — пересечение пусто!
C
*
.^.C
io
io
Cio
~=
((['A:'A:E
[E6])),2≠'А])
restr[ ])
C
=
(([E
],],E'B:'B:(a2b
io
2:'A:E66
2:'B :●), restr[E
0 =[ [E
'B:
(a2b
restr[ ] restr[
E2])
:(a2b [E5 :E6]), restr[E2≠'А]
Cio*io.^.C
= ((['A:'A:E
],6]),
'B:'B:●])),
C
]—
пусто!
5 :E
6пересечение
io
0 =[ ] — пересечение пусто!
Ccio6 .^.C
= [E5io→'А]
┐c6
┐c6
[E5→'А]
Cio = ((['A:A*], 'B:[c6]),=restr[
])
Cio .^. C0io = [([E1→'A:A*], restr[ ])]
'B:E5:(a2b [E6]), …
E2:E5:(a2b [E6]), …
'B:'B:(a2b [E6]),restr[ ]
E2:'B:(a2b [E6]), …
Отсечение бесперспективных
поддеревьев



Пусть заказ на инверсное вычисление
p и C0io=((cxs0i, cx0o), rs0)
Пусть у текущей вершины k класс
достижимости:
Ckin = (cxski, rsk)
конфигурация:
ck = (csk, rsk)
аппроксимация io-класса:
Ckiо = ((cxski, cxko), rsk),
где cxko = skel(csk)
Тогда, если Ckiо.^. C0io = [ ], то
текущую вершину можно удалить из
дерева (с соответствующим
поддеревом).
cprev
ck=(csk,rsk)
cprev
ck=(csk,rsk)
Пример 2: ura f C0io, где
C0io = (([[A1,A2,A3]], [[A0,A0,A0],['B,'B,'B]]), restr[])
(f [[A1,A2,A3]]), restr[ ]
c1=[A1→'А]
┐c1
[[A1,A2,A3],(a2b [[A1,A2,A3]]), restr[ ]
c2=[A2→'А]
c3=[A3→'А]
┐c2
┐c3
c3
[ ['A,A2,A3],
'B:(a2b [[A2,A3]])], …
[ ['A,'A,A3],
[[A ]])], …
[[A'B:'B:(a2b
1,A2,A3],[A1,A32,A3]] …
[[A11,A
,'A,'A],[A
,'B,'B]]
[[A
,'A,A
,'B,A
2,'A],[A
3],[A1,A
2,'B]]
3]] …
Решение:
Нет
решения!
Нет
решения!
[ ['A,A
2,A
[A
→'B,
A32],→'B, A3→'B, A0→'B]
1
'B:A2:(a2b [[A3]])], …
┐c2
c2
┐c3
c3
┐c3
c3
┐c3
[ [A1,A2,A3],
A1:(a2b [[A2,A3]])], …
[ [A1,'A,A3],
A1:'B:(a2b [[A3]])],
[['A,'A,'A],['B,'B,'B]],
……
[['A,
[['A,'A,A
A2,'A],['B,A
,A
…
…
3],['B,'B,A
3],['B,A
2,'B]],
2,A
3]],
3]]…
Решение:
Нет[решения!
[A1,A2A
,A3→'А,
],
[A1→'А,
A3→'А, A0 →'А]
2
A1:A2:(a2b [[A3]])], …
Пример 2: ura f C0io, где
C0io = (([[A1,A2,A3]], [[A0,A0,A0],['B,'B,'B]]), restr[])
(f [[A1,A2,A3]]), restr[ ]
c1=[A1→'А]
c2=[A2→'А]
c3=[A3→'А]
┐c1
[[A1,A2,A3],(a2b [[A1,A2,A3]]), restr[ ]
┐c2
┐c3
c3
[['A,'A,'A],['B,'B,'B]], …
Решение:
[ A1→'А, A2→'А, A3→'А, A0 →'А]
┐c2
c2
┐c3
c3
┐c3
c3
┐c3
[[A1,A2,A3],[A1,A2,A3]] …
Решение:
[A1→'B, A2→'B, A3→'B, A0→'B]
Пример 2: ura f C0io, где
C0io = (([[A1,A2,A3]], [[A0,A0,A0],['B,'B,'B]]), restr[])
(f [[A1,A2,A3]]), restr[ ]
[[A1,A2,A3],(a2b [[A1,A2,A3]])], restr[ ]
[([A1→A0, A2→A0, A3→A0],restr[])]
c0=[A0→'А]
[[A0,A0,A0],(a2b [[A0,A0,A0]])], restr[ ]
┐c0
[['A,'A,'A],(a2b [['A,'A,'A]])], restr[ ]
[[A0,A0,A0],(a2b [[A0,A0,A0]])],[A0≠‘A]
[['A,'A,'A],'B:(a2b [['A,'A]])], restr[ ]
[[A0,A0,A0], A0:(a2b [[A0,A0]])],[A0≠‘A]
[['A,'A,'A],'B:'B:(a2b [['A]])], restr[ ]
[[A0,A0,A0], A0:A0:(a2b [[A0]])],[A0≠‘A]
c1
= ([[A1,A2,A3],(a2b [[A1,A2,A3]]), restr[])
[['A,'A,'A],'B:'B:'B:(a2b
] [[A ,A ,A ],A0:A0:A0:(a2b [[]])],[A0≠‘A]
C1in
= ([[A1[[]])],
,A2,Arestr[
3]],restr[])0 0 0
C1io
= (([[A1,A2,A3]], [[A1,A2,A3], ●), restr[])
['B:'B:'B:]], restr[ ]
[[A0,A0,A0],[A0,A0,A0]],[A0≠‘A]
C0[['A,'A,'A],
=
(([[A
,A
,A
]],
[[A
,A
io
1
2
3
0
0,A0],['B,'B,'B]]), restr[])
C1io .^. C0io = [([A1→A0, A2→A0, A3→A0,●→['B,'B,'B]],restr[])]
Backpropagation



Пусть заказ на инверсное вычисление
p и C0io=((cxs0i, cx0o), rs0)
Пусть у текущей вершины k класс
достижимости:
Ckin = (cxski, rsk)
конфигурация:
ck = (csk, rsk)
аппроксимация io-класса:
Ckiо = ((cxski, cxko), rsk),
где cxko = skel(csk)
Тогда, если
Ckiо.^. C0io = [(s,rs)],
то к текущей вершине можно
применить сужение (s,rs)
cprev
ck=(csk,rsk)
cprev
ck=(csk,rsk)
(s,rs)
ck/.s/.rs
Отсечение бесперспективных
поддеревьев и Backpropagation



k
0
k
0
Пусть заказ на инверсное C iо.^.C io=[ ] C iо.^.C io=[(s,rs)]
вычисление p и
cprev
cprev
C0io=((cxs0i, cx0o), rs0)
Пусть у текущей вершины
k класс достижимости:
Ckin = (cxski, rsk)
ck=(csk,rsk)
ck=(csk,rsk)
конфигурация:
ck = (csk, rsk)
аппроксимация io-класса:
Ckiо=((cxski, cxko), rsk),
cprev
cprev
где cxko = skel(csk)
Рассматриваем результат
Ckiо.^.C0io и выполняем
соответствующую
ck=(csk,rsk)
ck=(csk,rsk)
операцию над текущей
(s,rs)
вершиной
ck/.s/.rs
Выводы
В неплоском языке до завершения вычисления
может быть частично известен результат
 Можно серьезно уменьшить search space у УРА
и даже изменить свойства терминируемости —
за счет отсечения бесперспективных
поддеревьев и Backpropagation
 Как результат: сохраняем полноту и
непротиворечивость УРА, не приобретаем, но
улучшаем терминируемость УРА
 Ясная идея (по сравнению с FL-языками)

Вне программы: BTI вместо
«прямой реализации»
 Можно
«в лоб» реализовать отсечение
бесперспективных поддеревьев и
Backpropagation
 Можно использовать идею «BTI», если
язык (XSG), для которого реализуется
ura, поддерживает:
 mgu-based операцию равенства
(equ? ... ...)
 ленивую и справедливую семантику
Вне программы: BTI вместо
«прямой реализации»

p Cio: Inv(p, Cio) = Inv(p*, C*io)
где
Cio = (([d1, ... dn], dout ), rs)
C*io = (([d1, ... dn,dout], 'True), rs)
p* =
[ (define main[in1,... inn, out]
(call test
[ (call mainfct(p) [in1, ... inn]),
out]
) ),
(define test [res, out]
(if (equ? res out) ’True ’False)
)
] ++ p
XSG и XURA: состояние и
перспективы
Язык XSG — незавершенный проект, с
большой перспективой
 Сделаны сравнения с FL-языками,
эксперименты на проверку чистоты реализации
тех или иных технических решений:

mgu-based операцию равенства (equ? ... ...)
 ленивую и справедливую семантику
 отсечение бесперспективных поддеревьев
 Backpropagation


«XSG» и «MC для XSG» — хорошие и
перспективные темы для Theoretical Computer
Science исследований и разработок