калькуляция с отражением

23

Я ищу простое исчисление, которое поддерживает рассуждения о рефлексии , а именно, самоанализ и манипулирование запущенными программами.

Есть нетипизированная -исчисления расширения , которое позволяет конвертировать -терминов в форму , которая может быть синтаксический манипулирует , а затем впоследствии оценивается? $\lambda$ $\lambda$

Я предполагаю, что в исчислении есть два основных дополнительных условия:

$\mathtt{reflect}\ v$ : принимает и создает представление изменить с помощью синтаксических манипуляций. $v$ $v$
$\mathtt{eval}\ v$ : принимает синтаксическое представление термина и оценивает его.

Чтобы поддержать рефлексию, требуется синтаксическое представление терминов. Это будет выглядеть примерно так:

$\lambda x.e$ будет представлен как термин , где является отраженной версией , $(\mathsf{LAM}\ R(e))$ $R(e)$ $e$
$e\ e'$ будет представлен как термин , и $(\mathsf{APP}\ R(e)\ R(e'))$
$x$ будет представлен как . $(\mathsf{VAR}\ x)$

При таком представлении сопоставление с образцом может использоваться для манипулирования терминами.

Но мы сталкиваемся с проблемой. и должны быть закодированы как термины, как и сопоставление с образцом. Разобраться с этим, кажется, просто, добавив , и , но мне нужно будет добавить другие термины для поддержки манипулирования ими? $\mathtt{reflect}$ $\mathtt{eval}$ $\mathsf{REFLECT}$ $\mathsf{EVAL}$ $\mathsf{MATCH}$

Есть выбор дизайна, который должен быть сделан. Что должна делать функция упомянутая выше, с телом и ? Должен ли преобразовывать тело или нет? $R(-)$ $\mathtt{reflect}$ $\mathtt{eval}$ $R(-)$

Поскольку я не очень заинтересован в изучении самого отражения - исчисление послужит средством для других исследований - я не хочу изобретать велосипед.

Существуют ли какие-либо исчисления, которые соответствуют тому, что я только что описал?

Насколько я могу судить, исчисления, такие как MetaML, предложенные в комментарии, имеют большое значение, но они не включают в себя возможность сопоставления с образцом и деконструкции уже созданных фрагментов кода.

Я хотел бы иметь возможность сделать следующее:

$\mathtt{let}\ x=\lambda y.y\ \mathtt{in}\ \mathtt{reflect}\ x \to (\mathsf{LAM}\ (\mathsf{VAR}\ y)\ (\mathsf{VAR}\ y))$

А затем выполните сопоставление с шаблоном для результата, чтобы создать совершенно другое выражение.

Это, конечно, не является консервативным расширением -calculus, и мета-теория, вероятно, будет некрасивой, но это своего рода точка для моего приложения. Я хочу разбить абстракции на части. $\lambda$ $\lambda$

— Дэйв Кларк
источник

MetaML - это типизированный рефлексивный язык с оператором брекетинга, который выполняет ваш REFLECT и снимает брекеты с EVAL. Печатание является базовым, но вы можете увидеть фрагмент, унаследованный от модального S4, в работе, подобной этой, которая может вам помочь.

— ex0du5

@ ex0du5: Спасибо, но, насколько я могу судить, этого недостаточно. Конечно, я могу создавать код на разных этапах, но мне кажется, что я не могу разлучить термины. (Я буду читать более внимательно, чтобы увидеть, пропустил ли я что-нибудь.)

— Дэйв Кларк

Схема (без изменчивости и других осложнений)?

— Жиль "ТАК - перестань быть злым"

@ Жиль: Схема - это язык программирования, а не исчисление. Кроме того, я не думаю, что он может делать то, что я хочу.

— Дейв Кларк,

@DaveClarke Язык программирования - это исчисление с большим количеством бородавок. С первого взгляда ядро Схемы кажется подходящим, но я не достаточно продумал ваши требования, чтобы быть уверенным. Как вы думаете, не будет работать? (Заходите, чтобы поболтать, если хотите.)

— Жиль "ТАК - перестань быть злым"

15

Жан Луи Кривин представил абстрактное исчисление, которое расширяет «Машину Кривина» весьма нетривиальным способом (обратите внимание, что машина Кривина уже поддерживает инструкцию call / cc из lisp):

В этой статье он вводит оператор «кавычки», определенный следующим образом: если является термином, заметим образ некоторой биекцией от лямбда-членов до натуральных чисел. Примечание церковь с номером , который соответствует . Кривин определяет оператор по правилу оценки: $\phi$ $\lambda$ $n_\phi$ $\phi$ $\pi: \Lambda \rightarrow \mathbb{N}$ $\overline{n}$ $n\in\mathbb{N}$ $\chi$

χ ϕ \to ϕ \bar{n_{ϕ}}

$\chi\ \phi \rightarrow \phi\ \overline{n_\phi}$ Я полагаю, что Kleene wizardry покажет, что этого достаточно, чтобы делать то, что вы хотите: т.е. определять операторы кавычек и eval, если

вычислимо.

π

$\pi$

Обратите внимание, что Кривин, как известно, сложно читать (пожалуйста, не сердитесь, если вы читаете это, Жан-Луи!), И некоторые исследователи предприняли благотворительный акт, пытаясь извлечь технический контент в более читабельной форме. Вы можете попытаться взглянуть на эти заметки Кристофа Раффали.

Надеюсь это поможет!

Мне приходит в голову, что есть еще одна ссылка, которая может иметь отношение к вашим интересам: исчисление чистого образца Джея и Кеснера формализует вариант исчисления, который расширяет простую абстракцию над переменной на абстракцию над шаблоном, представляющим исчисление образца сам. Это феноменально выразительно и, в частности, позволяет деконструировать само приложение: если я не ошибаюсь, термин: $\lambda$

(λ (x y) . x) ((λ x . x x) (λ y . y))

$(\lambda (x\ y). x)((\lambda x.x\ x)\ (\lambda y.y))$

сводится к . Опять же, я верю, что этого более чем достаточно, чтобы реализовать операторы quote и eval . $\lambda x.x\ x$

— Коди
источник

Я хотел бы высказать этот, казалось бы, разумный ответ, но я понятия не имею, начинает ли он даже отвечать на вопрос.

— Рафаэль

@ Рафаэль прочитайте статьи и узнайте :) По правде говоря, это только частичный ответ: статьи действительно формализуют важную особенность lisp, которой нет в лямбда-исчислении, а именно оператор QUOTE. Тем не менее, нет обширного мета-теоретического исследования, они просто представляют его как средство выражения своего рода странного непрозрачного вычисления для реализации сложных аксиом теории множеств.

— Коди

1

Если я правильно помню, в PPC вы не можете сопоставлять шаблоны при переопределении, причина, которую они дали, ради слияния. Кроме того, в PPC сопоставление с образцом строго соответствует сопоставляемому, поэтому

будет немедленно нормализовано до

, тогда попытка сопоставить его с шаблоном

не удастся.

(λ x . x x) (λ y . y)

$(\lambda x . x\ x)\ (\lambda y . y)$

λ y . y

$\lambda y . y$

(x y)

$(x\ y)$

— день

1

Единственная известная мне цитата - Лисп. Но, насколько я помню, он просто меняет все, что указано в синтаксическом объекте. «Функция»

принимает ее аргумент невычисленным ..

функция должен принимать значение аргумента (оценить его), и превратить его обратно в какое - то синтаксическое выражение , которое (как ?) к этому значению. Так что, если Кривин формализм имеет дело с LISP

, мы не получим далеко , что предлагается в этом вопросе.

q u o t e

$\mathtt{quote}$

r e f l e c t

$\mathtt{reflect}$

q u o t e

$\mathtt{quote}$

— Бабу

8

Это очень трудно, если не невозможно, не отказываясь от слияния. То есть я подозреваю, что вы правы насчет волосатой мета-теории. С другой стороны, можно разработать исчисление комбинатора, которое может выражать все вычислимые функции Тьюринга и которое обладает полной способностью проверять его термины: см. Jay and Give-Wilson .

Однако я считаю, что наличие этой способности вредит вашей теории эквалайзера. В частности, вы сможете доказать, что два значения равны, если они равны с точностью до альфа-эквивалентов.

Я еще не читал связанную с Криви бумагу Коди, но я должен отметить, что в классической логике у вас есть только две вещи: истинная и ложная. Все эквивалентно одному из них. То есть, в любом случае, вы склонны иметь разрушенную эквалайзерную теорию.

— Филипп JF
источник

1

Обратите внимание, что исчисление Кривина не исчисление предложений, а скорее реализаторы для них, которые имеют весьма нетривиальную эквациональную теорию.

— cody

5

В теории языков программирования функция, о которой вы говорите, обычно называется «цитата». Например, Джон Лонгли писал об этом в некоторых своих работах, см. Эту статью .

Если вы просто придерживаетесь теоретических соображений (в отличие от действительно полезной реализации), то вы можете упростить вещи, заявив, что quote(или, reflectкак вы это называете) отображаются в тип целых чисел nat, возвращая код Гёделя своего аргумента. Затем вы можете разложить число так же, как и абстрактное синтаксическое дерево. Кроме того, вам не нужно, evalпотому что это может быть реализовано на языке - это по сути переводчик для языка.

Для конкретной модели, которая имеет эти особенности, вы можете рассмотреть первую комбинаторную алгебру Клини: интерпретировать все как число (представьте их как коды Гёделя) и определить приложение Клини чтобы обозначить где - это - частичная функция Это даст вам модель калькуляции (с частичными отображениями), в которой это просто единичная функция. Больше никаких функций не нужно добавлять к языку. $n \star m$ $\varphi_n(m)$ $\varphi_n$ $n$ $\lambda$ quote

Если вы скажете мне, что вы ищете, я смогу дать вам более конкретные ссылки.

Кстати, здесь есть открытая проблема:

Обогащите калькуляцию (типизированную или нетипизированную), которая является конгруэнцией таким образом, что вы сохраняете правило. $\lambda$ quote $\xi$

-правило $\xi$ говорит, чтоабстракция является конгруэнцией. Это позволяет нам,так сказать,уменьшить под. В сочетании сэтим становится проблематичным, таккак предполагается также конгруэнтность,

\frac{е_{1} \equiv е_{2}}{λ Икс, е_{1} \equiv λ Икс, е_{2}}

$\frac{e_1 \equiv e_2}{\lambda x \,.\, e_1 \equiv \lambda x \,.\, e_2}$

λ

$\lambda$

λ

$\lambda$ quotequote

\frac{е_{1} \equiv е_{2}}{Q U о T е е_{1} \equiv Q U о T е е_{2}},

$\frac{e_1 \equiv e_2}{\mathtt{quote}\,e_1 \equiv \mathtt{quote}\,e_2},$

Q U о T е ((λ Икс, Икс) Y) \equiv Q U о T е Y,

$\mathtt{quote}\,((\lambda x \,.\,x) y) \equiv \mathtt{quote}\, y.$ quote

λ

$\lambda$

— Андрей Бауэр
источник

β

$\beta$ quote

λ

$\lambda$

ξ

$\xi$

ξ

$\xi$

β

$\beta$

Следующая статья показывает некоторые проблемы с уравнением (ξ): Лямбда-исчисление алгебраическое, Питер Селинджер. Интересно, что-то новое я не знал! Круто.

— Трансфинные числа

4

Вот альтернативный ответ, вместо того, чтобы использовать мой номинальный подход, который все еще экспериментален, есть еще более устоявшийся подход, который восходит к статье:

LEAP: язык с eval и полиморфизмом
Фрэнк Пфеннинг и Питер Ли
https://www.cs.cmu.edu/~fp/papers/tapsoft89.pdf

Статья начинается с:

Затем это привело нас к вопросу, впервые заданному Рейнольдсом, о том, допускают ли строго типизированные языки метациркулярные интерпретаторы. Обычная мудрость, казалось, указывала, что ответ был «Нет». Наш ответ «Почти».

Обратите внимание, что LEAP намного сильнее, чем хочет ОП. Прежде всего это напечатано. И, во-вторых, он запрашивает метациркуляцию, что означает, например, что eval может выполнить свое собственное определение. В Прологе вы получаете метациркулярность для решения / 1:

solve(true).
solve((A,B)) :- solve(A), solve(B).
solve(H) :- clause(H,B), solve(B).

Если вы добавите следующий пункт для решения / 1:

solve(clause(H,B)) :- clause(H,B).

И если вы видите, что условие / 2 также возвращает пункты решения / 1. Затем вы можете позвонить решить (решить (...)) и посмотреть, как выполняет сама себя.

Вопросы саморепрезентации все еще стимулируют некоторые исследования, см., Например:

Самопредставление в системе Girards U
Мэтт Браун, Дженс Палсберг
http://compilers.cs.ucla.edu/popl15/popl15-full.pdf

— Трансфинитные числа
источник

3

Проблема выявляется в непосредственной близости от таких помощников, как Coq и Isabelle / HOL. Он идет под аббревиатурой HOAS . Вокруг λ-Пролога есть некоторые утверждения, что с помощью нового квантификатора можно делать такие вещи. Но я еще не мог получить контроль над этим требованием. Я думаю, что главное понимание, которое я получил до сих пор, это то, что нет определенного подхода, есть несколько возможных подходов.

Мое собственное мнение , еще не законченное , вдохновлено недавней работой Полсона о доказательстве Гёделса неполноты. Я бы использовал связыватели уровня объекта в связи с некоторой структурой данных, которая имеет имена метауровня. По сути, такая же, но отличная структура данных, как у OP и с церковным кодированием, поскольку меня интересуют зависимые типы:

datatype Expr = var Name                 /* written as n */
              | app Expr Expr            /* written as s t */
              | abs Name Expr Expr       /* written as λn:s.t */

Выражения мета-уровня можно отличить от выражений уровня объекта тем, что мы используем имена переменных n, m, ... и т. Д. Для обозначения имен. В то время как мы используем имена переменных x, y, .. и т. Д. На уровне объекта. Интерпретация мета-термина в объектной логике будет тогда работать следующим образом. Давайте напишем [t] σ для интерпретации номинального термина t в номинальном контексте σ, который должен дать объектный термин. Тогда бы мы имели:

 [n]σ = lookup σ n
 [s t]σ = [s]σ [t]σ
 [λn:s.t]σ = λx:[s]σ.[t]σ,n:x

Выше будет определять то, что OP вызывает функцию EVAL. Небольшая разница с Полсоном в том, что σ является лишь конечным списком, а не функционалом. По моему мнению, было бы возможно только ввести функцию EVAL, а не функцию REFLECT. Поскольку на уровне объекта вы можете иметь некоторое равенство, чтобы разные лямбда-выражения были одинаковыми. Что вам нужно сделать, так это использовать eval для рассуждения, возможно, также и о рефлексии, если вы чувствуете необходимость.

Вам нужно перейти к крайностям, таким как Пролог, где ничего не расширяется, если вы хотите разрушить стену между номинальной и неноминальной. Но, как показывает пример системы λ-Prolog, в случае более высокого порядка возникают дополнительные проблемы, которые, например, могут быть преодолены только логическим путем, путем введения новых средств, таких как such квантификатор!

— Трансфинитные числа
источник