WikiDer > Церковная кодировка - Википедия

В математика, Церковная кодировка это средство представления данных и операторов в лямбда-исчисление. В Церковные цифры представляют собой представление натуральных чисел с использованием лямбда-обозначения. Метод назван в честь Церковь Алонсо, который первым закодировал данные в лямбда-исчислении таким образом.

Термины, которые обычно считаются примитивными в других обозначениях (таких как целые числа, логические значения, пары, списки и помеченные объединения), отображаются в функции высшего порядка под церковной кодировкой. В Тезис Черча-Тьюринга утверждает, что любой вычислимый оператор (и его операнды) могут быть представлены в кодировке Чёрча. в нетипизированное лямбда-исчисление единственный примитивный тип данных - это функция.

Кодировка Чёрча не предназначена для практической реализации примитивных типов данных. Его использование должно показать, что другие примитивные типы данных не требуются для представления каких-либо вычислений. Полнота репрезентативна. Дополнительные функции необходимы для преобразования представления в общие типы данных для отображения людям. В общем случае невозможно решить, являются ли две функции экстенсивно равны из-за неразрешимость эквивалентности из Теорема Черча. Перевод может каким-либо образом применить функцию для получения значения, которое она представляет, или поиска его значения как буквального лямбда-термина.

Лямбда-исчисление обычно интерпретируется как использование содержательное равенство. Есть потенциальные проблемы с интерпретацией результатов из-за разницы между интенсиональным и экстенсиональным определениями равенства.

Церковные цифры

Церковные цифры представляют собой натуральные числа под церковной кодировкой. В функция высшего порядка что представляет собой натуральное число п это функция, которая отображает любую функцию ${ displaystyle f}$ к его п-складывать сочинение.^[1] Проще говоря, «значение» числа эквивалентно тому, сколько раз функция инкапсулирует свой аргумент.

${ displaystyle f ^ { circ n} = underbrace {f circ f circ cdots circ f} _ {n { text {times}}}. ,}$

Все числа Чёрча - это функции, которые принимают два параметра. Церковные цифры 0, 1, 2, ..., определены в лямбда-исчисление.

Начиная с 0 не применяя функцию вообще, продолжайте 1 применяя функцию один раз, 2применяя функцию дважды, 3 применение функции три раза и т. д.:

${ displaystyle { begin {array} {r | l | l} { text {Number}} & { text {Определение функции}} & { text {Лямбда-выражение}} hline 0 & 0 f x = x & 0 = lambda f. lambda xx 1 & 1 f x = f x & 1 = lambda f. lambda xf x 2 & 2 f x = f (f x) & 2 = lambda f. lambda xf (f x) 3 & 3 f x = f (f (f x)) & 3 = lambda f. lambda xf (f (f x)) vdots & vdots & vdots n & n f x = f ^ {n} x & n = lambda f. lambda xf ^ { circ n} x end {array}}}$

Церковная цифра 3 представляет действие трехкратного применения любой заданной функции к значению. Предоставленная функция сначала применяется к предоставленному параметру, а затем последовательно к собственному результату.^[1] Конечным результатом будет не цифра 3 (если только указанный параметр не равен 0, а функция не является функция преемника). Сама функция, а не ее конечный результат, - это цифра Чёрча. 3. Церковная цифра 3 означает просто сделать что-нибудь трижды. Это показной демонстрация того, что подразумевается под «трижды».

Расчет по церковным цифрам

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

Функция сложения ${ Displaystyle OperatorName {плюс} (м, п) = м + п}$ использует личность ${ Displaystyle е ^ { circ (m + n)} (x) = f ^ { circ m} (f ^ { circ n} (x))}$.

${ Displaystyle OperatorName {плюс} эквив лямбда м. лямбда п. лямбда е. лямбда х.м е (п е х)}$

Функция преемника ${ Displaystyle OperatorName {succ} (п) = п + 1}$ является β-эквивалент к ${ displaystyle ( operatorname {plus} 1)}$.

${ Displaystyle OperatorName {succ} экв лямбда п. лямбда е. лямбда х.ф (п е х)}$

Функция умножения ${ displaystyle operatorname {mult} (m, n) = m * n}$ использует личность ${ Displaystyle е ^ { circ (m * n)} (x) = (f ^ { circ n}) ^ { circ m} (x)}$.

${ Displaystyle OperatorName {Mult} Equiv lambda m. lambda n. lambda f. lambda x.m (n f) x}$

Функция возведения в степень ${ displaystyle operatorname {exp} (m, n) = m ^ {n}}$ дается определением цифр Чёрча, ${ Displaystyle п ч х = ч ^ {п} х}$. В определении заменить ${ displaystyle h to m, x to f}$ получить ${ Displaystyle п м е = м ^ {п} f}$ и,

${ Displaystyle OperatorName {exp} m n = m ^ {n} = n m}$

что дает лямбда-выражение,

${ Displaystyle OperatorName {exp} Equiv lambda m. lambda n.n m}$

В ${ Displaystyle OperatorName {пред} (п)}$ функция труднее понять.

${ Displaystyle OperatorName {пред} эквив лямбда п. лямбда е. лямбда х.n ( лямбда г. лямбда ч.ч (г f)) ( лямбда и.х) ( лямбда и.у)}$

Цифра Чёрча применяет функцию п раз. Функция-предшественник должна возвращать функцию, которая применяет ее параметр п - 1 раз. Это достигается путем создания контейнера вокруг ж и Икс, который инициализируется способом, исключающим применение функции в первый раз. Видеть предшественник для более подробного объяснения.

Функцию вычитания можно записать на основе функции-предшественника.

${ Displaystyle OperatorName {минус} Equiv lambda m. lambda n. (п OperatorName {pred}) m}$

Таблица функций на цифрах Чёрча

Функция	Алгебра	Личность	Определение функции	Лямбда-выражения
Преемник	${ displaystyle n + 1}$	${ Displaystyle е ^ {п + 1} х = е (е ^ {п} х)}$	${ Displaystyle OperatorName {succ} п е х = е (п е х)}$	${ Displaystyle лямбда п. лямбда е. лямбда х.f (п е х)}$	...
Добавление	${ displaystyle m + n}$	${ Displaystyle е ^ {м + п} х = е ^ {м} (е ^ {п} х)}$	${ Displaystyle OperatorName {плюс} м п е х = м е (п е х)}$	${ displaystyle lambda m. lambda n. lambda f. lambda x.m f (n f x)}$	${ displaystyle lambda m. lambda n.n operatorname {succ} m}$
Умножение	${ displaystyle m * n}$	${ Displaystyle е ^ {м * п} х = (е ^ {м}) ^ {п} х}$	${ displaystyle operatorname {multiply} m n f x = m (n f) x}$	${ displaystyle lambda m. lambda n. lambda f. lambda x.m (n f) x}$	${ Displaystyle лямбда м. лямбда п. лямбда ф.м (п е)}$
Возведение в степень	${ Displaystyle м ^ {п}}$	${ Displaystyle п м е = м ^ {п} f}$[2]	${ Displaystyle OperatorName {ехр} м п е х = (п м) е х}$	${ Displaystyle лямбда м. лямбда п. лямбда е. лямбда х. (п м) е х}$	${ displaystyle lambda m. lambda n.n m}$
Предшественник*	${ displaystyle n-1}$	${ displaystyle operatorname {inc} ^ {n} operatorname {con} = operatorname {val} (f ^ {n-1} x)}$	${ Displaystyle если (п == 0) 0 еще (п-1)}$	${ displaystyle lambda n. lambda f. lambda x.n ( lambda g. lambda h.h (g f)) ( lambda u.x) ( lambda u.u)}$
Вычитание*	${ displaystyle m-n}$	${ Displaystyle е ^ {м-п} х = (е ^ {- 1}) ^ {п} (е ^ {м} х)}$	${ displaystyle operatorname {минус} m n = (n operatorname {pred}) m}$	...	${ displaystyle lambda m. lambda n.n operatorname {pred} m}$

* Обратите внимание, что в церковной кодировке

• ${ displaystyle operatorname {pred} (0) = 0}$
• ${ Displaystyle м <п к м-п = 0}$

Вывод функции-предшественника

Функция-предшественник, используемая в кодировке Чёрча:

${ displaystyle operatorname {pred} (n) = { begin {cases} 0 & { mbox {if}} n = 0, n-1 & { mbox {else}} end {cases}}}$.

Чтобы построить предшественника, нам нужен способ применения функции на 1 меньше раз. Числительное п применяет функцию ж п раз, чтобы Икс. Функция-предшественник должна использовать цифру п применить функцию п-1 раз.

Перед реализацией функции-предшественника приведем схему, которая обертывает значение в функцию-контейнер. Мы определим новые функции, которые будут использоваться вместо ж и Икс, называется inc и в этом. Функция контейнера называется ценить. В левой части таблицы показана цифра п применительно к inc и в этом.

${ displaystyle { begin {array} {r | r | r} { text {Number}} & { text {Использование init}} & { text {Использование const}} hline 0 & operatorname {init } = operatorname {значение} x & 1 & operatorname {inc} operatorname {init} = operatorname {value} (f x) & operatorname {inc} operatorname {const} = operatorname {значение} x 2 & operatorname {inc} ( operatorname {inc} operatorname {init}) = operatorname {value} (f (f x)) & operatorname {inc} ( operatorname {inc} operatorname {const}) = operatorname {value} (f x) 3 & operatorname {inc} ( operatorname {inc} ( operatorname {inc} operatorname {init})) = operatorname {value} (f (f (f x))) & operatorname {inc} ( operatorname {inc} ( operatorname {inc} operatorname {const })) = operatorname {значение} (f (f x)) vdots & vdots & vdots n & n operatorname {inc} operatorname {init} = operatorname {value} (f ^ {n} x) = operatorname {значение} (n f x) & n operatorname {inc} operatorname {const} = operatorname {value} (f ^ {n-1} х) = о peratorname {значение} ((n-1) f x) end {array}}}$

Общее правило повторения:

${ displaystyle operatorname {inc} ( operatorname {value} v) = operatorname {value} (f v)}$

Если есть также функция для извлечения значения из контейнера (называется извлекать),

${ displaystyle operatorname {extract} ( operatorname {value} v) = v}$

потом извлекать может использоваться для определения Samenum функционировать как,

${ displaystyle operatorname {samenum} = lambda n. lambda f. lambda x. operatorname {extract} (n operatorname {inc} operatorname {init}) = lambda n. lambda f. лямбда x. operatorname {extract} ( operatorname {value} (n f x)) = lambda n. lambda f. lambda xn f x = lambda nn}$

В Samenum функция по сути не полезна. Однако, как inc делегаты созывают ж аргументу контейнера, мы можем организовать это в первом приложении inc получает специальный контейнер, который игнорирует его аргумент, позволяя пропустить первое применение ж. Назовите этот новый начальный контейнер const. В правой части приведенной выше таблицы показаны расширения п inc const. Затем, заменив в этом с const в выражении для одно и тоже function мы получаем функцию-предшественницу,

${ displaystyle operatorname {pred} = lambda n. lambda f. lambda x. operatorname {extract} (n operatorname {inc} operatorname {const}) = lambda n. lambda f. лямбда x. operatorname {extract} ( operatorname {value} ((n-1) f x)) = lambda n. lambda f. lambda x. (n-1) f x = лямбда п. (п-1)}$

Как объяснено ниже, функции inc, в этом, const, ценить и извлекать можно определить как,

${ displaystyle { begin {align} operatorname {value} & = lambda v. ( lambda hh v) operatorname {extract} k & = k lambda uu operatorname {inc} & = lambda g. lambda hh (g f) operatorname {init} & = lambda hh x operatorname {const} & = lambda ux end {align}}}$

Это дает лямбда-выражение для пред в качестве,

${ displaystyle operatorname {pred} = lambda n. lambda f. lambda x.n ( lambda g. lambda h.h (g f)) ( lambda u.x) ( lambda u.u)}$

Другой способ определения пред

Pred также можно определить с помощью пар:

${ displaystyle { begin {align} operatorname {f} = & lambda p. operatorname {pair} ( operatorname {second} p) ( operatorname {succ} ( operatorname {second } p)) operatorname {zero} = & ( lambda f. lambda x. x) operatorname {pc0} = & operatorname {pair} operatorname {zero} имя оператора {ноль} имя оператора {пред} = & lambda n. имя оператора {первое} (n имя оператора {f} имя оператора {pc0}) конец {выровнено}}}$

Это более простое определение, но приводит к более сложному выражению для pred. ${ Displaystyle OperatorName {пред} OperatorName {три}}$:

${ displaystyle { begin {align} operatorname {pred} operatorname {three} = & operatorname {first} ( operatorname {f} ( operatorname {f} ( operatorname {f} ( operatorname {pair} operatorname {zero} operatorname {zero})))) = & operatorname {first} ( operatorname {f} ( operatorname {f} ( operatorname { пара} OperatorName {ноль} OperatorName {one}))) = & operatorname {first} ( operatorname {f} ( operatorname {pair} operatorname {one} operatorname {two})) = & operatorname {first} ( operatorname {pair} operatorname {two} operatorname {three}) = & operatorname {two} end {выровнено} }}$

Разделение

Разделение натуральных чисел может быть реализовано с помощью,^[3]

${ Displaystyle п / м = имя оператора {если} п geq м имя оператора {то} 1+ (п-м) / м имя оператора {else} 0}$

Расчет ${ displaystyle n-m}$ требует много сокращений бета-версии. Если сокращение не выполняется вручную, это не имеет большого значения, но желательно не выполнять этот расчет дважды. Самый простой предикат для проверки чисел - это IsZero так что рассмотрите условие.

${ displaystyle operatorname {IsZero} ( operatorname {minus} n m)}$

Но это условие эквивалентно ${ Displaystyle п leq m}$, нет ${ Displaystyle п <м}$. Если используется это выражение, то приведенное выше математическое определение деления переводится в функцию на числах Чёрча как,

${ Displaystyle OperatorName {Divide1} N M F X = ( lambda d. Operatorname {IsZero} d (0 f x) (f ( Operatorname {diver1} d m f x))) ( operatorname {minus} n m)}$

Как и следовало ожидать, это определение имеет единственный вызов ${ Displaystyle OperatorName {минус} п м}$. Однако в результате эта формула дает значение ${ Displaystyle (п-1) / м}$.

Эту проблему можно исправить, добавив 1 к п перед звонком разделять. Определение разделять затем,

${ Displaystyle OperatorName {Разделить} N = OperatorName {Разделить1} ( OperatorName {succ} N)}$

разделить1 рекурсивное определение. В Y комбинатор может использоваться для реализации рекурсии. Создайте новую функцию с именем div к;

• В левой части ${ Displaystyle OperatorName {разделять1} rightarrow OperatorName {div} c}$
• В правой части ${ Displaystyle OperatorName {DivX1} rightarrow c}$

получить,

${ displaystyle operatorname {div} = lambda c. lambda n. lambda m. lambda f. lambda x. ( lambda d. operatorname {IsZero} d (0 f x) (е (c d m f x))) ( OperatorName {minus} n m)}$

Потом,

${ Displaystyle OperatorName {разделять} = лямбда п. OperatorName {разделять1} ( OperatorName {succ} n)}$

куда,

${ displaystyle { begin {align} operatorname {div} & = Y operatorname {div} operatorname {succ} & = lambda n. lambda f. lambda xf (n f x ) Y & = lambda f. ( Lambda xf (x x)) ( lambda xf (x x)) 0 & = lambda f. Lambda xx имя оператора {IsZero} & = lambda nn ( lambda x. operatorname {false}) operatorname {true} end {align}}}$

${ Displaystyle { begin {выровнено} OperatorName {истина} & Equiv lambda a. lambda b.a operatorname {false} & Equiv lambda a. lambda b.b end {выровнено}}}$

${ displaystyle { begin {align} operatorname {minus} & = lambda m. lambda nn operatorname {pred} m operatorname {pred} & = lambda n. lambda f. lambda xn ( lambda g. lambda hh (g f)) ( lambda ux) ( lambda uu) end {выровнено}}}$

Дает,

${ Displaystyle scriptstyle OperatorName {разделять} = лямбда п. (( лямбда ф. ( лямбда хх х) ( лямбда хf (х х))) ( лямбда с. лямбда п . lambda m. lambda f. lambda x. ( lambda d. ( lambda nn ( lambda x. ( lambda a. lambda bb)) ​​( lambda a. lambda ba)) d (( lambda f. lambda xx) f x) (f (c d m f x))) (( lambda m. lambda nn ( lambda n. лямбда f. lambda xn ( lambda g. lambda hh (g f)) ( lambda ux) ( lambda uu)) m) n m))) (( lambda n . lambda f. lambda xf (n f x)) n)}$

Или как текст, используя для λ,

разделить = ( n. (( f. ( xx x) ( xf (xx))) ( c.  n.  m.  f.  x. ( d. ( nn ( x . ( a.  bb)) ( a.  ba)) d (( f.  xx) fx) (f (cdmfx))) (( m.  nn ( n.  f.  xn ( g.  hh (gf)) ( ux) ( uu)) m) nm))) (( n.  f.  x. f (nfx)) n))

Например, 9/3 представлено как

разделить ( f.  x.f (f (f (f (f (f (f (f (f x)))))))) ( f.  x.f (f (f x)))

Используя калькулятор лямбда-исчисления, приведенное выше выражение сокращается до 3 в обычном порядке.

 е.  x.f (е (е (х)))

Подписанные числа

Один простой способ расширения церковных цифр на числа со знаком - использовать пару Чёрча, содержащую числа Чёрча, представляющие положительное и отрицательное значение.^[4] Целочисленное значение - это разница между двумя цифрами Чёрча.

Натуральное число преобразуется в число со знаком:

${ displaystyle operatorname {convert} _ {s} = lambda x. operatorname {pair} x 0}$

Отрицание выполняется заменой значений.

${ displaystyle operatorname {neg} _ {s} = lambda x. operatorname {pair} ( operatorname {second} x) ( operatorname {first} x)}$

Целочисленное значение более естественно представлено, если одна из пары равна нулю. В OneZero функция достигает этого условия,

${ displaystyle operatorname {OneZero} = lambda x. operatorname {IsZero} ( operatorname {first} x) x ( operatorname {IsZero} ( operatorname {second} x) x ( operatorname {OneZero} operatorname {pair} ( operatorname {pred} ( operatorname {first} x)) ( operatorname {pred} ( operatorname {second} x)))) }$

Рекурсия может быть реализована с использованием комбинатора Y,

${ displaystyle operatorname {OneZ} = lambda c. lambda x. operatorname {IsZero} ( operatorname {first} x) x ( operatorname {IsZero} ( Operatorname {second} x ) x (c OperatorName {пара} ( operatorname {pred} ( operatorname {first} x)) ( operatorname {pred} ( operatorname {second} x)))) }$

${ displaystyle operatorname {OneZero} = Y operatorname {OneZ}}$

Плюс и минус

Сложение определяется математически на паре как

${ displaystyle x + y = [x_ {p}, x_ {n}] + [y_ {p}, y_ {n}] = x_ {p} -x_ {n} + y_ {p} -y_ {n} = (x_ {p} + y_ {p}) - (x_ {n} + y_ {n}) = [x_ {p} + y_ {p}, x_ {n} + y_ {n}]}$

Последнее выражение переводится в лямбда-исчисление как,

${ displaystyle operatorname {plus} _ {s} = lambda x. lambda y. operatorname {OneZero} ( operatorname {pair} ( operatorname {plus} ( operatorname {first} x) ( operatorname {first} y)) ( operatorname {plus} ( operatorname {second} x) ( operatorname {second} y)))}$

Аналогично определяется вычитание,

${ displaystyle xy = [x_ {p}, x_ {n}] - [y_ {p}, y_ {n}] = x_ {p} -x_ {n} -y_ {p} + y_ {n} = ( x_ {p} + y_ {n}) - (x_ {n} + y_ {p}) = [x_ {p} + y_ {n}, x_ {n} + y_ {p}]}$

давая

${ displaystyle operatorname {minus} _ {s} = lambda x. lambda y. operatorname {OneZero} ( operatorname {pair} ( operatorname {plus} ( operatorname {first} x) ( operatorname {second} y)) ( operatorname {plus} ( operatorname {second} x) ( operatorname {first} y)))}$

Умножить и разделить

Умножение можно определить следующим образом:

${ displaystyle x * y = [x_ {p}, x_ {n}] * [y_ {p}, y_ {n}] = (x_ {p} -x_ {n}) * (y_ {p} -y_ {n}) = (x_ {p} * y_ {p} + x_ {n} * y_ {n}) - (x_ {p} * y_ {n} + x_ {n} * y_ {p}) = [ x_ {p} * y_ {p} + x_ {n} * y_ {n}, x_ {p} * y_ {n} + x_ {n} * y_ {p}]}$

Последнее выражение переводится в лямбда-исчисление как,

${ displaystyle operatorname {mult} _ {s} = lambda x. lambda y. operatorname {pair} ( operatorname {plus} ( operatorname {mult} ( operatorname {first} x) ( operatorname {first} y)) ( operatorname {mult} ( operatorname {second} x) ( operatorname {second} y))) ( operatorname {plus} ( OperatorName {mult} ( operatorname {first} x) ( operatorname {second} y)) ( operatorname {mult} ( operatorname {second} x) ( operatorname {first} у)))}$

Аналогичное определение дается здесь для деления, за исключением того, что в этом определении одно значение в каждой паре должно быть равно нулю (см. OneZero над). В divZ Функция позволяет нам игнорировать значение с нулевым компонентом.

${ displaystyle operatorname {divZ} = lambda x. lambda y. operatorname {IsZero} y 0 ( operatorname {DivZ} x y)}$

divZ затем используется в следующей формуле, которая такая же, как для умножения, но с мульт заменен на divZ.

${ displaystyle operatorname {div} _ {s} = lambda x. lambda y. operatorname {pair} ( operatorname {plus} ( operatorname {divZ} ( operatorname {first} x) ( operatorname {first} y)) ( operatorname {divZ} ( operatorname {second} x) ( operatorname {second} y))) ( operatorname {plus} ( OperatorName {divZ} ( operatorname {first} x) ( operatorname {second} y)) ( operatorname {divZ} ( operatorname {second} x) ( operatorname {first} у)))}$

Рациональные и действительные числа

Рациональные и вычислимые действительные числа также могут быть закодированы в лямбда-исчислении. Рациональные числа могут быть закодированы как пара чисел со знаком. Вычислимые действительные числа могут быть закодированы с помощью ограничивающего процесса, который гарантирует, что разница от реального значения отличается на число, которое может быть сделано настолько маленьким, насколько нам нужно.^[5][6] Приведенные ссылки описывают программное обеспечение, которое теоретически может быть переведено в лямбда-исчисление. После определения действительных чисел комплексные числа естественным образом кодируются как пара действительных чисел.

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

Перевод с другими представлениями

Большинство реальных языков поддерживают машинные целые числа; то церковь и отлучить от церкви функции конвертируют между неотрицательными целыми числами и соответствующими им числами Чёрча. Функции приведены здесь в Haskell, где \ соответствует λ из лямбда-исчисления. Реализации на других языках аналогичны.

тип Церковь а = (а -> а) -> а -> ацерковь :: Целое число -> Церковь Целое числоцерковь 0 = \ж -> \Икс -> Иксцерковь п = \ж -> \Икс -> ж (церковь (п-1) ж Икс)отлучить от церкви :: Церковь Целое число -> Целое числоотлучить от церкви сп = сп (+ 1) 0

Церковные логические значения

Церковные логические значения являются кодировкой Чёрча булевых значений истинный и ложный. Некоторые языки программирования используют их как модель реализации для логической арифметики; примеры Болтовня и Пико.

Булеву логику можно рассматривать как выбор. Церковная кодировка истинный и ложный являются функциями двух параметров:

• истинный выбирает первый параметр.
• ложный выбирает второй параметр.

Эти два определения известны как логические значения Чёрча:

${ Displaystyle { begin {выровнено} OperatorName {истина} & Equiv lambda a. lambda b.a operatorname {false} & Equiv lambda a. lambda b.b end {выровнено}}}$

Это определение допускает предикаты (т.е. функции, возвращающие логические значения), чтобы действовать как if-clauses. Функция, возвращающая логическое значение, которое затем применяется к двум параметрам, возвращает либо первый, либо второй параметр:

${ displaystyle operatorname {предикат} x operatorname {then-clause} operatorname {else-clause}}$

оценивает затем предложение если предикат Икс оценивает истинный, и чтобы else-clause если предикат Икс оценивает ложный.

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

${ displaystyle { begin {align} operatorname {and} & = lambda p. lambda qp q p operatorname {or} & = lambda p. lambda qp p q operatorname {not} _ {1} & = lambda p. lambda a. lambda bp b a { scriptstyle { text {(Это правильная реализация, только если стратегия оценки является аппликативной.)} }} operatorname {not} _ {2} & = lambda pp ( lambda a. lambda bb) ( lambda a. lambda ba) = lambda pp operatorname {false} operatorname { true} { scriptstyle { text {(Это правильная реализация, только если стратегия оценки соответствует нормальному порядку.)}}} operatorname {xor} & = lambda a. lambda ba ( operatorname { not} b) b operatorname {if} & = lambda p. lambda a. lambda bp a b end {align}}}$

Некоторые примеры:

${ displaystyle { begin {align} operatorname {and} operatorname {true} operatorname {false} & = ( lambda p. lambda qp q p) operatorname {true} operatorname {false } = operatorname {true} operatorname {false} operatorname {true} = ( lambda a. lambda ba) operatorname {false} operatorname {true} = operatorname {false} operatorname {или} operatorname {true} operatorname {false} & = ( lambda p. lambda qp p q) ( lambda a. lambda ba) ( lambda a. lambda bb) = ( lambda a . lambda ba) ( lambda a. lambda ba) ( lambda a. lambda bb) = ( lambda a. lambda ba) = operatorname {true} operatorname {not} _ { 1} operatorname {true} & = ( lambda p. Lambda a. Lambda bp b a) ( lambda a. Lambda ba) = lambda a. Lambda b. ( Lambda a. lambda ba) b a = lambda a. lambda b. ( lambda cb) a = lambda a. lambda bb = operatorname {false} operatorname {not} _ {2} operatorname {true} & = ( lambda pp ( lambda a. lambda bb) ( lambda a. lambda ba)) ( lambda a. lambda ba) = ( lambda a. lambda ba) ( la mbda a. lambda bb) ( lambda a. lambda ba) = ( lambda b. ( lambda a. lambda bb)) ​​( lambda a. lambda ba) = lambda a. lambda bb = OperatorName {false} end {align}}}$

Предикаты

А предикат - функция, возвращающая логическое значение. Самый фундаментальный предикат - это ${ displaystyle operatorname {IsZero}}$, который возвращает ${ displaystyle operatorname {true}}$ если его аргумент - цифра Чёрча ${ displaystyle 0}$, и ${ displaystyle operatorname {false}}$ если его аргумент - любое другое число Чёрча:

${ displaystyle operatorname {IsZero} = lambda n.n ( lambda x. operatorname {false}) operatorname {true}}$

Следующий предикат проверяет, меньше ли первый аргумент второму или равен ему:

${ displaystyle operatorname {LEQ} = lambda m. lambda n. operatorname {IsZero} ( operatorname {minus} m n)}$,

Из-за личности,

${ Displaystyle х = у эквив (х Leq у земля у Leq х)}$

Проверка на равенство может быть реализована как:

${ displaystyle operatorname {EQ} = lambda m. lambda n. operatorname {and} ( operatorname {LEQ} m n) ( operatorname {LEQ} n m)}$

Церковные пары

Церковные пары - это церковная кодировка пара (двукортежный) тип. Пара представлена ​​как функция, которая принимает аргумент функции. Получив аргумент, он применит аргумент к двум компонентам пары. Определение в лямбда-исчисление является,

${ Displaystyle { begin {выровнено} OperatorName {pair} & Equiv lambda x. lambda y. lambda zz ​​x y operatorname {first} & Equiv lambda pp ( lambda x . lambda yx) operatorname {second} & Equiv lambda pp ( lambda x. lambda yy) end {выравнивается}}}$

Например,

${ displaystyle { begin {align} & operatorname {first} ( operatorname {pair} a b) = & ( lambda pp ( lambda x. lambda yx)) (( лямбда x. lambda y. lambda zz ​​x y) a b) = & ( lambda pp ( lambda x. lambda yx)) ( lambda zz ​​a b) = & ( lambda zz ​​a b) ( lambda x. lambda yx) = & ( lambda x. lambda yx) a b = a end {align}}}$

Список кодировок

An (неизменный) список состоит из узлов списка. Основные операции в списке:

Ниже мы приводим четыре различных представления списков:

• Создайте каждый узел списка из двух пар (чтобы учесть пустые списки).
• Постройте каждый узел списка из одной пары.
• Представьте список с помощью функция правого сгиба.
• Представьте список с использованием кодировки Скотта, которая принимает в качестве аргументов случаи выражения соответствия

Две пары как узел списка

Непустой список может быть реализован парой Чёрча;

• Первый содержит голову.
• Второй содержит хвост.

Однако это не дает представления о пустом списке, потому что нет «нулевого» указателя. Чтобы представить null, пара может быть завернута в другую пару, давая свободные значения,

• Первый - пустой указатель (пустой список).
• Во-вторых, во-первых содержит голову.
• Второй. Второй. содержит хвост.

Используя эту идею, основные операции со списком можно определить следующим образом:^[7]

Выражение	Описание
${ Displaystyle OperatorName {ниль} Equiv OperatorName {пара} OperatorName {истина} OperatorName {истина}}$	Первый элемент пары - это истинный это означает, что список пуст.
${ Displaystyle OperatorName {isnil} Equiv OperatorName {первый}}$	Получите нулевой (или пустой список) индикатор.
${ displaystyle operatorname {cons} Equiv lambda h. lambda t. operatorname {pair} operatorname {false} ( operatorname {pair} h t)}$	Создайте узел списка, который не является нулевым, и дайте ему заголовок час и хвост т.
${ Displaystyle OperatorName {голова} Equiv lambda Z. OperatorName {первый} ( OperatorName {второй} z)}$	второй. первый это голова.
${ Displaystyle OperatorName {хвост} Equiv lambda Z. OperatorName {second} ( OperatorName {second} z)}$	второй. второй это хвост.

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

Одна пара как узел списка

В качестве альтернативы определите^[8]

${ displaystyle { begin {align} operatorname {cons} & Equiv operatorname {pair} operatorname {head} & Equiv operatorname {first} operatorname {tail} & Equiv operatorname { second} operatorname {nil} & Equiv operatorname {false} operatorname {isnil} & Equiv lambda ll ( lambda h. lambda t. lambda d. operatorname {false}) имя оператора {истина} конец {выровнено}}}$

где последнее определение является частным случаем общего

${ displaystyle operatorname {список-процессов} Equ lambda l.l ( lambda h. lambda t. lambda d. operatorname {head-and-tail-clause}) operatorname {nil-clause}}$

Представьте список, используя правая складка

В качестве альтернативы кодированию с использованием пар Чёрча список можно закодировать, отождествив его с функция правого сгиба. Например, список из трех элементов x, y и z может быть закодирован функцией высшего порядка, которая при применении к комбинатору c и значению n возвращает c x (c y (c z n)).

${ displaystyle { begin {align} operatorname {nil} & Equiv lambda c. lambda nn operatorname {isnil} & Equiv lambda ll ( lambda h. lambda t. operatorname { false}) OperatorName {true} OperatorName {cons} & Equiv lambda h. lambda t. lambda c. lambda nc h (t c n) operatorname {head } & Equiv lambda ll ( lambda h. lambda th) operatorname {false} operatorname {tail} & Equiv lambda l. lambda c. lambda nl ( lambda h. lambda t. lambda gg h (t c)) ( lambda tn) ( lambda h. lambda tt) end {выровнено}}}$

Это представление списка может иметь тип Система F.

Представьте список с использованием кодировки Скотта

Альтернативным представлением является кодировка Скотта, в которой используется идея продолжения и может привести к упрощению кода.^[9] (смотрите также Кодировка Могенсена – Скотта).

В этом подходе мы используем тот факт, что списки можно наблюдать с помощью выражения сопоставления с образцом. Например, используя Scala обозначение, если список обозначает значение типа Список с пустым списком Ноль и конструктор Минусы (ч, т) мы можем проверить список и вычислить nilCode если список пуст и consCode (ч, т) когда список не пуст:

список матч {  дело Ноль        => nilCode  дело Минусы(час, т) => consCode(час,т)}

«Список» определяется тем, как он действует с «nilCode» и «consCode». Поэтому мы определяем список как функцию, которая принимает такие 'nilCode' и 'consCode' в качестве аргументов, так что вместо совпадения с указанным выше шаблоном мы можем просто написать:

${ displaystyle operatorname {список} operatorname {nilCode} ( operatorname {consCode} h t)}$

Обозначим через 'n' параметр, соответствующий 'nilCode', а через 'c' - параметр, соответствующий 'consCode'. Пустой список - это тот, который возвращает аргумент nil:

${ Displaystyle OperatorName {nil} экв лямбда п лямбда с. п}$

Непустой список с заголовком "h" и хвостом "t" задается следующим образом:

${ Displaystyle OperatorName {cons} ч т эквив лямбда п. лямбда с. с ч т}$

В более общем плане алгебраический тип данных с ${ displaystyle m}$ альтернатив становится функцией с ${ displaystyle m}$ параметры. Когда ${ displaystyle i}$th конструктор имеет ${ displaystyle n_ {i}}$ аргументы, соответствующий параметр кодировки принимает ${ displaystyle n_ {i}}$ аргументы тоже.

Кодирование Скотта может выполняться в нетипизированном лямбда-исчислении, тогда как для его использования с типами требуется система типов с рекурсией и полиморфизмом типов. Список с типом элемента E в этом представлении, который используется для вычисления значений типа C, будет иметь следующее определение рекурсивного типа, где '=>' обозначает тип функции:

тип Список =   C =>                    // нулевой аргумент  (E => Список => C) =>     // аргумент cons  C                       // результат сопоставления с образцом

Список, который можно использовать для вычисления произвольных типов, будет иметь тип, который количественно превышает C. Общий список^{[требуется разъяснение]} в E также взял бы E в качестве аргумента типа.

Смотрите также

• Лямбда-исчисление
• Система F для чисел Чёрча в типизированном исчислении
• Кодировка Могенсена – Скотта
• Определение фон Неймана ординалов - другой способ кодирования натуральных чисел: как наборы

Примечания

Рекомендации

• Непосредственно отражающее метапрограммирование
• Объяснение церковных чисел и логических значений Роберт Картрайт в Университет Райса
• Теоретические основы практического «полностью функционального программирования» (Главы 2 и 5) Все о церковных и других подобных кодировках, включая способы их получения и действия с ними, из первых принципов
• Некоторые интерактивные примеры церковных цифр
• Живое руководство по лямбда-исчислению: логическая алгебра