лямбда-исчисление

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

есть в основном два и половина процессов в лямбда-исчислении:

1) Альфа-преобразование - если вы применяете два лямбда-выражения с одинаковым именем переменной внутри, вы меняете одно из них на новое имя переменной. Например (λx.xx) (λx.x) становится чем-то вроде (λx.xx) (λy.y) или (λx.xx) (λx'.х') после сокращения. Результат эквивалентен тому, с чего вы начинаете, просто с разными именами переменных.

2) бета-сокращение-в основном просто замена. Это процесс вызова лямбда-выражение с вводом и получение вывода. Лямбда-выражение похоже на функцию, вы вызываете функцию, подставляя входные данные по всему выражению. Взять (λx.xy) z, вторая половина (λx.xy), все после периода, выводится, вы сохраняете вывод, но заменяете переменную (названную до периода) предоставленным входом. z вход, x - имя параметра, xy выход. Найдите все вхождения параметра в выходных данных и замените их с вводом и это то, к чему он сводится, так что (λx.xy)z =>xy С z заменить на x, которая составляет zy.

2.5) ETA Conversion / Eta Reduction - это сокращение особого случая, которое я называю только половиной процесса, потому что это своего рода бета-сокращение, как в technichally это не. Вы можете увидеть его написанным в Википедии или в учебнике как "Eta-преобразование преобразует между λx.(f x) и f всякий раз, когда x не отображается свободно в f", который звучит очень запутанно. Все, что на самом деле означает λx.(f x) = f, если f не использует x. если это действительно имеет смысл, но лучше показано на примере. Рассмотрим (λx.(λy.yy) x), это эквивалентно через уменьшение eta до (λy.yy), потому что f = (λy.yy), в котором нет x, вы можете показать это, уменьшив его, так как он решил бы (λx.xx), что, по-видимому, одно и то же. Вы сказали сосредоточиться на бета-сокращении, и поэтому я не собираюсь подробно обсуждать преобразование eta это заслуживает, но многие люди дали им идти на это об обмене стеками теории cs

на обозначение для бета-сокращения:

Я собираюсь использовать следующую нотацию для замены предоставленного ввода на вывод:

(λ param . output)input =>output [param := input] =>result

это означает, что мы заменяем вхождения param в выходе, и это то, что он сводится к

пример:

(λx.xy)z

= (xy)[x:=z]

= (zy)

= zy

хватит теории, давайте решим это. Лямбда-исчисление-хорошее развлечение.

проблема, которую вы придумали, может быть решена только с Альфа-преобразованием и бета-уменьшением, не пугайтесь того, как долго длится процесс ниже. Это довольно долго, без сомнения, но ни один шаг в его решении не является действительно трудным.

(λxyz.xyz) (λx.xx) (λx.x) x

= (((λxyz.xyz) (λx.xx)) (λx.x)) x - добавим скобки в "нормальном порядке", левая ассоциативность, abc уменьшается как ((ab) c), где b применяется к a, а c применяется к результату этого

= (((λxyz.xyz) (λx.xx))(λx.x)) x - выберите самое глубокое вложенное приложение и сначала уменьшите его.

выделенная часть уменьшает как:

(λxyz.xyz) (λx.xx)

= (λx.λyz.xyz) (λx.xx) - означает то же самое, но мы вытаскиваем первый параметр, так как мы собираемся уменьшить его, и поэтому я хочу, чтобы он был ясным

= (λx.λyz.xyz) (λx'.x'X') - Альфа-преобразование, некоторые люди придерживаются новых букв, но мне нравится добавлять цифры в конце или в любом случае. Поскольку оба выражения используют параметр x, мы должны переименовать их с одной стороны, потому что два Xs являются локальными переменными и поэтому не должны представлять одно и то же.

= (λyz.xyz) [x := λx'.x'X'] - обозначение для бета-редукции, удаляем первый параметр и заменить его вхождения в выходных данных тем, что применяется [a: = b] означает, что a должен быть заменен на b.

= (λyz.(λx'.x'X') yz) - фактическая редукция, заменяем вхождение x на предоставленное лямбда-выражение.

= (λyz. ((λx'.х х')г) z) - нормальный порядок скобок снова, и посмотрите, другое приложение для уменьшения, на этот раз y применяется к (λx.xx`), поэтому давайте уменьшим это теперь

= (λyz. ((x'x')[x' := y]) z) - поместите это в нотацию для бета-сокращения.

= (λyz. (yy) z) - мы меняем два вхождения x'X' на Ys, и теперь это полностью уменьшено.

добавить обратно в исходное выражение:

(((λxyz.xyz) (λx.xx))(λx.x)) x

= ((λyz.(yy)z) (λx.x)) x-это не ново, просто возвращая то, что мы нашли ранее в.

= ((λyz.(yy)z) (λx.x)) x-захватите самое глубокое вложенное приложение ,оно имеет (λx.x) применяется к (λyz.(yy)z)

мы решим это отдельно еще раз:

(λyz.(yy)z) (λx.x)

= (λy.λz.(yy)z) (λx.x) - просто снова вывести первый параметр для ясности.

= (λz.(yy)z) [y: = (λx.x)] - положить в бета-сокращение нотации, мы выскакиваем первый параметр, и обратите внимание, что Ys будет переключил на (λx.x)

= (λz.((λx.x) (λx.x)) z) - фактическое уменьшение / замещение, жирный раздел теперь можно уменьшить

= (λz.((x)[x := λx.x])z) - надеюсь, вы уже получили картину, мы начинаем бета-уменьшение (λx.x) (λx.x), поместив его в форму (x)[x := λx.x]

= (λz.((λx.x)) z) - и есть подстановка

= (λz.(λx.x) z) - убирается чрезмерная скобка, и что мы находим, но другое приложение для борьбы с

= (λz.(x) [x:=z]) - Pop параметр x, помещенный в обозначение

= (λz.(z)) - выполнить подстановку

= (λz.z) - очистить избыточную скобку

положите его обратно в основное выражение:

((λyz.(yy)z) (λx.x)) x

= ((λz.z)) x-заполнение того, что мы доказали выше

= (λz.z) x-очистка от чрезмерных скобок, теперь это сводится к одному окончательному применению, x применяется к(λz.z)

= (z)[z:=x] - бета-редукция, введенная в обозначение

= (x) - сделайте подстановку

= x-очистите чрезмерную скобку

так, да. Ответ x, он уменьшился просто groovy.