{ "cells": [ { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ ":opt no-lint" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Untyped $𝜆$-calculus\n", "타입없는 람다계산법의 문법과 줄일 수 있는 식(reducible expression)의 개념 등에 대해 알아본다.\n", "\n", "\"줄일 수 있는 식\"이라는 말이 너무 길기 때문에 '주는식'(redex)과 같은 줄임말을 보통 더 많이 사용한다." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 문법\n", "$ x \\in \\textit{Nm} $\n", "\n", "$ e \\in \\textit{Tm}\n", "\\\\ e ::=~ x ~\\mid~ (\\lambda x.e) ~\\mid~ (e_1~e_2)\n", "$\n", "\n", "보통 수학에서 $f(x) = x^2$과 같이 정의하는 함수 $f$를 람다계산법에서는 아래와 같은 방식으로 표현한다.\n", "\n", "$(\\lambda x.x^2)$\n", "\n", "그리고 보통 수학에서 정의된 함수를 호출하는 $f(3)$과 같은 표현은 람다계산법에서는 괄호 없이 함수와 인자를 나열하여 아래와 같은 방식으로 표현한다.\n", "\n", "$((\\lambda x.x^2)~3)$\n", "\n", "수학에서도 그렇듯 람다계산법에서도 어떤 함수가 다른 함수를 받아 또 다른 함수를 만들어낼 수 있다.\n", "가장 대표적인 예로 '미분'이라는 개념을 함수를 받아 함수를 돌려주는 함수로 이해할 수도 있다.\n", "\n", "$((미분~(\\lambda x.x^2))~3) \\longrightarrow\\cdots\\longrightarrow ((\\lambda x.\\,2\\times x)~3) \\longrightarrow 2\\times 3 \\longrightarrow 6$\n", "\n", "물론 순수한 람다계산법에는 미분이나, 제곱, 곱하기, 등의 개념을 기본적으로 제공하지는 않으며 심지어 자연수도 기본 구성요소로 제공되지 않는다. 위에 예제는 개념적인 이해를 돕기 위한 설명이다. 참고로 Alonzo Church의 람다계산법은 Alan Turing의 튜링머신과 마찬가지로 괴델이 \"수학명제 자동판별 문제\"가 해결 불가능함을 증명한 불완전성 정리를 그들 나름의 방식으로 좀더 직접적으로 간략하게 증명하기 위한 이론적 도구 혹은 소품으로 만들어진 것이다. 가정하는 것이 아니라 하지만 이후 이런 소품들의 이론적 계산능력이 동일하다는 것이 밝혀지면서 오늘날 우리가 이해하는 컴퓨터로 할 수 있는 모든 계산의 이론적 범위를 발견한 것으로 받아들여지고 있는데 이를 처치-튜링 논제(Church-Turing thesis)라고 한다. 이와 관련한 역사적 배경 및 좀더 자세한 내용이 궁금한 사람들은 다음 온라인에 공개된 [컴퓨터과학이 여는 세계](https://www.youtube.com/watch?v=HTWSPoDLmHI&list=PL0Nf1KJu6Ui7yoc9RQ2TiiYL9Z0MKoggH) 강의 시리즈의 1.4, 1.5, 1.6 내용 영상 등이 참고가 될 것이다." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "-- 변수 이름은 문자열 나타낸다\n", "type Nm = String\n", "\n", "-- 람다식 문법 구조\n", "data Tm = Var Nm -- x\n", " | Lam Nm Tm -- (λx.e)\n", " | App Tm Tm -- (e1 e2)\n", " deriving (Show, Eq)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "-- 람다식을 보기좋게 문자열로 변환해주는 함수\n", "ppTm (Var x) = x\n", "ppTm (Lam x e) = \"\\\\\" ++ x ++ \" -> \" ++ ppTm e\n", "ppTm (App e1 e2) = pp1 e1 ++ \" \" ++ pp2 e2\n", " where\n", " pp1 e@(Lam{}) = paren (ppTm e)\n", " pp1 e = ppTm e\n", " pp2 e@(Var{}) = ppTm e\n", " pp2 e = paren (ppTm e)\n", "\n", "paren s = \"(\" ++ s ++ \")\"\n", "brack s = \"[\" ++ s ++ \"]\"\n", "latex s = \"$\" ++ s ++ \"$\"\n", "\n", "-- 람다식을 보기좋게 TeX 코드로 변환해주는 함수\n", "texTm (Var x) = x\n", "texTm (Lam x e) = \"\\\\lambda \" ++ x ++ \".\" ++ texTm e\n", "texTm (App e1 e2) = tex1 e1 ++ \"~\" ++ tex2 e2\n", " where\n", " tex1 e@(Lam{}) = paren (texTm e)\n", " tex1 t = texTm t\n", " tex2 s@(Var{}) = texTm s\n", " tex2 s = paren (texTm s)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "idTm = Lam \"x\" (Var \"x\")\n", "ttTm = Lam \"x\" (Lam \"y\" (Var \"x\")) \n", "ffTm = Lam \"x\" (Lam \"y\" (Var \"y\")) " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\\x -> x" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "\\x -> \\y -> x" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "\\x -> \\y -> y" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "putStr $ ppTm idTm\n", "putStr $ ppTm ttTm\n", "putStr $ ppTm ffTm" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/html": [ "$\\lambda x.x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda x.\\lambda y.x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda x.\\lambda y.y$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$x~y~z$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$x~(y~z)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$(\\lambda x.\\lambda y.y)~(\\lambda x.x)~(\\lambda x.\\lambda y.x)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$(\\lambda x.\\lambda y.y)~((\\lambda x.x)~(\\lambda x.\\lambda y.x))$" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import IHaskell.Display\n", "\n", "html . latex $ texTm idTm\n", "html . latex $ texTm ttTm\n", "html . latex $ texTm ffTm\n", "html . latex $ texTm (App (App (Var \"x\") (Var \"y\")) (Var \"z\"))\n", "html . latex $ texTm (App (Var \"x\") (App (Var \"y\") (Var \"z\")))\n", "html . latex $ texTm (App (App ffTm idTm) ttTm)\n", "html . latex $ texTm (App ffTm (App idTm ttTm))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 부분식(sub-expression)\n", "람다식의 부분식은 그 식의 일부로 나타나는 람다식이다. 전체 식 자체도 자기 자신의 부분식이라고 하자.\n", "\n", "하스켈 데이타 타입 `Tm`으로 표현된 어떤 람다식의 부분식을 모두 나열하는 리스트를 구하는 함수를 다음과 같이 작성할 수 있다." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[2,3,4,7,8]" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "[2,3,4] ++ [7,8]" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "subTm :: Tm -> [Tm]\n", "subTm (Var x) = [(Var x)] -- (Var x) : []\n", "subTm (Lam x e1) = (Lam x e1) : subTm e1\n", "subTm (App e1 e2) = (App e1 e2) : subTm e1 ++ subTm e2" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/html": [ "$(\\lambda x.x)~(\\lambda y.y)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "[App (Lam \"x\" (Var \"x\")) (Lam \"y\" (Var \"y\")),Lam \"x\" (Var \"x\"),Var \"x\",Lam \"y\" (Var \"y\"),Var \"y\"]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$(\\lambda x.x)~(\\lambda y.y)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda x.x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda y.y$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$y$" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "e = App (Lam \"x\" (Var \"x\")) (Lam \"y\" (Var \"y\"))\n", "\n", "html . latex . texTm $ e\n", "\n", "subTm e\n", "\n", "map (html . latex . texTm) (subTm e)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "패턴매칭에서 부분별로 이름을 붙임과 동시에 구조 전체에도 이름을 붙여주려면 `@`을 활용한다.\n", "예컨대 위의 `subTm`과 같은 함수를 다음과 `@`패턴을 활용하면 더 간결하게 정의되며,\n", "컴파일러가 구조 전체를 함수 결과에서 그대로 참조할 수 있는 추가 정보가 돌 수 있으므로\n", "컴파일된 코드의 성능이 개선될 가능성도 있다." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "subTm' :: Tm -> [Tm]\n", "subTm' e@(Var _) = [e]\n", "subTm' e@(Lam x e1) = e : subTm e1\n", "subTm' e@(App e1 e2) = e : subTm e1 ++ subTm e2" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[App (Lam \"x\" (Var \"x\")) (Lam \"y\" (Var \"y\")),Lam \"x\" (Var \"x\"),Var \"x\",Lam \"y\" (Var \"y\"),Var \"y\"]" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$(\\lambda x.x)~(\\lambda y.y)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda x.x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda y.y$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$y$" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "e = App (Lam \"x\" (Var \"x\")) (Lam \"y\" (Var \"y\"))\n", "\n", "subTm' e\n", "\n", "map (html . latex . texTm) (subTm' e)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 주는식(redex)\n", "람다계산법의 실행의미는 그 문법만큼이나 매우 단순하다.\n", "함수정의식 $(\\lambda x.e)$를 인자 $e_2$에 적용한\n", "함수적용식 $((\\lambda x.e)~e_2)$는 곧바로 줄일 수 있는\n", "주는식(redex)이며 그것을 한 걸음 줄인 결과는\n", "$e$에 나타나는 $x$를 $e_2$로 치환한 식,\n", "즉 $x$의 자리에 $x$대신 $e_2$로 끼워넣은 식이 된다.\n", "달리 말하지면 주는식이란 즉시 함수 호출을 할 수 있는 형태의 함수적용식을 말하는 것이다.\n", "왜냐하면 즉시 함수 호출이 가능하려면 왼쪽에 오는 함수 부분이 람다로 시작하는 함수정의식이어야 하니까.\n", "이러한 계산 규칙을 $\\beta$-줄이기($\\beta$-reduction)이라고 하며\n", "아래와 같이 나타낸다. 참고로 줄이는 방법이 한 가지가 아니라 여러 가지 규칙이 포함된\n", "람다계산법의 변이들도 가능한데 그런 경우 특정 규칙에 따라 주는식임을 표현하기 위해\n", "$\\beta$-주는식($\\beta$-redex)이라고 줄이는 규칙의 이름을 앞에 붙여서 말하기도 한다.\n", "\n", "$((\\lambda x. e)~e_2) \\longrightarrow \\{x\\mapsto e_2\\}e$\n", "\n", "여기에서 $\\{x\\mapsto e_2\\}e$는 바로 $e$에서 $x$를 $e_2$로 치환한 식을 의미하는 표기법이다.\n", "예컨대 $\\big(\\big(\\lambda x.(\\lambda y.(y~x)~x)\\big)~z\\big)$를\n", "줄이면 $\\{x\\mapsto z\\}(\\lambda y.(y~x)~x)$ 그러니까 $(\\lambda y.(y~z)~z)$가 된다.\n", "\n", "참고로 위의 $\\beta$-줄이기 규칙을 핵심으로 하되, 어떤 식이 그 자체로는 $\\beta$-줄이기 규칙의\n", "적용 대상이 아니더라도 규칙이 적용되는 부분을 찾아 그 부분의 식에 $\\beta$-줄이기를 적용하는\n", "규칙들을 추가로 정의할 수 있다. 예컨대, $\\big(\\big((\\lambda x.x)~(\\lambda y.y)\\big)~(\\lambda z.z)\\big)$는\n", "그 자체로는 식 전체에 $\\beta$-줄이기 규칙을 적용할 수 없지만\n", "그 부분식인 $\\big((\\lambda x.x)~(\\lambda y.y)\\big)$에는 $\\beta$-줄이기 규칙을 적용할 수 있다.\n", "사실 부분식에 $\\beta$-줄이기를 어떻게 적용할지는 여러 가지\n", "방법 혹은 전략이 가능한데 지금은 일단 적당히 아무 곳에나 적용한다고 하고 넘어가기로 하고 이후에\n", "다시 이에 대해 생각해 보겠다.\n", "\n", "하스켈 데이타 타입 `Tm`으로 표현된 어떤 람다식이\n", "그 자체로 $\\beta$-줄이기 규칙을 바로 적용할 수 있는 주는식(redex)인지\n", "검사하는 함수를 다음과 같이 작성할 수 있다." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "isRedEx :: Tm -> Bool\n", "isRedEx (App (Lam{}) _) = True\n", "isRedEx _ = False" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "$\\lambda x.x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "False" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$(\\lambda x.x)~(\\lambda x.x)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "True" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda x.(\\lambda x.x)~(\\lambda x.x)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "False" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "e1 = idTm\n", "e2 = App idTm idTm\n", "e3 = (Lam \"x\" e2)\n", "\n", "html . latex $ texTm e1\n", "isRedEx e1\n", "html . latex $ texTm e2\n", "isRedEx e2\n", "html . latex $ texTm e3\n", "isRedEx e3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "주어진 식 자체로는 주는식(redex)이 아니더라도 어떤 부분의 부분식에 주는식을 포함하고 있을 수도 있다.\n", "그 자체로 주는 식인 경우 뿐만 아니라 부분식으로 주는식을 포함하는 식인지까지 검사하는 `hasRedEx` 함수를\n", "다음과 같이 작성할 수 있다." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "hasRedEx :: Tm -> Bool\n", "hasRedEx (Var _) = False\n", "hasRedEx (Lam _ e1) = hasRedEx e1\n", "hasRedEx e@(App e1 e2) = isRedEx e || hasRedEx e1 || hasRedEx e2" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/html": [ "$\\lambda x.x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "False" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$(\\lambda x.x)~(\\lambda x.x)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "True" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda x.(\\lambda x.x)~(\\lambda x.x)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "True" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "e1 = idTm\n", "e2 = App idTm idTm\n", "e3 = (Lam \"x\" e2)\n", "\n", "html . latex $ texTm e1\n", "hasRedEx e1\n", "html . latex $ texTm e2\n", "hasRedEx e2\n", "html . latex $ texTm e3\n", "hasRedEx e3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "참고로 위와 같은 일을 하는 다른 방법으로도 정의할 수 있다.\n", "앞서 정의한 `subTm` 함수로 부분식을 모두 나열하여\n", "그 중 하나라도 주는 식이 있는지 검사하는 `isRedEx` 함수와 함께\n", "표준라이브러리 고차함수 `any`를 활용하면 알아볼 수 있으므로\n", "똑같은 일을 하는 함수를 다음과 같이 정의할 수도 있다." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "True" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "even 3\n", "even 4" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "False" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "True" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "any even [1,3,5,7,9]\n", "any even [1,3,4,7,9]" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "hasRedEx' = any isRedEx . subTm" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/html": [ "$\\lambda x.x$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "False" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$(\\lambda x.x)~(\\lambda x.x)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "True" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\lambda x.(\\lambda x.x)~(\\lambda x.x)$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "True" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "e1 = idTm\n", "e2 = App idTm idTm\n", "e3 = (Lam \"x\" e2)\n", "\n", "html . latex $ texTm e1\n", "hasRedEx' e1\n", "html . latex $ texTm e2\n", "hasRedEx' e2\n", "html . latex $ texTm e3\n", "hasRedEx' e3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "----" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "-- texTm을 적절히 변경하여 함수적용식 (e1 e2)에서\n", "-- 함수 부분인 e1에 빨강 인자 부분인 e2에 파랑 사각형 테두리 추가\n", "texTmColor (Var x) = x\n", "texTmColor (Lam x e) = \"\\\\lambda \" ++ x ++ \".\" ++ texTmColor e\n", "texTmColor (App e1 e2) = box1(tex1 e1) ++ \"~\" ++ box2(tex2 e2)\n", " where\n", " tex1 e@(Lam{}) = paren (texTmColor e)\n", " tex1 t = texTmColor t\n", " tex2 s@(Var{}) = texTmColor s\n", " tex2 s = paren (texTmColor s)\n", " box1 = red . boxed . black\n", " box2 = blue . boxed . black\n", "\n", "color c s = \"\\\\color{\"++c++\"}{\"++s++\"}\"\n", "boxed s = \"\\\\boxed{\"++s++\"}\"\n", "\n", "black = color \"black\"\n", "red = color \"red\"\n", "blue = color \"blue\"" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/html": [ "$(\\lambda f.(\\lambda x.x)~((\\lambda x.x)~(f~f)))~((\\lambda x.x)~(\\lambda x.x))$" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "\\color{red}{\\boxed{\\color{black}{(\\lambda f.\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{f}}}~\\color{blue}{\\boxed{\\color{black}{f}}})}}})}}})}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\lambda x.x)}}})}}}" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\color{red}{\\boxed{\\color{black}{(\\lambda f.\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{f}}}~\\color{blue}{\\boxed{\\color{black}{f}}})}}})}}})}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\lambda x.x)}}})}}}$" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "e1 = Lam \"f\" (App idTm (App idTm (Var \"f\" `App` Var \"f\"))) `App` App idTm idTm\n", "html . latex $ texTm e1\n", "putStr $ texTmColor e1\n", "html . latex $ texTmColor e1" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "-- texTmRedEx :: Tm -> String\n", "-- texTm을 적절히 변경하여 함수적용식 (e1 e2)에서\n", "-- 함수 부분인 e1에 빨강 인자 부분인 e2에 파랑 사각형 테두리 추가\n", "texTmRedEx (Var x) = x\n", "texTmRedEx (Lam x e) = \"\\\\lambda \" ++ x ++ \".\" ++ texTmRedEx e\n", "texTmRedEx e@(App e1 e2) =\n", " if isRedEx e then box1(tex1 e1) ++ \"~\" ++ box2(tex2 e2)\n", " else tex1 e1 ++ \"~\" ++ tex2 e2\n", " where\n", " tex1 e@(Lam{}) = paren (texTmRedEx e)\n", " tex1 t = texTmRedEx t\n", " tex2 s@(Var{}) = texTmRedEx s\n", " tex2 s = paren (texTmRedEx s)\n", " box1 = red . boxed . black\n", " box2 = blue . boxed . black" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "\\color{red}{\\boxed{\\color{black}{(\\lambda f.\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(f~f)}}})}}})}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\lambda x.x)}}})}}}" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "$\\color{red}{\\boxed{\\color{black}{(\\lambda f.\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(f~f)}}})}}})}}}~\\color{blue}{\\boxed{\\color{black}{(\\color{red}{\\boxed{\\color{black}{(\\lambda x.x)}}}~\\color{blue}{\\boxed{\\color{black}{(\\lambda x.x)}}})}}}$" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "e1 = Lam \"f\" (App idTm (App idTm (Var \"f\" `App` Var \"f\"))) `App` App idTm idTm\n", "putStr $ texTmRedEx e1\n", "html. latex $ texTmRedEx e1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "----" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 표준형(normal form)\n", "\n", "표준형은 규칙에 따라 더 이상 줄일 수 있는 부분식을 포함하지 않는 형태의 람다식을 말한다.\n", "구체적으로 $\\beta$-줄이기로 더 이상 줄일 수 있는 부분식이 전혀 포함하지 않는 람다식을 $\\beta$-표준형이라 일컫는다.\n", "\n", "주어진 람다식 $e$에 $\\beta$-줄이기를 반복적으로 적용해 얻을 수 있는 $\\beta$-표준형을\n", "$e$의 $\\beta$-표준형이라 말하는데, 타입없는 람다계산법에서는\n", "주어진 람다식의 $\\beta$-표준형이 존재한다면 유일하다는\n", "**처치-로서 정리(Church-Rosser theorem)**가 성립힌다.\n", "\n", "람다계산법의 처치-로서 정리를 직접 설명하기보다는\n", "우선 직관적으로 처치-로서 정리가 어떤 성질을 의미하는지 덧셈식을 통해 간단히 개념만 알아보자.\n", " \n", "예를 들어 (1 + 2) + (4 + 5) 라는 덧셈식이 있다면 어떤 덧셈을 먼저 하든 관계없이 항상 같은 결과값을 얻는다.\n", "즉 덧셈식에서는 덧셈을 줄여나가는 것에 대한 처치-로서 정리의 성질이 성립한다고 말할 수 있다.\n", "\n", "$(1 + 2) + (4 + 5) ~\\longrightarrow~ 3 + (4 + 5) ~\\longrightarrow~ 3 + 9 ~\\longrightarrow~ 12$\n", "\n", "$(1 + 2) + (4 + 5) ~\\longrightarrow~ (1 + 2) + 9 ~\\longrightarrow~ 3 + 9 ~\\longrightarrow~ 12$\n", "\n", "하지만 타입없는 람다계산법의 경우 계산이 일반적으로 항상 끝난다는 보장이 없다.\n", "즉 어떤 람다식은 표준형이 아예 존재하지 않을 수도 있으며\n", "표준형이 존재하더라도 어떤 줄일식을 먼저 계산하는가에 따라\n", "계산이 끝날 수도 있고 끝나지 않을 수도 있다. 그래서 타입없는\n", "람다계산법에서의 처치-로서 정리는 표준형이 존재하는 식의 경우\n", "표준형에 도달할 수 있는 모든 계산 경로 끝에 있는 표준형이 모두 \"같다\"는 의미이다.\n", "\n", "참고로 표준형이 없는 끝나지 않는 계산을 하는 대표적인 예가 바로 다음과 같은 람다식이다.\n", "\n", "$\n", "\\big((\\lambda x.x~x)~(\\lambda x.x~x)\\big)\n", "\\longrightarrow\n", "\\big((\\lambda x.x~x)~(\\lambda x.x~x)\\big)\n", "\\longrightarrow\n", "~~\\cdots$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## $\\alpha$-변환 ($\\alpha$-conversion), $\\alpha$-동치 ($\\alpha$-equivalence)\n", "\n", "잠깐, 근데 \"같다\"는 게 무엇인지 우리가 아직 정확히 정의하지 않았다.\n", "\n", "일단 확실한 것은 글자 하나도 틀리지 않고 똑같으면 분명히 같은 것이다.\n", "하지만 이것은 너무나 협소한 같음의 정의다.\n", "왜냐하면 $(\\lambda x.x)$와 $(\\lambda y.y)$의 경우\n", "비록 글자 하나하나를 비교하면 다른 점이 있기는 하지만\n", "분명히 똑같은 식이라고 볼 수 있기 때문이다.\n", "$(\\lambda x.x)$에서 함수 인자의 이름을 $x$대신 $y$로 바꾼 함수가 $(\\lambda y.y)$이다.\n", "이렇게 함수 인자의 이름을 일괄적으로 바꿔는 것을 $\\alpha$-변환이라고 하며,\n", "함수 인자 이름만 바꿔나가면 똑같아지는 관계에 있는 람다식들을 $\\alpha$-동치 관계에 있다고 한다.\n", "\n", "## $\\beta$-동치 ($\\beta$-equivalence)\n", "$((\\lambda x.x)~(\\lambda y.y))$와 $((\\lambda y.(\\lambda x.x))~z)$는 $\\alpha$-동치가 아니다.\n", "하지만 이를 $\\beta$-줄이기로 한단계만 계산하면 계산 결과로 나오는 식들이 $\\alpha$-동치임을 알 수 있다.\n", "\n", "$((\\lambda x.x)~(\\lambda y.y)) \\longrightarrow (\\lambda y.y)$\n", "\n", "$((\\lambda y.(\\lambda x.x))~z) \\longrightarrow (\\lambda x.x)$\n", "\n", "\n", "이와 같이 $\\beta$-줄이기를 (일반적으로는 한 걸음만 아니라 여러 걸음으로) 적용해서 같아지는\n", "관계를 $\\beta$-동치라고 한다. 덧셈식으로 비유하자면 ((3+4)+5)와 (2+(5+6))처럼 구조나 생김새가\n", "설령 다르더라도 계산 결과가 같은 관계에 해당한다. 표준형이 있는 람다식끼리 비교하는 경우라면 처치-로서 정리의 성질에\n", "의거해 서로의 표준형을 구해 같은지 알아봄으로써 $\\beta$-동치 관계인지 검사가 가능하다." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Haskell", "language": "haskell", "name": "haskell" }, "language_info": { "codemirror_mode": "ihaskell", "file_extension": ".hs", "name": "haskell", "pygments_lexer": "Haskell", "version": "8.6.5" } }, "nbformat": 4, "nbformat_minor": 4 }