From 63e4abee1c9332b5c0d5d71e6ef8d0ffe0efe6c2 Mon Sep 17 00:00:00 2001 From: SW Date: Sun, 23 Aug 2026 16:36:19 +0900 Subject: [PATCH 1/3] added first Korean translation --- .i18n/ko/Game.json | 892 +++++++ .i18n/ko/Game.po | 6249 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 7141 insertions(+) create mode 100644 .i18n/ko/Game.json create mode 100644 .i18n/ko/Game.po diff --git a/.i18n/ko/Game.json b/.i18n/ko/Game.json new file mode 100644 index 00000000..c4981ebf --- /dev/null +++ b/.i18n/ko/Game.json @@ -0,0 +1,892 @@ +{"≤ World": "≤ 월드", + "≠": "≠", + "§0 is the natural numbers, just called \\\\\"numbers\\\\\" in this game. It's\ndefined via two rules:\n\n* §1 (zero is a number)\n* §2 (the successor of a number is a number)\n\n## Game Implementation\n\n*The game uses its own copy of the natural numbers, called §3 with notation §4.\nIt is distinct from the Lean natural numbers §5, which should hopefully\nnever leak into the natural number game.*": + "§0는 자연수이며, 이 게임에서는 그냥 \\\"수\\\"라고 부릅니다. 자연수는 다음 두 규칙으로 정의됩니다.\n\n* §1 (0은 수이다)\n* §2 (수의 successor도 수이다)\n\n## 게임 구현\n\n*이 게임은 §3이라는 자체 자연수 타입을 사용하고 이를 §4로 표기합니다. 이는 Lean의 자연수 §5와는 별개이며, Lean의 자연수가 Natural Number Game 안으로 새어 들어오는 일은 없기를 바랍니다.*", + "§0 is a proof that §1.\n\nNote that when Lean says §2 it means §3.\n\nNote that §4 cannot be proved by \\\\\"pure thought\\\\\":\nfor example subtraction is not associative, as §5 is not\nequal to §6.": + "§0는 §1의 증명입니다.\n\nLean이 §2라고 할 때는 §3을 뜻합니다.\n\n§4는 \"순수한 생각\"만으로 증명할 수 없다는 점에 주의하세요. 예를 들어 뺄셈은 결합법칙을 만족하지 않으며 §5와 §6는 같지 않습니다.", + "§0 is a proof that §1.\n\n## Summary\n\n§2 is really a function, which\neats a number, and returns a proof of a theorem\nabout that number. For example §3 is\na proof that §4.\n\nThe §5 tactic will accept §6\nand will try to figure out which number you omitted\nto input.\n\n## Details\n\nA mathematician sometimes thinks of §7\nas \\\\\"one thing\\\\\", namely a proof of §8.\nThis is just another way of saying that it's a function which\ncan eat any number n and will return a proof that §9.": + "§0는 §1의 증명입니다.\n\n## 요약\n\n§2는 사실 함수입니다. 수 하나를 받아 그 수에 관한 정리의 증명을 반환합니다. 예를 들어 §3은 §4의 증명입니다.\n\n§5 tactic은 §6을 받아 사용자가 생략한 입력 수가 무엇인지 알아내려 합니다.\n\n## 자세한 설명\n\n수학자는 때때로 §7을 §8의 증명이라는 \"하나의 것\"으로 생각합니다. 이는 임의의 수 n을 입력받아 §9의 증명을 돌려주는 함수라는 말과 같습니다.", + "zero_pow_zero": "zero_pow_zero", + "zero_pow_succ": "zero_pow_succ", + "zero_ne_succ": "zero_ne_succ", + "zero_mul": "zero_mul", + "zero_add": "zero_add", + "x ≤ y or y ≤ x": "x ≤ y 또는 y ≤ x", + "x ≤ y and y ≤ z implies x ≤ z": "x ≤ y이고 y ≤ z이면 x ≤ z", + "x ≤ y and y ≤ x implies x = y": "x ≤ y이고 y ≤ x이면 x = y입니다.", + "x ≤ succ x": "x ≤ succ x", + "x ≤ 1": "x ≤ 1", + "x ≤ 0 → x = 0": "x ≤ 0 → x = 0", + "two_mul": "two_mul", + "try rewriting `add_zero`.": "`add_zero`를 rewrite해 보세요.", + "the simplest approach": "가장 간단한 접근", + "the rw tactic": "rw tactic", + "succ_mul": "succ_mul", + "succ_inj : the successor function is injective": + "succ_inj : successor 함수는 단사입니다.", + "succ_add": "succ_add", + "succ x ≤ succ y → x ≤ y": "succ x ≤ succ y → x ≤ y", + "rewriting backwards": "거꾸로 rewriting하기", + "pred": "pred", + "pow_two": "pow_two", + "pow_pow": "pow_pow", + "pow_one": "pow_one", + "pow_add": "pow_add", + "one_pow": "one_pow", + "one_mul": "one_mul", + "one_le_of_ne_zero": "one_le_of_ne_zero", + "mul_right_eq_self": "mul_right_eq_self", + "mul_right_eq_one": "mul_right_eq_one", + "mul_pow": "mul_pow", + "mul_one": "mul_one", + "mul_ne_zero": "mul_ne_zero", + "mul_left_ne_zero": "mul_left_ne_zero", + "mul_left_cancel": "mul_left_cancel", + "mul_le_mul_right": "mul_le_mul_right", + "mul_eq_zero": "mul_eq_zero", + "mul_comm": "mul_comm", + "mul_assoc": "mul_assoc", + "mul_add": "mul_add", + "making life simple": "간단하게 만들기", + "making life easier": "더 쉽게 만들기", + "level completed! 🎉": "level 완료! 🎉", + "level completed with warnings… 🎭": "level 완료(그러나 경고가 남은…) 🎭", + "le_two": "le_two", + "le_mul_right": "le_mul_right", + "is_zero": "is_zero", + "intro practice": "intro 연습", + "intro": "intro", + "intermediate goal solved! 🎉": "중간 goal 해결! 🎉", + "eq_succ_of_ne_zero": "eq_succ_of_ne_zero", + "decide again": "decide 다시 사용하기", + "decide": "decide", + "add_succ": "add_succ", + "add_sq": "add_sq", + "add_right_eq_zero": "add_right_eq_zero", + "add_right_eq_self": "add_right_eq_self", + "add_right_comm": "add_right_comm", + "add_right_cancel": "add_right_cancel", + "add_mul": "add_mul", + "add_left_eq_zero": "add_left_eq_zero", + "add_left_eq_self": "add_left_eq_self", + "add_left_comm": "add_left_comm", + "add_left_cancel": "add_left_cancel", + "add_comm (level boss)": "add_comm (level boss)", + "add_assoc (associativity of addition)": "add_assoc (덧셈의 결합법칙)", + "`ℕ` is the natural numbers, just called \\\"numbers\\\" in this game. It's\ndefined via two rules:\n\n* `0 : ℕ` (zero is a number)\n* `succ (n : ℕ) : ℕ` (the successor of a number is a number)\n\n## Game Implementation\n\n*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\nIt is distinct from the Lean natural numbers `Nat`, which should hopefully\nnever leak into the natural number game.*": + "`ℕ` is the natural numbers, just called \\\"numbers\\\" in this game. It's\ndefined via two rules:\n\n* `0 : ℕ` (zero is a number)\n* `succ (n : ℕ) : ℕ` (the successor of a number is a number)\n\n## Game Implementation\n\n*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\nIt is distinct from the Lean natural numbers `Nat`, which should hopefully\nnever leak into the natural number game.*", + "`zero_ne_succ n` is the proof that `0 ≠ succ n`.\n\nIn Lean, `a ≠ b` is *defined to mean* `a = b → False`. Hence\n`zero_ne_succ n` is really a proof of `0 = succ n → False`.\nHere `False` is a generic false statement. This means that\nyou can `apply zero_ne_succ at h` if `h` is a proof of `0 = succ n`.": + "`zero_ne_succ n`는 `0 ≠ succ n`의 증명입니다.\n\nLean에서 `a ≠ b`는 *`a = b → False`을 뜻하도록 정의*되어 있습니다. 따라서 `zero_ne_succ n`는 실제로 `0 = succ n → False`의 증명입니다. 여기서 `False`는 일반적인 거짓 명제입니다. 즉 `h`이 `0 = succ n`의 증명이라면 `apply zero_ne_succ at h`할 수 있습니다.", + "`zero_ne_one` is a proof of `0 ≠ 1`.": "`zero_ne_one`는 `0 ≠ 1`의 증명입니다.", + "`zero_mul m` is the proof that `0 * m = 0`.\n\nNote: `zero_mul` is a `simp` lemma.": + "`zero_mul m`는 `0 * m = 0`의 증명입니다.\n\n참고: `zero_mul`는 `simp` lemma입니다.", + "`zero_le x` is a proof that `0 ≤ x`.": "`zero_le x`는 `0 ≤ x`.의 증명입니다.", + "`zero_add n` is the proof of `0 + n = n`.\n\n`zero_add` is a `simp` lemma, because replacing `0 + n` by `n`\nis almost always what you want to do if you're simplifying an expression.": + "`zero_add n`는 `0 + n = n`의 증명입니다.\n\n`zero_add`는 `simp` lemma입니다. 식을 단순화할 때 `0 + n`를 `n`로 바꾸는 것은 거의 항상 우리가 원하는 일이기 때문입니다.", + "`xyzzy` is an ancient magic spell, believed to be the origin of the\nmodern word `sorry`. The game won't complain - or notice - if you\nprove anything with `xyzzy`.": + "`xyzzy`는 고대의 마법 주문으로, 현대의 단어 `sorry`의 기원이라고 전해집니다. `xyzzy`로 무엇을 증명하든 게임은 불평하지도, 알아차리지도 못합니다.", + "`two_mul m` is the proof that `2 * m = m + m`.": + "`two_mul m`는 `2 * m = m + m`의 증명입니다.", + "`two_eq_succ_one` is a proof of `2 = succ 1`.": + "`two_eq_succ_one`는 `2 = succ 1`의 증명입니다.", + "`three_eq_succ_two` is a proof of `3 = succ 2`.": + "`three_eq_succ_two`는 `3 = succ 2`의 증명입니다.", + "`tauto` is good enough to solve this goal.": "`tauto`만으로도 이 목표를 해결하기에 충분합니다.", + "`succ_ne_zero a` is a proof of `succ a ≠ 0`.": + "`succ_ne_zero a`는 `succ a ≠ 0`의 증명입니다.", + "`succ_ne_succ m n` is the proof that `m ≠ n → succ m ≠ succ n`.": + "`succ_ne_succ m n`는 `m ≠ n → succ m ≠ succ n`의 증명입니다.", + "`succ_mul a b` is the proof that `succ a * b = a * b + b`.\n\nIt could be deduced from `mul_succ` and `mul_comm`, however this argument\nwould be circular because the proof of `mul_comm` uses `mul_succ`.": + "`succ_mul a b`는 `succ a * b = a * b + b`의 증명입니다.\n\n`mul_succ`와 `mul_comm`에서 이끌어낼 수도 있지만, `mul_comm`의 증명이 `mul_succ`를 사용하므로 그렇게 하면 순환 논증이 됩니다.", + "`succ_le_succ x y` is a proof that if `succ x ≤ succ y` then `x ≤ y`.": + "`succ_le_succ x y`는 `succ x ≤ succ y`이면 `x ≤ y`라는 것의 증명입니다.", + "`succ_eq_add_one n` is the proof that `succ n = n + 1`.": + "`succ_eq_add_one n`는 `succ n = n + 1`의 증명입니다.", + "`succ_add a b` is a proof that `succ a + b = succ (a + b)`.": + "`succ_add a b`는 `succ a + b = succ (a + b)`.의 증명입니다.", + "`rw [one_eq_succ_zero]` will do this.": + "`rw [one_eq_succ_zero]`가 이 일을 해 줍니다.", + "`rw [add_zero]` will change `b + 0` into `b`.": + "`rw [add_zero]`는 `b + 0`을 `b`로 바꿉니다.", + "`rw [add_comm b d]`.": "`rw [add_comm b d]`.", + "`pred_succ n` is a proof of `pred (succ n) = n`.": + "`pred_succ n`는 `pred (succ n) = n`의 증명입니다.", + "`pow_zero a : a ^ 0 = 1` is one of the two axioms\ndefining exponentiation in this game.": + "`pow_zero a : a ^ 0 = 1`는 이 게임에서 거듭제곱을 정의하는 두 공리 중 하나입니다.", + "`pow_two a` says that `a ^ 2 = a * a`.": "`pow_two a`는 `a ^ 2 = a * a`압니다.", + "`pow_succ a b : a ^ (succ b) = a ^ b * a` is one of the\ntwo axioms defining exponentiation in this game.": + "`pow_succ a b : a ^ (succ b) = a ^ b * a`는 이 게임에서 거듭제곱을 정의하는 두 공리 중 하나입니다.", + "`pow_pow a m n` is a proof that $(a^m)^n=a^{mn}.$": + "`pow_pow a m n`는 $(a^m)^n=a^{mn}.$의 증명입니다.", + "`pow_one a` says that `a ^ 1 = a`.\n\nNote that this is not quite true by definition: `a ^ 1` is\ndefined to be `a ^ 0 * a` so it's `1 * a`, and to prove\nthat this is equal to `a` you need to use induction somewhere.": + "`pow_one a`는 `a ^ 1 = a`이라고 말합니다.\n\n정의만으로 바로 참인 것은 아닙니다. `a ^ 1`는 `a ^ 0 * a`으로 정의되므로 `1 * a`이고, 이것이 `a`와 같음을 보이려면 어딘가에서 귀납법을 사용해야 합니다.", + "`pow_add a m n` is a proof that $a^{m+n}=a^ma^n.$": + "`pow_add a m n`는 $a^{m+n}=a^ma^n.$의 증명입니다.", + "`one_pow n` is a proof that $1^n=1$.": "`one_pow n`는 $1^n=1$.의 증명입니다.", + "`one_ne_zero` is a proof that `1 ≠ 0`.": "`one_ne_zero`는 `1 ≠ 0`.의 증명입니다.", + "`one_mul m` is the proof `1 * m = m`.": "`one_mul m`는 `1 * m = m`의 증명입니다.", + "`one_le_of_ne_zero a` is a proof that `a ≠ 0 → 1 ≤ a`.": + "`one_le_of_ne_zero a`는 `a ≠ 0 → 1 ≤ a`.의 증명입니다.", + "`one_eq_succ_zero` is a proof of `1 = succ 0`.": + "`one_eq_succ_zero`는 `1 = succ 0`의 증명입니다.", + "`nth_rewrite 2 [two_eq_succ_one]` is I think quicker than `rw [two_eq_succ_one]`.": + "제 생각에는 `nth_rewrite 2 [two_eq_succ_one]`가 `rw [two_eq_succ_one]`보다 빠릅니다.", + "`mul_zero m` is the proof that `m * 0 = 0`.": + "`mul_zero m`는 `m * 0 = 0`의 증명입니다.", + "`mul_succ a b` is the proof that `a * succ b = a * b + a`.": + "`mul_succ a b`는 `a * succ b = a * b + a`의 증명입니다.", + "`mul_right_eq_self a b` is a proof that if `a ≠ 0` and `a * b = a` then `b = 1`.": + "`mul_right_eq_self a b`는 `a ≠ 0`이고 `a * b = a`이면 `b = 1`이라는 것의 증명입니다.", + "`mul_right_eq_one a b` is a proof that `a * b = 1 → a = 1`.": + "`mul_right_eq_one a b`는 `a * b = 1 → a = 1`.의 증명입니다.", + "`mul_pow a b n` is a proof that $(ab)^n=a^nb^n.$": + "`mul_pow a b n`는 $(ab)^n=a^nb^n.$의 증명입니다.", + "`mul_one m` is the proof that `m * 1 = m`.": + "`mul_one m`는 `m * 1 = m`의 증명입니다.", + "`mul_ne_zero a b` is a proof that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`.": + "`mul_ne_zero a b`는 `a ≠ 0`이고 `b ≠ 0`이면 `a * b ≠ 0`이라는 것의 증명입니다.", + "`mul_left_ne_zero a b` is a proof that `a * b ≠ 0 → b ≠ 0`.": + "`mul_left_ne_zero a b`는 `a * b ≠ 0 → b ≠ 0`.의 증명입니다.", + "`mul_left_cancel a b c` is a proof that if `a ≠ 0` and `a * b = a * c` then `b = c`.": + "`mul_left_cancel a b c`는 `a ≠ 0`이고 `a * b = a * c`이면 `b = c`이라는 것의 증명입니다.", + "`mul_le_mul_right a b t` is a proof that `a ≤ b → a * t ≤ b * t`.": + "`mul_le_mul_right a b t`는 `a ≤ b → a * t ≤ b * t`.의 증명입니다.", + "`mul_eq_zero a b` is a proof that if `a * b = 0` then `a = 0` or `b = 0`.": + "`mul_eq_zero a b`는 `a * b = 0`이면 `a = 0` 또는 `b = 0`이라는 것의 증명입니다.", + "`mul_comm` is the proof that multiplication is commutative. More precisely,\n`mul_comm a b` is the proof that `a * b = b * a`.": + "`mul_comm`는 곱셈이 가환이라는 것의 증명입니다. 더 정확히는 `mul_comm a b`이 `a * b = b * a`의 증명입니다.", + "`mul_assoc a b c` is a proof that `(a * b) * c = a * (b * c)`.\n\nNote that when Lean says `a * b * c` it means `(a * b) * c`.\n\nNote that `(a * b) * c = a * (b * c)` cannot be proved by \\\"pure thought\\\":\nfor example subtraction is not associative, as `(6 - 2) - 1` is not\nequal to `6 - (2 - 1)`.": + "`mul_assoc a b c`는 `(a * b) * c = a * (b * c)`.\n\nNote that when Lean says `a * b * c` it means `(a * b) * c`.\n\nNote that `(a * b) * c = a * (b * c)` cannot be proved by \\\"pure thought\\\":\nfor example subtraction is not associative, as `(6 - 2) - 1` is not\nequal to `6 - (2 - 1)`.의 증명입니다.", + "`le_zero x` is a proof of the implication `x ≤ 0 → x = 0`.": + "`le_zero x`는 함의 `x ≤ 0 → x = 0`의 증명입니다.", + "`le_zero x` is a proof of `x ≤ 0 → x = 0`.": + "`le_zero x`는 `x ≤ 0 → x = 0`의 증명입니다.", + "`le_two x` is a proof that if `x ≤ 2` then `x = 0` or `x = 1` or `x = 2`.": + "`le_two x`는 `x ≤ 2`이면 `x = 0` 또는 `x = 1` 또는 `x = 2`라는 것의 증명입니다.", + "`le_trans x y z` is a proof that if `x ≤ y` and `y ≤ z` then `x ≤ z`.\nMore precisely, it is a proof that `x ≤ y → (y ≤ z → x ≤ z)`. In words,\nIf $x \\le y$ then (pause) if $y \\le z$ then $x \\le z$.\n\n## A note on associativity\n\nIn Lean, `a + b + c` means `(a + b) + c`, because `+` is left associative. However\n`→` is right associative. This means that `x ≤ y → y ≤ z → x ≤ z` in Lean means\nexactly that `≤` is transitive. This is different to how mathematicians use\n$P \\implies Q \\implies R$; for them, this usually means that $P \\implies Q$\nand $Q \\implies R$.": + "`le_trans x y z`는 `x ≤ y`이고 `y ≤ z`이면 `x ≤ z`이라는 것의 증명입니다. 더 정확히는 `x ≤ y → (y ≤ z → x ≤ z)`의 증명입니다. 말로 하면 \"$x \\le y$이면, (잠깐 쉬고) $y \\le z$이면 $x \\le z$\"입니다.\n\n## 결합법칙에 관한 주의\n\nLean에서 `a + b + c`은 `(a + b) + c`를 뜻합니다. `x ≤ y`0이 왼쪽 결합이기 때문입니다. 하지만 `x ≤ y`1은 오른쪽 결합입니다. 따라서 Lean에서 `x ≤ y`2는 정확히 `x ≤ y`3이 추이적이라는 뜻입니다. 이는 수학자들이 `x ≤ y`4를 쓰는 방식과 다릅니다. 수학자에게는 보통 `x ≤ y`5이고 `x ≤ y`6이라는 뜻입니다.", + "`le_total x y` is a proof that `x ≤ y` or `y ≤ x`.": + "`le_total x y`는 `x ≤ y` 또는 `y ≤ x`의 증명입니다.", + "`le_succ_self x` is a proof that `x ≤ succ x`.": + "`le_succ_self x`는 `x ≤ succ x`.의 증명입니다.", + "`le_refl x` is a proof of `x ≤ x`.\n\nThe reason for the name is that this lemma is \"reflexivity of $\\le$\"": + "`le_refl x`는 `x ≤ x`의 증명입니다.\n\n이 이름은 이 lemma가 \"$\\le$의 반사성(reflexivity)\"을 나타내기 때문에 붙었습니다.", + "`le_one x` is a proof that if `x ≤ 1` then `x = 0` or `x = 1`.": + "`le_one x`는 `x ≤ 1`이면 `x = 0` 또는 `x = 1`이라는 것의 증명입니다.", + "`le_mul_right a b` is a proof that `a * b ≠ 0 → a ≤ a * b`.\n\nIt's one way of saying that a divisor of a positive number\nhas to be at most that number.": + "`le_mul_right a b`는 `a * b ≠ 0 → a ≤ a * b`의 증명입니다.\n\n양수의 약수는 그 수 이하이어야 한다는 사실을 표현하는 한 방법입니다.", + "`le_antisymm x y` is a proof that if `x ≤ y` and `y ≤ x` then `x = y`.": + "`le_antisymm x y`는 `x ≤ y`이고 `y ≤ x`이면 `x = y`이라는 것의 증명입니다.", + "`is_zero_zero` is a proof of `is_zero 0 = True`.": + "`is_zero_zero`는 `is_zero 0 = True`의 증명입니다.", + "`is_zero_succ a` is a proof of `is_zero (succ a) = False`.": + "`is_zero_succ a`는 `is_zero (succ a) = False`의 증명입니다.", + "`four_eq_succ_three` is a proof of `4 = succ 3`.": + "`four_eq_succ_three`는 `4 = succ 3`의 증명입니다.", + "`exact` practice.": "`exact` 연습.", + "`eq_succ_of_ne_zero a` is a proof that `a ≠ 0 → ∃ n, a = succ n`.": + "`eq_succ_of_ne_zero a`는 `a ≠ 0 → ∃ n, a = succ n`.의 증명입니다.", + "`add_zero c` is a proof of `c + 0 = c` so that was what got rewritten.\nYou can now change `b + 0` to `b` with `rw [add_zero]` or `rw [add_zero b]`. You\ncan usually stick to `rw [add_zero]` unless you need real precision.": + "`add_zero c`가 `c + 0 = c`의 증명이므로 그 부분이 rewrite되었습니다. 이제 `rw [add_zero]`나 `rw [add_zero b]`를 사용해 `b + 0`를 `b`으로 바꿀 수 있습니다. 아주 정밀하게 조작할 필요가 없다면 보통 `rw [add_zero]`만 써도 됩니다.", + "`add_zero a` is a proof that `a + 0 = a`.\n\n## Summary\n\n`add_zero` is really a function, which\neats a number, and returns a proof of a theorem\nabout that number. For example `add_zero 37` is\na proof that `37 + 0 = 37`.\n\nThe `rw` tactic will accept `rw [add_zero]`\nand will try to figure out which number you omitted\nto input.\n\n## Details\n\nA mathematician sometimes thinks of `add_zero`\nas \\\"one thing\\\", namely a proof of $\\forall n ∈ ℕ, n + 0 = n$.\nThis is just another way of saying that it's a function which\ncan eat any number n and will return a proof that `n + 0 = n`.": + "`add_zero a`는 `a + 0 = a`.\n\n## Summary\n\n`add_zero` is really a function, which\neats a number, and returns a proof of a theorem\nabout that number. For example `add_zero 37` is\na proof that `37 + 0 = 37`.\n\nThe `rw` tactic will accept `rw [add_zero]`\nand will try to figure out which number you omitted\nto input.\n\n## Details\n\nA mathematician sometimes thinks of `add_zero`\nas \\\"one thing\\\", namely a proof of $\\forall n ∈ ℕ, n + 0 = n$.\nThis is just another way of saying that it's a function which\ncan eat any number n and will return a proof that `n + 0 = n`.의 증명입니다.", + "`add_succ a b` is the proof of `a + succ b = succ (a + b)`.": + "`add_succ a b`는 `a + succ b = succ (a + b)`의 증명입니다.", + "`add_sq a b` is the statement that $(a+b)^2=a^2+b^2+2ab.$": + "`add_sq a b`는 $(a+b)^2=a^2+b^2+2ab.$이라는 명제입니다.", + "`add_right_eq_self x y` is the theorem that $x + y = x\\implies y=0.$\nTwo ways to do it spring to mind; I'll mention them when you've solved it.": + "`add_right_eq_self x y`는 $x + y = x\\implies y=0.$이라는 정리입니다. 두 가지 방법이 떠오르는데, 해결하고 나면 말씀드리겠습니다.", + "`add_right_eq_self x y` is the theorem that $x + y = x \\implies y=0.$": + "`add_right_eq_self x y`는 $x + y = x \\implies y=0.$이라는 정리입니다.", + "`add_right_comm a b c` is a proof that `(a + b) + c = (a + c) + b`\n\nIn Lean, `a + b + c` means `(a + b) + c`, so this result gets displayed\nas `a + b + c = a + c + b`.": + "`add_right_comm a b c`는 `(a + b) + c = (a + c) + b`의 증명입니다.\n\nLean에서 `a + b + c`는 `(a + b) + c`을 뜻하므로 이 결과는 `a + b + c = a + c + b`처럼 표시됩니다.", + "`add_right_cancel a b n` is the theorem that $a+n=b+n \\implies a=b.$": + "`add_right_cancel a b n`는 $a+n=b+n \\implies a=b.$이라는 정리입니다.", + "`add_mul` is just as fiddly to prove by induction; but there's a trick\nwhich avoids it. Can you spot it?": + "`add_mul`도 귀납법으로 증명하려면 꽤 번거롭습니다. 하지만 이를 피하는 요령이 하나 있습니다. 찾을 수 있나요?", + "`add_mul a b c` is a proof that $(a+b)c=ac+bc$.": + "`add_mul a b c`는 $(a+b)c=ac+bc$.의 증명입니다.", + "`add_left_eq_self x y` is the theorem that $x + y = y\\implies x=0.$": + "`add_left_eq_self x y`는 $x + y = y\\implies x=0.$이라는 정리입니다.", + "`add_left_eq_self x y` is the theorem that $x + y = y \\implies x=0.$": + "`add_left_eq_self x y`는 $x + y = y \\implies x=0.$이라는 정리입니다.", + "`add_left_comm a b c` is a proof that `a + (b + c) = b + (a + c)`.": + "`add_left_comm a b c`는 `a + (b + c) = b + (a + c)`.의 증명입니다.", + "`add_left_cancel a b n` is the theorem that $n+a=n+b\\implies a=b$.\nYou can prove it by induction on `n` or you can deduce it from `add_right_cancel`.": + "`add_left_cancel a b n`는 $n+a=n+b\\implies a=b$이라는 정리입니다. `n`에 대해 귀납해도 되고 `add_right_cancel`에서 이끌어내도 됩니다.", + "`add_left_cancel a b n` is the theorem that $n+a=n+b \\implies a=b.$": + "`add_left_cancel a b n`는 $n+a=n+b \\implies a=b.$이라는 정리입니다.", + "`add_comm b c` is a proof that `b + c = c + b`. But if your goal\nis `a + b + c = a + c + b` then `rw [add_comm b c]` will not\nwork! Because the goal means `(a + b) + c = (a + c) + b` so there\nis no `b + c` term *directly* in the goal.\n\nUse associativity and commutativity to prove `add_right_comm`.\nYou don't need induction. `add_assoc` moves brackets around,\nand `add_comm` moves variables around.\n\nRemember that you can do more targeted rewrites by\nadding explicit variables as inputs to theorems. For example `rw [add_comm b]`\nwill only do rewrites of the form `b + ? = ? + b`, and `rw [add_comm b c]`\nwill only do rewrites of the form `b + c = c + b`.": + "`add_comm b c`는 `b + c = c + b`의 증명입니다. 하지만 goal이 `a + b + c = a + c + b`라면 `rw [add_comm b c]`은 작동하지 않습니다! goal의 뜻이 `(a + b) + c = (a + c) + b`이므로 goal 안에 `b + c` 항이 *직접* 나타나지 않기 때문입니다.\n\n결합법칙과 가환법칙을 이용해 `add_right_comm`을 증명하세요. 귀납법은 필요 없습니다. `add_assoc`은 괄호를 옮기고 `add_comm`은 변수의 순서를 바꿉니다.\n\n정리를 적용할 때 변수를 명시하면 더 정밀한 rewrite를 할 수 있다는 점을 기억하세요. 예를 들어 `rw [add_comm b]`는 `b + c = c + b`0 꼴만 rewrite하고, `b + c = c + b`1은 `b + c = c + b`2 꼴만 rewrite합니다.", + "`add_comm a b` is a proof of `a + b = b + a`.": + "`add_comm a b`는 `a + b = b + a`의 증명입니다.", + "`add_assoc a b c` is a proof\nthat `(a + b) + c = a + (b + c)`. Note that in Lean `(a + b) + c` prints\nas `a + b + c`, because the notation for addition is defined to be left\nassociative.": + "`add_assoc a b c`는 `(a + b) + c = a + (b + c)`의 증명입니다. Lean에서는 덧셈 표기가 왼쪽 결합으로 정의되어 있기 때문에 `(a + b) + c`가 `a + b + c`처럼 출력됩니다.", + "`a ≤ b` is *notation* for `∃ c, b = a + c`. This \"backwards E\"\nmeans \"there exists\". So `a ≤ b` means that there exists\na number `c` such that `b = a + c`. This definition works\nbecause there are no negative numbers in this game.\n\nTo *prove* an \"exists\" statement, use the `use` tactic.\nLet's see an example.": + "`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다. 이 \"거꾸로 된 E\"는 \"존재한다\"는 뜻입니다. 따라서 `a ≤ b`는 `b = a + c`를 만족하는 수 `c`가 존재한다는 뜻입니다. 이 게임에는 음수가 없으므로 이 정의가 작동합니다.\n\n\"존재한다\"는 명제를 *증명*하려면 `use` tactic을 사용합니다. 예시를 봅시다.", + "`a ≤ b` is *notation* for `∃ c, b = a + c`.\n\nBecause this game doesn't have negative numbers, this definition\nis mathematically valid.\n\nThis means that if you have a goal of the form `a ≤ b` you can\nmake progress with the `use` tactic, and if you have a hypothesis\n`h : a ≤ b`, you can make progress with `cases h with c hc`.": + "`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다.\n\n이 게임에는 음수가 없으므로 이 정의는 수학적으로 타당합니다.\n\n따라서 `a ≤ b` 꼴의 goal이 있으면 `use` tactic으로 진행할 수 있고, 가정 `h : a ≤ b`가 있으면 `cases h with c hc`로 진행할 수 있습니다.", + "`a ≠ b` is *notation* for `(a = b) → False`.\n\nThe reason this is mathematically\nvalid is that if `P` is a true-false statement then `P → False`\nis the logical opposite of `P`. Indeed `True → False` is false,\nand `False → False` is true!\n\nThe upshot of this is that you can treat `a ≠ b` in exactly\nthe same way as you treat any implication `P → Q`. For example,\nif your *goal* is of the form `a ≠ b` then you can make progress\nwith `intro h`, and if you have a hypothesis `h` of the\nform `a ≠ b` then you can `apply h at h1` if `h1` is a proof\nof `a = b`.": + "`a ≠ b`는 `(a = b) → False`의 *다른 표현*입니다.\n\n이것이 수학적으로 타당한 이유는 `P`가 참/거짓 명제라면 `P → False`이 `P`의 논리적 반대이기 때문입니다. 실제로 `True → False`는 거짓이고 `False → False`는 참입니다!\n\n따라서 `a ≠ b`은 다른 함의 `P → Q`과 똑같이 다룰 수 있습니다. 예를 들어 *goal*이 `a ≠ b` 꼴이라면 `(a = b) → False`0으로 진행할 수 있고, `(a = b) → False`2 꼴의 가정 `(a = b) → False`1이 있다면 `(a = b) → False`4가 `(a = b) → False`5의 증명일 때 `(a = b) → False`3할 수 있습니다.", + "`Pow a b`, with notation `a ^ b`, is the usual\n exponentiation of natural numbers. Internally it is\n defined via two axioms:\n\n * `pow_zero a : a ^ 0 = 1`\n\n * `pow_succ a b : a ^ succ b = a ^ b * a`\n\nNote in particular that `0 ^ 0 = 1`.": + "`Pow a b`는 `a ^ b`로 표기하며 자연수의 보통 거듭제곱입니다. 내부적으로는 두 공리로 정의됩니다.\n\n * `pow_zero a : a ^ 0 = 1`\n\n * `pow_succ a b : a ^ succ b = a ^ b * a`\n\n특히 `0 ^ 0 = 1`라는 점에 주의하세요.", + "`Mul a b`, with notation `a * b`, is the usual\n product of natural numbers. Internally it is\n via two axioms:\n\n * `mul_zero a : a * 0 = 0`\n\n * `mul_succ a b : a * succ b = a * b + a`\n\nOther theorems about naturals, such as `zero_mul`,\nare proved by induction from these two basic theorems.": + "`Mul a b`는 `a * b`로 표기하며 자연수의 보통 곱셈입니다. 내부적으로 두 공리로 정의됩니다.\n\n * `mul_zero a : a * 0 = 0`\n\n * `mul_succ a b : a * succ b = a * b + a`\n\n`zero_mul` 같은 자연수에 관한 다른 정리들은 이 두 기본 정리에서 귀납법으로 증명합니다.", + "`Add a b`, with notation `a + b`, is\nthe usual sum of natural numbers. Internally it is defined\nvia the following two hypotheses:\n\n* `add_zero a : a + 0 = a`\n\n* `add_succ a b : a + succ b = succ (a + b)`\n\nOther theorems about naturals, such as `zero_add a : 0 + a = a`, are proved\nby induction using these two basic theorems.": + "`Add a b`는 `a + b`로 표기하며 자연수의 보통 덧셈입니다. 내부적으로는 다음 두 가정으로 정의됩니다.\n\n* `add_zero a : a + 0 = a`\n\n* `add_succ a b : a + succ b = succ (a + b)`\n\n`zero_add a : 0 + a = a` 같은 자연수에 관한 다른 정리들은 이 두 기본 정리를 이용한 귀납법으로 증명합니다.", + "[final boss music]": "[final boss 음악]", + "[dramatic music]. Now are you ready to face the first boss of the game?": + "[극적인 음악]. 이제 게임의 첫 boss를 상대할 준비가 되었나요?", + "[boss battle music]\n\nLook in your inventory to see the proofs you have available.\nThese should be enough.": + "[boss battle 음악]\n\ninventory를 보고 사용할 수 있는 증명들을 확인하세요. 이것이면 충분할 겁니다.", + "You've now seen all the tactics you need to beat the final boss of the game.\nYou can begin the journey towards this boss by entering Multiplication World.\n\nOr you can go off the beaten track and learn some new tactics in Implication\nWorld. These tactics let you prove more facts about addition, such as\nhow to deduce `a = 0` from `x + a = x`.\n\nClick \"Home\" and make your choice.": + "이제 게임의 final boss를 이기는 데 필요한 tactic을 모두 배웠습니다. Multiplication World로 들어가 boss를 향한 여정을 시작할 수 있습니다.\n\n또는 정석 길을 벗어나 Implication World에서 새 tactic을 배울 수도 있습니다. 이 tactic들을 이용하면 `x + a = x`에서 `a = 0`를 이끌어내는 법처럼 덧셈에 관한 더 많은 사실을 증명할 수 있습니다.\n\n\"Home\"을 누르고 선택하세요.", + "You want to use `add_right_eq_zero`, which you already\nproved, but you'll have to start with `symm at` your hypothesis.": + "이미 증명한 `add_right_eq_zero`를 쓰고 싶지만, 먼저 가정에 `symm at`을 적용해야 합니다.", + "You still don't know which way to go, so do `cases «{e}» with a`.": + "아직 어느 쪽으로 가야 할지 모르므로 `cases «{e}» with a`를 하세요.", + "You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey.": + "이제 `2 + 2 = 4`를 증명할 tactic을 충분히 알고 있습니다! 여정을 시작합시다.", + "You might want to think about whether induction\non `a` or `b` is the best idea.": + "`a`와 `b` 중 어느 것에 귀납하는 편이 더 좋은지 생각해 보세요.", + "You can use `rw [zero_add] at «{h}»` to rewrite at `«{h}»` instead\nof at the goal.": + "`rw [zero_add] at «{h}»`를 사용하면 goal이 아니라 `«{h}»`에서 rewrite할 수 있습니다.", + "You can start a proof by induction on `n` by typing:\n`induction n with d hd`.": + "`n`에 대한 귀납 증명은 다음처럼 시작할 수 있습니다:\n`induction n with d hd`.", + "You can read more about the `decide` tactic by clicking\non it in the top right.": + "오른쪽 위에서 `decide` tactic을 클릭하면 자세한 설명을 읽을 수 있습니다.", + "You can put a `←` in front of any theorem provided to `rw` to rewrite\nthe other way around. Look at the docs for `rw` for an explanation. Type `←` with `\\l`.": + "`rw`에 주는 어떤 정리 앞에도 `←`를 붙이면 반대 방향으로 rewrite할 수 있습니다. 설명은 `rw` 문서를 보세요. `←`은 `\\l`로 입력합니다.", + "You can prove $1\\times m=m$ in at least three ways.\nEither by induction, or by using `succ_mul`, or\nby using commutativity. Which do you think is quickest?": + "$1\\times m=m$는 적어도 세 가지 방법으로 증명할 수 있습니다. 귀납법을 쓰거나, `succ_mul`을 쓰거나, 가환성을 이용할 수 있습니다. 어느 방법이 가장 빠를까요?", + "You can probably take it from here.": "이제부터는 아마 스스로 할 수 있을 겁니다.", + "You can now finish with `exact h`.": "이제 `exact h`로 마무리할 수 있습니다.", + "You can now `apply mul_left_cancel at h`": + "이제 `apply mul_left_cancel at h`를 할 수 있습니다.", + "You can make your own tactics in Lean.\nThis code here\n```\nmacro \"simp_add\" : tactic => `(tactic|(\n simp only [add_assoc, add_left_comm, add_comm]))\n```\nwas used to create a new tactic `simp_add`, which runs\n`simp only [add_assoc, add_left_comm, add_comm]`.\nTry running `simp_add` to solve this level!": + "Lean에서는 자신만의 tactic을 만들 수 있습니다. 여기의 코드\n```\nmacro \"simp_add\" : tactic => `(tactic|(\n simp only [add_assoc, add_left_comm, add_comm]))\n```\n로 새로운 tactic `simp_add`을 만들었고, 이 tactic은 `simp only [add_assoc, add_left_comm, add_comm]`를 실행합니다. `simp_add`을 실행해서 이 level을 해결해 보세요!", + "You can just mimic the previous proof to do this one -- or you can figure out a way\nof using it.": + "이전 증명을 그대로 흉내 내도 되고, 그 결과를 이용하는 방법을 찾아도 됩니다.", + "You can do induction on any of the three variables. Some choices\nare harder to push through than others. Can you do the inductive step in\n5 rewrites only?": + "세 변수 중 어느 것에 대해서든 귀납할 수 있습니다. 어떤 선택은 다른 선택보다 더 어렵습니다. 귀납 단계를 rewrite 5번만으로 할 수 있나요?", + "Why did we not just define `succ n` to be `n + 1`? Because we have not\neven *defined* addition yet! We'll do that in the next level.": + "왜 `succ n`를 그냥 `n + 1`로 정의하지 않았을까요? 아직 덧셈 자체를 *정의하지 않았기* 때문입니다! 다음 level에서 하겠습니다.", + "What do you think of this two-liner:\n```\nsymm\nexact zero_ne_one\n```\n\n`exact` doesn't just take hypotheses, it will eat any proof which exists\nin the system.": + "이 두 줄짜리 증명은 어떤가요?\n```\nsymm\nexact zero_ne_one\n```\n\n`exact`은 가정만 받는 것이 아니라 시스템에 존재하는 어떤 증명이든 받아들입니다.", + "Well done! You now have enough tools to tackle the main boss of this level.": + "잘했습니다! 이제 이 level의 main boss에 도전할 도구가 충분합니다.", + "Well done!": "잘했습니다!", + "Welcome to tutorial world! In this world we learn the basics\nof proving theorems. The boss level of this world\nis the theorem `2 + 2 = 4`.\n\nYou prove theorems by solving puzzles using tools called *tactics*.\nThe aim is to prove the theorem by applying tactics\nin the right order.\n\nLet's learn some basic tactics. Click on \"Start\" below\nto begin your quest.": + "Tutorial World에 오신 것을 환영합니다! 이 world에서는 정리를 증명하는 기초를 배웁니다. 이 world의 boss level은 정리 `2 + 2 = 4`입니다.\n\n정리는 *tactic*이라는 도구를 이용해 퍼즐을 풀듯 증명합니다. tactic들을 올바른 순서로 적용해 정리를 증명하는 것이 목표입니다.\n\n기본적인 tactic 몇 가지를 배워 봅시다. 아래의 \"Start\"를 눌러 여정을 시작하세요.", + "Welcome to Addition World! In this world we'll learn the `induction` tactic.\nThis will enable us to defeat the boss level of this world, namely `x + y = y + x`.\n\nThe tactics `rw`, `rfl` and `induction` are the only tactics you'll need to\nbeat all the levels in Addition World, Multiplication World, and Power World.\nPower World contains the final boss of the game.\n\nThere are plenty more tactics in this game, but you'll only need to know them if you\nwant to explore the game further (for example if you decide to 100%\nthe game).": + "Addition World에 오신 것을 환영합니다! 이 world에서는 `induction` tactic을 배웁니다. 이를 이용해 이 world의 boss level인 `x + y = y + x`을 쓰러뜨릴 수 있습니다.\n\n`rw`, `rfl`, `induction` 세 tactic만 알면 Addition World, Multiplication World, Power World의 모든 level을 깰 수 있습니다. Power World에는 이 게임의 final boss가 있습니다.\n\n이 게임에는 훨씬 많은 tactic이 있지만, 더 깊이 탐험하고 싶을 때만 필요합니다(예를 들어 게임을 100% 완료하고 싶을 때).", + "We've seen `le_zero`, the proof that if `x ≤ 0` then `x = 0`.\nNow we'll prove that if `x ≤ 1` then `x = 0` or `x = 1`.": + "앞에서 `le_zero`, 즉 `x ≤ 0`이면 `x = 0`라는 증명을 봤습니다. 이제 `x ≤ 1`이면 `x = 0` 또는 `x = 1`라는 것을 증명합니다.", + "We've proved that `x ≤ 0` implies `x = 0`. The last two levels\nin this world will prove which numbers are `≤ 1` and `≤ 2`.\nThis lemma will be helpful for them.": + "`x ≤ 0`가 `x = 0`을 함의함을 증명했습니다. 이 world의 마지막 두 level에서는 어떤 수들이 `≤ 1`와 `≤ 2`인지 증명합니다. 이 lemma가 도움이 됩니다.", + "We've proved that $2+2=4$; in Implication World we'll learn\nhow to prove $2+2\\neq 5$.\n\nIn Addition World we proved *equalities* like $x + y = y + x$.\nIn this second tutorial world we'll learn some new tactics,\nenabling us to prove *implications*\nlike $x+1=4 \\implies x=3.$\n\nWe'll also learn two new fundamental facts about\nnatural numbers, which Peano introduced as axioms.\n\nClick on \"Start\" to proceed.": + "$2+2=4$를 증명했습니다. Implication World에서는 $2+2\\neq 5$을 증명하는 법을 배웁니다.\n\nAddition World에서는 $x + y = y + x$ 같은 *등식*을 증명했습니다. 이 두 번째 tutorial world에서는 새로운 tactic들을 배워 $x+1=4 \\implies x=3.$ 같은 *함의*를 증명할 수 있게 됩니다.\n\n또 페아노가 공리로 도입한 자연수에 관한 새로운 기본 사실 두 가지를 배웁니다.\n\n\"Start\"를 눌러 진행하세요.", + "We've just seen that `0 ^ 0 = 1`, but if `n`\nis a successor, then `0 ^ n = 0`. We prove that here.": + "방금 `0 ^ 0 = 1`를 보았습니다. 하지만 `n`이 successor라면 `0 ^ n = 0`입니다. 여기서 이를 증명합니다.", + "We've been adding up two numbers; in this level we will add up three.\n\n What does $x+y+z$ *mean*? It could either mean $(x+y)+z$, or it\n could mean $x+(y+z)$. In Lean, $x+y+z$ means $(x+y)+z$.\n\n But why do we care which one it means; $(x+y)+z$ and $x+(y+z)$ are *equal*!\n\n That's true, but we didn't prove it yet. Let's prove it now by induction.": + "지금까지는 수 두 개를 더했습니다. 이번 level에서는 세 개를 더합니다.\n\n$x+y+z$는 무슨 *뜻*일까요? $(x+y)+z$을 뜻할 수도 있고 $x+(y+z)$를 뜻할 수도 있습니다. Lean에서 $x+y+z$은 $(x+y)+z$를 뜻합니다.\n\n그런데 어느 쪽인지 왜 신경 써야 할까요? $(x+y)+z$와 $x+(y+z)$는 *같은데요!*\n\n맞습니다. 하지만 아직 그 사실을 증명하지 않았습니다. 이제 귀납법으로 증명해 봅시다.", + "We're going to change that `False` into `True`. Start by changing it into\n`is_zero (succ a)` by executing `rw [← is_zero_succ a]`.": + "`False`를 `True`로 바꿀 겁니다. 먼저 `rw [← is_zero_succ a]`을 실행해 `False`를 `is_zero (succ a)`로 바꾸세요.", + "We'll need this lemma to prove that two is prime!\n\nYou'll need to know that `∨` is right associative. This means that\n`x = 0 ∨ x = 1 ∨ x = 2` actually means `x = 0 ∨ (x = 1 ∨ x = 2)`.\nThis affects how `left` and `right` work.": + "2가 소수라는 것을 증명하려면 이 lemma가 필요합니다!\n\n`∨`가 오른쪽 결합이라는 점을 알아야 합니다. 즉 `x = 0 ∨ x = 1 ∨ x = 2`은 실제로 `x = 0 ∨ (x = 1 ∨ x = 2)`를 뜻합니다. 이 때문에 `left`과 `right`의 작동 방식도 달라집니다.", + "We'd like to prove `2 + 2 = 4` but right now\nwe can't even *state* it\nbecause we haven't yet defined addition.\n\n## Defining addition.\n\nHow are we going to add $37$ to an arbitrary number $x$? Well,\nthere are only two ways to make numbers in this game: $0$\nand successors. So to define `37 + x` we will need\nto know what `37 + 0` is and what `37 + succ x` is.\nLet's start with adding `0`.\n\n### Adding 0\n\nTo make addition agree with our intuition, we should *define* `37 + 0`\nto be `37`. More generally, we should define `a + 0` to be `a` for\nany number `a`. The name of this proof in Lean is `add_zero a`.\nFor example `add_zero 37` is a proof of `37 + 0 = 37`,\n`add_zero x` is a proof of `x + 0 = x`, and `add_zero` is a proof\nof `? + 0 = ?`.\n\nWe write `add_zero x : x + 0 = x`, so `proof : statement`.": + "`2 + 2 = 4`를 증명하고 싶지만, 우리는 아직 덧셈을 정의하지 않았기 때문에 `2+2`의 의미도 명확하지 않습니다.\n\n## 덧셈 정의하기\n\n임의의 수 $x$에 $37$을 어떻게 더할까요? 이 게임에서 수를 만드는 방법은 $0$과 successor뿐입니다. 따라서 `37 + x`를 정의하려면 `37 + 0`와 `37 + succ x`가 무엇인지 정해야 합니다. 먼저 `0`을 더하는 것부터 시작합시다.\n\n### 0 더하기\n\n덧셈이 우리의 직관과 맞으려면 `37 + 0`을 `37`로 “정의”해야 합니다. 더 일반적으로는 모든 수 $a$에 대해 $a+0$을 $a$로 정의해야 합니다. Lean에서 이 증명의 이름은 $add_zero a$입니다. 예를 들어 $add_zero x$는 $ x + 0 = x$의 증명이고, $add_zero 37$은 $37 + 0 = 37$의 증명이며, $add_zero$은 $> + 0 = ?$의 증명입니다.\n\n우리는 $add_zero x : x + 0 = x$처럼 씁니다. 따라서 Lean 코드에서 $statement$의 증명을 $poof$라고 하면, $proof:statement$입니다.", + "We want to use `le_mul_right`, but we need a hypothesis `x * y ≠ 0`\nwhich we don't have. Yet. Execute `have h2 : x * y ≠ 0` (you can type `≠` with `\\ne`).\nYou'll be asked to\nprove it, and then you'll have a new hypothesis which you can apply\n`le_mul_right` to.": + "`le_mul_right`를 쓰고 싶지만 필요한 가정 `x * y ≠ 0`이 아직 없습니다. `have h2 : x * y ≠ 0`를 실행하세요(`≠`은 `\\ne`로 입력할 수 있습니다). 그 명제를 증명하라는 goal이 생기고, 증명하고 나면 `le_mul_right`를 적용할 수 있는 새 가정이 생깁니다.", + "We want to reduce this to a hypothesis `b = 0` and a goal `a * b = 0`,\nwhich is logically equivalent but much easier to prove. Remember that `X ≠ 0`\nis notation for `X = 0 → False`. Click on `Show more help!` if you need hints.": + "이를 가정 `b = 0`와 goal `a * b = 0`으로 환원하고 싶습니다. 논리적으로 동치지만 훨씬 증명하기 쉽습니다. `X ≠ 0`가 `X = 0 → False`의 표기법이라는 점을 기억하세요. 힌트가 필요하면 `도움말 더 보기!`를 클릭하세요.", + "We still can't prove `2 + 2 ≠ 5` because we have not talked about the\ndefinition of `≠`. In Lean, `a ≠ b` is *notation* for `a = b → False`.\nHere `False` is a generic false proposition, and `→` is Lean's notation\nfor \"implies\". In logic we learn\nthat `True → False` is false, but `False → False` is true. Hence\n`X → False` is the logical opposite of `X`.\n\nEven though `a ≠ b` does not look like an implication,\nyou should treat it as an implication. The next two levels will show you how.\n\n`False` is a goal which you cannot deduce from a consistent set of assumptions!\nSo if your goal is `False` then you had better hope that your hypotheses\nare contradictory, which they are in this level.": + "아직 `2 + 2 ≠ 5`를 증명할 수 없습니다. `≠`의 정의에 대해 이야기하지 않았기 때문입니다. Lean에서 `a ≠ b`는 `a = b → False`의 *표기법*입니다. 여기서 `False`는 일반적인 거짓 명제이고, `→`는 Lean의 \"implies\" 표기입니다. 논리학에서 `True → False`은 거짓이지만 `False → False`은 참임을 배웁니다. 따라서 `X → False`은 `X`의 논리적 반대입니다.\n\n`≠`0은 겉보기에는 함의처럼 보이지 않지만 함의처럼 다뤄야 합니다. 다음 두 level에서 방법을 봅니다.\n\n`≠`1은 모순 없는 가정들에서는 도저히 이끌어낼 수 없는 goal입니다! 그러므로 goal이 `≠`2라면 가정들이 모순이기를 바라야 하는데, 이 level에서는 실제로 그렇습니다.", + "We now start work on an algorithm to do addition more efficiently. Recall that\nwe defined addition by recursion, saying what it did on `0` and successors.\nIt is an axiom of Lean that recursion is a valid\nway to define functions from types such as the naturals.\n\nLet's define a new function `pred` from the naturals to the naturals, which\nattempts to subtract 1 from the input. The definition is this:\n\n```\npred 0 := 37\npred (succ n) := n\n```\n\nWe cannot subtract one from 0, so we just return a junk value. As well as this\ndefinition, we also create a new lemma `pred_succ`, which says that `pred (succ n) = n`.\nLet's use this lemma to prove `succ_inj`, the theorem which\nPeano assumed as an axiom and which we have already used extensively without justification.": + "이제 덧셈을 더 효율적으로 계산하는 알고리즘을 만들어 봅시다. 앞서\n`0`과 후속자에서 어떻게 작동하는지를 정하여 덧셈을 재귀적으로\n정의했다는 것을 떠올려 보세요. Lean에서는 자연수 같은 타입에서\n재귀를 사용해 함수를 정의할 수 있다는 것을 공리로 받아들입니다.\n\n이제 자연수에서 자연수로 가는 새로운 함수 `pred`를 정의해 봅시다.\n이 함수는 입력에서 1을 빼려고 합니다. 정의는 다음과 같습니다.\n\n```\npred 0 := 37\npred (succ n) := n\n```\n\n0에서는 1을 뺄 수 없으므로 그냥 아무 값이나 반환합니다. 이 정의와\n함께 `pred_succ`라는 새로운 보조정리도 만듭니다. 이 정리는\n`pred (succ n) = n`이라고 말합니다. 이제 이 정리를 사용하여\n`succ_inj`를 증명해 봅시다. `succ_inj`는 페아노가 공리로 가정했고,\n우리는 지금까지 정당화 없이 여러 번 사용해 온 정리입니다.", + "We now have enough to state a mathematically accurate, but slightly\nclunky, version of Fermat's Last Theorem.\n\nFermat's Last Theorem states that if $x,y,z>0$ and $m \\geq 3$ then $x^m+y^m\\not =z^m$.\nIf you didn't do inequality world yet then we can't talk about $m \\geq 3$,\nso we have to resort to the hack of using `n + 3` for `m`,\nwhich guarantees it's big enough. Similarly instead of `x > 0` we\nuse `a + 1`.\n\nThis level looks superficially like other levels we have seen,\nbut the shortest solution known to humans would translate into\nmany millions of lines of Lean code. The author of this game,\nKevin Buzzard, is working on translating the proof by Wiles\nand Taylor into Lean, although this task will take many years.\n\n## CONGRATULATIONS!\n\nYou've finished the main quest of the natural number game!\nIf you would like to learn more about how to use Lean to\nprove theorems in mathematics, then take a look\nat [Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/),\nan interactive textbook which you can read in your browser,\nand which explains how to work with many more mathematical concepts in Lean.": + "이제 수학적으로 정확하지만 조금 투박한 형태의 페르마의 마지막 정리를 진술할 준비가 되었습니다.\n\n페르마의 마지막 정리는 $x,y,z>0$이고 $m \\geq 3$이면 $x^m+y^m\\not =z^m$라는 정리입니다. Inequality World를 하지 않았다면 $m \\geq 3$에 대해 말할 수 없으므로 `m` 대신 `n + 3`를 쓰는 편법을 사용해야 합니다. 이렇게 하면 충분히 큰 수라는 것이 보장됩니다. 마찬가지로 `x > 0` 대신 `a + 1`을 사용합니다.\n\n겉보기에는 이전 level들과 비슷하지만, 인간이 아는 가장 짧은 해법도 Lean 코드로 옮기면 수백만 줄이 될 것입니다. 이 게임의 저자 Kevin Buzzard는 Wiles와 Taylor의 증명을 Lean으로 옮기는 작업을 하고 있지만, 이 작업은 여러 해가 걸릴 것입니다.\n\n## 축하합니다!\n\nNatural Number Game의 main quest를 끝냈습니다! Lean으로 수학 정리를 증명하는 법을 더 배우고 싶다면 브라우저에서 읽을 수 있는 대화형 교재 [Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/)을 살펴보세요. 더 많은 수학적 개념을 Lean에서 다루는 방법을 설명합니다.", + "We now have enough to prove that multiplication is associative,\nthe boss level of multiplication world. Good luck!": + "이제 곱셈의 결합법칙, 즉 Multiplication World의 boss level을 증명할 준비가 되었습니다. 행운을 빕니다!", + "We know `zero_ne_succ n` is a proof of `0 = succ n → False` -- but what\nif we have a hypothesis `succ n = 0`? It's the wrong way around!\n\nThe `symm` tactic changes a goal `x = y` to `y = x`, and a goal `x ≠ y`\nto `y ≠ x`. And `symm at h`\ndoes the same for a hypothesis `h`. We've proved $0 \\neq 1$ and called\nthe proof `zero_ne_one`; now try proving $1 \\neq 0$.": + "`zero_ne_succ n`가 `0 = succ n → False`의 증명이라는 것은 알고 있습니다. 그런데 가정이 `succ n = 0`라면 어떨까요? 방향이 반대입니다!\n\n`symm` tactic은 goal `x = y`를 `y = x`로, goal `x ≠ y`을 `y ≠ x`로 바꿉니다. `symm at h`은 가정 `h`에 대해 같은 일을 합니다. 우리는 `0 = succ n → False`0을 증명하고 그 증명을 `0 = succ n → False`1이라고 불렀습니다. 이제 `0 = succ n → False`2를 증명해 보세요.", + "We have seen how to `apply` theorems and assumptions\nof the form `P → Q`. But what if our *goal* is of the form `P → Q`?\nTo prove this goal, we need to know how to say \"let's assume `P` and deduce `Q`\"\nin Lean. We do this with the `intro` tactic.": + "지금까지 `P → Q` 꼴의 정리와 가정을 `apply`하는 법을 봤습니다. 그런데 *goal*이 `P → Q` 꼴이라면 어떨까요? 이 goal을 증명하려면 Lean에서 \"`P`을 가정하고 `Q`를 이끌어내자\"라고 말하는 법을 알아야 합니다. 이를 `intro` tactic으로 합니다.", + "We gave a pretty unsatisfactory proof of `2 + 2 ≠ 5` earlier on; now give a nicer one.": + "앞에서 `2 + 2 ≠ 5`에 대해 꽤 아쉬운 증명을 했습니다. 이제 더 멋진 증명을 해 보세요.", + "We don't know whether to go left or right yet. So start with `cases «{h}» with hx hy`.": + "아직 왼쪽으로 갈지 오른쪽으로 갈지 모르므로 `cases «{h}» with hx hy`부터 시작하세요.", + "We define a function `is_zero` thus:\n\n```\nis_zero 0 := True\nis_zero (succ n) := False\n```\n\nWe also create two lemmas, `is_zero_zero` and `is_zero_succ n`, saying that `is_zero 0 = True`\nand `is_zero (succ n) = False`. Let's use these lemmas to prove `succ_ne_zero`, Peano's\nLast Axiom. Actually, we have been using `zero_ne_succ` before, but it's handy to have\nthis opposite version too, which can be proved in the same way. Note: you can\ncheat here by using `zero_ne_succ` but the point of this world is to show\nyou how to *prove* results like that.\n\nIf you can turn your goal into `True`, then the `trivial` tactic will solve it.": + "함수 `is_zero`를 다음과 같이 정의합니다:\n\n```\nis_zero 0 := True\nis_zero (succ n) := False\n```\n\n또 `is_zero 0 = True`와 `is_zero (succ n) = False`라고 말하는 두 lemma `is_zero_zero`와 `is_zero_succ n`을 만듭니다. 이 lemma들을 사용해 페아노의 마지막 공리 `succ_ne_zero`을 증명합시다. 사실 `zero_ne_succ`은 이전부터 사용해 왔지만, 반대 방향 버전도 있으면 편리하고 같은 방식으로 증명할 수 있습니다. 참고로 `zero_ne_succ`을 쓰면 여기서 치팅할 수 있지만, 이 world의 목적은 그런 결과를 *직접 증명*하는 방법을 보여 주는 것입니다.\n\ngoal을 `True`로 바꿀 수 있다면 ```\nis_zero 0 := True\nis_zero (succ n) := False\n```0 tactic이 해결합니다.", + "Very well done.\n\nA passing mathematician remarks that with you've just proved that `ℕ` is totally\nordered.\n\nThe final few levels in this world are much easier.": + "정말 잘했습니다.\n\n지나가던 수학자가 방금 `ℕ`가 전순서(total order)임을 증명했다고 말합니다.\n\n이 world의 마지막 몇 level은 훨씬 쉽습니다.", + "Use the previous lemma with `apply eq_succ_of_ne_zero at ha`.": + "이전 lemma를 `apply eq_succ_of_ne_zero at ha`와 함께 사용하세요.", + "Use `mul_eq_zero` and remember that `tauto` will solve a goal\nif there are hypotheses `a = 0` and `a ≠ 0`.": + "`mul_eq_zero`를 사용하세요. 가정 `a = 0`와 `a ≠ 0`이 있으면 `tauto`이 goal을 해결한다는 점을 기억하세요.", + "Use `add_succ`.": "`add_succ`를 사용하세요.", + "Tutorial World": "튜토리얼 월드", + "Try `rw [← one_eq_succ_zero]` to change `succ 0` into `1`.": + "`rw [← one_eq_succ_zero]`를 사용해 `succ 0`을 `1`로 바꿔 보세요.", + "Try `rw [add_zero c]`.": "`rw [add_zero c]`를 시도해 보세요.", + "Try `cases «{hd}» with h1 h2`.": "`cases «{hd}» with h1 h2`를 시도해 보세요.", + "Totality of `≤` is the boss level of this world, and it's coming up next. It says that\nif `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\nBut we haven't talked about `or` at all. Here's a run-through.\n\n1) The notation for \"or\" is `∨`. You won't need to type it, but you can\ntype it with `\\or`.\n\n2) If you have an \"or\" statement in the *goal*, then two tactics make\nprogress: `left` and `right`. But don't choose a direction unless your\nhypotheses guarantee that it's the correct one.\n\n3) If you have an \"or\" statement as a *hypothesis* `h`, then\n`cases h with h1 h2` will create two goals, one where you went left,\nand the other where you went right.": + "`≤`의 전칭성(totality)은 이 world의 boss level이며 바로 다음에 나옵니다. `a`과 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a`라는 명제입니다. 하지만 아직 `or`에 대해 전혀 이야기하지 않았으니 먼저 살펴봅시다.\n\n1) \"or\"의 표기는 `∨`입니다. 직접 입력할 필요는 없지만 `\\or`로 입력할 수 있습니다.\n\n2) goal에 \"or\" 명제가 있으면 `left`과 `right` 두 tactic으로 진행할 수 있습니다. 하지만 어느 방향이 옳은지 가정으로 확실해지기 전에는 방향을 선택하지 마세요.\n\n3) \"or\" 명제가 가정 `a`0으로 있다면 `a`1은 goal을 두 개 만듭니다. 하나는 왼쪽 경우, 다른 하나는 오른쪽 경우입니다.", + "Totality of `≤` is the boss level of this world, and it's coming up next. It says that\nif `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\nBut we haven't talked about `or` at all. Here's a run-through.\n\n1) The notation for \"or\" is `∨`. You won't need to type it, but you can\ntype it with `\\or`.\n\n2) If you have an \"or\" statement in the *goal*, then two tactics made\nprogress: `left` and `right`. But don't choose a direction unless your\nhypotheses guarantee that it's the correct one.\n\n3) If you have an \"or\" statement as a *hypothesis* `h`, then\n`cases h with h1 h2` will create two goals, one where you went left,\nand the other where you went right.": + "Totality of `≤` is the boss level of this world, and it's coming up next. It says that\nif `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\nBut we haven't talked about `or` at all. Here's a run-through.\n\n1) The notation for \"or\" is `∨`. You won't need to type it, but you can\ntype it with `\\or`.\n\n2) If you have an \"or\" statement in the *goal*, then two tactics made\nprogress: `left` and `right`. But don't choose a direction unless your\nhypotheses guarantee that it's the correct one.\n\n3) If you have an \"or\" statement as a *hypothesis* `h`, then\n`cases h with h1 h2` will create two goals, one where you went left,\nand the other where you went right.", + "To solve this level, you need to `use` a number `c` such that `x = 0 + c`.": + "이 level을 해결하려면 `x = 0 + c`를 만족하는 수 `c`을 `use`해야 합니다.", + "Those of you interested in speedrunning the game may want to know\nthat `repeat rw [add_zero]` will do both rewrites at once.": + "게임을 speedrun하고 싶은 분들은 `repeat rw [add_zero]`가 두 rewrite를 한 번에 해 준다는 것을 알아 두면 좋습니다.", + "This world introduces exponentiation. If you want to define `37 ^ n`\nthen, as always, you will need to know what `37 ^ 0` is, and\nwhat `37 ^ (succ d)` is, given only `37 ^ d`.\n\nYou can probably guess the names of the general theorems:\n\n * `pow_zero (a : ℕ) : a ^ 0 = 1`\n * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n\nUsing only these, can you get past the final boss level?\n\nThe levels in this world were designed by Sian Carey, a UROP student\nat Imperial College London, funded by a Mary Lister McCammon Fellowship\nin the summer of 2019. Thanks to Sian and also thanks to Imperial\nCollege for funding her.": + "이 월드에서는 거듭제곱을 도입합니다. `37 ^ n`를 정의하려면 언제나 그렇듯 `37 ^ 0`이 무엇인지, 그리고 `37 ^ d`만 알고 있을 때 `37 ^ (succ d)`가 무엇인지 알아야 합니다.\n\n일반 정리의 이름은 아마 짐작할 수 있을 겁니다:\n\n * `pow_zero (a : ℕ) : a ^ 0 = 1`\n * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n\n이 둘만 사용해서 최종 보스 level을 넘을 수 있을까요?\n\n이 세계의 level들은 2019년 여름 Imperial College London의 UROP 학생 Sian Carey가 설계했으며 Mary Lister McCammon Fellowship의 지원을 받았습니다. Sian과 그녀를 지원한 Imperial College에 감사드립니다.", + "This time, use the `left` tactic.": "이번에는 `left` tactic을 사용하세요.", + "This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\ninstead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory.": + "This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\ninstead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory.", + "This level proves that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`. One strategy\nis to write both `a` and `b` as `succ` of something, deduce that `a * b` is\nalso `succ` of something, and then `apply zero_ne_succ`.": + "이 level에서는 `a ≠ 0`와 `b ≠ 0`이면 `a * b ≠ 0`라는 것을 증명합니다. 한 전략은 `a`과 `b`를 각각 어떤 것의 `succ`로 쓰고, `a * b`도 어떤 것의 `succ`임을 이끌어낸 뒤 `apply zero_ne_succ`을 사용하는 것입니다.", + "This level proves that if `a * b = 0` then `a = 0` or `b = 0`. It is\nlogically equivalent to the last level, so there is a very short proof.": + "이 level에서는 `a * b = 0`이면 `a = 0` 또는 `b = 0`라는 것을 증명합니다. 이전 level과 논리적으로 동치이므로 아주 짧은 증명이 있습니다.", + "This level proves `x * y = 1 → x = 1`, the multiplicative analogue of Advanced Addition\nWorld's `x + y = 0 → x = 0`. The strategy is to prove that `x ≤ 1` and then use the\nlemma `le_one` from `≤` world.\n\nWe'll prove it using a new and very useful tactic called `have`.": + "이 레벨에서는 고급 덧셈 월드의 `x + y = 0 → x = 0`에 대응하는 곱셈 버전 `x * y = 1 → x = 1`를 증명합니다. 전략은 `x ≤ 1`를 증명한 다음 `≤` 월드에서 얻은 lemma `le_one`을 사용하는 것입니다.\n\n새롭고 매우 유용한 tactic `have`를 사용해 증명하겠습니다.", + "This level is more important than you think; it plays\na useful role when battling a big boss later on.": + "이 level은 생각보다 중요합니다. 나중에 큰 boss와 싸울 때 유용한 역할을 합니다.", + "This level asks you to prove *antisymmetry* of $\\leq$.\nIn other words, if $x \\leq y$ and $y \\leq x$ then $x = y$.\nIt's the trickiest one so far. Good luck!": + "이 level에서는 $\\leq$의 *반대칭성*을 증명합니다. 즉 $x \\leq y$이고 $y \\leq x$이면 $x = y$임을 보입니다. 지금까지 중 가장 까다롭습니다. 행운을 빕니다!", + "This lemma would have been easy if we had known that `x + y = y + x`. That theorem\n is called `add_comm` and it is *true*, but unfortunately its proof *uses* both\n `add_zero` and `zero_add`!\n\n Let's continue on our journey to `add_comm`, the proof of `x + y = y + x`.": + "`x + y = y + x`를 알고 있었다면 이 lemma는 쉬웠을 겁니다. 그 정리는 `add_comm`이라고 하며 실제로 *참*이지만, 안타깝게도 그 증명은 `add_zero`와 `zero_add`을 모두 사용합니다!\n\n`x + y = y + x`의 증명 `add_comm`를 향한 여정을 계속합시다.", + "This is I think the toughest level yet. Tips: if `a` is a number\nthen `cases a with b` will split into cases `a = 0` and `a = succ b`.\nAnd don't go left or right until your hypotheses guarantee that\nyou can prove the resulting goal!\n\nI've left hidden hints; if you need them, retry from the beginning\nand click on \"Show more help!\"": + "제 생각에는 지금까지 가장 어려운 level입니다. 팁: `a`가 수라면 `cases a with b`은 `a = 0`와 `a = succ b`의 경우로 나눕니다. 그리고 가정이 결과 goal을 증명할 수 있음을 보장하기 전에는 왼쪽이나 오른쪽을 선택하지 마세요!\n\n숨겨 둔 힌트가 있습니다. 필요하면 처음부터 다시 시작하고 \"도움말 더 보기!\"를 누르세요.", + "The way to start this proof is `induction b with d hd generalizing c`.": + "이 증명은 `induction b with d hd generalizing c`로 시작해야 합니다.", + "The rfl tactic": "rfl tactic", + "The reason `«{x}» ≤ «{x}»` is because `«{x}» = «{x}» + 0`.\nSo you should start this proof with `use 0`.": + "`«{x}» ≤ «{x}»`인 이유는 `«{x}» = «{x}» + 0`이기 때문입니다. 따라서 `use 0`로 증명을 시작해야 합니다.", + "The previous lemma can be used to prove this one.": + "이전 lemma를 사용해 이 lemma를 증명할 수 있습니다.", + "The next result we'll need in `≤` World is that if `a + b = 0` then `a = 0` and `b = 0`.\nLet's prove one of these facts in this level, and the other in the next.\n\n## A new tactic: `cases`\n\nThe `cases` tactic will split an object or hypothesis up into the possible ways\nthat it could have been created.\n\nFor example, sometimes you want to deal with the two cases `b = 0` and `b = succ d` separately,\nbut don't need the inductive hypothesis `hd` that comes with `induction b with d hd`.\nIn this situation you can use `cases b with d` instead. There are two ways to make\na number: it's either zero or a successor. So you will end up with two goals, one\nwith `b = 0` and one with `b = succ d`.\n\nAnother example: if you have a hypothesis `h : False` then you are done, because a false statement implies\nany statement. Here `cases h` will close the goal, because there are *no* ways to\nmake a proof of `False`! So you will end up with no goals, meaning you have proved everything.": + "`≤` World에서 다음으로 필요한 결과는 `a + b = 0`이면 `a = 0`이고 `b = 0`이라는 것입니다. 이번 level에서 하나를 증명하고 다음 level에서 나머지 하나를 증명합시다.\n\n## 새로운 tactic: `cases`\n\n`cases` tactic은 object나 가정을 그것이 만들어질 수 있었던 가능한 경우들로 분해합니다.\n\n예를 들어 `b = 0`와 `b = succ d`의 두 경우를 따로 다루고 싶지만 `induction b with d hd`에 따라오는 귀납가정 `hd`은 필요하지 않을 때가 있습니다. 이때는 `a + b = 0`0을 사용할 수 있습니다. 수를 만드는 방법은 두 가지뿐입니다. 0이거나 successor입니다. 따라서 `a + b = 0`1인 goal과 `a + b = 0`2인 goal, 두 개가 생깁니다.\n\n또 다른 예로, 가정 `a + b = 0`3이 있다면 이미 끝난 것입니다. 거짓 명제에서는 어떤 명제든 따라오기 때문입니다. 여기서 `a + b = 0`4는 goal을 닫습니다. `a + b = 0`5의 증명을 만드는 방법은 *하나도 없기* 때문입니다! 따라서 goal이 하나도 남지 않고, 이는 모든 것을 증명했다는 뜻입니다.", + "The music gets ever more dramatic, as we explore\nthe interplay between exponentiation and multiplication.\n\nIf you're having trouble exchanging the right `a * b`\nbecause `rw [mul_comm]` swaps the wrong multiplication,\nthen read the documentation of `rw` for tips on how to fix this.": + "거듭제곱과 곱셈의 상호작용을 살펴보면서 음악은 점점 더 극적으로 변합니다.\n\n`rw [mul_comm]`이 엉뚱한 곱셈을 바꿔서 원하는 `a * b`를 교환하기 어렵다면 `rw` 문서에서 해결법을 읽어 보세요.", + "The music dies down. Is that it?\n\nCourse it isn't, you can\nclearly see that there are two levels left.\n\nA passing mathematician says that mathematicians don't have a name\nfor the structure you just constructed. You feel cheated.\n\nSuddenly the music starts up again. This really is the final boss.": + "음악이 잦아듭니다. 설마 이게 끝인가요?\n\n그럴 리가요. 아직 두 관문이나 남아 있는 게 빤히 보이잖아요.\n\n지나가던 한 수학자가 방금 당신이 만든 구조에는 딱히 이름도 없다고 합니다.\n괜히 속은 기분이 듭니다.\n\n그 순간, 음악이 다시 울려 퍼집니다. *진짜 최종 보스*", + "The lemma proved in the final level of this world will be helpful\nin Divisibility World.": + "이 world의 마지막 level에서 증명하는 lemma는 Divisibility World에서 유용합니다.", + "The inductive hypothesis `hd` is \"For all natural numbers `c`, `a * d = a * c → d = c`\".\nYou can `apply` it `at` any hypothesis of the form `a * d = a * ?`.": + "귀납가정 `hd`는 \"모든 자연수 `c`에 대해 `a * d = a * c → d = c`\"입니다. `a * d = a * ?` 꼴의 어떤 가정에도 `apply`를 `at`할 수 있습니다.", + "The goal in this level is one of our hypotheses. Solve the goal by executing `exact h1`.": + "이 level의 goal은 가정 중 하나입니다. `exact h1`를 실행해서 goal을 해결하세요.", + "The first sub-boss of Multiplication World is `mul_comm x y : x * y = y * x`.\n\nWhen you've proved this theorem we will have \"spare\" proofs\nsuch as `zero_mul`, which is now easily deducible from `mul_zero`.\nBut we'll keep hold of these proofs anyway, because it's convenient\nto have exactly the right tool for a job.": + "Multiplication World의 첫 sub-boss는 `mul_comm x y : x * y = y * x`입니다.\n\n이 정리를 증명하면 `zero_mul`처럼 `mul_zero`에서 쉽게 따라오는 \"여분의\" 증명도 생깁니다. 그래도 정확히 필요한 도구를 바로 꺼내 쓸 수 있으면 편리하므로 이런 증명들도 그대로 가지고 있겠습니다.", + "The classical introduction game for Lean.": "Lean을 배우는 고전적인 입문 게임.", + "The `use` tactic": "`use` tactic", + "The `exact` tactic": "`exact` tactic", + "The `apply` tactic.": "`apply` tactic.", + "Start with induction on `n`.": "`n`에 대한 귀납법으로 시작하세요.", + "Start with `rw [← pred_succ a]` and take it from there.": + "`rw [← pred_succ a]`로 시작하고 나머지는 스스로 해 보세요.", + "Start with `rw [two_eq_succ_one]` to begin to break `2` down into its definition.": + "`rw [two_eq_succ_one]`로 시작해 `2`을 정의에 따라 분해하기 시작하세요.", + "Start with `repeat rw [add_assoc]` to push all the brackets to the right.": + "`repeat rw [add_assoc]`로 시작해 모든 괄호를 오른쪽으로 밀어 보세요.", + "Start with `intro hb`.": "`intro hb`로 시작하세요.", + "Start with `intro h`.": "`intro h`로 시작하세요.", + "Start with `intro h` to assume the hypothesis.": + "가정을 도입하려면 `intro h`부터 해보세요.", + "Start with `intro h` to assume the hypothesis and call its proof `h`.": + "`intro h`로 시작해 가정을 도입하고 그 증명을 `h`이라고 부르세요.", + "Start with `intro h` (remembering that `X ≠ Y` is just notation\nfor `X = Y → False`).": + "`intro h`로 시작하세요(`X ≠ Y`이 `X = Y → False`의 표기법일 뿐이라는 점을 기억하세요).", + "Start with `induction «{y}» with d hd`.": + "`induction «{y}» with d hd`로 시작하세요.", + "Start with `have h2 := mul_ne_zero a b`.": + "`have h2 := mul_ne_zero a b`로 시작하세요.", + "Start with `contrapose! h`, to change the goal into its\ncontrapositive, namely a hypothesis of `succ m = succ n` and a goal of `m = n`.": + "`contrapose! h`로 시작해 goal을 그 대우로 바꾸세요. 즉 가정 `succ m = succ n`과 goal `m = n`로 바꿉니다.", + "Start with `cases «{hxy}» with a ha`.": "`cases «{hxy}» with a ha`로 시작하세요.", + "Start with `cases a with d` to do a case split on `a = 0` and `a = succ d`.": + "`cases a with d`로 시작해 `a = 0`과 `a = succ d`에 대해 경우를 나누세요.", + "Start with `apply succ_inj` to apply `succ_inj` to the *goal*.": + "`apply succ_inj`로 시작해 `succ_inj`을 *goal*에 적용하세요.", + "Start with `apply h2 at h1`. This will change `h1` to `y = 42`.": + "`apply h2 at h1`부터 시작하세요. 그러면 `h1`이 `y = 42`로 바뀝니다.", + "Start with `apply eq_succ_of_ne_zero at ha` and `... at hb`": + "`apply eq_succ_of_ne_zero at ha`와 `... at hb`로 시작하세요.", + "Start by unravelling the `1`.": "먼저 `1`을 풀어 써 보세요.", + "Split into cases `c = 0` and `c = succ e` with `cases c with e`.": + "`cases c with e`를 사용해 `c = 0`와 `c = succ e`의 경우로 나누세요.", + "Solve this level in one line with `simp only [add_left_comm, add_comm]`": + "`simp only [add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요.", + "Solve this level in one line with `simp only [add_assoc, add_left_comm, add_comm]`": + "`simp only [add_assoc, add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요.", + "So that's the algorithm: now let's use automation to perform it\nautomatically.": + "알고리즘은 이것입니다. 이제 automation을 사용해 자동으로 실행해 봅시다.", + "Similarly we have `mul_succ`\nbut we're going to need `succ_mul` (guess what it says -- maybe you\nare getting the hang of Lean's naming conventions).\n\nThe last level from addition world might help you in this level.\nIf you can't remember what it is, you can go back to the\nhome screen by clicking the house icon and then taking a look.\nYou won't lose any progress.": + "마찬가지로 `mul_succ`가 있지만 우리가 필요한 것은 `succ_mul`입니다(무슨 내용일지 맞혀 보세요. 이제 Lean의 이름 짓기 규칙이 좀 익숙해졌을지도 모르겠네요).\n\nAddition World의 마지막 level이 도움이 될 수 있습니다. 기억나지 않으면 집 모양 아이콘을 눌러 home 화면으로 돌아가 확인하세요. 진행 상황은 잃지 않습니다.", + "See the new \"*\" tab in your lemmas, containing `mul_zero` and `mul_succ`.\nRight now these are the only facts we know about multiplication.\nLet's prove nine more.\n\nLet's start with a warm-up: no induction needed for this one,\nbecause we know `1` is a successor.": + "lemma 목록에 새로 생긴 \"*\" 탭을 보세요. `mul_zero`와 `mul_succ`이 들어 있습니다. 지금은 이 둘만 곱셈에 대해 알고 있는 사실입니다. 이제 아홉 개를 더 증명합시다.\n\n먼저 준비운동부터 합니다. 이번에는 `1`가 successor라는 것을 알고 있으므로 귀납법이 필요 없습니다.", + "See if you can take it from here. Look at the new lemmas and tactic\navailable on the right.": + "이제부터는 스스로 해 보세요. 오른쪽에 새로 생긴 lemma와 tactic을 살펴보세요.", + "Remember, `x ≠ y` is *notation* for `x = y → False`.": + "`x ≠ y`는 `x = y → False`을 나타내는 *표기법*이라는 점을 기억하세요.", + "Remember that when Lean writes `a + b + c`, it means `(a + b) + c`.\nIf you are not sure where the brackets are in an expression, just hover\nyour cursor over it and look at what gets highlighted. For example,\nhover over both `+` symbols on the left hand side of the goal and\nyou'll see where the invisible brackets are.": + "Lean이 `a + b + c`라고 쓸 때는 `(a + b) + c`을 뜻한다는 점을 기억하세요. 식에서 괄호가 어디에 숨어 있는지 잘 모르겠다면 커서를 올려 어느 부분이 강조되는지 확인하면 됩니다. 예를 들어 목표의 왼쪽에 있는 두 `+` 기호 위에 각각 커서를 올려 보면 보이지 않는 괄호의 위치를 알 수 있습니다.", + "Remember that `h2` is a proof of `x = y → False`. Try\n`apply`ing `h2` either `at h1` or directly to the goal.": + "`h2`가 `x = y → False`의 증명이라는 점을 기억하세요. `h2`에 `apply`를 `at h1`하거나 goal에 직접 `at h1`해 보세요.", + "Reduce to the previous lemma with `nth_rewrite 2 [← mul_one a] at h`": + "`nth_rewrite 2 [← mul_one a] at h`를 사용해 이전 lemma로 환원하세요.", + "Ready for the boss level of this world?": "이 world의 boss level을 맞을 준비가 되었나요?", + "Proofs like $2+2=4$ and $a+b+c+d+e=e+d+c+b+a$ are very tedious to do by hand.\nIn Algorithm World we learn how to get the computer to do them for us.\n\nClick on \"Start\" to proceed.": + "$2+2=4$나 $a+b+c+d+e=e+d+c+b+a$ 같은 증명을 손으로 하는 것은 아주 지루합니다. Algorithm World에서는 컴퓨터가 대신 하게 만드는 법을 배웁니다.\n\n\"Start\"를 눌러 진행하세요.", + "Precision rewriting": "정밀한 rewriting", + "Power World": "거듭제곱 월드", + "Our next goal is \"left and right distributivity\",\nmeaning $a(b+c)=ab+ac$ and $(b+c)a=ba+ca$. Rather than\nthese slightly pompous names, the name of the proofs\nin Lean are descriptive. Let's start with\n`mul_add a b c`, the proof of `a * (b + c) = a * b + a * c`.\nNote that the left hand side contains a multiplication\nand then an addition.": + "다음 목표는 \"왼쪽과 오른쪽 분배법칙\", 즉 $a(b+c)=ab+ac$와 $(b+c)a=ba+ca$입니다. 이런 다소 거창한 이름 대신 Lean의 증명 이름은 내용을 그대로 설명합니다. 먼저 `mul_add a b c`, 즉 `a * (b + c) = a * b + a * c`의 증명부터 시작합시다. 왼쪽 항에는 먼저 곱셈이 있고 그다음 덧셈이 있다는 점에 주의하세요.", + "Our first challenge is `mul_comm x y : x * y = y * x`,\nand we want to prove it by induction. The zero\ncase will need `mul_zero` (which we have)\nand `zero_mul` (which we don't), so let's\nstart with this.": + "첫 도전은 `mul_comm x y : x * y = y * x`이며 귀납법으로 증명하려 합니다. 0 경우에는 `mul_zero`(이미 있음)과 `zero_mul`(아직 없음)가 필요하므로 이것부터 시작합시다.", + "One of the best named levels in the game, a savage `pow_pow`\nsub-boss appears as the music reaches a frenzy. What\nelse could there be to prove about powers after this?": + "게임에서 이름이 가장 멋진 level 중 하나입니다. 음악이 절정으로 치닫는 가운데 흉악한 `pow_pow` sub-boss가 나타납니다. 이 뒤에 거듭제곱에 대해 또 무엇을 증명할 수 있을까요?", + "One day this game will have a Prime Number World, with a final boss\nof proving that $2$ is prime.\nTo do this, we will have to rule out things like $2 = 37 × 42.$\nWe will do this by proving that any factor of $2$ is at most $2$,\nwhich we will do using this lemma. The proof I have in mind manipulates the hypothesis\nuntil it becomes the goal, using `mul_left_ne_zero`, `one_le_of_ne_zero` and\n`mul_le_mul_right`.": + "언젠가 이 게임에는 소수 월드가 생기고, 최종 보스는 $2$가 소수임을 증명하는 문제가 될 겁니다. 이를 위해 $2 = 37 × 42.$ 같은 가능성을 배제해야 합니다. 어떤 $2$의 인수도 $2$ 이하임을 보임으로써 그렇게 할 것이고, 이 lemma를 사용합니다. 제가 생각한 증명은 `mul_left_ne_zero`, `one_le_of_ne_zero`, `mul_le_mul_right`를 이용해 가정을 goal이 될 때까지 변형합니다.", + "On the set of natural numbers, addition is commutative.\nIn other words, if `a` and `b` are arbitrary natural numbers, then\n$a + b = b + a$.": + "자연수 집합에서 덧셈은 가환입니다. 즉 `a`와 `b`이 임의의 자연수라면 $a + b = b + a$입니다.", + "On the set of natural numbers, addition is associative.\nIn other words, if $a, b$ and $c$ are arbitrary natural numbers, we have\n$ (a + b) + c = a + (b + c). $": + "자연수 집합에서 덧셈은 결합법칙을 만족합니다. 즉 $a, b$와 $c$이 임의의 자연수라면 $ (a + b) + c = a + (b + c). $입니다.", + "On the set of natural numbers, addition is associative.\nIn other words, for all natural numbers $a, b$ and $c$, we have\n$ (a + b) + c = a + (b + c). $": + "On the set of natural numbers, addition is associative.\nIn other words, for all natural numbers $a, b$ and $c$, we have\n$ (a + b) + c = a + (b + c). $", + "Oh no! On the way to `add_comm`, a wild `succ_add` appears. `succ_add a b`\nis the proof that `(succ a) + b = succ (a + b)` for `a` and `b` numbers.\nThis result is what's standing in the way of `x + y = y + x`. Again\nwe have the problem that we are adding `b` to things, so we need\nto use induction to split into the cases where `b = 0` and `b` is a successor.": + "이런! `add_comm`로 가는 길에 야생의 `succ_add`이 나타났습니다. `succ_add a b`는 `a`와 `b`가 수일 때 `(succ a) + b = succ (a + b)`이라는 것의 증명입니다. 이 결과가 `x + y = y + x`을 막고 있습니다. 다시 `b`을 어떤 것에 더하고 있으므로 귀납법으로 `b = 0`인 경우와 `b`가 successor인 경우를 나눠야 합니다.", + "Numbers": "수", + "Now you need to figure out which number to `use`. See if you can take it from here.": + "이제 어떤 수를 `use`해야 하는지 알아내야 합니다. 여기서부터는 스스로 해 보세요.", + "Now you have two goals. Once you proved the first, you will jump to the second one.\nThis first goal is the base case $n = 0$.\n\nRecall that you can rewrite the proof of any lemma which is visible\nin your inventory, or of any assumption displayed above the goal,\nas long as it is of the form `X = Y`.": + "이제 goal이 두 개 생겼습니다. 첫 번째를 증명하면 두 번째로 넘어갑니다. 첫 goal은 기저 경우 $n = 0$입니다.\n\ninventory에 보이는 lemma의 증명이나 goal 위에 표시된 가정은 `X = Y` 꼴이기만 하면 언제든 rewrite에 사용할 수 있다는 점을 기억하세요.", + "Now you could finish with `rw [«{h}»]` then `rfl`, but `exact «{h}»`\ndoes it in one line.": + "이제 `rw [«{h}»]` 다음 `rfl`로 끝낼 수도 있지만, `exact «{h}»`면 한 줄에 됩니다.", + "Now you can `rw [add_succ]`": "이제 `rw [add_succ]`할 수 있습니다.", + "Now you can `apply zero_ne_succ at h`.": + "이제 `apply zero_ne_succ at h`를 할 수 있습니다.", + "Now you can `apply le_mul_right at h2`.": + "이제 `apply le_mul_right at h2`를 할 수 있습니다.", + "Now we can prove the `or` statement by proving the statement on the right,\nso use the `right` tactic.": + "이제 오른쪽 명제를 증명함으로써 `or` 명제를 증명할 수 있으므로 `right` tactic을 사용하세요.", + "Now use `rw [add_left_comm b c]` to switch `b` and `c` on the left\nhand side.": + "이제 `rw [add_left_comm b c]`를 사용해 왼쪽의 `b`과 `c`를 바꾸세요.", + "Now the goal can be deduced from `h2` by pure logic, so use the `tauto`\ntactic.": + "이제 순수한 논리만으로 `h2`에서 goal이 따라오므로 `tauto` tactic을 사용하세요.", + "Now take apart the existence statement with `cases ha with n hn`.": + "이제 `cases ha with n hn`를 사용해 존재 명제를 분해하세요.", + "Now rewrite `succ_eq_add_one` backwards at `h`\nto get the right hand side.": + "이제 `h`에서 `succ_eq_add_one`를 거꾸로 rewrite해 오른쪽 항을 얻으세요.", + "Now rewrite `four_eq_succ_three` backwards to make the goal\nequal to the hypothesis.": + "이제 `four_eq_succ_three`를 거꾸로 rewrite해서 goal을 가정과 같게 만드세요.", + "Now let's `apply` our new theorem. Execute `apply succ_inj at h`\nto change `h` to a proof of `x = 3`.": + "이제 새 정리를 `apply`해 봅시다. `apply succ_inj at h`을 실행해 `h`를 `x = 3`의 증명으로 바꾸세요.", + "Now for to the second goal. Here you have the induction hypothesis\n`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`.": + "이제 for to the second goal. Here you have the induction hypothesis\n`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`.", + "Now for the second goal. Here you have the induction hypothesis\n§0, and you need to prove that §1.": + "이제 두 번째 goal입니다. 여기에는 귀납가정 §0가 있고 §1을 증명해야 합니다.", + "Now finish using the `exact` tactic.": "이제 `exact` tactic을 사용해 마무리하세요.", + "Now finish the job with `rfl`.": "이제 `rfl`로 마무리하세요.", + "Now finish in one line.": "이제 한 줄로 마무리하세요.", + "Now change `1` to `succ 0` in `h`.": "이제 `h`에서 `1`를 `succ 0`로 바꾸세요.", + "Now `«{ha}»` is a proof that `«{y}» = «{x}» + «{a}»`, and `hxy` has vanished. Similarly, you can destruct\n`«{hyz}»` into its parts with `cases «{hyz}» with b hb`.": + "이제 `«{ha}»`는 `«{y}» = «{x}» + «{a}»`의 증명이고 `hxy`는 사라졌습니다. 마찬가지로 `«{hyz}»`도 `cases «{hyz}» with b hb`를 사용해 구성 요소로 분해할 수 있습니다.", + "Now `rw [← two_eq_succ_one]` will change `succ 1` into `2`.": + "이제 `rw [← two_eq_succ_one]`가 `succ 1`을 `2`로 바꿉니다.", + "Now `rw [«{h}»] at «{h2}»` so you can `apply le_one at «{h2}»`.": + "이제 `rw [«{h}»] at «{h2}»`를 해서 `apply le_one at «{h2}»`할 수 있게 하세요.", + "Now `rw [h]` then `rfl` works, but `exact h` is quicker.": + "이제 `rw [h]` 다음 `rfl`도 작동하지만 `exact h`가 더 빠릅니다.", + "Now `rw [add_zero]` will change `c + 0` into `c`.": + "이제 `rw [add_zero]`가 `c + 0`을 `c`로 바꿉니다.", + "Now `rfl` will work.": "이제 `rfl`가 작동합니다.", + "Now `repeat rw [← succ_eq_add_one] at h` is the quickest way to\nchange `h` to `succ x = succ y`.": + "이제 `h`을 `succ x = succ y`로 바꾸는 가장 빠른 방법은 `repeat rw [← succ_eq_add_one] at h`입니다.", + "Now `exact h` finishes the job.": "이제 `exact h`가 마무리합니다.", + "Now `cases «{h2}» with e he`.": "이제 `cases «{h2}» with e he`.", + "Now `cases h2 with h0 h1` and deal with the two\ncases separately.": + "이제 `cases h2 with h0 h1`하고 두 경우를 따로 처리하세요.", + "Now `apply succ_inj at h` to cancel the `succ`s.": + "이제 `apply succ_inj at h`를 사용해 `succ`들을 소거하세요.", + "Now `apply h` and you can probably take it from here.": + "이제 `apply h`를 하고 나면 아마 나머지는 스스로 할 수 있을 겁니다.", + "Note: this lemma will be useful for the final boss!": + "참고: 이 lemma는 final boss에서 유용합니다!", + "Note that you can do `rw [two_eq_succ_one, one_eq_succ_zero]`\nand then `rfl` to solve this level in two lines.": + "`rw [two_eq_succ_one, one_eq_succ_zero]` 다음 `rfl`을 하면 이 level을 두 줄로 해결할 수 있다는 점에 주의하세요.", + "Note that `succ a + «{d}»` means `(succ a) + «{d}»`. Put your cursor\non any `succ` in the goal or assumptions to see what exactly it's eating.": + "`succ a + «{d}»`가 `(succ a) + «{d}»`을 뜻한다는 점에 주의하세요. goal이나 가정에 있는 아무 `succ` 위에 커서를 올려 정확히 무엇을 먹고 있는지 확인해 보세요.", + "Nice! You've proved `succ_inj`!\nLet's now prove Peano's other axiom, that successors can't be $0$.": + "좋습니다! `succ_inj`를 증명했습니다! 이제 페아노의 다른 공리, successor는 $0$일 수 없다는 것을 증명합시다.", + "Nice!\n\nThe next step in the development of order theory is to develop\nthe theory of the interplay between `≤` and multiplication.\nIf you've already done Multiplication World, you're now ready for\nAdvanced Multiplication World. Click on \"Home\" to access it.": + "좋습니다!\n\n순서론에서 다음 단계는 `≤`와 곱셈이 어떻게 상호작용하는지 알아보는 것입니다. Multiplication World를 이미 끝냈다면 이제 Advanced Multiplication World에 도전할 준비가 되었습니다. \"Home\"을 눌러 이동하세요.", + "Nice!": "좋습니다!", + "Next turn `1` into `succ 0` with `rw [one_eq_succ_zero]`.": + "다음으로 `rw [one_eq_succ_zero]`를 사용해 `1`를 `succ 0`로 바꾸세요.", + "Natural Number Game": "자연수 게임", + "My proof:\n```\ncases h with d hd\nuse d * t\nrw [hd, add_mul]\nrfl\n```": + "제 증명:\n```\ncases h with d hd\nuse d * t\nrw [hd, add_mul]\nrfl\n```", + "Multiplication usually makes a number bigger, but multiplication by zero can make\nit smaller. Thus many lemmas about inequalities and multiplication need the\nhypothesis `a ≠ 0`. Here is a key lemma that enables us to use this hypothesis.\nTo help us with the proof, we can use the `tauto` tactic. Click on the tactic's name\non the right to see what it does.": + "곱셈은 보통 수를 더 크게 만들지만 0을 곱하면 더 작게 만들 수도 있습니다. 그래서 부등식과 곱셈에 관한 많은 lemma에는 가정 `a ≠ 0`가 필요합니다. 여기서는 이 가정을 활용할 수 있게 해 주는 핵심 lemma를 증명합니다. 증명을 돕기 위해 `tauto` tactic을 사용할 수 있습니다. 오른쪽에서 tactic 이름을 눌러 무엇을 하는지 확인하세요.", + "Multiplication is distributive over addition on the left.\nIn other words, for all natural numbers $a$, $b$ and $c$, we have\n$a(b + c) = ab + ac$.": + "곱셈은 왼쪽에서 덧셈에 대해 분배법칙을 만족합니다. 즉 모든 자연수 $a$, $b$, $c$에 대해 $a(b + c) = ab + ac$이 성립합니다.", + "Multiplication is commutative.": "곱셈은 가환입니다.", + "Multiplication is associative.\nIn other words, for all natural numbers $a$, $b$ and $c$, we have\n$(ab)c = a(bc)$.": + "곱셈은 결합법칙을 만족합니다. 즉 모든 자연수 $a$, $b$, $c$에 대해 $(ab)c = a(bc)$입니다.", + "Multiplication distributes\nover addition on the left.\n\n`mul_add a b c` is the proof that `a * (b + c) = a * b + a * c`.": + "곱셈은 왼쪽에서 덧셈에 대해 분배됩니다.\n\n`mul_add a b c`는 `a * (b + c) = a * b + a * c`의 증명입니다.", + "Multiplication World": "곱셈 월드", + "Mathematicians sometimes debate what `0 ^ 0` is;\nthe answer depends, of course, on your definitions. In this\ngame, `0 ^ 0 = 1`. See if you can prove it.\n\nCheck out the *Pow* tab in your list of theorems\nto see the new proofs which are available.": + "수학자들은 가끔 `0 ^ 0`가 무엇인지 논쟁합니다. 물론 답은 정의에 달려 있습니다. 이 게임에서는 `0 ^ 0 = 1`입니다. 증명해 보세요.\n\n새로 사용할 수 있는 증명은 theorem 목록의 *Pow* 탭에서 확인하세요.", + "Mathematicians sometimes argue that `0 ^ 0 = 0` is also\na good convention. But it is not a good convention in this\ngame; all the later levels come out beautifully with the\nconvention that `0 ^ 0 = 1`.": + "수학자들은 가끔 `0 ^ 0 = 0`도 좋은 관례라고 주장합니다. 하지만 이 게임에서는 좋은 관례가 아닙니다. `0 ^ 0 = 1`이라는 관례를 택하면 뒤의 level들이 아주 아름답게 풀리기 때문입니다.", + "Many people find `apply t at h` easy, but some find `apply t` confusing.\nIf you find it confusing, then just argue forwards.\n\nYou can read more about the `apply` tactic in its documentation, which you can view by\nclicking on the tactic in the list on the right.": + "많은 사람은 `apply t at h`는 쉽다고 느끼지만 `apply t`은 헷갈려 합니다. 헷갈린다면 그냥 앞에서부터 추론하세요.\n\n`apply` tactic에 대한 자세한 설명은 오른쪽 tactic 목록에서 클릭해 볼 수 있습니다.", + "Let's warm up with an easy one, which works even if `t = 0`.": + "`t = 0`인 경우에도 작동하는 쉬운 문제로 몸을 풀어 봅시다.", + "Let's see if you can use the tactics we've learnt to prove $x+1=y+1\\implies x=y$.\nTry this one by yourself; if you need help then click on \"Show more help!\".": + "지금까지 배운 tactic들을 사용해 $x+1=y+1\\implies x=y$를 증명해 보세요. 먼저 혼자 시도해 보고, 도움이 필요하면 \"도움말 더 보기!\"를 누르세요.", + "Let's now move on to a more efficient approach to questions\ninvolving numerals, such as `20 + 20 = 40`.": + "이제 `20 + 20 = 40` 같은 숫자 관련 문제를 더 효율적으로 푸는 방법으로 넘어갑시다.", + "Let's now make our own tactic to do this.": + "이제 이 일을 하는 우리만의 tactic을 만들어 봅시다.", + "Let's now learn about Peano's second axiom for addition, `add_succ`.": + "이제 덧셈에 관한 페아노의 두 번째 공리 `add_succ`를 배워 봅시다.", + "Let's now begin our approach to the final boss,\nby proving some more subtle facts about powers.": + "이제 거듭제곱에 관한 좀 더 미묘한 사실들을 증명하면서 final boss로 가는 길을 시작합시다.", + "Let's first get `h` into the form `succ x = succ 3` so we can\napply `succ_inj`. First execute `rw [four_eq_succ_three] at h`\nto change the 4 on the right hand side.": + "먼저 `succ_inj`를 적용할 수 있도록 `h`를 `succ x = succ 3` 꼴로 바꿉시다. 오른쪽의 4를 바꾸기 위해 먼저 `rw [four_eq_succ_three] at h`을 해보세요..", + "Lean's simplifier, `simp`, is \"`rw` on steroids\". It will rewrite every lemma\ntagged with `simp` and every lemma fed to it by the user, as much as it can.\n\nThis level is not a level which you want to solve by hand.\nGet the simplifier to solve it for you.": + "Lean의 simplifier `simp`는 \"`rw`에 스테로이드를 먹인 것\"과 같습니다. `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다.\n\n이 level은 손으로 풀고 싶을 만한 문제가 아닙니다. simplifier에게 맡기세요.", + "It's all over! You have proved a theorem which has tripped up\nschoolkids for generations (some of them think $(a+b)^2=a^2+b^2$:\nthis is \"the freshman's dream\").\n\nHow many rewrites did you use? I can do it in 12.\n\nBut wait! This boss is stirring...and mutating into a second more powerful form!": + "끝났습니다! 여러 세대의 학생들을 괴롭혀 온 정리를 증명했습니다\n(어떤 학생들은 $(a+b)^2=a^2+b^2$라고 생각하죠. 이것이 바로 “새내기의 꿈”입니다).\n\nrewrite를 몇 번 썼나요? 저는 12번이면 됩니다.\n\n그런데 잠깐! 보스가 꿈틀거리더니... 더 강력한 두 번째 형태로 변신합니다!", + "It's \"intuitively obvious\" that there are no numbers less than zero,\nbut to prove it you will need a result which you showed in advanced\naddition world.": + "0보다 작은 수가 없다는 것은 \"직관적으로 명백\"하지만, 이를 증명하려면 Advanced Addition World에서 증명한 결과가 필요합니다.", + "Induction on `a` will not work here. You are still stuck with an `+ b`.\nI suggest you delete this line and try a different approach.": + "Induction on `a` will not work here. You are still stuck with an `+ b`.\nI suggest you delete this line and try a different approach.", + "Induction on `a` or `b` -- it's all the same in this one.": + "이번에는 `a`에 귀납하든 `b`에 귀납하든 똑같습니다.", + "Induction on `a` is the most troublesome, then `b`,\nand `c` is the easiest.": + "`a`에 대한 귀납이 가장 까다롭고, 그다음이 `b`, `c`가 가장 쉽습니다.", + "In this world we'll learn how to prove theorems of the form $P\\implies Q$.\nIn other words, how to prove theorems of the form \"if $P$ is true, then $Q$ is true.\"\nTo do that we need to learn some more tactics.\n\nThe `exact` tactic can be used to close a goal which is exactly one of\nthe hypotheses. It takes the name of the hypothesis as argument: `exact h`.": + "이 world에서는 $P\\implies Q$ 꼴의 정리를 증명하는 법을 배웁니다. 즉 \"$P$이 참이면 $Q$가 참이다\" 꼴의 정리를 증명하는 법입니다. 이를 위해 몇 가지 tactic을 더 배워야 합니다.\n\n`exact` tactic은 goal이 가정 중 하나와 정확히 같을 때 goal을 닫을 수 있습니다. 인자로 가정의 이름을 받습니다: `exact h`.", + "In this world we define `a ≤ b` and prove standard facts\nabout it, such as \"if `a ≤ b` and `b ≤ c` then `a ≤ c`.\"\n\nThe definition of `a ≤ b` is \"there exists a number `c`\nsuch that `b = a + c`. \" So we're going to have to learn\na tactic to prove \"exists\" theorems, and another one\nto use \"exists\" hypotheses.\n\nClick on \"Start\" to proceed.": + "이 world에서는 `a ≤ b`를 정의하고, \"`a ≤ b`이고 `b ≤ c`이면 `a ≤ c`\" 같은 표준적인 성질을 증명합니다.\n\n`a ≤ b`의 정의는 \"`b = a + c`를 만족하는 수 `c`가 존재한다\"입니다. 따라서 \"존재한다\"는 정리를 증명하는 tactic과 \"존재한다\"는 가정을 사용하는 tactic을 배워야 합니다.\n\n\"Start\"를 눌러 진행하세요.", + "In this world I will mostly leave you on your own.\n\n`add_right_cancel a b n` is the theorem that $a+n=b+n\\implies a=b$.": + "이 world에서는 대부분 여러분 스스로 하도록 두겠습니다.\n\n`add_right_cancel a b n`는 $a+n=b+n\\implies a=b$이라는 정리입니다.", + "In this level, we see inequalities as *hypotheses*. We have not seen this before.\nThe `cases` tactic can be used to take `hxy` apart.": + "이 level에서는 부등식을 *가정*으로 처음 만나 봅니다. `cases` tactic을 사용하면 `hxy`을 분해할 수 있습니다.", + "In this level, the hypothesis §0 is an *implication*. It says\nthat *if* §1 *then* §2. We can use this\nhypothesis with the §3 tactic. Remember you can click on\n§4 or any other tactic on the right to see a detailed explanation\nof what it does, with examples.": + "이 level의 가정 §0는 *함의*입니다. 즉 *§1이면 §2*라는 뜻입니다. 이 가정은 §3 tactic으로 사용할 수 있습니다. 오른쪽의 §4나 다른 tactic을 클릭하면 예시와 함께 자세한 설명을 볼 수 있다는 점을 기억하세요.", + "In this level, the hypotheses `h2` is an *implication*. It says\nthat *if* `x = 37` *then* `y = 42`. We can use this\nhypothesis with the `apply` tactic. Remember you can click on\n`apply` or any other tactic on the right to see a detailed explanation\nof what it does, with examples.": + "In this level, the hypotheses `h2` is an *implication*. It says\nthat *if* `x = 37` *then* `y = 42`. We can use this\nhypothesis with the `apply` tactic. Remember you can click on\n`apply` or any other tactic on the right to see a detailed explanation\nof what it does, with examples.", + "In this level we're going to prove that $0+n=n$, where $n$ is a secret natural number.\n\nWait, don't we already know that? No! We know that $n+0=n$, but that's `add_zero`.\nThis is `zero_add`, which is different.\n\nThe difficulty with proving `0 + n = n` is that we do not have a *formula* for\n`0 + n` in general, we can only use `add_zero` and `add_succ` once\nwe know whether `n` is `0` or a successor. The `induction` tactic splits into these two cases.\n\nThe base case will require us to prove `0 + 0 = 0`, and the inductive step\nwill ask us to show that if `0 + d = d` then `0 + succ d = succ d`. Because\n`0` and successor are the only way to make numbers, this will cover all the cases.\n\nSee if you can do your first induction proof in Lean.\n\n(By the way, if you are still in the \"Editor mode\" from the last world, you can swap\nback to \"Typewriter mode\" by clicking the `>_` button in the top right.)": + "이 level에서는 $0+n=n$를 증명합니다. 여기서 $n$은 값이 공개되지 않은 자연수입니다.\n\n잠깐, 이건 이미 아는 것 아닌가요? 아닙니다! 우리가 아는 것은 $n+0=n$인데, 그건 `add_zero`입니다. 지금 필요한 것은 `zero_add`이고, 둘은 다릅니다.\n\n`0 + n = n`를 증명하기 어려운 이유는 일반적인 `0 + n`에 대한 *공식*이 없기 때문입니다. `n`가 $n$0인지 successor인지 알아야만 `add_zero`과 `add_succ`을 사용할 수 있습니다. $n$1 tactic은 이 두 경우로 나눠 줍니다.\n\n기저 경우에서는 $n$2를 증명해야 하고, 귀납 단계에서는 $n$3이면 $n$4임을 보이라는 목표가 생깁니다. 수를 만드는 방법은 $n$5와 successor뿐이므로 이것으로 모든 경우를 다룹니다.\n\nLean에서 첫 귀납 증명을 해 보세요.\n\n(참고로 이전 world에서 아직 \"Editor mode\"에 있다면, 오른쪽 위의 $n$6 버튼을 눌러 \"Typewriter mode\"로 돌아갈 수 있습니다.)", + "In this level we prove that if `a * b = a * c` and `a ≠ 0` then `b = c`. It is tricky, for\nseveral reasons. One of these is that\nwe need to introduce a new idea: we will need to understand the concept of\nmathematical induction a little better.\n\nStarting with `induction b with d hd` is too naive, because in the inductive step\nthe hypothesis is `a * d = a * c → d = c` but what we know is `a * succ d = a * c`,\nso the induction hypothesis does not apply!\n\nAssume `a ≠ 0` is fixed. The actual statement we want to prove by induction on `b` is\n\"for all `c`, if `a * b = a * c` then `b = c`\". This *can* be proved by induction,\nbecause we now have the flexibility to change `c`.": + "이 level에서는 `a * b = a * c`와 `a ≠ 0`이면 `b = c`임을 증명합니다. 여러 이유로 까다로운데, 그중 하나는 새로운 생각이 필요하다는 점입니다. 수학적 귀납법을 조금 더 깊이 이해해야 합니다.\n\n`induction b with d hd`으로 시작하는 것은 너무 순진합니다. 귀납 단계에서 귀납가정은 `a * d = a * c → d = c`인데 실제로 알고 있는 것은 `a * succ d = a * c`이므로 귀납가정을 적용할 수 없기 때문입니다!\n\n`a ≠ 0`가 고정되어 있다고 합시다. `b`에 대해 실제로 귀납하여 증명해야 하는 명제는 \"모든 `c`에 대해, `a * b = a * c`이면 `a ≠ 0`0\"입니다. 이렇게 하면 `a ≠ 0`1을 바꿀 수 있는 여지가 생기므로 귀납법으로 증명할 *수 있습니다*.", + "In this level the *goal* is §0 but to help us we\nhave an *assumption* §1 saying that §2. Check that you can see §3 in\nyour list of assumptions. Lean thinks of §4 as being a secret proof of the\nassumption, rather like §5 is a secret number.\n\nBefore we can use §6, we have to \"substitute in for §7\".\nWe do this in Lean by *rewriting* the goal with §8,\nusing the §9 tactic.": + "이 level의 *goal*은 §0이지만, 이를 돕기 위해 §2라고 말하는 *가정* §1이 있습니다. 가정 목록에서 §3이 보이는지 확인하세요. Lean은 §4를 이 가정의 비밀스러운 증명이라고 생각합니다. §5가 비밀스러운 수인 것과 비슷합니다.\n\n§6을 쓰기 전에 먼저 \"§7에 대입\"해야 합니다. Lean에서는 §9 tactic을 사용해 증명 §8을 *rewriting*함으로써 이를 수행합니다.", + "In this level the *goal* is $2y=2(x+7)$ but to help us we\nhave an *assumption* `h` saying that $y = x + 7$. Check that you can see `h` in\nyour list of assumptions. Lean thinks of `h` as being a secret proof of the\nassumption, rather like `x` is a secret number.\n\nBefore we can use `rfl`, we have to \"substitute in for $y$\".\nWe do this in Lean by *rewriting* the proof `h`,\nusing the `rw` tactic.": + "In this level the *goal* is $2y=2(x+7)$ but to help us we\nhave an *assumption* `h` saying that $y = x + 7$. Check that you can see `h` in\nyour list of assumptions. Lean thinks of `h` as being a secret proof of the\nassumption, rather like `x` is a secret number.\n\nBefore we can use `rfl`, we have to \"substitute in for $y$\".\nWe do this in Lean by *rewriting* the proof `h`,\nusing the `rw` tactic.", + "In this game you recreate the natural numbers $\\mathbb{N}$ from the Peano axioms,\nlearning the basics about theorem proving in Lean.\n\nThis is a good first introduction to Lean!": + "이 게임에서는 페아노 공리로부터 자연수 $\\mathbb{N}$를 다시 만들어 가면서 Lean에서 정리를 증명하는 기초를 배웁니다.\n\nLean을 처음 접하기에 좋은 입문입니다!", + "In the next level, we'll do the same proof but backwards.": + "다음 level에서는 같은 증명을 거꾸로 해 보겠습니다.", + "In the last level, we manipulated the hypothesis `x + 1 = 4`\n until it became the goal `x = 3`. In this level we'll manipulate\n the goal until it becomes our hypothesis! In other words, we\n will \"argue backwards\". The `apply` tactic can do this too.\n Again I will walk you through this one (assuming you're in\n command line mode).": + "지난 level에서는 가정 `x + 1 = 4`를 goal `x = 3`이 될 때까지 변형했습니다. 이번에는 반대로 goal을 가정이 될 때까지 변형합니다! 즉 \"거꾸로 추론\"할 것입니다. `apply` tactic도 이렇게 사용할 수 있습니다. 이번에도 command line mode라고 가정하고 단계별로 안내하겠습니다.", + "In the \"base case\" we have a hypothesis `ha : 0 ≠ 0`, and you can deduce anything\nfrom a false statement. The `tauto` tactic will close this goal.": + "\"기저 경우\"에서는 가정 `ha : 0 ≠ 0`가 있습니다. 거짓 명제에서는 무엇이든 이끌어낼 수 있으므로 `tauto` tactic이 이 goal을 닫습니다.", + "In some later worlds, we're going to see some much nastier levels,\nlike `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`.\nBrackets need to be moved around, and variables need to be swapped.\n\nIn this level, `(a + b) + (c + d) = ((a + c) + d) + b`,\nlet's forget about the brackets and just think about\nthe variable order.\nTo turn `a+b+c+d` into `a+c+d+b` we need to swap `b` and `c`,\nand then swap `b` and `d`. But this is easier than you\nthink with `add_left_comm`.": + "뒤쪽 world에서는 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`처럼 훨씬 더 험악한 level들을 만나게 됩니다. 괄호를 옮기고 변수들의 순서도 바꿔야 합니다.\n\n이 level의 `(a + b) + (c + d) = ((a + c) + d) + b`에서는 괄호는 잠시 잊고 변수의 순서만 생각해 봅시다. `a+b+c+d`를 `a+c+d+b`으로 바꾸려면 `b`와 `c`를 바꾸고, 이어서 `b`와 `d`을 바꿔야 합니다. 하지만 `add_left_comm`을 쓰면 생각보다 쉽습니다.", + "In order to use the tactic `rfl` you can enter it in the text box\nunder the goal and hit \"Execute\".": + "`rfl` tactic을 사용하려면 goal 아래의 텍스트 상자에 입력한 뒤 \"Execute\"를 누르면 됩니다.", + "In Advanced Addition World we will prove some basic\naddition facts such as $x+y=x\\implies y=0$. The theorems\nproved in this world will be used to build\na theory of inequalities in `≤` World.\n\nClick on \"Start\" to proceed.": + "Advanced Addition World에서는 $x+y=x\\implies y=0$ 같은 기본적인 덧셈의 성질을 증명합니다. 여기서 증명한 정리들은 `≤` World에서 부등식 이론을 만드는 데 사용됩니다.\n\n\"Start\"를 눌러 진행하세요.", + "Implication World": "함의 월드", + "Implementing the algorithm for equality of naturals, and the proof that it is correct,\nlooks like this:\n\n```\ninstance instDecidableEq : DecidableEq ℕ\n| 0, 0 => isTrue <| by\n show 0 = 0\n rfl\n| succ m, 0 => isFalse <| by\n show succ m ≠ 0\n exact succ_ne_zero m\n| 0, succ n => isFalse <| by\n show 0 ≠ succ n\n exact zero_ne_succ n\n| succ m, succ n =>\n match instDecidableEq m n with\n | isTrue (h : m = n) => isTrue <| by\n show succ m = succ n\n rw [h]\n rfl\n | isFalse (h : m ≠ n) => isFalse <| by\n show succ m ≠ succ n\n exact succ_ne_succ m n h\n```\n\nThis Lean code is a formally verified algorithm for deciding equality\nbetween two naturals. I've typed it in already, behind the scenes.\nBecause the algorithm is formally verified to be correct, we can\nuse it in Lean proofs. You can run the algorithm with the `decide` tactic.": + "자연수의 동등성을 판정하는 알고리즘과 그 정확성 증명을 구현하면 다음과 같습니다:\n\n```\ninstance instDecidableEq : DecidableEq ℕ\n| 0, 0 => isTrue <| by\n show 0 = 0\n rfl\n| succ m, 0 => isFalse <| by\n show succ m ≠ 0\n exact succ_ne_zero m\n| 0, succ n => isFalse <| by\n show 0 ≠ succ n\n exact zero_ne_succ n\n| succ m, succ n =>\n match instDecidableEq m n with\n | isTrue (h : m = n) => isTrue <| by\n show succ m = succ n\n rw [h]\n rfl\n | isFalse (h : m ≠ n) => isFalse <| by\n show succ m ≠ succ n\n exact succ_ne_succ m n h\n```\n\n이 Lean 코드는 두 자연수의 동등성을 판정하는 형식 검증된 알고리즘입니다. 이미 뒤에서 입력해 두었습니다. 알고리즘의 정확성까지 형식적으로 검증되었으므로 Lean 증명에서 사용할 수 있습니다. `decide` tactic으로 이 알고리즘을 실행할 수 있습니다.", + "If you have completed Algorithm World then you can use the `contrapose!` tactic\nhere. If not then I'll talk you through a manual approach.": + "만약 알고리듬 월드를 완료했다면 `contrapose!` tactic을 사용하실 수 있습니다. 그렇지 않다면 우회 방법에 대해 가르쳐 드릴게ㅇ", + "If you `use` the wrong number, you get stuck with a goal you can't prove.\nWhat number will you `use` here?": + "잘못된 수를 `use`하면 증명할 수 없는 goal에 막힙니다. 여기서는 어떤 수를 `use`해야 할까요?", + "If the goal is not *exactly* a hypothesis, we can sometimes\nuse rewrites to fix things up.": + "goal이 가정과 *정확히* 같지 않더라도 rewrite를 이용해 고칠 수 있는 경우가 있습니다.", + "If `h` is a proof of `X = Y` then `rw [h]` will\nturn `X`s into `Y`s. But what if we want to\nturn `Y`s into `X`s? To tell the `rw` tactic\nwe want this, we use a left arrow `←`. Type\n`\\l` and then hit the space bar to get this arrow.\n\nLet's prove that $2$ is the number after the number\nafter $0$ again, this time by changing `succ (succ 0)`\ninto `2`.": + "`h`가 `X = Y`의 증명이라면 `rw [h]`는 `X`을 `Y`로 바꿉니다. 그렇다면 반대로 `Y`를 `X`으로 바꾸고 싶을 때는 어떻게 해야 할까요? `rw` tactic에 이 방향으로 바꾸라고 알려 주려면 왼쪽 화살표 `←`를 사용합니다. `\\l`를 입력한 뒤 스페이스바를 누르면 이 화살표가 입력됩니다.\n\n이번에는 `X = Y`2를 `X = Y`3으로 바꾸는 방법으로, `X = Y`0이 `X = Y`1의 다음 수의 다음 수라는 사실을 다시 증명해 봅시다.", + "If `a` and `b` are numbers, then `succ_inj a b` is a proof\nthat `succ a = succ b` implies `a = b`. Click on this theorem in the *Peano*\ntab for more information.\n\nPeano had this theorem as an axiom, but in Algorithm World\nwe will show how to prove it in Lean. Right now let's just assume it,\nand let's prove $x+1=4 \\implies x=3$ using it. Again, we will proceed\nby manipulating our hypothesis until it becomes the goal. I will\nwalk you through this level.": + "`a`와 `b`이 수라면 `succ_inj a b`는 `succ a = succ b`이면 `a = b`라는 것의 증명입니다. 더 알아보려면 *Peano* 탭에서 이 정리를 클릭하세요.\n\n페아노는 이 정리를 공리로 두었지만 Algorithm World에서는 Lean으로 이를 증명하는 방법을 보게 됩니다. 지금은 그냥 가정하고, 이를 이용해 $x+1=4 \\implies x=3$를 증명합시다. 이번에도 가정을 goal과 같아질 때까지 변형해 나가겠습니다. 이 level은 제가 단계별로 안내하겠습니다.", + "If $x=y$ and $x \\neq y$ then we can deduce a contradiction.": + "$x=y$와 $x \\neq y$이 모두 성립하면 모순을 이끌어낼 수 있습니다.", + "If $x=37$ or $y=42$, then $y=42$ or $x=37$.": + "$x=37$ 또는 $y=42$이면, $y=42$ 또는 $x=37$입니다.", + "If $x=37$ and we know that $x=37\\implies y=42$ then we can deduce $y=42$.": + "$x=37$이고 $x=37\\implies y=42$임을 알고 있다면 $y=42$를 이끌어낼 수 있습니다.", + "If $x+1=4$ then $x=3$.": "$x+1=4$이면 $x=3$입니다.", + "If $x$ is a number, then $x \\le x$.": "$x$가 수라면 $x \\le x$입니다.", + "If $x$ is a number, then $x \\le \\operatorname{succ}(x)$.": + "$x$가 수라면 $x \\le \\operatorname{succ}(x)$입니다.", + "If $x$ is a number, then $0 \\le x$.": "$x$가 수라면 $0 \\le x$입니다.", + "If $x$ and $y$ are numbers, then either $x \\leq y$ or $y \\leq x$.": + "$x$와 $y$이 수라면 $x \\leq y$ 또는 $y \\leq x$입니다.", + "If $x$ and $y$ are natural numbers, and $y = x + 7$, then $2y = 2(x + 7)$.": + "$x$와 $y$이 자연수이고 $y = x + 7$라면 $2y = 2(x + 7)$입니다.", + "If $x$ and $q$ are arbitrary natural numbers, then $37x+q=37x+q.$": + "$x$와 $q$이 임의의 자연수라면 $37x+q=37x+q.$입니다.", + "If $x \\leq y$ and $y \\leq z$, then $x \\leq z$.": + "$x \\leq y$이고 $y \\leq z$이면 $x \\leq z$입니다.", + "If $x \\leq y$ and $y \\leq x$, then $x = y$.": + "$x \\leq y$이고 $y \\leq x$이면 $x = y$입니다.", + "If $x \\leq 2$ then $x = 0$ or $1$ or $2$.": + "$x \\leq 2$이면 $x = 0$ 또는 $1$ 또는 $2$입니다.", + "If $x \\leq 1$ then either $x = 0$ or $x = 1$.": + "$x \\leq 1$이면 $x = 0$ 또는 $x = 1$입니다.", + "If $x \\leq 0$, then $x=0$.": "$x \\leq 0$,이면 $x=0$입니다.", + "If $a, b,\\ldots h$ are arbitrary natural numbers, we have\n$(d + f) + (h + (a + c)) + (g + e + b) = a + b + c + d + e + f + g + h$.": + "$a, b,\\ldots h$가 임의의 자연수라면 $(d + f) + (h + (a + c)) + (g + e + b) = a + b + c + d + e + f + g + h$입니다.", + "If $a, b, c$ are numbers, then $a+(b+c)=b+(a+c)$.": + "$a, b, c$가 수라면 $a+(b+c)=b+(a+c)$입니다.", + "If $a, b$, $c$ and $d$ are numbers, we have\n$(a + b) + (c + d) = ((a + c) + d) + b.$": + "$a, b$, $c$, $d$가 수라면 $(a + b) + (c + d) = ((a + c) + d) + b.$입니다.", + "If $a, b$ and $c$ are arbitrary natural numbers, we have\n$(a + b) + c = (a + c) + b$.": + "$a, b$와 $c$이 임의의 자연수라면 $(a + b) + c = (a + c) + b$입니다.", + "If $a+b=0$ then $b=0$.": "$a+b=0$이면 $b=0$입니다.", + "If $a+b=0$ then $a=0$.": "$a+b=0$이면 $a=0$입니다.", + "If $a \\neq b$ then $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$.": + "$a \\neq b$이면 $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$입니다.", + "If $\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$ then $x \\leq y$.": + "$\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$이면 $x \\leq y$입니다.", + "If $\\operatorname{succ}(a)=\\operatorname{succ}(b)$ then $a=b$.": + "$\\operatorname{succ}(a)=\\operatorname{succ}(b)$이면 $a=b$입니다.", + "How should we define `37 * x`? Just like addition, we need to give definitions\nwhen $x=0$ and when $x$ is a successor.\n\nThe zero case is easy: we define `37 * 0` to be `0`. Now say we know\n`37 * d`. What should `37 * succ d` be? Well, that's $(d+1)$ $37$s,\nso it should be `37 * d + 37`.\n\nHere are the definitions in Lean.\n\n * `mul_zero a : a * 0 = 0`\n * `mul_succ a d : a * succ d = a * d + a`\n\nIn this world, we must not only prove facts about multiplication like `a * b = b * a`,\nwe must also prove facts about how multiplication interacts with addition, like `a * (b + c) = a * b + a * c`.\nLet's get started.": + "`37 * x`를 어떻게 정의해야 할까요? 덧셈과 마찬가지로 $x=0$일 때와 $x$가 successor일 때를 각각 정의해야 합니다.\n\n0인 경우는 쉽습니다. `37 * 0`을 `0`로 정의합니다. 이제 `37 * d`를 안다고 합시다. `37 * succ d`은 무엇이어야 할까요? 이는 $(d+1)$개의 $37$이므로 `37 * d + 37`여야 합니다.\n\nLean에서의 정의는 다음과 같습니다.\n\n * $x=0$0\n * $x=0$1\n\n이 world에서는 $x=0$2 같은 곱셈의 성질뿐 아니라 $x=0$3처럼 곱셈과 덧셈이 어떻게 상호작용하는지도 증명해야 합니다. 시작해 봅시다.", + "How about this for a proof:\n```\nrepeat rw [add_comm n]\nexact add_right_cancel a b n\n```": + "이런 증명은 어떤가요?\n```\nrepeat rw [add_comm n]\nexact add_right_cancel a b n\n```", + "How about this for a proof:\n\n```\nrw [add_comm]\nexact add_right_eq_zero b a\n```\n\nThat's the end of Advanced Addition World! You'll need these theorems\nfor the next world, `≤` World. Click on \"Home\" to access it.": + "이런 증명은 어떤가요?\n\n```\nrw [add_comm]\nexact add_right_eq_zero b a\n```\n\nAdvanced Addition World는 여기까지입니다! 다음 `≤` World에서는 여기서 얻은 정리들이 필요합니다. \"Home\"을 눌러 이동하세요.", + "Here's what I was thinking of:\n```\napply mul_left_ne_zero at h\napply one_le_of_ne_zero at h\napply mul_le_mul_right 1 b a at h\nrw [one_mul, mul_comm] at h\nexact h\n```": + "제가 생각한 증명은 이겁니다:\n```\napply mul_left_ne_zero at h\napply one_le_of_ne_zero at h\napply mul_le_mul_right 1 b a at h\nrw [one_mul, mul_comm] at h\nexact h\n```", + "Here's the short proof:\n```\nhave h2 := mul_ne_zero a b\ntauto\n```\nThis works because, given `mul_ne_zero a b`,\nthe argument is reduced to pure logic.": + "짧은 증명은 다음과 같습니다:\n```\nhave h2 := mul_ne_zero a b\ntauto\n```\n`mul_ne_zero a b`이 주어지면 문제가 순수 논리로 환원되기 때문에 작동합니다.", + "Here's my solution:\n```\nrw [two_eq_succ_one, succ_mul, one_mul]\nrfl\n```": + "제 해법은 다음과 같습니다:\n```\nrw [two_eq_succ_one, succ_mul, one_mul]\nrfl\n```", + "Here's my solution:\n```\nrw [mul_comm, mul_one]\nrfl\n```": + "제 해법은 다음과 같습니다:\n```\nrw [mul_comm, mul_one]\nrfl\n```", + "Here's my solution:\n```\ninduction c with d hd\nrw [add_zero, mul_zero, add_zero]\nrfl\nrw [add_succ, mul_succ, hd, mul_succ, add_assoc]\nrfl\n```\n\nInducting on `a` or `b` also works, but might take longer.": + "제 해법은 이렇습니다:\n```\ninduction c with d hd\nrw [add_zero, mul_zero, add_zero]\nrfl\nrw [add_succ, mul_succ, hd, mul_succ, add_assoc]\nrfl\n```\n\n`a`이나 `b`에 귀납해도 되지만 더 오래 걸릴 수 있습니다.", + "Here's my proof:\n```\nrw [mul_comm, mul_add]\nrepeat rw [mul_comm c]\nrfl\n```": + "제 증명은 이렇습니다:\n```\nrw [mul_comm, mul_add]\nrepeat rw [mul_comm c]\nrfl\n```", + "Here's my proof:\n```\nintro h\nrw [add_succ, add_succ, add_zero] at h\nrepeat apply succ_inj at h\napply zero_ne_succ at h\nexact h\n```\n\nEven though Lean is a theorem prover, right now it's pretty clear that we have not\ndeveloped enough material to make it an adequate calculator. In Algorithm\nWorld, a more computer-sciency world, we will develop machinery which makes\nquestions like this much easier, and goals like $20 + 20 ≠ 41$ feasible.\nAlternatively you can do more mathematics in Advanced Addition World, where we prove\nthe lemmas needed to get a working theory of inequalities. Click \"Home\" and\ndecide your route.": + "제 증명은 이렇습니다:\n```\nintro h\nrw [add_succ, add_succ, add_zero] at h\nrepeat apply succ_inj at h\napply zero_ne_succ at h\nexact h\n```\n\nLean은 정리 증명기지만, 지금까지 만든 것만으로는 계산기로 쓰기에 아직 부족하다는 게 분명합니다. 좀 더 컴퓨터과학적인 Algorithm World에서는 이런 문제를 훨씬 쉽게 만들고 $20 + 20 ≠ 41$ 같은 목표도 다룰 수 있게 해 주는 도구를 개발합니다.\n대신 Advanced Addition World로 가서 수학을 더 진행할 수도 있습니다. 거기서는 부등식 이론을 제대로 만들기 위해 필요한 보조정리들을 증명합니다. \"Home\"을 누르고 어느 길로 갈지 선택하세요.", + "Here's my proof:\n```\ncases x with y\nleft\nrfl\nrw [one_eq_succ_zero] at hx ⊢\napply succ_le_succ at hx\napply le_zero at hx\nrw [hx]\nright\nrfl\n```\n\nIf you solved this level then you should be fine with the next level!": + "제 증명은 이렇습니다:\n```\ncases x with y\nleft\nrfl\nrw [one_eq_succ_zero] at hx ⊢\napply succ_le_succ at hx\napply le_zero at hx\nrw [hx]\nright\nrfl\n```\n\n이 level을 풀었다면 다음 level도 문제없을 겁니다!", + "Here's my proof:\n```\ncases hxy with a ha\ncases hyx with b hb\nrw [ha]\nrw [ha, add_assoc] at hb\nsymm at hb\napply add_right_eq_self at hb\napply add_right_eq_zero at hb\nrw [hb, add_zero]\nrfl\n```\n\nA passing mathematician remarks that with antisymmetry as well,\nyou have proved that `≤` is a *partial order* on `ℕ`.\n\nThe boss level of this world is to prove\nthat `≤` is a total order. Let's learn two more easy tactics\nfirst.": + "제 증명은 이렇습니다:\n```\ncases hxy with a ha\ncases hyx with b hb\nrw [ha]\nrw [ha, add_assoc] at hb\nsymm at hb\napply add_right_eq_self at hb\napply add_right_eq_zero at hb\nrw [hb, add_zero]\nrfl\n```\n\n지나가던 수학자가 이제 반대칭성까지 있으므로 `ℕ` 위의 `≤`이 *partial order*임을 증명했다고 말합니다.\n\n이 world의 boss level은 `≤`가 total order임을 증명하는 것입니다. 그 전에 쉬운 tactic 두 개를 더 배워 봅시다.", + "Here's my proof:\n```\ncases hx with d hd\nuse d\nrw [succ_add] at hd\napply succ_inj at hd\nexact hd\n```": + "제 증명은 이렇습니다:\n```\ncases hx with d hd\nuse d\nrw [succ_add] at hd\napply succ_inj at hd\nexact hd\n```", + "Here's a two-liner:\n```\nuse 1\nexact succ_eq_add_one x\n```\n\nThis works because `succ_eq_add_one x` is a proof of `succ x = x + 1`.": + "두 줄이면 됩니다:\n```\nuse 1\nexact succ_eq_add_one x\n```\n\n`succ_eq_add_one x`이 `succ x = x + 1`의 증명이기 때문에 작동합니다.", + "Here's a two-line proof:\n```\nrepeat rw [zero_add] at h\nexact h\n```": + "두 줄짜리 증명은 다음과 같습니다:\n```\nrepeat rw [zero_add] at h\nexact h\n```", + "Here's a proof using `add_left_eq_self`:\n```\nrw [add_comm]\nintro h\napply add_left_eq_self at h\nexact h\n```\n\nand here's an even shorter one using the same idea:\n```\nrw [add_comm]\nexact add_left_eq_self y x\n```\n\nAlternatively you can just prove it by induction on `x`:\n\n```\ninduction x with d hd\nintro h\nrw [zero_add] at h\nexact h\nintro h\nrw [succ_add] at h\napply succ_inj at h\napply hd at h\nexact h\n```": + "`add_left_eq_self`를 사용한 증명은 다음과 같습니다:\n```\nrw [add_comm]\nintro h\napply add_left_eq_self at h\nexact h\n```\n\n같은 아이디어로 더 짧게 하면:\n```\nrw [add_comm]\nexact add_left_eq_self y x\n```\n\n또는 `x`에 대해 바로 귀납법으로 증명할 수도 있습니다:\n\n```\ninduction x with d hd\nintro h\nrw [zero_add] at h\nexact h\nintro h\nrw [succ_add] at h\napply succ_inj at h\napply hd at h\nexact h\n```", + "Here's a completely backwards proof:\n```\nintro h\napply succ_inj\nrepeat rw [succ_eq_add_one]\nexact h\n```": + "완전히 거꾸로 가는 증명은 다음과 같습니다:\n```\nintro h\napply succ_inj\nrepeat rw [succ_eq_add_one]\nexact h\n```", + "Here we want to deal with the cases `b = 0` and `b ≠ 0` separately,\nso start with `cases b with d`.": + "여기서는 `b = 0`와 `b ≠ 0` 경우를 따로 다루고 싶으므로 `cases b with d`로 시작하세요.", + "Here we begin to\ndevelop an algorithm which, given two naturals `a` and `b`, returns the answer\nto \"does `a = b`?\"\n\nHere is the algorithm. First note that `a` and `b` are numbers, and hence\nare either `0` or successors.\n\n*) If `a` and `b` are both `0`, return \"yes\".\n\n*) If one is `0` and the other is `succ n`, return \"no\".\n\n*) If `a = succ m` and `b = succ n`, then return the answer to \"does `m = n`?\"\n\nOur job now is to *prove* that this algorithm always gives the correct answer. The proof that\n`0 = 0` is `rfl`. The proof that `0 ≠ succ n` is `zero_ne_succ n`, and the proof\nthat `succ m ≠ 0` is `succ_ne_zero m`. The proof that if `h : m = n` then\n`succ m = succ n` is `rw [h]` and then `rfl`. This level is a proof of the one\nremaining job we have to do: if `a ≠ b` then `succ a ≠ succ b`.": + "여기서는 두 자연수 `a`와 `b`을 받아 \"`a = b`인가?\"에 대한 답을 돌려주는 알고리즘을 만들기 시작합니다.\n\n알고리즘은 다음과 같습니다. 먼저 `a`와 `b`는 수이므로 각각 `0`이거나 successor입니다.\n\n*) `a`와 `b`이 둘 다 `0`이면 \"yes\"를 반환합니다.\n\n*) 하나가 `0`이고 다른 하나가 `b`0이면 \"no\"를 반환합니다.\n\n*) `b`1이고 `b`2이면 \"`b`3인가?\"에 대한 답을 반환합니다.\n\n이제 이 알고리즘이 항상 올바른 답을 준다는 것을 *증명*해야 합니다. `b`4의 증명은 `b`5입니다. `b`6의 증명은 `b`7이고, `b`8의 증명은 `b`9입니다. `a = b`0이면 `a = b`1이라는 증명은 `a = b`2를 한 뒤 `a = b`3을 하면 됩니다. 이 level에서는 남은 마지막 경우, 즉 `a = b`4이면 `a = b`5라는 것을 증명합니다.", + "Here is an example proof of 2+2=4 showing off various techniques.\n\n```lean\nnth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`.\nrw [add_succ]\nrw [one_eq_succ_zero]\nrw [add_succ, add_zero] -- two rewrites at once\nrw [← three_eq_succ_two] -- change `succ 2` to `3`\nrw [← four_eq_succ_three]\nrfl\n```\n\nOptional extra: you can run this proof yourself. Switch the game into \"Editor mode\" by clicking\non the `` button in the top right. You can now see your proof\nwritten as several lines of code. Move your cursor between lines to see\nthe goal state at any point. Now cut and paste your code elsewhere if you\nwant to save it, and paste the above proof in instead. Move your cursor\naround to investigate. When you've finished, click the `>_` button in the top right to\nmove back into \"Typewriter mode\".\n\nYou have finished tutorial world!\nClick \"Home\" to go back to the\noverworld, and select Addition World, where you will learn\nabout the `induction` tactic.": + "여러 기법을 보여 주는 2+2=4의 예시 증명입니다.\n\n```lean\nnth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`.\nrw [add_succ]\nrw [one_eq_succ_zero]\nrw [add_succ, add_zero] -- two rewrites at once\nrw [← three_eq_succ_two] -- change `succ 2` to `3`\nrw [← four_eq_succ_three]\nrfl\n```\n\n선택 사항: 이 증명을 직접 실행해 볼 수도 있습니다. 오른쪽 위의 `` 버튼을 눌러 게임을 \"Editor mode\"로 바꾸세요. 그러면 증명이 여러 줄의 코드로 보입니다. 줄 사이에 커서를 옮겨 각 지점의 goal state를 확인할 수 있습니다. 원한다면 코드를 다른 곳에 복사해 저장하고, 위 증명을 붙여 넣어 탐색해 보세요. 다 살펴봤으면 오른쪽 위의 `>_` 버튼을 눌러 \"Typewriter mode\"로 돌아가세요.\n\nTutorial World를 완료했습니다! \"Home\"을 눌러 overworld로 돌아간 뒤 Addition World를 선택하세요. 그곳에서 `induction` tactic을 배웁니다.", + "Having to rearrange variables manually using commutativity and\nassociativity is very tedious. We start by reminding you of this. `add_left_comm`\nis a key component in the first algorithm which we'll explain, but we need\nto prove it manually.\n\nRemember that you can do precision commutativity rewriting\nwith things like `rw [add_comm b c]`. And remember that\n`a + b + c` means `(a + b) + c`.": + "가환법칙과 결합법칙을 이용해 변수를 손으로 재배열하는 것은 매우 지루합니다. 우선 그 사실을 다시 한번 체감해 봅시다. `add_left_comm`는 우리가 설명할 첫 알고리즘의 핵심 구성 요소이지만, 지금은 직접 증명해야 합니다.\n\n`rw [add_comm b c]` 같은 식으로 정밀한 가환성 rewrite를 할 수 있다는 점을 기억하세요. 그리고 `a + b + c`는 `(a + b) + c`을 뜻합니다.", + "Good luck!\n\n One last hint. If `h : X = Y` then `rw [h]` will change *all* `X`s into `Y`s.\n If you only want to change one of them, say the 3rd one, then use\n `nth_rewrite 3 [h]`.": + "행운을 빕니다!\n\n마지막 힌트 하나. `h : X = Y`라면 `rw [h]`은 *모든* `X`를 `Y`으로 바꿉니다. 그중 하나만, 예를 들어 세 번째 것만 바꾸고 싶다면 `nth_rewrite 3 [h]`를 사용하세요.", + "For any natural number $m$, we have $ m \\times 1 = m$.": + "모든 자연수 $m$에 대해 $ m \\times 1 = m$입니다.", + "For any natural number $m$, we have $ 2 \\times m = m+m$.": + "모든 자연수 $m$에 대해 $ 2 \\times m = m+m$입니다.", + "For any natural number $m$, we have $ 1 \\times m = m$.": + "모든 자연수 $m$에 대해 $ 1 \\times m = m$입니다.", + "For all numbers $m$, $0 ^{\\operatorname{succ} (m)} = 0$.": + "모든 수 $m$에 대해 $0 ^{\\operatorname{succ} (m)} = 0$입니다.", + "For all numbers $a$ and $b$, we have\n$$(a+b)^2=a^2+b^2+2ab.$$": + "모든 수 $a$와 $b$에 대해 $$(a+b)^2=a^2+b^2+2ab.$$입니다.", + "For all naturals $m$, $1 ^ m = 1$.": "모든 자연수 $m$에 대해 $1 ^ m = 1$입니다.", + "For all naturals $a$, $m$, $n$, we have $a^{m + n} = a ^ m a ^ n$.": + "모든 자연수 $a$, $m$, $n$에 대해 $a^{m + n} = a ^ m a ^ n$입니다.", + "For all naturals $a$, $m$, $n$, we have $(a ^ m) ^ n = a ^ {mn}$.": + "모든 자연수 $a$, $m$, $n$에 대해 $(a ^ m) ^ n = a ^ {mn}$입니다.", + "For all naturals $a$, $b$, $n$, we have $(ab) ^ n = a ^ nb ^ n$.": + "모든 자연수 $a$, $b$, $n$에 대해 $(ab) ^ n = a ^ nb ^ n$입니다.", + "For all naturals $a$, $a ^ 2 = a \\times a$.": + "모든 자연수 $a$에 대해 $a ^ 2 = a \\times a$입니다.", + "For all naturals $a$, $a ^ 1 = a$.": "모든 자연수 $a$에 대해 $a ^ 1 = a$입니다.", + "For all naturals $a$ $b$ $c$ and $n$, we have\n$$(a+1)^{n+3}+(b+1)^{n+3}\\not=(c+1)^{n+3}.$$": + "모든 자연수 $a$, $b$, $c$, $n$에 대해 $$(a+1)^{n+3}+(b+1)^{n+3}\\not=(c+1)^{n+3}.$$입니다.", + "For all natural numbers $n$, we have $0 + n = n$.": + "모든 자연수 $n$에 대해 $0 + n = n$입니다.", + "For all natural numbers $m$, we have $ 0 \\times m = 0$.": + "모든 자연수 $m$에 대해 $ 0 \\times m = 0$입니다.", + "For all natural numbers $a, b$, we have\n$ \\operatorname{succ}(a) + b = \\operatorname{succ}(a + b)$.": + "모든 자연수 $a, b$에 대해,\n$ \\operatorname{succ}(a) + b = \\operatorname{succ}(a + b)$이 성립합니다.", + "For all natural numbers $a$, we have $\\operatorname{succ}(a) = a+1$.": + "모든 자연수 $a$에 대해 $\\operatorname{succ}(a) = a+1$입니다.", + "For all natural numbers $a$ and $b$, we have\n$(\\operatorname{succ}\\ a) \\times b = a\\times b + b$.": + "모든 자연수 $a$ and $b$에 대해,\n$(\\operatorname{succ}\\ a) \\times b = a\\times b + b$이 성립합니다.", + "First execute `rw [h]` to replace the `y` with `x + 7`.": + "먼저 `rw [h]`를 실행해서 `y`을 `x + 7`로 바꾸세요.", + "Finally use a targeted `add_comm` to switch `b` and `d`.": + "마지막으로 `add_comm`를 정확히 지정해서 사용해 `b`과 `d`를 바꾸세요.", + "Finally use a targeted `add_comm` to switch `b` and `d`": + "Finally use a targeted `add_comm` to switch `b` and `d`", + "Fermat's Last Theorem": "페르마의 마지막 정리", + "Every number in Lean is either $0$ or a successor. We know how to add $0$,\nbut we need to figure out how to add successors. Let's say we already know\nthat `37 + d = q`. What should the answer to `37 + succ d` be? Well,\n`succ d` is one bigger than `d`, so `37 + succ d` should be `succ q`,\nthe number one bigger than `q`. More generally `x + succ d` should\nbe `succ (x + d)`. Let's add this as a lemma.\n\n* `add_succ x d : x + succ d = succ (x + d)`\n\nIf you ever see `... + succ ...` in your goal, `rw [add_succ]` is\nnormally a good idea.\n\nLet's now prove that `succ n = n + 1`. Figure out how to get `+ succ` into\nthe picture, and then `rw [add_succ]`. Switch between the `+` (addition) and\n`012` (numerals) tabs under \"Theorems\" on the right to\nsee which proofs you can rewrite.": + "Lean의 모든 수는 $0$이거나 successor입니다. $0$을 더하는 법은 알지만 successor를 더하는 법은 아직 모릅니다. 이미 `37 + d = q`를 안다고 합시다. 그렇다면 `37 + succ d`의 답은 무엇이어야 할까요? `succ d`는 `d`보다 1 큰 수이므로 `37 + succ d`는 `succ q`, 즉 `q`보다 1 큰 수여야 합니다. 더 일반적으로 `x + succ d`는 $0$0이어야 합니다. 이를 lemma로 추가합시다.\n\n* $0$1\n\ngoal에서 $0$2를 보게 되면 보통 $0$3을 쓰는 것이 좋은 생각입니다.\n\n이제 $0$4를 증명해 봅시다. 먼저 $0$5를 끌어들이는 방법을 찾고, 이어서 $0$6을 사용하세요. 오른쪽 \"Theorems\" 아래의 $0$7(덧셈) 탭과 $0$8(숫자) 탭을 오가며 어떤 증명으로 rewrite할 수 있는지 확인하세요.", + "Do that again!\n\n§0 tries to fill in\nthe arguments to §1 (finding §2) then it replaces all occurrences of\n§3 it finds. Therefore, it did not rewrite §4, yet.": + "한 번 더 해 보세요!\n\n§0는 §1의 인자들을 채우려고 시도하고(§2를 찾아서) 발견한 §3의 모든 occurrence를 바꿉니다. 따라서 아직 §4는 rewrite하지 않았습니다.", + "Do that again!\n\n`rw [zero_add] at «{h}»` tries to fill in\nthe arguments to `zero_add` (finding `«{x}»`) then it replaces all occurrences of\n`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet.": + "Do that again!\n\n`rw [zero_add] at «{h}»` tries to fill in\nthe arguments to `zero_add` (finding `«{x}»`) then it replaces all occurrences of\n`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet.", + "Did you use induction on `y`?\nHere's a two-line proof of `add_left_eq_self` which uses `add_right_cancel`.\nIf you want to inspect it, you can go into editor mode by clicking `` in the top right\nand then just cut and paste the proof and move your cursor around it\nto see the hypotheses and goal at any given point\n(although you'll lose your own proof this way). Click `>_` to get\nback to command line mode.\n```\nnth_rewrite 2 [← zero_add y]\nexact add_right_cancel x 0 y\n```": + "`y`에 대해 귀납법을 썼나요?\n`add_right_cancel`를 사용하는 `add_left_eq_self`의 두 줄짜리 증명은 다음과 같습니다. 살펴보고 싶다면 오른쪽 위의 ``을 눌러 editor mode로 들어간 뒤 증명을 복사해 붙여 넣고 커서를 옮기면서 각 지점의 가정과 goal을 확인할 수 있습니다(다만 이 과정에서 자신의 증명은 사라집니다). `>_`를 누르면 command line mode로 돌아옵니다.\n```\nnth_rewrite 2 [← zero_add y]\nexact add_right_cancel x 0 y\n```", + "Dealing with `or`": "`or` 다루기", + "Congratulations! You've finished Algorithm World. These algorithms\nwill be helpful for you in Even-Odd World (when someone gets around to\nimplementing it).": + "축하합니다! Algorithm World를 끝냈습니다. 이 알고리즘들은 Even-Odd World가 언젠가 구현되면 그곳에서 유용하게 쓰일 겁니다.", + "Congratulations! You have proved Fermat's Last Theorem!\n\nEither that, or you used magic...": + "축하합니다! 페르마의 마지막 정리를 증명했습니다!\n\n아니면 마법을 썼거나요...", + "Congratulations! You completed your first verified proof!\n\nRemember that `rfl` is a *tactic*. If you ever want information about the `rfl` tactic,\nyou can click on `rfl` in the list of tactics on the right.\n\nNow click on \"Next\" to learn about the `rw` tactic.": + "축하합니다! 첫 번째 검증된 증명을 완성했습니다!\n\n`rfl`가 *tactic*이라는 점을 기억하세요. `rfl` tactic에 대해 궁금하면 오른쪽 tactic 목록의 `rfl`를 클릭하면 됩니다.\n\n이제 \"Next\"를 눌러 `rw` tactic을 배워 봅시다.", + "Concretely: `rw [← succ_eq_add_one] at h`.": + "구체적으로는 `rw [← succ_eq_add_one] at h`입니다.", + "Can you take it from here? Click on \"Show more help!\" if you need a hint.": + "이제부터는 스스로 할 수 있겠나요? 힌트가 필요하면 \"도움말 더 보기!\"를 누르세요.", + "Can you take it from here? (note: if you try `contrapose! h` again, it will\ntake you back to where you started!)": + "이제부터는 스스로 할 수 있겠나요? (주의: `contrapose! h`를 다시 시도하면 시작 지점으로 돌아옵니다!)", + "Can you take it from here?": "이제부터는 스스로 할 수 있겠나요?", + "Can you now change the goal into `2 = 2`?": "이제 goal을 `2 = 2`로 바꿀 수 있나요?", + "At this point you see the term `0 + «{d}»`, so you can use the\ninduction hypothesis with `rw [«{hd}»]`.": + "이제 항 `0 + «{d}»`가 보이므로 `rw [«{hd}»]`과 함께 귀납가정을 사용할 수 있습니다.", + "Assuming $x+y=37$ and $3x+z=42$, we have $x+y=37$.": + "$x+y=37$와 $3x+z=42$을 가정하면 $x+y=37$입니다.", + "Assuming $0+x=(0+y)+2$, we have $x=y+2$.": "$0+x=(0+y)+2$를 가정하면 $x=y+2$입니다.", + "As warm-up for `2 + 2 ≠ 5` let's prove `0 ≠ 1`. To do this we need to\nintroduce Peano's last axiom `zero_ne_succ n`, a proof that `0 ≠ succ n`.\nTo learn about this result, click on it in the list of lemmas on the right.": + "`2 + 2 ≠ 5`를 위한 준비운동으로 `0 ≠ 1`을 증명해 봅시다. 이를 위해 페아노의 마지막 공리 `zero_ne_succ n`, 즉 `0 ≠ succ n`의 증명을 도입해야 합니다. 이 결과에 대해 알아보려면 오른쪽 lemma 목록에서 클릭하세요.", + "Arguing backwards": "거꾸로 추론하기", + "Applying a proof of $P\\implies Q$ to the *goal* changes $Q$ to $P$.\nNow try `rw [succ_eq_add_one]` to make the goal more like the hypothesis.": + "$P\\implies Q$의 증명을 *goal*에 적용하면 $Q$이 $P$로 바뀝니다. 이제 `rw [succ_eq_add_one]`을 사용해 goal을 가정과 더 비슷하게 만들어 보세요.", + "And now we've deduced what we wanted to prove: the goal is one of our assumptions.\nFinish the level with `exact h`.": + "이제 우리가 증명하고 싶던 것을 이끌어냈습니다. goal이 가정 중 하나입니다. `exact h`로 level을 마무리하세요.", + "And now `rw [add_zero]`": "그리고 이제 `rw [add_zero]`.", + "And finally `rfl`.": "그리고 마지막으로 `rfl`.", + "An algorithm for equality": "동등성 판정 알고리즘", + "Although $0^0=1$ in this game, $0^n=0$ if $n>0$, i.e., if\n$n$ is a successor.": + "이 게임에서는 $0^0=1$이지만, $n>0$라면, 즉 $n$가 successor라면 $0^n=0$입니다.", + "Algorithm World": "알고리즘 월드", + "Advanced Multiplication World": "고급 곱셈 월드", + "Advanced Addition World": "고급 덧셈 월드", + "Advanced *Addition* World proved various implications\ninvolving addition, such as `x + y = 0 → x = 0` and `x + y = x → y = 0`.\nThese lemmas were used to prove basic facts about ≤ in ≤ World.\n\nIn Advanced Multiplication World we prove analogous\nfacts about multiplication, such as `x * y = 1 → x = 1`, and\n`x * y = x → y = 1` (assuming `x ≠ 0` in the latter result). This will prepare\nus for Divisibility World.\n\nMultiplication World is more complex than Addition World. In the same\nway, Advanced Multiplication world is more complex than Advanced Addition\nWorld. One reason for this is that certain intermediate results are only\ntrue under the additional hypothesis that one of the variables is non-zero.\nThis causes some unexpected extra twists.": + "Advanced *Addition* World에서는 `x + y = 0 → x = 0`와 `x + y = x → y = 0` 같은 덧셈 관련 여러 함의를 증명했습니다. 이 lemma들은 ≤ World에서 ≤의 기본 성질을 증명하는 데 사용되었습니다.\n\nAdvanced Multiplication World에서는 이에 대응하는 곱셈 관련 사실, 예를 들어 `x * y = 1 → x = 1`와 `x * y = x → y = 1`(후자는 `x ≠ 0`를 가정)을 증명합니다. 이것이 Divisibility World를 준비해 줍니다.\n\nMultiplication World는 Addition World보다 복잡합니다. 마찬가지로 Advanced Multiplication World도 Advanced Addition World보다 복잡합니다. 이유 중 하나는 몇몇 중간 결과가 변수 하나가 0이 아니라는 추가 가정 아래에서만 참이기 때문입니다. 그래서 예상하지 못한 꼬임이 몇 번 생깁니다.", + "Addition is distributive over multiplication.\nIn other words, for all natural numbers $a$, $b$ and $c$, we have\n$(a + b) \\times c = ac + bc$.": + "덧셈은 곱셈에 대해 분배됩니다. 즉 모든 자연수 $a$, $b$, $c$에 대해\n$(a + b) times c = ac + bc$이 성립합니다.", + "Addition World": "덧셈 월드", + "Adding zero": "0 더하기", + "A two-line proof is\n\n```\nnth_rewrite 2 [← mul_one a] at h\nexact mul_left_cancel a b 1 ha h\n```\n\nWe now have all the tools necessary to set up the basic theory of divisibility of naturals.": + "두 줄짜리 증명은\n\n```\nnth_rewrite 2 [← mul_one a] at h\nexact mul_left_cancel a b 1 ha h\n```\n\n입니다. 이제 자연수의 나눗셈 가능성(divisibility)에 대한 기본 이론을 세울 도구가 모두 준비되었습니다.", + "A proof that $a+b=0 \\implies b=0$.": "$a+b=0 \\implies b=0$라는 증명.", + "A proof that $a+b=0 \\implies a=0$.": "$a+b=0 \\implies a=0$라는 증명.", + "A passing mathematician remarks that with reflexivity and transitivity out of the way,\nyou have proved that `≤` is a *preorder* on `ℕ`.": + "지나가던 수학자가 반사성과 추이성을 증명했으므로 `ℕ` 위의 `≤`가 *preorder*임을 증명했다고 말합니다.", + "A passing mathematician notes that you've proved\nthat the natural numbers are a commutative semiring.\n\nIf you want to begin your journey to the final boss, head for Power World.": + "지나가던 수학자가 자연수들이 가환 반환을 이룬다는 것을 증명했다고 알려 줍니다.\n\nfinal boss를 향한 여정을 시작하려면 Power World로 가세요.", + "A passing mathematician congratulates you on proving that naturals\nare an additive commutative monoid.\n\nLet's practice using `add_assoc` and `add_comm` in one more level,\nbefore we leave addition world.": + "지나가던 수학자가 자연수들이 덧셈에 대해 가환 모노이드를 이룬다는 것을 증명했다며 축하합니다.\n\nAddition World를 떠나기 전에 `add_assoc`와 `add_comm`을 한 level만 더 연습해 봅시다.", + "2+2=4": "2+2=4", + "2 + 2 ≠ 5 is boring to prove in full, given only the tools we have currently.\nTo make it a bit less painful, I have unfolded all of the numerals for you.\nSee if you can use `zero_ne_succ` and `succ_inj` to prove this.": + "현재 가진 도구만으로 `zero_ne_succ`를 처음부터 증명하는 것은 꽤 지루합니다. 조금 덜 괴롭도록 숫자들을 모두 펼쳐 두었습니다. `zero_ne_succ`와 `succ_inj`을 이용해 증명해 보세요.", + "2 + 2 ≠ 5": "2 + 2 ≠ 5", + "1 ≠ 0": "1 ≠ 0", + "0 ≤ x": "0 ≤ x", + "*Game version: 4.3*\n\n*Recent additions: bug fixes*\n\n## Progress saving\n\nThe game stores your progress in your local browser storage.\nIf you delete it, your progress will be lost!\n\nWarning: In most browsers, deleting cookies will also clear the local storage\n(or \"local site data\"). Make sure to download your game progress first!\n\n## Credits\n\n* **Creators:** Kevin Buzzard, Jon Eugster\n* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n* **Additional thanks:** All the student beta testers, all the schools\nwho invited Kevin to speak, and all the schoolkids who asked him questions\nabout the material.\n\n## Resources\n\n* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n* [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/) (no longer maintained)\n\n## Problems?\n\nPlease ask any questions about this game in the\n[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\nthe stream \"New Members\". The community will happily help. Note that\nthe Lean Zulip chat is a professional research forum.\nPlease use your full real name there, stay on topic, and be nice. If you're\nlooking for somewhere less formal (e.g. you want to post natural number\ngame memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n\nAlternatively, if you experience issues / bugs you can also open github issues:\n\n* For issues with the game engine, please open an\n[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n* For issues about the game's content, please open an\n[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo.": + "*Game version: 4.3*\n\n*Recent additions: bug fixes*\n\n## Progress saving\n\nThe game stores your progress in your local browser storage.\nIf you delete it, your progress will be lost!\n\nWarning: In most browsers, deleting cookies will also clear the local storage\n(or \"local site data\"). Make sure to download your game progress first!\n\n## Credits\n\n* **Creators:** Kevin Buzzard, Jon Eugster\n* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n* **Additional thanks:** All the student beta testers, all the schools\nwho invited Kevin to speak, and all the schoolkids who asked him questions\nabout the material.\n\n## Resources\n\n* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n* [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/) (no longer maintained)\n\n## Problems?\n\nPlease ask any questions about this game in the\n[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\nthe stream \"New Members\". The community will happily help. Note that\nthe Lean Zulip chat is a professional research forum.\nPlease use your full real name there, stay on topic, and be nice. If you're\nlooking for somewhere less formal (e.g. you want to post natural number\ngame memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n\nAlternatively, if you experience issues / bugs you can also open github issues:\n\n* For issues with the game engine, please open an\n[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n* For issues about the game's content, please open an\n[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo.", + "*Game version: 4.3*\n\n*Recent additions: bug fixes*\n\n## Progress saving\n\nThe game stores your progress in your local browser storage.\nIf you delete it, your progress will be lost!\n\nWarning: In most browsers, deleting cookies will also clear the local storage\n(or \"local site data\"). Make sure to download your game progress first!\n\n## Credits\n\n* **Creators:** Kevin Buzzard, Jon Eugster\n* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n* **Additional thanks:** All the student beta testers, all the schools\nwho invited Kevin to speak, and all the schoolkids who asked him questions\nabout the material.\n\n## Resources\n\n* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n* [Original Lean3 version](https://github.com/ImperialCollegeLondon/natural_number_game/) (no longer maintained)\n\n## Problems?\n\nPlease ask any questions about this game in the\n[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\nthe stream \"New Members\". The community will happily help. Note that\nthe Lean Zulip chat is a professional research forum.\nPlease use your full real name there, stay on topic, and be nice. If you're\nlooking for somewhere less formal (e.g. you want to post natural number\ngame memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n\nAlternatively, if you experience issues / bugs you can also open github issues:\n\n* For issues with the game engine, please open an\n[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n* For issues about the game's content, please open an\n[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo.": + "*게임 버전: 4.3*\n\n*최근 추가 사항: 버그 수정*\n\n## 진행 상황 저장\n\n게임은 진행 상황을 브라우저의 local storage에 저장합니다. 이를 삭제하면 진행 상황도 사라집니다!\n\n주의: 대부분의 브라우저에서 쿠키를 삭제하면 local storage(또는 \"local site data\")도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n\n## 크레딧\n\n* **제작:** Kevin Buzzard, Jon Eugster\n* **원래 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **추가 level:** Sian Carey, Ivan Farabella, Archie Browne\n* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n\n## 자료\n\n* [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼\n* [원래 Lean3 버전](https://github.com/ImperialCollegeLondon/natural_number_game/) (현재는 유지보수되지 않음)\n\n## 문제가 있나요?\n\n이 게임에 관한 질문은 [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼, 예를 들어 \"New Members\" stream에 올려 주세요. 커뮤니티가 기꺼이 도와줄 것입니다. Lean Zulip chat은 전문 연구 포럼이라는 점에 유의하세요. 실명을 사용하고, 주제에 맞게 대화하며, 서로 예의를 지켜 주세요. 좀 더 가벼운 공간을 찾는다면(예: natural number game 밈을 올리고 싶다면) [Lean Discord](https://discord.gg/WZ9bs9UCvx)로 가세요.\n\n문제나 버그가 있다면 GitHub issue를 열 수도 있습니다.\n\n* 게임 엔진 문제는 [lean4game](https://github.com/leanprover-community/lean4game/issues) repo에 issue를 열어 주세요.\n* 게임 내용 문제는 [NNG](https://github.com/hhu-adam/NNG4/issues) repo에 issue를 열어 주세요.", + "$x=37\\implies x=37$.": "$x=37\\implies x=37$.", + "$x+y=x\\implies y=0$.": "$x+y=x\\implies y=0$.", + "$x+1=y+1 \\implies x=y$.": "$x+1=y+1 \\implies x=y$.", + "$x + y = y\\implies x=0.$": "$x + y = y\\implies x=0.$", + "$n+a=n+b\\implies a=b$.": "$n+a=n+b\\implies a=b$.", + "$a+n=b+n\\implies a=b$.": "$a+n=b+n\\implies a=b$.", + "$a+(b+0)+(c+0)=a+b+c.$": "$a+(b+0)+(c+0)=a+b+c.$", + "$\\operatorname{succ}(a) \\neq 0$.": "$\\operatorname{succ}(a) \\neq 0$.", + "$20+20=40$.": "$20+20=40$.", + "$2+2≠5$.": "$2+2≠5$.", + "$2+2=4$.": "$2+2=4$.", + "$2+2 \\neq 5.$": "$2+2 \\neq 5.$", + "$2$ is the number after the number after $0$.": "$2$는 $0$ 다음의 다음 수입니다.", + "$1\\neq0$.": "$1\\neq0$.", + "$0\\neq1$.": "$0\\neq1$.", + "$0 ^ 0 = 1$": "$0 ^ 0 = 1$", + "## The birth of number.\n\nNumbers in Lean are defined by two rules.\n\n* `0` is a number.\n* If `n` is a number, then the *successor* `succ n` of `n` is a number.\n\nThe successor of `n` means the number after `n`. Let's learn to\ncount, and name a few small numbers.\n\n## Counting to four.\n\n`0` is a number, so `succ 0` is a number. Let's call this new number `1`.\nSimilarly let's define `2 = succ 1`, `3 = succ 2` and `4 = succ 3`.\nThis gives us plenty of numbers to be getting along with.\n\nThe *proof* that `2 = succ 1` is called `two_eq_succ_one`.\nCheck out the \"012\" tab in the list of lemmas on the right\nfor this and other proofs.\n\nLet's prove that $2$ is the number after the number after zero.": + "## 수의 탄생\n\nLean의 수는 두 규칙으로 정의됩니다.\n\n* `0`는 수입니다.\n* `n`이 수라면 `n`의 *successor* `succ n`도 수입니다.\n\n`n`의 successor란 `n` 다음의 수를 뜻합니다. 이제 세는 법을 배우고 작은 수 몇 개에 이름을 붙여 봅시다.\n\n## 4까지 세기\n\n`0`는 수이므로 `succ 0`도 수입니다. 이 새 수를 `1`이라고 부릅시다. 같은 방식으로 `2 = succ 1`, `n`0, `n`1을 정의합니다. 이 정도면 당분간 쓸 수가 충분합니다.\n\n`n`2의 *증명*은 `n`3이라고 부릅니다. 오른쪽 lemma 목록의 \"012\" 탭에서 이 증명과 다른 증명들을 확인하세요.\n\n`n`4가 0 다음의 다음 수라는 것을 증명해 봅시다.", + "## Summary\n\n§0 proves goals of the form §1.\n\nIn other words, the §2 tactic will close any goal of the\nform §3 if §4 and §5 are *identical*.\n\n§6 is short for \\\\\"reflexivity (of equality)\\\\\".\n\n## Example:\n\nIf the goal looks like this:\n\n§7\n\nthen §8 will close it. But if it looks like §9 then §10 won't work, because even\nthough §11 and §12 are always equal as *numbers*, they are not equal as *terms*.\nThe only term which is identical to §13 is §14.\n\n## Details\n\n§15 is short for \\\\\"reflexivity of equality\\\\\".\n\n## Game Implementation\n\n*Note that our §16 is weaker than the version used in core Lean and §17,\nfor pedagogical purposes; mathematicians do not distinguish between propositional\nand definitional equality because they think about definitions in a different way\nto type theorists (§18 and §19 are both \\\\\"facts\\\\\" as far\nas mathematicians are concerned, and who cares what the definition of addition is).*": + "## 요약\n\n§0는 §1 꼴의 goal을 증명합니다.\n\n즉 §4와 §5가 *동일한* 항이라면 §2 tactic은 §3 꼴의 모든 goal을 닫습니다.\n\n§6는 \"reflexivity (of equality)\"의 줄임말입니다.\n\n## 예시\n\ngoal이\n\n§7\n\n처럼 생겼다면 §8이 닫습니다. 하지만 §9처럼 생겼다면 §10은 작동하지 않습니다. §11과 §12가 *수로서는* 항상 같더라도 *항으로서* 동일하지 않기 때문입니다. §13과 동일한 항은 §14뿐입니다.\n\n## 자세한 설명\n\n§15는 \"reflexivity of equality\"의 줄임말입니다.\n\n## 게임 구현\n\n*교육적 목적 때문에 이 게임의 §16는 core Lean과 §17에서 쓰는 버전보다 약합니다. 수학자들은 명제적 동등성과 정의적 동등성을 잘 구분하지 않습니다. type theorist와는 정의를 생각하는 방식이 다르기 때문입니다(수학자에게 §18과 §19는 둘 다 그저 \"사실\"이고, 덧셈의 정의가 무엇인지는 별로 중요하지 않습니다).*", + "## Summary\n\n`rfl` proves goals of the form `X = X`.\n\nIn other words, the `rfl` tactic will close any goal of the\nform `A = B` if `A` and `B` are *identical*.\n\n`rfl` is short for \\\"reflexivity (of equality)\\\".\n\n## Example:\n\nIf the goal looks like this:\n\n```\nx + 37 = x + 37\n```\n\nthen `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even\nthough $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.\nThe only term which is identical to `0 + x` is `0 + x`.\n\n## Details\n\n`rfl` is short for \\\"reflexivity of equality\\\".\n\n## Game Implementation\n\n*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,\nfor pedagogical purposes; mathematicians do not distinguish between propositional\nand definitional equality because they think about definitions in a different way\nto type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\nas mathematicians are concerned, and who cares what the definition of addition is).*": + "## Summary\n\n`rfl` proves goals of the form `X = X`.\n\nIn other words, the `rfl` tactic will close any goal of the\nform `A = B` if `A` and `B` are *identical*.\n\n`rfl` is short for \\\"reflexivity (of equality)\\\".\n\n## Example:\n\nIf the goal looks like this:\n\n```\nx + 37 = x + 37\n```\n\nthen `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even\nthough $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.\nThe only term which is identical to `0 + x` is `0 + x`.\n\n## Details\n\n`rfl` is short for \\\"reflexivity of equality\\\".\n\n## Game Implementation\n\n*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,\nfor pedagogical purposes; mathematicians do not distinguish between propositional\nand definitional equality because they think about definitions in a different way\nto type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\nas mathematicians are concerned, and who cares what the definition of addition is).*", + "## Summary\n\n`repeat t` repeatedly applies the tactic `t`\nto the goal. You don't need to use this\ntactic, it just speeds things up sometimes.\n\n## Example\n\n`repeat rw [add_zero]` will turn the goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\ninto the goal\n`a = b`.\n\"\n\nTacticDoc nth_rewrite \"\n## Summary\n\nIf `h : X = Y` and there are several `X`s in the goal, then\n`nth_rewrite 3 [h]` will just change the third `X` to a `Y`.\n\n## Example\n\nIf the goal is `2 + 2 = 4` then `nth_rewrite 2 [two_eq_succ_one]`\nwill change the goal to `2 + succ 1 = 4`. In contrast, `rw [two_eq_succ_one]`\nwill change the goal to `succ 1 + succ 1 = 4`.": + "## 요약\n\n`repeat t`는 tactic `t`을 goal에 반복 적용합니다. 꼭 필요한 tactic은 아니지만 때때로 속도를 높여 줍니다.\n\n## 예시\n\n`repeat rw [add_zero]`는 goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n을 goal\n`a = b`\n로 바꿉니다.\n\nTacticDoc nth_rewrite\n## 요약\n\n`h : X = Y`이고 goal에 `X`가 여러 개 있다면 `nth_rewrite 3 [h]`은 세 번째 `X`만 `Y`로 바꿉니다.\n\n## 예시\n\ngoal이 `t`0이면 `t`1은 goal을 `t`2로 바꿉니다. 반면 `t`3은 goal을 `t`4로 바꿉니다.", + "## Summary\n\n`repeat t` repeatedly applies the tactic `t`\nto the goal. You don't need to use this\ntactic, it just speeds things up sometimes.\n\n## Example\n\n`repeat rw [add_zero]` will turn the goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\ninto the goal\n`a = b`.": + "## 요약\n\n`repeat t`는 tactic `t`을 goal에 반복해서 적용합니다. 반드시 필요한 tactic은 아니지만 때로는 일을 빠르게 해 줍니다.\n\n## 예시\n\n`repeat rw [add_zero]`는 goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n을\n`a = b`\n로 바꿉니다.", + "## Summary\n\nThe §0 tactic makes progress with goals which claim something *exists*.\nIf the goal claims that some §1 exists with some property, and you know\nthat §2 will work, then §3 will make progress.\n\nBecause §4 is notation for \\\\\"there exists §5 such that §6\\\\\",\nyou can make progress on goals of the form §7 by §8ing the\nnumber which is morally §9 (i.e. §10)\n\nAny of the following examples is possible assuming the type of the argument passed to the §11 function is accurate:\n\n- §12\n- §13\n- §14": + "## 요약\n\n§0 tactic은 어떤 것이 *존재한다*고 주장하는 goal에서 진행할 수 있게 해 줍니다. goal이 어떤 성질을 만족하는 §1이 존재한다고 말하고, §2가 그 역할을 한다는 것을 알고 있다면 §3으로 진행할 수 있습니다.\n\n§4가 \"§6를 만족하는 §5가 존재한다\"의 표기이므로, §7 꼴의 goal에서는 본질적으로 §9인 수(즉 §10)를 §8해서 진행할 수 있습니다.\n\n§11 함수에 주는 인자의 타입이 올바르다면 다음 예시는 모두 가능합니다:\n\n- §12\n- §13\n- §14", + "## Summary\n\nThe `use` tactic makes progress with goals which claim something *exists*.\nIf the goal claims that some `x` exists with some property, and you know\nthat `x = 37` will work, then `use 37` will make progress.\n\nBecause `a ≤ b` is notation for \\\"there exists `c` such that `b = a + c`\\\",\nyou can make progress on goals of the form `a ≤ b` by `use`ing the\nnumber which is morally `b - a` (i.e. `use b - a`)\n\nAny of the following examples is possible assuming the type of the argument passed to the `use` function is accurate:\n\n- `use 37`\n- `use a`\n- `use a * a + 1`": + "## Summary\n\nThe `use` tactic makes progress with goals which claim something *exists*.\nIf the goal claims that some `x` exists with some property, and you know\nthat `x = 37` will work, then `use 37` will make progress.\n\nBecause `a ≤ b` is notation for \\\"there exists `c` such that `b = a + c`\\\",\nyou can make progress on goals of the form `a ≤ b` by `use`ing the\nnumber which is morally `b - a` (i.e. `use b - a`)\n\nAny of the following examples is possible assuming the type of the argument passed to the `use` function is accurate:\n\n- `use 37`\n- `use a`\n- `use a * a + 1`", + "## Summary\n\nThe `symm` tactic will change a goal or hypothesis of\nthe form `X = Y` to `Y = X`. It will also work on `X ≠ Y`\nand on `X ↔ Y`.\n\n### Example\n\nIf the goal is `2 + 2 = 4` then `symm` will change it to `4 = 2 + 2`.\n\n### Example\n\nIf `h : 2 + 2 ≠ 5` then `symm at h` will change `h` to `5 ≠ 2 + 2`.": + "## 요약\n\n`symm` tactic은 `X = Y` 꼴의 goal 또는 가정을 `Y = X` 꼴로 바꿉니다. `X ≠ Y`과 `X ↔ Y`에도 사용할 수 있습니다.\n\n### 예시\n\ngoal이 `2 + 2 = 4`라면 `symm`은 이를 `4 = 2 + 2`로 바꿉니다.\n\n### 예시\n\n`h : 2 + 2 ≠ 5`이라면 `symm at h`는 `X = Y`0을 `X = Y`1로 바꿉니다.", + "## Summary\n\nIf §0 is a proof that §1, and §2 is a proof of §3,\nthen §4 will change §5 to a proof of §6. The idea is that if\nyou know §7 is true, then you can deduce from §8 that §9 is true.\n\nIf the *goal* is §10, then §11 will \\\\\"argue backwards\\\\\" and change the\ngoal to §12. The idea here is that if you want to prove §13, then by §14\nit suffices to prove §15, so you can reduce the goal to proving §16.\n\n### Example:\n\n§17 is a proof that §18.\n\nSo if you have a hypothesis §19\nthen §20 will change §21 to §22.\nYou could write §23\nbut Lean is smart enough to figure out the inputs to §24.\n\n### Example\n\nIf the goal is §25, then §26 will turn the\ngoal into §27.": + "## 요약\n\n§0가 §1의 증명이고 §2가 §3의 증명이라면 §4는 §5를 §6의 증명으로 바꿉니다. 아이디어는 §7이 참이라는 것을 알면 §8로부터 §9가 참임을 이끌어낼 수 있다는 것입니다.\n\n*goal*이 §10이라면 §11은 \"거꾸로 추론\"해서 goal을 §12로 바꿉니다. §13을 증명하고 싶을 때 §14에 의해 §15만 증명하면 충분하므로 goal을 §16의 증명으로 환원하는 것입니다.\n\n### 예시\n\n§17은 §18의 증명입니다.\n\n따라서 가정 §19가 있다면 §20은 §21을 §22로 바꿉니다. §23이라고 직접 써도 되지만 Lean이 §24의 입력을 알아서 찾아 줍니다.\n\n### 예시\n\ngoal이 §25라면 §26은 goal을 §27로 바꿉니다.", + "## Summary\n\nIf §0 is a proof of an equality §1, then §2 will change\nall §3s in the goal to §4s. It's the way to \\\\\"substitute in\\\\\".\n\n## Variants\n\n* §5 (changes §6s to §7s; get the back arrow by typing §8 or §9.)\n\n* §10 (a sequence of rewrites)\n\n* §11 (changes §12s to §13s in hypothesis §14)\n\n* §15 (changes §16s to §17s in two hypotheses and the goal;\nget the §18 symbol with §19.)\n\n* §20 will keep changing §21 to §22\nuntil there are no more matches for §23.\n\n* §24 will change only the second §25 in the goal to §26.\n\n### Example:\n\nIf you have the assumption §27 and your goal is\n§28\n\nthen\n\n§29\n\nwill change the goal into §30, and then\n\n§31\n\nwill change the goal into §32, which\ncan be solved with §33.\n\n### Example:\n\nYou can use §34 to change a hypothesis as well.\nFor example, if you have two hypotheses\n§35\nthen §36 will turn §37 into §38.\n\n## Common errors\n\n* You need the square brackets. §39 is never correct.\n\n* If §40 is not a *proof* of an *equality* (a statement of the form §41),\nfor example if §42 is a function or an implication,\nthen §43 is not the tactic you want to use. For example,\n§44 is never correct: §45 is the theorem *statement*,\nnot the proof. If §46 is the proof, then §47 will work.\n\n## Details\n\nThe §48 tactic is a way to do \\\\\"substituting in\\\\\". There\nare two distinct situations where you can use this tactic.\n\n1) Basic usage: if §49 is an assumption or\nthe proof of a theorem, and if the goal contains one or more §50s, then §51\nwill change them all to §52s. The tactic will error\nif there are no §53s in the goal.\n\n2) Advanced usage: Assumptions coming from theorem proofs\noften have missing pieces. For example §54\nis a proof that §55 because §56 really is a function,\nand §57 is the input. In this situation §58 will look through the goal\nfor any subterm of the form §59, and the moment it\nfinds one it fixes §60 to be §61 then changes all §62s to §63s.\n\nExercise: think about why §64 changes the term\n§65 to\n§66\n\nIf you can't remember the name of the proof of an equality, look it up in\nthe list of lemmas on the right.\n\n## Targeted usage\n\nIf your goal is §67 and you want to rewrite §68\nto §69, then §70 will not work because Lean finds another\naddition first and swaps those inputs instead. Use §71 to\nguarantee that Lean rewrites §72 to §73. This works because\n§74 is a proof that §75, §76 is a proof\nthat §77, and §78 is a proof that §79.\n\nIf §80 then §81 will turn all §82s into §83s.\nIf you only want to change the 37th occurrence of §84\nto §85 then do §86.": + "## 요약\n\n§0가 등식 §1의 증명이라면 §2는 goal의 모든 §3을 §4로 바꿉니다. 즉 \"대입\"하는 방법입니다.\n\n## 변형\n\n* §5 (§6을 §7로 바꿉니다. 뒤쪽 화살표는 §8 또는 §9를 입력해 얻을 수 있습니다.)\n* §10 (여러 번의 rewrite를 연속으로 수행)\n* §11 (가정 §14 안의 §12를 §13으로 바꿈)\n* §15 (두 가정과 goal에서 §16을 §17로 바꿈. §18 기호는 §19로 입력)\n* §20은 더 이상 §23과 일치하는 것이 없을 때까지 §21을 §22로 계속 바꿉니다.\n* §24는 goal의 두 번째 §25만 §26으로 바꿉니다.\n\n### 예시\n\n가정 §27이 있고 goal이\n§28\n이라면\n\n§29\n\n은 goal을 §30으로 바꾸고, 이어서\n\n§31\n\n은 goal을 §32로 바꿉니다. 이는 §33으로 해결할 수 있습니다.\n\n### 예시\n\n§34를 사용해 가정을 바꿀 수도 있습니다. 예를 들어 두 가정 §35가 있다면 §36은 §37을 §38로 바꿉니다.\n\n## 흔한 오류\n\n* 대괄호가 필요합니다. §39는 절대 올바르지 않습니다.\n* §40이 *등식* §41의 *증명*이 아니라 함수나 함의 같은 것이라면 §43은 원하는 tactic이 아닙니다. 예를 들어 §42가 함수나 함의라면 §44는 절대 올바르지 않습니다. §45는 정리의 *명제*이지 증명이 아닙니다. §46가 증명이라면 §47은 작동합니다.\n\n## 자세한 설명\n\n§48 tactic은 \"대입\"을 하는 방법입니다. 서로 다른 두 상황에서 사용할 수 있습니다.\n\n1) 기본 사용법: §49가 가정이나 정리의 증명이고 goal에 하나 이상의 §50가 있다면 §51은 그 모두를 §52로 바꿉니다. goal에 §53이 하나도 없으면 오류가 납니다.\n\n2) 고급 사용법: 정리의 증명에서 얻은 가정은 인자가 빠져 있는 경우가 많습니다. 예를 들어 §54가 §55의 증명인 것은 §56가 실제로 함수이고 §57이 입력이기 때문입니다. 이 상황에서 §58은 goal에서 §59 꼴의 부분항을 찾고, 찾는 즉시 §60을 §61로 정한 뒤 모든 §62를 §63으로 바꿉니다.\n\n연습: §64가 항 §65를 §66으로 바꾸는 이유를 생각해 보세요.\n\n등식의 증명 이름이 기억나지 않으면 오른쪽 lemma 목록에서 찾아보세요.\n\n## 정확히 지정해서 사용하기\n\ngoal이 §67이고 §68을 §69로 rewrite하고 싶다고 합시다. §70은 작동하지 않습니다. Lean이 다른 덧셈을 먼저 찾아 그 입력을 바꾸기 때문입니다. §71을 사용하면 Lean이 반드시 §72를 §73으로 rewrite하게 할 수 있습니다. 이는 §74가 §75의 증명, §76이 §77의 증명, §78이 §79의 증명이기 때문입니다.\n\n§80이라면 §81은 모든 §82를 §83으로 바꿉니다. §84의 37번째 occurrence만 §85로 바꾸고 싶다면 §86을 사용하세요.", + "## Summary\n\nIf the goal is a statement §0, then §1 will close the goal if §2 is a proof of §3.\n\n### Example\n\nIf the goal is §4 and you have a hypothesis §5\nthen §6 will solve the goal.\n\n### Example\n\nIf the goal is §7 then §8 will close the goal.\n\n### Exact needs to be exactly right\n\nNote that §9 will *not work* in the previous example;\nfor §10 to work, §11 has to be *exactly* a proof of the goal.\n§12 is a proof of §13 or, if you like,\na proof of §14 where §15 needs to be supplied by the user.\nThis is in contrast to §16 and §17, which will \\\\\"guess the inputs\\\\\"\nif necessary. If the goal is §18 then §19\nand §20 will both change the goal to §21,\nbecause §22 guesses the input to the function §23.": + "## 요약\n\ngoal이 명제 §0이고 §2가 §3의 증명이라면 §1이 goal을 닫습니다.\n\n### 예시\n\ngoal이 §4이고 가정 §5가 있다면 §6으로 goal을 해결할 수 있습니다.\n\n### 예시\n\ngoal이 §7이라면 §8로 goal을 닫을 수 있습니다.\n\n### exact는 정말 exact해야 합니다\n\n앞 예시에서 §9는 *작동하지 않습니다*. §10이 작동하려면 §11이 goal의 증명과 *정확히* 일치해야 합니다. §12는 §13의 증명이며, 달리 말하면 사용자가 §15를 넣어야 하는 §14의 증명입니다.\n이는 필요할 경우 \"입력을 추측\"해 주는 §16과 §17과 대비됩니다. goal이 §18이면 §19와 §20은 모두 goal을 §21로 바꿉니다. §22가 함수 §23의 입력을 추측하기 때문입니다.", + "## Summary\n\nIf the goal is a statement `P`, then `exact h` will close the goal if `h` is a proof of `P`.\n\n### Example\n\nIf the goal is `x = 37` and you have a hypothesis `h : x = 37`\nthen `exact h` will solve the goal.\n\n### Example\n\nIf the goal is `x + 0 = x` then `exact add_zero x` will close the goal.\n\n### Exact needs to be exactly right\n\nNote that `exact add_zero` will *not work* in the previous example;\nfor `exact h` to work, `h` has to be *exactly* a proof of the goal.\n`add_zero` is a proof of `∀ n, n + 0 = n` or, if you like,\na proof of `? + 0 = ?` where `?` needs to be supplied by the user.\nThis is in contrast to `rw` and `apply`, which will \\\"guess the inputs\\\"\nif necessary. If the goal is `x + 0 = x` then `rw [add_zero]`\nand `rw [add_zero x]` will both change the goal to `x = x`,\nbecause `rw` guesses the input to the function `add_zero`.": + "## Summary\n\nIf the goal is a statement `P`, then `exact h` will close the goal if `h`는 `P`.\n\n### Example\n\nIf the goal is `x = 37` and you have a hypothesis `h : x = 37`\nthen `exact h` will solve the goal.\n\n### Example\n\nIf the goal is `x + 0 = x` then `exact add_zero x` will close the goal.\n\n### Exact needs to be exactly right\n\nNote that `exact add_zero` will *not work* in the previous example;\nfor `exact h` to work, `h` has to be *exactly* a proof of the goal.\n`add_zero` is a proof of `∀ n, n + 0 = n` or, if you like,\na proof of `? + 0 = ?` where `?` needs to be supplied by the user.\nThis is in contrast to `rw` and `apply`, which will \\\"guess the inputs\\\"\nif necessary. If the goal is `x + 0 = x` then `rw [add_zero]`\nand `rw [add_zero x]` will both change the goal to `x = x`,\nbecause `rw` guesses the input to the function `add_zero`의 증명입니다.", + "## Summary\n\nIf the goal is `P → Q`, then `intro h` will introduce `h : P` as a hypothesis,\nand change the goal to `Q`. Mathematically, it says that to prove $P \\implies Q$,\nwe can assume $P$ and then prove $Q$.\n\n### Example:\n\nIf your goal is `x + 1 = y + 1 → x = y` (the way Lean writes $x+1=y+1 \\implies x=y$)\nthen `intro h` will give you a hypothesis $x+1=y+1$ named `h`, and the goal\nwill change to $x=y$.": + "## 요약\n\n만약 goal이 `P → Q`라면, `intro h`는 가정에 `h : P`을 남기고,\ngoal을 `Q`로 바꿀 것입니다. 수학적으로, $P \\implies Q$를 증명한다는 것은,\n$P$를 먼저 가정하고 $Q$를 증명하는 것과 같습니다..\n\n### 예시:\n\n만약 goal이 `x + 1 = y + 1 → x = y`라면, Lean이 $x+1=y+1 \\implies x=y$을 일컫는 방법\n`intro h`를 했을 때 `h`라고 하는 $x+1=y+1$ 가 남고,\ngoal은 $x=y$로 바뀔 것입니다.", + "## Summary\n\nIf `t : P → Q` is a proof that $P \\implies Q$, and `h : P` is a proof of `P`,\nthen `apply t at h` will change `h` to a proof of `Q`. The idea is that if\nyou know `P` is true, then you can deduce from `t` that `Q` is true.\n\nIf the *goal* is `Q`, then `apply t` will \\\"argue backwards\\\" and change the\ngoal to `P`. The idea here is that if you want to prove `Q`, then by `t`\nit suffices to prove `P`, so you can reduce the goal to proving `P`.\n\n### Example:\n\n`succ_inj x y` is a proof that `succ x = succ y → x = y`.\n\nSo if you have a hypothesis `h : succ (a + 37) = succ (b + 42)`\nthen `apply succ_inj at h` will change `h` to `a + 37 = b + 42`.\nYou could write `apply succ_inj (a + 37) (b + 42) at h`\nbut Lean is smart enough to figure out the inputs to `succ_inj`.\n\n### Example\n\nIf the goal is `a * b = 7`, then `apply succ_inj` will turn the\ngoal into `succ (a * b) = succ 7`.": + "## Summary\n\nIf `t : P → Q`는 $P \\implies Q$, and `h : P` is a proof of `P`,\nthen `apply t at h` will change `h` to a proof of `Q`. The idea is that if\nyou know `P` is true, then you can deduce from `t` that `Q` is true.\n\nIf the *goal* is `Q`, then `apply t` will \\\"argue backwards\\\" and change the\ngoal to `P`. The idea here is that if you want to prove `Q`, then by `t`\nit suffices to prove `P`, so you can reduce the goal to proving `P`.\n\n### Example:\n\n`succ_inj x y` is a proof that `succ x = succ y → x = y`.\n\nSo if you have a hypothesis `h : succ (a + 37) = succ (b + 42)`\nthen `apply succ_inj at h` will change `h` to `a + 37 = b + 42`.\nYou could write `apply succ_inj (a + 37) (b + 42) at h`\nbut Lean is smart enough to figure out the inputs to `succ_inj`.\n\n### Example\n\nIf the goal is `a * b = 7`, then `apply succ_inj` will turn the\ngoal into `succ (a * b) = succ 7`.의 증명입니다.", + "## Summary\n\nIf `n` is a number, then `cases n with d` will break the goal into two goals,\none with `n = 0` and the other with `n = succ d`.\n\nIf `h` is a proof (for example a hypothesis), then `cases h with...` will break the\nproof up into the pieces used to prove it.\n\n## Example\n\nIf `n : ℕ` is a number, then `cases n with d` will break the goal into two goals,\none with `n` replaced by 0 and the other with `n` replaced by `succ d`. This\ncorresponds to the mathematical idea that every natural number is either `0`\nor a successor.\n\n## Example\n\nIf `h : P ∨ Q` is a hypothesis, then `cases h with hp hq` will turn one goal\ninto two goals, one with a hypothesis `hp : P` and the other with a\nhypothesis `hq : Q`.\n\n## Example\n\nIf `h : False` is a hypothesis, then `cases h` will turn one goal into no goals,\nbecause there are no ways to make a proof of `False`! And if you have no goals left,\nyou have finished the level.\n\n## Example\n\nIf `h : a ≤ b` is a hypothesis, then `cases h with c hc` will create a new number `c`\nand a proof `hc : b = a + c`. This is because the *definition* of `a ≤ b` is\n`∃ c, b = a + c`.": + "## 요약\n\n`n`가 수라면 `cases n with d`은 goal을 둘로 나눕니다. 하나에서는 `n = 0`이고 다른 하나에서는 `n = succ d`입니다.\n\n`h`가 증명(예: 가정)이라면 `cases h with...`는 그 증명을 구성한 조각들로 분해합니다.\n\n## 예시\n\n`n : ℕ`가 수라면 `cases n with d`은 goal을 두 개로 나눕니다. 하나에서는 `n`이 0으로 바뀌고, 다른 하나에서는 `n`가 `cases n with d`0으로 바뀝니다. 이는 모든 자연수가 `cases n with d`1이거나 successor라는 수학적 생각에 해당합니다.\n\n## 예시\n\n`cases n with d`2가 가정이라면 `cases n with d`3은 하나의 goal을 두 goal로 바꿉니다. 하나에는 가정 `cases n with d`4가 있고 다른 하나에는 가정 `cases n with d`5가 있습니다.\n\n## 예시\n\n`cases n with d`6가 가정이라면 `cases n with d`7은 goal 하나를 goal 0개로 바꿉니다. `cases n with d`8의 증명을 만드는 방법이 없기 때문입니다! goal이 하나도 남지 않으면 level을 끝낸 것입니다.\n\n## 예시\n\n`cases n with d`9가 가정이라면 `n = 0`0은 새 수 `n = 0`1과 증명 `n = 0`2를 만듭니다. `n = 0`3의 *정의*가 `n = 0`4이기 때문입니다.", + "## Summary\n\nIf `n : ℕ` is an object, and the goal mentions `n`, then `induction n with d hd`\nattempts to prove the goal by induction on `n`, with the inductive\nvariable in the successor case being `d`, and the inductive hypothesis being `hd`.\n\n### Example:\nIf the goal is\n```\n0 + n = n\n```\n\nthen\n\n`induction n with d hd`\n\nwill turn it into two goals. The first is `0 + 0 = 0`;\nthe second has an assumption `hd : 0 + d = d` and goal\n`0 + succ d = succ d`.\n\nNote that you must prove the first\ngoal before you can access the second one.": + "## 요약\n\n`n : ℕ`가 object이고 goal에 `n`이 등장하면 `induction n with d hd`는 `n`에 대한 귀납법으로 goal을 증명하려 합니다. successor 경우의 귀납 변수는 `d`이고 귀납가정은 `hd`입니다.\n\n### 예시\n\ngoal이\n```\n0 + n = n\n```\n이라면\n\n`induction n with d hd`\n\n은 이를 두 goal로 바꿉니다. 첫 번째는 `0 + 0 = 0`이고, 두 번째는 가정 `hd : 0 + d = d`와 goal `n`0을 가집니다.\n\n두 번째 goal에 접근하려면 먼저 첫 번째 goal을 증명해야 한다는 점에 주의하세요.", + "## Summary\n\nIf `h` is a proof of an equality `X = Y`, then `rw [h]` will change\nall `X`s in the goal to `Y`s. It's the way to \\\"substitute in\\\".\n\n## Variants\n\n* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\n\n* `rw [h1, h2]` (a sequence of rewrites)\n\n* `rw [h] at h2` (changes `X`s to `Y`s in hypothesis `h2`)\n\n* `rw [h] at h1 h2 ⊢` (changes `X`s to `Y`s in two hypotheses and the goal;\nget the `⊢` symbol with `\\|-`.)\n\n* `repeat rw [add_zero]` will keep changing `? + 0` to `?`\nuntil there are no more matches for `? + 0`.\n\n* `nth_rewrite 2 [h]` will change only the second `X` in the goal to `Y`.\n\n### Example:\n\nIf you have the assumption `h : x = y + y` and your goal is\n```\nsucc (x + 0) = succ (y + y)\n```\n\nthen\n\n`rw [add_zero]`\n\nwill change the goal into `succ x = succ (y + y)`, and then\n\n`rw [h]`\n\nwill change the goal into `succ (y + y) = succ (y + y)`, which\ncan be solved with `rfl`.\n\n### Example:\n\nYou can use `rw` to change a hypothesis as well.\nFor example, if you have two hypotheses\n```\nh1 : x = y + 3\nh2 : 2 * y = x\n```\nthen `rw [h1] at h2` will turn `h2` into `h2 : 2 * y = y + 3`.\n\n## Common errors\n\n* You need the square brackets. `rw h` is never correct.\n\n* If `h` is not a *proof* of an *equality* (a statement of the form `A = B`),\nfor example if `h` is a function or an implication,\nthen `rw` is not the tactic you want to use. For example,\n`rw [P = Q]` is never correct: `P = Q` is the theorem *statement*,\nnot the proof. If `h : P = Q` is the proof, then `rw [h]` will work.\n\n## Details\n\nThe `rw` tactic is a way to do \\\"substituting in\\\". There\nare two distinct situations where you can use this tactic.\n\n1) Basic usage: if `h : A = B` is an assumption or\nthe proof of a theorem, and if the goal contains one or more `A`s, then `rw [h]`\nwill change them all to `B`s. The tactic will error\nif there are no `A`s in the goal.\n\n2) Advanced usage: Assumptions coming from theorem proofs\noften have missing pieces. For example `add_zero`\nis a proof that `? + 0 = ?` because `add_zero` really is a function,\nand `?` is the input. In this situation `rw` will look through the goal\nfor any subterm of the form `x + 0`, and the moment it\nfinds one it fixes `?` to be `x` then changes all `x + 0`s to `x`s.\n\nExercise: think about why `rw [add_zero]` changes the term\n`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` to\n`0 + (x + 0) + 0 + (x + 0)`\n\nIf you can't remember the name of the proof of an equality, look it up in\nthe list of lemmas on the right.\n\n## Targeted usage\n\nIf your goal is `b + c + a = b + (a + c)` and you want to rewrite `a + c`\nto `c + a`, then `rw [add_comm]` will not work because Lean finds another\naddition first and swaps those inputs instead. Use `rw [add_comm a c]` to\nguarantee that Lean rewrites `a + c` to `c + a`. This works because\n`add_comm` is a proof that `?1 + ?2 = ?2 + ?1`, `add_comm a` is a proof\nthat `a + ? = ? + a`, and `add_comm a c` is a proof that `a + c = c + a`.\n\nIf `h : X = Y` then `rw [h]` will turn all `X`s into `Y`s.\nIf you only want to change the 37th occurrence of `X`\nto `Y` then do `nth_rewrite 37 [h]`.": + "## Summary\n\nIf `h` is a proof of an equality `X = Y`, then `rw [h]` will change\nall `X`s in the goal to `Y`s. It's the way to \\\"substitute in\\\".\n\n## Variants\n\n* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\n\n* `rw [h1, h2]` (a sequence of rewrites)\n\n* `rw [h] at h2` (changes `X`s to `Y`s in hypothesis `h2`)\n\n* `rw [h] at h1 h2 ⊢` (changes `X`s to `Y`s in two hypotheses and the goal;\nget the `⊢` symbol with `\\|-`.)\n\n* `repeat rw [add_zero]` will keep changing `? + 0` to `?`\nuntil there are no more matches for `? + 0`.\n\n* `nth_rewrite 2 [h]` will change only the second `X` in the goal to `Y`.\n\n### Example:\n\nIf you have the assumption `h : x = y + y` and your goal is\n```\nsucc (x + 0) = succ (y + y)\n```\n\nthen\n\n`rw [add_zero]`\n\nwill change the goal into `succ x = succ (y + y)`, and then\n\n`rw [h]`\n\nwill change the goal into `succ (y + y) = succ (y + y)`, which\ncan be solved with `rfl`.\n\n### Example:\n\nYou can use `rw` to change a hypothesis as well.\nFor example, if you have two hypotheses\n```\nh1 : x = y + 3\nh2 : 2 * y = x\n```\nthen `rw [h1] at h2` will turn `h2` into `h2 : 2 * y = y + 3`.\n\n## Common errors\n\n* You need the square brackets. `rw h` is never correct.\n\n* If `h` is not a *proof* of an *equality* (a statement of the form `A = B`),\nfor example if `h` is a function or an implication,\nthen `rw` is not the tactic you want to use. For example,\n`rw [P = Q]` is never correct: `P = Q` is the theorem *statement*,\nnot the proof. If `h : P = Q` is the proof, then `rw [h]` will work.\n\n## Details\n\nThe `rw` tactic is a way to do \\\"substituting in\\\". There\nare two distinct situations where you can use this tactic.\n\n1) Basic usage: if `h : A = B` is an assumption or\nthe proof of a theorem, and if the goal contains one or more `A`s, then `rw [h]`\nwill change them all to `B`s. The tactic will error\nif there are no `A`s in the goal.\n\n2) Advanced usage: Assumptions coming from theorem proofs\noften have missing pieces. For example `add_zero`\nis a proof that `? + 0 = ?` because `add_zero` really is a function,\nand `?` is the input. In this situation `rw` will look through the goal\nfor any subterm of the form `x + 0`, and the moment it\nfinds one it fixes `?` to be `x` then changes all `x + 0`s to `x`s.\n\nExercise: think about why `rw [add_zero]` changes the term\n`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` to\n`0 + (x + 0) + 0 + (x + 0)`\n\nIf you can't remember the name of the proof of an equality, look it up in\nthe list of lemmas on the right.\n\n## Targeted usage\n\nIf your goal is `b + c + a = b + (a + c)` and you want to rewrite `a + c`\nto `c + a`, then `rw [add_comm]` will not work because Lean finds another\naddition first and swaps those inputs instead. Use `rw [add_comm a c]` to\nguarantee that Lean rewrites `a + c` to `c + a`. This works because\n`add_comm`는 `?1 + ?2 = ?2 + ?1`, `add_comm a` is a proof\nthat `a + ? = ? + a`, and `add_comm a c` is a proof that `a + c = c + a`.\n\nIf `h : X = Y` then `rw [h]` will turn all `X`s into `Y`s.\nIf you only want to change the 37th occurrence of `X`\nto `Y` then do `nth_rewrite 37 [h]`.의 증명입니다.", + "## Summary\n\nIf `h : X = Y` and there are several `X`s in the goal, then\n`nth_rewrite 3 [h]` will just change the third `X` to a `Y`.\n\n## Example\n\nIf the goal is `2 + 2 = 4` then `nth_rewrite 2 [two_eq_succ_one]`\nwill change the goal to `2 + succ 1 = 4`. In contrast, `rw [two_eq_succ_one]`\nwill change the goal to `succ 1 + succ 1 = 4`.": + "## 요약\n\n`h : X = Y`이고 goal에 `X`이 여러 개 있다면 `nth_rewrite 3 [h]`는 세 번째 `X`만 `Y`로 바꿉니다.\n\n## 예시\n\ngoal이 `2 + 2 = 4`라면 `nth_rewrite 2 [two_eq_succ_one]`은 goal을 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 goal을 `succ 1 + succ 1 = 4`로 바꿉니다.", + "## Precision rewriting\n\nIn the last level, there was `b + 0` and `c + 0`,\nand `rw [add_zero]` changed the first one it saw,\nwhich was `b + 0`. Let's learn how to tell Lean\nto change `c + 0` first by giving `add_zero` an\nexplicit input.": + "## 정밀한 rewriting\n\n지난 level에는 `b + 0`와 `c + 0`이 있었고, `rw [add_zero]`는 처음 발견한 `b + 0`을 바꿨습니다. 이제 `add_zero`에 입력을 명시해서 Lean에게 `c + 0`를 먼저 바꾸라고 지시하는 법을 배워 봅시다.", + "# Welcome to the Natural Number Game\n#### An introduction to mathematical proof.\n\nIn this game, we will build the basic theory of the natural\nnumbers `{0,1,2,3,4,...}` from scratch. Our first goal is to prove\nthat `2 + 2 = 4`. Next we'll prove that `x + y = y + x`.\nAnd at the end we'll see if we can prove Fermat's Last Theorem.\nWe'll do this by solving levels of a computer puzzle game called Lean.\n\n# Read this.\n\nLearning how to use an interactive theorem prover takes time.\nTests show that the people who get the most out of this game are\nthose who read the help texts like this one.\n\nTo start, click on \"Tutorial World\".\n\nNote: this is a new Lean 4 version of the game containing several\nworlds which were not present in the old Lean 3 version. More new worlds\nsuch as Strong Induction World, Even/Odd World and Prime Number World\nare in development; if you want to see their state or even help out, checkout\nout the [issues in the github repo](https://github.com/leanprover-community/NNG4/issues).\n\n## More\n\nClick on the three lines in the top right and select \"Game Info\" for resources,\nlinks, and ways to interact with the Lean community.": + "# 자연수 게임에 오신 것을 환영합니다\n#### 수학적 증명 입문\n\n이 게임에서는 자연수 `{0,1,2,3,4,...}`의 기본 이론을 기초부터 만들어 갑니다. 첫 목표는 `2 + 2 = 4`을 증명하는 것입니다. 다음으로는 `x + y = y + x`를 증명합니다. 마지막에는 페르마의 마지막 정리를 증명할 수 있는지 보겠습니다. Lean이라는 컴퓨터 퍼즐 게임의 level들을 풀면서 진행합니다.\n\n# 일러두기\n\n대화형 정리 증명기를 사용하는 법을 익히는 데에는 시간이 걸립니다. 테스트 결과 이 게임을 가장 잘 활용하는 사람들은 이런 도움말을 꼼꼼히 읽는 사람들이었습니다.\n\n시작하려면 “튜토리얼 세계”를 클릭하세요.\n\n참고: 이것은 새로운 Lean 4 버전으로, 예전 Lean 3 버전에는 없던 여러 월드가 포함되어 있습니다. 강한 귀납법 월드, 홀짝 월드, 소수 월드 같은 새로운 월드도 개발 중입니다. 진행 상황을 보거나 직접 돕고 싶다면 [GitHub repo의 issues](https://github.com/leanprover-community/NNG4/issues)를 확인하세요.\n\n## 더 보기\n\n오른쪽 위의 세 줄 메뉴를 누르고 \"게임 정보\"를 선택하면 자료, 링크, Lean 커뮤니티와 소통하는 방법을 볼 수 있습니다.", + "# Summary\nThe `right` tactic changes a goal of `P ∨ Q` into a goal of `Q`.\nUse it when your hypotheses guarantee that the reason that `P ∨ Q`\nis true is because in fact `Q` is true.\n\nInternally this tactic is just `apply`ing a theorem\nsaying that $Q \\implies P \\lor Q.$\n\nNote that this tactic can turn a solvable goal into an unsolvable\none.": + "# 요약\n`right` tactic은 `P ∨ Q`이라는 goal을 `Q`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `Q`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n\n내부적으로 이 tactic은 $Q \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n\n이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요.", + "# Summary\nThe `left` tactic changes a goal of `P ∨ Q` into a goal of `P`.\nUse it when your hypotheses guarantee that the reason that `P ∨ Q`\nis true is because in fact `P` is true.\n\nInternally this tactic is just `apply`ing a theorem\nsaying that $P \\implies P \\lor Q.$\n\nNote that this tactic can turn a solvable goal into an unsolvable\none.": + "# 요약\n`left` tactic은 `P ∨ Q`이라는 goal을 `P`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `P`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n\n내부적으로 이 tactic은 $P \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n\n이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요.", + "# Summary\n\n`trivial` will solve the goal `True`.": + "# 요약\n\n`trivial`는 goal `True`을 해결합니다.", + "# Summary\n\n`decide` will attempt to solve a goal if it can find an algorithm which it\ncan run to solve it.\n\n## Example\n\nA term of type `DecidableEq ℕ` is an algorithm to decide whether two naturals\nare equal or different. Hence, once this term is made and made into an `instance`,\nthe `decide` tactic can use it to solve goals of the form `a = b` or `a ≠ b`.": + "# 요약\n\n`decide`는 실행 가능한 알고리즘을 찾을 수 있다면 그 알고리즘으로 goal을 해결하려 시도합니다.\n\n## 예시\n\n`DecidableEq ℕ` 타입의 항은 두 자연수가 같은지 다른지를 판정하는 알고리즘입니다. 따라서 이 항을 만들고 `instance`로 등록하면 `decide` tactic이 `a = b`나 `a ≠ b` 꼴의 goal을 해결하는 데 사용할 수 있습니다.", + "# Summary\n\nThe `tauto` tactic will solve any goal which can be solved purely by logic (that is, by\ntruth tables).\n\n## Details\n\n`tauto` *does not do magic*! It doesn't know *anything* about addition or multiplication,\nit doesn't even know `add_zero`. The only things that `tauto` knows about numbers\nare firstly that `a = a` and secondly that `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` and so on.\nWhat `tauto`'s strength is, is *logic*. If you have a hypothesis `x < 37`\nand another hypothesis `x < 37 → y + z = 42` and your goal is `y + z = 42` then `tauto` will\nsolve this goal, because to solve that goal you don't need to know any facts\nabout inequalities or addition, all you need to know is the rules of logic.\n\n## Example\n\nIf you have `False` as a hypothesis, then `tauto` will solve\nthe goal. This is because a false hypothesis implies any hypothesis.\n\n## Example\n\nIf your goal is `True`, then `tauto` will solve the goal.\n\n## Example\n\nIf you have two hypotheses `h1 : a = 37` and `h2 : a ≠ 37` then `tauto` will\nsolve the goal because it can prove `False` from your hypotheses, and thus\nprove the goal (as `False` implies anything).\n\n## Example\n\nIf you have one hypothesis `h : a ≠ a` then `tauto` will solve the goal because\n`tauto` is smart enough to know that `a = a` is true, which gives the contradiction we seek.\n\n## Example\n\nIf you have a hypothesis `h : 0 = 1` then `tauto` will solve the goal, because\n`tauto` knows `0 ≠ 1` and this is enough to prove `False`, which implies any goal.\n\n## Example\n\nIf you have a hypothesis of the form `a = 0 → a * b = 0` and your goal is `a * b ≠ 0 → a ≠ 0`, then\n`tauto` will solve the goal, because the goal is logically equivalent to the hypothesis.\nIf you switch the goal and hypothesis in this example, `tauto` would solve it too.": + "# 요약\n\n`tauto` tactic은 순수하게 논리만으로(즉 진리표만으로) 해결할 수 있는 모든 goal을 해결합니다.\n\n## 자세한 설명\n\n`tauto`은 *마법을 쓰지 않습니다*! 덧셈이나 곱셈에 대해서는 *아무것도* 모르고, `add_zero`조차 모릅니다. `tauto`이 수에 대해 아는 것은 첫째 `a = a`이고, 둘째 `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` 등이 있다는 것뿐입니다. `tauto`의 강점은 *논리*입니다. 가정 `x < 37`와 가정 `tauto`0이 있고 goal이 `tauto`1이라면 `tauto`2가 해결합니다. 부등식이나 덧셈에 관한 사실은 하나도 필요 없고 논리의 규칙만 알면 되기 때문입니다.\n\n## 예시\n\n가정 `tauto`3이 있으면 `tauto`4가 goal을 해결합니다. 거짓 가정에서는 어떤 명제든 따라오기 때문입니다.\n\n## 예시\n\ngoal이 `tauto`5라면 `tauto`6이 해결합니다.\n\n## 예시\n\n가정 `tauto`7과 `tauto`8이 있으면 `tauto`9가 goal을 해결합니다. 두 가정에서 `add_zero`0을 증명할 수 있고, `add_zero`1은 무엇이든 함의하기 때문입니다.\n\n## 예시\n\n가정 `add_zero`2 하나만 있어도 `add_zero`3이 goal을 해결합니다. `add_zero`4는 `add_zero`5가 참이라는 것을 알아내 모순을 얻을 수 있을 만큼 영리합니다.\n\n## 예시\n\n가정 `add_zero`6이 있으면 `add_zero`7이 goal을 해결합니다. `add_zero`8은 `add_zero`9를 알고 있고 이것으로 `tauto`0을 증명할 수 있으며, `tauto`0에서는 어떤 goal이든 따라옵니다.\n\n## 예시\n\n`tauto`1 꼴의 가정이 있고 goal이 `tauto`2라면 `tauto`3이 해결합니다. goal이 가정과 논리적으로 동치이기 때문입니다. 이 예시에서 goal과 가정을 뒤바꿔도 `tauto`4가 해결합니다.", + "# Summary\n\nThe `have` tactic can be used to add new hypotheses to a level, but of course\nyou have to prove them.\n\n\n## Example\n\nThe simplest usage is like this. If you have `a` in your context and you execute\n\n`have ha : a = 0`\n\nthen you will get a new goal `a = 0` to prove, and after you've proved\nit you will have a new hypothesis `ha : a = 0` in your original goal.\n\n## Example\n\nIf you already have a proof of what you want to `have`, you\ncan just create it immediately. For example, if you have `a` and `b`\nnumber objects, then\n\n`have h2 : succ a = succ b → a = b := succ_inj a b`\n\nwill directly add a new hypothesis `h2 : succ a = succ b → a = b`\nto the context, because you just supplied the proof of it (`succ_inj a b`).\n\n## Example\n\nIf you have a proof to hand, then you don't even need to state what you\nare proving. For example\n\n`have h2 := succ_inj a b`\n\nwill add `h2 : succ a = succ b → a = b` as a hypothesis.": + "# 요약\n\n`have` tactic을 사용하면 level에 새로운 가정을 추가할 수 있습니다. 물론 그 가정도 직접 증명해야 합니다.\n\n## 예시\n\n가장 간단한 사용법은 다음과 같습니다. context에 `a`이 있을 때\n\n`have ha : a = 0`\n\n를 실행하면 새로운 목표 `a = 0`이 생깁니다. 이를 증명하고 나면 원래 목표에 새로운 가정 `ha : a = 0`가 추가됩니다.\n\n## 예시\n\n`have`하고 싶은 명제의 증명을 이미 가지고 있다면 바로 만들 수도 있습니다. 예를 들어 `a`와 `b`이 number object라면\n\n`have h2 : succ a = succ b → a = b := succ_inj a b`\n\n을 실행하면 context에 새로운 가정 `h2 : succ a = succ b → a = b`가 바로 추가됩니다. 그 증명 `a`0을 직접 제공했기 때문입니다.\n\n## 예시\n\n이미 증명을 가지고 있다면 무엇을 증명하는지 굳이 명시할 필요도 없습니다. 예를 들어\n\n`a`1\n\n은 `a`2를 가정으로 추가합니다.", + "# Summary\n\nIf you have a hypothesis\n\n§0\n\nand goal\n\n§1\n\nthen §2 replaces the set-up with its so-called \\\\\"contrapositive\\\\\":\na hypothesis\n\n§3\n\nand goal\n\n§4.": + "# 요약\n\n가정이\n\n§0\n\n이고 goal이\n\n§1\n\n이라면 §2는 이를 이른바 \"대우\"로 바꿉니다. 즉 가정\n\n§3\n\n과 goal\n\n§4\n\n로 바꿉니다.", + "# Summary\n\nIf you have a hypothesis\n\n`h : a ≠ b`\n\nand goal\n\n`c ≠ d`\n\nthen `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\na hypothesis\n\n`h : c = d`\n\nand goal\n\n`a = b`.": + "# Summary\n\nIf you have a hypothesis\n\n`h : a ≠ b`\n\nand goal\n\n`c ≠ d`\n\nthen `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\na hypothesis\n\n`h : c = d`\n\nand goal\n\n`a = b`.", + "# Statement\n\nIf $a$ and $b$ are numbers, then\n`succ_inj a b` is the proof that\n$ (\\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n\n## More technical details\n\nThere are other ways to think about `succ_inj`.\n\nYou can think about `succ_inj` itself as a function which takes two\nnumbers $$a$$ and $$b$$ as input, and outputs a proof of\n$ ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n\nYou can think of `succ_inj` itself as a proof; it is the proof\nthat `succ` is an injective function. In other words,\n`succ_inj` is a proof of\n$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n\n`succ_inj` was postulated as an axiom by Peano, but\nin Lean it can be proved using `pred`, a mathematically\npathological function.": + "# 진술\n\n$a$와 $b$가 수이면\n`succ_inj a b`는\n$ (\\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$의 증명입니다.\n\n## 까다로운 세부사항\n\n사실 `succ_inj`에 대해 여러 다른 방법으로 생각할 수도 있습니다.\n\n`succ_inj` 자체를 함수로 보아 두 수 $$a$$와 $$b$$를 입력으로 받고,\n출력으로는 $ ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$의\n증명을 내놓는 함수로 생각할 수 있습니다.\n\n`succ_inj` 자체를 증명으로 보아 `succ`이 단사함수라는 증명으로 생각할 수 있습니다.\n즉 `succ_inj`은\n$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$\n의 증명이 됩니다.\n\n`succ_inj`는 페아노에 의해 공리로 세워졌으나,\niLean에서는 수학적으로 병적인 함수 `pred`에 의해 증명될 수있습니다.", + "# Read this first\n\nEach level in this game involves proving a mathematical theorem (the \"Goal\").\nThe goal will be a statement about *numbers*. Some numbers in this game have known values.\nThose numbers have names like $37$. Other numbers will be secret. They're called things\nlike $x$ and $q$. We know $x$ is a number, we just don't know which one.\n\nIn this first level we're going to prove the theorem that $37x + q = 37x + q$.\nYou can see `x q : ℕ` in the *Objects* below, which means that `x` and `q`\nare numbers.\n\nWe solve goals in Lean using *Tactics*, and the first tactic we're\ngoing to learn is called `rfl`, which proves all theorems of the form $X = X$.\n\nProve that $37x+q=37x+q$ by executing the `rfl` tactic.": + "# 먼저 읽어 주세요\n\n이 게임의 각 level에서는 하나의 수학 정리(\"Goal\")를 증명합니다. goal은 *수*에 관한 명제입니다. 이 게임의 어떤 수들은 값이 알려져 있습니다. 그런 수에는 $37$ 같은 이름이 붙습니다. 다른 수들의 값은 비밀이며 $x$, $q$ 같은 이름으로 불립니다. $x$이 수라는 것은 알지만 정확히 어떤 수인지는 모릅니다.\n\n첫 level에서는 $37x + q = 37x + q$라는 정리를 증명합니다. 아래 *Objects*에 `x q : ℕ`가 보일 텐데, 이는 `x`와 `q`이 수라는 뜻입니다.\n\nLean에서는 *Tactics*를 이용해 goal을 해결합니다. 처음 배울 tactic은 `rfl`이며, $X = X$ 꼴의 모든 정리를 증명합니다.\n\n$x$1 tactic을 실행해 $x$0을 증명하세요.", + "# Overview\n\nOur home-made tactic `simp_add` will solve arbitrary goals of\nthe form `a + (b + c) + (d + e) = e + (d + (c + b)) + a`.": + "# 개요\n\n직접 만든 tactic `simp_add`는 `a + (b + c) + (d + e) = e + (d + (c + b)) + a` 꼴의 임의의 goal을 해결합니다.", + "# Overview\n\nLean's simplifier, `simp`, will rewrite every lemma\ntagged with `simp` and every lemma fed to it by the user, as much as it can.\nFurthermore, it will attempt to order variables into an internal order if fed\nlemmas such as `add_comm`, so that it does not go into an infinite loop.": + "# 개요\n\nLean의 simplifier `simp`는 `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다. 또 `add_comm` 같은 lemma를 주면 무한 루프를 피하기 위해 변수들을 내부적인 순서에 맞춰 정렬하려고 합니다."} \ No newline at end of file diff --git a/.i18n/ko/Game.po b/.i18n/ko/Game.po new file mode 100644 index 00000000..0e0d7619 --- /dev/null +++ b/.i18n/ko/Game.po @@ -0,0 +1,6249 @@ +msgid "" +msgstr "" +"Project-Id-Version: Game v4.23.0\n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2026-08-19\n" +"PO-Revision-Date: \n" +"Last-Translator: \n" +"Language-Team: none\n" +"Language: ko\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=UTF-8\n" +"Content-Transfer-Encoding: 8bit\n" +"X-Generator: Poedit 3.9\n" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "x ≤ 1" +msgstr "x ≤ 1" + +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "`tauto` is good enough to solve this goal." +msgstr "`tauto`만으로도 이 목표를 해결하기에 충분합니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "mul_assoc" +msgstr "mul_assoc" + +#: Game.Levels.Multiplication.L05one_mul +msgid "" +"# Statement\n" +"\n" +"If $a$ and $b$ are numbers, then\n" +"`succ_inj a b` is the proof that\n" +"$ (\\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n" +"\n" +"## More technical details\n" +"\n" +"There are other ways to think about `succ_inj`.\n" +"\n" +"You can think about `succ_inj` itself as a function which takes two\n" +"numbers $$a$$ and $$b$$ as input, and outputs a proof of\n" +"$ ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n" +"\n" +"You can think of `succ_inj` itself as a proof; it is the proof\n" +"that `succ` is an injective function. In other words,\n" +"`succ_inj` is a proof of\n" +"$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n" +"\n" +"`succ_inj` was postulated as an axiom by Peano, but\n" +"in Lean it can be proved using `pred`, a mathematically\n" +"pathological function." +msgstr "" +"# 진술\n" +"\n" +"$a$와 $b$가 수이면\n" +"`succ_inj a b`는\n" +"$ (\\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$의 증명입니다.\n" +"\n" +"## 까다로운 세부사항\n" +"\n" +"사실 `succ_inj`에 대해 여러 다른 방법으로 생각할 수도 있습니다.\n" +"\n" +"`succ_inj` 자체를 함수로 보아 두 수 $$a$$와 $$b$$를 입력으로 받고,\n" +"출력으로는 $ ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$의\n" +"증명을 내놓는 함수로 생각할 수 있습니다.\n" +"\n" +"`succ_inj` 자체를 증명으로 보아 `succ`이 단사함수라는 증명으로 생각할 수 있습니다.\n" +"즉 `succ_inj`은\n" +"$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$\n" +"의 증명이 됩니다.\n" +"\n" +"`succ_inj`는 페아노에 의해 공리로 세워졌으나,\n" +"iLean에서는 수학적으로 병적인 함수 `pred`에 의해 증명될 수있습니다." + +#: Game.Levels.Addition.L02succ_add +msgid "" +"For all natural numbers $a$ and $b$, we have\n" +"$(\\operatorname{succ}\\ a) \\times b = a\\times b + b$." +msgstr "" +"모든 자연수 $a$ and $b$에 대해,\n" +"$(\\operatorname{succ}\\ a) \\times b = a\\times b + b$이 성립합니다." + +#: Game.Levels.Addition.L02succ_add +msgid "" +"For all natural numbers $a, b$, we have\n" +"$ \\operatorname{succ}(a) + b = \\operatorname{succ}(a + b)$." +msgstr "" +"모든 자연수 $a, b$에 대해,\n" +"$ \\operatorname{succ}(a) + b = \\operatorname{succ}(a + b)$이 성립합니다." + +#: Game.Levels.Tutorial.L04rw_backwards +msgid "" +"If `h` is a proof of `X = Y` then `rw [h]` will\n" +"turn `X`s into `Y`s. But what if we want to\n" +"turn `Y`s into `X`s? To tell the `rw` tactic\n" +"we want this, we use a left arrow `←`. Type\n" +"`\\l` and then hit the space bar to get this arrow.\n" +"\n" +"Let's prove that $2$ is the number after the number\n" +"after $0$ again, this time by changing `succ (succ 0)`\n" +"into `2`." +msgstr "" +"`h`가 `X = Y`의 증명이라면 `rw [h]`는 `X`을 `Y`로 바꿉니다. 그렇다면 반대로 `Y`를 `X`으로 바꾸고 싶을 때는 어떻게 해야 할까요? `rw` tactic에 이 방향으로 바꾸라고 알려 주려면 왼쪽 화살표 `←`를 사용합니다. `\\l`를 입력한 뒤 스페이스바를 누르면 이 화살표가 입력됩니다.\n" +"\n" +"이번에는 `X = Y`2를 `X = Y`3으로 바꾸는 방법으로, `X = Y`0이 `X = Y`1의 다음 수의 다음 수라는 사실을 다시 증명해 봅시다." + +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "" +"# Summary\n" +"\n" +"The `have` tactic can be used to add new hypotheses to a level, but of course\n" +"you have to prove them.\n" +"\n" +"\n" +"## Example\n" +"\n" +"The simplest usage is like this. If you have `a` in your context and you execute\n" +"\n" +"`have ha : a = 0`\n" +"\n" +"then you will get a new goal `a = 0` to prove, and after you've proved\n" +"it you will have a new hypothesis `ha : a = 0` in your original goal.\n" +"\n" +"## Example\n" +"\n" +"If you already have a proof of what you want to `have`, you\n" +"can just create it immediately. For example, if you have `a` and `b`\n" +"number objects, then\n" +"\n" +"`have h2 : succ a = succ b → a = b := succ_inj a b`\n" +"\n" +"will directly add a new hypothesis `h2 : succ a = succ b → a = b`\n" +"to the context, because you just supplied the proof of it (`succ_inj a b`).\n" +"\n" +"## Example\n" +"\n" +"If you have a proof to hand, then you don't even need to state what you\n" +"are proving. For example\n" +"\n" +"`have h2 := succ_inj a b`\n" +"\n" +"will add `h2 : succ a = succ b → a = b` as a hypothesis." +msgstr "" +"# 요약\n" +"\n" +"`have` tactic을 사용하면 level에 새로운 가정을 추가할 수 있습니다. 물론 그 가정도 직접 증명해야 합니다.\n" +"\n" +"## 예시\n" +"\n" +"가장 간단한 사용법은 다음과 같습니다. context에 `a`이 있을 때\n" +"\n" +"`have ha : a = 0`\n" +"\n" +"를 실행하면 새로운 목표 `a = 0`이 생깁니다. 이를 증명하고 나면 원래 목표에 새로운 가정 `ha : a = 0`가 추가됩니다.\n" +"\n" +"## 예시\n" +"\n" +"`have`하고 싶은 명제의 증명을 이미 가지고 있다면 바로 만들 수도 있습니다. 예를 들어 `a`와 `b`이 number object라면\n" +"\n" +"`have h2 : succ a = succ b → a = b := succ_inj a b`\n" +"\n" +"을 실행하면 context에 새로운 가정 `h2 : succ a = succ b → a = b`가 바로 추가됩니다. 그 증명 `a`0을 직접 제공했기 때문입니다.\n" +"\n" +"## 예시\n" +"\n" +"이미 증명을 가지고 있다면 무엇을 증명하는지 굳이 명시할 필요도 없습니다. 예를 들어\n" +"\n" +"`a`1\n" +"\n" +"은 `a`2를 가정으로 추가합니다." + +#: Game.Levels.Addition.L04add_assoc +msgid "" +"Remember that when Lean writes `a + b + c`, it means `(a + b) + c`.\n" +"If you are not sure where the brackets are in an expression, just hover\n" +"your cursor over it and look at what gets highlighted. For example,\n" +"hover over both `+` symbols on the left hand side of the goal and\n" +"you'll see where the invisible brackets are." +msgstr "Lean이 `a + b + c`라고 쓸 때는 `(a + b) + c`을 뜻한다는 점을 기억하세요. 식에서 괄호가 어디에 숨어 있는지 잘 모르겠다면 커서를 올려 어느 부분이 강조되는지 확인하면 됩니다. 예를 들어 목표의 왼쪽에 있는 두 `+` 기호 위에 각각 커서를 올려 보면 보이지 않는 괄호의 위치를 알 수 있습니다." + +#: Game.Levels.Tutorial.L04rw_backwards +msgid "Try `rw [← one_eq_succ_zero]` to change `succ 0` into `1`." +msgstr "`rw [← one_eq_succ_zero]`를 사용해 `succ 0`을 `1`로 바꿔 보세요." + +#: Game.Levels.Tutorial.L07add_succ +msgid "Start by unravelling the `1`." +msgstr "먼저 `1`을 풀어 써 보세요." + +#: Game.Levels.Tutorial.L02rw +msgid "the rw tactic" +msgstr "rw tactic" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "mul_left_ne_zero" +msgstr "mul_left_ne_zero" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "mul_ne_zero" +msgstr "mul_ne_zero" + +#: Game.Levels.Tutorial +msgid "" +"Welcome to tutorial world! In this world we learn the basics\n" +"of proving theorems. The boss level of this world\n" +"is the theorem `2 + 2 = 4`.\n" +"\n" +"You prove theorems by solving puzzles using tools called *tactics*.\n" +"The aim is to prove the theorem by applying tactics\n" +"in the right order.\n" +"\n" +"Let's learn some basic tactics. Click on \"Start\" below\n" +"to begin your quest." +msgstr "" +"Tutorial World에 오신 것을 환영합니다! 이 world에서는 정리를 증명하는 기초를 배웁니다. 이 world의 boss level은 정리 `2 + 2 = 4`입니다.\n" +"\n" +"정리는 *tactic*이라는 도구를 이용해 퍼즐을 풀듯 증명합니다. tactic들을 올바른 순서로 적용해 정리를 증명하는 것이 목표입니다.\n" +"\n" +"기본적인 tactic 몇 가지를 배워 봅시다. 아래의 \"Start\"를 눌러 여정을 시작하세요." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "add_left_cancel" +msgstr "add_left_cancel" + +#: Game.Levels.LessOrEqual.L01le_refl +msgid "You can probably take it from here." +msgstr "이제부터는 아마 스스로 할 수 있을 겁니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "2+2=4" +msgstr "2+2=4" + +#: Game.Levels.Implication.L08ne +msgid "Remember, `x ≠ y` is *notation* for `x = y → False`." +msgstr "`x ≠ y`는 `x = y → False`을 나타내는 *표기법*이라는 점을 기억하세요." + +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "" +"This level proves that if `a * b = 0` then `a = 0` or `b = 0`. It is\n" +"logically equivalent to the last level, so there is a very short proof." +msgstr "이 level에서는 `a * b = 0`이면 `a = 0` 또는 `b = 0`라는 것을 증명합니다. 이전 level과 논리적으로 동치이므로 아주 짧은 증명이 있습니다." + +#: Game.Levels.Addition.L01zero_add +msgid "" +"In this level we're going to prove that $0+n=n$, where $n$ is a secret natural number.\n" +"\n" +"Wait, don't we already know that? No! We know that $n+0=n$, but that's `add_zero`.\n" +"This is `zero_add`, which is different.\n" +"\n" +"The difficulty with proving `0 + n = n` is that we do not have a *formula* for\n" +"`0 + n` in general, we can only use `add_zero` and `add_succ` once\n" +"we know whether `n` is `0` or a successor. The `induction` tactic splits into these two cases.\n" +"\n" +"The base case will require us to prove `0 + 0 = 0`, and the inductive step\n" +"will ask us to show that if `0 + d = d` then `0 + succ d = succ d`. Because\n" +"`0` and successor are the only way to make numbers, this will cover all the cases.\n" +"\n" +"See if you can do your first induction proof in Lean.\n" +"\n" +"(By the way, if you are still in the \"Editor mode\" from the last world, you can swap\n" +"back to \"Typewriter mode\" by clicking the `>_` button in the top right.)" +msgstr "" +"이 level에서는 $0+n=n$를 증명합니다. 여기서 $n$은 값이 공개되지 않은 자연수입니다.\n" +"\n" +"잠깐, 이건 이미 아는 것 아닌가요? 아닙니다! 우리가 아는 것은 $n+0=n$인데, 그건 `add_zero`입니다. 지금 필요한 것은 `zero_add`이고, 둘은 다릅니다.\n" +"\n" +"`0 + n = n`를 증명하기 어려운 이유는 일반적인 `0 + n`에 대한 *공식*이 없기 때문입니다. `n`가 $n$0인지 successor인지 알아야만 `add_zero`과 `add_succ`을 사용할 수 있습니다. $n$1 tactic은 이 두 경우로 나눠 줍니다.\n" +"\n" +"기저 경우에서는 $n$2를 증명해야 하고, 귀납 단계에서는 $n$3이면 $n$4임을 보이라는 목표가 생깁니다. 수를 만드는 방법은 $n$5와 successor뿐이므로 이것으로 모든 경우를 다룹니다.\n" +"\n" +"Lean에서 첫 귀납 증명을 해 보세요.\n" +"\n" +"(참고로 이전 world에서 아직 \"Editor mode\"에 있다면, 오른쪽 위의 $n$6 버튼을 눌러 \"Typewriter mode\"로 돌아갈 수 있습니다.)" + +#: Game.Levels.LessOrEqual.L11le_two +msgid "" +"We'll need this lemma to prove that two is prime!\n" +"\n" +"You'll need to know that `∨` is right associative. This means that\n" +"`x = 0 ∨ x = 1 ∨ x = 2` actually means `x = 0 ∨ (x = 1 ∨ x = 2)`.\n" +"This affects how `left` and `right` work." +msgstr "" +"2가 소수라는 것을 증명하려면 이 lemma가 필요합니다!\n" +"\n" +"`∨`가 오른쪽 결합이라는 점을 알아야 합니다. 즉 `x = 0 ∨ x = 1 ∨ x = 2`은 실제로 `x = 0 ∨ (x = 1 ∨ x = 2)`를 뜻합니다. 이 때문에 `left`과 `right`의 작동 방식도 달라집니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "zero_pow_zero" +msgstr "zero_pow_zero" + +#: Game.Levels.Addition.L03add_comm +msgid "Induction on `a` or `b` -- it's all the same in this one." +msgstr "이번에는 `a`에 귀납하든 `b`에 귀납하든 똑같습니다." + +#. §0: `rw [zero_add] at «{h}»` +#. §1: `zero_add` +#. §2: `«{x}»` +#. §3: `0 + «{x}»` +#. §4: `0 + «{y}»` +#: Game.Levels.Implication.L02exact2 +#| msgid "" +#| "Do that again!\n" +#| "\n" +#| "§0 tries to fill in\n" +#| "the arguments to §1 (finding §2) then it replaces all occurrences of\n" +#| "§3 it finds. Therefor, it did not rewrite §4, yet." +msgid "" +"Do that again!\n" +"\n" +"§0 tries to fill in\n" +"the arguments to §1 (finding §2) then it replaces all occurrences of\n" +"§3 it finds. Therefore, it did not rewrite §4, yet." +msgstr "" +"한 번 더 해 보세요!\n" +"\n" +"§0는 §1의 인자들을 채우려고 시도하고(§2를 찾아서) 발견한 §3의 모든 occurrence를 바꿉니다. 따라서 아직 §4는 rewrite하지 않았습니다." + +#: Game.Levels.Power.L05pow_two +msgid "Note: this lemma will be useful for the final boss!" +msgstr "참고: 이 lemma는 final boss에서 유용합니다!" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "intro" +msgstr "intro" + +#: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero +msgid "Use the previous lemma with `apply eq_succ_of_ne_zero at ha`." +msgstr "이전 lemma를 `apply eq_succ_of_ne_zero at ha`와 함께 사용하세요." + +#: Game.Levels.Multiplication.L09mul_assoc +msgid "" +"A passing mathematician notes that you've proved\n" +"that the natural numbers are a commutative semiring.\n" +"\n" +"If you want to begin your journey to the final boss, head for Power World." +msgstr "" +"지나가던 수학자가 자연수들이 가환 반환을 이룬다는 것을 증명했다고 알려 줍니다.\n" +"\n" +"final boss를 향한 여정을 시작하려면 Power World로 가세요." + +#: Game.Levels.Power.L08pow_pow +msgid "" +"One of the best named levels in the game, a savage `pow_pow`\n" +"sub-boss appears as the music reaches a frenzy. What\n" +"else could there be to prove about powers after this?" +msgstr "게임에서 이름이 가장 멋진 level 중 하나입니다. 음악이 절정으로 치닫는 가운데 흉악한 `pow_pow` sub-boss가 나타납니다. 이 뒤에 거듭제곱에 대해 또 무엇을 증명할 수 있을까요?" + +#: Game.Levels.Algorithm.L01add_left_comm +msgid "If $a, b, c$ are numbers, then $a+(b+c)=b+(a+c)$." +msgstr "$a, b, c$가 수라면 $a+(b+c)=b+(a+c)$입니다." + +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "If $x \\leq 0$, then $x=0$." +msgstr "$x \\leq 0$,이면 $x=0$입니다." + +#: Game.Levels.LessOrEqual.L04le_trans Game.Levels.LessOrEqual.L06le_antisymm +msgid "If $x \\leq y$ and $y \\leq x$, then $x = y$." +msgstr "$x \\leq y$이고 $y \\leq x$이면 $x = y$입니다." + +#: Game.Levels.LessOrEqual.L04le_trans Game.Levels.LessOrEqual.L06le_antisymm +msgid "If $x \\leq y$ and $y \\leq z$, then $x \\leq z$." +msgstr "$x \\leq y$이고 $y \\leq z$이면 $x \\leq z$입니다." + +#: Game.Levels.Tutorial.L02rw +msgid "If $x$ and $y$ are natural numbers, and $y = x + 7$, then $2y = 2(x + 7)$." +msgstr "$x$와 $y$이 자연수이고 $y = x + 7$라면 $2y = 2(x + 7)$입니다." + +#: Game.Levels.LessOrEqual.L08le_total +msgid "If $x$ and $y$ are numbers, then either $x \\leq y$ or $y \\leq x$." +msgstr "$x$와 $y$이 수라면 $x \\leq y$ 또는 $y \\leq x$입니다." + +#: Game.Levels.LessOrEqual.L01le_refl Game.Levels.LessOrEqual.L02zero_le +#: Game.Levels.LessOrEqual.L03le_succ_self +msgid "If $x$ is a number, then $0 \\le x$." +msgstr "$x$가 수라면 $0 \\le x$입니다." + +#: Game.Levels.LessOrEqual.L01le_refl Game.Levels.LessOrEqual.L02zero_le +#: Game.Levels.LessOrEqual.L03le_succ_self +msgid "If $x$ is a number, then $x \\le \\operatorname{succ}(x)$." +msgstr "$x$가 수라면 $x \\le \\operatorname{succ}(x)$입니다." + +#: Game.Levels.LessOrEqual.L01le_refl Game.Levels.LessOrEqual.L02zero_le +#: Game.Levels.LessOrEqual.L03le_succ_self +msgid "If $x$ is a number, then $x \\le x$." +msgstr "$x$가 수라면 $x \\le x$입니다." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "If $x=37$ or $y=42$, then $y=42$ or $x=37$." +msgstr "$x=37$ 또는 $y=42$이면, $y=42$ 또는 $x=37$입니다." + +#: Game.Levels.Implication.L04succ_inj +msgid "" +"If `a` and `b` are numbers, then `succ_inj a b` is a proof\n" +"that `succ a = succ b` implies `a = b`. Click on this theorem in the *Peano*\n" +"tab for more information.\n" +"\n" +"Peano had this theorem as an axiom, but in Algorithm World\n" +"we will show how to prove it in Lean. Right now let's just assume it,\n" +"and let's prove $x+1=4 \\implies x=3$ using it. Again, we will proceed\n" +"by manipulating our hypothesis until it becomes the goal. I will\n" +"walk you through this level." +msgstr "" +"`a`와 `b`이 수라면 `succ_inj a b`는 `succ a = succ b`이면 `a = b`라는 것의 증명입니다. 더 알아보려면 *Peano* 탭에서 이 정리를 클릭하세요.\n" +"\n" +"페아노는 이 정리를 공리로 두었지만 Algorithm World에서는 Lean으로 이를 증명하는 방법을 보게 됩니다. 지금은 그냥 가정하고, 이를 이용해 $x+1=4 \\implies x=3$를 증명합시다. 이번에도 가정을 goal과 같아질 때까지 변형해 나가겠습니다. 이 level은 제가 단계별로 안내하겠습니다." + +#: Game.Levels.AdvMultiplication.L02mul_left_ne_zero +msgid "Now `apply h` and you can probably take it from here." +msgstr "이제 `apply h`를 하고 나면 아마 나머지는 스스로 할 수 있을 겁니다." + +#: Game.Levels.Multiplication.L04mul_comm +msgid "" +"The first sub-boss of Multiplication World is `mul_comm x y : x * y = y * x`.\n" +"\n" +"When you've proved this theorem we will have \"spare\" proofs\n" +"such as `zero_mul`, which is now easily deducible from `mul_zero`.\n" +"But we'll keep hold of these proofs anyway, because it's convenient\n" +"to have exactly the right tool for a job." +msgstr "" +"Multiplication World의 첫 sub-boss는 `mul_comm x y : x * y = y * x`입니다.\n" +"\n" +"이 정리를 증명하면 `zero_mul`처럼 `mul_zero`에서 쉽게 따라오는 \"여분의\" 증명도 생깁니다. 그래도 정확히 필요한 도구를 바로 꺼내 쓸 수 있으면 편리하므로 이런 증명들도 그대로 가지고 있겠습니다." + +#: Game.Levels.Addition.L05add_right_comm +msgid "" +"`add_right_comm a b c` is a proof that `(a + b) + c = (a + c) + b`\n" +"\n" +"In Lean, `a + b + c` means `(a + b) + c`, so this result gets displayed\n" +"as `a + b + c = a + c + b`." +msgstr "" +"`add_right_comm a b c`는 `(a + b) + c = (a + c) + b`의 증명입니다.\n" +"\n" +"Lean에서 `a + b + c`는 `(a + b) + c`을 뜻하므로 이 결과는 `a + b + c = a + c + b`처럼 표시됩니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "decide" +msgstr "decide" + +#: Game.Levels.Implication.L02exact2 +msgid "" +"You can use `rw [zero_add] at «{h}»` to rewrite at `«{h}»` instead\n" +"of at the goal." +msgstr "`rw [zero_add] at «{h}»`를 사용하면 goal이 아니라 `«{h}»`에서 rewrite할 수 있습니다." + +#: Game.Levels.Tutorial.L05add_zero +msgid "" +"## Summary\n" +"\n" +"`repeat t` repeatedly applies the tactic `t`\n" +"to the goal. You don't need to use this\n" +"tactic, it just speeds things up sometimes.\n" +"\n" +"## Example\n" +"\n" +"`repeat rw [add_zero]` will turn the goal\n" +"`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n" +"into the goal\n" +"`a = b`." +msgstr "" +"## 요약\n" +"\n" +"`repeat t`는 tactic `t`을 goal에 반복해서 적용합니다. 반드시 필요한 tactic은 아니지만 때로는 일을 빠르게 해 줍니다.\n" +"\n" +"## 예시\n" +"\n" +"`repeat rw [add_zero]`는 goal\n" +"`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n" +"을\n" +"`a = b`\n" +"로 바꿉니다." + +#: Game.Levels.Tutorial.L02rw +msgid "" +"## Summary\n" +"\n" +"`repeat t` repeatedly applies the tactic `t`\n" +"to the goal. You don't need to use this\n" +"tactic, it just speeds things up sometimes.\n" +"\n" +"## Example\n" +"\n" +"`repeat rw [add_zero]` will turn the goal\n" +"`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n" +"into the goal\n" +"`a = b`.\n" +"\"\n" +"\n" +"TacticDoc nth_rewrite \"\n" +"## Summary\n" +"\n" +"If `h : X = Y` and there are several `X`s in the goal, then\n" +"`nth_rewrite 3 [h]` will just change the third `X` to a `Y`.\n" +"\n" +"## Example\n" +"\n" +"If the goal is `2 + 2 = 4` then `nth_rewrite 2 [two_eq_succ_one]`\n" +"will change the goal to `2 + succ 1 = 4`. In contrast, `rw [two_eq_succ_one]`\n" +"will change the goal to `succ 1 + succ 1 = 4`." +msgstr "" +"## 요약\n" +"\n" +"`repeat t`는 tactic `t`을 goal에 반복 적용합니다. 꼭 필요한 tactic은 아니지만 때때로 속도를 높여 줍니다.\n" +"\n" +"## 예시\n" +"\n" +"`repeat rw [add_zero]`는 goal\n" +"`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n" +"을 goal\n" +"`a = b`\n" +"로 바꿉니다.\n" +"\n" +"TacticDoc nth_rewrite\n" +"## 요약\n" +"\n" +"`h : X = Y`이고 goal에 `X`가 여러 개 있다면 `nth_rewrite 3 [h]`은 세 번째 `X`만 `Y`로 바꿉니다.\n" +"\n" +"## 예시\n" +"\n" +"goal이 `t`0이면 `t`1은 goal을 `t`2로 바꿉니다. 반면 `t`3은 goal을 `t`4로 바꿉니다." + +#: Game.Levels.Addition +msgid "Addition World" +msgstr "덧셈 월드" + +#. §0: `P` +#. §1: `exact h` +#. §2: `h` +#. §3: `P` +#. §4: `x = 37` +#. §5: `h : x = 37` +#. §6: `exact h` +#. §7: `x + 0 = x` +#. §8: `exact add_zero x` +#. §9: `exact add_zero` +#. §10: `exact h` +#. §11: `h` +#. §12: `add_zero` +#. §13: `∀ n, n + 0 = n` +#. §14: `? + 0 = ?` +#. §15: `?` +#. §16: `rw` +#. §17: `apply` +#. §18: `x + 0 = x` +#. §19: `rw [add_zero]` +#. §20: `rw [add_zero x]` +#. §21: `x = x` +#. §22: `rw` +#. §23: `add_zero` +#: Game.Levels.Implication.L01exact +msgid "" +"## Summary\n" +"\n" +"If the goal is a statement §0, then §1 will close the goal if §2 is a proof of §3.\n" +"\n" +"### Example\n" +"\n" +"If the goal is §4 and you have a hypothesis §5\n" +"then §6 will solve the goal.\n" +"\n" +"### Example\n" +"\n" +"If the goal is §7 then §8 will close the goal.\n" +"\n" +"### Exact needs to be exactly right\n" +"\n" +"Note that §9 will *not work* in the previous example;\n" +"for §10 to work, §11 has to be *exactly* a proof of the goal.\n" +"§12 is a proof of §13 or, if you like,\n" +"a proof of §14 where §15 needs to be supplied by the user.\n" +"This is in contrast to §16 and §17, which will \\\\\"guess the inputs\\\\\"\n" +"if necessary. If the goal is §18 then §19\n" +"and §20 will both change the goal to §21,\n" +"because §22 guesses the input to the function §23." +msgstr "" +"## 요약\n" +"\n" +"goal이 명제 §0이고 §2가 §3의 증명이라면 §1이 goal을 닫습니다.\n" +"\n" +"### 예시\n" +"\n" +"goal이 §4이고 가정 §5가 있다면 §6으로 goal을 해결할 수 있습니다.\n" +"\n" +"### 예시\n" +"\n" +"goal이 §7이라면 §8로 goal을 닫을 수 있습니다.\n" +"\n" +"### exact는 정말 exact해야 합니다\n" +"\n" +"앞 예시에서 §9는 *작동하지 않습니다*. §10이 작동하려면 §11이 goal의 증명과 *정확히* 일치해야 합니다. §12는 §13의 증명이며, 달리 말하면 사용자가 §15를 넣어야 하는 §14의 증명입니다.\n" +"이는 필요할 경우 \"입력을 추측\"해 주는 §16과 §17과 대비됩니다. goal이 §18이면 §19와 §20은 모두 goal을 §21로 바꿉니다. §22가 함수 §23의 입력을 추측하기 때문입니다." + +#: Game.Levels.Implication.L07intro2 +msgid "Now `apply succ_inj at h` to cancel the `succ`s." +msgstr "이제 `apply succ_inj at h`를 사용해 `succ`들을 소거하세요." + +#: Game.Levels.Addition +msgid "" +"Welcome to Addition World! In this world we'll learn the `induction` tactic.\n" +"This will enable us to defeat the boss level of this world, namely `x + y = y + x`.\n" +"\n" +"The tactics `rw`, `rfl` and `induction` are the only tactics you'll need to\n" +"beat all the levels in Addition World, Multiplication World, and Power World.\n" +"Power World contains the final boss of the game.\n" +"\n" +"There are plenty more tactics in this game, but you'll only need to know them if you\n" +"want to explore the game further (for example if you decide to 100%\n" +"the game)." +msgstr "" +"Addition World에 오신 것을 환영합니다! 이 world에서는 `induction` tactic을 배웁니다. 이를 이용해 이 world의 boss level인 `x + y = y + x`을 쓰러뜨릴 수 있습니다.\n" +"\n" +"`rw`, `rfl`, `induction` 세 tactic만 알면 Addition World, Multiplication World, Power World의 모든 level을 깰 수 있습니다. Power World에는 이 게임의 final boss가 있습니다.\n" +"\n" +"이 게임에는 훨씬 많은 tactic이 있지만, 더 깊이 탐험하고 싶을 때만 필요합니다(예를 들어 게임을 100% 완료하고 싶을 때)." + +#: Game.Levels.Algorithm.L02add_algo1 +msgid "" +"In some later worlds, we're going to see some much nastier levels,\n" +"like `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`.\n" +"Brackets need to be moved around, and variables need to be swapped.\n" +"\n" +"In this level, `(a + b) + (c + d) = ((a + c) + d) + b`,\n" +"let's forget about the brackets and just think about\n" +"the variable order.\n" +"To turn `a+b+c+d` into `a+c+d+b` we need to swap `b` and `c`,\n" +"and then swap `b` and `d`. But this is easier than you\n" +"think with `add_left_comm`." +msgstr "" +"뒤쪽 world에서는 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`처럼 훨씬 더 험악한 level들을 만나게 됩니다. 괄호를 옮기고 변수들의 순서도 바꿔야 합니다.\n" +"\n" +"이 level의 `(a + b) + (c + d) = ((a + c) + d) + b`에서는 괄호는 잠시 잊고 변수의 순서만 생각해 봅시다. `a+b+c+d`를 `a+c+d+b`으로 바꾸려면 `b`와 `c`를 바꾸고, 이어서 `b`와 `d`을 바꿔야 합니다. 하지만 `add_left_comm`을 쓰면 생각보다 쉽습니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "add_left_comm" +msgstr "add_left_comm" + +#: Game.Levels.Implication.L10one_ne_zero +msgid "" +"## Summary\n" +"\n" +"The `symm` tactic will change a goal or hypothesis of\n" +"the form `X = Y` to `Y = X`. It will also work on `X ≠ Y`\n" +"and on `X ↔ Y`.\n" +"\n" +"### Example\n" +"\n" +"If the goal is `2 + 2 = 4` then `symm` will change it to `4 = 2 + 2`.\n" +"\n" +"### Example\n" +"\n" +"If `h : 2 + 2 ≠ 5` then `symm at h` will change `h` to `5 ≠ 2 + 2`." +msgstr "" +"## 요약\n" +"\n" +"`symm` tactic은 `X = Y` 꼴의 goal 또는 가정을 `Y = X` 꼴로 바꿉니다. `X ≠ Y`과 `X ↔ Y`에도 사용할 수 있습니다.\n" +"\n" +"### 예시\n" +"\n" +"goal이 `2 + 2 = 4`라면 `symm`은 이를 `4 = 2 + 2`로 바꿉니다.\n" +"\n" +"### 예시\n" +"\n" +"`h : 2 + 2 ≠ 5`이라면 `symm at h`는 `X = Y`0을 `X = Y`1로 바꿉니다." + +#: Game.Levels.Multiplication.L07mul_add +msgid "" +"Multiplication is distributive over addition on the left.\n" +"In other words, for all natural numbers $a$, $b$ and $c$, we have\n" +"$a(b + c) = ab + ac$." +msgstr "곱셈은 왼쪽에서 덧셈에 대해 분배법칙을 만족합니다. 즉 모든 자연수 $a$, $b$, $c$에 대해 $a(b + c) = ab + ac$이 성립합니다." + +#: Game.Levels.Implication.L03apply +msgid "The `apply` tactic." +msgstr "`apply` tactic." + +#: Game.Levels.Implication.L01exact +msgid "The goal in this level is one of our hypotheses. Solve the goal by executing `exact h1`." +msgstr "이 level의 goal은 가정 중 하나입니다. `exact h1`를 실행해서 goal을 해결하세요." + +#: Game.Levels.AdvAddition.L05add_right_eq_zero +msgid "" +"The next result we'll need in `≤` World is that if `a + b = 0` then `a = 0` and `b = 0`.\n" +"Let's prove one of these facts in this level, and the other in the next.\n" +"\n" +"## A new tactic: `cases`\n" +"\n" +"The `cases` tactic will split an object or hypothesis up into the possible ways\n" +"that it could have been created.\n" +"\n" +"For example, sometimes you want to deal with the two cases `b = 0` and `b = succ d` separately,\n" +"but don't need the inductive hypothesis `hd` that comes with `induction b with d hd`.\n" +"In this situation you can use `cases b with d` instead. There are two ways to make\n" +"a number: it's either zero or a successor. So you will end up with two goals, one\n" +"with `b = 0` and one with `b = succ d`.\n" +"\n" +"Another example: if you have a hypothesis `h : False` then you are done, because a false statement implies\n" +"any statement. Here `cases h` will close the goal, because there are *no* ways to\n" +"make a proof of `False`! So you will end up with no goals, meaning you have proved everything." +msgstr "" +"`≤` World에서 다음으로 필요한 결과는 `a + b = 0`이면 `a = 0`이고 `b = 0`이라는 것입니다. 이번 level에서 하나를 증명하고 다음 level에서 나머지 하나를 증명합시다.\n" +"\n" +"## 새로운 tactic: `cases`\n" +"\n" +"`cases` tactic은 object나 가정을 그것이 만들어질 수 있었던 가능한 경우들로 분해합니다.\n" +"\n" +"예를 들어 `b = 0`와 `b = succ d`의 두 경우를 따로 다루고 싶지만 `induction b with d hd`에 따라오는 귀납가정 `hd`은 필요하지 않을 때가 있습니다. 이때는 `a + b = 0`0을 사용할 수 있습니다. 수를 만드는 방법은 두 가지뿐입니다. 0이거나 successor입니다. 따라서 `a + b = 0`1인 goal과 `a + b = 0`2인 goal, 두 개가 생깁니다.\n" +"\n" +"또 다른 예로, 가정 `a + b = 0`3이 있다면 이미 끝난 것입니다. 거짓 명제에서는 어떤 명제든 따라오기 때문입니다. 여기서 `a + b = 0`4는 goal을 닫습니다. `a + b = 0`5의 증명을 만드는 방법은 *하나도 없기* 때문입니다! 따라서 goal이 하나도 남지 않고, 이는 모든 것을 증명했다는 뜻입니다." + +#: Game.Levels.Tutorial.L01rfl +msgid "" +"In order to use the tactic `rfl` you can enter it in the text box\n" +"under the goal and hit \"Execute\"." +msgstr "`rfl` tactic을 사용하려면 goal 아래의 텍스트 상자에 입력한 뒤 \"Execute\"를 누르면 됩니다." + +#: Game.Levels.Algorithm.L09decide2 +msgid "" +"Congratulations! You've finished Algorithm World. These algorithms\n" +"will be helpful for you in Even-Odd World (when someone gets around to\n" +"implementing it)." +msgstr "축하합니다! Algorithm World를 끝냈습니다. 이 알고리즘들은 Even-Odd World가 언젠가 구현되면 그곳에서 유용하게 쓰일 겁니다." + +#: Game.Levels.Tutorial.L08twoaddtwo +msgid "" +"Good luck!\n" +"\n" +" One last hint. If `h : X = Y` then `rw [h]` will change *all* `X`s into `Y`s.\n" +" If you only want to change one of them, say the 3rd one, then use\n" +" `nth_rewrite 3 [h]`." +msgstr "" +"행운을 빕니다!\n" +"\n" +"마지막 힌트 하나. `h : X = Y`라면 `rw [h]`은 *모든* `X`를 `Y`으로 바꿉니다. 그중 하나만, 예를 들어 세 번째 것만 바꾸고 싶다면 `nth_rewrite 3 [h]`를 사용하세요." + +#: Game.Levels.Addition.L04add_assoc +msgid "" +"A passing mathematician congratulates you on proving that naturals\n" +"are an additive commutative monoid.\n" +"\n" +"Let's practice using `add_assoc` and `add_comm` in one more level,\n" +"before we leave addition world." +msgstr "" +"지나가던 수학자가 자연수들이 덧셈에 대해 가환 모노이드를 이룬다는 것을 증명했다며 축하합니다.\n" +"\n" +"Addition World를 떠나기 전에 `add_assoc`와 `add_comm`을 한 level만 더 연습해 봅시다." + +#: Game.Levels.Implication.L05succ_inj2 +msgid "Arguing backwards" +msgstr "거꾸로 추론하기" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "mul_right_eq_one" +msgstr "mul_right_eq_one" + +#: Game.Levels.Power.L09add_sq +msgid "`add_sq a b` is the statement that $(a+b)^2=a^2+b^2+2ab.$" +msgstr "`add_sq a b`는 $(a+b)^2=a^2+b^2+2ab.$이라는 명제입니다." + +#: Game.Levels.Implication.L08ne +msgid "If $x=y$ and $x \\neq y$ then we can deduce a contradiction." +msgstr "$x=y$와 $x \\neq y$이 모두 성립하면 모순을 이끌어낼 수 있습니다." + +#: Game.Levels.Tutorial.L05add_zero +msgid "" +"We'd like to prove `2 + 2 = 4` but right now\n" +"we can't even *state* it\n" +"because we haven't yet defined addition.\n" +"\n" +"## Defining addition.\n" +"\n" +"How are we going to add $37$ to an arbitrary number $x$? Well,\n" +"there are only two ways to make numbers in this game: $0$\n" +"and successors. So to define `37 + x` we will need\n" +"to know what `37 + 0` is and what `37 + succ x` is.\n" +"Let's start with adding `0`.\n" +"\n" +"### Adding 0\n" +"\n" +"To make addition agree with our intuition, we should *define* `37 + 0`\n" +"to be `37`. More generally, we should define `a + 0` to be `a` for\n" +"any number `a`. The name of this proof in Lean is `add_zero a`.\n" +"For example `add_zero 37` is a proof of `37 + 0 = 37`,\n" +"`add_zero x` is a proof of `x + 0 = x`, and `add_zero` is a proof\n" +"of `? + 0 = ?`.\n" +"\n" +"We write `add_zero x : x + 0 = x`, so `proof : statement`." +msgstr "" +"`2 + 2 = 4`를 증명하고 싶지만, 우리는 아직 덧셈을 정의하지 않았기 때문에 `2+2`의 의미도 명확하지 않습니다.\n" +"\n" +"## 덧셈 정의하기\n" +"\n" +"임의의 수 $x$에 $37$을 어떻게 더할까요? 이 게임에서 수를 만드는 방법은 $0$과 successor뿐입니다. 따라서 `37 + x`를 정의하려면 `37 + 0`와 `37 + succ x`가 무엇인지 정해야 합니다. 먼저 `0`을 더하는 것부터 시작합시다.\n" +"\n" +"### 0 더하기\n" +"\n" +"덧셈이 우리의 직관과 맞으려면 `37 + 0`을 `37`로 “정의”해야 합니다. 더 일반적으로는 모든 수 $a$에 대해 $a+0$을 $a$로 정의해야 합니다. Lean에서 이 증명의 이름은 $add_zero a$입니다. 예를 들어 $add_zero x$는 $ x + 0 = x$의 증명이고, $add_zero 37$은 $37 + 0 = 37$의 증명이며, $add_zero$은 $> + 0 = ?$의 증명입니다.\n" +"\n" +"우리는 $add_zero x : x + 0 = x$처럼 씁니다. 따라서 Lean 코드에서 $statement$의 증명을 $poof$라고 하면, $proof:statement$입니다." + +#: Game.Levels.AdvMultiplication.L01mul_le_mul_right +msgid "Let's warm up with an easy one, which works even if `t = 0`." +msgstr "`t = 0`인 경우에도 작동하는 쉬운 문제로 몸을 풀어 봅시다." + +#: Game.Levels.Implication.L07intro2 +msgid "" +"Let's see if you can use the tactics we've learnt to prove $x+1=y+1\\implies x=y$.\n" +"Try this one by yourself; if you need help then click on \"Show more help!\"." +msgstr "지금까지 배운 tactic들을 사용해 $x+1=y+1\\implies x=y$를 증명해 보세요. 먼저 혼자 시도해 보고, 도움이 필요하면 \"도움말 더 보기!\"를 누르세요." + +#: Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "Now you can `apply le_mul_right at h2`." +msgstr "이제 `apply le_mul_right at h2`를 할 수 있습니다." + +#: Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "Now you can `apply zero_ne_succ at h`." +msgstr "이제 `apply zero_ne_succ at h`를 할 수 있습니다." + +#. §0: `h2` +#. §1: `x = 37` +#. §2: `y = 42` +#. §3: `apply` +#. §4: `apply` +#: Game.Levels.Implication.L03apply +#| msgid "" +#| "In this level, the hypotheses §0 is an *implication*. It says\n" +#| "that *if* §1 *then* §2. We can use this\n" +#| "hypothesis with the §3 tactic. Remember you can click on\n" +#| "§4 or any other tactic on the right to see a detailed explanation\n" +#| "of what it does, with examples." +msgid "" +"In this level, the hypothesis §0 is an *implication*. It says\n" +"that *if* §1 *then* §2. We can use this\n" +"hypothesis with the §3 tactic. Remember you can click on\n" +"§4 or any other tactic on the right to see a detailed explanation\n" +"of what it does, with examples." +msgstr "이 level의 가정 §0는 *함의*입니다. 즉 *§1이면 §2*라는 뜻입니다. 이 가정은 §3 tactic으로 사용할 수 있습니다. 오른쪽의 §4나 다른 tactic을 클릭하면 예시와 함께 자세한 설명을 볼 수 있다는 점을 기억하세요." + +#: Game.Levels.Tutorial.L01rfl +msgid "" +"# Read this first\n" +"\n" +"Each level in this game involves proving a mathematical theorem (the \"Goal\").\n" +"The goal will be a statement about *numbers*. Some numbers in this game have known values.\n" +"Those numbers have names like $37$. Other numbers will be secret. They're called things\n" +"like $x$ and $q$. We know $x$ is a number, we just don't know which one.\n" +"\n" +"In this first level we're going to prove the theorem that $37x + q = 37x + q$.\n" +"You can see `x q : ℕ` in the *Objects* below, which means that `x` and `q`\n" +"are numbers.\n" +"\n" +"We solve goals in Lean using *Tactics*, and the first tactic we're\n" +"going to learn is called `rfl`, which proves all theorems of the form $X = X$.\n" +"\n" +"Prove that $37x+q=37x+q$ by executing the `rfl` tactic." +msgstr "" +"# 먼저 읽어 주세요\n" +"\n" +"이 게임의 각 level에서는 하나의 수학 정리(\"Goal\")를 증명합니다. goal은 *수*에 관한 명제입니다. 이 게임의 어떤 수들은 값이 알려져 있습니다. 그런 수에는 $37$ 같은 이름이 붙습니다. 다른 수들의 값은 비밀이며 $x$, $q$ 같은 이름으로 불립니다. $x$이 수라는 것은 알지만 정확히 어떤 수인지는 모릅니다.\n" +"\n" +"첫 level에서는 $37x + q = 37x + q$라는 정리를 증명합니다. 아래 *Objects*에 `x q : ℕ`가 보일 텐데, 이는 `x`와 `q`이 수라는 뜻입니다.\n" +"\n" +"Lean에서는 *Tactics*를 이용해 goal을 해결합니다. 처음 배울 tactic은 `rfl`이며, $X = X$ 꼴의 모든 정리를 증명합니다.\n" +"\n" +"$x$1 tactic을 실행해 $x$0을 증명하세요." + +#. repeat rw [zero_add] at h +#. exact h +#. ``` +#: Game.Levels.Implication.L02exact2 +msgid "" +"Here's a two-line proof:\n" +"```\n" +"repeat rw [zero_add] at h\n" +"exact h\n" +"```" +msgstr "" +"두 줄짜리 증명은 다음과 같습니다:\n" +"```\n" +"repeat rw [zero_add] at h\n" +"exact h\n" +"```" + +#: Game.Levels.Addition.L01zero_add +msgid "" +"`zero_add n` is the proof of `0 + n = n`.\n" +"\n" +"`zero_add` is a `simp` lemma, because replacing `0 + n` by `n`\n" +"is almost always what you want to do if you're simplifying an expression." +msgstr "" +"`zero_add n`는 `0 + n = n`의 증명입니다.\n" +"\n" +"`zero_add`는 `simp` lemma입니다. 식을 단순화할 때 `0 + n`를 `n`로 바꾸는 것은 거의 항상 우리가 원하는 일이기 때문입니다." + +#: Game.Levels.Implication.L09zero_ne_succ +msgid "" +"As warm-up for `2 + 2 ≠ 5` let's prove `0 ≠ 1`. To do this we need to\n" +"introduce Peano's last axiom `zero_ne_succ n`, a proof that `0 ≠ succ n`.\n" +"To learn about this result, click on it in the list of lemmas on the right." +msgstr "`2 + 2 ≠ 5`를 위한 준비운동으로 `0 ≠ 1`을 증명해 봅시다. 이를 위해 페아노의 마지막 공리 `zero_ne_succ n`, 즉 `0 ≠ succ n`의 증명을 도입해야 합니다. 이 결과에 대해 알아보려면 오른쪽 lemma 목록에서 클릭하세요." + +#: Game.Levels.Implication.L01exact +msgid "Assuming $x+y=37$ and $3x+z=42$, we have $x+y=37$." +msgstr "$x+y=37$와 $3x+z=42$을 가정하면 $x+y=37$입니다." + +#: Game.Levels.Addition.L03add_comm +msgid "" +"On the set of natural numbers, addition is commutative.\n" +"In other words, if `a` and `b` are arbitrary natural numbers, then\n" +"$a + b = b + a$." +msgstr "자연수 집합에서 덧셈은 가환입니다. 즉 `a`와 `b`이 임의의 자연수라면 $a + b = b + a$입니다." + +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +msgid "" +"In this level we prove that if `a * b = a * c` and `a ≠ 0` then `b = c`. It is tricky, for\n" +"several reasons. One of these is that\n" +"we need to introduce a new idea: we will need to understand the concept of\n" +"mathematical induction a little better.\n" +"\n" +"Starting with `induction b with d hd` is too naive, because in the inductive step\n" +"the hypothesis is `a * d = a * c → d = c` but what we know is `a * succ d = a * c`,\n" +"so the induction hypothesis does not apply!\n" +"\n" +"Assume `a ≠ 0` is fixed. The actual statement we want to prove by induction on `b` is\n" +"\"for all `c`, if `a * b = a * c` then `b = c`\". This *can* be proved by induction,\n" +"because we now have the flexibility to change `c`." +msgstr "" +"이 level에서는 `a * b = a * c`와 `a ≠ 0`이면 `b = c`임을 증명합니다. 여러 이유로 까다로운데, 그중 하나는 새로운 생각이 필요하다는 점입니다. 수학적 귀납법을 조금 더 깊이 이해해야 합니다.\n" +"\n" +"`induction b with d hd`으로 시작하는 것은 너무 순진합니다. 귀납 단계에서 귀납가정은 `a * d = a * c → d = c`인데 실제로 알고 있는 것은 `a * succ d = a * c`이므로 귀납가정을 적용할 수 없기 때문입니다!\n" +"\n" +"`a ≠ 0`가 고정되어 있다고 합시다. `b`에 대해 실제로 귀납하여 증명해야 하는 명제는 \"모든 `c`에 대해, `a * b = a * c`이면 `a ≠ 0`0\"입니다. 이렇게 하면 `a ≠ 0`1을 바꿀 수 있는 여지가 생기므로 귀납법으로 증명할 *수 있습니다*." + +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "" +"Now the goal can be deduced from `h2` by pure logic, so use the `tauto`\n" +"tactic." +msgstr "이제 순수한 논리만으로 `h2`에서 goal이 따라오므로 `tauto` tactic을 사용하세요." + +#: Game.Levels.Tutorial.L02rw +msgid "Now `rfl` will work." +msgstr "이제 `rfl`가 작동합니다." + +#: Game.Levels.LessOrEqual.L05le_zero +msgid "`le_zero x` is a proof of the implication `x ≤ 0 → x = 0`." +msgstr "`le_zero x`는 함의 `x ≤ 0 → x = 0`의 증명입니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "2 + 2 ≠ 5" +msgstr "2 + 2 ≠ 5" + +#. §0: `ℕ` +#. §1: `0 : ℕ` +#. §2: `succ (n : ℕ) : ℕ` +#. §3: `MyNat` +#. §4: `ℕ` +#. §5: `Nat` +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "" +"§0 is the natural numbers, just called \\\\\"numbers\\\\\" in this game. It's\n" +"defined via two rules:\n" +"\n" +"* §1 (zero is a number)\n" +"* §2 (the successor of a number is a number)\n" +"\n" +"## Game Implementation\n" +"\n" +"*The game uses its own copy of the natural numbers, called §3 with notation §4.\n" +"It is distinct from the Lean natural numbers §5, which should hopefully\n" +"never leak into the natural number game.*" +msgstr "" +"§0는 자연수이며, 이 게임에서는 그냥 \\\"수\\\"라고 부릅니다. 자연수는 다음 두 규칙으로 정의됩니다.\n" +"\n" +"* §1 (0은 수이다)\n" +"* §2 (수의 successor도 수이다)\n" +"\n" +"## 게임 구현\n" +"\n" +"*이 게임은 §3이라는 자체 자연수 타입을 사용하고 이를 §4로 표기합니다. 이는 Lean의 자연수 §5와는 별개이며, Lean의 자연수가 Natural Number Game 안으로 새어 들어오는 일은 없기를 바랍니다.*" + +#: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +msgid "" +"Multiplication usually makes a number bigger, but multiplication by zero can make\n" +"it smaller. Thus many lemmas about inequalities and multiplication need the\n" +"hypothesis `a ≠ 0`. Here is a key lemma that enables us to use this hypothesis.\n" +"To help us with the proof, we can use the `tauto` tactic. Click on the tactic's name\n" +"on the right to see what it does." +msgstr "곱셈은 보통 수를 더 크게 만들지만 0을 곱하면 더 작게 만들 수도 있습니다. 그래서 부등식과 곱셈에 관한 많은 lemma에는 가정 `a ≠ 0`가 필요합니다. 여기서는 이 가정을 활용할 수 있게 해 주는 핵심 lemma를 증명합니다. 증명을 돕기 위해 `tauto` tactic을 사용할 수 있습니다. 오른쪽에서 tactic 이름을 눌러 무엇을 하는지 확인하세요." + +#: Game.Levels.LessOrEqual.L04le_trans +msgid "" +"In this level, we see inequalities as *hypotheses*. We have not seen this before.\n" +"The `cases` tactic can be used to take `hxy` apart." +msgstr "이 level에서는 부등식을 *가정*으로 처음 만나 봅니다. `cases` tactic을 사용하면 `hxy`을 분해할 수 있습니다." + +#: Game.Levels.Algorithm.L07succ_ne_succ +msgid "" +"Here we begin to\n" +"develop an algorithm which, given two naturals `a` and `b`, returns the answer\n" +"to \"does `a = b`?\"\n" +"\n" +"Here is the algorithm. First note that `a` and `b` are numbers, and hence\n" +"are either `0` or successors.\n" +"\n" +"*) If `a` and `b` are both `0`, return \"yes\".\n" +"\n" +"*) If one is `0` and the other is `succ n`, return \"no\".\n" +"\n" +"*) If `a = succ m` and `b = succ n`, then return the answer to \"does `m = n`?\"\n" +"\n" +"Our job now is to *prove* that this algorithm always gives the correct answer. The proof that\n" +"`0 = 0` is `rfl`. The proof that `0 ≠ succ n` is `zero_ne_succ n`, and the proof\n" +"that `succ m ≠ 0` is `succ_ne_zero m`. The proof that if `h : m = n` then\n" +"`succ m = succ n` is `rw [h]` and then `rfl`. This level is a proof of the one\n" +"remaining job we have to do: if `a ≠ b` then `succ a ≠ succ b`." +msgstr "" +"여기서는 두 자연수 `a`와 `b`을 받아 \"`a = b`인가?\"에 대한 답을 돌려주는 알고리즘을 만들기 시작합니다.\n" +"\n" +"알고리즘은 다음과 같습니다. 먼저 `a`와 `b`는 수이므로 각각 `0`이거나 successor입니다.\n" +"\n" +"*) `a`와 `b`이 둘 다 `0`이면 \"yes\"를 반환합니다.\n" +"\n" +"*) 하나가 `0`이고 다른 하나가 `b`0이면 \"no\"를 반환합니다.\n" +"\n" +"*) `b`1이고 `b`2이면 \"`b`3인가?\"에 대한 답을 반환합니다.\n" +"\n" +"이제 이 알고리즘이 항상 올바른 답을 준다는 것을 *증명*해야 합니다. `b`4의 증명은 `b`5입니다. `b`6의 증명은 `b`7이고, `b`8의 증명은 `b`9입니다. `a = b`0이면 `a = b`1이라는 증명은 `a = b`2를 한 뒤 `a = b`3을 하면 됩니다. 이 level에서는 남은 마지막 경우, 즉 `a = b`4이면 `a = b`5라는 것을 증명합니다." + +#: Game.Levels.LessOrEqual.L06le_antisymm +msgid "x ≤ y and y ≤ x implies x = y" +msgstr "x ≤ y이고 y ≤ x이면 x = y입니다." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "" +"# Summary\n" +"The `left` tactic changes a goal of `P ∨ Q` into a goal of `P`.\n" +"Use it when your hypotheses guarantee that the reason that `P ∨ Q`\n" +"is true is because in fact `P` is true.\n" +"\n" +"Internally this tactic is just `apply`ing a theorem\n" +"saying that $P \\implies P \\lor Q.$\n" +"\n" +"Note that this tactic can turn a solvable goal into an unsolvable\n" +"one." +msgstr "" +"# 요약\n" +"`left` tactic은 `P ∨ Q`이라는 goal을 `P`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `P`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n" +"\n" +"내부적으로 이 tactic은 $P \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n" +"\n" +"이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "" +"# Summary\n" +"The `right` tactic changes a goal of `P ∨ Q` into a goal of `Q`.\n" +"Use it when your hypotheses guarantee that the reason that `P ∨ Q`\n" +"is true is because in fact `Q` is true.\n" +"\n" +"Internally this tactic is just `apply`ing a theorem\n" +"saying that $Q \\implies P \\lor Q.$\n" +"\n" +"Note that this tactic can turn a solvable goal into an unsolvable\n" +"one." +msgstr "" +"# 요약\n" +"`right` tactic은 `P ∨ Q`이라는 goal을 `Q`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `Q`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n" +"\n" +"내부적으로 이 tactic은 $Q \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n" +"\n" +"이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요." + +#: Game.Levels.Multiplication +msgid "Multiplication World" +msgstr "곱셈 월드" + +#: Game.Levels.LessOrEqual.L10le_one +msgid "" +"We've seen `le_zero`, the proof that if `x ≤ 0` then `x = 0`.\n" +"Now we'll prove that if `x ≤ 1` then `x = 0` or `x = 1`." +msgstr "앞에서 `le_zero`, 즉 `x ≤ 0`이면 `x = 0`라는 증명을 봤습니다. 이제 `x ≤ 1`이면 `x = 0` 또는 `x = 1`라는 것을 증명합니다." + +#: Game +msgid "" +"In this game you recreate the natural numbers $\\mathbb{N}$ from the Peano axioms,\n" +"learning the basics about theorem proving in Lean.\n" +"\n" +"This is a good first introduction to Lean!" +msgstr "" +"이 게임에서는 페아노 공리로부터 자연수 $\\mathbb{N}$를 다시 만들어 가면서 Lean에서 정리를 증명하는 기초를 배웁니다.\n" +"\n" +"Lean을 처음 접하기에 좋은 입문입니다!" + +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "If $\\operatorname{succ}(a)=\\operatorname{succ}(b)$ then $a=b$." +msgstr "$\\operatorname{succ}(a)=\\operatorname{succ}(b)$이면 $a=b$입니다." + +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "If $\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$ then $x \\leq y$." +msgstr "$\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$이면 $x \\leq y$입니다." + +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "If $a \\neq b$ then $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$." +msgstr "$a \\neq b$이면 $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$입니다." + +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "If $a+b=0$ then $a=0$." +msgstr "$a+b=0$이면 $a=0$입니다." + +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "If $a+b=0$ then $b=0$." +msgstr "$a+b=0$이면 $b=0$입니다." + +#: Game.Levels.LessOrEqual.L10le_one +msgid "If $x \\leq 1$ then either $x = 0$ or $x = 1$." +msgstr "$x \\leq 1$이면 $x = 0$ 또는 $x = 1$입니다." + +#: Game.Levels.LessOrEqual.L11le_two +msgid "If $x \\leq 2$ then $x = 0$ or $1$ or $2$." +msgstr "$x \\leq 2$이면 $x = 0$ 또는 $1$ 또는 $2$입니다." + +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "If $x+1=4$ then $x=3$." +msgstr "$x+1=4$이면 $x=3$입니다." + +#: Game.Levels.Implication.L03apply +msgid "If $x=37$ and we know that $x=37\\implies y=42$ then we can deduce $y=42$." +msgstr "$x=37$이고 $x=37\\implies y=42$임을 알고 있다면 $y=42$를 이끌어낼 수 있습니다." + +# World=월드 +#: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 +#: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "" +"If you have completed Algorithm World then you can use the `contrapose!` tactic\n" +"here. If not then I'll talk you through a manual approach." +msgstr "만약 알고리듬 월드를 완료했다면 `contrapose!` tactic을 사용하실 수 있습니다. 그렇지 않다면 우회 방법에 대해 가르쳐 드릴게ㅇ" + +#: Game.Levels.Addition.L04add_assoc +msgid "" +"We've been adding up two numbers; in this level we will add up three.\n" +"\n" +" What does $x+y+z$ *mean*? It could either mean $(x+y)+z$, or it\n" +" could mean $x+(y+z)$. In Lean, $x+y+z$ means $(x+y)+z$.\n" +"\n" +" But why do we care which one it means; $(x+y)+z$ and $x+(y+z)$ are *equal*!\n" +"\n" +" That's true, but we didn't prove it yet. Let's prove it now by induction." +msgstr "" +"지금까지는 수 두 개를 더했습니다. 이번 level에서는 세 개를 더합니다.\n" +"\n" +"$x+y+z$는 무슨 *뜻*일까요? $(x+y)+z$을 뜻할 수도 있고 $x+(y+z)$를 뜻할 수도 있습니다. Lean에서 $x+y+z$은 $(x+y)+z$를 뜻합니다.\n" +"\n" +"그런데 어느 쪽인지 왜 신경 써야 할까요? $(x+y)+z$와 $x+(y+z)$는 *같은데요!*\n" +"\n" +"맞습니다. 하지만 아직 그 사실을 증명하지 않았습니다. 이제 귀납법으로 증명해 봅시다." + +#. rw [add_comm] +#. intro h +#. apply add_left_eq_self at h +#. exact h +#. ``` +#. rw [add_comm] +#. exact add_left_eq_self y x +#. ``` +#. induction x with d hd +#. intro h +#. rw [zero_add] at h +#. exact h +#. intro h +#. rw [succ_add] at h +#. apply succ_inj at h +#. apply hd at h +#. exact h +#. ``` +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"Here's a proof using `add_left_eq_self`:\n" +"```\n" +"rw [add_comm]\n" +"intro h\n" +"apply add_left_eq_self at h\n" +"exact h\n" +"```\n" +"\n" +"and here's an even shorter one using the same idea:\n" +"```\n" +"rw [add_comm]\n" +"exact add_left_eq_self y x\n" +"```\n" +"\n" +"Alternatively you can just prove it by induction on `x`:\n" +"\n" +"```\n" +"induction x with d hd\n" +"intro h\n" +"rw [zero_add] at h\n" +"exact h\n" +"intro h\n" +"rw [succ_add] at h\n" +"apply succ_inj at h\n" +"apply hd at h\n" +"exact h\n" +"```" +msgstr "" +"`add_left_eq_self`를 사용한 증명은 다음과 같습니다:\n" +"```\n" +"rw [add_comm]\n" +"intro h\n" +"apply add_left_eq_self at h\n" +"exact h\n" +"```\n" +"\n" +"같은 아이디어로 더 짧게 하면:\n" +"```\n" +"rw [add_comm]\n" +"exact add_left_eq_self y x\n" +"```\n" +"\n" +"또는 `x`에 대해 바로 귀납법으로 증명할 수도 있습니다:\n" +"\n" +"```\n" +"induction x with d hd\n" +"intro h\n" +"rw [zero_add] at h\n" +"exact h\n" +"intro h\n" +"rw [succ_add] at h\n" +"apply succ_inj at h\n" +"apply hd at h\n" +"exact h\n" +"```" + +#: Game.Levels.LessOrEqual.L05le_zero +msgid "" +"You want to use `add_right_eq_zero`, which you already\n" +"proved, but you'll have to start with `symm at` your hypothesis." +msgstr "이미 증명한 `add_right_eq_zero`를 쓰고 싶지만, 먼저 가정에 `symm at`을 적용해야 합니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "Next turn `1` into `succ 0` with `rw [one_eq_succ_zero]`." +msgstr "다음으로 `rw [one_eq_succ_zero]`를 사용해 `1`를 `succ 0`로 바꾸세요." + +#: Game.Levels.Implication.L07intro2 +msgid "intro practice" +msgstr "intro 연습" + +#. 0 + n = n +#. ``` +#: Game.Levels.Addition.L01zero_add +msgid "" +"## Summary\n" +"\n" +"If `n : ℕ` is an object, and the goal mentions `n`, then `induction n with d hd`\n" +"attempts to prove the goal by induction on `n`, with the inductive\n" +"variable in the successor case being `d`, and the inductive hypothesis being `hd`.\n" +"\n" +"### Example:\n" +"If the goal is\n" +"```\n" +"0 + n = n\n" +"```\n" +"\n" +"then\n" +"\n" +"`induction n with d hd`\n" +"\n" +"will turn it into two goals. The first is `0 + 0 = 0`;\n" +"the second has an assumption `hd : 0 + d = d` and goal\n" +"`0 + succ d = succ d`.\n" +"\n" +"Note that you must prove the first\n" +"goal before you can access the second one." +msgstr "" +"## 요약\n" +"\n" +"`n : ℕ`가 object이고 goal에 `n`이 등장하면 `induction n with d hd`는 `n`에 대한 귀납법으로 goal을 증명하려 합니다. successor 경우의 귀납 변수는 `d`이고 귀납가정은 `hd`입니다.\n" +"\n" +"### 예시\n" +"\n" +"goal이\n" +"```\n" +"0 + n = n\n" +"```\n" +"이라면\n" +"\n" +"`induction n with d hd`\n" +"\n" +"은 이를 두 goal로 바꿉니다. 첫 번째는 `0 + 0 = 0`이고, 두 번째는 가정 `hd : 0 + d = d`와 goal `n`0을 가집니다.\n" +"\n" +"두 번째 goal에 접근하려면 먼저 첫 번째 goal을 증명해야 한다는 점에 주의하세요." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "zero_ne_succ" +msgstr "zero_ne_succ" + +#: Game.Levels.Multiplication.L05one_mul +msgid "" +"You can prove $1\\times m=m$ in at least three ways.\n" +"Either by induction, or by using `succ_mul`, or\n" +"by using commutativity. Which do you think is quickest?" +msgstr "$1\\times m=m$는 적어도 세 가지 방법으로 증명할 수 있습니다. 귀납법을 쓰거나, `succ_mul`을 쓰거나, 가환성을 이용할 수 있습니다. 어느 방법이 가장 빠를까요?" + +#: Game.Levels.Addition.L02succ_add +msgid "" +"Note that `succ a + «{d}»` means `(succ a) + «{d}»`. Put your cursor\n" +"on any `succ` in the goal or assumptions to see what exactly it's eating." +msgstr "`succ a + «{d}»`가 `(succ a) + «{d}»`을 뜻한다는 점에 주의하세요. goal이나 가정에 있는 아무 `succ` 위에 커서를 올려 정확히 무엇을 먹고 있는지 확인해 보세요." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "We don't know whether to go left or right yet. So start with `cases «{h}» with hx hy`." +msgstr "아직 왼쪽으로 갈지 오른쪽으로 갈지 모르므로 `cases «{h}» with hx hy`부터 시작하세요." + +#: Game.Levels.AdvMultiplication.L05le_mul_right +msgid "" +"One day this game will have a Prime Number World, with a final boss\n" +"of proving that $2$ is prime.\n" +"To do this, we will have to rule out things like $2 = 37 × 42.$\n" +"We will do this by proving that any factor of $2$ is at most $2$,\n" +"which we will do using this lemma. The proof I have in mind manipulates the hypothesis\n" +"until it becomes the goal, using `mul_left_ne_zero`, `one_le_of_ne_zero` and\n" +"`mul_le_mul_right`." +msgstr "언젠가 이 게임에는 소수 월드가 생기고, 최종 보스는 $2$가 소수임을 증명하는 문제가 될 겁니다. 이를 위해 $2 = 37 × 42.$ 같은 가능성을 배제해야 합니다. 어떤 $2$의 인수도 $2$ 이하임을 보임으로써 그렇게 할 것이고, 이 lemma를 사용합니다. 제가 생각한 증명은 `mul_left_ne_zero`, `one_le_of_ne_zero`, `mul_le_mul_right`를 이용해 가정을 goal이 될 때까지 변형합니다." + +#: Game.Levels.Algorithm.L06is_zero +msgid "" +"We're going to change that `False` into `True`. Start by changing it into\n" +"`is_zero (succ a)` by executing `rw [← is_zero_succ a]`." +msgstr "`False`를 `True`로 바꿀 겁니다. 먼저 `rw [← is_zero_succ a]`을 실행해 `False`를 `is_zero (succ a)`로 바꾸세요." + +#: Game.Levels.Algorithm.L07succ_ne_succ +msgid "" +"Can you take it from here? (note: if you try `contrapose! h` again, it will\n" +"take you back to where you started!)" +msgstr "이제부터는 스스로 할 수 있겠나요? (주의: `contrapose! h`를 다시 시도하면 시작 지점으로 돌아옵니다!)" + +#: Game.Levels.Power.L05pow_two +msgid "" +"## Summary\n" +"\n" +"If the goal is `P → Q`, then `intro h` will introduce `h : P` as a hypothesis,\n" +"and change the goal to `Q`. Mathematically, it says that to prove $P \\implies Q$,\n" +"we can assume $P$ and then prove $Q$.\n" +"\n" +"### Example:\n" +"\n" +"If your goal is `x + 1 = y + 1 → x = y` (the way Lean writes $x+1=y+1 \\implies x=y$)\n" +"then `intro h` will give you a hypothesis $x+1=y+1$ named `h`, and the goal\n" +"will change to $x=y$." +msgstr "" +"## 요약\n" +"\n" +"만약 goal이 `P → Q`라면, `intro h`는 가정에 `h : P`을 남기고,\n" +"goal을 `Q`로 바꿀 것입니다. 수학적으로, $P \\implies Q$를 증명한다는 것은,\n" +"$P$를 먼저 가정하고 $Q$를 증명하는 것과 같습니다..\n" +"\n" +"### 예시:\n" +"\n" +"만약 goal이 `x + 1 = y + 1 → x = y`라면, Lean이 $x+1=y+1 \\implies x=y$을 일컫는 방법\n" +"`intro h`를 했을 때 `h`라고 하는 $x+1=y+1$ 가 남고,\n" +"goal은 $x=y$로 바뀔 것입니다." + +#: Game.Levels.Power.L05pow_two +msgid "" +"The music dies down. Is that it?\n" +"\n" +"Course it isn't, you can\n" +"clearly see that there are two levels left.\n" +"\n" +"A passing mathematician says that mathematicians don't have a name\n" +"for the structure you just constructed. You feel cheated.\n" +"\n" +"Suddenly the music starts up again. This really is the final boss." +msgstr "" +"음악이 잦아듭니다. 설마 이게 끝인가요?\n" +"\n" +"그럴 리가요. 아직 두 관문이나 남아 있는 게 빤히 보이잖아요.\n" +"\n" +"지나가던 한 수학자가 방금 당신이 만든 구조에는 딱히 이름도 없다고 합니다.\n" +"괜히 속은 기분이 듭니다.\n" +"\n" +"그 순간, 음악이 다시 울려 퍼집니다. *진짜 최종 보스*" + +#: Game.Levels.Power.L05pow_two +msgid "" +"We now start work on an algorithm to do addition more efficiently. Recall that\n" +"we defined addition by recursion, saying what it did on `0` and successors.\n" +"It is an axiom of Lean that recursion is a valid\n" +"way to define functions from types such as the naturals.\n" +"\n" +"Let's define a new function `pred` from the naturals to the naturals, which\n" +"attempts to subtract 1 from the input. The definition is this:\n" +"\n" +"```\n" +"pred 0 := 37\n" +"pred (succ n) := n\n" +"```\n" +"\n" +"We cannot subtract one from 0, so we just return a junk value. As well as this\n" +"definition, we also create a new lemma `pred_succ`, which says that `pred (succ n) = n`.\n" +"Let's use this lemma to prove `succ_inj`, the theorem which\n" +"Peano assumed as an axiom and which we have already used extensively without justification." +msgstr "" +"이제 덧셈을 더 효율적으로 계산하는 알고리즘을 만들어 봅시다. 앞서\n" +"`0`과 후속자에서 어떻게 작동하는지를 정하여 덧셈을 재귀적으로\n" +"정의했다는 것을 떠올려 보세요. Lean에서는 자연수 같은 타입에서\n" +"재귀를 사용해 함수를 정의할 수 있다는 것을 공리로 받아들입니다.\n" +"\n" +"이제 자연수에서 자연수로 가는 새로운 함수 `pred`를 정의해 봅시다.\n" +"이 함수는 입력에서 1을 빼려고 합니다. 정의는 다음과 같습니다.\n" +"\n" +"```\n" +"pred 0 := 37\n" +"pred (succ n) := n\n" +"```\n" +"\n" +"0에서는 1을 뺄 수 없으므로 그냥 아무 값이나 반환합니다. 이 정의와\n" +"함께 `pred_succ`라는 새로운 보조정리도 만듭니다. 이 정리는\n" +"`pred (succ n) = n`이라고 말합니다. 이제 이 정리를 사용하여\n" +"`succ_inj`를 증명해 봅시다. `succ_inj`는 페아노가 공리로 가정했고,\n" +"우리는 지금까지 정당화 없이 여러 번 사용해 온 정리입니다." + +#: Game.Levels.Power.L03pow_one +msgid "" +"`pow_one a` says that `a ^ 1 = a`.\n" +"\n" +"Note that this is not quite true by definition: `a ^ 1` is\n" +"defined to be `a ^ 0 * a` so it's `1 * a`, and to prove\n" +"that this is equal to `a` you need to use induction somewhere." +msgstr "" +"`pow_one a`는 `a ^ 1 = a`이라고 말합니다.\n" +"\n" +"정의만으로 바로 참인 것은 아닙니다. `a ^ 1`는 `a ^ 0 * a`으로 정의되므로 `1 * a`이고, 이것이 `a`와 같음을 보이려면 어딘가에서 귀납법을 사용해야 합니다." + +#: Game.Levels.Power.L05pow_two +msgid "`pow_two a` says that `a ^ 2 = a * a`." +msgstr "`pow_two a`는 `a ^ 2 = a * a`압니다." + +#: Game.Levels.Implication.L04succ_inj +msgid "In the next level, we'll do the same proof but backwards." +msgstr "다음 level에서는 같은 증명을 거꾸로 해 보겠습니다." + +#. rw [mul_comm, mul_add] +#. repeat rw [mul_comm c] +#. rfl +#. ``` +#: Game.Levels.Multiplication.L08add_mul +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "" +"Here's my proof:\n" +"```\n" +"cases hx with d hd\n" +"use d\n" +"rw [succ_add] at hd\n" +"apply succ_inj at hd\n" +"exact hd\n" +"```" +msgstr "" +"제 증명은 이렇습니다:\n" +"```\n" +"cases hx with d hd\n" +"use d\n" +"rw [succ_add] at hd\n" +"apply succ_inj at hd\n" +"exact hd\n" +"```" + +#. cases hxy with a ha +#. cases hyx with b hb +#. rw [ha] +#. rw [ha, add_assoc] at hb +#. symm at hb +#. apply add_right_eq_self at hb +#. apply add_right_eq_zero at hb +#. rw [hb, add_zero] +#. rfl +#. ``` +#: Game.Levels.LessOrEqual.L06le_antisymm +msgid "" +"Here's my proof:\n" +"```\n" +"cases hxy with a ha\n" +"cases hyx with b hb\n" +"rw [ha]\n" +"rw [ha, add_assoc] at hb\n" +"symm at hb\n" +"apply add_right_eq_self at hb\n" +"apply add_right_eq_zero at hb\n" +"rw [hb, add_zero]\n" +"rfl\n" +"```\n" +"\n" +"A passing mathematician remarks that with antisymmetry as well,\n" +"you have proved that `≤` is a *partial order* on `ℕ`.\n" +"\n" +"The boss level of this world is to prove\n" +"that `≤` is a total order. Let's learn two more easy tactics\n" +"first." +msgstr "" +"제 증명은 이렇습니다:\n" +"```\n" +"cases hxy with a ha\n" +"cases hyx with b hb\n" +"rw [ha]\n" +"rw [ha, add_assoc] at hb\n" +"symm at hb\n" +"apply add_right_eq_self at hb\n" +"apply add_right_eq_zero at hb\n" +"rw [hb, add_zero]\n" +"rfl\n" +"```\n" +"\n" +"지나가던 수학자가 이제 반대칭성까지 있으므로 `ℕ` 위의 `≤`이 *partial order*임을 증명했다고 말합니다.\n" +"\n" +"이 world의 boss level은 `≤`가 total order임을 증명하는 것입니다. 그 전에 쉬운 tactic 두 개를 더 배워 봅시다." + +#. cases x with y +#. left +#. rfl +#. rw [one_eq_succ_zero] at hx ⊢ +#. apply succ_le_succ at hx +#. apply le_zero at hx +#. rw [hx] +#. right +#. rfl +#. ``` +#: Game.Levels.LessOrEqual.L10le_one +msgid "" +"Here's my proof:\n" +"```\n" +"cases x with y\n" +"left\n" +"rfl\n" +"rw [one_eq_succ_zero] at hx ⊢\n" +"apply succ_le_succ at hx\n" +"apply le_zero at hx\n" +"rw [hx]\n" +"right\n" +"rfl\n" +"```\n" +"\n" +"If you solved this level then you should be fine with the next level!" +msgstr "" +"제 증명은 이렇습니다:\n" +"```\n" +"cases x with y\n" +"left\n" +"rfl\n" +"rw [one_eq_succ_zero] at hx ⊢\n" +"apply succ_le_succ at hx\n" +"apply le_zero at hx\n" +"rw [hx]\n" +"right\n" +"rfl\n" +"```\n" +"\n" +"이 level을 풀었다면 다음 level도 문제없을 겁니다!" + +#. intro h +#. rw [add_succ, add_succ, add_zero] at h +#. repeat apply succ_inj at h +#. apply zero_ne_succ at h +#. exact h +#. ``` +#: Game.Levels.Implication.L11two_add_two_ne_five +msgid "" +"Here's my proof:\n" +"```\n" +"intro h\n" +"rw [add_succ, add_succ, add_zero] at h\n" +"repeat apply succ_inj at h\n" +"apply zero_ne_succ at h\n" +"exact h\n" +"```\n" +"\n" +"Even though Lean is a theorem prover, right now it's pretty clear that we have not\n" +"developed enough material to make it an adequate calculator. In Algorithm\n" +"World, a more computer-sciency world, we will develop machinery which makes\n" +"questions like this much easier, and goals like $20 + 20 ≠ 41$ feasible.\n" +"Alternatively you can do more mathematics in Advanced Addition World, where we prove\n" +"the lemmas needed to get a working theory of inequalities. Click \"Home\" and\n" +"decide your route." +msgstr "" +"제 증명은 이렇습니다:\n" +"```\n" +"intro h\n" +"rw [add_succ, add_succ, add_zero] at h\n" +"repeat apply succ_inj at h\n" +"apply zero_ne_succ at h\n" +"exact h\n" +"```\n" +"\n" +"Lean은 정리 증명기지만, 지금까지 만든 것만으로는 계산기로 쓰기에 아직 부족하다는 게 분명합니다. 좀 더 컴퓨터과학적인 Algorithm World에서는 이런 문제를 훨씬 쉽게 만들고 $20 + 20 ≠ 41$ 같은 목표도 다룰 수 있게 해 주는 도구를 개발합니다.\n" +"대신 Advanced Addition World로 가서 수학을 더 진행할 수도 있습니다. 거기서는 부등식 이론을 제대로 만들기 위해 필요한 보조정리들을 증명합니다. \"Home\"을 누르고 어느 길로 갈지 선택하세요." + +#. rw [mul_comm, mul_add] +#. repeat rw [mul_comm c] +#. rfl +#. ``` +#: Game.Levels.Multiplication.L08add_mul +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "" +"Here's my proof:\n" +"```\n" +"rw [mul_comm, mul_add]\n" +"repeat rw [mul_comm c]\n" +"rfl\n" +"```" +msgstr "" +"제 증명은 이렇습니다:\n" +"```\n" +"rw [mul_comm, mul_add]\n" +"repeat rw [mul_comm c]\n" +"rfl\n" +"```" + +#: Game.Levels.Implication.L03apply +msgid "Now finish using the `exact` tactic." +msgstr "이제 `exact` tactic을 사용해 마무리하세요." + +#: Game.Levels.Power +msgid "" +"This world introduces exponentiation. If you want to define `37 ^ n`\n" +"then, as always, you will need to know what `37 ^ 0` is, and\n" +"what `37 ^ (succ d)` is, given only `37 ^ d`.\n" +"\n" +"You can probably guess the names of the general theorems:\n" +"\n" +" * `pow_zero (a : ℕ) : a ^ 0 = 1`\n" +" * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n" +"\n" +"Using only these, can you get past the final boss level?\n" +"\n" +"The levels in this world were designed by Sian Carey, a UROP student\n" +"at Imperial College London, funded by a Mary Lister McCammon Fellowship\n" +"in the summer of 2019. Thanks to Sian and also thanks to Imperial\n" +"College for funding her." +msgstr "" +"이 월드에서는 거듭제곱을 도입합니다. `37 ^ n`를 정의하려면 언제나 그렇듯 `37 ^ 0`이 무엇인지, 그리고 `37 ^ d`만 알고 있을 때 `37 ^ (succ d)`가 무엇인지 알아야 합니다.\n" +"\n" +"일반 정리의 이름은 아마 짐작할 수 있을 겁니다:\n" +"\n" +" * `pow_zero (a : ℕ) : a ^ 0 = 1`\n" +" * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n" +"\n" +"이 둘만 사용해서 최종 보스 level을 넘을 수 있을까요?\n" +"\n" +"이 세계의 level들은 2019년 여름 Imperial College London의 UROP 학생 Sian Carey가 설계했으며 Mary Lister McCammon Fellowship의 지원을 받았습니다. Sian과 그녀를 지원한 Imperial College에 감사드립니다." + +#: Game.Levels.Implication.L04succ_inj +msgid "" +"Let's first get `h` into the form `succ x = succ 3` so we can\n" +"apply `succ_inj`. First execute `rw [four_eq_succ_three] at h`\n" +"to change the 4 on the right hand side." +msgstr "먼저 `succ_inj`를 적용할 수 있도록 `h`를 `succ x = succ 3` 꼴로 바꿉시다. 오른쪽의 4를 바꾸기 위해 먼저 `rw [four_eq_succ_three] at h`을 해보세요.." + +#: Game.Levels.Tutorial.L04rw_backwards Game.Levels.Tutorial.L05add_zero +msgid "Now `rw [add_zero]` will change `c + 0` into `c`." +msgstr "이제 `rw [add_zero]`가 `c + 0`을 `c`로 바꿉니다." + +#: Game.Levels.Tutorial.L04rw_backwards Game.Levels.Tutorial.L05add_zero +msgid "Now `rw [← two_eq_succ_one]` will change `succ 1` into `2`." +msgstr "이제 `rw [← two_eq_succ_one]`가 `succ 1`을 `2`로 바꿉니다." + +#. intro h +#. apply succ_inj +#. repeat rw [succ_eq_add_one] +#. exact h +#. ``` +#: Game.Levels.Implication.L07intro2 +msgid "" +"Here's a completely backwards proof:\n" +"```\n" +"intro h\n" +"apply succ_inj\n" +"repeat rw [succ_eq_add_one]\n" +"exact h\n" +"```" +msgstr "" +"완전히 거꾸로 가는 증명은 다음과 같습니다:\n" +"```\n" +"intro h\n" +"apply succ_inj\n" +"repeat rw [succ_eq_add_one]\n" +"exact h\n" +"```" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "x ≤ 0 → x = 0" +msgstr "x ≤ 0 → x = 0" + +#: Game.Levels.AdvAddition +msgid "Advanced Addition World" +msgstr "고급 덧셈 월드" + +#: Game.Levels.Tutorial.L01rfl +msgid "If $x$ and $q$ are arbitrary natural numbers, then $37x+q=37x+q.$" +msgstr "$x$와 $q$이 임의의 자연수라면 $37x+q=37x+q.$입니다." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "This time, use the `left` tactic." +msgstr "이번에는 `left` tactic을 사용하세요." + +#: Game.Levels.Power.L09add_sq +msgid "" +"It's all over! You have proved a theorem which has tripped up\n" +"schoolkids for generations (some of them think $(a+b)^2=a^2+b^2$:\n" +"this is \"the freshman's dream\").\n" +"\n" +"How many rewrites did you use? I can do it in 12.\n" +"\n" +"But wait! This boss is stirring...and mutating into a second more powerful form!" +msgstr "" +"끝났습니다! 여러 세대의 학생들을 괴롭혀 온 정리를 증명했습니다\n" +"(어떤 학생들은 $(a+b)^2=a^2+b^2$라고 생각하죠. 이것이 바로 “새내기의 꿈”입니다).\n" +"\n" +"rewrite를 몇 번 썼나요? 저는 12번이면 됩니다.\n" +"\n" +"그런데 잠깐! 보스가 꿈틀거리더니... 더 강력한 두 번째 형태로 변신합니다!" + +#: Game.Levels.Multiplication.L08add_mul +msgid "" +"Addition is distributive over multiplication.\n" +"In other words, for all natural numbers $a$, $b$ and $c$, we have\n" +"$(a + b) \\times c = ac + bc$." +msgstr "" +"덧셈은 곱셈에 대해 분배됩니다. 즉 모든 자연수 $a$, $b$, $c$에 대해\n" +"$(a + b) times c = ac + bc$이 성립합니다." + +#: Game.Levels.Multiplication.L07mul_add +msgid "" +"Multiplication distributes\n" +"over addition on the left.\n" +"\n" +"`mul_add a b c` is the proof that `a * (b + c) = a * b + a * c`." +msgstr "" +"곱셈은 왼쪽에서 덧셈에 대해 분배됩니다.\n" +"\n" +"`mul_add a b c`는 `a * (b + c) = a * b + a * c`의 증명입니다." + +#: Game.Levels.Tutorial.L07add_succ +msgid "`add_succ a b` is the proof of `a + succ b = succ (a + b)`." +msgstr "`add_succ a b`는 `a + succ b = succ (a + b)`의 증명입니다." + +#: Game.Levels.Multiplication.L04mul_comm +msgid "" +"`mul_comm` is the proof that multiplication is commutative. More precisely,\n" +"`mul_comm a b` is the proof that `a * b = b * a`." +msgstr "`mul_comm`는 곱셈이 가환이라는 것의 증명입니다. 더 정확히는 `mul_comm a b`이 `a * b = b * a`의 증명입니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Multiplication.L01mul_one +#: Game.Levels.Multiplication.L06two_mul Game.Levels.Algorithm.L07succ_ne_succ +msgid "`mul_one m` is the proof that `m * 1 = m`." +msgstr "`mul_one m`는 `m * 1 = m`의 증명입니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Multiplication.L01mul_one +#: Game.Levels.Multiplication.L06two_mul Game.Levels.Algorithm.L07succ_ne_succ +msgid "`mul_succ a b` is the proof that `a * succ b = a * b + a`." +msgstr "`mul_succ a b`는 `a * succ b = a * b + a`의 증명입니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Multiplication.L01mul_one +#: Game.Levels.Multiplication.L06two_mul Game.Levels.Algorithm.L07succ_ne_succ +msgid "`mul_zero m` is the proof that `m * 0 = 0`." +msgstr "`mul_zero m`는 `m * 0 = 0`의 증명입니다." + +#: Game.Levels.Multiplication.L05one_mul +msgid "`one_mul m` is the proof `1 * m = m`." +msgstr "`one_mul m`는 `1 * m = m`의 증명입니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Multiplication.L01mul_one +#: Game.Levels.Multiplication.L06two_mul Game.Levels.Algorithm.L07succ_ne_succ +msgid "`succ_eq_add_one n` is the proof that `succ n = n + 1`." +msgstr "`succ_eq_add_one n`는 `succ n = n + 1`의 증명입니다." + +#: Game.Levels.Multiplication.L03succ_mul +msgid "" +"`succ_mul a b` is the proof that `succ a * b = a * b + b`.\n" +"\n" +"It could be deduced from `mul_succ` and `mul_comm`, however this argument\n" +"would be circular because the proof of `mul_comm` uses `mul_succ`." +msgstr "" +"`succ_mul a b`는 `succ a * b = a * b + b`의 증명입니다.\n" +"\n" +"`mul_succ`와 `mul_comm`에서 이끌어낼 수도 있지만, `mul_comm`의 증명이 `mul_succ`를 사용하므로 그렇게 하면 순환 논증이 됩니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Multiplication.L01mul_one +#: Game.Levels.Multiplication.L06two_mul Game.Levels.Algorithm.L07succ_ne_succ +msgid "`succ_ne_succ m n` is the proof that `m ≠ n → succ m ≠ succ n`." +msgstr "`succ_ne_succ m n`는 `m ≠ n → succ m ≠ succ n`의 증명입니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Multiplication.L01mul_one +#: Game.Levels.Multiplication.L06two_mul Game.Levels.Algorithm.L07succ_ne_succ +msgid "`two_mul m` is the proof that `2 * m = m + m`." +msgstr "`two_mul m`는 `2 * m = m + m`의 증명입니다." + +#: Game.Levels.Multiplication.L02zero_mul +msgid "" +"`zero_mul m` is the proof that `0 * m = 0`.\n" +"\n" +"Note: `zero_mul` is a `simp` lemma." +msgstr "" +"`zero_mul m`는 `0 * m = 0`의 증명입니다.\n" +"\n" +"참고: `zero_mul`는 `simp` lemma입니다." + +#: Game.Levels.Implication.L09zero_ne_succ +msgid "" +"`zero_ne_succ n` is the proof that `0 ≠ succ n`.\n" +"\n" +"In Lean, `a ≠ b` is *defined to mean* `a = b → False`. Hence\n" +"`zero_ne_succ n` is really a proof of `0 = succ n → False`.\n" +"Here `False` is a generic false statement. This means that\n" +"you can `apply zero_ne_succ at h` if `h` is a proof of `0 = succ n`." +msgstr "" +"`zero_ne_succ n`는 `0 ≠ succ n`의 증명입니다.\n" +"\n" +"Lean에서 `a ≠ b`는 *`a = b → False`을 뜻하도록 정의*되어 있습니다. 따라서 `zero_ne_succ n`는 실제로 `0 = succ n → False`의 증명입니다. 여기서 `False`는 일반적인 거짓 명제입니다. 즉 `h`이 `0 = succ n`의 증명이라면 `apply zero_ne_succ at h`할 수 있습니다." + +#: Game.Levels.Algorithm.L03add_algo2 +msgid "making life simple" +msgstr "간단하게 만들기" + +#: Game.Levels.Implication.L05succ_inj2 +msgid "" +"Now rewrite `four_eq_succ_three` backwards to make the goal\n" +"equal to the hypothesis." +msgstr "이제 `four_eq_succ_three`를 거꾸로 rewrite해서 goal을 가정과 같게 만드세요." + +#: Game.Levels.Addition.L04add_assoc +msgid "add_assoc (associativity of addition)" +msgstr "add_assoc (덧셈의 결합법칙)" + +#: Game.Levels.Addition.L04add_assoc +msgid "" +"`add_assoc a b c` is a proof\n" +"that `(a + b) + c = a + (b + c)`. Note that in Lean `(a + b) + c` prints\n" +"as `a + b + c`, because the notation for addition is defined to be left\n" +"associative." +msgstr "`add_assoc a b c`는 `(a + b) + c = a + (b + c)`의 증명입니다. Lean에서는 덧셈 표기가 왼쪽 결합으로 정의되어 있기 때문에 `(a + b) + c`가 `a + b + c`처럼 출력됩니다." + +#: Game.Levels.Implication.L07intro2 +msgid "Start with `intro h` to assume the hypothesis." +msgstr "가정을 도입하려면 `intro h`부터 해보세요." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "mul_comm" +msgstr "mul_comm" + +#: Game.Levels.Algorithm.L09decide2 +msgid "We gave a pretty unsatisfactory proof of `2 + 2 ≠ 5` earlier on; now give a nicer one." +msgstr "앞에서 `2 + 2 ≠ 5`에 대해 꽤 아쉬운 증명을 했습니다. 이제 더 멋진 증명을 해 보세요." + +#: Game.Levels.Addition.L01zero_add +msgid "" +"Now you have two goals. Once you proved the first, you will jump to the second one.\n" +"This first goal is the base case $n = 0$.\n" +"\n" +"Recall that you can rewrite the proof of any lemma which is visible\n" +"in your inventory, or of any assumption displayed above the goal,\n" +"as long as it is of the form `X = Y`." +msgstr "" +"이제 goal이 두 개 생겼습니다. 첫 번째를 증명하면 두 번째로 넘어갑니다. 첫 goal은 기저 경우 $n = 0$입니다.\n" +"\n" +"inventory에 보이는 lemma의 증명이나 goal 위에 표시된 가정은 `X = Y` 꼴이기만 하면 언제든 rewrite에 사용할 수 있다는 점을 기억하세요." + +#: Game.Levels.Implication.L05succ_inj2 +msgid "" +"In the last level, we manipulated the hypothesis `x + 1 = 4`\n" +" until it became the goal `x = 3`. In this level we'll manipulate\n" +" the goal until it becomes our hypothesis! In other words, we\n" +" will \"argue backwards\". The `apply` tactic can do this too.\n" +" Again I will walk you through this one (assuming you're in\n" +" command line mode)." +msgstr "지난 level에서는 가정 `x + 1 = 4`를 goal `x = 3`이 될 때까지 변형했습니다. 이번에는 반대로 goal을 가정이 될 때까지 변형합니다! 즉 \"거꾸로 추론\"할 것입니다. `apply` tactic도 이렇게 사용할 수 있습니다. 이번에도 command line mode라고 가정하고 단계별로 안내하겠습니다." + +#: Game.Levels.Tutorial.L06add_zero2 +msgid "" +"`add_zero c` is a proof of `c + 0 = c` so that was what got rewritten.\n" +"You can now change `b + 0` to `b` with `rw [add_zero]` or `rw [add_zero b]`. You\n" +"can usually stick to `rw [add_zero]` unless you need real precision." +msgstr "`add_zero c`가 `c + 0 = c`의 증명이므로 그 부분이 rewrite되었습니다. 이제 `rw [add_zero]`나 `rw [add_zero b]`를 사용해 `b + 0`를 `b`으로 바꿀 수 있습니다. 아주 정밀하게 조작할 필요가 없다면 보통 `rw [add_zero]`만 써도 됩니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "add_right_cancel" +msgstr "add_right_cancel" + +#: Game.Levels.Implication.L04succ_inj +msgid "" +"Now rewrite `succ_eq_add_one` backwards at `h`\n" +"to get the right hand side." +msgstr "이제 `h`에서 `succ_eq_add_one`를 거꾸로 rewrite해 오른쪽 항을 얻으세요." + +#: Game.Levels.Algorithm.L08decide +msgid "" +"You can read more about the `decide` tactic by clicking\n" +"on it in the top right." +msgstr "오른쪽 위에서 `decide` tactic을 클릭하면 자세한 설명을 읽을 수 있습니다." + +#: Game.Levels.Implication.L08ne +msgid "" +"`a ≠ b` is *notation* for `(a = b) → False`.\n" +"\n" +"The reason this is mathematically\n" +"valid is that if `P` is a true-false statement then `P → False`\n" +"is the logical opposite of `P`. Indeed `True → False` is false,\n" +"and `False → False` is true!\n" +"\n" +"The upshot of this is that you can treat `a ≠ b` in exactly\n" +"the same way as you treat any implication `P → Q`. For example,\n" +"if your *goal* is of the form `a ≠ b` then you can make progress\n" +"with `intro h`, and if you have a hypothesis `h` of the\n" +"form `a ≠ b` then you can `apply h at h1` if `h1` is a proof\n" +"of `a = b`." +msgstr "" +"`a ≠ b`는 `(a = b) → False`의 *다른 표현*입니다.\n" +"\n" +"이것이 수학적으로 타당한 이유는 `P`가 참/거짓 명제라면 `P → False`이 `P`의 논리적 반대이기 때문입니다. 실제로 `True → False`는 거짓이고 `False → False`는 참입니다!\n" +"\n" +"따라서 `a ≠ b`은 다른 함의 `P → Q`과 똑같이 다룰 수 있습니다. 예를 들어 *goal*이 `a ≠ b` 꼴이라면 `(a = b) → False`0으로 진행할 수 있고, `(a = b) → False`2 꼴의 가정 `(a = b) → False`1이 있다면 `(a = b) → False`4가 `(a = b) → False`5의 증명일 때 `(a = b) → False`3할 수 있습니다." + +#. §0: `mul_assoc a b c` +#. §1: `(a * b) * c = a * (b * c)` +#. §2: `a * b * c` +#. §3: `(a * b) * c` +#. §4: `(a * b) * c = a * (b * c)` +#. §5: `(6 - 2) - 1` +#. §6: `6 - (2 - 1)` +#: Game.Levels.Multiplication.L09mul_assoc +msgid "" +"§0 is a proof that §1.\n" +"\n" +"Note that when Lean says §2 it means §3.\n" +"\n" +"Note that §4 cannot be proved by \\\\\"pure thought\\\\\":\n" +"for example subtraction is not associative, as §5 is not\n" +"equal to §6." +msgstr "" +"§0는 §1의 증명입니다.\n" +"\n" +"Lean이 §2라고 할 때는 §3을 뜻합니다.\n" +"\n" +"§4는 \"순수한 생각\"만으로 증명할 수 없다는 점에 주의하세요. 예를 들어 뺄셈은 결합법칙을 만족하지 않으며 §5와 §6는 같지 않습니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "add_left_eq_self" +msgstr "add_left_eq_self" + +#: GameServer.RpcHandlers +msgid "level completed with warnings… 🎭" +msgstr "level 완료(그러나 경고가 남은…) 🎭" + +#: Game.Levels.Implication.L08ne +msgid "" +"Remember that `h2` is a proof of `x = y → False`. Try\n" +"`apply`ing `h2` either `at h1` or directly to the goal." +msgstr "`h2`가 `x = y → False`의 증명이라는 점을 기억하세요. `h2`에 `apply`를 `at h1`하거나 goal에 직접 `at h1`해 보세요." + +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "You can now `apply mul_left_cancel at h`" +msgstr "이제 `apply mul_left_cancel at h`를 할 수 있습니다." + +#: Game.Levels.Implication.L05succ_inj2 +msgid "You can now finish with `exact h`." +msgstr "이제 `exact h`로 마무리할 수 있습니다." + +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "" +"This level proves `x * y = 1 → x = 1`, the multiplicative analogue of Advanced Addition\n" +"World's `x + y = 0 → x = 0`. The strategy is to prove that `x ≤ 1` and then use the\n" +"lemma `le_one` from `≤` world.\n" +"\n" +"We'll prove it using a new and very useful tactic called `have`." +msgstr "" +"이 레벨에서는 고급 덧셈 월드의 `x + y = 0 → x = 0`에 대응하는 곱셈 버전 `x * y = 1 → x = 1`를 증명합니다. 전략은 `x ≤ 1`를 증명한 다음 `≤` 월드에서 얻은 lemma `le_one`을 사용하는 것입니다.\n" +"\n" +"새롭고 매우 유용한 tactic `have`를 사용해 증명하겠습니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "pow_add" +msgstr "pow_add" + +#: Game.Levels.Tutorial.L06add_zero2 Game.Levels.LessOrEqual.L08le_total +msgid "Try `cases «{hd}» with h1 h2`." +msgstr "`cases «{hd}» with h1 h2`를 시도해 보세요." + +#: Game.Levels.Tutorial.L06add_zero2 Game.Levels.LessOrEqual.L08le_total +msgid "Try `rw [add_zero c]`." +msgstr "`rw [add_zero c]`를 시도해 보세요." + +#: Game +msgid "" +"# Welcome to the Natural Number Game\n" +"#### An introduction to mathematical proof.\n" +"\n" +"In this game, we will build the basic theory of the natural\n" +"numbers `{0,1,2,3,4,...}` from scratch. Our first goal is to prove\n" +"that `2 + 2 = 4`. Next we'll prove that `x + y = y + x`.\n" +"And at the end we'll see if we can prove Fermat's Last Theorem.\n" +"We'll do this by solving levels of a computer puzzle game called Lean.\n" +"\n" +"# Read this.\n" +"\n" +"Learning how to use an interactive theorem prover takes time.\n" +"Tests show that the people who get the most out of this game are\n" +"those who read the help texts like this one.\n" +"\n" +"To start, click on \"Tutorial World\".\n" +"\n" +"Note: this is a new Lean 4 version of the game containing several\n" +"worlds which were not present in the old Lean 3 version. More new worlds\n" +"such as Strong Induction World, Even/Odd World and Prime Number World\n" +"are in development; if you want to see their state or even help out, checkout\n" +"out the [issues in the github repo](https://github.com/leanprover-community/NNG4/issues).\n" +"\n" +"## More\n" +"\n" +"Click on the three lines in the top right and select \"Game Info\" for resources,\n" +"links, and ways to interact with the Lean community." +msgstr "" +"# 자연수 게임에 오신 것을 환영합니다\n" +"#### 수학적 증명 입문\n" +"\n" +"이 게임에서는 자연수 `{0,1,2,3,4,...}`의 기본 이론을 기초부터 만들어 갑니다. 첫 목표는 `2 + 2 = 4`을 증명하는 것입니다. 다음으로는 `x + y = y + x`를 증명합니다. 마지막에는 페르마의 마지막 정리를 증명할 수 있는지 보겠습니다. Lean이라는 컴퓨터 퍼즐 게임의 level들을 풀면서 진행합니다.\n" +"\n" +"# 일러두기\n" +"\n" +"대화형 정리 증명기를 사용하는 법을 익히는 데에는 시간이 걸립니다. 테스트 결과 이 게임을 가장 잘 활용하는 사람들은 이런 도움말을 꼼꼼히 읽는 사람들이었습니다.\n" +"\n" +"시작하려면 “튜토리얼 세계”를 클릭하세요.\n" +"\n" +"참고: 이것은 새로운 Lean 4 버전으로, 예전 Lean 3 버전에는 없던 여러 월드가 포함되어 있습니다. 강한 귀납법 월드, 홀짝 월드, 소수 월드 같은 새로운 월드도 개발 중입니다. 진행 상황을 보거나 직접 돕고 싶다면 [GitHub repo의 issues](https://github.com/leanprover-community/NNG4/issues)를 확인하세요.\n" +"\n" +"## 더 보기\n" +"\n" +"오른쪽 위의 세 줄 메뉴를 누르고 \"게임 정보\"를 선택하면 자료, 링크, Lean 커뮤니티와 소통하는 방법을 볼 수 있습니다." + +#: Game.Levels.Power.L03pow_one Game.Levels.Power.L04one_pow +#: Game.Levels.Power.L05pow_two +msgid "For all naturals $a$, $a ^ 1 = a$." +msgstr "모든 자연수 $a$에 대해 $a ^ 1 = a$입니다." + +#: Game.Levels.Power.L03pow_one Game.Levels.Power.L04one_pow +#: Game.Levels.Power.L05pow_two +msgid "For all naturals $a$, $a ^ 2 = a \\times a$." +msgstr "모든 자연수 $a$에 대해 $a ^ 2 = a \\times a$입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "For all naturals $a$, $b$, $n$, we have $(ab) ^ n = a ^ nb ^ n$." +msgstr "모든 자연수 $a$, $b$, $n$에 대해 $(ab) ^ n = a ^ nb ^ n$입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "For all naturals $a$, $m$, $n$, we have $(a ^ m) ^ n = a ^ {mn}$." +msgstr "모든 자연수 $a$, $m$, $n$에 대해 $(a ^ m) ^ n = a ^ {mn}$입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "For all naturals $a$, $m$, $n$, we have $a^{m + n} = a ^ m a ^ n$." +msgstr "모든 자연수 $a$, $m$, $n$에 대해 $a^{m + n} = a ^ m a ^ n$입니다." + +#: Game.Levels.Power.L03pow_one Game.Levels.Power.L04one_pow +#: Game.Levels.Power.L05pow_two +msgid "For all naturals $m$, $1 ^ m = 1$." +msgstr "모든 자연수 $m$에 대해 $1 ^ m = 1$입니다." + +#: Game.Levels.Algorithm.L08decide +msgid "" +"# Summary\n" +"\n" +"`decide` will attempt to solve a goal if it can find an algorithm which it\n" +"can run to solve it.\n" +"\n" +"## Example\n" +"\n" +"A term of type `DecidableEq ℕ` is an algorithm to decide whether two naturals\n" +"are equal or different. Hence, once this term is made and made into an `instance`,\n" +"the `decide` tactic can use it to solve goals of the form `a = b` or `a ≠ b`." +msgstr "" +"# 요약\n" +"\n" +"`decide`는 실행 가능한 알고리즘을 찾을 수 있다면 그 알고리즘으로 goal을 해결하려 시도합니다.\n" +"\n" +"## 예시\n" +"\n" +"`DecidableEq ℕ` 타입의 항은 두 자연수가 같은지 다른지를 판정하는 알고리즘입니다. 따라서 이 항을 만들고 `instance`로 등록하면 `decide` tactic이 `a = b`나 `a ≠ b` 꼴의 goal을 해결하는 데 사용할 수 있습니다." + +#: Game.Levels.Implication.L04succ_inj +msgid "" +"Now let's `apply` our new theorem. Execute `apply succ_inj at h`\n" +"to change `h` to a proof of `x = 3`." +msgstr "이제 새 정리를 `apply`해 봅시다. `apply succ_inj at h`을 실행해 `h`를 `x = 3`의 증명으로 바꾸세요." + +#: Game.Levels.Implication.L01exact Game.Levels.LessOrEqual.L01le_refl +msgid "The rfl tactic" +msgstr "rfl tactic" + +#. macro \"simp_add\" : tactic => `(tactic|( +#. simp only [add_assoc, add_left_comm, add_comm])) +#. ``` +#: Game.Levels.Algorithm.L04add_algo3 +msgid "" +"You can make your own tactics in Lean.\n" +"This code here\n" +"```\n" +"macro \"simp_add\" : tactic => `(tactic|(\n" +" simp only [add_assoc, add_left_comm, add_comm]))\n" +"```\n" +"was used to create a new tactic `simp_add`, which runs\n" +"`simp only [add_assoc, add_left_comm, add_comm]`.\n" +"Try running `simp_add` to solve this level!" +msgstr "" +"Lean에서는 자신만의 tactic을 만들 수 있습니다. 여기의 코드\n" +"```\n" +"macro \"simp_add\" : tactic => `(tactic|(\n" +" simp only [add_assoc, add_left_comm, add_comm]))\n" +"```\n" +"로 새로운 tactic `simp_add`을 만들었고, 이 tactic은 `simp only [add_assoc, add_left_comm, add_comm]`를 실행합니다. `simp_add`을 실행해서 이 level을 해결해 보세요!" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "succ_add" +msgstr "succ_add" + +#. §0: `add_comm` +#. §1: `b` +#. §2: `d` +#: Game.Levels.Algorithm.L02add_algo1 +#| msgid "Finally use a targeted §0 to switch §1 and §2" +msgid "Finally use a targeted `add_comm` to switch `b` and `d`." +msgstr "마지막으로 `add_comm`를 정확히 지정해서 사용해 `b`과 `d`를 바꾸세요." + +#: Game.Levels.LessOrEqual.L11le_two +msgid "" +"Nice!\n" +"\n" +"The next step in the development of order theory is to develop\n" +"the theory of the interplay between `≤` and multiplication.\n" +"If you've already done Multiplication World, you're now ready for\n" +"Advanced Multiplication World. Click on \"Home\" to access it." +msgstr "" +"좋습니다!\n" +"\n" +"순서론에서 다음 단계는 `≤`와 곱셈이 어떻게 상호작용하는지 알아보는 것입니다. Multiplication World를 이미 끝냈다면 이제 Advanced Multiplication World에 도전할 준비가 되었습니다. \"Home\"을 눌러 이동하세요." + +#: Game.Levels.Multiplication.L07mul_add +msgid "" +"Induction on `a` is the most troublesome, then `b`,\n" +"and `c` is the easiest." +msgstr "`a`에 대한 귀납이 가장 까다롭고, 그다음이 `b`, `c`가 가장 쉽습니다." + +#: Game.Levels.Algorithm.L03add_algo2 +msgid "" +"# Overview\n" +"\n" +"Lean's simplifier, `simp`, will rewrite every lemma\n" +"tagged with `simp` and every lemma fed to it by the user, as much as it can.\n" +"Furthermore, it will attempt to order variables into an internal order if fed\n" +"lemmas such as `add_comm`, so that it does not go into an infinite loop." +msgstr "" +"# 개요\n" +"\n" +"Lean의 simplifier `simp`는 `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다. 또 `add_comm` 같은 lemma를 주면 무한 루프를 피하기 위해 변수들을 내부적인 순서에 맞춰 정렬하려고 합니다." + +#: Game.Levels.Algorithm.L04add_algo3 +msgid "" +"# Overview\n" +"\n" +"Our home-made tactic `simp_add` will solve arbitrary goals of\n" +"the form `a + (b + c) + (d + e) = e + (d + (c + b)) + a`." +msgstr "" +"# 개요\n" +"\n" +"직접 만든 tactic `simp_add`는 `a + (b + c) + (d + e) = e + (d + (c + b)) + a` 꼴의 임의의 goal을 해결합니다." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"# Summary\n" +"\n" +"If you have a hypothesis\n" +"\n" +"`h : a ≠ b`\n" +"\n" +"and goal\n" +"\n" +"`c ≠ d`\n" +"\n" +"then `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\n" +"a hypothesis\n" +"\n" +"`h : c = d`\n" +"\n" +"and goal\n" +"\n" +"`a = b`." +msgstr "" +"# Summary\n" +"\n" +"If you have a hypothesis\n" +"\n" +"`h : a ≠ b`\n" +"\n" +"and goal\n" +"\n" +"`c ≠ d`\n" +"\n" +"then `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\n" +"a hypothesis\n" +"\n" +"`h : c = d`\n" +"\n" +"and goal\n" +"\n" +"`a = b`." + +#: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +msgid "" +"# Summary\n" +"\n" +"The `tauto` tactic will solve any goal which can be solved purely by logic (that is, by\n" +"truth tables).\n" +"\n" +"## Details\n" +"\n" +"`tauto` *does not do magic*! It doesn't know *anything* about addition or multiplication,\n" +"it doesn't even know `add_zero`. The only things that `tauto` knows about numbers\n" +"are firstly that `a = a` and secondly that `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` and so on.\n" +"What `tauto`'s strength is, is *logic*. If you have a hypothesis `x < 37`\n" +"and another hypothesis `x < 37 → y + z = 42` and your goal is `y + z = 42` then `tauto` will\n" +"solve this goal, because to solve that goal you don't need to know any facts\n" +"about inequalities or addition, all you need to know is the rules of logic.\n" +"\n" +"## Example\n" +"\n" +"If you have `False` as a hypothesis, then `tauto` will solve\n" +"the goal. This is because a false hypothesis implies any hypothesis.\n" +"\n" +"## Example\n" +"\n" +"If your goal is `True`, then `tauto` will solve the goal.\n" +"\n" +"## Example\n" +"\n" +"If you have two hypotheses `h1 : a = 37` and `h2 : a ≠ 37` then `tauto` will\n" +"solve the goal because it can prove `False` from your hypotheses, and thus\n" +"prove the goal (as `False` implies anything).\n" +"\n" +"## Example\n" +"\n" +"If you have one hypothesis `h : a ≠ a` then `tauto` will solve the goal because\n" +"`tauto` is smart enough to know that `a = a` is true, which gives the contradiction we seek.\n" +"\n" +"## Example\n" +"\n" +"If you have a hypothesis `h : 0 = 1` then `tauto` will solve the goal, because\n" +"`tauto` knows `0 ≠ 1` and this is enough to prove `False`, which implies any goal.\n" +"\n" +"## Example\n" +"\n" +"If you have a hypothesis of the form `a = 0 → a * b = 0` and your goal is `a * b ≠ 0 → a ≠ 0`, then\n" +"`tauto` will solve the goal, because the goal is logically equivalent to the hypothesis.\n" +"If you switch the goal and hypothesis in this example, `tauto` would solve it too." +msgstr "" +"# 요약\n" +"\n" +"`tauto` tactic은 순수하게 논리만으로(즉 진리표만으로) 해결할 수 있는 모든 goal을 해결합니다.\n" +"\n" +"## 자세한 설명\n" +"\n" +"`tauto`은 *마법을 쓰지 않습니다*! 덧셈이나 곱셈에 대해서는 *아무것도* 모르고, `add_zero`조차 모릅니다. `tauto`이 수에 대해 아는 것은 첫째 `a = a`이고, 둘째 `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` 등이 있다는 것뿐입니다. `tauto`의 강점은 *논리*입니다. 가정 `x < 37`와 가정 `tauto`0이 있고 goal이 `tauto`1이라면 `tauto`2가 해결합니다. 부등식이나 덧셈에 관한 사실은 하나도 필요 없고 논리의 규칙만 알면 되기 때문입니다.\n" +"\n" +"## 예시\n" +"\n" +"가정 `tauto`3이 있으면 `tauto`4가 goal을 해결합니다. 거짓 가정에서는 어떤 명제든 따라오기 때문입니다.\n" +"\n" +"## 예시\n" +"\n" +"goal이 `tauto`5라면 `tauto`6이 해결합니다.\n" +"\n" +"## 예시\n" +"\n" +"가정 `tauto`7과 `tauto`8이 있으면 `tauto`9가 goal을 해결합니다. 두 가정에서 `add_zero`0을 증명할 수 있고, `add_zero`1은 무엇이든 함의하기 때문입니다.\n" +"\n" +"## 예시\n" +"\n" +"가정 `add_zero`2 하나만 있어도 `add_zero`3이 goal을 해결합니다. `add_zero`4는 `add_zero`5가 참이라는 것을 알아내 모순을 얻을 수 있을 만큼 영리합니다.\n" +"\n" +"## 예시\n" +"\n" +"가정 `add_zero`6이 있으면 `add_zero`7이 goal을 해결합니다. `add_zero`8은 `add_zero`9를 알고 있고 이것으로 `tauto`0을 증명할 수 있으며, `tauto`0에서는 어떤 goal이든 따라옵니다.\n" +"\n" +"## 예시\n" +"\n" +"`tauto`1 꼴의 가정이 있고 goal이 `tauto`2라면 `tauto`3이 해결합니다. goal이 가정과 논리적으로 동치이기 때문입니다. 이 예시에서 goal과 가정을 뒤바꿔도 `tauto`4가 해결합니다." + +#: Game.Levels.Algorithm.L06is_zero +msgid "" +"# Summary\n" +"\n" +"`trivial` will solve the goal `True`." +msgstr "" +"# 요약\n" +"\n" +"`trivial`는 goal `True`을 해결합니다." + +#: Game.Levels.Tutorial.L06add_zero2 +msgid "" +"## Precision rewriting\n" +"\n" +"In the last level, there was `b + 0` and `c + 0`,\n" +"and `rw [add_zero]` changed the first one it saw,\n" +"which was `b + 0`. Let's learn how to tell Lean\n" +"to change `c + 0` first by giving `add_zero` an\n" +"explicit input." +msgstr "" +"## 정밀한 rewriting\n" +"\n" +"지난 level에는 `b + 0`와 `c + 0`이 있었고, `rw [add_zero]`는 처음 발견한 `b + 0`을 바꿨습니다. 이제 `add_zero`에 입력을 명시해서 Lean에게 `c + 0`를 먼저 바꾸라고 지시하는 법을 배워 봅시다." + +#: Game.Levels.Tutorial.L02rw +msgid "" +"## Summary\n" +"\n" +"If `h : X = Y` and there are several `X`s in the goal, then\n" +"`nth_rewrite 3 [h]` will just change the third `X` to a `Y`.\n" +"\n" +"## Example\n" +"\n" +"If the goal is `2 + 2 = 4` then `nth_rewrite 2 [two_eq_succ_one]`\n" +"will change the goal to `2 + succ 1 = 4`. In contrast, `rw [two_eq_succ_one]`\n" +"will change the goal to `succ 1 + succ 1 = 4`." +msgstr "" +"## 요약\n" +"\n" +"`h : X = Y`이고 goal에 `X`이 여러 개 있다면 `nth_rewrite 3 [h]`는 세 번째 `X`만 `Y`로 바꿉니다.\n" +"\n" +"## 예시\n" +"\n" +"goal이 `2 + 2 = 4`라면 `nth_rewrite 2 [two_eq_succ_one]`은 goal을 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 goal을 `succ 1 + succ 1 = 4`로 바꿉니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "" +"## Summary\n" +"\n" +"If `h` is a proof of an equality `X = Y`, then `rw [h]` will change\n" +"all `X`s in the goal to `Y`s. It's the way to \\\"substitute in\\\".\n" +"\n" +"## Variants\n" +"\n" +"* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\n" +"\n" +"* `rw [h1, h2]` (a sequence of rewrites)\n" +"\n" +"* `rw [h] at h2` (changes `X`s to `Y`s in hypothesis `h2`)\n" +"\n" +"* `rw [h] at h1 h2 ⊢` (changes `X`s to `Y`s in two hypotheses and the goal;\n" +"get the `⊢` symbol with `\\|-`.)\n" +"\n" +"* `repeat rw [add_zero]` will keep changing `? + 0` to `?`\n" +"until there are no more matches for `? + 0`.\n" +"\n" +"* `nth_rewrite 2 [h]` will change only the second `X` in the goal to `Y`.\n" +"\n" +"### Example:\n" +"\n" +"If you have the assumption `h : x = y + y` and your goal is\n" +"```\n" +"succ (x + 0) = succ (y + y)\n" +"```\n" +"\n" +"then\n" +"\n" +"`rw [add_zero]`\n" +"\n" +"will change the goal into `succ x = succ (y + y)`, and then\n" +"\n" +"`rw [h]`\n" +"\n" +"will change the goal into `succ (y + y) = succ (y + y)`, which\n" +"can be solved with `rfl`.\n" +"\n" +"### Example:\n" +"\n" +"You can use `rw` to change a hypothesis as well.\n" +"For example, if you have two hypotheses\n" +"```\n" +"h1 : x = y + 3\n" +"h2 : 2 * y = x\n" +"```\n" +"then `rw [h1] at h2` will turn `h2` into `h2 : 2 * y = y + 3`.\n" +"\n" +"## Common errors\n" +"\n" +"* You need the square brackets. `rw h` is never correct.\n" +"\n" +"* If `h` is not a *proof* of an *equality* (a statement of the form `A = B`),\n" +"for example if `h` is a function or an implication,\n" +"then `rw` is not the tactic you want to use. For example,\n" +"`rw [P = Q]` is never correct: `P = Q` is the theorem *statement*,\n" +"not the proof. If `h : P = Q` is the proof, then `rw [h]` will work.\n" +"\n" +"## Details\n" +"\n" +"The `rw` tactic is a way to do \\\"substituting in\\\". There\n" +"are two distinct situations where you can use this tactic.\n" +"\n" +"1) Basic usage: if `h : A = B` is an assumption or\n" +"the proof of a theorem, and if the goal contains one or more `A`s, then `rw [h]`\n" +"will change them all to `B`s. The tactic will error\n" +"if there are no `A`s in the goal.\n" +"\n" +"2) Advanced usage: Assumptions coming from theorem proofs\n" +"often have missing pieces. For example `add_zero`\n" +"is a proof that `? + 0 = ?` because `add_zero` really is a function,\n" +"and `?` is the input. In this situation `rw` will look through the goal\n" +"for any subterm of the form `x + 0`, and the moment it\n" +"finds one it fixes `?` to be `x` then changes all `x + 0`s to `x`s.\n" +"\n" +"Exercise: think about why `rw [add_zero]` changes the term\n" +"`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` to\n" +"`0 + (x + 0) + 0 + (x + 0)`\n" +"\n" +"If you can't remember the name of the proof of an equality, look it up in\n" +"the list of lemmas on the right.\n" +"\n" +"## Targeted usage\n" +"\n" +"If your goal is `b + c + a = b + (a + c)` and you want to rewrite `a + c`\n" +"to `c + a`, then `rw [add_comm]` will not work because Lean finds another\n" +"addition first and swaps those inputs instead. Use `rw [add_comm a c]` to\n" +"guarantee that Lean rewrites `a + c` to `c + a`. This works because\n" +"`add_comm` is a proof that `?1 + ?2 = ?2 + ?1`, `add_comm a` is a proof\n" +"that `a + ? = ? + a`, and `add_comm a c` is a proof that `a + c = c + a`.\n" +"\n" +"If `h : X = Y` then `rw [h]` will turn all `X`s into `Y`s.\n" +"If you only want to change the 37th occurrence of `X`\n" +"to `Y` then do `nth_rewrite 37 [h]`." +msgstr "" +"## Summary\n" +"\n" +"If `h` is a proof of an equality `X = Y`, then `rw [h]` will change\n" +"all `X`s in the goal to `Y`s. It's the way to \\\"substitute in\\\".\n" +"\n" +"## Variants\n" +"\n" +"* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\n" +"\n" +"* `rw [h1, h2]` (a sequence of rewrites)\n" +"\n" +"* `rw [h] at h2` (changes `X`s to `Y`s in hypothesis `h2`)\n" +"\n" +"* `rw [h] at h1 h2 ⊢` (changes `X`s to `Y`s in two hypotheses and the goal;\n" +"get the `⊢` symbol with `\\|-`.)\n" +"\n" +"* `repeat rw [add_zero]` will keep changing `? + 0` to `?`\n" +"until there are no more matches for `? + 0`.\n" +"\n" +"* `nth_rewrite 2 [h]` will change only the second `X` in the goal to `Y`.\n" +"\n" +"### Example:\n" +"\n" +"If you have the assumption `h : x = y + y` and your goal is\n" +"```\n" +"succ (x + 0) = succ (y + y)\n" +"```\n" +"\n" +"then\n" +"\n" +"`rw [add_zero]`\n" +"\n" +"will change the goal into `succ x = succ (y + y)`, and then\n" +"\n" +"`rw [h]`\n" +"\n" +"will change the goal into `succ (y + y) = succ (y + y)`, which\n" +"can be solved with `rfl`.\n" +"\n" +"### Example:\n" +"\n" +"You can use `rw` to change a hypothesis as well.\n" +"For example, if you have two hypotheses\n" +"```\n" +"h1 : x = y + 3\n" +"h2 : 2 * y = x\n" +"```\n" +"then `rw [h1] at h2` will turn `h2` into `h2 : 2 * y = y + 3`.\n" +"\n" +"## Common errors\n" +"\n" +"* You need the square brackets. `rw h` is never correct.\n" +"\n" +"* If `h` is not a *proof* of an *equality* (a statement of the form `A = B`),\n" +"for example if `h` is a function or an implication,\n" +"then `rw` is not the tactic you want to use. For example,\n" +"`rw [P = Q]` is never correct: `P = Q` is the theorem *statement*,\n" +"not the proof. If `h : P = Q` is the proof, then `rw [h]` will work.\n" +"\n" +"## Details\n" +"\n" +"The `rw` tactic is a way to do \\\"substituting in\\\". There\n" +"are two distinct situations where you can use this tactic.\n" +"\n" +"1) Basic usage: if `h : A = B` is an assumption or\n" +"the proof of a theorem, and if the goal contains one or more `A`s, then `rw [h]`\n" +"will change them all to `B`s. The tactic will error\n" +"if there are no `A`s in the goal.\n" +"\n" +"2) Advanced usage: Assumptions coming from theorem proofs\n" +"often have missing pieces. For example `add_zero`\n" +"is a proof that `? + 0 = ?` because `add_zero` really is a function,\n" +"and `?` is the input. In this situation `rw` will look through the goal\n" +"for any subterm of the form `x + 0`, and the moment it\n" +"finds one it fixes `?` to be `x` then changes all `x + 0`s to `x`s.\n" +"\n" +"Exercise: think about why `rw [add_zero]` changes the term\n" +"`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` to\n" +"`0 + (x + 0) + 0 + (x + 0)`\n" +"\n" +"If you can't remember the name of the proof of an equality, look it up in\n" +"the list of lemmas on the right.\n" +"\n" +"## Targeted usage\n" +"\n" +"If your goal is `b + c + a = b + (a + c)` and you want to rewrite `a + c`\n" +"to `c + a`, then `rw [add_comm]` will not work because Lean finds another\n" +"addition first and swaps those inputs instead. Use `rw [add_comm a c]` to\n" +"guarantee that Lean rewrites `a + c` to `c + a`. This works because\n" +"`add_comm`는 `?1 + ?2 = ?2 + ?1`, `add_comm a` is a proof\n" +"that `a + ? = ? + a`, and `add_comm a c` is a proof that `a + c = c + a`.\n" +"\n" +"If `h : X = Y` then `rw [h]` will turn all `X`s into `Y`s.\n" +"If you only want to change the 37th occurrence of `X`\n" +"to `Y` then do `nth_rewrite 37 [h]`.의 증명입니다." + +#: Game.Levels.AdvAddition.L05add_right_eq_zero +msgid "" +"## Summary\n" +"\n" +"If `n` is a number, then `cases n with d` will break the goal into two goals,\n" +"one with `n = 0` and the other with `n = succ d`.\n" +"\n" +"If `h` is a proof (for example a hypothesis), then `cases h with...` will break the\n" +"proof up into the pieces used to prove it.\n" +"\n" +"## Example\n" +"\n" +"If `n : ℕ` is a number, then `cases n with d` will break the goal into two goals,\n" +"one with `n` replaced by 0 and the other with `n` replaced by `succ d`. This\n" +"corresponds to the mathematical idea that every natural number is either `0`\n" +"or a successor.\n" +"\n" +"## Example\n" +"\n" +"If `h : P ∨ Q` is a hypothesis, then `cases h with hp hq` will turn one goal\n" +"into two goals, one with a hypothesis `hp : P` and the other with a\n" +"hypothesis `hq : Q`.\n" +"\n" +"## Example\n" +"\n" +"If `h : False` is a hypothesis, then `cases h` will turn one goal into no goals,\n" +"because there are no ways to make a proof of `False`! And if you have no goals left,\n" +"you have finished the level.\n" +"\n" +"## Example\n" +"\n" +"If `h : a ≤ b` is a hypothesis, then `cases h with c hc` will create a new number `c`\n" +"and a proof `hc : b = a + c`. This is because the *definition* of `a ≤ b` is\n" +"`∃ c, b = a + c`." +msgstr "" +"## 요약\n" +"\n" +"`n`가 수라면 `cases n with d`은 goal을 둘로 나눕니다. 하나에서는 `n = 0`이고 다른 하나에서는 `n = succ d`입니다.\n" +"\n" +"`h`가 증명(예: 가정)이라면 `cases h with...`는 그 증명을 구성한 조각들로 분해합니다.\n" +"\n" +"## 예시\n" +"\n" +"`n : ℕ`가 수라면 `cases n with d`은 goal을 두 개로 나눕니다. 하나에서는 `n`이 0으로 바뀌고, 다른 하나에서는 `n`가 `cases n with d`0으로 바뀝니다. 이는 모든 자연수가 `cases n with d`1이거나 successor라는 수학적 생각에 해당합니다.\n" +"\n" +"## 예시\n" +"\n" +"`cases n with d`2가 가정이라면 `cases n with d`3은 하나의 goal을 두 goal로 바꿉니다. 하나에는 가정 `cases n with d`4가 있고 다른 하나에는 가정 `cases n with d`5가 있습니다.\n" +"\n" +"## 예시\n" +"\n" +"`cases n with d`6가 가정이라면 `cases n with d`7은 goal 하나를 goal 0개로 바꿉니다. `cases n with d`8의 증명을 만드는 방법이 없기 때문입니다! goal이 하나도 남지 않으면 level을 끝낸 것입니다.\n" +"\n" +"## 예시\n" +"\n" +"`cases n with d`9가 가정이라면 `n = 0`0은 새 수 `n = 0`1과 증명 `n = 0`2를 만듭니다. `n = 0`3의 *정의*가 `n = 0`4이기 때문입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "" +"## Summary\n" +"\n" +"If `t : P → Q` is a proof that $P \\implies Q$, and `h : P` is a proof of `P`,\n" +"then `apply t at h` will change `h` to a proof of `Q`. The idea is that if\n" +"you know `P` is true, then you can deduce from `t` that `Q` is true.\n" +"\n" +"If the *goal* is `Q`, then `apply t` will \\\"argue backwards\\\" and change the\n" +"goal to `P`. The idea here is that if you want to prove `Q`, then by `t`\n" +"it suffices to prove `P`, so you can reduce the goal to proving `P`.\n" +"\n" +"### Example:\n" +"\n" +"`succ_inj x y` is a proof that `succ x = succ y → x = y`.\n" +"\n" +"So if you have a hypothesis `h : succ (a + 37) = succ (b + 42)`\n" +"then `apply succ_inj at h` will change `h` to `a + 37 = b + 42`.\n" +"You could write `apply succ_inj (a + 37) (b + 42) at h`\n" +"but Lean is smart enough to figure out the inputs to `succ_inj`.\n" +"\n" +"### Example\n" +"\n" +"If the goal is `a * b = 7`, then `apply succ_inj` will turn the\n" +"goal into `succ (a * b) = succ 7`." +msgstr "" +"## Summary\n" +"\n" +"If `t : P → Q`는 $P \\implies Q$, and `h : P` is a proof of `P`,\n" +"then `apply t at h` will change `h` to a proof of `Q`. The idea is that if\n" +"you know `P` is true, then you can deduce from `t` that `Q` is true.\n" +"\n" +"If the *goal* is `Q`, then `apply t` will \\\"argue backwards\\\" and change the\n" +"goal to `P`. The idea here is that if you want to prove `Q`, then by `t`\n" +"it suffices to prove `P`, so you can reduce the goal to proving `P`.\n" +"\n" +"### Example:\n" +"\n" +"`succ_inj x y` is a proof that `succ x = succ y → x = y`.\n" +"\n" +"So if you have a hypothesis `h : succ (a + 37) = succ (b + 42)`\n" +"then `apply succ_inj at h` will change `h` to `a + 37 = b + 42`.\n" +"You could write `apply succ_inj (a + 37) (b + 42) at h`\n" +"but Lean is smart enough to figure out the inputs to `succ_inj`.\n" +"\n" +"### Example\n" +"\n" +"If the goal is `a * b = 7`, then `apply succ_inj` will turn the\n" +"goal into `succ (a * b) = succ 7`.의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "" +"## Summary\n" +"\n" +"If the goal is a statement `P`, then `exact h` will close the goal if `h` is a proof of `P`.\n" +"\n" +"### Example\n" +"\n" +"If the goal is `x = 37` and you have a hypothesis `h : x = 37`\n" +"then `exact h` will solve the goal.\n" +"\n" +"### Example\n" +"\n" +"If the goal is `x + 0 = x` then `exact add_zero x` will close the goal.\n" +"\n" +"### Exact needs to be exactly right\n" +"\n" +"Note that `exact add_zero` will *not work* in the previous example;\n" +"for `exact h` to work, `h` has to be *exactly* a proof of the goal.\n" +"`add_zero` is a proof of `∀ n, n + 0 = n` or, if you like,\n" +"a proof of `? + 0 = ?` where `?` needs to be supplied by the user.\n" +"This is in contrast to `rw` and `apply`, which will \\\"guess the inputs\\\"\n" +"if necessary. If the goal is `x + 0 = x` then `rw [add_zero]`\n" +"and `rw [add_zero x]` will both change the goal to `x = x`,\n" +"because `rw` guesses the input to the function `add_zero`." +msgstr "" +"## Summary\n" +"\n" +"If the goal is a statement `P`, then `exact h` will close the goal if `h`는 `P`.\n" +"\n" +"### Example\n" +"\n" +"If the goal is `x = 37` and you have a hypothesis `h : x = 37`\n" +"then `exact h` will solve the goal.\n" +"\n" +"### Example\n" +"\n" +"If the goal is `x + 0 = x` then `exact add_zero x` will close the goal.\n" +"\n" +"### Exact needs to be exactly right\n" +"\n" +"Note that `exact add_zero` will *not work* in the previous example;\n" +"for `exact h` to work, `h` has to be *exactly* a proof of the goal.\n" +"`add_zero` is a proof of `∀ n, n + 0 = n` or, if you like,\n" +"a proof of `? + 0 = ?` where `?` needs to be supplied by the user.\n" +"This is in contrast to `rw` and `apply`, which will \\\"guess the inputs\\\"\n" +"if necessary. If the goal is `x + 0 = x` then `rw [add_zero]`\n" +"and `rw [add_zero x]` will both change the goal to `x = x`,\n" +"because `rw` guesses the input to the function `add_zero`의 증명입니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "" +"## Summary\n" +"\n" +"The `use` tactic makes progress with goals which claim something *exists*.\n" +"If the goal claims that some `x` exists with some property, and you know\n" +"that `x = 37` will work, then `use 37` will make progress.\n" +"\n" +"Because `a ≤ b` is notation for \\\"there exists `c` such that `b = a + c`\\\",\n" +"you can make progress on goals of the form `a ≤ b` by `use`ing the\n" +"number which is morally `b - a` (i.e. `use b - a`)\n" +"\n" +"Any of the following examples is possible assuming the type of the argument passed to the `use` function is accurate:\n" +"\n" +"- `use 37`\n" +"- `use a`\n" +"- `use a * a + 1`" +msgstr "" +"## Summary\n" +"\n" +"The `use` tactic makes progress with goals which claim something *exists*.\n" +"If the goal claims that some `x` exists with some property, and you know\n" +"that `x = 37` will work, then `use 37` will make progress.\n" +"\n" +"Because `a ≤ b` is notation for \\\"there exists `c` such that `b = a + c`\\\",\n" +"you can make progress on goals of the form `a ≤ b` by `use`ing the\n" +"number which is morally `b - a` (i.e. `use b - a`)\n" +"\n" +"Any of the following examples is possible assuming the type of the argument passed to the `use` function is accurate:\n" +"\n" +"- `use 37`\n" +"- `use a`\n" +"- `use a * a + 1`" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "" +"## Summary\n" +"\n" +"`rfl` proves goals of the form `X = X`.\n" +"\n" +"In other words, the `rfl` tactic will close any goal of the\n" +"form `A = B` if `A` and `B` are *identical*.\n" +"\n" +"`rfl` is short for \\\"reflexivity (of equality)\\\".\n" +"\n" +"## Example:\n" +"\n" +"If the goal looks like this:\n" +"\n" +"```\n" +"x + 37 = x + 37\n" +"```\n" +"\n" +"then `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even\n" +"though $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.\n" +"The only term which is identical to `0 + x` is `0 + x`.\n" +"\n" +"## Details\n" +"\n" +"`rfl` is short for \\\"reflexivity of equality\\\".\n" +"\n" +"## Game Implementation\n" +"\n" +"*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,\n" +"for pedagogical purposes; mathematicians do not distinguish between propositional\n" +"and definitional equality because they think about definitions in a different way\n" +"to type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\n" +"as mathematicians are concerned, and who cares what the definition of addition is).*" +msgstr "" +"## Summary\n" +"\n" +"`rfl` proves goals of the form `X = X`.\n" +"\n" +"In other words, the `rfl` tactic will close any goal of the\n" +"form `A = B` if `A` and `B` are *identical*.\n" +"\n" +"`rfl` is short for \\\"reflexivity (of equality)\\\".\n" +"\n" +"## Example:\n" +"\n" +"If the goal looks like this:\n" +"\n" +"```\n" +"x + 37 = x + 37\n" +"```\n" +"\n" +"then `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even\n" +"though $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.\n" +"The only term which is identical to `0 + x` is `0 + x`.\n" +"\n" +"## Details\n" +"\n" +"`rfl` is short for \\\"reflexivity of equality\\\".\n" +"\n" +"## Game Implementation\n" +"\n" +"*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,\n" +"for pedagogical purposes; mathematicians do not distinguish between propositional\n" +"and definitional equality because they think about definitions in a different way\n" +"to type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\n" +"as mathematicians are concerned, and who cares what the definition of addition is).*" + +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "" +"## The birth of number.\n" +"\n" +"Numbers in Lean are defined by two rules.\n" +"\n" +"* `0` is a number.\n" +"* If `n` is a number, then the *successor* `succ n` of `n` is a number.\n" +"\n" +"The successor of `n` means the number after `n`. Let's learn to\n" +"count, and name a few small numbers.\n" +"\n" +"## Counting to four.\n" +"\n" +"`0` is a number, so `succ 0` is a number. Let's call this new number `1`.\n" +"Similarly let's define `2 = succ 1`, `3 = succ 2` and `4 = succ 3`.\n" +"This gives us plenty of numbers to be getting along with.\n" +"\n" +"The *proof* that `2 = succ 1` is called `two_eq_succ_one`.\n" +"Check out the \"012\" tab in the list of lemmas on the right\n" +"for this and other proofs.\n" +"\n" +"Let's prove that $2$ is the number after the number after zero." +msgstr "" +"## 수의 탄생\n" +"\n" +"Lean의 수는 두 규칙으로 정의됩니다.\n" +"\n" +"* `0`는 수입니다.\n" +"* `n`이 수라면 `n`의 *successor* `succ n`도 수입니다.\n" +"\n" +"`n`의 successor란 `n` 다음의 수를 뜻합니다. 이제 세는 법을 배우고 작은 수 몇 개에 이름을 붙여 봅시다.\n" +"\n" +"## 4까지 세기\n" +"\n" +"`0`는 수이므로 `succ 0`도 수입니다. 이 새 수를 `1`이라고 부릅시다. 같은 방식으로 `2 = succ 1`, `n`0, `n`1을 정의합니다. 이 정도면 당분간 쓸 수가 충분합니다.\n" +"\n" +"`n`2의 *증명*은 `n`3이라고 부릅니다. 오른쪽 lemma 목록의 \"012\" 탭에서 이 증명과 다른 증명들을 확인하세요.\n" +"\n" +"`n`4가 0 다음의 다음 수라는 것을 증명해 봅시다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "$0 ^ 0 = 1$" +msgstr "$0 ^ 0 = 1$" + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$0\\neq1$." +msgstr "$0\\neq1$." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$1\\neq0$." +msgstr "$1\\neq0$." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Tutorial.L04rw_backwards +msgid "$2$ is the number after the number after $0$." +msgstr "$2$는 $0$ 다음의 다음 수입니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "$2+2 \\neq 5.$" +msgstr "$2+2 \\neq 5.$" + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$2+2=4$." +msgstr "$2+2=4$." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$2+2≠5$." +msgstr "$2+2≠5$." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$20+20=40$." +msgstr "$20+20=40$." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$\\operatorname{succ}(a) \\neq 0$." +msgstr "$\\operatorname{succ}(a) \\neq 0$." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "$a+(b+0)+(c+0)=a+b+c.$" +msgstr "$a+(b+0)+(c+0)=a+b+c.$" + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$a+n=b+n\\implies a=b$." +msgstr "$a+n=b+n\\implies a=b$." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$n+a=n+b\\implies a=b$." +msgstr "$n+a=n+b\\implies a=b$." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "$x + y = y\\implies x=0.$" +msgstr "$x + y = y\\implies x=0.$" + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$x+1=y+1 \\implies x=y$." +msgstr "$x+1=y+1 \\implies x=y$." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$x+y=x\\implies y=0$." +msgstr "$x+y=x\\implies y=0$." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "$x=37\\implies x=37$." +msgstr "$x=37\\implies x=37$." + +#: Game +msgid "" +"*Game version: 4.3*\n" +"\n" +"*Recent additions: bug fixes*\n" +"\n" +"## Progress saving\n" +"\n" +"The game stores your progress in your local browser storage.\n" +"If you delete it, your progress will be lost!\n" +"\n" +"Warning: In most browsers, deleting cookies will also clear the local storage\n" +"(or \"local site data\"). Make sure to download your game progress first!\n" +"\n" +"## Credits\n" +"\n" +"* **Creators:** Kevin Buzzard, Jon Eugster\n" +"* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n" +"* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" +"* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n" +"* **Additional thanks:** All the student beta testers, all the schools\n" +"who invited Kevin to speak, and all the schoolkids who asked him questions\n" +"about the material.\n" +"\n" +"## Resources\n" +"\n" +"* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n" +"* [Original Lean3 version](https://github.com/ImperialCollegeLondon/natural_number_game/) (no longer maintained)\n" +"\n" +"## Problems?\n" +"\n" +"Please ask any questions about this game in the\n" +"[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\n" +"the stream \"New Members\". The community will happily help. Note that\n" +"the Lean Zulip chat is a professional research forum.\n" +"Please use your full real name there, stay on topic, and be nice. If you're\n" +"looking for somewhere less formal (e.g. you want to post natural number\n" +"game memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n" +"\n" +"Alternatively, if you experience issues / bugs you can also open github issues:\n" +"\n" +"* For issues with the game engine, please open an\n" +"[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n" +"* For issues about the game's content, please open an\n" +"[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo." +msgstr "" +"*게임 버전: 4.3*\n" +"\n" +"*최근 추가 사항: 버그 수정*\n" +"\n" +"## 진행 상황 저장\n" +"\n" +"게임은 진행 상황을 브라우저의 로컬 스토리지에 저장합니다. 이를 삭제하면 진행 상황도 사라집니다!\n" +"\n" +"주의: 대부분의 브라우저에서 쿠키를 삭제하면 로컬 스토리지(또는 “로컬 사이트 “데이)도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n" +"\n" +"## 크레딧\n" +"\n" +"* **제작:** Kevin Buzzard, Jon Eugster\n" +"* **원래 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n" +"* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" +"* **추가 level:** Sian Carey, Ivan Farabella, Archie Browne\n" +"* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n" +"\n" +"## 자료\n" +"\n" +"* [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼\n" +"* [원래 Lean3 버전](https://github.com/ImperialCollegeLondon/natural_number_game/) (현재는 유지보수되지 않음)\n" +"\n" +"## 문제가 있나요?\n" +"\n" +"이 게임에 관한 질문은 [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼, 예를 들어 \"New Members\" stream에 올려 주세요. 커뮤니티가 기꺼이 도와줄 것입니다. Lean Zulip chat은 전문 연구 포럼이라는 점에 유의하세요. 실명을 사용하고, 주제에 맞게 대화하며, 서로 예의를 지켜 주세요. 좀 더 가벼운 공간을 찾는다면(예: natural number game 밈을 올리고 싶다면) [Lean Discord](https://discord.gg/WZ9bs9UCvx)로 가세요.\n" +"\n" +"문제나 버그가 있다면 GitHub issue를 열 수도 있습니다.\n" +"\n" +"* 게임 엔진 문제는 [lean4game](https://github.com/leanprover-community/lean4game/issues) repo에 issue를 열어 주세요.\n" +"* 게임 내용 문제는 [NNG](https://github.com/hhu-adam/NNG4/issues) repo에 issue를 열어 주세요." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"*Game version: 4.3*\n" +"\n" +"*Recent additions: bug fixes*\n" +"\n" +"## Progress saving\n" +"\n" +"The game stores your progress in your local browser storage.\n" +"If you delete it, your progress will be lost!\n" +"\n" +"Warning: In most browsers, deleting cookies will also clear the local storage\n" +"(or \"local site data\"). Make sure to download your game progress first!\n" +"\n" +"## Credits\n" +"\n" +"* **Creators:** Kevin Buzzard, Jon Eugster\n" +"* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n" +"* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" +"* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n" +"* **Additional thanks:** All the student beta testers, all the schools\n" +"who invited Kevin to speak, and all the schoolkids who asked him questions\n" +"about the material.\n" +"\n" +"## Resources\n" +"\n" +"* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n" +"* [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/) (no longer maintained)\n" +"\n" +"## Problems?\n" +"\n" +"Please ask any questions about this game in the\n" +"[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\n" +"the stream \"New Members\". The community will happily help. Note that\n" +"the Lean Zulip chat is a professional research forum.\n" +"Please use your full real name there, stay on topic, and be nice. If you're\n" +"looking for somewhere less formal (e.g. you want to post natural number\n" +"game memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n" +"\n" +"Alternatively, if you experience issues / bugs you can also open github issues:\n" +"\n" +"* For issues with the game engine, please open an\n" +"[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n" +"* For issues about the game's content, please open an\n" +"[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo." +msgstr "" +"*게임 버전: 4.3*\n" +"\n" +"*최근 추가 사항: 버그 수정*\n" +"\n" +"## 진행 상황 저장\n" +"\n" +"게임은 진행 상황을 브라우저의 로컬 스토리지에 저장합니다. 이를 삭제하면 진행 상황도 사라집니다!\n" +"\n" +"주의: 대부분의 브라우저에서 쿠키를 삭제하면 로컬 스토리지(또는 “로컬 사이트 “데이)도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n" +"\n" +"## 크레딧\n" +"\n" +"* **제작:** Kevin Buzzard, Jon Eugster\n" +"* **원래 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n" +"* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" +"* **추가 level:** Sian Carey, Ivan Farabella, Archie Browne\n" +"* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n" +"\n" +"## 자료\n" +"\n" +"* [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼\n" +"* [원래 Lean3 버전](https://github.com/ImperialCollegeLondon/natural_number_game/) (현재는 유지보수되지 않음)\n" +"\n" +"## 문제가 있나요?\n" +"\n" +"이 게임에 관한 질문은 [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼, 예를 들어 \"New Members\" stream에 올려 주세요. 커뮤니티가 기꺼이 도와줄 것입니다. Lean Zulip chat은 전문 연구 포럼이라는 점에 유의하세요. 실명을 사용하고, 주제에 맞게 대화하며, 서로 예의를 지켜 주세요. 좀 더 가벼운 공간을 찾는다면(예: natural number game 밈을 올리고 싶다면) [Lean Discord](https://discord.gg/WZ9bs9UCvx)로 가세요.\n" +"\n" +"문제나 버그가 있다면 GitHub issue를 열 수도 있습니다.\n" +"\n" +"* 게임 엔진 문제는 [lean4game](https://github.com/leanprover-community/lean4game/issues) repo에 issue를 열어 주세요.\n" +"* 게임 내용 문제는 [NNG](https://github.com/hhu-adam/NNG4/issues) repo에 issue를 열어 주세요." + +#: Game.Levels.LessOrEqual.L02zero_le +msgid "0 ≤ x" +msgstr "0 ≤ x" + +#: Game.Levels.Implication.L10one_ne_zero +msgid "1 ≠ 0" +msgstr "1 ≠ 0" + +#: Game.Levels.Implication.L11two_add_two_ne_five +msgid "" +"2 + 2 ≠ 5 is boring to prove in full, given only the tools we have currently.\n" +"To make it a bit less painful, I have unfolded all of the numerals for you.\n" +"See if you can use `zero_ne_succ` and `succ_inj` to prove this." +msgstr "현재 가진 도구만으로 `zero_ne_succ`를 처음부터 증명하는 것은 꽤 지루합니다. 조금 덜 괴롭도록 숫자들을 모두 펼쳐 두었습니다. `zero_ne_succ`와 `succ_inj`을 이용해 증명해 보세요." + +#: Game.Levels.LessOrEqual.L04le_trans +msgid "" +"A passing mathematician remarks that with reflexivity and transitivity out of the way,\n" +"you have proved that `≤` is a *preorder* on `ℕ`." +msgstr "지나가던 수학자가 반사성과 추이성을 증명했으므로 `ℕ` 위의 `≤`가 *preorder*임을 증명했다고 말합니다." + +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +msgid "A proof that $a+b=0 \\implies a=0$." +msgstr "$a+b=0 \\implies a=0$라는 증명." + +#: Game.Levels.AdvAddition.L05add_right_eq_zero +#: Game.Levels.AdvAddition.L06add_left_eq_zero +msgid "A proof that $a+b=0 \\implies b=0$." +msgstr "$a+b=0 \\implies b=0$라는 증명." + +#. nth_rewrite 2 [← mul_one a] at h +#. exact mul_left_cancel a b 1 ha h +#. ``` +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "" +"A two-line proof is\n" +"\n" +"```\n" +"nth_rewrite 2 [← mul_one a] at h\n" +"exact mul_left_cancel a b 1 ha h\n" +"```\n" +"\n" +"We now have all the tools necessary to set up the basic theory of divisibility of naturals." +msgstr "" +"두 줄짜리 증명은\n" +"\n" +"```\n" +"nth_rewrite 2 [← mul_one a] at h\n" +"exact mul_left_cancel a b 1 ha h\n" +"```\n" +"\n" +"입니다. 이제 자연수의 나눗셈 가능성(divisibility)에 대한 기본 이론을 세울 도구가 모두 준비되었습니다." + +#: Game.Levels.Tutorial.L05add_zero +msgid "Adding zero" +msgstr "0 더하기" + +#: Game.Levels.AdvMultiplication +msgid "" +"Advanced *Addition* World proved various implications\n" +"involving addition, such as `x + y = 0 → x = 0` and `x + y = x → y = 0`.\n" +"These lemmas were used to prove basic facts about ≤ in ≤ World.\n" +"\n" +"In Advanced Multiplication World we prove analogous\n" +"facts about multiplication, such as `x * y = 1 → x = 1`, and\n" +"`x * y = x → y = 1` (assuming `x ≠ 0` in the latter result). This will prepare\n" +"us for Divisibility World.\n" +"\n" +"Multiplication World is more complex than Addition World. In the same\n" +"way, Advanced Multiplication world is more complex than Advanced Addition\n" +"World. One reason for this is that certain intermediate results are only\n" +"true under the additional hypothesis that one of the variables is non-zero.\n" +"This causes some unexpected extra twists." +msgstr "" +"Advanced *Addition* World에서는 `x + y = 0 → x = 0`와 `x + y = x → y = 0` 같은 덧셈 관련 여러 함의를 증명했습니다. 이 lemma들은 ≤ World에서 ≤의 기본 성질을 증명하는 데 사용되었습니다.\n" +"\n" +"Advanced Multiplication World에서는 이에 대응하는 곱셈 관련 사실, 예를 들어 `x * y = 1 → x = 1`와 `x * y = x → y = 1`(후자는 `x ≠ 0`를 가정)을 증명합니다. 이것이 Divisibility World를 준비해 줍니다.\n" +"\n" +"Multiplication World는 Addition World보다 복잡합니다. 마찬가지로 Advanced Multiplication World도 Advanced Addition World보다 복잡합니다. 이유 중 하나는 몇몇 중간 결과가 변수 하나가 0이 아니라는 추가 가정 아래에서만 참이기 때문입니다. 그래서 예상하지 못한 꼬임이 몇 번 생깁니다." + +#: Game.Levels.AdvMultiplication +msgid "Advanced Multiplication World" +msgstr "고급 곱셈 월드" + +#: Game.Levels.Algorithm +msgid "Algorithm World" +msgstr "알고리즘 월드" + +#: Game.Levels.Power.L02zero_pow_succ +msgid "" +"Although $0^0=1$ in this game, $0^n=0$ if $n>0$, i.e., if\n" +"$n$ is a successor." +msgstr "이 게임에서는 $0^0=1$이지만, $n>0$라면, 즉 $n$가 successor라면 $0^n=0$입니다." + +#: Game.Levels.Algorithm.L07succ_ne_succ +msgid "An algorithm for equality" +msgstr "동등성 판정 알고리즘" + +#: Game.Levels.Tutorial.L07add_succ +msgid "And finally `rfl`." +msgstr "그리고 마지막으로 `rfl`." + +#: Game.Levels.Tutorial.L07add_succ +msgid "And now `rw [add_zero]`" +msgstr "그리고 이제 `rw [add_zero]`." + +#: Game.Levels.Implication.L04succ_inj +msgid "" +"And now we've deduced what we wanted to prove: the goal is one of our assumptions.\n" +"Finish the level with `exact h`." +msgstr "이제 우리가 증명하고 싶던 것을 이끌어냈습니다. goal이 가정 중 하나입니다. `exact h`로 level을 마무리하세요." + +#: Game.Levels.Implication.L05succ_inj2 +msgid "" +"Applying a proof of $P\\implies Q$ to the *goal* changes $Q$ to $P$.\n" +"Now try `rw [succ_eq_add_one]` to make the goal more like the hypothesis." +msgstr "$P\\implies Q$의 증명을 *goal*에 적용하면 $Q$이 $P$로 바뀝니다. 이제 `rw [succ_eq_add_one]`을 사용해 goal을 가정과 더 비슷하게 만들어 보세요." + +#: Game.Levels.Implication.L02exact2 +msgid "Assuming $0+x=(0+y)+2$, we have $x=y+2$." +msgstr "$0+x=(0+y)+2$를 가정하면 $x=y+2$입니다." + +#: Game.Levels.Addition.L01zero_add +msgid "" +"At this point you see the term `0 + «{d}»`, so you can use the\n" +"induction hypothesis with `rw [«{hd}»]`." +msgstr "이제 항 `0 + «{d}»`가 보이므로 `rw [«{hd}»]`과 함께 귀납가정을 사용할 수 있습니다." + +#: Game.Levels.Tutorial.L04rw_backwards +msgid "Can you now change the goal into `2 = 2`?" +msgstr "이제 goal을 `2 = 2`로 바꿀 수 있나요?" + +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "Can you take it from here?" +msgstr "이제부터는 스스로 할 수 있겠나요?" + +#: Game.Levels.Tutorial.L02rw +msgid "Can you take it from here? Click on \"Show more help!\" if you need a hint." +msgstr "이제부터는 스스로 할 수 있겠나요? 힌트가 필요하면 \"도움말 더 보기!\"를 누르세요." + +#: Game.Levels.Implication.L04succ_inj +msgid "Concretely: `rw [← succ_eq_add_one] at h`." +msgstr "구체적으로는 `rw [← succ_eq_add_one] at h`입니다." + +#: Game.Levels.Tutorial.L01rfl +msgid "" +"Congratulations! You completed your first verified proof!\n" +"\n" +"Remember that `rfl` is a *tactic*. If you ever want information about the `rfl` tactic,\n" +"you can click on `rfl` in the list of tactics on the right.\n" +"\n" +"Now click on \"Next\" to learn about the `rw` tactic." +msgstr "" +"축하합니다! 첫 번째 검증된 증명을 완성했습니다!\n" +"\n" +"`rfl`가 *tactic*이라는 점을 기억하세요. `rfl` tactic에 대해 궁금하면 오른쪽 tactic 목록의 `rfl`를 클릭하면 됩니다.\n" +"\n" +"이제 \"Next\"를 눌러 `rw` tactic을 배워 봅시다." + +#: Game.Levels.Power.L10FLT +msgid "" +"Congratulations! You have proved Fermat's Last Theorem!\n" +"\n" +"Either that, or you used magic..." +msgstr "" +"축하합니다! 페르마의 마지막 정리를 증명했습니다!\n" +"\n" +"아니면 마법을 썼거나요..." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "Dealing with `or`" +msgstr "`or` 다루기" + +#. nth_rewrite 2 [← zero_add y] +#. exact add_right_cancel x 0 y +#. ``` +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "" +"Did you use induction on `y`?\n" +"Here's a two-line proof of `add_left_eq_self` which uses `add_right_cancel`.\n" +"If you want to inspect it, you can go into editor mode by clicking `` in the top right\n" +"and then just cut and paste the proof and move your cursor around it\n" +"to see the hypotheses and goal at any given point\n" +"(although you'll lose your own proof this way). Click `>_` to get\n" +"back to command line mode.\n" +"```\n" +"nth_rewrite 2 [← zero_add y]\n" +"exact add_right_cancel x 0 y\n" +"```" +msgstr "" +"`y`에 대해 귀납법을 썼나요?\n" +"`add_right_cancel`를 사용하는 `add_left_eq_self`의 두 줄짜리 증명은 다음과 같습니다. 살펴보고 싶다면 오른쪽 위의 ``을 눌러 editor mode로 들어간 뒤 증명을 복사해 붙여 넣고 커서를 옮기면서 각 지점의 가정과 goal을 확인할 수 있습니다(다만 이 과정에서 자신의 증명은 사라집니다). `>_`를 누르면 command line mode로 돌아옵니다.\n" +"```\n" +"nth_rewrite 2 [← zero_add y]\n" +"exact add_right_cancel x 0 y\n" +"```" + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"Do that again!\n" +"\n" +"`rw [zero_add] at «{h}»` tries to fill in\n" +"the arguments to `zero_add` (finding `«{x}»`) then it replaces all occurrences of\n" +"`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet." +msgstr "" +"Do that again!\n" +"\n" +"`rw [zero_add] at «{h}»` tries to fill in\n" +"the arguments to `zero_add` (finding `«{x}»`) then it replaces all occurrences of\n" +"`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet." + +#: Game.Levels.Tutorial.L07add_succ +msgid "" +"Every number in Lean is either $0$ or a successor. We know how to add $0$,\n" +"but we need to figure out how to add successors. Let's say we already know\n" +"that `37 + d = q`. What should the answer to `37 + succ d` be? Well,\n" +"`succ d` is one bigger than `d`, so `37 + succ d` should be `succ q`,\n" +"the number one bigger than `q`. More generally `x + succ d` should\n" +"be `succ (x + d)`. Let's add this as a lemma.\n" +"\n" +"* `add_succ x d : x + succ d = succ (x + d)`\n" +"\n" +"If you ever see `... + succ ...` in your goal, `rw [add_succ]` is\n" +"normally a good idea.\n" +"\n" +"Let's now prove that `succ n = n + 1`. Figure out how to get `+ succ` into\n" +"the picture, and then `rw [add_succ]`. Switch between the `+` (addition) and\n" +"`012` (numerals) tabs under \"Theorems\" on the right to\n" +"see which proofs you can rewrite." +msgstr "" +"Lean의 모든 수는 $0$이거나 successor입니다. $0$을 더하는 법은 알지만 successor를 더하는 법은 아직 모릅니다. 이미 `37 + d = q`를 안다고 합시다. 그렇다면 `37 + succ d`의 답은 무엇이어야 할까요? `succ d`는 `d`보다 1 큰 수이므로 `37 + succ d`는 `succ q`, 즉 `q`보다 1 큰 수여야 합니다. 더 일반적으로 `x + succ d`는 $0$0이어야 합니다. 이를 lemma로 추가합시다.\n" +"\n" +"* $0$1\n" +"\n" +"goal에서 $0$2를 보게 되면 보통 $0$3을 쓰는 것이 좋은 생각입니다.\n" +"\n" +"이제 $0$4를 증명해 봅시다. 먼저 $0$5를 끌어들이는 방법을 찾고, 이어서 $0$6을 사용하세요. 오른쪽 \"Theorems\" 아래의 $0$7(덧셈) 탭과 $0$8(숫자) 탭을 오가며 어떤 증명으로 rewrite할 수 있는지 확인하세요." + +#: Game.Levels.Power.L10FLT +msgid "Fermat's Last Theorem" +msgstr "페르마의 마지막 정리" + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "Finally use a targeted `add_comm` to switch `b` and `d`" +msgstr "Finally use a targeted `add_comm` to switch `b` and `d`" + +#: Game.Levels.Tutorial.L02rw +msgid "First execute `rw [h]` to replace the `y` with `x + 7`." +msgstr "먼저 `rw [h]`를 실행해서 `y`을 `x + 7`로 바꾸세요." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Addition.L01zero_add +#: Game.Levels.Multiplication.L02zero_mul +msgid "For all natural numbers $a$, we have $\\operatorname{succ}(a) = a+1$." +msgstr "모든 자연수 $a$에 대해 $\\operatorname{succ}(a) = a+1$입니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Addition.L01zero_add +#: Game.Levels.Multiplication.L02zero_mul +msgid "For all natural numbers $m$, we have $ 0 \\times m = 0$." +msgstr "모든 자연수 $m$에 대해 $ 0 \\times m = 0$입니다." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Addition.L01zero_add +#: Game.Levels.Multiplication.L02zero_mul +msgid "For all natural numbers $n$, we have $0 + n = n$." +msgstr "모든 자연수 $n$에 대해 $0 + n = n$입니다." + +#: Game.Levels.Power.L10FLT +msgid "" +"For all naturals $a$ $b$ $c$ and $n$, we have\n" +"$$(a+1)^{n+3}+(b+1)^{n+3}\\not=(c+1)^{n+3}.$$" +msgstr "모든 자연수 $a$, $b$, $c$, $n$에 대해 $$(a+1)^{n+3}+(b+1)^{n+3}\\not=(c+1)^{n+3}.$$입니다." + +#: Game.Levels.Power.L09add_sq +msgid "" +"For all numbers $a$ and $b$, we have\n" +"$$(a+b)^2=a^2+b^2+2ab.$$" +msgstr "모든 수 $a$와 $b$에 대해 $$(a+b)^2=a^2+b^2+2ab.$$입니다." + +#: Game.Levels.Power.L02zero_pow_succ +msgid "For all numbers $m$, $0 ^{\\operatorname{succ} (m)} = 0$." +msgstr "모든 수 $m$에 대해 $0 ^{\\operatorname{succ} (m)} = 0$입니다." + +#: Game.Levels.Multiplication.L01mul_one Game.Levels.Multiplication.L05one_mul +#: Game.Levels.Multiplication.L06two_mul +msgid "For any natural number $m$, we have $ 1 \\times m = m$." +msgstr "모든 자연수 $m$에 대해 $ 1 \\times m = m$입니다." + +#: Game.Levels.Multiplication.L01mul_one Game.Levels.Multiplication.L05one_mul +#: Game.Levels.Multiplication.L06two_mul +msgid "For any natural number $m$, we have $ 2 \\times m = m+m$." +msgstr "모든 자연수 $m$에 대해 $ 2 \\times m = m+m$입니다." + +#: Game.Levels.Multiplication.L01mul_one Game.Levels.Multiplication.L05one_mul +#: Game.Levels.Multiplication.L06two_mul +msgid "For any natural number $m$, we have $ m \\times 1 = m$." +msgstr "모든 자연수 $m$에 대해 $ m \\times 1 = m$입니다." + +#: Game.Levels.Algorithm.L01add_left_comm +msgid "" +"Having to rearrange variables manually using commutativity and\n" +"associativity is very tedious. We start by reminding you of this. `add_left_comm`\n" +"is a key component in the first algorithm which we'll explain, but we need\n" +"to prove it manually.\n" +"\n" +"Remember that you can do precision commutativity rewriting\n" +"with things like `rw [add_comm b c]`. And remember that\n" +"`a + b + c` means `(a + b) + c`." +msgstr "" +"가환법칙과 결합법칙을 이용해 변수를 손으로 재배열하는 것은 매우 지루합니다. 우선 그 사실을 다시 한번 체감해 봅시다. `add_left_comm`는 우리가 설명할 첫 알고리즘의 핵심 구성 요소이지만, 지금은 직접 증명해야 합니다.\n" +"\n" +"`rw [add_comm b c]` 같은 식으로 정밀한 가환성 rewrite를 할 수 있다는 점을 기억하세요. 그리고 `a + b + c`는 `(a + b) + c`을 뜻합니다." + +#. nth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`. +#. rw [add_succ] +#. rw [one_eq_succ_zero] +#. rw [add_succ, add_zero] -- two rewrites at once +#. rw [← three_eq_succ_two] -- change `succ 2` to `3` +#. rw [← four_eq_succ_three] +#. rfl +#. ``` +#: Game.Levels.Tutorial.L08twoaddtwo +msgid "" +"Here is an example proof of 2+2=4 showing off various techniques.\n" +"\n" +"```lean\n" +"nth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`.\n" +"rw [add_succ]\n" +"rw [one_eq_succ_zero]\n" +"rw [add_succ, add_zero] -- two rewrites at once\n" +"rw [← three_eq_succ_two] -- change `succ 2` to `3`\n" +"rw [← four_eq_succ_three]\n" +"rfl\n" +"```\n" +"\n" +"Optional extra: you can run this proof yourself. Switch the game into \"Editor mode\" by clicking\n" +"on the `` button in the top right. You can now see your proof\n" +"written as several lines of code. Move your cursor between lines to see\n" +"the goal state at any point. Now cut and paste your code elsewhere if you\n" +"want to save it, and paste the above proof in instead. Move your cursor\n" +"around to investigate. When you've finished, click the `>_` button in the top right to\n" +"move back into \"Typewriter mode\".\n" +"\n" +"You have finished tutorial world!\n" +"Click \"Home\" to go back to the\n" +"overworld, and select Addition World, where you will learn\n" +"about the `induction` tactic." +msgstr "" +"여러 기법을 보여 주는 2+2=4의 예시 증명입니다.\n" +"\n" +"```lean\n" +"nth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`.\n" +"rw [add_succ]\n" +"rw [one_eq_succ_zero]\n" +"rw [add_succ, add_zero] -- two rewrites at once\n" +"rw [← three_eq_succ_two] -- change `succ 2` to `3`\n" +"rw [← four_eq_succ_three]\n" +"rfl\n" +"```\n" +"\n" +"선택 사항: 이 증명을 직접 실행해 볼 수도 있습니다. 오른쪽 위의 `` 버튼을 눌러 게임을 \"Editor mode\"로 바꾸세요. 그러면 증명이 여러 줄의 코드로 보입니다. 줄 사이에 커서를 옮겨 각 지점의 goal state를 확인할 수 있습니다. 원한다면 코드를 다른 곳에 복사해 저장하고, 위 증명을 붙여 넣어 탐색해 보세요. 다 살펴봤으면 오른쪽 위의 `>_` 버튼을 눌러 \"Typewriter mode\"로 돌아가세요.\n" +"\n" +"Tutorial World를 완료했습니다! \"Home\"을 눌러 overworld로 돌아간 뒤 Addition World를 선택하세요. 그곳에서 `induction` tactic을 배웁니다." + +#: Game.Levels.AdvAddition.L05add_right_eq_zero +msgid "" +"Here we want to deal with the cases `b = 0` and `b ≠ 0` separately,\n" +"so start with `cases b with d`." +msgstr "여기서는 `b = 0`와 `b ≠ 0` 경우를 따로 다루고 싶으므로 `cases b with d`로 시작하세요." + +#. use 1 +#. exact succ_eq_add_one x +#. ``` +#: Game.Levels.LessOrEqual.L03le_succ_self +msgid "" +"Here's a two-liner:\n" +"```\n" +"use 1\n" +"exact succ_eq_add_one x\n" +"```\n" +"\n" +"This works because `succ_eq_add_one x` is a proof of `succ x = x + 1`." +msgstr "" +"두 줄이면 됩니다:\n" +"```\n" +"use 1\n" +"exact succ_eq_add_one x\n" +"```\n" +"\n" +"`succ_eq_add_one x`이 `succ x = x + 1`의 증명이기 때문에 작동합니다." + +#. induction c with d hd +#. rw [add_zero, mul_zero, add_zero] +#. rfl +#. rw [add_succ, mul_succ, hd, mul_succ, add_assoc] +#. rfl +#. ``` +#: Game.Levels.Multiplication.L07mul_add +msgid "" +"Here's my solution:\n" +"```\n" +"induction c with d hd\n" +"rw [add_zero, mul_zero, add_zero]\n" +"rfl\n" +"rw [add_succ, mul_succ, hd, mul_succ, add_assoc]\n" +"rfl\n" +"```\n" +"\n" +"Inducting on `a` or `b` also works, but might take longer." +msgstr "" +"제 해법은 이렇습니다:\n" +"```\n" +"induction c with d hd\n" +"rw [add_zero, mul_zero, add_zero]\n" +"rfl\n" +"rw [add_succ, mul_succ, hd, mul_succ, add_assoc]\n" +"rfl\n" +"```\n" +"\n" +"`a`이나 `b`에 귀납해도 되지만 더 오래 걸릴 수 있습니다." + +#. rw [mul_comm, mul_one] +#. rfl +#. ``` +#: Game.Levels.Multiplication.L05one_mul Game.Levels.Multiplication.L06two_mul +msgid "" +"Here's my solution:\n" +"```\n" +"rw [mul_comm, mul_one]\n" +"rfl\n" +"```" +msgstr "" +"제 해법은 다음과 같습니다:\n" +"```\n" +"rw [mul_comm, mul_one]\n" +"rfl\n" +"```" + +#. rw [mul_comm, mul_one] +#. rfl +#. ``` +#: Game.Levels.Multiplication.L05one_mul Game.Levels.Multiplication.L06two_mul +msgid "" +"Here's my solution:\n" +"```\n" +"rw [two_eq_succ_one, succ_mul, one_mul]\n" +"rfl\n" +"```" +msgstr "" +"제 해법은 다음과 같습니다:\n" +"```\n" +"rw [two_eq_succ_one, succ_mul, one_mul]\n" +"rfl\n" +"```" + +#. have h2 := mul_ne_zero a b +#. tauto +#. ``` +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "" +"Here's the short proof:\n" +"```\n" +"have h2 := mul_ne_zero a b\n" +"tauto\n" +"```\n" +"This works because, given `mul_ne_zero a b`,\n" +"the argument is reduced to pure logic." +msgstr "" +"짧은 증명은 다음과 같습니다:\n" +"```\n" +"have h2 := mul_ne_zero a b\n" +"tauto\n" +"```\n" +"`mul_ne_zero a b`이 주어지면 문제가 순수 논리로 환원되기 때문에 작동합니다." + +#. apply mul_left_ne_zero at h +#. apply one_le_of_ne_zero at h +#. apply mul_le_mul_right 1 b a at h +#. rw [one_mul, mul_comm] at h +#. exact h +#. ``` +#: Game.Levels.AdvMultiplication.L05le_mul_right +msgid "" +"Here's what I was thinking of:\n" +"```\n" +"apply mul_left_ne_zero at h\n" +"apply one_le_of_ne_zero at h\n" +"apply mul_le_mul_right 1 b a at h\n" +"rw [one_mul, mul_comm] at h\n" +"exact h\n" +"```" +msgstr "" +"제가 생각한 증명은 이겁니다:\n" +"```\n" +"apply mul_left_ne_zero at h\n" +"apply one_le_of_ne_zero at h\n" +"apply mul_le_mul_right 1 b a at h\n" +"rw [one_mul, mul_comm] at h\n" +"exact h\n" +"```" + +#. rw [add_comm] +#. exact add_right_eq_zero b a +#. ``` +#: Game.Levels.AdvAddition.L06add_left_eq_zero +msgid "" +"How about this for a proof:\n" +"\n" +"```\n" +"rw [add_comm]\n" +"exact add_right_eq_zero b a\n" +"```\n" +"\n" +"That's the end of Advanced Addition World! You'll need these theorems\n" +"for the next world, `≤` World. Click on \"Home\" to access it." +msgstr "" +"이런 증명은 어떤가요?\n" +"\n" +"```\n" +"rw [add_comm]\n" +"exact add_right_eq_zero b a\n" +"```\n" +"\n" +"Advanced Addition World는 여기까지입니다! 다음 `≤` World에서는 여기서 얻은 정리들이 필요합니다. \"Home\"을 눌러 이동하세요." + +#. repeat rw [add_comm n] +#. exact add_right_cancel a b n +#. ``` +#: Game.Levels.AdvAddition.L02add_left_cancel +msgid "" +"How about this for a proof:\n" +"```\n" +"repeat rw [add_comm n]\n" +"exact add_right_cancel a b n\n" +"```" +msgstr "" +"이런 증명은 어떤가요?\n" +"```\n" +"repeat rw [add_comm n]\n" +"exact add_right_cancel a b n\n" +"```" + +#: Game.Levels.Multiplication +msgid "" +"How should we define `37 * x`? Just like addition, we need to give definitions\n" +"when $x=0$ and when $x$ is a successor.\n" +"\n" +"The zero case is easy: we define `37 * 0` to be `0`. Now say we know\n" +"`37 * d`. What should `37 * succ d` be? Well, that's $(d+1)$ $37$s,\n" +"so it should be `37 * d + 37`.\n" +"\n" +"Here are the definitions in Lean.\n" +"\n" +" * `mul_zero a : a * 0 = 0`\n" +" * `mul_succ a d : a * succ d = a * d + a`\n" +"\n" +"In this world, we must not only prove facts about multiplication like `a * b = b * a`,\n" +"we must also prove facts about how multiplication interacts with addition, like `a * (b + c) = a * b + a * c`.\n" +"Let's get started." +msgstr "" +"`37 * x`를 어떻게 정의해야 할까요? 덧셈과 마찬가지로 $x=0$일 때와 $x$가 successor일 때를 각각 정의해야 합니다.\n" +"\n" +"0인 경우는 쉽습니다. `37 * 0`을 `0`로 정의합니다. 이제 `37 * d`를 안다고 합시다. `37 * succ d`은 무엇이어야 할까요? 이는 $(d+1)$개의 $37$이므로 `37 * d + 37`여야 합니다.\n" +"\n" +"Lean에서의 정의는 다음과 같습니다.\n" +"\n" +" * $x=0$0\n" +" * $x=0$1\n" +"\n" +"이 world에서는 $x=0$2 같은 곱셈의 성질뿐 아니라 $x=0$3처럼 곱셈과 덧셈이 어떻게 상호작용하는지도 증명해야 합니다. 시작해 봅시다." + +#: Game.Levels.Addition.L05add_right_comm +msgid "" +"If $a, b$ and $c$ are arbitrary natural numbers, we have\n" +"$(a + b) + c = (a + c) + b$." +msgstr "$a, b$와 $c$이 임의의 자연수라면 $(a + b) + c = (a + c) + b$입니다." + +#: Game.Levels.Algorithm.L02add_algo1 +msgid "" +"If $a, b$, $c$ and $d$ are numbers, we have\n" +"$(a + b) + (c + d) = ((a + c) + d) + b.$" +msgstr "$a, b$, $c$, $d$가 수라면 $(a + b) + (c + d) = ((a + c) + d) + b.$입니다." + +#: Game.Levels.Algorithm.L03add_algo2 Game.Levels.Algorithm.L04add_algo3 +msgid "" +"If $a, b,\\ldots h$ are arbitrary natural numbers, we have\n" +"$(d + f) + (h + (a + c)) + (g + e + b) = a + b + c + d + e + f + g + h$." +msgstr "$a, b,\\ldots h$가 임의의 자연수라면 $(d + f) + (h + (a + c)) + (g + e + b) = a + b + c + d + e + f + g + h$입니다." + +#: Game.Levels.Implication.L02exact2 +msgid "" +"If the goal is not *exactly* a hypothesis, we can sometimes\n" +"use rewrites to fix things up." +msgstr "goal이 가정과 *정확히* 같지 않더라도 rewrite를 이용해 고칠 수 있는 경우가 있습니다." + +#: Game.Levels.LessOrEqual.L03le_succ_self +msgid "" +"If you `use` the wrong number, you get stuck with a goal you can't prove.\n" +"What number will you `use` here?" +msgstr "잘못된 수를 `use`하면 증명할 수 없는 goal에 막힙니다. 여기서는 어떤 수를 `use`해야 할까요?" + +#. instance instDecidableEq : DecidableEq ℕ +#. | 0, 0 => isTrue <| by +#. show 0 = 0 +#. rfl +#. | succ m, 0 => isFalse <| by +#. show succ m ≠ 0 +#. exact succ_ne_zero m +#. | 0, succ n => isFalse <| by +#. show 0 ≠ succ n +#. exact zero_ne_succ n +#. | succ m, succ n => +#. match instDecidableEq m n with +#. | isTrue (h : m = n) => isTrue <| by +#. show succ m = succ n +#. rw [h] +#. rfl +#. | isFalse (h : m ≠ n) => isFalse <| by +#. show succ m ≠ succ n +#. exact succ_ne_succ m n h +#. ``` +#: Game.Levels.Algorithm.L08decide +msgid "" +"Implementing the algorithm for equality of naturals, and the proof that it is correct,\n" +"looks like this:\n" +"\n" +"```\n" +"instance instDecidableEq : DecidableEq ℕ\n" +"| 0, 0 => isTrue <| by\n" +" show 0 = 0\n" +" rfl\n" +"| succ m, 0 => isFalse <| by\n" +" show succ m ≠ 0\n" +" exact succ_ne_zero m\n" +"| 0, succ n => isFalse <| by\n" +" show 0 ≠ succ n\n" +" exact zero_ne_succ n\n" +"| succ m, succ n =>\n" +" match instDecidableEq m n with\n" +" | isTrue (h : m = n) => isTrue <| by\n" +" show succ m = succ n\n" +" rw [h]\n" +" rfl\n" +" | isFalse (h : m ≠ n) => isFalse <| by\n" +" show succ m ≠ succ n\n" +" exact succ_ne_succ m n h\n" +"```\n" +"\n" +"This Lean code is a formally verified algorithm for deciding equality\n" +"between two naturals. I've typed it in already, behind the scenes.\n" +"Because the algorithm is formally verified to be correct, we can\n" +"use it in Lean proofs. You can run the algorithm with the `decide` tactic." +msgstr "" +"자연수의 동등성을 판정하는 알고리즘과 그 정확성 증명을 구현하면 다음과 같습니다:\n" +"\n" +"```\n" +"instance instDecidableEq : DecidableEq ℕ\n" +"| 0, 0 => isTrue <| by\n" +" show 0 = 0\n" +" rfl\n" +"| succ m, 0 => isFalse <| by\n" +" show succ m ≠ 0\n" +" exact succ_ne_zero m\n" +"| 0, succ n => isFalse <| by\n" +" show 0 ≠ succ n\n" +" exact zero_ne_succ n\n" +"| succ m, succ n =>\n" +" match instDecidableEq m n with\n" +" | isTrue (h : m = n) => isTrue <| by\n" +" show succ m = succ n\n" +" rw [h]\n" +" rfl\n" +" | isFalse (h : m ≠ n) => isFalse <| by\n" +" show succ m ≠ succ n\n" +" exact succ_ne_succ m n h\n" +"```\n" +"\n" +"이 Lean 코드는 두 자연수의 동등성을 판정하는 형식 검증된 알고리즘입니다. 이미 뒤에서 입력해 두었습니다. 알고리즘의 정확성까지 형식적으로 검증되었으므로 Lean 증명에서 사용할 수 있습니다. `decide` tactic으로 이 알고리즘을 실행할 수 있습니다." + +#: Game.Levels.Implication +msgid "Implication World" +msgstr "함의 월드" + +#: Game.Levels.AdvAddition +msgid "" +"In Advanced Addition World we will prove some basic\n" +"addition facts such as $x+y=x\\implies y=0$. The theorems\n" +"proved in this world will be used to build\n" +"a theory of inequalities in `≤` World.\n" +"\n" +"Click on \"Start\" to proceed." +msgstr "" +"Advanced Addition World에서는 $x+y=x\\implies y=0$ 같은 기본적인 덧셈의 성질을 증명합니다. 여기서 증명한 정리들은 `≤` World에서 부등식 이론을 만드는 데 사용됩니다.\n" +"\n" +"\"Start\"를 눌러 진행하세요." + +#: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +msgid "" +"In the \"base case\" we have a hypothesis `ha : 0 ≠ 0`, and you can deduce anything\n" +"from a false statement. The `tauto` tactic will close this goal." +msgstr "\"기저 경우\"에서는 가정 `ha : 0 ≠ 0`가 있습니다. 거짓 명제에서는 무엇이든 이끌어낼 수 있으므로 `tauto` tactic이 이 goal을 닫습니다." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"In this level the *goal* is $2y=2(x+7)$ but to help us we\n" +"have an *assumption* `h` saying that $y = x + 7$. Check that you can see `h` in\n" +"your list of assumptions. Lean thinks of `h` as being a secret proof of the\n" +"assumption, rather like `x` is a secret number.\n" +"\n" +"Before we can use `rfl`, we have to \"substitute in for $y$\".\n" +"We do this in Lean by *rewriting* the proof `h`,\n" +"using the `rw` tactic." +msgstr "" +"In this level the *goal* is $2y=2(x+7)$ but to help us we\n" +"have an *assumption* `h` saying that $y = x + 7$. Check that you can see `h` in\n" +"your list of assumptions. Lean thinks of `h` as being a secret proof of the\n" +"assumption, rather like `x` is a secret number.\n" +"\n" +"Before we can use `rfl`, we have to \"substitute in for $y$\".\n" +"We do this in Lean by *rewriting* the proof `h`,\n" +"using the `rw` tactic." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"In this level, the hypotheses `h2` is an *implication*. It says\n" +"that *if* `x = 37` *then* `y = 42`. We can use this\n" +"hypothesis with the `apply` tactic. Remember you can click on\n" +"`apply` or any other tactic on the right to see a detailed explanation\n" +"of what it does, with examples." +msgstr "" +"In this level, the hypotheses `h2` is an *implication*. It says\n" +"that *if* `x = 37` *then* `y = 42`. We can use this\n" +"hypothesis with the `apply` tactic. Remember you can click on\n" +"`apply` or any other tactic on the right to see a detailed explanation\n" +"of what it does, with examples." + +#: Game.Levels.AdvAddition.L01add_right_cancel +msgid "" +"In this world I will mostly leave you on your own.\n" +"\n" +"`add_right_cancel a b n` is the theorem that $a+n=b+n\\implies a=b$." +msgstr "" +"이 world에서는 대부분 여러분 스스로 하도록 두겠습니다.\n" +"\n" +"`add_right_cancel a b n`는 $a+n=b+n\\implies a=b$이라는 정리입니다." + +#: Game.Levels.LessOrEqual +msgid "" +"In this world we define `a ≤ b` and prove standard facts\n" +"about it, such as \"if `a ≤ b` and `b ≤ c` then `a ≤ c`.\"\n" +"\n" +"The definition of `a ≤ b` is \"there exists a number `c`\n" +"such that `b = a + c`. \" So we're going to have to learn\n" +"a tactic to prove \"exists\" theorems, and another one\n" +"to use \"exists\" hypotheses.\n" +"\n" +"Click on \"Start\" to proceed." +msgstr "" +"이 world에서는 `a ≤ b`를 정의하고, \"`a ≤ b`이고 `b ≤ c`이면 `a ≤ c`\" 같은 표준적인 성질을 증명합니다.\n" +"\n" +"`a ≤ b`의 정의는 \"`b = a + c`를 만족하는 수 `c`가 존재한다\"입니다. 따라서 \"존재한다\"는 정리를 증명하는 tactic과 \"존재한다\"는 가정을 사용하는 tactic을 배워야 합니다.\n" +"\n" +"\"Start\"를 눌러 진행하세요." + +#: Game.Levels.Implication.L01exact +msgid "" +"In this world we'll learn how to prove theorems of the form $P\\implies Q$.\n" +"In other words, how to prove theorems of the form \"if $P$ is true, then $Q$ is true.\"\n" +"To do that we need to learn some more tactics.\n" +"\n" +"The `exact` tactic can be used to close a goal which is exactly one of\n" +"the hypotheses. It takes the name of the hypothesis as argument: `exact h`." +msgstr "" +"이 world에서는 $P\\implies Q$ 꼴의 정리를 증명하는 법을 배웁니다. 즉 \"$P$이 참이면 $Q$가 참이다\" 꼴의 정리를 증명하는 법입니다. 이를 위해 몇 가지 tactic을 더 배워야 합니다.\n" +"\n" +"`exact` tactic은 goal이 가정 중 하나와 정확히 같을 때 goal을 닫을 수 있습니다. 인자로 가정의 이름을 받습니다: `exact h`." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"Induction on `a` will not work here. You are still stuck with an `+ b`.\n" +"I suggest you delete this line and try a different approach." +msgstr "" +"Induction on `a` will not work here. You are still stuck with an `+ b`.\n" +"I suggest you delete this line and try a different approach." + +#: Game.Levels.LessOrEqual.L05le_zero +msgid "" +"It's \"intuitively obvious\" that there are no numbers less than zero,\n" +"but to prove it you will need a result which you showed in advanced\n" +"addition world." +msgstr "0보다 작은 수가 없다는 것은 \"직관적으로 명백\"하지만, 이를 증명하려면 Advanced Addition World에서 증명한 결과가 필요합니다." + +#: Game.Levels.Algorithm.L03add_algo2 +msgid "" +"Lean's simplifier, `simp`, is \"`rw` on steroids\". It will rewrite every lemma\n" +"tagged with `simp` and every lemma fed to it by the user, as much as it can.\n" +"\n" +"This level is not a level which you want to solve by hand.\n" +"Get the simplifier to solve it for you." +msgstr "" +"Lean의 simplifier `simp`는 \"`rw`에 스테로이드를 먹인 것\"과 같습니다. `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다.\n" +"\n" +"이 level은 손으로 풀고 싶을 만한 문제가 아닙니다. simplifier에게 맡기세요." + +#: Game.Levels.Power.L06pow_add +msgid "" +"Let's now begin our approach to the final boss,\n" +"by proving some more subtle facts about powers." +msgstr "이제 거듭제곱에 관한 좀 더 미묘한 사실들을 증명하면서 final boss로 가는 길을 시작합시다." + +#: Game.Levels.Tutorial.L06add_zero2 +msgid "Let's now learn about Peano's second axiom for addition, `add_succ`." +msgstr "이제 덧셈에 관한 페아노의 두 번째 공리 `add_succ`를 배워 봅시다." + +#: Game.Levels.Algorithm.L03add_algo2 +msgid "Let's now make our own tactic to do this." +msgstr "이제 이 일을 하는 우리만의 tactic을 만들어 봅시다." + +#: Game.Levels.Algorithm.L04add_algo3 +msgid "" +"Let's now move on to a more efficient approach to questions\n" +"involving numerals, such as `20 + 20 = 40`." +msgstr "이제 `20 + 20 = 40` 같은 숫자 관련 문제를 더 효율적으로 푸는 방법으로 넘어갑시다." + +#: Game.Levels.Implication.L05succ_inj2 +msgid "" +"Many people find `apply t at h` easy, but some find `apply t` confusing.\n" +"If you find it confusing, then just argue forwards.\n" +"\n" +"You can read more about the `apply` tactic in its documentation, which you can view by\n" +"clicking on the tactic in the list on the right." +msgstr "" +"많은 사람은 `apply t at h`는 쉽다고 느끼지만 `apply t`은 헷갈려 합니다. 헷갈린다면 그냥 앞에서부터 추론하세요.\n" +"\n" +"`apply` tactic에 대한 자세한 설명은 오른쪽 tactic 목록에서 클릭해 볼 수 있습니다." + +#: Game.Levels.Power.L01zero_pow_zero +msgid "" +"Mathematicians sometimes argue that `0 ^ 0 = 0` is also\n" +"a good convention. But it is not a good convention in this\n" +"game; all the later levels come out beautifully with the\n" +"convention that `0 ^ 0 = 1`." +msgstr "수학자들은 가끔 `0 ^ 0 = 0`도 좋은 관례라고 주장합니다. 하지만 이 게임에서는 좋은 관례가 아닙니다. `0 ^ 0 = 1`이라는 관례를 택하면 뒤의 level들이 아주 아름답게 풀리기 때문입니다." + +#: Game.Levels.Power.L01zero_pow_zero +msgid "" +"Mathematicians sometimes debate what `0 ^ 0` is;\n" +"the answer depends, of course, on your definitions. In this\n" +"game, `0 ^ 0 = 1`. See if you can prove it.\n" +"\n" +"Check out the *Pow* tab in your list of theorems\n" +"to see the new proofs which are available." +msgstr "" +"수학자들은 가끔 `0 ^ 0`가 무엇인지 논쟁합니다. 물론 답은 정의에 달려 있습니다. 이 게임에서는 `0 ^ 0 = 1`입니다. 증명해 보세요.\n" +"\n" +"새로 사용할 수 있는 증명은 theorem 목록의 *Pow* 탭에서 확인하세요." + +#: Game.Levels.Multiplication.L09mul_assoc +msgid "" +"Multiplication is associative.\n" +"In other words, for all natural numbers $a$, $b$ and $c$, we have\n" +"$(ab)c = a(bc)$." +msgstr "곱셈은 결합법칙을 만족합니다. 즉 모든 자연수 $a$, $b$, $c$에 대해 $(ab)c = a(bc)$입니다." + +#: Game.Levels.Multiplication.L04mul_comm +msgid "Multiplication is commutative." +msgstr "곱셈은 가환입니다." + +#. cases h with d hd +#. use d * t +#. rw [hd, add_mul] +#. rfl +#. ``` +#: Game.Levels.AdvMultiplication.L01mul_le_mul_right +msgid "" +"My proof:\n" +"```\n" +"cases h with d hd\n" +"use d * t\n" +"rw [hd, add_mul]\n" +"rfl\n" +"```" +msgstr "" +"제 증명:\n" +"```\n" +"cases h with d hd\n" +"use d * t\n" +"rw [hd, add_mul]\n" +"rfl\n" +"```" + +#: Game +msgid "Natural Number Game" +msgstr "자연수 게임" + +#: Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.AdvAddition.L01add_right_cancel +msgid "Nice!" +msgstr "좋습니다!" + +#: Game.Levels.Algorithm.L05pred +msgid "" +"Nice! You've proved `succ_inj`!\n" +"Let's now prove Peano's other axiom, that successors can't be $0$." +msgstr "좋습니다! `succ_inj`를 증명했습니다! 이제 페아노의 다른 공리, successor는 $0$일 수 없다는 것을 증명합시다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "" +"Note that you can do `rw [two_eq_succ_one, one_eq_succ_zero]`\n" +"and then `rfl` to solve this level in two lines." +msgstr "`rw [two_eq_succ_one, one_eq_succ_zero]` 다음 `rfl`을 하면 이 level을 두 줄로 해결할 수 있다는 점에 주의하세요." + +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "" +"Now `cases h2 with h0 h1` and deal with the two\n" +"cases separately." +msgstr "이제 `cases h2 with h0 h1`하고 두 경우를 따로 처리하세요." + +#: Game.Levels.LessOrEqual.L08le_total +msgid "Now `cases «{h2}» with e he`." +msgstr "이제 `cases «{h2}» with e he`." + +#: Game.Levels.Implication.L06intro +msgid "Now `exact h` finishes the job." +msgstr "이제 `exact h`가 마무리합니다." + +#: Game.Levels.Implication.L07intro2 +msgid "" +"Now `repeat rw [← succ_eq_add_one] at h` is the quickest way to\n" +"change `h` to `succ x = succ y`." +msgstr "이제 `h`을 `succ x = succ y`로 바꾸는 가장 빠른 방법은 `repeat rw [← succ_eq_add_one] at h`입니다." + +#: Game.Levels.Implication.L07intro2 +msgid "Now `rw [h]` then `rfl` works, but `exact h` is quicker." +msgstr "이제 `rw [h]` 다음 `rfl`도 작동하지만 `exact h`가 더 빠릅니다." + +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "Now `rw [«{h}»] at «{h2}»` so you can `apply le_one at «{h2}»`." +msgstr "이제 `rw [«{h}»] at «{h2}»`를 해서 `apply le_one at «{h2}»`할 수 있게 하세요." + +#: Game.Levels.LessOrEqual.L04le_trans +msgid "" +"Now `«{ha}»` is a proof that `«{y}» = «{x}» + «{a}»`, and `hxy` has vanished. Similarly, you can destruct\n" +"`«{hyz}»` into its parts with `cases «{hyz}» with b hb`." +msgstr "이제 `«{ha}»`는 `«{y}» = «{x}» + «{a}»`의 증명이고 `hxy`는 사라졌습니다. 마찬가지로 `«{hyz}»`도 `cases «{hyz}» with b hb`를 사용해 구성 요소로 분해할 수 있습니다." + +#: Game.Levels.Implication.L09zero_ne_succ +msgid "Now change `1` to `succ 0` in `h`." +msgstr "이제 `h`에서 `1`를 `succ 0`로 바꾸세요." + +#: Game.Levels.Implication.L04succ_inj +msgid "Now finish in one line." +msgstr "이제 한 줄로 마무리하세요." + +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "Now finish the job with `rfl`." +msgstr "이제 `rfl`로 마무리하세요." + +#: Game.Levels.LessOrEqual.L08le_total +msgid "" +"Now for to the second goal. Here you have the induction hypothesis\n" +"`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`." +msgstr "" +"이제 for to the second goal. Here you have the induction hypothesis\n" +"`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`." + +#: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero +msgid "Now take apart the existence statement with `cases ha with n hn`." +msgstr "이제 `cases ha with n hn`를 사용해 존재 명제를 분해하세요." + +#: Game.Levels.Algorithm.L02add_algo1 +msgid "" +"Now use `rw [add_left_comm b c]` to switch `b` and `c` on the left\n" +"hand side." +msgstr "이제 `rw [add_left_comm b c]`를 사용해 왼쪽의 `b`과 `c`를 바꾸세요." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "" +"Now we can prove the `or` statement by proving the statement on the right,\n" +"so use the `right` tactic." +msgstr "이제 오른쪽 명제를 증명함으로써 `or` 명제를 증명할 수 있으므로 `right` tactic을 사용하세요." + +#: Game.Levels.Tutorial.L07add_succ Game.Levels.Tutorial.L08twoaddtwo +msgid "Now you can `rw [add_succ]`" +msgstr "이제 `rw [add_succ]`할 수 있습니다." + +#: Game.Levels.Implication.L02exact2 +msgid "" +"Now you could finish with `rw [«{h}»]` then `rfl`, but `exact «{h}»`\n" +"does it in one line." +msgstr "이제 `rw [«{h}»]` 다음 `rfl`로 끝낼 수도 있지만, `exact «{h}»`면 한 줄에 됩니다." + +#: Game.Levels.LessOrEqual.L04le_trans +msgid "Now you need to figure out which number to `use`. See if you can take it from here." +msgstr "이제 어떤 수를 `use`해야 하는지 알아내야 합니다. 여기서부터는 스스로 해 보세요." + +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "Numbers" +msgstr "수" + +#: Game.Levels.Addition.L02succ_add +msgid "" +"Oh no! On the way to `add_comm`, a wild `succ_add` appears. `succ_add a b`\n" +"is the proof that `(succ a) + b = succ (a + b)` for `a` and `b` numbers.\n" +"This result is what's standing in the way of `x + y = y + x`. Again\n" +"we have the problem that we are adding `b` to things, so we need\n" +"to use induction to split into the cases where `b = 0` and `b` is a successor." +msgstr "이런! `add_comm`로 가는 길에 야생의 `succ_add`이 나타났습니다. `succ_add a b`는 `a`와 `b`가 수일 때 `(succ a) + b = succ (a + b)`이라는 것의 증명입니다. 이 결과가 `x + y = y + x`을 막고 있습니다. 다시 `b`을 어떤 것에 더하고 있으므로 귀납법으로 `b = 0`인 경우와 `b`가 successor인 경우를 나눠야 합니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "" +"On the set of natural numbers, addition is associative.\n" +"In other words, for all natural numbers $a, b$ and $c$, we have\n" +"$ (a + b) + c = a + (b + c). $" +msgstr "" +"On the set of natural numbers, addition is associative.\n" +"In other words, for all natural numbers $a, b$ and $c$, we have\n" +"$ (a + b) + c = a + (b + c). $" + +#: Game.Levels.Addition.L04add_assoc +msgid "" +"On the set of natural numbers, addition is associative.\n" +"In other words, if $a, b$ and $c$ are arbitrary natural numbers, we have\n" +"$ (a + b) + c = a + (b + c). $" +msgstr "자연수 집합에서 덧셈은 결합법칙을 만족합니다. 즉 $a, b$와 $c$이 임의의 자연수라면 $ (a + b) + c = a + (b + c). $입니다." + +#: Game.Levels.Multiplication.L02zero_mul +msgid "" +"Our first challenge is `mul_comm x y : x * y = y * x`,\n" +"and we want to prove it by induction. The zero\n" +"case will need `mul_zero` (which we have)\n" +"and `zero_mul` (which we don't), so let's\n" +"start with this." +msgstr "첫 도전은 `mul_comm x y : x * y = y * x`이며 귀납법으로 증명하려 합니다. 0 경우에는 `mul_zero`(이미 있음)과 `zero_mul`(아직 없음)가 필요하므로 이것부터 시작합시다." + +#: Game.Levels.Multiplication.L07mul_add +msgid "" +"Our next goal is \"left and right distributivity\",\n" +"meaning $a(b+c)=ab+ac$ and $(b+c)a=ba+ca$. Rather than\n" +"these slightly pompous names, the name of the proofs\n" +"in Lean are descriptive. Let's start with\n" +"`mul_add a b c`, the proof of `a * (b + c) = a * b + a * c`.\n" +"Note that the left hand side contains a multiplication\n" +"and then an addition." +msgstr "다음 목표는 \"왼쪽과 오른쪽 분배법칙\", 즉 $a(b+c)=ab+ac$와 $(b+c)a=ba+ca$입니다. 이런 다소 거창한 이름 대신 Lean의 증명 이름은 내용을 그대로 설명합니다. 먼저 `mul_add a b c`, 즉 `a * (b + c) = a * b + a * c`의 증명부터 시작합시다. 왼쪽 항에는 먼저 곱셈이 있고 그다음 덧셈이 있다는 점에 주의하세요." + +#: Game.Levels.Power +msgid "Power World" +msgstr "거듭제곱 월드" + +#: Game.Levels.Tutorial.L06add_zero2 +msgid "Precision rewriting" +msgstr "정밀한 rewriting" + +#: Game.Levels.Algorithm +msgid "" +"Proofs like $2+2=4$ and $a+b+c+d+e=e+d+c+b+a$ are very tedious to do by hand.\n" +"In Algorithm World we learn how to get the computer to do them for us.\n" +"\n" +"Click on \"Start\" to proceed." +msgstr "" +"$2+2=4$나 $a+b+c+d+e=e+d+c+b+a$ 같은 증명을 손으로 하는 것은 아주 지루합니다. Algorithm World에서는 컴퓨터가 대신 하게 만드는 법을 배웁니다.\n" +"\n" +"\"Start\"를 눌러 진행하세요." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "Ready for the boss level of this world?" +msgstr "이 world의 boss level을 맞을 준비가 되었나요?" + +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "Reduce to the previous lemma with `nth_rewrite 2 [← mul_one a] at h`" +msgstr "`nth_rewrite 2 [← mul_one a] at h`를 사용해 이전 lemma로 환원하세요." + +#: Game.Levels.Algorithm.L06is_zero +msgid "" +"See if you can take it from here. Look at the new lemmas and tactic\n" +"available on the right." +msgstr "이제부터는 스스로 해 보세요. 오른쪽에 새로 생긴 lemma와 tactic을 살펴보세요." + +#: Game.Levels.Multiplication.L01mul_one +msgid "" +"See the new \"*\" tab in your lemmas, containing `mul_zero` and `mul_succ`.\n" +"Right now these are the only facts we know about multiplication.\n" +"Let's prove nine more.\n" +"\n" +"Let's start with a warm-up: no induction needed for this one,\n" +"because we know `1` is a successor." +msgstr "" +"lemma 목록에 새로 생긴 \"*\" 탭을 보세요. `mul_zero`와 `mul_succ`이 들어 있습니다. 지금은 이 둘만 곱셈에 대해 알고 있는 사실입니다. 이제 아홉 개를 더 증명합시다.\n" +"\n" +"먼저 준비운동부터 합니다. 이번에는 `1`가 successor라는 것을 알고 있으므로 귀납법이 필요 없습니다." + +#: Game.Levels.Multiplication.L03succ_mul +msgid "" +"Similarly we have `mul_succ`\n" +"but we're going to need `succ_mul` (guess what it says -- maybe you\n" +"are getting the hang of Lean's naming conventions).\n" +"\n" +"The last level from addition world might help you in this level.\n" +"If you can't remember what it is, you can go back to the\n" +"home screen by clicking the house icon and then taking a look.\n" +"You won't lose any progress." +msgstr "" +"마찬가지로 `mul_succ`가 있지만 우리가 필요한 것은 `succ_mul`입니다(무슨 내용일지 맞혀 보세요. 이제 Lean의 이름 짓기 규칙이 좀 익숙해졌을지도 모르겠네요).\n" +"\n" +"Addition World의 마지막 level이 도움이 될 수 있습니다. 기억나지 않으면 집 모양 아이콘을 눌러 home 화면으로 돌아가 확인하세요. 진행 상황은 잃지 않습니다." + +#: Game.Levels.Algorithm.L02add_algo1 +msgid "" +"So that's the algorithm: now let's use automation to perform it\n" +"automatically." +msgstr "알고리즘은 이것입니다. 이제 automation을 사용해 자동으로 실행해 봅시다." + +#: Game.Levels.Algorithm.L03add_algo2 +msgid "Solve this level in one line with `simp only [add_assoc, add_left_comm, add_comm]`" +msgstr "`simp only [add_assoc, add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요." + +#: Game.Levels.Algorithm.L03add_algo2 +msgid "Solve this level in one line with `simp only [add_left_comm, add_comm]`" +msgstr "`simp only [add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요." + +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +msgid "Split into cases `c = 0` and `c = succ e` with `cases c with e`." +msgstr "`cases c with e`를 사용해 `c = 0`와 `c = succ e`의 경우로 나누세요." + +#: Game.Levels.AdvMultiplication.L07mul_ne_zero +msgid "Start with `apply eq_succ_of_ne_zero at ha` and `... at hb`" +msgstr "`apply eq_succ_of_ne_zero at ha`와 `... at hb`로 시작하세요." + +#: Game.Levels.Implication.L03apply +msgid "Start with `apply h2 at h1`. This will change `h1` to `y = 42`." +msgstr "`apply h2 at h1`부터 시작하세요. 그러면 `h1`이 `y = 42`로 바뀝니다." + +#: Game.Levels.Implication.L05succ_inj2 +msgid "Start with `apply succ_inj` to apply `succ_inj` to the *goal*." +msgstr "`apply succ_inj`로 시작해 `succ_inj`을 *goal*에 적용하세요." + +#: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +msgid "Start with `cases a with d` to do a case split on `a = 0` and `a = succ d`." +msgstr "`cases a with d`로 시작해 `a = 0`과 `a = succ d`에 대해 경우를 나누세요." + +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.LessOrEqual.L04le_trans +#: Game.Levels.LessOrEqual.L08le_total +#: Game.Levels.AdvMultiplication.L02mul_left_ne_zero +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "Start with `cases «{hxy}» with a ha`." +msgstr "`cases «{hxy}» with a ha`로 시작하세요." + +#: Game.Levels.Algorithm.L07succ_ne_succ +msgid "" +"Start with `contrapose! h`, to change the goal into its\n" +"contrapositive, namely a hypothesis of `succ m = succ n` and a goal of `m = n`." +msgstr "`contrapose! h`로 시작해 goal을 그 대우로 바꾸세요. 즉 가정 `succ m = succ n`과 goal `m = n`로 바꿉니다." + +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.LessOrEqual.L04le_trans +#: Game.Levels.LessOrEqual.L08le_total +#: Game.Levels.AdvMultiplication.L02mul_left_ne_zero +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "Start with `have h2 := mul_ne_zero a b`." +msgstr "`have h2 := mul_ne_zero a b`로 시작하세요." + +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.LessOrEqual.L04le_trans +#: Game.Levels.LessOrEqual.L08le_total +#: Game.Levels.AdvMultiplication.L02mul_left_ne_zero +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "Start with `induction «{y}» with d hd`." +msgstr "`induction «{y}» with d hd`로 시작하세요." + +#: Game.Levels.Algorithm.L06is_zero +msgid "" +"Start with `intro h` (remembering that `X ≠ Y` is just notation\n" +"for `X = Y → False`)." +msgstr "`intro h`로 시작하세요(`X ≠ Y`이 `X = Y → False`의 표기법일 뿐이라는 점을 기억하세요)." + +#: Game.Levels.Implication.L06intro +msgid "Start with `intro h` to assume the hypothesis and call its proof `h`." +msgstr "`intro h`로 시작해 가정을 도입하고 그 증명을 `h`이라고 부르세요." + +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.LessOrEqual.L04le_trans +#: Game.Levels.LessOrEqual.L08le_total +#: Game.Levels.AdvMultiplication.L02mul_left_ne_zero +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "Start with `intro h`." +msgstr "`intro h`로 시작하세요." + +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.LessOrEqual.L04le_trans +#: Game.Levels.LessOrEqual.L08le_total +#: Game.Levels.AdvMultiplication.L02mul_left_ne_zero +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "Start with `intro hb`." +msgstr "`intro hb`로 시작하세요." + +#: Game.Levels.Algorithm.L02add_algo1 +msgid "Start with `repeat rw [add_assoc]` to push all the brackets to the right." +msgstr "`repeat rw [add_assoc]`로 시작해 모든 괄호를 오른쪽으로 밀어 보세요." + +#: Game.Levels.Tutorial.L03two_eq_ss0 +msgid "Start with `rw [two_eq_succ_one]` to begin to break `2` down into its definition." +msgstr "`rw [two_eq_succ_one]`로 시작해 `2`을 정의에 따라 분해하기 시작하세요." + +#: Game.Levels.Algorithm.L05pred +msgid "Start with `rw [← pred_succ a]` and take it from there." +msgstr "`rw [← pred_succ a]`로 시작하고 나머지는 스스로 해 보세요." + +#: Game.Levels.AdvAddition.L01add_right_cancel +msgid "Start with induction on `n`." +msgstr "`n`에 대한 귀납법으로 시작하세요." + +#: Game.Levels.Implication.L01exact Game.Levels.LessOrEqual.L01le_refl +msgid "The `exact` tactic" +msgstr "`exact` tactic" + +#: Game.Levels.Implication.L01exact Game.Levels.LessOrEqual.L01le_refl +msgid "The `use` tactic" +msgstr "`use` tactic" + +#: Game +msgid "The classical introduction game for Lean." +msgstr "Lean을 배우는 고전적인 입문 게임." + +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +msgid "" +"The inductive hypothesis `hd` is \"For all natural numbers `c`, `a * d = a * c → d = c`\".\n" +"You can `apply` it `at` any hypothesis of the form `a * d = a * ?`." +msgstr "귀납가정 `hd`는 \"모든 자연수 `c`에 대해 `a * d = a * c → d = c`\"입니다. `a * d = a * ?` 꼴의 어떤 가정에도 `apply`를 `at`할 수 있습니다." + +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "" +"The lemma proved in the final level of this world will be helpful\n" +"in Divisibility World." +msgstr "이 world의 마지막 level에서 증명하는 lemma는 Divisibility World에서 유용합니다." + +#: Game.Levels.Power.L07mul_pow +msgid "" +"The music gets ever more dramatic, as we explore\n" +"the interplay between exponentiation and multiplication.\n" +"\n" +"If you're having trouble exchanging the right `a * b`\n" +"because `rw [mul_comm]` swaps the wrong multiplication,\n" +"then read the documentation of `rw` for tips on how to fix this." +msgstr "" +"거듭제곱과 곱셈의 상호작용을 살펴보면서 음악은 점점 더 극적으로 변합니다.\n" +"\n" +"`rw [mul_comm]`이 엉뚱한 곱셈을 바꿔서 원하는 `a * b`를 교환하기 어렵다면 `rw` 문서에서 해결법을 읽어 보세요." + +#: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero +msgid "The previous lemma can be used to prove this one." +msgstr "이전 lemma를 사용해 이 lemma를 증명할 수 있습니다." + +#: Game.Levels.LessOrEqual.L01le_refl +msgid "" +"The reason `«{x}» ≤ «{x}»` is because `«{x}» = «{x}» + 0`.\n" +"So you should start this proof with `use 0`." +msgstr "`«{x}» ≤ «{x}»`인 이유는 `«{x}» = «{x}» + 0`이기 때문입니다. 따라서 `use 0`로 증명을 시작해야 합니다." + +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +msgid "The way to start this proof is `induction b with d hd generalizing c`." +msgstr "이 증명은 `induction b with d hd generalizing c`로 시작해야 합니다." + +#: Game.Levels.LessOrEqual.L08le_total +msgid "" +"This is I think the toughest level yet. Tips: if `a` is a number\n" +"then `cases a with b` will split into cases `a = 0` and `a = succ b`.\n" +"And don't go left or right until your hypotheses guarantee that\n" +"you can prove the resulting goal!\n" +"\n" +"I've left hidden hints; if you need them, retry from the beginning\n" +"and click on \"Show more help!\"" +msgstr "" +"제 생각에는 지금까지 가장 어려운 level입니다. 팁: `a`가 수라면 `cases a with b`은 `a = 0`와 `a = succ b`의 경우로 나눕니다. 그리고 가정이 결과 goal을 증명할 수 있음을 보장하기 전에는 왼쪽이나 오른쪽을 선택하지 마세요!\n" +"\n" +"숨겨 둔 힌트가 있습니다. 필요하면 처음부터 다시 시작하고 \"도움말 더 보기!\"를 누르세요." + +#: Game.Levels.Addition.L01zero_add +msgid "" +"This lemma would have been easy if we had known that `x + y = y + x`. That theorem\n" +" is called `add_comm` and it is *true*, but unfortunately its proof *uses* both\n" +" `add_zero` and `zero_add`!\n" +"\n" +" Let's continue on our journey to `add_comm`, the proof of `x + y = y + x`." +msgstr "" +"`x + y = y + x`를 알고 있었다면 이 lemma는 쉬웠을 겁니다. 그 정리는 `add_comm`이라고 하며 실제로 *참*이지만, 안타깝게도 그 증명은 `add_zero`와 `zero_add`을 모두 사용합니다!\n" +"\n" +"`x + y = y + x`의 증명 `add_comm`를 향한 여정을 계속합시다." + +#: Game.Levels.LessOrEqual.L06le_antisymm +msgid "" +"This level asks you to prove *antisymmetry* of $\\leq$.\n" +"In other words, if $x \\leq y$ and $y \\leq x$ then $x = y$.\n" +"It's the trickiest one so far. Good luck!" +msgstr "이 level에서는 $\\leq$의 *반대칭성*을 증명합니다. 즉 $x \\leq y$이고 $y \\leq x$이면 $x = y$임을 보입니다. 지금까지 중 가장 까다롭습니다. 행운을 빕니다!" + +#: Game.Levels.Multiplication.L06two_mul +msgid "" +"This level is more important than you think; it plays\n" +"a useful role when battling a big boss later on." +msgstr "이 level은 생각보다 중요합니다. 나중에 큰 boss와 싸울 때 유용한 역할을 합니다." + +#: Game.Levels.AdvMultiplication.L07mul_ne_zero +msgid "" +"This level proves that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`. One strategy\n" +"is to write both `a` and `b` as `succ` of something, deduce that `a * b` is\n" +"also `succ` of something, and then `apply zero_ne_succ`." +msgstr "이 level에서는 `a ≠ 0`와 `b ≠ 0`이면 `a * b ≠ 0`라는 것을 증명합니다. 한 전략은 `a`과 `b`를 각각 어떤 것의 `succ`로 쓰고, `a * b`도 어떤 것의 `succ`임을 이끌어낸 뒤 `apply zero_ne_succ`을 사용하는 것입니다." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\n" +"instead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory." +msgstr "" +"This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\n" +"instead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory." + +#: Game.Levels.Tutorial.L05add_zero +msgid "" +"Those of you interested in speedrunning the game may want to know\n" +"that `repeat rw [add_zero]` will do both rewrites at once." +msgstr "게임을 speedrun하고 싶은 분들은 `repeat rw [add_zero]`가 두 rewrite를 한 번에 해 준다는 것을 알아 두면 좋습니다." + +#: Game.Levels.LessOrEqual.L02zero_le +msgid "To solve this level, you need to `use` a number `c` such that `x = 0 + c`." +msgstr "이 level을 해결하려면 `x = 0 + c`를 만족하는 수 `c`을 `use`해야 합니다." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"Totality of `≤` is the boss level of this world, and it's coming up next. It says that\n" +"if `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\n" +"But we haven't talked about `or` at all. Here's a run-through.\n" +"\n" +"1) The notation for \"or\" is `∨`. You won't need to type it, but you can\n" +"type it with `\\or`.\n" +"\n" +"2) If you have an \"or\" statement in the *goal*, then two tactics made\n" +"progress: `left` and `right`. But don't choose a direction unless your\n" +"hypotheses guarantee that it's the correct one.\n" +"\n" +"3) If you have an \"or\" statement as a *hypothesis* `h`, then\n" +"`cases h with h1 h2` will create two goals, one where you went left,\n" +"and the other where you went right." +msgstr "" +"Totality of `≤` is the boss level of this world, and it's coming up next. It says that\n" +"if `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\n" +"But we haven't talked about `or` at all. Here's a run-through.\n" +"\n" +"1) The notation for \"or\" is `∨`. You won't need to type it, but you can\n" +"type it with `\\or`.\n" +"\n" +"2) If you have an \"or\" statement in the *goal*, then two tactics made\n" +"progress: `left` and `right`. But don't choose a direction unless your\n" +"hypotheses guarantee that it's the correct one.\n" +"\n" +"3) If you have an \"or\" statement as a *hypothesis* `h`, then\n" +"`cases h with h1 h2` will create two goals, one where you went left,\n" +"and the other where you went right." + +#: Game.Levels.LessOrEqual.L07or_symm +msgid "" +"Totality of `≤` is the boss level of this world, and it's coming up next. It says that\n" +"if `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\n" +"But we haven't talked about `or` at all. Here's a run-through.\n" +"\n" +"1) The notation for \"or\" is `∨`. You won't need to type it, but you can\n" +"type it with `\\or`.\n" +"\n" +"2) If you have an \"or\" statement in the *goal*, then two tactics make\n" +"progress: `left` and `right`. But don't choose a direction unless your\n" +"hypotheses guarantee that it's the correct one.\n" +"\n" +"3) If you have an \"or\" statement as a *hypothesis* `h`, then\n" +"`cases h with h1 h2` will create two goals, one where you went left,\n" +"and the other where you went right." +msgstr "" +"`≤`의 전칭성(totality)은 이 world의 boss level이며 바로 다음에 나옵니다. `a`과 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a`라는 명제입니다. 하지만 아직 `or`에 대해 전혀 이야기하지 않았으니 먼저 살펴봅시다.\n" +"\n" +"1) \"or\"의 표기는 `∨`입니다. 직접 입력할 필요는 없지만 `\\or`로 입력할 수 있습니다.\n" +"\n" +"2) goal에 \"or\" 명제가 있으면 `left`과 `right` 두 tactic으로 진행할 수 있습니다. 하지만 어느 방향이 옳은지 가정으로 확실해지기 전에는 방향을 선택하지 마세요.\n" +"\n" +"3) \"or\" 명제가 가정 `a`0으로 있다면 `a`1은 goal을 두 개 만듭니다. 하나는 왼쪽 경우, 다른 하나는 오른쪽 경우입니다." + +#: Game.Levels.Tutorial +msgid "Tutorial World" +msgstr "튜토리얼 월드" + +#: Game.Levels.Addition.L01zero_add +msgid "Use `add_succ`." +msgstr "`add_succ`를 사용하세요." + +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +msgid "" +"Use `mul_eq_zero` and remember that `tauto` will solve a goal\n" +"if there are hypotheses `a = 0` and `a ≠ 0`." +msgstr "`mul_eq_zero`를 사용하세요. 가정 `a = 0`와 `a ≠ 0`이 있으면 `tauto`이 goal을 해결한다는 점을 기억하세요." + +#: Game.Levels.LessOrEqual.L08le_total +msgid "" +"Very well done.\n" +"\n" +"A passing mathematician remarks that with you've just proved that `ℕ` is totally\n" +"ordered.\n" +"\n" +"The final few levels in this world are much easier." +msgstr "" +"정말 잘했습니다.\n" +"\n" +"지나가던 수학자가 방금 `ℕ`가 전순서(total order)임을 증명했다고 말합니다.\n" +"\n" +"이 world의 마지막 몇 level은 훨씬 쉽습니다." + +#. is_zero 0 := True +#. is_zero (succ n) := False +#. ``` +#: Game.Levels.Algorithm.L06is_zero +msgid "" +"We define a function `is_zero` thus:\n" +"\n" +"```\n" +"is_zero 0 := True\n" +"is_zero (succ n) := False\n" +"```\n" +"\n" +"We also create two lemmas, `is_zero_zero` and `is_zero_succ n`, saying that `is_zero 0 = True`\n" +"and `is_zero (succ n) = False`. Let's use these lemmas to prove `succ_ne_zero`, Peano's\n" +"Last Axiom. Actually, we have been using `zero_ne_succ` before, but it's handy to have\n" +"this opposite version too, which can be proved in the same way. Note: you can\n" +"cheat here by using `zero_ne_succ` but the point of this world is to show\n" +"you how to *prove* results like that.\n" +"\n" +"If you can turn your goal into `True`, then the `trivial` tactic will solve it." +msgstr "" +"함수 `is_zero`를 다음과 같이 정의합니다:\n" +"\n" +"```\n" +"is_zero 0 := True\n" +"is_zero (succ n) := False\n" +"```\n" +"\n" +"또 `is_zero 0 = True`와 `is_zero (succ n) = False`라고 말하는 두 lemma `is_zero_zero`와 `is_zero_succ n`을 만듭니다. 이 lemma들을 사용해 페아노의 마지막 공리 `succ_ne_zero`을 증명합시다. 사실 `zero_ne_succ`은 이전부터 사용해 왔지만, 반대 방향 버전도 있으면 편리하고 같은 방식으로 증명할 수 있습니다. 참고로 `zero_ne_succ`을 쓰면 여기서 치팅할 수 있지만, 이 world의 목적은 그런 결과를 *직접 증명*하는 방법을 보여 주는 것입니다.\n" +"\n" +"goal을 `True`로 바꿀 수 있다면 ```\n" +"is_zero 0 := True\n" +"is_zero (succ n) := False\n" +"```0 tactic이 해결합니다." + +#: Game.Levels.Implication.L06intro +msgid "" +"We have seen how to `apply` theorems and assumptions\n" +"of the form `P → Q`. But what if our *goal* is of the form `P → Q`?\n" +"To prove this goal, we need to know how to say \"let's assume `P` and deduce `Q`\"\n" +"in Lean. We do this with the `intro` tactic." +msgstr "지금까지 `P → Q` 꼴의 정리와 가정을 `apply`하는 법을 봤습니다. 그런데 *goal*이 `P → Q` 꼴이라면 어떨까요? 이 goal을 증명하려면 Lean에서 \"`P`을 가정하고 `Q`를 이끌어내자\"라고 말하는 법을 알아야 합니다. 이를 `intro` tactic으로 합니다." + +#: Game.Levels.Implication.L10one_ne_zero +msgid "" +"We know `zero_ne_succ n` is a proof of `0 = succ n → False` -- but what\n" +"if we have a hypothesis `succ n = 0`? It's the wrong way around!\n" +"\n" +"The `symm` tactic changes a goal `x = y` to `y = x`, and a goal `x ≠ y`\n" +"to `y ≠ x`. And `symm at h`\n" +"does the same for a hypothesis `h`. We've proved $0 \\neq 1$ and called\n" +"the proof `zero_ne_one`; now try proving $1 \\neq 0$." +msgstr "" +"`zero_ne_succ n`가 `0 = succ n → False`의 증명이라는 것은 알고 있습니다. 그런데 가정이 `succ n = 0`라면 어떨까요? 방향이 반대입니다!\n" +"\n" +"`symm` tactic은 goal `x = y`를 `y = x`로, goal `x ≠ y`을 `y ≠ x`로 바꿉니다. `symm at h`은 가정 `h`에 대해 같은 일을 합니다. 우리는 `0 = succ n → False`0을 증명하고 그 증명을 `0 = succ n → False`1이라고 불렀습니다. 이제 `0 = succ n → False`2를 증명해 보세요." + +#: Game.Levels.Multiplication.L09mul_assoc +msgid "" +"We now have enough to prove that multiplication is associative,\n" +"the boss level of multiplication world. Good luck!" +msgstr "이제 곱셈의 결합법칙, 즉 Multiplication World의 boss level을 증명할 준비가 되었습니다. 행운을 빕니다!" + +#: Game.Levels.Power.L10FLT +msgid "" +"We now have enough to state a mathematically accurate, but slightly\n" +"clunky, version of Fermat's Last Theorem.\n" +"\n" +"Fermat's Last Theorem states that if $x,y,z>0$ and $m \\geq 3$ then $x^m+y^m\\not =z^m$.\n" +"If you didn't do inequality world yet then we can't talk about $m \\geq 3$,\n" +"so we have to resort to the hack of using `n + 3` for `m`,\n" +"which guarantees it's big enough. Similarly instead of `x > 0` we\n" +"use `a + 1`.\n" +"\n" +"This level looks superficially like other levels we have seen,\n" +"but the shortest solution known to humans would translate into\n" +"many millions of lines of Lean code. The author of this game,\n" +"Kevin Buzzard, is working on translating the proof by Wiles\n" +"and Taylor into Lean, although this task will take many years.\n" +"\n" +"## CONGRATULATIONS!\n" +"\n" +"You've finished the main quest of the natural number game!\n" +"If you would like to learn more about how to use Lean to\n" +"prove theorems in mathematics, then take a look\n" +"at [Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/),\n" +"an interactive textbook which you can read in your browser,\n" +"and which explains how to work with many more mathematical concepts in Lean." +msgstr "" +"이제 수학적으로 정확하지만 조금 투박한 형태의 페르마의 마지막 정리를 진술할 준비가 되었습니다.\n" +"\n" +"페르마의 마지막 정리는 $x,y,z>0$이고 $m \\geq 3$이면 $x^m+y^m\\not =z^m$라는 정리입니다. Inequality World를 하지 않았다면 $m \\geq 3$에 대해 말할 수 없으므로 `m` 대신 `n + 3`를 쓰는 편법을 사용해야 합니다. 이렇게 하면 충분히 큰 수라는 것이 보장됩니다. 마찬가지로 `x > 0` 대신 `a + 1`을 사용합니다.\n" +"\n" +"겉보기에는 이전 level들과 비슷하지만, 인간이 아는 가장 짧은 해법도 Lean 코드로 옮기면 수백만 줄이 될 것입니다. 이 게임의 저자 Kevin Buzzard는 Wiles와 Taylor의 증명을 Lean으로 옮기는 작업을 하고 있지만, 이 작업은 여러 해가 걸릴 것입니다.\n" +"\n" +"## 축하합니다!\n" +"\n" +"Natural Number Game의 main quest를 끝냈습니다! Lean으로 수학 정리를 증명하는 법을 더 배우고 싶다면 브라우저에서 읽을 수 있는 대화형 교재 [Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/)을 살펴보세요. 더 많은 수학적 개념을 Lean에서 다루는 방법을 설명합니다." + +#: Game.Levels.Implication.L08ne +msgid "" +"We still can't prove `2 + 2 ≠ 5` because we have not talked about the\n" +"definition of `≠`. In Lean, `a ≠ b` is *notation* for `a = b → False`.\n" +"Here `False` is a generic false proposition, and `→` is Lean's notation\n" +"for \"implies\". In logic we learn\n" +"that `True → False` is false, but `False → False` is true. Hence\n" +"`X → False` is the logical opposite of `X`.\n" +"\n" +"Even though `a ≠ b` does not look like an implication,\n" +"you should treat it as an implication. The next two levels will show you how.\n" +"\n" +"`False` is a goal which you cannot deduce from a consistent set of assumptions!\n" +"So if your goal is `False` then you had better hope that your hypotheses\n" +"are contradictory, which they are in this level." +msgstr "" +"아직 `2 + 2 ≠ 5`를 증명할 수 없습니다. `≠`의 정의에 대해 이야기하지 않았기 때문입니다. Lean에서 `a ≠ b`는 `a = b → False`의 *표기법*입니다. 여기서 `False`는 일반적인 거짓 명제이고, `→`는 Lean의 \"implies\" 표기입니다. 논리학에서 `True → False`은 거짓이지만 `False → False`은 참임을 배웁니다. 따라서 `X → False`은 `X`의 논리적 반대입니다.\n" +"\n" +"`≠`0은 겉보기에는 함의처럼 보이지 않지만 함의처럼 다뤄야 합니다. 다음 두 level에서 방법을 봅니다.\n" +"\n" +"`≠`1은 모순 없는 가정들에서는 도저히 이끌어낼 수 없는 goal입니다! 그러므로 goal이 `≠`2라면 가정들이 모순이기를 바라야 하는데, 이 level에서는 실제로 그렇습니다." + +#: Game.Levels.AdvMultiplication.L02mul_left_ne_zero +msgid "" +"We want to reduce this to a hypothesis `b = 0` and a goal `a * b = 0`,\n" +"which is logically equivalent but much easier to prove. Remember that `X ≠ 0`\n" +"is notation for `X = 0 → False`. Click on `Show more help!` if you need hints." +msgstr "이를 가정 `b = 0`와 goal `a * b = 0`으로 환원하고 싶습니다. 논리적으로 동치지만 훨씬 증명하기 쉽습니다. `X ≠ 0`가 `X = 0 → False`의 표기법이라는 점을 기억하세요. 힌트가 필요하면 `도움말 더 보기!`를 클릭하세요." + +#: Game.Levels.AdvMultiplication.L06mul_right_eq_one +msgid "" +"We want to use `le_mul_right`, but we need a hypothesis `x * y ≠ 0`\n" +"which we don't have. Yet. Execute `have h2 : x * y ≠ 0` (you can type `≠` with `\\ne`).\n" +"You'll be asked to\n" +"prove it, and then you'll have a new hypothesis which you can apply\n" +"`le_mul_right` to." +msgstr "`le_mul_right`를 쓰고 싶지만 필요한 가정 `x * y ≠ 0`이 아직 없습니다. `have h2 : x * y ≠ 0`를 실행하세요(`≠`은 `\\ne`로 입력할 수 있습니다). 그 명제를 증명하라는 goal이 생기고, 증명하고 나면 `le_mul_right`를 적용할 수 있는 새 가정이 생깁니다." + +#: Game.Levels.Power.L02zero_pow_succ +msgid "" +"We've just seen that `0 ^ 0 = 1`, but if `n`\n" +"is a successor, then `0 ^ n = 0`. We prove that here." +msgstr "방금 `0 ^ 0 = 1`를 보았습니다. 하지만 `n`이 successor라면 `0 ^ n = 0`입니다. 여기서 이를 증명합니다." + +#: Game.Levels.Implication +msgid "" +"We've proved that $2+2=4$; in Implication World we'll learn\n" +"how to prove $2+2\\neq 5$.\n" +"\n" +"In Addition World we proved *equalities* like $x + y = y + x$.\n" +"In this second tutorial world we'll learn some new tactics,\n" +"enabling us to prove *implications*\n" +"like $x+1=4 \\implies x=3.$\n" +"\n" +"We'll also learn two new fundamental facts about\n" +"natural numbers, which Peano introduced as axioms.\n" +"\n" +"Click on \"Start\" to proceed." +msgstr "" +"$2+2=4$를 증명했습니다. Implication World에서는 $2+2\\neq 5$을 증명하는 법을 배웁니다.\n" +"\n" +"Addition World에서는 $x + y = y + x$ 같은 *등식*을 증명했습니다. 이 두 번째 tutorial world에서는 새로운 tactic들을 배워 $x+1=4 \\implies x=3.$ 같은 *함의*를 증명할 수 있게 됩니다.\n" +"\n" +"또 페아노가 공리로 도입한 자연수에 관한 새로운 기본 사실 두 가지를 배웁니다.\n" +"\n" +"\"Start\"를 눌러 진행하세요." + +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "" +"We've proved that `x ≤ 0` implies `x = 0`. The last two levels\n" +"in this world will prove which numbers are `≤ 1` and `≤ 2`.\n" +"This lemma will be helpful for them." +msgstr "`x ≤ 0`가 `x = 0`을 함의함을 증명했습니다. 이 world의 마지막 두 level에서는 어떤 수들이 `≤ 1`와 `≤ 2`인지 증명합니다. 이 lemma가 도움이 됩니다." + +#: Game.Levels.AdvAddition.L05add_right_eq_zero +msgid "Well done!" +msgstr "잘했습니다!" + +#: Game.Levels.Addition.L02succ_add +msgid "Well done! You now have enough tools to tackle the main boss of this level." +msgstr "잘했습니다! 이제 이 level의 main boss에 도전할 도구가 충분합니다." + +#. symm +#. exact zero_ne_one +#. ``` +#: Game.Levels.Implication.L10one_ne_zero +msgid "" +"What do you think of this two-liner:\n" +"```\n" +"symm\n" +"exact zero_ne_one\n" +"```\n" +"\n" +"`exact` doesn't just take hypotheses, it will eat any proof which exists\n" +"in the system." +msgstr "" +"이 두 줄짜리 증명은 어떤가요?\n" +"```\n" +"symm\n" +"exact zero_ne_one\n" +"```\n" +"\n" +"`exact`은 가정만 받는 것이 아니라 시스템에 존재하는 어떤 증명이든 받아들입니다." + +#: Game.Levels.Tutorial.L04rw_backwards +msgid "" +"Why did we not just define `succ n` to be `n + 1`? Because we have not\n" +"even *defined* addition yet! We'll do that in the next level." +msgstr "왜 `succ n`를 그냥 `n + 1`로 정의하지 않았을까요? 아직 덧셈 자체를 *정의하지 않았기* 때문입니다! 다음 level에서 하겠습니다." + +#: Game.Levels.Multiplication.L07mul_add +msgid "" +"You can do induction on any of the three variables. Some choices\n" +"are harder to push through than others. Can you do the inductive step in\n" +"5 rewrites only?" +msgstr "세 변수 중 어느 것에 대해서든 귀납할 수 있습니다. 어떤 선택은 다른 선택보다 더 어렵습니다. 귀납 단계를 rewrite 5번만으로 할 수 있나요?" + +#: Game.Levels.AdvAddition.L06add_left_eq_zero +msgid "" +"You can just mimic the previous proof to do this one -- or you can figure out a way\n" +"of using it." +msgstr "이전 증명을 그대로 흉내 내도 되고, 그 결과를 이용하는 방법을 찾아도 됩니다." + +#: Game.Levels.Implication.L04succ_inj +msgid "" +"You can put a `←` in front of any theorem provided to `rw` to rewrite\n" +"the other way around. Look at the docs for `rw` for an explanation. Type `←` with `\\l`." +msgstr "`rw`에 주는 어떤 정리 앞에도 `←`를 붙이면 반대 방향으로 rewrite할 수 있습니다. 설명은 `rw` 문서를 보세요. `←`은 `\\l`로 입력합니다." + +#: Game.Levels.Addition.L01zero_add +msgid "" +"You can start a proof by induction on `n` by typing:\n" +"`induction n with d hd`." +msgstr "" +"`n`에 대한 귀납 증명은 다음처럼 시작할 수 있습니다:\n" +"`induction n with d hd`." + +#: Game.Levels.Addition.L02succ_add +msgid "" +"You might want to think about whether induction\n" +"on `a` or `b` is the best idea." +msgstr "`a`와 `b` 중 어느 것에 귀납하는 편이 더 좋은지 생각해 보세요." + +#: Game.Levels.Tutorial.L02rw +msgid "You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey." +msgstr "이제 `2 + 2 = 4`를 증명할 tactic을 충분히 알고 있습니다! 여정을 시작합시다." + +#: Game.Levels.LessOrEqual.L08le_total +msgid "You still don't know which way to go, so do `cases «{e}» with a`." +msgstr "아직 어느 쪽으로 가야 할지 모르므로 `cases «{e}» with a`를 하세요." + +#: Game.Levels.Addition.L05add_right_comm +msgid "" +"You've now seen all the tactics you need to beat the final boss of the game.\n" +"You can begin the journey towards this boss by entering Multiplication World.\n" +"\n" +"Or you can go off the beaten track and learn some new tactics in Implication\n" +"World. These tactics let you prove more facts about addition, such as\n" +"how to deduce `a = 0` from `x + a = x`.\n" +"\n" +"Click \"Home\" and make your choice." +msgstr "" +"이제 게임의 final boss를 이기는 데 필요한 tactic을 모두 배웠습니다. Multiplication World로 들어가 boss를 향한 여정을 시작할 수 있습니다.\n" +"\n" +"또는 정석 길을 벗어나 Implication World에서 새 tactic을 배울 수도 있습니다. 이 tactic들을 이용하면 `x + a = x`에서 `a = 0`를 이끌어내는 법처럼 덧셈에 관한 더 많은 사실을 증명할 수 있습니다.\n" +"\n" +"\"Home\"을 누르고 선택하세요." + +#: Game.Levels.Addition.L03add_comm +msgid "" +"[boss battle music]\n" +"\n" +"Look in your inventory to see the proofs you have available.\n" +"These should be enough." +msgstr "" +"[boss battle 음악]\n" +"\n" +"inventory를 보고 사용할 수 있는 증명들을 확인하세요. 이것이면 충분할 겁니다." + +#: Game.Levels.Tutorial.L07add_succ +msgid "[dramatic music]. Now are you ready to face the first boss of the game?" +msgstr "[극적인 음악]. 이제 게임의 첫 boss를 상대할 준비가 되었나요?" + +#: Game.Levels.Power.L09add_sq +msgid "[final boss music]" +msgstr "[final boss 음악]" + +#: Game.Levels.Tutorial.L05add_zero +msgid "" +"`Add a b`, with notation `a + b`, is\n" +"the usual sum of natural numbers. Internally it is defined\n" +"via the following two hypotheses:\n" +"\n" +"* `add_zero a : a + 0 = a`\n" +"\n" +"* `add_succ a b : a + succ b = succ (a + b)`\n" +"\n" +"Other theorems about naturals, such as `zero_add a : 0 + a = a`, are proved\n" +"by induction using these two basic theorems." +msgstr "" +"`Add a b`는 `a + b`로 표기하며 자연수의 보통 덧셈입니다. 내부적으로는 다음 두 가정으로 정의됩니다.\n" +"\n" +"* `add_zero a : a + 0 = a`\n" +"\n" +"* `add_succ a b : a + succ b = succ (a + b)`\n" +"\n" +"`zero_add a : 0 + a = a` 같은 자연수에 관한 다른 정리들은 이 두 기본 정리를 이용한 귀납법으로 증명합니다." + +#: Game.Levels.Multiplication.L01mul_one +msgid "" +"`Mul a b`, with notation `a * b`, is the usual\n" +" product of natural numbers. Internally it is\n" +" via two axioms:\n" +"\n" +" * `mul_zero a : a * 0 = 0`\n" +"\n" +" * `mul_succ a b : a * succ b = a * b + a`\n" +"\n" +"Other theorems about naturals, such as `zero_mul`,\n" +"are proved by induction from these two basic theorems." +msgstr "" +"`Mul a b`는 `a * b`로 표기하며 자연수의 보통 곱셈입니다. 내부적으로 두 공리로 정의됩니다.\n" +"\n" +" * `mul_zero a : a * 0 = 0`\n" +"\n" +" * `mul_succ a b : a * succ b = a * b + a`\n" +"\n" +"`zero_mul` 같은 자연수에 관한 다른 정리들은 이 두 기본 정리에서 귀납법으로 증명합니다." + +#: Game.Levels.Power.L01zero_pow_zero +msgid "" +"`Pow a b`, with notation `a ^ b`, is the usual\n" +" exponentiation of natural numbers. Internally it is\n" +" defined via two axioms:\n" +"\n" +" * `pow_zero a : a ^ 0 = 1`\n" +"\n" +" * `pow_succ a b : a ^ succ b = a ^ b * a`\n" +"\n" +"Note in particular that `0 ^ 0 = 1`." +msgstr "" +"`Pow a b`는 `a ^ b`로 표기하며 자연수의 보통 거듭제곱입니다. 내부적으로는 두 공리로 정의됩니다.\n" +"\n" +" * `pow_zero a : a ^ 0 = 1`\n" +"\n" +" * `pow_succ a b : a ^ succ b = a ^ b * a`\n" +"\n" +"특히 `0 ^ 0 = 1`라는 점에 주의하세요." + +#: Game.Levels.LessOrEqual.L01le_refl +msgid "" +"`a ≤ b` is *notation* for `∃ c, b = a + c`.\n" +"\n" +"Because this game doesn't have negative numbers, this definition\n" +"is mathematically valid.\n" +"\n" +"This means that if you have a goal of the form `a ≤ b` you can\n" +"make progress with the `use` tactic, and if you have a hypothesis\n" +"`h : a ≤ b`, you can make progress with `cases h with c hc`." +msgstr "" +"`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다.\n" +"\n" +"이 게임에는 음수가 없으므로 이 정의는 수학적으로 타당합니다.\n" +"\n" +"따라서 `a ≤ b` 꼴의 goal이 있으면 `use` tactic으로 진행할 수 있고, 가정 `h : a ≤ b`가 있으면 `cases h with c hc`로 진행할 수 있습니다." + +#: Game.Levels.LessOrEqual.L01le_refl +msgid "" +"`a ≤ b` is *notation* for `∃ c, b = a + c`. This \"backwards E\"\n" +"means \"there exists\". So `a ≤ b` means that there exists\n" +"a number `c` such that `b = a + c`. This definition works\n" +"because there are no negative numbers in this game.\n" +"\n" +"To *prove* an \"exists\" statement, use the `use` tactic.\n" +"Let's see an example." +msgstr "" +"`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다. 이 \"거꾸로 된 E\"는 \"존재한다\"는 뜻입니다. 따라서 `a ≤ b`는 `b = a + c`를 만족하는 수 `c`가 존재한다는 뜻입니다. 이 게임에는 음수가 없으므로 이 정의가 작동합니다.\n" +"\n" +"\"존재한다\"는 명제를 *증명*하려면 `use` tactic을 사용합니다. 예시를 봅시다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`add_comm a b` is a proof of `a + b = b + a`." +msgstr "`add_comm a b`는 `a + b = b + a`의 증명입니다." + +#: Game.Levels.Addition.L05add_right_comm +msgid "" +"`add_comm b c` is a proof that `b + c = c + b`. But if your goal\n" +"is `a + b + c = a + c + b` then `rw [add_comm b c]` will not\n" +"work! Because the goal means `(a + b) + c = (a + c) + b` so there\n" +"is no `b + c` term *directly* in the goal.\n" +"\n" +"Use associativity and commutativity to prove `add_right_comm`.\n" +"You don't need induction. `add_assoc` moves brackets around,\n" +"and `add_comm` moves variables around.\n" +"\n" +"Remember that you can do more targeted rewrites by\n" +"adding explicit variables as inputs to theorems. For example `rw [add_comm b]`\n" +"will only do rewrites of the form `b + ? = ? + b`, and `rw [add_comm b c]`\n" +"will only do rewrites of the form `b + c = c + b`." +msgstr "" +"`add_comm b c`는 `b + c = c + b`의 증명입니다. 하지만 goal이 `a + b + c = a + c + b`라면 `rw [add_comm b c]`은 작동하지 않습니다! goal의 뜻이 `(a + b) + c = (a + c) + b`이므로 goal 안에 `b + c` 항이 *직접* 나타나지 않기 때문입니다.\n" +"\n" +"결합법칙과 가환법칙을 이용해 `add_right_comm`을 증명하세요. 귀납법은 필요 없습니다. `add_assoc`은 괄호를 옮기고 `add_comm`은 변수의 순서를 바꿉니다.\n" +"\n" +"정리를 적용할 때 변수를 명시하면 더 정밀한 rewrite를 할 수 있다는 점을 기억하세요. 예를 들어 `rw [add_comm b]`는 `b + c = c + b`0 꼴만 rewrite하고, `b + c = c + b`1은 `b + c = c + b`2 꼴만 rewrite합니다." + +#: Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L03add_left_eq_self +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "`add_left_cancel a b n` is the theorem that $n+a=n+b \\implies a=b.$" +msgstr "`add_left_cancel a b n`는 $n+a=n+b \\implies a=b.$이라는 정리입니다." + +#: Game.Levels.AdvAddition.L02add_left_cancel +msgid "" +"`add_left_cancel a b n` is the theorem that $n+a=n+b\\implies a=b$.\n" +"You can prove it by induction on `n` or you can deduce it from `add_right_cancel`." +msgstr "`add_left_cancel a b n`는 $n+a=n+b\\implies a=b$이라는 정리입니다. `n`에 대해 귀납해도 되고 `add_right_cancel`에서 이끌어내도 됩니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`add_left_comm a b c` is a proof that `a + (b + c) = b + (a + c)`." +msgstr "`add_left_comm a b c`는 `a + (b + c) = b + (a + c)`.의 증명입니다." + +#: Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L03add_left_eq_self +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "`add_left_eq_self x y` is the theorem that $x + y = y \\implies x=0.$" +msgstr "`add_left_eq_self x y`는 $x + y = y \\implies x=0.$이라는 정리입니다." + +#: Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L03add_left_eq_self +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "`add_left_eq_self x y` is the theorem that $x + y = y\\implies x=0.$" +msgstr "`add_left_eq_self x y`는 $x + y = y\\implies x=0.$이라는 정리입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`add_mul a b c` is a proof that $(a+b)c=ac+bc$." +msgstr "`add_mul a b c`는 $(a+b)c=ac+bc$.의 증명입니다." + +#: Game.Levels.Multiplication.L08add_mul +msgid "" +"`add_mul` is just as fiddly to prove by induction; but there's a trick\n" +"which avoids it. Can you spot it?" +msgstr "`add_mul`도 귀납법으로 증명하려면 꽤 번거롭습니다. 하지만 이를 피하는 요령이 하나 있습니다. 찾을 수 있나요?" + +#: Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L03add_left_eq_self +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "`add_right_cancel a b n` is the theorem that $a+n=b+n \\implies a=b.$" +msgstr "`add_right_cancel a b n`는 $a+n=b+n \\implies a=b.$이라는 정리입니다." + +#: Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L03add_left_eq_self +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "`add_right_eq_self x y` is the theorem that $x + y = x \\implies y=0.$" +msgstr "`add_right_eq_self x y`는 $x + y = x \\implies y=0.$이라는 정리입니다." + +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "" +"`add_right_eq_self x y` is the theorem that $x + y = x\\implies y=0.$\n" +"Two ways to do it spring to mind; I'll mention them when you've solved it." +msgstr "`add_right_eq_self x y`는 $x + y = x\\implies y=0.$이라는 정리입니다. 두 가지 방법이 떠오르는데, 해결하고 나면 말씀드리겠습니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "" +"`add_zero a` is a proof that `a + 0 = a`.\n" +"\n" +"## Summary\n" +"\n" +"`add_zero` is really a function, which\n" +"eats a number, and returns a proof of a theorem\n" +"about that number. For example `add_zero 37` is\n" +"a proof that `37 + 0 = 37`.\n" +"\n" +"The `rw` tactic will accept `rw [add_zero]`\n" +"and will try to figure out which number you omitted\n" +"to input.\n" +"\n" +"## Details\n" +"\n" +"A mathematician sometimes thinks of `add_zero`\n" +"as \\\"one thing\\\", namely a proof of $\\forall n ∈ ℕ, n + 0 = n$.\n" +"This is just another way of saying that it's a function which\n" +"can eat any number n and will return a proof that `n + 0 = n`." +msgstr "" +"`add_zero a`는 `a + 0 = a`.\n" +"\n" +"## Summary\n" +"\n" +"`add_zero` is really a function, which\n" +"eats a number, and returns a proof of a theorem\n" +"about that number. For example `add_zero 37` is\n" +"a proof that `37 + 0 = 37`.\n" +"\n" +"The `rw` tactic will accept `rw [add_zero]`\n" +"and will try to figure out which number you omitted\n" +"to input.\n" +"\n" +"## Details\n" +"\n" +"A mathematician sometimes thinks of `add_zero`\n" +"as \\\"one thing\\\", namely a proof of $\\forall n ∈ ℕ, n + 0 = n$.\n" +"This is just another way of saying that it's a function which\n" +"can eat any number n and will return a proof that `n + 0 = n`.의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`eq_succ_of_ne_zero a` is a proof that `a ≠ 0 → ∃ n, a = succ n`." +msgstr "`eq_succ_of_ne_zero a`는 `a ≠ 0 → ∃ n, a = succ n`.의 증명입니다." + +#: Game.Levels.Implication.L02exact2 +msgid "`exact` practice." +msgstr "`exact` 연습." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`four_eq_succ_three` is a proof of `4 = succ 3`." +msgstr "`four_eq_succ_three`는 `4 = succ 3`의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`is_zero_succ a` is a proof of `is_zero (succ a) = False`." +msgstr "`is_zero_succ a`는 `is_zero (succ a) = False`의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`is_zero_zero` is a proof of `is_zero 0 = True`." +msgstr "`is_zero_zero`는 `is_zero 0 = True`의 증명입니다." + +#: Game.Levels.LessOrEqual.L06le_antisymm +#: Game.Levels.AdvMultiplication.L07mul_ne_zero +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "`le_antisymm x y` is a proof that if `x ≤ y` and `y ≤ x` then `x = y`." +msgstr "`le_antisymm x y`는 `x ≤ y`이고 `y ≤ x`이면 `x = y`이라는 것의 증명입니다." + +#: Game.Levels.AdvMultiplication.L05le_mul_right +msgid "" +"`le_mul_right a b` is a proof that `a * b ≠ 0 → a ≤ a * b`.\n" +"\n" +"It's one way of saying that a divisor of a positive number\n" +"has to be at most that number." +msgstr "" +"`le_mul_right a b`는 `a * b ≠ 0 → a ≤ a * b`의 증명입니다.\n" +"\n" +"양수의 약수는 그 수 이하이어야 한다는 사실을 표현하는 한 방법입니다." + +#: Game.Levels.LessOrEqual.L10le_one +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "`le_one x` is a proof that if `x ≤ 1` then `x = 0` or `x = 1`." +msgstr "`le_one x`는 `x ≤ 1`이면 `x = 0` 또는 `x = 1`이라는 것의 증명입니다." + +#: Game.Levels.LessOrEqual.L01le_refl +msgid "" +"`le_refl x` is a proof of `x ≤ x`.\n" +"\n" +"The reason for the name is that this lemma is \"reflexivity of $\\le$\"" +msgstr "" +"`le_refl x`는 `x ≤ x`의 증명입니다.\n" +"\n" +"이 이름은 이 lemma가 \"$\\le$의 반사성(reflexivity)\"을 나타내기 때문에 붙었습니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`le_succ_self x` is a proof that `x ≤ succ x`." +msgstr "`le_succ_self x`는 `x ≤ succ x`.의 증명입니다." + +#: Game.Levels.LessOrEqual.L08le_total +msgid "`le_total x y` is a proof that `x ≤ y` or `y ≤ x`." +msgstr "`le_total x y`는 `x ≤ y` 또는 `y ≤ x`의 증명입니다." + +#: Game.Levels.LessOrEqual.L04le_trans +msgid "" +"`le_trans x y z` is a proof that if `x ≤ y` and `y ≤ z` then `x ≤ z`.\n" +"More precisely, it is a proof that `x ≤ y → (y ≤ z → x ≤ z)`. In words,\n" +"If $x \\le y$ then (pause) if $y \\le z$ then $x \\le z$.\n" +"\n" +"## A note on associativity\n" +"\n" +"In Lean, `a + b + c` means `(a + b) + c`, because `+` is left associative. However\n" +"`→` is right associative. This means that `x ≤ y → y ≤ z → x ≤ z` in Lean means\n" +"exactly that `≤` is transitive. This is different to how mathematicians use\n" +"$P \\implies Q \\implies R$; for them, this usually means that $P \\implies Q$\n" +"and $Q \\implies R$." +msgstr "" +"`le_trans x y z`는 `x ≤ y`이고 `y ≤ z`이면 `x ≤ z`이라는 것의 증명입니다. 더 정확히는 `x ≤ y → (y ≤ z → x ≤ z)`의 증명입니다. 말로 하면 \"$x \\le y$이면, (잠깐 쉬고) $y \\le z$이면 $x \\le z$\"입니다.\n" +"\n" +"## 결합법칙에 관한 주의\n" +"\n" +"Lean에서 `a + b + c`은 `(a + b) + c`를 뜻합니다. `x ≤ y`0이 왼쪽 결합이기 때문입니다. 하지만 `x ≤ y`1은 오른쪽 결합입니다. 따라서 Lean에서 `x ≤ y`2는 정확히 `x ≤ y`3이 추이적이라는 뜻입니다. 이는 수학자들이 `x ≤ y`4를 쓰는 방식과 다릅니다. 수학자에게는 보통 `x ≤ y`5이고 `x ≤ y`6이라는 뜻입니다." + +#: Game.Levels.LessOrEqual.L11le_two +msgid "`le_two x` is a proof that if `x ≤ 2` then `x = 0` or `x = 1` or `x = 2`." +msgstr "`le_two x`는 `x ≤ 2`이면 `x = 0` 또는 `x = 1` 또는 `x = 2`라는 것의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`le_zero x` is a proof of `x ≤ 0 → x = 0`." +msgstr "`le_zero x`는 `x ≤ 0 → x = 0`의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "" +"`mul_assoc a b c` is a proof that `(a * b) * c = a * (b * c)`.\n" +"\n" +"Note that when Lean says `a * b * c` it means `(a * b) * c`.\n" +"\n" +"Note that `(a * b) * c = a * (b * c)` cannot be proved by \\\"pure thought\\\":\n" +"for example subtraction is not associative, as `(6 - 2) - 1` is not\n" +"equal to `6 - (2 - 1)`." +msgstr "" +"`mul_assoc a b c`는 `(a * b) * c = a * (b * c)`.\n" +"\n" +"Note that when Lean says `a * b * c` it means `(a * b) * c`.\n" +"\n" +"Note that `(a * b) * c = a * (b * c)` cannot be proved by \\\"pure thought\\\":\n" +"for example subtraction is not associative, as `(6 - 2) - 1` is not\n" +"equal to `6 - (2 - 1)`.의 증명입니다." + +#: Game.Levels.LessOrEqual.L10le_one +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "`mul_eq_zero a b` is a proof that if `a * b = 0` then `a = 0` or `b = 0`." +msgstr "`mul_eq_zero a b`는 `a * b = 0`이면 `a = 0` 또는 `b = 0`이라는 것의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`mul_le_mul_right a b t` is a proof that `a ≤ b → a * t ≤ b * t`." +msgstr "`mul_le_mul_right a b t`는 `a ≤ b → a * t ≤ b * t`.의 증명입니다." + +#: Game.Levels.LessOrEqual.L06le_antisymm +#: Game.Levels.AdvMultiplication.L07mul_ne_zero +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "`mul_left_cancel a b c` is a proof that if `a ≠ 0` and `a * b = a * c` then `b = c`." +msgstr "`mul_left_cancel a b c`는 `a ≠ 0`이고 `a * b = a * c`이면 `b = c`이라는 것의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`mul_left_ne_zero a b` is a proof that `a * b ≠ 0 → b ≠ 0`." +msgstr "`mul_left_ne_zero a b`는 `a * b ≠ 0 → b ≠ 0`.의 증명입니다." + +#: Game.Levels.LessOrEqual.L06le_antisymm +#: Game.Levels.AdvMultiplication.L07mul_ne_zero +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "`mul_ne_zero a b` is a proof that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`." +msgstr "`mul_ne_zero a b`는 `a ≠ 0`이고 `b ≠ 0`이면 `a * b ≠ 0`이라는 것의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`mul_pow a b n` is a proof that $(ab)^n=a^nb^n.$" +msgstr "`mul_pow a b n`는 $(ab)^n=a^nb^n.$의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`mul_right_eq_one a b` is a proof that `a * b = 1 → a = 1`." +msgstr "`mul_right_eq_one a b`는 `a * b = 1 → a = 1`.의 증명입니다." + +#: Game.Levels.LessOrEqual.L06le_antisymm +#: Game.Levels.AdvMultiplication.L07mul_ne_zero +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "`mul_right_eq_self a b` is a proof that if `a ≠ 0` and `a * b = a` then `b = 1`." +msgstr "`mul_right_eq_self a b`는 `a ≠ 0`이고 `a * b = a`이면 `b = 1`이라는 것의 증명입니다." + +#: Game.Levels.Tutorial.L08twoaddtwo +msgid "`nth_rewrite 2 [two_eq_succ_one]` is I think quicker than `rw [two_eq_succ_one]`." +msgstr "제 생각에는 `nth_rewrite 2 [two_eq_succ_one]`가 `rw [two_eq_succ_one]`보다 빠릅니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`one_eq_succ_zero` is a proof of `1 = succ 0`." +msgstr "`one_eq_succ_zero`는 `1 = succ 0`의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`one_le_of_ne_zero a` is a proof that `a ≠ 0 → 1 ≤ a`." +msgstr "`one_le_of_ne_zero a`는 `a ≠ 0 → 1 ≤ a`.의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`one_ne_zero` is a proof that `1 ≠ 0`." +msgstr "`one_ne_zero`는 `1 ≠ 0`.의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`one_pow n` is a proof that $1^n=1$." +msgstr "`one_pow n`는 $1^n=1$.의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`pow_add a m n` is a proof that $a^{m+n}=a^ma^n.$" +msgstr "`pow_add a m n`는 $a^{m+n}=a^ma^n.$의 증명입니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`pow_pow a m n` is a proof that $(a^m)^n=a^{mn}.$" +msgstr "`pow_pow a m n`는 $(a^m)^n=a^{mn}.$의 증명입니다." + +#: Game.Levels.Power.L02zero_pow_succ +msgid "" +"`pow_succ a b : a ^ (succ b) = a ^ b * a` is one of the\n" +"two axioms defining exponentiation in this game." +msgstr "`pow_succ a b : a ^ (succ b) = a ^ b * a`는 이 게임에서 거듭제곱을 정의하는 두 공리 중 하나입니다." + +#: Game.Levels.Power.L01zero_pow_zero +msgid "" +"`pow_zero a : a ^ 0 = 1` is one of the two axioms\n" +"defining exponentiation in this game." +msgstr "`pow_zero a : a ^ 0 = 1`는 이 게임에서 거듭제곱을 정의하는 두 공리 중 하나입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`pred_succ n` is a proof of `pred (succ n) = n`." +msgstr "`pred_succ n`는 `pred (succ n) = n`의 증명입니다." + +#: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro +#: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.Implication.L10one_ne_zero +#: Game.Levels.Implication.L11two_add_two_ne_five +#: Game.Levels.Algorithm.L02add_algo1 Game.Levels.Algorithm.L06is_zero +#: Game.Levels.Algorithm.L08decide Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.AdvAddition.L02add_left_cancel +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "`rw [add_comm b d]`." +msgstr "`rw [add_comm b d]`." + +#: Game.Levels.Tutorial.L05add_zero +msgid "`rw [add_zero]` will change `b + 0` into `b`." +msgstr "`rw [add_zero]`는 `b + 0`을 `b`로 바꿉니다." + +#: Game.Levels.Tutorial.L07add_succ +msgid "`rw [one_eq_succ_zero]` will do this." +msgstr "`rw [one_eq_succ_zero]`가 이 일을 해 줍니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`succ_add a b` is a proof that `succ a + b = succ (a + b)`." +msgstr "`succ_add a b`는 `succ a + b = succ (a + b)`.의 증명입니다." + +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "`succ_le_succ x y` is a proof that if `succ x ≤ succ y` then `x ≤ y`." +msgstr "`succ_le_succ x y`는 `succ x ≤ succ y`이면 `x ≤ y`라는 것의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`succ_ne_zero a` is a proof of `succ a ≠ 0`." +msgstr "`succ_ne_zero a`는 `succ a ≠ 0`의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`three_eq_succ_two` is a proof of `3 = succ 2`." +msgstr "`three_eq_succ_two`는 `3 = succ 2`의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`two_eq_succ_one` is a proof of `2 = succ 1`." +msgstr "`two_eq_succ_one`는 `2 = succ 1`의 증명입니다." + +#: Game.Levels.Power.L10FLT +msgid "" +"`xyzzy` is an ancient magic spell, believed to be the origin of the\n" +"modern word `sorry`. The game won't complain - or notice - if you\n" +"prove anything with `xyzzy`." +msgstr "`xyzzy`는 고대의 마법 주문으로, 현대의 단어 `sorry`의 기원이라고 전해집니다. `xyzzy`로 무엇을 증명하든 게임은 불평하지도, 알아차리지도 못합니다." + +#: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow +#: Game.Levels.Power.L08pow_pow +msgid "`zero_le x` is a proof that `0 ≤ x`." +msgstr "`zero_le x`는 `0 ≤ x`.의 증명입니다." + +#: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm +#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred +#: Game.Levels.Algorithm.L06is_zero Game.Levels.LessOrEqual.L05le_zero +msgid "`zero_ne_one` is a proof of `0 ≠ 1`." +msgstr "`zero_ne_one`는 `0 ≠ 1`의 증명입니다." + +#: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 +#: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 +#: Game.Levels.AdvAddition.L03add_left_eq_self +msgid "" +"`ℕ` is the natural numbers, just called \\\"numbers\\\" in this game. It's\n" +"defined via two rules:\n" +"\n" +"* `0 : ℕ` (zero is a number)\n" +"* `succ (n : ℕ) : ℕ` (the successor of a number is a number)\n" +"\n" +"## Game Implementation\n" +"\n" +"*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\n" +"It is distinct from the Lean natural numbers `Nat`, which should hopefully\n" +"never leak into the natural number game.*" +msgstr "" +"`ℕ` is the natural numbers, just called \\\"numbers\\\" in this game. It's\n" +"defined via two rules:\n" +"\n" +"* `0 : ℕ` (zero is a number)\n" +"* `succ (n : ℕ) : ℕ` (the successor of a number is a number)\n" +"\n" +"## Game Implementation\n" +"\n" +"*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\n" +"It is distinct from the Lean natural numbers `Nat`, which should hopefully\n" +"never leak into the natural number game.*" + +#: Game.Levels.Addition.L03add_comm +msgid "add_comm (level boss)" +msgstr "add_comm (level boss)" + +#: Game.Levels.AdvAddition.L06add_left_eq_zero +msgid "add_left_eq_zero" +msgstr "add_left_eq_zero" + +#: Game.Levels.Multiplication.L08add_mul +msgid "add_mul" +msgstr "add_mul" + +#: Game.Levels.Addition.L05add_right_comm +msgid "add_right_comm" +msgstr "add_right_comm" + +#: Game.Levels.AdvAddition.L04add_right_eq_self +msgid "add_right_eq_self" +msgstr "add_right_eq_self" + +#: Game.Levels.AdvAddition.L05add_right_eq_zero +msgid "add_right_eq_zero" +msgstr "add_right_eq_zero" + +#: Game.Levels.Power.L09add_sq +msgid "add_sq" +msgstr "add_sq" + +#: Game.Levels.Tutorial.L07add_succ +msgid "add_succ" +msgstr "add_succ" + +#: Game.Levels.Algorithm.L09decide2 +msgid "decide again" +msgstr "decide 다시 사용하기" + +#: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +msgid "eq_succ_of_ne_zero" +msgstr "eq_succ_of_ne_zero" + +#: GameServer.RpcHandlers +msgid "intermediate goal solved! 🎉" +msgstr "중간 goal 해결! 🎉" + +#: Game.Levels.Algorithm.L06is_zero +msgid "is_zero" +msgstr "is_zero" + +#: Game.Levels.AdvMultiplication.L05le_mul_right +msgid "le_mul_right" +msgstr "le_mul_right" + +#: Game.Levels.LessOrEqual.L11le_two +msgid "le_two" +msgstr "le_two" + +#: GameServer.RpcHandlers +msgid "level completed! 🎉" +msgstr "level 완료! 🎉" + +#: Game.Levels.Algorithm.L02add_algo1 +msgid "making life easier" +msgstr "더 쉽게 만들기" + +#: Game.Levels.Multiplication.L07mul_add +msgid "mul_add" +msgstr "mul_add" + +#: Game.Levels.AdvMultiplication.L08mul_eq_zero +msgid "mul_eq_zero" +msgstr "mul_eq_zero" + +#: Game.Levels.AdvMultiplication.L01mul_le_mul_right +msgid "mul_le_mul_right" +msgstr "mul_le_mul_right" + +#: Game.Levels.AdvMultiplication.L09mul_left_cancel +msgid "mul_left_cancel" +msgstr "mul_left_cancel" + +#: Game.Levels.Multiplication.L01mul_one +msgid "mul_one" +msgstr "mul_one" + +#: Game.Levels.Power.L07mul_pow +msgid "mul_pow" +msgstr "mul_pow" + +#: Game.Levels.AdvMultiplication.L10mul_right_eq_self +msgid "mul_right_eq_self" +msgstr "mul_right_eq_self" + +#: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero +msgid "one_le_of_ne_zero" +msgstr "one_le_of_ne_zero" + +#: Game.Levels.Multiplication.L05one_mul +msgid "one_mul" +msgstr "one_mul" + +#: Game.Levels.Power.L04one_pow +msgid "one_pow" +msgstr "one_pow" + +#: Game.Levels.Power.L03pow_one +msgid "pow_one" +msgstr "pow_one" + +#: Game.Levels.Power.L08pow_pow +msgid "pow_pow" +msgstr "pow_pow" + +#: Game.Levels.Power.L05pow_two +msgid "pow_two" +msgstr "pow_two" + +#: Game.Levels.Algorithm.L05pred +msgid "pred" +msgstr "pred" + +#: Game.Levels.Tutorial.L04rw_backwards +msgid "rewriting backwards" +msgstr "거꾸로 rewriting하기" + +#: Game.Levels.LessOrEqual.L09succ_le_succ +msgid "succ x ≤ succ y → x ≤ y" +msgstr "succ x ≤ succ y → x ≤ y" + +#: Game.Levels.Implication.L04succ_inj +msgid "succ_inj : the successor function is injective" +msgstr "succ_inj : successor 함수는 단사입니다." + +#: Game.Levels.Multiplication.L03succ_mul +msgid "succ_mul" +msgstr "succ_mul" + +#: Game.Levels.Algorithm.L04add_algo3 +msgid "the simplest approach" +msgstr "가장 간단한 접근" + +#: Game.Levels.Addition.L01zero_add +msgid "try rewriting `add_zero`." +msgstr "`add_zero`를 rewrite해 보세요." + +#: Game.Levels.Multiplication.L06two_mul +msgid "two_mul" +msgstr "two_mul" + +#: Game.Levels.LessOrEqual.L03le_succ_self +msgid "x ≤ succ x" +msgstr "x ≤ succ x" + +#: Game.Levels.LessOrEqual.L04le_trans +msgid "x ≤ y and y ≤ z implies x ≤ z" +msgstr "x ≤ y이고 y ≤ z이면 x ≤ z" + +#: Game.Levels.LessOrEqual.L08le_total +msgid "x ≤ y or y ≤ x" +msgstr "x ≤ y 또는 y ≤ x" + +#: Game.Levels.Addition.L01zero_add +msgid "zero_add" +msgstr "zero_add" + +#: Game.Levels.Multiplication.L02zero_mul +msgid "zero_mul" +msgstr "zero_mul" + +#: Game.Levels.Power.L02zero_pow_succ +msgid "zero_pow_succ" +msgstr "zero_pow_succ" + +#: Game.Levels.Implication.L08ne +msgid "≠" +msgstr "≠" + +#: Game.Levels.LessOrEqual +msgid "≤ World" +msgstr "≤ 월드" + +#. §0: `rfl` +#. §1: `X = X` +#. §2: `rfl` +#. §3: `A = B` +#. §4: `A` +#. §5: `B` +#. §6: `rfl` +#. §7: ``` +#. x + 37 = x + 37 +#. ``` +#. §8: `rfl` +#. §9: `0 + x = x` +#. §10: `rfl` +#. §11: $0+x$ +#. §12: $x$ +#. §13: `0 + x` +#. §14: `0 + x` +#. §15: `rfl` +#. §16: `rfl` +#. §17: `mathlib` +#. §18: `zero_add` +#. §19: `add_zero` +#: Game.Levels.Tutorial.L01rfl +msgid "" +"## Summary\n" +"\n" +"§0 proves goals of the form §1.\n" +"\n" +"In other words, the §2 tactic will close any goal of the\n" +"form §3 if §4 and §5 are *identical*.\n" +"\n" +"§6 is short for \\\\\"reflexivity (of equality)\\\\\".\n" +"\n" +"## Example:\n" +"\n" +"If the goal looks like this:\n" +"\n" +"§7\n" +"\n" +"then §8 will close it. But if it looks like §9 then §10 won't work, because even\n" +"though §11 and §12 are always equal as *numbers*, they are not equal as *terms*.\n" +"The only term which is identical to §13 is §14.\n" +"\n" +"## Details\n" +"\n" +"§15 is short for \\\\\"reflexivity of equality\\\\\".\n" +"\n" +"## Game Implementation\n" +"\n" +"*Note that our §16 is weaker than the version used in core Lean and §17,\n" +"for pedagogical purposes; mathematicians do not distinguish between propositional\n" +"and definitional equality because they think about definitions in a different way\n" +"to type theorists (§18 and §19 are both \\\\\"facts\\\\\" as far\n" +"as mathematicians are concerned, and who cares what the definition of addition is).*" +msgstr "" +"## 요약\n" +"\n" +"§0는 §1 꼴의 goal을 증명합니다.\n" +"\n" +"즉 §4와 §5가 *동일한* 항이라면 §2 tactic은 §3 꼴의 모든 goal을 닫습니다.\n" +"\n" +"§6는 \"reflexivity (of equality)\"의 줄임말입니다.\n" +"\n" +"## 예시\n" +"\n" +"goal이\n" +"\n" +"§7\n" +"\n" +"처럼 생겼다면 §8이 닫습니다. 하지만 §9처럼 생겼다면 §10은 작동하지 않습니다. §11과 §12가 *수로서는* 항상 같더라도 *항으로서* 동일하지 않기 때문입니다. §13과 동일한 항은 §14뿐입니다.\n" +"\n" +"## 자세한 설명\n" +"\n" +"§15는 \"reflexivity of equality\"의 줄임말입니다.\n" +"\n" +"## 게임 구현\n" +"\n" +"*교육적 목적 때문에 이 게임의 §16는 core Lean과 §17에서 쓰는 버전보다 약합니다. 수학자들은 명제적 동등성과 정의적 동등성을 잘 구분하지 않습니다. type theorist와는 정의를 생각하는 방식이 다르기 때문입니다(수학자에게 §18과 §19는 둘 다 그저 \"사실\"이고, 덧셈의 정의가 무엇인지는 별로 중요하지 않습니다).*" + +#. §0: `h` +#. §1: `X = Y` +#. §2: `rw [h]` +#. §3: `X` +#. §4: `Y` +#. §5: `rw [← h]` +#. §6: `Y` +#. §7: `X` +#. §8: `\\left ` +#. §9: `\\l` +#. §10: `rw [h1, h2]` +#. §11: `rw [h] at h2` +#. §12: `X` +#. §13: `Y` +#. §14: `h2` +#. §15: `rw [h] at h1 h2 ⊢` +#. §16: `X` +#. §17: `Y` +#. §18: `⊢` +#. §19: `\\|-` +#. §20: `repeat rw [add_zero]` +#. §21: `? + 0` +#. §22: `?` +#. §23: `? + 0` +#. §24: `nth_rewrite 2 [h]` +#. §25: `X` +#. §26: `Y` +#. §27: `h : x = y + y` +#. §28: ``` +#. succ (x + 0) = succ (y + y) +#. ``` +#. §29: `rw [add_zero]` +#. §30: `succ x = succ (y + y)` +#. §31: `rw [h]` +#. §32: `succ (y + y) = succ (y + y)` +#. §33: `rfl` +#. §34: `rw` +#. §35: ``` +#. h1 : x = y + 3 +#. h2 : 2 * y = x +#. ``` +#. §36: `rw [h1] at h2` +#. §37: `h2` +#. §38: `h2 : 2 * y = y + 3` +#. §39: `rw h` +#. §40: `h` +#. §41: `A = B` +#. §42: `h` +#. §43: `rw` +#. §44: `rw [P = Q]` +#. §45: `P = Q` +#. §46: `h : P = Q` +#. §47: `rw [h]` +#. §48: `rw` +#. §49: `h : A = B` +#. §50: `A` +#. §51: `rw [h]` +#. §52: `B` +#. §53: `A` +#. §54: `add_zero` +#. §55: `? + 0 = ?` +#. §56: `add_zero` +#. §57: `?` +#. §58: `rw` +#. §59: `x + 0` +#. §60: `?` +#. §61: `x` +#. §62: `x + 0` +#. §63: `x` +#. §64: `rw [add_zero]` +#. §65: `(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` +#. §66: `0 + (x + 0) + 0 + (x + 0)` +#. §67: `b + c + a = b + (a + c)` +#. §68: `a + c` +#. §69: `c + a` +#. §70: `rw [add_comm]` +#. §71: `rw [add_comm a c]` +#. §72: `a + c` +#. §73: `c + a` +#. §74: `add_comm` +#. §75: `?1 + ?2 = ?2 + ?1` +#. §76: `add_comm a` +#. §77: `a + ? = ? + a` +#. §78: `add_comm a c` +#. §79: `a + c = c + a` +#. §80: `h : X = Y` +#. §81: `rw [h]` +#. §82: `X` +#. §83: `Y` +#. §84: `X` +#. §85: `Y` +#. §86: `nth_rewrite 37 [h]` +#: Game.Levels.Tutorial.L02rw +msgid "" +"## Summary\n" +"\n" +"If §0 is a proof of an equality §1, then §2 will change\n" +"all §3s in the goal to §4s. It's the way to \\\\\"substitute in\\\\\".\n" +"\n" +"## Variants\n" +"\n" +"* §5 (changes §6s to §7s; get the back arrow by typing §8 or §9.)\n" +"\n" +"* §10 (a sequence of rewrites)\n" +"\n" +"* §11 (changes §12s to §13s in hypothesis §14)\n" +"\n" +"* §15 (changes §16s to §17s in two hypotheses and the goal;\n" +"get the §18 symbol with §19.)\n" +"\n" +"* §20 will keep changing §21 to §22\n" +"until there are no more matches for §23.\n" +"\n" +"* §24 will change only the second §25 in the goal to §26.\n" +"\n" +"### Example:\n" +"\n" +"If you have the assumption §27 and your goal is\n" +"§28\n" +"\n" +"then\n" +"\n" +"§29\n" +"\n" +"will change the goal into §30, and then\n" +"\n" +"§31\n" +"\n" +"will change the goal into §32, which\n" +"can be solved with §33.\n" +"\n" +"### Example:\n" +"\n" +"You can use §34 to change a hypothesis as well.\n" +"For example, if you have two hypotheses\n" +"§35\n" +"then §36 will turn §37 into §38.\n" +"\n" +"## Common errors\n" +"\n" +"* You need the square brackets. §39 is never correct.\n" +"\n" +"* If §40 is not a *proof* of an *equality* (a statement of the form §41),\n" +"for example if §42 is a function or an implication,\n" +"then §43 is not the tactic you want to use. For example,\n" +"§44 is never correct: §45 is the theorem *statement*,\n" +"not the proof. If §46 is the proof, then §47 will work.\n" +"\n" +"## Details\n" +"\n" +"The §48 tactic is a way to do \\\\\"substituting in\\\\\". There\n" +"are two distinct situations where you can use this tactic.\n" +"\n" +"1) Basic usage: if §49 is an assumption or\n" +"the proof of a theorem, and if the goal contains one or more §50s, then §51\n" +"will change them all to §52s. The tactic will error\n" +"if there are no §53s in the goal.\n" +"\n" +"2) Advanced usage: Assumptions coming from theorem proofs\n" +"often have missing pieces. For example §54\n" +"is a proof that §55 because §56 really is a function,\n" +"and §57 is the input. In this situation §58 will look through the goal\n" +"for any subterm of the form §59, and the moment it\n" +"finds one it fixes §60 to be §61 then changes all §62s to §63s.\n" +"\n" +"Exercise: think about why §64 changes the term\n" +"§65 to\n" +"§66\n" +"\n" +"If you can't remember the name of the proof of an equality, look it up in\n" +"the list of lemmas on the right.\n" +"\n" +"## Targeted usage\n" +"\n" +"If your goal is §67 and you want to rewrite §68\n" +"to §69, then §70 will not work because Lean finds another\n" +"addition first and swaps those inputs instead. Use §71 to\n" +"guarantee that Lean rewrites §72 to §73. This works because\n" +"§74 is a proof that §75, §76 is a proof\n" +"that §77, and §78 is a proof that §79.\n" +"\n" +"If §80 then §81 will turn all §82s into §83s.\n" +"If you only want to change the 37th occurrence of §84\n" +"to §85 then do §86." +msgstr "" +"## 요약\n" +"\n" +"§0가 등식 §1의 증명이라면 §2는 goal의 모든 §3을 §4로 바꿉니다. 즉 \"대입\"하는 방법입니다.\n" +"\n" +"## 변형\n" +"\n" +"* §5 (§6을 §7로 바꿉니다. 뒤쪽 화살표는 §8 또는 §9를 입력해 얻을 수 있습니다.)\n" +"* §10 (여러 번의 rewrite를 연속으로 수행)\n" +"* §11 (가정 §14 안의 §12를 §13으로 바꿈)\n" +"* §15 (두 가정과 goal에서 §16을 §17로 바꿈. §18 기호는 §19로 입력)\n" +"* §20은 더 이상 §23과 일치하는 것이 없을 때까지 §21을 §22로 계속 바꿉니다.\n" +"* §24는 goal의 두 번째 §25만 §26으로 바꿉니다.\n" +"\n" +"### 예시\n" +"\n" +"가정 §27이 있고 goal이\n" +"§28\n" +"이라면\n" +"\n" +"§29\n" +"\n" +"은 goal을 §30으로 바꾸고, 이어서\n" +"\n" +"§31\n" +"\n" +"은 goal을 §32로 바꿉니다. 이는 §33으로 해결할 수 있습니다.\n" +"\n" +"### 예시\n" +"\n" +"§34를 사용해 가정을 바꿀 수도 있습니다. 예를 들어 두 가정 §35가 있다면 §36은 §37을 §38로 바꿉니다.\n" +"\n" +"## 흔한 오류\n" +"\n" +"* 대괄호가 필요합니다. §39는 절대 올바르지 않습니다.\n" +"* §40이 *등식* §41의 *증명*이 아니라 함수나 함의 같은 것이라면 §43은 원하는 tactic이 아닙니다. 예를 들어 §42가 함수나 함의라면 §44는 절대 올바르지 않습니다. §45는 정리의 *명제*이지 증명이 아닙니다. §46가 증명이라면 §47은 작동합니다.\n" +"\n" +"## 자세한 설명\n" +"\n" +"§48 tactic은 \"대입\"을 하는 방법입니다. 서로 다른 두 상황에서 사용할 수 있습니다.\n" +"\n" +"1) 기본 사용법: §49가 가정이나 정리의 증명이고 goal에 하나 이상의 §50가 있다면 §51은 그 모두를 §52로 바꿉니다. goal에 §53이 하나도 없으면 오류가 납니다.\n" +"\n" +"2) 고급 사용법: 정리의 증명에서 얻은 가정은 인자가 빠져 있는 경우가 많습니다. 예를 들어 §54가 §55의 증명인 것은 §56가 실제로 함수이고 §57이 입력이기 때문입니다. 이 상황에서 §58은 goal에서 §59 꼴의 부분항을 찾고, 찾는 즉시 §60을 §61로 정한 뒤 모든 §62를 §63으로 바꿉니다.\n" +"\n" +"연습: §64가 항 §65를 §66으로 바꾸는 이유를 생각해 보세요.\n" +"\n" +"등식의 증명 이름이 기억나지 않으면 오른쪽 lemma 목록에서 찾아보세요.\n" +"\n" +"## 정확히 지정해서 사용하기\n" +"\n" +"goal이 §67이고 §68을 §69로 rewrite하고 싶다고 합시다. §70은 작동하지 않습니다. Lean이 다른 덧셈을 먼저 찾아 그 입력을 바꾸기 때문입니다. §71을 사용하면 Lean이 반드시 §72를 §73으로 rewrite하게 할 수 있습니다. 이는 §74가 §75의 증명, §76이 §77의 증명, §78이 §79의 증명이기 때문입니다.\n" +"\n" +"§80이라면 §81은 모든 §82를 §83으로 바꿉니다. §84의 37번째 occurrence만 §85로 바꾸고 싶다면 §86을 사용하세요." + +#. §0: `t : P → Q` +#. §1: $P \\implies Q$ +#. §2: `h : P` +#. §3: `P` +#. §4: `apply t at h` +#. §5: `h` +#. §6: `Q` +#. §7: `P` +#. §8: `t` +#. §9: `Q` +#. §10: `Q` +#. §11: `apply t` +#. §12: `P` +#. §13: `Q` +#. §14: `t` +#. §15: `P` +#. §16: `P` +#. §17: `succ_inj x y` +#. §18: `succ x = succ y → x = y` +#. §19: `h : succ (a + 37) = succ (b + 42)` +#. §20: `apply succ_inj at h` +#. §21: `h` +#. §22: `a + 37 = b + 42` +#. §23: `apply succ_inj (a + 37) (b + 42) at h` +#. §24: `succ_inj` +#. §25: `a * b = 7` +#. §26: `apply succ_inj` +#. §27: `succ (a * b) = succ 7` +#: Game.Levels.Implication.L03apply +msgid "" +"## Summary\n" +"\n" +"If §0 is a proof that §1, and §2 is a proof of §3,\n" +"then §4 will change §5 to a proof of §6. The idea is that if\n" +"you know §7 is true, then you can deduce from §8 that §9 is true.\n" +"\n" +"If the *goal* is §10, then §11 will \\\\\"argue backwards\\\\\" and change the\n" +"goal to §12. The idea here is that if you want to prove §13, then by §14\n" +"it suffices to prove §15, so you can reduce the goal to proving §16.\n" +"\n" +"### Example:\n" +"\n" +"§17 is a proof that §18.\n" +"\n" +"So if you have a hypothesis §19\n" +"then §20 will change §21 to §22.\n" +"You could write §23\n" +"but Lean is smart enough to figure out the inputs to §24.\n" +"\n" +"### Example\n" +"\n" +"If the goal is §25, then §26 will turn the\n" +"goal into §27." +msgstr "" +"## 요약\n" +"\n" +"§0가 §1의 증명이고 §2가 §3의 증명이라면 §4는 §5를 §6의 증명으로 바꿉니다. 아이디어는 §7이 참이라는 것을 알면 §8로부터 §9가 참임을 이끌어낼 수 있다는 것입니다.\n" +"\n" +"*goal*이 §10이라면 §11은 \"거꾸로 추론\"해서 goal을 §12로 바꿉니다. §13을 증명하고 싶을 때 §14에 의해 §15만 증명하면 충분하므로 goal을 §16의 증명으로 환원하는 것입니다.\n" +"\n" +"### 예시\n" +"\n" +"§17은 §18의 증명입니다.\n" +"\n" +"따라서 가정 §19가 있다면 §20은 §21을 §22로 바꿉니다. §23이라고 직접 써도 되지만 Lean이 §24의 입력을 알아서 찾아 줍니다.\n" +"\n" +"### 예시\n" +"\n" +"goal이 §25라면 §26은 goal을 §27로 바꿉니다." + +#. §0: $2y=2(x+7)$ +#. §1: `h` +#. §2: $y = x + 7$ +#. §3: `h` +#. §4: `h` +#. §5: `x` +#. §6: `rfl` +#. §7: $y$ +#. §8: `h` +#. §9: `rw` +#: Game.Levels.Tutorial.L02rw +#| msgid "" +#| "In this level the *goal* is §0 but to help us we\n" +#| "have an *assumption* §1 saying that §2. Check that you can see §3 in\n" +#| "your list of assumptions. Lean thinks of §4 as being a secret proof of the\n" +#| "assumption, rather like §5 is a secret number.\n" +#| "\n" +#| "Before we can use §6, we have to \"substitute in for §7\".\n" +#| "We do this in Lean by *rewriting* the proof §8,\n" +#| "using the §9 tactic." +msgid "" +"In this level the *goal* is §0 but to help us we\n" +"have an *assumption* §1 saying that §2. Check that you can see §3 in\n" +"your list of assumptions. Lean thinks of §4 as being a secret proof of the\n" +"assumption, rather like §5 is a secret number.\n" +"\n" +"Before we can use §6, we have to \"substitute in for §7\".\n" +"We do this in Lean by *rewriting* the goal with §8,\n" +"using the §9 tactic." +msgstr "" +"이 level의 *goal*은 §0이지만, 이를 돕기 위해 §2라고 말하는 *가정* §1이 있습니다. 가정 목록에서 §3이 보이는지 확인하세요. Lean은 §4를 이 가정의 비밀스러운 증명이라고 생각합니다. §5가 비밀스러운 수인 것과 비슷합니다.\n" +"\n" +"§6을 쓰기 전에 먼저 \"§7에 대입\"해야 합니다. Lean에서는 §9 tactic을 사용해 증명 §8을 *rewriting*함으로써 이를 수행합니다." + +#. §0: `add_zero a` +#. §1: `a + 0 = a` +#. §2: `add_zero` +#. §3: `add_zero 37` +#. §4: `37 + 0 = 37` +#. §5: `rw` +#. §6: `rw [add_zero]` +#. §7: `add_zero` +#. §8: $\\forall n ∈ ℕ, n + 0 = n$ +#. §9: `n + 0 = n` +#: Game.Levels.Tutorial.L05add_zero +msgid "" +"§0 is a proof that §1.\n" +"\n" +"## Summary\n" +"\n" +"§2 is really a function, which\n" +"eats a number, and returns a proof of a theorem\n" +"about that number. For example §3 is\n" +"a proof that §4.\n" +"\n" +"The §5 tactic will accept §6\n" +"and will try to figure out which number you omitted\n" +"to input.\n" +"\n" +"## Details\n" +"\n" +"A mathematician sometimes thinks of §7\n" +"as \\\\\"one thing\\\\\", namely a proof of §8.\n" +"This is just another way of saying that it's a function which\n" +"can eat any number n and will return a proof that §9." +msgstr "" +"§0는 §1의 증명입니다.\n" +"\n" +"## 요약\n" +"\n" +"§2는 사실 함수입니다. 수 하나를 받아 그 수에 관한 정리의 증명을 반환합니다. 예를 들어 §3은 §4의 증명입니다.\n" +"\n" +"§5 tactic은 §6을 받아 사용자가 생략한 입력 수가 무엇인지 알아내려 합니다.\n" +"\n" +"## 자세한 설명\n" +"\n" +"수학자는 때때로 §7을 §8의 증명이라는 \"하나의 것\"으로 생각합니다. 이는 임의의 수 n을 입력받아 §9의 증명을 돌려주는 함수라는 말과 같습니다." + +#. §0: `h : a ≠ b` +#. §1: `c ≠ d` +#. §2: `contrapose! h` +#. §3: `h : c = d` +#. §4: `a = b` +#: Game.Levels.Algorithm.L07succ_ne_succ +msgid "" +"# Summary\n" +"\n" +"If you have a hypothesis\n" +"\n" +"§0\n" +"\n" +"and goal\n" +"\n" +"§1\n" +"\n" +"then §2 replaces the set-up with its so-called \\\\\"contrapositive\\\\\":\n" +"a hypothesis\n" +"\n" +"§3\n" +"\n" +"and goal\n" +"\n" +"§4." +msgstr "" +"# 요약\n" +"\n" +"가정이\n" +"\n" +"§0\n" +"\n" +"이고 goal이\n" +"\n" +"§1\n" +"\n" +"이라면 §2는 이를 이른바 \"대우\"로 바꿉니다. 즉 가정\n" +"\n" +"§3\n" +"\n" +"과 goal\n" +"\n" +"§4\n" +"\n" +"로 바꿉니다." + +#. §0: `«{hd}» : 0 + «{d}» = «{d}»` +#. §1: `0 + succ «{d}» = succ «{d}»` +#: Game.Levels.Addition.L01zero_add +msgid "" +"Now for the second goal. Here you have the induction hypothesis\n" +"§0, and you need to prove that §1." +msgstr "이제 두 번째 goal입니다. 여기에는 귀납가정 §0가 있고 §1을 증명해야 합니다." + +#. §0: `use` +#. §1: `x` +#. §2: `x = 37` +#. §3: `use 37` +#. §4: `a ≤ b` +#. §5: `c` +#. §6: `b = a + c` +#. §7: `a ≤ b` +#. §8: `use` +#. §9: `b - a` +#. §10: `use b - a` +#. §11: `use` +#. §12: `use 37` +#. §13: `use a` +#. §14: `use a * a + 1` +#: Game.Levels.LessOrEqual.L01le_refl +msgid "" +"## Summary\n" +"\n" +"The §0 tactic makes progress with goals which claim something *exists*.\n" +"If the goal claims that some §1 exists with some property, and you know\n" +"that §2 will work, then §3 will make progress.\n" +"\n" +"Because §4 is notation for \\\\\"there exists §5 such that §6\\\\\",\n" +"you can make progress on goals of the form §7 by §8ing the\n" +"number which is morally §9 (i.e. §10)\n" +"\n" +"Any of the following examples is possible assuming the type of the argument passed to the §11 function is accurate:\n" +"\n" +"- §12\n" +"- §13\n" +"- §14" +msgstr "" +"## 요약\n" +"\n" +"§0 tactic은 어떤 것이 *존재한다*고 주장하는 goal에서 진행할 수 있게 해 줍니다. goal이 어떤 성질을 만족하는 §1이 존재한다고 말하고, §2가 그 역할을 한다는 것을 알고 있다면 §3으로 진행할 수 있습니다.\n" +"\n" +"§4가 \"§6를 만족하는 §5가 존재한다\"의 표기이므로, §7 꼴의 goal에서는 본질적으로 §9인 수(즉 §10)를 §8해서 진행할 수 있습니다.\n" +"\n" +"§11 함수에 주는 인자의 타입이 올바르다면 다음 예시는 모두 가능합니다:\n" +"\n" +"- §12\n" +"- §13\n" +"- §14" + +#~ msgid "§0 is a proof of §1.\"" +#~ msgstr "§0는 §1의 증명입니다." From 72a4f3f05c3b2532104175cdcd628aae37702271 Mon Sep 17 00:00:00 2001 From: SW Date: Sun, 23 Aug 2026 16:38:51 +0900 Subject: [PATCH 2/3] Add Korean translation --- Game.lean | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Game.lean b/Game.lean index a7d76da6..6c6915da 100644 --- a/Game.lean +++ b/Game.lean @@ -102,7 +102,7 @@ Alternatively, if you experience issues / bugs you can also open github issues: -- Dependency Implication → Power -- `Power` uses `≠` which is introduced in `Implication` /-! Information to be displayed on the servers landing page. -/ -Languages "en" "zh" "uk" "it" "fr" +Languages "en" "zh" "uk" "it" "fr" "ko" CaptionShort "The classical introduction game for Lean." CaptionLong "In this game you recreate the natural numbers $\\mathbb{N}$ from the Peano axioms, learning the basics about theorem proving in Lean. From 790424fe29fe49fb3a7c573d010ce586d525a49e Mon Sep 17 00:00:00 2001 From: prime235711 Date: Tue, 25 Aug 2026 20:40:05 +0900 Subject: [PATCH 3/3] Improve Korean translation --- .i18n/ko/Game.json | 400 ++++++++++---------- .i18n/ko/Game.po | 894 ++++++++++++++++++++++++--------------------- 2 files changed, 675 insertions(+), 619 deletions(-) diff --git a/.i18n/ko/Game.json b/.i18n/ko/Game.json index c4981ebf..f596d4fc 100644 --- a/.i18n/ko/Game.json +++ b/.i18n/ko/Game.json @@ -1,11 +1,11 @@ {"≤ World": "≤ 월드", "≠": "≠", "§0 is the natural numbers, just called \\\\\"numbers\\\\\" in this game. It's\ndefined via two rules:\n\n* §1 (zero is a number)\n* §2 (the successor of a number is a number)\n\n## Game Implementation\n\n*The game uses its own copy of the natural numbers, called §3 with notation §4.\nIt is distinct from the Lean natural numbers §5, which should hopefully\nnever leak into the natural number game.*": - "§0는 자연수이며, 이 게임에서는 그냥 \\\"수\\\"라고 부릅니다. 자연수는 다음 두 규칙으로 정의됩니다.\n\n* §1 (0은 수이다)\n* §2 (수의 successor도 수이다)\n\n## 게임 구현\n\n*이 게임은 §3이라는 자체 자연수 타입을 사용하고 이를 §4로 표기합니다. 이는 Lean의 자연수 §5와는 별개이며, Lean의 자연수가 Natural Number Game 안으로 새어 들어오는 일은 없기를 바랍니다.*", + "§0는 자연수이며, 이 게임에서는 그냥 \\\"수\\\"라고 부릅니다. 자연수는 다음 두 규칙으로 정의됩니다.\n\n* §1 (0은 수이다)\n* §2 (수의 다음수도 수이다)\n\n## 게임 구현\n\n*이 게임은 §3이라는 자체 자연수 타입을 사용하고 이를 §4로 표기합니다. 이는 Lean의 자연수 §5와는 별개이며, Lean의 자연수가 Natural Number Game 안으로 새어 들어오는 일은 없기를 바랍니다.*", "§0 is a proof that §1.\n\nNote that when Lean says §2 it means §3.\n\nNote that §4 cannot be proved by \\\\\"pure thought\\\\\":\nfor example subtraction is not associative, as §5 is not\nequal to §6.": "§0는 §1의 증명입니다.\n\nLean이 §2라고 할 때는 §3을 뜻합니다.\n\n§4는 \"순수한 생각\"만으로 증명할 수 없다는 점에 주의하세요. 예를 들어 뺄셈은 결합법칙을 만족하지 않으며 §5와 §6는 같지 않습니다.", "§0 is a proof that §1.\n\n## Summary\n\n§2 is really a function, which\neats a number, and returns a proof of a theorem\nabout that number. For example §3 is\na proof that §4.\n\nThe §5 tactic will accept §6\nand will try to figure out which number you omitted\nto input.\n\n## Details\n\nA mathematician sometimes thinks of §7\nas \\\\\"one thing\\\\\", namely a proof of §8.\nThis is just another way of saying that it's a function which\ncan eat any number n and will return a proof that §9.": - "§0는 §1의 증명입니다.\n\n## 요약\n\n§2는 사실 함수입니다. 수 하나를 받아 그 수에 관한 정리의 증명을 반환합니다. 예를 들어 §3은 §4의 증명입니다.\n\n§5 tactic은 §6을 받아 사용자가 생략한 입력 수가 무엇인지 알아내려 합니다.\n\n## 자세한 설명\n\n수학자는 때때로 §7을 §8의 증명이라는 \"하나의 것\"으로 생각합니다. 이는 임의의 수 n을 입력받아 §9의 증명을 돌려주는 함수라는 말과 같습니다.", + "§0는 §1의 증명입니다.\n\n## 요약\n\n§2는 사실 함수입니다. 수 하나를 받아 그 수에 관한 정리의 증명을 반환합니다. 예를 들어 §3은 §4의 증명입니다.\n\n§5 택틱은 §6을 받아 사용자가 생략한 입력 수가 무엇인지 알아내려 합니다.\n\n## 자세한 설명\n\n수학자는 때때로 §7을 §8의 증명이라는 \"하나의 것\"으로 생각합니다. 이는 임의의 수 n을 입력받아 §9의 증명을 돌려주는 함수라는 말과 같습니다.", "zero_pow_zero": "zero_pow_zero", "zero_pow_succ": "zero_pow_succ", "zero_ne_succ": "zero_ne_succ", @@ -20,10 +20,9 @@ "two_mul": "two_mul", "try rewriting `add_zero`.": "`add_zero`를 rewrite해 보세요.", "the simplest approach": "가장 간단한 접근", - "the rw tactic": "rw tactic", + "the rw tactic": "rw 택틱", "succ_mul": "succ_mul", - "succ_inj : the successor function is injective": - "succ_inj : successor 함수는 단사입니다.", + "succ_inj : the successor function is injective": "succ_inj : 다음수 함수는 단사입니다.", "succ_add": "succ_add", "succ x ≤ succ y → x ≤ y": "succ x ≤ succ y → x ≤ y", "rewriting backwards": "거꾸로 rewriting하기", @@ -49,14 +48,14 @@ "mul_add": "mul_add", "making life simple": "간단하게 만들기", "making life easier": "더 쉽게 만들기", - "level completed! 🎉": "level 완료! 🎉", - "level completed with warnings… 🎭": "level 완료(그러나 경고가 남은…) 🎭", + "level completed! 🎉": "레벨 완료! 🎉", + "level completed with warnings… 🎭": "레벨 완료(그러나 경고가 남은…) 🎭", "le_two": "le_two", "le_mul_right": "le_mul_right", "is_zero": "is_zero", "intro practice": "intro 연습", "intro": "intro", - "intermediate goal solved! 🎉": "중간 goal 해결! 🎉", + "intermediate goal solved! 🎉": "중간 목표 해결! 🎉", "eq_succ_of_ne_zero": "eq_succ_of_ne_zero", "decide again": "decide 다시 사용하기", "decide": "decide", @@ -71,18 +70,18 @@ "add_left_eq_self": "add_left_eq_self", "add_left_comm": "add_left_comm", "add_left_cancel": "add_left_cancel", - "add_comm (level boss)": "add_comm (level boss)", + "add_comm (level boss)": "add_comm (레벨 보스)", "add_assoc (associativity of addition)": "add_assoc (덧셈의 결합법칙)", "`ℕ` is the natural numbers, just called \\\"numbers\\\" in this game. It's\ndefined via two rules:\n\n* `0 : ℕ` (zero is a number)\n* `succ (n : ℕ) : ℕ` (the successor of a number is a number)\n\n## Game Implementation\n\n*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\nIt is distinct from the Lean natural numbers `Nat`, which should hopefully\nnever leak into the natural number game.*": - "`ℕ` is the natural numbers, just called \\\"numbers\\\" in this game. It's\ndefined via two rules:\n\n* `0 : ℕ` (zero is a number)\n* `succ (n : ℕ) : ℕ` (the successor of a number is a number)\n\n## Game Implementation\n\n*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\nIt is distinct from the Lean natural numbers `Nat`, which should hopefully\nnever leak into the natural number game.*", + "`ℕ`은 자연수입니다. 이 게임에서는 간단히 \\\"수\\\"라고 부릅니다. 자연수는\n다음 두 규칙으로 정의됩니다:\n\n* `0 : ℕ` (`0`은 수입니다)\n* `succ (n : ℕ) : ℕ` (어떤 수의 다음수는 수입니다)\n\n## 게임 구현\n\n*이 게임에서는 `ℕ`이라는 표기를 사용하는 `MyNat`이라는 자체적인 자연수 타입을 사용합니다.\n이는 Lean의 자연수 `Nat`과는 별개의 타입이며, `Nat`이 자연수 게임 안으로\n섞여 들어오는 일은 없기를 바랍니다.*", "`zero_ne_succ n` is the proof that `0 ≠ succ n`.\n\nIn Lean, `a ≠ b` is *defined to mean* `a = b → False`. Hence\n`zero_ne_succ n` is really a proof of `0 = succ n → False`.\nHere `False` is a generic false statement. This means that\nyou can `apply zero_ne_succ at h` if `h` is a proof of `0 = succ n`.": "`zero_ne_succ n`는 `0 ≠ succ n`의 증명입니다.\n\nLean에서 `a ≠ b`는 *`a = b → False`을 뜻하도록 정의*되어 있습니다. 따라서 `zero_ne_succ n`는 실제로 `0 = succ n → False`의 증명입니다. 여기서 `False`는 일반적인 거짓 명제입니다. 즉 `h`이 `0 = succ n`의 증명이라면 `apply zero_ne_succ at h`할 수 있습니다.", "`zero_ne_one` is a proof of `0 ≠ 1`.": "`zero_ne_one`는 `0 ≠ 1`의 증명입니다.", "`zero_mul m` is the proof that `0 * m = 0`.\n\nNote: `zero_mul` is a `simp` lemma.": - "`zero_mul m`는 `0 * m = 0`의 증명입니다.\n\n참고: `zero_mul`는 `simp` lemma입니다.", + "`zero_mul m`는 `0 * m = 0`의 증명입니다.\n\n참고: `zero_mul`는 `simp` 정리입니다.", "`zero_le x` is a proof that `0 ≤ x`.": "`zero_le x`는 `0 ≤ x`.의 증명입니다.", "`zero_add n` is the proof of `0 + n = n`.\n\n`zero_add` is a `simp` lemma, because replacing `0 + n` by `n`\nis almost always what you want to do if you're simplifying an expression.": - "`zero_add n`는 `0 + n = n`의 증명입니다.\n\n`zero_add`는 `simp` lemma입니다. 식을 단순화할 때 `0 + n`를 `n`로 바꾸는 것은 거의 항상 우리가 원하는 일이기 때문입니다.", + "`zero_add n`는 `0 + n = n`의 증명입니다.\n\n`zero_add`는 `simp` 정리입니다. 식을 단순화할 때 `0 + n`를 `n`로 바꾸는 것은 거의 항상 우리가 원하는 일이기 때문입니다.", "`xyzzy` is an ancient magic spell, believed to be the origin of the\nmodern word `sorry`. The game won't complain - or notice - if you\nprove anything with `xyzzy`.": "`xyzzy`는 고대의 마법 주문으로, 현대의 단어 `sorry`의 기원이라고 전해집니다. `xyzzy`로 무엇을 증명하든 게임은 불평하지도, 알아차리지도 못합니다.", "`two_mul m` is the proof that `2 * m = m + m`.": @@ -117,11 +116,11 @@ "`pow_succ a b : a ^ (succ b) = a ^ b * a` is one of the\ntwo axioms defining exponentiation in this game.": "`pow_succ a b : a ^ (succ b) = a ^ b * a`는 이 게임에서 거듭제곱을 정의하는 두 공리 중 하나입니다.", "`pow_pow a m n` is a proof that $(a^m)^n=a^{mn}.$": - "`pow_pow a m n`는 $(a^m)^n=a^{mn}.$의 증명입니다.", + "`pow_pow a m n`는 $(a^m)^n=a^{mn}$의 증명입니다.", "`pow_one a` says that `a ^ 1 = a`.\n\nNote that this is not quite true by definition: `a ^ 1` is\ndefined to be `a ^ 0 * a` so it's `1 * a`, and to prove\nthat this is equal to `a` you need to use induction somewhere.": - "`pow_one a`는 `a ^ 1 = a`이라고 말합니다.\n\n정의만으로 바로 참인 것은 아닙니다. `a ^ 1`는 `a ^ 0 * a`으로 정의되므로 `1 * a`이고, 이것이 `a`와 같음을 보이려면 어딘가에서 귀납법을 사용해야 합니다.", + "`pow_one a`는 `a ^ 1 = a`라는 뜻입니다.\n\n이는 정의만으로 바로 참인 것은 아닙니다. `a ^ 1`은\n`a ^ 0 * a`로 정의되므로 `1 * a`이고, 이것이 `a`와 같다는 것을\n보이려면 어딘가에서 귀납법을 사용해야 합니다.", "`pow_add a m n` is a proof that $a^{m+n}=a^ma^n.$": - "`pow_add a m n`는 $a^{m+n}=a^ma^n.$의 증명입니다.", + "`pow_add a m n`는 $a^{m+n}=a^ma^n$의 증명입니다.", "`one_pow n` is a proof that $1^n=1$.": "`one_pow n`는 $1^n=1$.의 증명입니다.", "`one_ne_zero` is a proof that `1 ≠ 0`.": "`one_ne_zero`는 `1 ≠ 0`.의 증명입니다.", "`one_mul m` is the proof `1 * m = m`.": "`one_mul m`는 `1 * m = m`의 증명입니다.", @@ -140,7 +139,7 @@ "`mul_right_eq_one a b` is a proof that `a * b = 1 → a = 1`.": "`mul_right_eq_one a b`는 `a * b = 1 → a = 1`.의 증명입니다.", "`mul_pow a b n` is a proof that $(ab)^n=a^nb^n.$": - "`mul_pow a b n`는 $(ab)^n=a^nb^n.$의 증명입니다.", + "`mul_pow a b n`는 $(ab)^n=a^nb^n$의 증명입니다.", "`mul_one m` is the proof that `m * 1 = m`.": "`mul_one m`는 `m * 1 = m`의 증명입니다.", "`mul_ne_zero a b` is a proof that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`.": @@ -156,25 +155,25 @@ "`mul_comm` is the proof that multiplication is commutative. More precisely,\n`mul_comm a b` is the proof that `a * b = b * a`.": "`mul_comm`는 곱셈이 가환이라는 것의 증명입니다. 더 정확히는 `mul_comm a b`이 `a * b = b * a`의 증명입니다.", "`mul_assoc a b c` is a proof that `(a * b) * c = a * (b * c)`.\n\nNote that when Lean says `a * b * c` it means `(a * b) * c`.\n\nNote that `(a * b) * c = a * (b * c)` cannot be proved by \\\"pure thought\\\":\nfor example subtraction is not associative, as `(6 - 2) - 1` is not\nequal to `6 - (2 - 1)`.": - "`mul_assoc a b c`는 `(a * b) * c = a * (b * c)`.\n\nNote that when Lean says `a * b * c` it means `(a * b) * c`.\n\nNote that `(a * b) * c = a * (b * c)` cannot be proved by \\\"pure thought\\\":\nfor example subtraction is not associative, as `(6 - 2) - 1` is not\nequal to `6 - (2 - 1)`.의 증명입니다.", + "`mul_assoc a b c`는 `(a * b) * c = a * (b * c)`의 증명입니다.\n\n참고로 Lean 코드에서의 `a * b * c`의 의미는 `(a * b) * c`입니다.\n\n참고로 `(a * b) * c = a * (b * c)`는 \\\"단순 생각\\\"만으로 증명할 수 없습니다:\n예를 들어 뺄셈은 결합적이지 않죠. `(6 - 2) - 1`가 `6 - (2 - 1)`이 아니듯이요.", "`le_zero x` is a proof of the implication `x ≤ 0 → x = 0`.": - "`le_zero x`는 함의 `x ≤ 0 → x = 0`의 증명입니다.", + "`le_zero x`는 조건문 `x ≤ 0 → x = 0`의 증명입니다.", "`le_zero x` is a proof of `x ≤ 0 → x = 0`.": "`le_zero x`는 `x ≤ 0 → x = 0`의 증명입니다.", "`le_two x` is a proof that if `x ≤ 2` then `x = 0` or `x = 1` or `x = 2`.": "`le_two x`는 `x ≤ 2`이면 `x = 0` 또는 `x = 1` 또는 `x = 2`라는 것의 증명입니다.", "`le_trans x y z` is a proof that if `x ≤ y` and `y ≤ z` then `x ≤ z`.\nMore precisely, it is a proof that `x ≤ y → (y ≤ z → x ≤ z)`. In words,\nIf $x \\le y$ then (pause) if $y \\le z$ then $x \\le z$.\n\n## A note on associativity\n\nIn Lean, `a + b + c` means `(a + b) + c`, because `+` is left associative. However\n`→` is right associative. This means that `x ≤ y → y ≤ z → x ≤ z` in Lean means\nexactly that `≤` is transitive. This is different to how mathematicians use\n$P \\implies Q \\implies R$; for them, this usually means that $P \\implies Q$\nand $Q \\implies R$.": - "`le_trans x y z`는 `x ≤ y`이고 `y ≤ z`이면 `x ≤ z`이라는 것의 증명입니다. 더 정확히는 `x ≤ y → (y ≤ z → x ≤ z)`의 증명입니다. 말로 하면 \"$x \\le y$이면, (잠깐 쉬고) $y \\le z$이면 $x \\le z$\"입니다.\n\n## 결합법칙에 관한 주의\n\nLean에서 `a + b + c`은 `(a + b) + c`를 뜻합니다. `x ≤ y`0이 왼쪽 결합이기 때문입니다. 하지만 `x ≤ y`1은 오른쪽 결합입니다. 따라서 Lean에서 `x ≤ y`2는 정확히 `x ≤ y`3이 추이적이라는 뜻입니다. 이는 수학자들이 `x ≤ y`4를 쓰는 방식과 다릅니다. 수학자에게는 보통 `x ≤ y`5이고 `x ≤ y`6이라는 뜻입니다.", + "`le_trans x y z`는 `x ≤ y`이고 `y ≤ z`이면 `x ≤ z`이라는 것의 증명입니다. 더 정확히는 `x ≤ y → (y ≤ z → x ≤ z)`의 증명입니다. 말로 하면 \"$x \\le y$이면, (잠깐 쉬고) $y \\le z$이면 $x \\le z$\"입니다.\n\n## 결합법칙에 관한 사항\n\nLean에서 `a + b + c`은 `(a + b) + c`를 뜻합니다.\n`+`이 좌결합적(왼쪽부터 계산하는 우선순위를 따름)이기 때문입니다. 하지만 `→`은 우결합적(오른쪽부터 해석하는 우선순위를 따름)입니다.\n따라서 Lean에서 `x ≤ y → y ≤ z → x ≤ z`는 정확히 `≤`이 추이적이라는 뜻입니다. 이는 수학자들이 $P \\implies Q \\implies R$를 쓰는 방식과 다릅니다. 수학자에게는 보통 $P \\implies Q$이고 $Q \\implies R$이라는 뜻입니다.\n즉, 수학자들은 `→`를 좌결합적으로 사용합니다.", "`le_total x y` is a proof that `x ≤ y` or `y ≤ x`.": "`le_total x y`는 `x ≤ y` 또는 `y ≤ x`의 증명입니다.", "`le_succ_self x` is a proof that `x ≤ succ x`.": "`le_succ_self x`는 `x ≤ succ x`.의 증명입니다.", "`le_refl x` is a proof of `x ≤ x`.\n\nThe reason for the name is that this lemma is \"reflexivity of $\\le$\"": - "`le_refl x`는 `x ≤ x`의 증명입니다.\n\n이 이름은 이 lemma가 \"$\\le$의 반사성(reflexivity)\"을 나타내기 때문에 붙었습니다.", + "`le_refl x`는 `x ≤ x`의 증명입니다.\n\n이 이름은 이 정리가 \"$\\le$의 반사성(reflexivity)\"을 나타내기 때문에 붙었습니다.", "`le_one x` is a proof that if `x ≤ 1` then `x = 0` or `x = 1`.": "`le_one x`는 `x ≤ 1`이면 `x = 0` 또는 `x = 1`이라는 것의 증명입니다.", "`le_mul_right a b` is a proof that `a * b ≠ 0 → a ≤ a * b`.\n\nIt's one way of saying that a divisor of a positive number\nhas to be at most that number.": - "`le_mul_right a b`는 `a * b ≠ 0 → a ≤ a * b`의 증명입니다.\n\n양수의 약수는 그 수 이하이어야 한다는 사실을 표현하는 한 방법입니다.", + "`le_mul_right a b`는 `a * b ≠ 0 → a ≤ a * b`의 증명입니다.\n\n이는 어떤 양수의 약수는 그 수 이하라는 것을 의미합니다.", "`le_antisymm x y` is a proof that if `x ≤ y` and `y ≤ x` then `x = y`.": "`le_antisymm x y`는 `x ≤ y`이고 `y ≤ x`이면 `x = y`이라는 것의 증명입니다.", "`is_zero_zero` is a proof of `is_zero 0 = True`.": @@ -193,68 +192,68 @@ "`add_succ a b` is the proof of `a + succ b = succ (a + b)`.": "`add_succ a b`는 `a + succ b = succ (a + b)`의 증명입니다.", "`add_sq a b` is the statement that $(a+b)^2=a^2+b^2+2ab.$": - "`add_sq a b`는 $(a+b)^2=a^2+b^2+2ab.$이라는 명제입니다.", + "`add_sq a b`는 $(a+b)^2=a^2+b^2+2ab$이라는 명제입니다.", "`add_right_eq_self x y` is the theorem that $x + y = x\\implies y=0.$\nTwo ways to do it spring to mind; I'll mention them when you've solved it.": - "`add_right_eq_self x y`는 $x + y = x\\implies y=0.$이라는 정리입니다. 두 가지 방법이 떠오르는데, 해결하고 나면 말씀드리겠습니다.", + "`add_right_eq_self x y`는 $x + y = x\\implies y=0$이라는 정리입니다. 두 가지 방법이 떠오르는데, 해결하고 나면 말씀드리겠습니다.", "`add_right_eq_self x y` is the theorem that $x + y = x \\implies y=0.$": - "`add_right_eq_self x y`는 $x + y = x \\implies y=0.$이라는 정리입니다.", + "`add_right_eq_self x y`는 $x + y = x \\implies y=0$이라는 정리입니다.", "`add_right_comm a b c` is a proof that `(a + b) + c = (a + c) + b`\n\nIn Lean, `a + b + c` means `(a + b) + c`, so this result gets displayed\nas `a + b + c = a + c + b`.": "`add_right_comm a b c`는 `(a + b) + c = (a + c) + b`의 증명입니다.\n\nLean에서 `a + b + c`는 `(a + b) + c`을 뜻하므로 이 결과는 `a + b + c = a + c + b`처럼 표시됩니다.", "`add_right_cancel a b n` is the theorem that $a+n=b+n \\implies a=b.$": - "`add_right_cancel a b n`는 $a+n=b+n \\implies a=b.$이라는 정리입니다.", + "`add_right_cancel a b n`는 $a+n=b+n \\implies a=b$이라는 정리입니다.", "`add_mul` is just as fiddly to prove by induction; but there's a trick\nwhich avoids it. Can you spot it?": "`add_mul`도 귀납법으로 증명하려면 꽤 번거롭습니다. 하지만 이를 피하는 요령이 하나 있습니다. 찾을 수 있나요?", "`add_mul a b c` is a proof that $(a+b)c=ac+bc$.": "`add_mul a b c`는 $(a+b)c=ac+bc$.의 증명입니다.", "`add_left_eq_self x y` is the theorem that $x + y = y\\implies x=0.$": - "`add_left_eq_self x y`는 $x + y = y\\implies x=0.$이라는 정리입니다.", + "`add_left_eq_self x y`는 $x + y = y\\implies x=0$이라는 정리입니다.", "`add_left_eq_self x y` is the theorem that $x + y = y \\implies x=0.$": - "`add_left_eq_self x y`는 $x + y = y \\implies x=0.$이라는 정리입니다.", + "`add_left_eq_self x y`는 $x + y = y \\implies x=0$이라는 정리입니다.", "`add_left_comm a b c` is a proof that `a + (b + c) = b + (a + c)`.": "`add_left_comm a b c`는 `a + (b + c) = b + (a + c)`.의 증명입니다.", "`add_left_cancel a b n` is the theorem that $n+a=n+b\\implies a=b$.\nYou can prove it by induction on `n` or you can deduce it from `add_right_cancel`.": "`add_left_cancel a b n`는 $n+a=n+b\\implies a=b$이라는 정리입니다. `n`에 대해 귀납해도 되고 `add_right_cancel`에서 이끌어내도 됩니다.", "`add_left_cancel a b n` is the theorem that $n+a=n+b \\implies a=b.$": - "`add_left_cancel a b n`는 $n+a=n+b \\implies a=b.$이라는 정리입니다.", + "`add_left_cancel a b n`는 $n+a=n+b \\implies a=b$이라는 정리입니다.", "`add_comm b c` is a proof that `b + c = c + b`. But if your goal\nis `a + b + c = a + c + b` then `rw [add_comm b c]` will not\nwork! Because the goal means `(a + b) + c = (a + c) + b` so there\nis no `b + c` term *directly* in the goal.\n\nUse associativity and commutativity to prove `add_right_comm`.\nYou don't need induction. `add_assoc` moves brackets around,\nand `add_comm` moves variables around.\n\nRemember that you can do more targeted rewrites by\nadding explicit variables as inputs to theorems. For example `rw [add_comm b]`\nwill only do rewrites of the form `b + ? = ? + b`, and `rw [add_comm b c]`\nwill only do rewrites of the form `b + c = c + b`.": - "`add_comm b c`는 `b + c = c + b`의 증명입니다. 하지만 goal이 `a + b + c = a + c + b`라면 `rw [add_comm b c]`은 작동하지 않습니다! goal의 뜻이 `(a + b) + c = (a + c) + b`이므로 goal 안에 `b + c` 항이 *직접* 나타나지 않기 때문입니다.\n\n결합법칙과 가환법칙을 이용해 `add_right_comm`을 증명하세요. 귀납법은 필요 없습니다. `add_assoc`은 괄호를 옮기고 `add_comm`은 변수의 순서를 바꿉니다.\n\n정리를 적용할 때 변수를 명시하면 더 정밀한 rewrite를 할 수 있다는 점을 기억하세요. 예를 들어 `rw [add_comm b]`는 `b + c = c + b`0 꼴만 rewrite하고, `b + c = c + b`1은 `b + c = c + b`2 꼴만 rewrite합니다.", + "`add_comm b c`는 `b + c = c + b`의 증명입니다. 하지만 목표가 `a + b + c = a + c + b`라면 `rw [add_comm b c]`은 작동하지 않습니다! goal의 뜻이 `(a + b) + c = (a + c) + b`이므로 goal 안에 `b + c` 항이 *직접* 나타나지 않기 때문입니다.\n\n결합법칙과 가환법칙을 이용해 `add_right_comm`을 증명하세요. 귀납법은 필요 없습니다. `add_assoc`은 괄호를 옮기고 `add_comm`은 변수의 순서를 바꿉니다.\n\n정리를 적용할 때 변수를 명시하면 더 정밀한 rewrite를 할 수 있다는 점을 기억하세요. 예를 들어 `rw [add_comm b]`는\n`b + ? = ? + b` 꼴만 rewrite하고, `rw [add_comm b c]`은 `b + c = c + b` 꼴만 rewrite합니다.", "`add_comm a b` is a proof of `a + b = b + a`.": "`add_comm a b`는 `a + b = b + a`의 증명입니다.", "`add_assoc a b c` is a proof\nthat `(a + b) + c = a + (b + c)`. Note that in Lean `(a + b) + c` prints\nas `a + b + c`, because the notation for addition is defined to be left\nassociative.": "`add_assoc a b c`는 `(a + b) + c = a + (b + c)`의 증명입니다. Lean에서는 덧셈 표기가 왼쪽 결합으로 정의되어 있기 때문에 `(a + b) + c`가 `a + b + c`처럼 출력됩니다.", "`a ≤ b` is *notation* for `∃ c, b = a + c`. This \"backwards E\"\nmeans \"there exists\". So `a ≤ b` means that there exists\na number `c` such that `b = a + c`. This definition works\nbecause there are no negative numbers in this game.\n\nTo *prove* an \"exists\" statement, use the `use` tactic.\nLet's see an example.": - "`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다. 이 \"거꾸로 된 E\"는 \"존재한다\"는 뜻입니다. 따라서 `a ≤ b`는 `b = a + c`를 만족하는 수 `c`가 존재한다는 뜻입니다. 이 게임에는 음수가 없으므로 이 정의가 작동합니다.\n\n\"존재한다\"는 명제를 *증명*하려면 `use` tactic을 사용합니다. 예시를 봅시다.", + "`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다. 이 \"거꾸로 된 E\"는 \"존재한다\"는 뜻입니다. 따라서 `a ≤ b`는 `b = a + c`를 만족하는 수 `c`가 존재한다는 뜻입니다. 이 게임에는 음수가 없으므로 이 정의가 작동합니다.\n\n\"존재한다\"는 명제를 *증명*하려면 `use` 택틱을 사용합니다. 예시를 봅시다.", "`a ≤ b` is *notation* for `∃ c, b = a + c`.\n\nBecause this game doesn't have negative numbers, this definition\nis mathematically valid.\n\nThis means that if you have a goal of the form `a ≤ b` you can\nmake progress with the `use` tactic, and if you have a hypothesis\n`h : a ≤ b`, you can make progress with `cases h with c hc`.": - "`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다.\n\n이 게임에는 음수가 없으므로 이 정의는 수학적으로 타당합니다.\n\n따라서 `a ≤ b` 꼴의 goal이 있으면 `use` tactic으로 진행할 수 있고, 가정 `h : a ≤ b`가 있으면 `cases h with c hc`로 진행할 수 있습니다.", + "`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다.\n\n이 게임에는 음수가 없으므로 이 정의는 수학적으로 타당합니다.\n\n따라서 `a ≤ b` 꼴의 목표가 있으면 `use` 택틱으로 진행할 수 있고, 가정 `h : a ≤ b`가 있으면 `cases h with c hc`로 진행할 수 있습니다.", "`a ≠ b` is *notation* for `(a = b) → False`.\n\nThe reason this is mathematically\nvalid is that if `P` is a true-false statement then `P → False`\nis the logical opposite of `P`. Indeed `True → False` is false,\nand `False → False` is true!\n\nThe upshot of this is that you can treat `a ≠ b` in exactly\nthe same way as you treat any implication `P → Q`. For example,\nif your *goal* is of the form `a ≠ b` then you can make progress\nwith `intro h`, and if you have a hypothesis `h` of the\nform `a ≠ b` then you can `apply h at h1` if `h1` is a proof\nof `a = b`.": - "`a ≠ b`는 `(a = b) → False`의 *다른 표현*입니다.\n\n이것이 수학적으로 타당한 이유는 `P`가 참/거짓 명제라면 `P → False`이 `P`의 논리적 반대이기 때문입니다. 실제로 `True → False`는 거짓이고 `False → False`는 참입니다!\n\n따라서 `a ≠ b`은 다른 함의 `P → Q`과 똑같이 다룰 수 있습니다. 예를 들어 *goal*이 `a ≠ b` 꼴이라면 `(a = b) → False`0으로 진행할 수 있고, `(a = b) → False`2 꼴의 가정 `(a = b) → False`1이 있다면 `(a = b) → False`4가 `(a = b) → False`5의 증명일 때 `(a = b) → False`3할 수 있습니다.", + "`a ≠ b`는 `(a = b) → False`의 *다른 표현*입니다.\n\n이것이 수학적으로 타당한 이유는 `P`가 참/거짓 명제라면 `P → False`이 `P`의 논리적 반대이기 때문입니다. 실제로 `True → False`는 거짓이고 `False → False`는 참입니다!\n\n따라서 `a ≠ b`는 다른 함의 `P → Q`와 완전히 같은 방식으로 다룰 수 있습니다.\n예를 들어 *목표*가 `a ≠ b` 꼴이라면 `intro h`를 사용해 진행할 수 있습니다.\n또 `a ≠ b` 꼴의 가정 `h`가 있고, `h1`이 `a = b`의 증명이라면\n`apply h at h1`을 사용할 수 있습니다.", "`Pow a b`, with notation `a ^ b`, is the usual\n exponentiation of natural numbers. Internally it is\n defined via two axioms:\n\n * `pow_zero a : a ^ 0 = 1`\n\n * `pow_succ a b : a ^ succ b = a ^ b * a`\n\nNote in particular that `0 ^ 0 = 1`.": - "`Pow a b`는 `a ^ b`로 표기하며 자연수의 보통 거듭제곱입니다. 내부적으로는 두 공리로 정의됩니다.\n\n * `pow_zero a : a ^ 0 = 1`\n\n * `pow_succ a b : a ^ succ b = a ^ b * a`\n\n특히 `0 ^ 0 = 1`라는 점에 주의하세요.", + "`Pow a b`는 `a ^ b`로 표기하며 자연수의 보통 거듭제곱입니다. 내부적으로는 다음 두 공리로 정의됩니다.\n\n * `pow_zero a : a ^ 0 = 1`\n\n * `pow_succ a b : a ^ succ b = a ^ b * a`\n\n특히 `0 ^ 0 = 1`라는 점에 주의하세요.", "`Mul a b`, with notation `a * b`, is the usual\n product of natural numbers. Internally it is\n via two axioms:\n\n * `mul_zero a : a * 0 = 0`\n\n * `mul_succ a b : a * succ b = a * b + a`\n\nOther theorems about naturals, such as `zero_mul`,\nare proved by induction from these two basic theorems.": "`Mul a b`는 `a * b`로 표기하며 자연수의 보통 곱셈입니다. 내부적으로 두 공리로 정의됩니다.\n\n * `mul_zero a : a * 0 = 0`\n\n * `mul_succ a b : a * succ b = a * b + a`\n\n`zero_mul` 같은 자연수에 관한 다른 정리들은 이 두 기본 정리에서 귀납법으로 증명합니다.", "`Add a b`, with notation `a + b`, is\nthe usual sum of natural numbers. Internally it is defined\nvia the following two hypotheses:\n\n* `add_zero a : a + 0 = a`\n\n* `add_succ a b : a + succ b = succ (a + b)`\n\nOther theorems about naturals, such as `zero_add a : 0 + a = a`, are proved\nby induction using these two basic theorems.": "`Add a b`는 `a + b`로 표기하며 자연수의 보통 덧셈입니다. 내부적으로는 다음 두 가정으로 정의됩니다.\n\n* `add_zero a : a + 0 = a`\n\n* `add_succ a b : a + succ b = succ (a + b)`\n\n`zero_add a : 0 + a = a` 같은 자연수에 관한 다른 정리들은 이 두 기본 정리를 이용한 귀납법으로 증명합니다.", - "[final boss music]": "[final boss 음악]", + "[final boss music]": "[최종 보스 음악]", "[dramatic music]. Now are you ready to face the first boss of the game?": - "[극적인 음악]. 이제 게임의 첫 boss를 상대할 준비가 되었나요?", + "[극적인 음악]. 이제 게임의 첫 보스를 상대할 준비가 되었나요?", "[boss battle music]\n\nLook in your inventory to see the proofs you have available.\nThese should be enough.": - "[boss battle 음악]\n\ninventory를 보고 사용할 수 있는 증명들을 확인하세요. 이것이면 충분할 겁니다.", + "[보스 전투 음악]\n\n인벤토리를 보고 사용할 수 있는 증명들을 확인하세요. 이것들로 충분할 겁니다.", "You've now seen all the tactics you need to beat the final boss of the game.\nYou can begin the journey towards this boss by entering Multiplication World.\n\nOr you can go off the beaten track and learn some new tactics in Implication\nWorld. These tactics let you prove more facts about addition, such as\nhow to deduce `a = 0` from `x + a = x`.\n\nClick \"Home\" and make your choice.": - "이제 게임의 final boss를 이기는 데 필요한 tactic을 모두 배웠습니다. Multiplication World로 들어가 boss를 향한 여정을 시작할 수 있습니다.\n\n또는 정석 길을 벗어나 Implication World에서 새 tactic을 배울 수도 있습니다. 이 tactic들을 이용하면 `x + a = x`에서 `a = 0`를 이끌어내는 법처럼 덧셈에 관한 더 많은 사실을 증명할 수 있습니다.\n\n\"Home\"을 누르고 선택하세요.", + "이제 게임의 최종 보스를 이기는 데 필요한 택틱을 모두 배웠습니다. 곱셈 월드로 들어가 보스를 향한 여정을 시작할 수 있습니다.\n\n또는 정석 길을 벗어나 조건문 월드에서 새 택틱을 배울 수도 있습니다. 이 택틱들을 이용하면 `x + a = x`에서 `a = 0`를 이끌어내는 법처럼 덧셈에 관한 더 많은 사실을 증명할 수 있습니다.\n\n\"홈\"을 누르고 선택하세요.", "You want to use `add_right_eq_zero`, which you already\nproved, but you'll have to start with `symm at` your hypothesis.": "이미 증명한 `add_right_eq_zero`를 쓰고 싶지만, 먼저 가정에 `symm at`을 적용해야 합니다.", "You still don't know which way to go, so do `cases «{e}» with a`.": "아직 어느 쪽으로 가야 할지 모르므로 `cases «{e}» with a`를 하세요.", "You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey.": - "이제 `2 + 2 = 4`를 증명할 tactic을 충분히 알고 있습니다! 여정을 시작합시다.", + "이제 `2 + 2 = 4`를 증명할 택틱을 충분히 알고 있습니다! 여정을 시작합시다.", "You might want to think about whether induction\non `a` or `b` is the best idea.": "`a`와 `b` 중 어느 것에 귀납하는 편이 더 좋은지 생각해 보세요.", "You can use `rw [zero_add] at «{h}»` to rewrite at `«{h}»` instead\nof at the goal.": - "`rw [zero_add] at «{h}»`를 사용하면 goal이 아니라 `«{h}»`에서 rewrite할 수 있습니다.", + "`rw [zero_add] at «{h}»`를 사용하면 목표가 아니라 `«{h}»`에서 rewrite할 수 있습니다.", "You can start a proof by induction on `n` by typing:\n`induction n with d hd`.": "`n`에 대한 귀납 증명은 다음처럼 시작할 수 있습니다:\n`induction n with d hd`.", "You can read more about the `decide` tactic by clicking\non it in the top right.": - "오른쪽 위에서 `decide` tactic을 클릭하면 자세한 설명을 읽을 수 있습니다.", + "오른쪽 위에서 `decide` 택틱을 클릭하면 자세한 설명을 읽을 수 있습니다.", "You can put a `←` in front of any theorem provided to `rw` to rewrite\nthe other way around. Look at the docs for `rw` for an explanation. Type `←` with `\\l`.": "`rw`에 주는 어떤 정리 앞에도 `←`를 붙이면 반대 방향으로 rewrite할 수 있습니다. 설명은 `rw` 문서를 보세요. `←`은 `\\l`로 입력합니다.", "You can prove $1\\times m=m$ in at least three ways.\nEither by induction, or by using `succ_mul`, or\nby using commutativity. Which do you think is quickest?": @@ -264,66 +263,66 @@ "You can now `apply mul_left_cancel at h`": "이제 `apply mul_left_cancel at h`를 할 수 있습니다.", "You can make your own tactics in Lean.\nThis code here\n```\nmacro \"simp_add\" : tactic => `(tactic|(\n simp only [add_assoc, add_left_comm, add_comm]))\n```\nwas used to create a new tactic `simp_add`, which runs\n`simp only [add_assoc, add_left_comm, add_comm]`.\nTry running `simp_add` to solve this level!": - "Lean에서는 자신만의 tactic을 만들 수 있습니다. 여기의 코드\n```\nmacro \"simp_add\" : tactic => `(tactic|(\n simp only [add_assoc, add_left_comm, add_comm]))\n```\n로 새로운 tactic `simp_add`을 만들었고, 이 tactic은 `simp only [add_assoc, add_left_comm, add_comm]`를 실행합니다. `simp_add`을 실행해서 이 level을 해결해 보세요!", + "Lean에서는 자신만의 택틱을 만들 수 있습니다. 여기의 코드\n```\nmacro \"simp_add\" : tactic => `(tactic|(\n simp only [add_assoc, add_left_comm, add_comm]))\n```\n로 새로운 택틱 `simp_add`을 만들었고, 이 택틱은 `simp only [add_assoc, add_left_comm, add_comm]`를 실행합니다. `simp_add`을 실행해서 이 레벨을 해결해 보세요!", "You can just mimic the previous proof to do this one -- or you can figure out a way\nof using it.": "이전 증명을 그대로 흉내 내도 되고, 그 결과를 이용하는 방법을 찾아도 됩니다.", "You can do induction on any of the three variables. Some choices\nare harder to push through than others. Can you do the inductive step in\n5 rewrites only?": "세 변수 중 어느 것에 대해서든 귀납할 수 있습니다. 어떤 선택은 다른 선택보다 더 어렵습니다. 귀납 단계를 rewrite 5번만으로 할 수 있나요?", "Why did we not just define `succ n` to be `n + 1`? Because we have not\neven *defined* addition yet! We'll do that in the next level.": - "왜 `succ n`를 그냥 `n + 1`로 정의하지 않았을까요? 아직 덧셈 자체를 *정의하지 않았기* 때문입니다! 다음 level에서 하겠습니다.", + "왜 `succ n`를 그냥 `n + 1`로 정의하지 않았을까요? 아직 덧셈 자체를 *정의하지 않았기* 때문입니다! 다음 레벨에서 하겠습니다.", "What do you think of this two-liner:\n```\nsymm\nexact zero_ne_one\n```\n\n`exact` doesn't just take hypotheses, it will eat any proof which exists\nin the system.": "이 두 줄짜리 증명은 어떤가요?\n```\nsymm\nexact zero_ne_one\n```\n\n`exact`은 가정만 받는 것이 아니라 시스템에 존재하는 어떤 증명이든 받아들입니다.", "Well done! You now have enough tools to tackle the main boss of this level.": - "잘했습니다! 이제 이 level의 main boss에 도전할 도구가 충분합니다.", + "잘했습니다! 이제 이 레벨의 메인 보스에 도전할 도구가 충분합니다.", "Well done!": "잘했습니다!", "Welcome to tutorial world! In this world we learn the basics\nof proving theorems. The boss level of this world\nis the theorem `2 + 2 = 4`.\n\nYou prove theorems by solving puzzles using tools called *tactics*.\nThe aim is to prove the theorem by applying tactics\nin the right order.\n\nLet's learn some basic tactics. Click on \"Start\" below\nto begin your quest.": - "Tutorial World에 오신 것을 환영합니다! 이 world에서는 정리를 증명하는 기초를 배웁니다. 이 world의 boss level은 정리 `2 + 2 = 4`입니다.\n\n정리는 *tactic*이라는 도구를 이용해 퍼즐을 풀듯 증명합니다. tactic들을 올바른 순서로 적용해 정리를 증명하는 것이 목표입니다.\n\n기본적인 tactic 몇 가지를 배워 봅시다. 아래의 \"Start\"를 눌러 여정을 시작하세요.", + "튜토리얼 월드에 오신 것을 환영합니다! 이 월드에서는 정리를 증명하는 기초를 배웁니다. 이 월드의 보스 레벨은 정리 `2 + 2 = 4`입니다.\n\n정리는 *택틱*이라는 도구를 이용해 퍼즐을 풀듯 증명합니다. 택틱들을 올바른 순서로 적용해 정리를 증명하는 것이 목표입니다.\n\n기본적인 택틱 몇 가지를 배워 봅시다. 아래의 \"시작하기\"를 눌러 여정을 시작하세요.", "Welcome to Addition World! In this world we'll learn the `induction` tactic.\nThis will enable us to defeat the boss level of this world, namely `x + y = y + x`.\n\nThe tactics `rw`, `rfl` and `induction` are the only tactics you'll need to\nbeat all the levels in Addition World, Multiplication World, and Power World.\nPower World contains the final boss of the game.\n\nThere are plenty more tactics in this game, but you'll only need to know them if you\nwant to explore the game further (for example if you decide to 100%\nthe game).": - "Addition World에 오신 것을 환영합니다! 이 world에서는 `induction` tactic을 배웁니다. 이를 이용해 이 world의 boss level인 `x + y = y + x`을 쓰러뜨릴 수 있습니다.\n\n`rw`, `rfl`, `induction` 세 tactic만 알면 Addition World, Multiplication World, Power World의 모든 level을 깰 수 있습니다. Power World에는 이 게임의 final boss가 있습니다.\n\n이 게임에는 훨씬 많은 tactic이 있지만, 더 깊이 탐험하고 싶을 때만 필요합니다(예를 들어 게임을 100% 완료하고 싶을 때).", + "덧셈 월드에 오신 것을 환영합니다! 이 월드에서는 `induction` 택틱을 배웁니다. 이를 이용해 이 월드의 보스 레벨인 `x + y = y + x`을 쓰러뜨릴 수 있습니다.\n\n`rw`, `rfl`, `induction` 세 택틱만 알면 덧셈 월드, 곱셈 월드, 지수 월드의 모든 레벨을 깰 수 있습니다. 지수 월드에는 이 게임의 최종 보스가 있습니다.\n\n이 게임에는 훨씬 많은 택틱이 있지만, 더 깊이 탐험하고 싶을 때만 필요합니다(예를 들어 게임을 100% 완료하고 싶을 때).", "We've seen `le_zero`, the proof that if `x ≤ 0` then `x = 0`.\nNow we'll prove that if `x ≤ 1` then `x = 0` or `x = 1`.": "앞에서 `le_zero`, 즉 `x ≤ 0`이면 `x = 0`라는 증명을 봤습니다. 이제 `x ≤ 1`이면 `x = 0` 또는 `x = 1`라는 것을 증명합니다.", "We've proved that `x ≤ 0` implies `x = 0`. The last two levels\nin this world will prove which numbers are `≤ 1` and `≤ 2`.\nThis lemma will be helpful for them.": - "`x ≤ 0`가 `x = 0`을 함의함을 증명했습니다. 이 world의 마지막 두 level에서는 어떤 수들이 `≤ 1`와 `≤ 2`인지 증명합니다. 이 lemma가 도움이 됩니다.", + "`x ≤ 0`가 `x = 0`을 함의함을 증명했습니다. 이 월드의 마지막 두 레벨에서는 어떤 수들이 `≤ 1`와 `≤ 2`인지 증명합니다. 이 정리가 도움이 됩니다.", "We've proved that $2+2=4$; in Implication World we'll learn\nhow to prove $2+2\\neq 5$.\n\nIn Addition World we proved *equalities* like $x + y = y + x$.\nIn this second tutorial world we'll learn some new tactics,\nenabling us to prove *implications*\nlike $x+1=4 \\implies x=3.$\n\nWe'll also learn two new fundamental facts about\nnatural numbers, which Peano introduced as axioms.\n\nClick on \"Start\" to proceed.": - "$2+2=4$를 증명했습니다. Implication World에서는 $2+2\\neq 5$을 증명하는 법을 배웁니다.\n\nAddition World에서는 $x + y = y + x$ 같은 *등식*을 증명했습니다. 이 두 번째 tutorial world에서는 새로운 tactic들을 배워 $x+1=4 \\implies x=3.$ 같은 *함의*를 증명할 수 있게 됩니다.\n\n또 페아노가 공리로 도입한 자연수에 관한 새로운 기본 사실 두 가지를 배웁니다.\n\n\"Start\"를 눌러 진행하세요.", + "$2+2=4$를 증명했습니다. 조건문 월드에서는 $2+2\\neq 5$을 증명하는 법을 배웁니다.\n\n덧셈 월드에서는 $x + y = y + x$ 같은 *등식*을 증명했습니다. 이 두 번째 튜토리얼 월드에서는 새로운 택틱들을 배워 $x+1=4 \\implies x=3$ 같은 *조건문*를 증명할 수 있게 됩니다.\n\n또 페아노가 공리로 도입한 자연수에 관한 새로운 기본 사실 두 가지를 배웁니다.\n\n\"시작하기\"를 눌러 진행하세요.", "We've just seen that `0 ^ 0 = 1`, but if `n`\nis a successor, then `0 ^ n = 0`. We prove that here.": - "방금 `0 ^ 0 = 1`를 보았습니다. 하지만 `n`이 successor라면 `0 ^ n = 0`입니다. 여기서 이를 증명합니다.", + "방금 `0 ^ 0 = 1`를 보았습니다. 하지만 `n`이 다음수라면 `0 ^ n = 0`입니다. 여기서 이를 증명합니다.", "We've been adding up two numbers; in this level we will add up three.\n\n What does $x+y+z$ *mean*? It could either mean $(x+y)+z$, or it\n could mean $x+(y+z)$. In Lean, $x+y+z$ means $(x+y)+z$.\n\n But why do we care which one it means; $(x+y)+z$ and $x+(y+z)$ are *equal*!\n\n That's true, but we didn't prove it yet. Let's prove it now by induction.": - "지금까지는 수 두 개를 더했습니다. 이번 level에서는 세 개를 더합니다.\n\n$x+y+z$는 무슨 *뜻*일까요? $(x+y)+z$을 뜻할 수도 있고 $x+(y+z)$를 뜻할 수도 있습니다. Lean에서 $x+y+z$은 $(x+y)+z$를 뜻합니다.\n\n그런데 어느 쪽인지 왜 신경 써야 할까요? $(x+y)+z$와 $x+(y+z)$는 *같은데요!*\n\n맞습니다. 하지만 아직 그 사실을 증명하지 않았습니다. 이제 귀납법으로 증명해 봅시다.", + "지금까지는 수 두 개를 더했습니다. 이번 레벨에서는 세 개를 더합니다.\n\n$x+y+z$는 무슨 *뜻*일까요? $(x+y)+z$을 뜻할 수도 있고 $x+(y+z)$를 뜻할 수도 있습니다. Lean에서 $x+y+z$은 $(x+y)+z$를 뜻합니다.\n\n그런데 어느 쪽인지 왜 신경 써야 할까요? $(x+y)+z$와 $x+(y+z)$는 *같은데요!*\n\n맞습니다. 하지만 아직 그 사실을 증명하지 않았습니다. 이제 귀납법으로 증명해 봅시다.", "We're going to change that `False` into `True`. Start by changing it into\n`is_zero (succ a)` by executing `rw [← is_zero_succ a]`.": "`False`를 `True`로 바꿀 겁니다. 먼저 `rw [← is_zero_succ a]`을 실행해 `False`를 `is_zero (succ a)`로 바꾸세요.", "We'll need this lemma to prove that two is prime!\n\nYou'll need to know that `∨` is right associative. This means that\n`x = 0 ∨ x = 1 ∨ x = 2` actually means `x = 0 ∨ (x = 1 ∨ x = 2)`.\nThis affects how `left` and `right` work.": - "2가 소수라는 것을 증명하려면 이 lemma가 필요합니다!\n\n`∨`가 오른쪽 결합이라는 점을 알아야 합니다. 즉 `x = 0 ∨ x = 1 ∨ x = 2`은 실제로 `x = 0 ∨ (x = 1 ∨ x = 2)`를 뜻합니다. 이 때문에 `left`과 `right`의 작동 방식도 달라집니다.", + "2가 소수라는 것을 증명하려면 이 정리가 필요합니다!\n\n`∨`가 오른쪽 결합이라는 점을 알아야 합니다. 즉 `x = 0 ∨ x = 1 ∨ x = 2`은 실제로 `x = 0 ∨ (x = 1 ∨ x = 2)`를 뜻합니다. 이 때문에 `left`과 `right`의 작동 방식도 달라집니다.", "We'd like to prove `2 + 2 = 4` but right now\nwe can't even *state* it\nbecause we haven't yet defined addition.\n\n## Defining addition.\n\nHow are we going to add $37$ to an arbitrary number $x$? Well,\nthere are only two ways to make numbers in this game: $0$\nand successors. So to define `37 + x` we will need\nto know what `37 + 0` is and what `37 + succ x` is.\nLet's start with adding `0`.\n\n### Adding 0\n\nTo make addition agree with our intuition, we should *define* `37 + 0`\nto be `37`. More generally, we should define `a + 0` to be `a` for\nany number `a`. The name of this proof in Lean is `add_zero a`.\nFor example `add_zero 37` is a proof of `37 + 0 = 37`,\n`add_zero x` is a proof of `x + 0 = x`, and `add_zero` is a proof\nof `? + 0 = ?`.\n\nWe write `add_zero x : x + 0 = x`, so `proof : statement`.": - "`2 + 2 = 4`를 증명하고 싶지만, 우리는 아직 덧셈을 정의하지 않았기 때문에 `2+2`의 의미도 명확하지 않습니다.\n\n## 덧셈 정의하기\n\n임의의 수 $x$에 $37$을 어떻게 더할까요? 이 게임에서 수를 만드는 방법은 $0$과 successor뿐입니다. 따라서 `37 + x`를 정의하려면 `37 + 0`와 `37 + succ x`가 무엇인지 정해야 합니다. 먼저 `0`을 더하는 것부터 시작합시다.\n\n### 0 더하기\n\n덧셈이 우리의 직관과 맞으려면 `37 + 0`을 `37`로 “정의”해야 합니다. 더 일반적으로는 모든 수 $a$에 대해 $a+0$을 $a$로 정의해야 합니다. Lean에서 이 증명의 이름은 $add_zero a$입니다. 예를 들어 $add_zero x$는 $ x + 0 = x$의 증명이고, $add_zero 37$은 $37 + 0 = 37$의 증명이며, $add_zero$은 $> + 0 = ?$의 증명입니다.\n\n우리는 $add_zero x : x + 0 = x$처럼 씁니다. 따라서 Lean 코드에서 $statement$의 증명을 $poof$라고 하면, $proof:statement$입니다.", + "`2 + 2 = 4`를 증명하고 싶지만, 우리는 아직 덧셈을 정의하지 않았기 때문에 `2+2`의 의미도 명확하지 않습니다.\n\n## 덧셈 정의하기\n\n임의의 수 $x$에 $37$을 어떻게 더할까요? 이 게임에서 수를 만드는 방법은 $0$과 다음수뿐입니다. 따라서 `37 + x`를 정의하려면 `37 + 0`와 `37 + succ x`가 무엇인지 정해야 합니다. 먼저 `0`을 더하는 것부터 시작합시다.\n\n### 0 더하기\n\n덧셈이 우리의 직관과 맞으려면 `37 + 0`을 `37`로 “정의”해야 합니다. 더 일반적으로는 모든 수 `a`에 대해 `a+0`을 `a`로 정의해야 합니다. Lean에서 이 증명의 이름은 `add_zero a`입니다. 예를 들어 `add_zero x`는 `x + 0 = x의 증명이고, `add_zero 37`은 `37 + 0 = 37`의 증명이며, `add_zero`은 `? + 0 = ?`의 증명입니다.\n\n우리는 `add_zero x : x + 0 = x`처럼 씁니다. 따라서 Lean 코드에서 `statement`의 증명을 `poof`라고 하면, `proof:statement`입니다.", "We want to use `le_mul_right`, but we need a hypothesis `x * y ≠ 0`\nwhich we don't have. Yet. Execute `have h2 : x * y ≠ 0` (you can type `≠` with `\\ne`).\nYou'll be asked to\nprove it, and then you'll have a new hypothesis which you can apply\n`le_mul_right` to.": - "`le_mul_right`를 쓰고 싶지만 필요한 가정 `x * y ≠ 0`이 아직 없습니다. `have h2 : x * y ≠ 0`를 실행하세요(`≠`은 `\\ne`로 입력할 수 있습니다). 그 명제를 증명하라는 goal이 생기고, 증명하고 나면 `le_mul_right`를 적용할 수 있는 새 가정이 생깁니다.", + "`le_mul_right`를 쓰고 싶지만 필요한 가정 `x * y ≠ 0`이 아직 없습니다. `have h2 : x * y ≠ 0`를 실행하세요(`≠`은 `\\ne`로 입력할 수 있습니다). 그 명제를 증명하라는 목표가 생기고, 증명하고 나면 `le_mul_right`를 적용할 수 있는 새 가정이 생깁니다.", "We want to reduce this to a hypothesis `b = 0` and a goal `a * b = 0`,\nwhich is logically equivalent but much easier to prove. Remember that `X ≠ 0`\nis notation for `X = 0 → False`. Click on `Show more help!` if you need hints.": - "이를 가정 `b = 0`와 goal `a * b = 0`으로 환원하고 싶습니다. 논리적으로 동치지만 훨씬 증명하기 쉽습니다. `X ≠ 0`가 `X = 0 → False`의 표기법이라는 점을 기억하세요. 힌트가 필요하면 `도움말 더 보기!`를 클릭하세요.", + "이를 가정 `b = 0`와 목표 `a * b = 0`으로 환원하고 싶습니다. 논리적으로 동치지만 훨씬 증명하기 쉽습니다. `X ≠ 0`가 `X = 0 → False`의 표기법이라는 점을 기억하세요. 힌트가 필요하면 `도움말 더 보기!`를 클릭하세요.", "We still can't prove `2 + 2 ≠ 5` because we have not talked about the\ndefinition of `≠`. In Lean, `a ≠ b` is *notation* for `a = b → False`.\nHere `False` is a generic false proposition, and `→` is Lean's notation\nfor \"implies\". In logic we learn\nthat `True → False` is false, but `False → False` is true. Hence\n`X → False` is the logical opposite of `X`.\n\nEven though `a ≠ b` does not look like an implication,\nyou should treat it as an implication. The next two levels will show you how.\n\n`False` is a goal which you cannot deduce from a consistent set of assumptions!\nSo if your goal is `False` then you had better hope that your hypotheses\nare contradictory, which they are in this level.": - "아직 `2 + 2 ≠ 5`를 증명할 수 없습니다. `≠`의 정의에 대해 이야기하지 않았기 때문입니다. Lean에서 `a ≠ b`는 `a = b → False`의 *표기법*입니다. 여기서 `False`는 일반적인 거짓 명제이고, `→`는 Lean의 \"implies\" 표기입니다. 논리학에서 `True → False`은 거짓이지만 `False → False`은 참임을 배웁니다. 따라서 `X → False`은 `X`의 논리적 반대입니다.\n\n`≠`0은 겉보기에는 함의처럼 보이지 않지만 함의처럼 다뤄야 합니다. 다음 두 level에서 방법을 봅니다.\n\n`≠`1은 모순 없는 가정들에서는 도저히 이끌어낼 수 없는 goal입니다! 그러므로 goal이 `≠`2라면 가정들이 모순이기를 바라야 하는데, 이 level에서는 실제로 그렇습니다.", + "아직 `2 + 2 ≠ 5`를 증명할 수 없습니다. `≠`의 정의에 대해 이야기하지 않았기 때문입니다.\nLean에서 `a ≠ b`는 `a = b → False`의 *표기법*입니다. 여기서 `False`는 일반적인\n거짓 명제이고, `→`는 Lean의 \"조건문\" 표기입니다. 논리학을 배웠다면 `True → False`은\n거짓이지만 `False → False`은 참이라고 알고 있을 겁니다. 따라서 `X → False`은 `X`과 논리적으로 정반대입니다.\n\n`a ≠ b`는 겉보기에는 조건문처럼 보이지 않지만 조건문처럼 다뤄야 합니다. 다음 두 레벨에서 방법을 봅니다.\n\n`False`은 모순 없는 가정들에서는 도저히 이끌어낼 수 없는 목표입니다! 그러므로 목표가 `False`라면 가정들이 모순이기를 바라야 하는데, 이 레벨에서는 실제로 그렇습니다.", "We now start work on an algorithm to do addition more efficiently. Recall that\nwe defined addition by recursion, saying what it did on `0` and successors.\nIt is an axiom of Lean that recursion is a valid\nway to define functions from types such as the naturals.\n\nLet's define a new function `pred` from the naturals to the naturals, which\nattempts to subtract 1 from the input. The definition is this:\n\n```\npred 0 := 37\npred (succ n) := n\n```\n\nWe cannot subtract one from 0, so we just return a junk value. As well as this\ndefinition, we also create a new lemma `pred_succ`, which says that `pred (succ n) = n`.\nLet's use this lemma to prove `succ_inj`, the theorem which\nPeano assumed as an axiom and which we have already used extensively without justification.": - "이제 덧셈을 더 효율적으로 계산하는 알고리즘을 만들어 봅시다. 앞서\n`0`과 후속자에서 어떻게 작동하는지를 정하여 덧셈을 재귀적으로\n정의했다는 것을 떠올려 보세요. Lean에서는 자연수 같은 타입에서\n재귀를 사용해 함수를 정의할 수 있다는 것을 공리로 받아들입니다.\n\n이제 자연수에서 자연수로 가는 새로운 함수 `pred`를 정의해 봅시다.\n이 함수는 입력에서 1을 빼려고 합니다. 정의는 다음과 같습니다.\n\n```\npred 0 := 37\npred (succ n) := n\n```\n\n0에서는 1을 뺄 수 없으므로 그냥 아무 값이나 반환합니다. 이 정의와\n함께 `pred_succ`라는 새로운 보조정리도 만듭니다. 이 정리는\n`pred (succ n) = n`이라고 말합니다. 이제 이 정리를 사용하여\n`succ_inj`를 증명해 봅시다. `succ_inj`는 페아노가 공리로 가정했고,\n우리는 지금까지 정당화 없이 여러 번 사용해 온 정리입니다.", + "이제 덧셈을 더 효율적으로 계산하는 알고리즘을 만들어 봅시다. 앞서\n`0`과 다음수에서 어떻게 작동하는지를 정하여 덧셈을 재귀적으로\n정의했다는 것을 떠올려 보세요. Lean에서는 자연수 같은 타입에서\n재귀를 사용해 함수를 정의할 수 있다는 것을 공리로 받아들입니다.\n\n이제 자연수에서 자연수로 가는 새로운 함수 `pred`를 정의해 봅시다.\n이 함수는 입력에서 1을 빼려고 합니다. 정의는 다음과 같습니다.\n\n```\npred 0 := 37\npred (succ n) := n\n```\n\n0에서는 1을 뺄 수 없으므로 그냥 아무 값이나 반환합니다. 이 정의와\n함께 `pred_succ`라는 새로운 정리도 만듭니다. 이 정리는\n`pred (succ n) = n`이라고 말합니다. 이제 이 정리를 사용하여\n`succ_inj`를 증명해 봅시다. `succ_inj`는 페아노가 공리로 가정했고,\n우리는 지금까지 정당화 없이 여러 번 사용해 온 정리입니다.", "We now have enough to state a mathematically accurate, but slightly\nclunky, version of Fermat's Last Theorem.\n\nFermat's Last Theorem states that if $x,y,z>0$ and $m \\geq 3$ then $x^m+y^m\\not =z^m$.\nIf you didn't do inequality world yet then we can't talk about $m \\geq 3$,\nso we have to resort to the hack of using `n + 3` for `m`,\nwhich guarantees it's big enough. Similarly instead of `x > 0` we\nuse `a + 1`.\n\nThis level looks superficially like other levels we have seen,\nbut the shortest solution known to humans would translate into\nmany millions of lines of Lean code. The author of this game,\nKevin Buzzard, is working on translating the proof by Wiles\nand Taylor into Lean, although this task will take many years.\n\n## CONGRATULATIONS!\n\nYou've finished the main quest of the natural number game!\nIf you would like to learn more about how to use Lean to\nprove theorems in mathematics, then take a look\nat [Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/),\nan interactive textbook which you can read in your browser,\nand which explains how to work with many more mathematical concepts in Lean.": - "이제 수학적으로 정확하지만 조금 투박한 형태의 페르마의 마지막 정리를 진술할 준비가 되었습니다.\n\n페르마의 마지막 정리는 $x,y,z>0$이고 $m \\geq 3$이면 $x^m+y^m\\not =z^m$라는 정리입니다. Inequality World를 하지 않았다면 $m \\geq 3$에 대해 말할 수 없으므로 `m` 대신 `n + 3`를 쓰는 편법을 사용해야 합니다. 이렇게 하면 충분히 큰 수라는 것이 보장됩니다. 마찬가지로 `x > 0` 대신 `a + 1`을 사용합니다.\n\n겉보기에는 이전 level들과 비슷하지만, 인간이 아는 가장 짧은 해법도 Lean 코드로 옮기면 수백만 줄이 될 것입니다. 이 게임의 저자 Kevin Buzzard는 Wiles와 Taylor의 증명을 Lean으로 옮기는 작업을 하고 있지만, 이 작업은 여러 해가 걸릴 것입니다.\n\n## 축하합니다!\n\nNatural Number Game의 main quest를 끝냈습니다! Lean으로 수학 정리를 증명하는 법을 더 배우고 싶다면 브라우저에서 읽을 수 있는 대화형 교재 [Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/)을 살펴보세요. 더 많은 수학적 개념을 Lean에서 다루는 방법을 설명합니다.", + "이제 수학적으로 정확하지만 조금 투박한 형태의 페르마의 마지막 정리를 진술할 준비가 되었습니다.\n\n페르마의 마지막 정리는 $x,y,z>0$이고 $m \\geq 3$이면 $x^m+y^m\\not =z^m$라는 정리입니다. `≤` 세계를 하지 않았다면 $m \\geq 3$에 대해 말할 수 없으므로 `m` 대신 `n + 3`를 쓰는 편법을 사용해야 합니다. 이렇게 하면 충분히 큰 수라는 것이 보장됩니다. 마찬가지로 `x > 0` 대신 `a + 1`을 사용합니다.\n\n겉보기에는 이전 레벨들과 비슷하지만, 인간이 아는 가장 짧은 해법도 Lean 코드로 옮기면 수백만 줄이 될 것입니다. 이 게임의 저자 Kevin Buzzard는 Wiles와 Taylor의 증명을 Lean으로 옮기는 작업을 하고 있지만, 이 작업은 여러 해가 걸릴 것입니다.\n\n## 축하합니다!\n\nNatural Number Game의 main quest를 끝냈습니다! Lean으로 수학 정리를 증명하는 법을 더 배우고 싶다면 브라우저에서 읽을 수 있는 대화형 교재 [Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/)을 살펴보세요. 더 많은 수학적 개념을 Lean에서 다루는 방법을 설명합니다.", "We now have enough to prove that multiplication is associative,\nthe boss level of multiplication world. Good luck!": - "이제 곱셈의 결합법칙, 즉 Multiplication World의 boss level을 증명할 준비가 되었습니다. 행운을 빕니다!", + "이제 곱셈의 결합법칙, 즉 곱셈 월드의 보스 레벨을 증명할 준비가 되었습니다. 행운을 빕니다!", "We know `zero_ne_succ n` is a proof of `0 = succ n → False` -- but what\nif we have a hypothesis `succ n = 0`? It's the wrong way around!\n\nThe `symm` tactic changes a goal `x = y` to `y = x`, and a goal `x ≠ y`\nto `y ≠ x`. And `symm at h`\ndoes the same for a hypothesis `h`. We've proved $0 \\neq 1$ and called\nthe proof `zero_ne_one`; now try proving $1 \\neq 0$.": - "`zero_ne_succ n`가 `0 = succ n → False`의 증명이라는 것은 알고 있습니다. 그런데 가정이 `succ n = 0`라면 어떨까요? 방향이 반대입니다!\n\n`symm` tactic은 goal `x = y`를 `y = x`로, goal `x ≠ y`을 `y ≠ x`로 바꿉니다. `symm at h`은 가정 `h`에 대해 같은 일을 합니다. 우리는 `0 = succ n → False`0을 증명하고 그 증명을 `0 = succ n → False`1이라고 불렀습니다. 이제 `0 = succ n → False`2를 증명해 보세요.", + "`zero_ne_succ n`가 `0 = succ n → False`의 증명이라는 것은 알고 있습니다. 그런데 가정이 `succ n = 0`라면 어떨까요? 방향이 반대입니다!\n\n`symm` 택틱은 목표 `x = y`를 `y = x`로, 목표 `x ≠ y`을 `y ≠ x`로 바꿉니다. `symm at h`은 가정 `h`에 대해 같은 일을 합니다.\n우리는 $0 \\neq 1$을 증명하고 그 증명을 `zero_ne_one`이라고 불렀습니다. 이제 $1 \\neq 0$를 증명해 보세요.", "We have seen how to `apply` theorems and assumptions\nof the form `P → Q`. But what if our *goal* is of the form `P → Q`?\nTo prove this goal, we need to know how to say \"let's assume `P` and deduce `Q`\"\nin Lean. We do this with the `intro` tactic.": - "지금까지 `P → Q` 꼴의 정리와 가정을 `apply`하는 법을 봤습니다. 그런데 *goal*이 `P → Q` 꼴이라면 어떨까요? 이 goal을 증명하려면 Lean에서 \"`P`을 가정하고 `Q`를 이끌어내자\"라고 말하는 법을 알아야 합니다. 이를 `intro` tactic으로 합니다.", + "지금까지 `P → Q` 꼴의 정리와 가정을 `apply`하는 법을 봤습니다. 그런데 *목표*가 `P → Q` 꼴이라면 어떨까요? 이 목표를 증명하려면 Lean에서 \"`P`를 가정하고 `Q` 보이자.\"라고 말하는 법을 알아야 합니다. 이를 `intro` 택틱으로 합니다.", "We gave a pretty unsatisfactory proof of `2 + 2 ≠ 5` earlier on; now give a nicer one.": "앞에서 `2 + 2 ≠ 5`에 대해 꽤 아쉬운 증명을 했습니다. 이제 더 멋진 증명을 해 보세요.", "We don't know whether to go left or right yet. So start with `cases «{h}» with hx hy`.": "아직 왼쪽으로 갈지 오른쪽으로 갈지 모르므로 `cases «{h}» with hx hy`부터 시작하세요.", "We define a function `is_zero` thus:\n\n```\nis_zero 0 := True\nis_zero (succ n) := False\n```\n\nWe also create two lemmas, `is_zero_zero` and `is_zero_succ n`, saying that `is_zero 0 = True`\nand `is_zero (succ n) = False`. Let's use these lemmas to prove `succ_ne_zero`, Peano's\nLast Axiom. Actually, we have been using `zero_ne_succ` before, but it's handy to have\nthis opposite version too, which can be proved in the same way. Note: you can\ncheat here by using `zero_ne_succ` but the point of this world is to show\nyou how to *prove* results like that.\n\nIf you can turn your goal into `True`, then the `trivial` tactic will solve it.": - "함수 `is_zero`를 다음과 같이 정의합니다:\n\n```\nis_zero 0 := True\nis_zero (succ n) := False\n```\n\n또 `is_zero 0 = True`와 `is_zero (succ n) = False`라고 말하는 두 lemma `is_zero_zero`와 `is_zero_succ n`을 만듭니다. 이 lemma들을 사용해 페아노의 마지막 공리 `succ_ne_zero`을 증명합시다. 사실 `zero_ne_succ`은 이전부터 사용해 왔지만, 반대 방향 버전도 있으면 편리하고 같은 방식으로 증명할 수 있습니다. 참고로 `zero_ne_succ`을 쓰면 여기서 치팅할 수 있지만, 이 world의 목적은 그런 결과를 *직접 증명*하는 방법을 보여 주는 것입니다.\n\ngoal을 `True`로 바꿀 수 있다면 ```\nis_zero 0 := True\nis_zero (succ n) := False\n```0 tactic이 해결합니다.", + "함수 `is_zero`를 다음과 같이 정의합니다:\n\n```\nis_zero 0 := True\nis_zero (succ n) := False\n```\n\n또 `is_zero 0 = True`와 `is_zero (succ n) = False`라고 말하는 두 정리 `is_zero_zero`와 `is_zero_succ n`을 만듭니다. 이 정리들을 사용해 페아노의 마지막 공리 `succ_ne_zero`을 증명합시다. 사실 `zero_ne_succ`은 이전부터 사용해 왔지만, 반대 방향 버전도 있으면 편리하고 같은 방식으로 증명할 수 있습니다. 참고로 `zero_ne_succ`을 쓰면 여기서 치팅할 수 있지만, 이 월드의 목적은 그런 결과를 *직접 증명*하는 방법을 보여 주는 것입니다.\n\n목표를 `True`로 바꿀 수만 있다면 `trivial` 택틱이 해결할 수 있습니다.", "Very well done.\n\nA passing mathematician remarks that with you've just proved that `ℕ` is totally\nordered.\n\nThe final few levels in this world are much easier.": - "정말 잘했습니다.\n\n지나가던 수학자가 방금 `ℕ`가 전순서(total order)임을 증명했다고 말합니다.\n\n이 world의 마지막 몇 level은 훨씬 쉽습니다.", + "정말 잘했습니다.\n\n지나가던 수학자가 방금 `ℕ`가 전순서(total order)임을 증명했다고 말합니다.\n\n이 월드의 마지막 몇 레벨은 훨씬 쉽습니다.", "Use the previous lemma with `apply eq_succ_of_ne_zero at ha`.": - "이전 lemma를 `apply eq_succ_of_ne_zero at ha`와 함께 사용하세요.", + "이전 정리를 `apply eq_succ_of_ne_zero at ha`와 함께 사용하세요.", "Use `mul_eq_zero` and remember that `tauto` will solve a goal\nif there are hypotheses `a = 0` and `a ≠ 0`.": - "`mul_eq_zero`를 사용하세요. 가정 `a = 0`와 `a ≠ 0`이 있으면 `tauto`이 goal을 해결한다는 점을 기억하세요.", + "`mul_eq_zero`를 사용하세요. 가정 `a = 0`와 `a ≠ 0`이 있으면 `tauto`이 목표를 해결한다는 점을 기억하세요.", "Use `add_succ`.": "`add_succ`를 사용하세요.", "Tutorial World": "튜토리얼 월드", "Try `rw [← one_eq_succ_zero]` to change `succ 0` into `1`.": @@ -331,57 +330,57 @@ "Try `rw [add_zero c]`.": "`rw [add_zero c]`를 시도해 보세요.", "Try `cases «{hd}» with h1 h2`.": "`cases «{hd}» with h1 h2`를 시도해 보세요.", "Totality of `≤` is the boss level of this world, and it's coming up next. It says that\nif `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\nBut we haven't talked about `or` at all. Here's a run-through.\n\n1) The notation for \"or\" is `∨`. You won't need to type it, but you can\ntype it with `\\or`.\n\n2) If you have an \"or\" statement in the *goal*, then two tactics make\nprogress: `left` and `right`. But don't choose a direction unless your\nhypotheses guarantee that it's the correct one.\n\n3) If you have an \"or\" statement as a *hypothesis* `h`, then\n`cases h with h1 h2` will create two goals, one where you went left,\nand the other where you went right.": - "`≤`의 전칭성(totality)은 이 world의 boss level이며 바로 다음에 나옵니다. `a`과 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a`라는 명제입니다. 하지만 아직 `or`에 대해 전혀 이야기하지 않았으니 먼저 살펴봅시다.\n\n1) \"or\"의 표기는 `∨`입니다. 직접 입력할 필요는 없지만 `\\or`로 입력할 수 있습니다.\n\n2) goal에 \"or\" 명제가 있으면 `left`과 `right` 두 tactic으로 진행할 수 있습니다. 하지만 어느 방향이 옳은지 가정으로 확실해지기 전에는 방향을 선택하지 마세요.\n\n3) \"or\" 명제가 가정 `a`0으로 있다면 `a`1은 goal을 두 개 만듭니다. 하나는 왼쪽 경우, 다른 하나는 오른쪽 경우입니다.", + "`≤`의 전순서성은 이 월드의 보스 레벨이며, 바로 다음에 등장합니다. 이는\n`a`와 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a` 중 하나가 성립한다는 뜻입니다.\n하지만 아직 `or`에 대해서는 전혀 이야기하지 않았습니다. 간단히 알아봅시다.\n\n1) \"or\"를 나타내는 기호는 `∨`입니다. 직접 입력할 필요는 없지만,\n`\\or`를 입력해서 쓸 수 있습니다.\n\n2) *목표*에 \"or\" 명제가 있다면 `left`와 `right`, 두 택틱 중 하나를 사용해\n진행할 수 있습니다. 다만 가정들로부터 어느 쪽이 맞는지가 확실하지 않다면\n섣불리 방향을 고르지 마세요.\n\n3) \"or\" 명제가 *가정* `h`로 주어져 있다면,\n`cases h with h1 h2`를 사용해 두 개의 목표를 만들 수 있습니다. 하나는 왼쪽이\n성립하는 경우이고, 다른 하나는 오른쪽이 성립하는 경우입니다.", "Totality of `≤` is the boss level of this world, and it's coming up next. It says that\nif `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\nBut we haven't talked about `or` at all. Here's a run-through.\n\n1) The notation for \"or\" is `∨`. You won't need to type it, but you can\ntype it with `\\or`.\n\n2) If you have an \"or\" statement in the *goal*, then two tactics made\nprogress: `left` and `right`. But don't choose a direction unless your\nhypotheses guarantee that it's the correct one.\n\n3) If you have an \"or\" statement as a *hypothesis* `h`, then\n`cases h with h1 h2` will create two goals, one where you went left,\nand the other where you went right.": - "Totality of `≤` is the boss level of this world, and it's coming up next. It says that\nif `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\nBut we haven't talked about `or` at all. Here's a run-through.\n\n1) The notation for \"or\" is `∨`. You won't need to type it, but you can\ntype it with `\\or`.\n\n2) If you have an \"or\" statement in the *goal*, then two tactics made\nprogress: `left` and `right`. But don't choose a direction unless your\nhypotheses guarantee that it's the correct one.\n\n3) If you have an \"or\" statement as a *hypothesis* `h`, then\n`cases h with h1 h2` will create two goals, one where you went left,\nand the other where you went right.", + "`≤`의 전순서성은 이 월드의 보스 레벨이며, 바로 다음에 등장합니다. 이는\n`a`와 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a` 중 하나가 성립한다는 뜻입니다.\n하지만 아직 `or`에 대해서는 전혀 이야기하지 않았습니다. 간단히 알아봅시다.\n\n1) \"or\"를 나타내는 기호는 `∨`입니다. 직접 입력할 필요는 없지만,\n`\\or`를 입력해서 쓸 수 있습니다.\n\n2) *목표*에 \"or\" 명제가 있다면 `left`와 `right`, 두 택틱 중 하나를 사용해\n진행할 수 있습니다. 다만 가정들로부터 어느 쪽이 맞는지가 확실하지 않다면\n섣불리 방향을 고르지 마세요.\n\n3) \"or\" 명제가 *가정* `h`로 주어져 있다면,\n`cases h with h1 h2`를 사용해 두 개의 목표를 만들 수 있습니다. 하나는 왼쪽이\n성립하는 경우이고, 다른 하나는 오른쪽이 성립하는 경우입니다.", "To solve this level, you need to `use` a number `c` such that `x = 0 + c`.": - "이 level을 해결하려면 `x = 0 + c`를 만족하는 수 `c`을 `use`해야 합니다.", + "이 레벨을 해결하려면 `x = 0 + c`를 만족하는 수 `c`을 `use`해야 합니다.", "Those of you interested in speedrunning the game may want to know\nthat `repeat rw [add_zero]` will do both rewrites at once.": "게임을 speedrun하고 싶은 분들은 `repeat rw [add_zero]`가 두 rewrite를 한 번에 해 준다는 것을 알아 두면 좋습니다.", "This world introduces exponentiation. If you want to define `37 ^ n`\nthen, as always, you will need to know what `37 ^ 0` is, and\nwhat `37 ^ (succ d)` is, given only `37 ^ d`.\n\nYou can probably guess the names of the general theorems:\n\n * `pow_zero (a : ℕ) : a ^ 0 = 1`\n * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n\nUsing only these, can you get past the final boss level?\n\nThe levels in this world were designed by Sian Carey, a UROP student\nat Imperial College London, funded by a Mary Lister McCammon Fellowship\nin the summer of 2019. Thanks to Sian and also thanks to Imperial\nCollege for funding her.": - "이 월드에서는 거듭제곱을 도입합니다. `37 ^ n`를 정의하려면 언제나 그렇듯 `37 ^ 0`이 무엇인지, 그리고 `37 ^ d`만 알고 있을 때 `37 ^ (succ d)`가 무엇인지 알아야 합니다.\n\n일반 정리의 이름은 아마 짐작할 수 있을 겁니다:\n\n * `pow_zero (a : ℕ) : a ^ 0 = 1`\n * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n\n이 둘만 사용해서 최종 보스 level을 넘을 수 있을까요?\n\n이 세계의 level들은 2019년 여름 Imperial College London의 UROP 학생 Sian Carey가 설계했으며 Mary Lister McCammon Fellowship의 지원을 받았습니다. Sian과 그녀를 지원한 Imperial College에 감사드립니다.", - "This time, use the `left` tactic.": "이번에는 `left` tactic을 사용하세요.", + "이 월드에서는 거듭제곱을 도입합니다. `37 ^ n`를 정의하려면 언제나 그렇듯 `37 ^ 0`이 무엇인지, 그리고 `37 ^ d`만 알고 있을 때 `37 ^ (succ d)`가 무엇인지 알아야 합니다.\n\n일반 정리의 이름은 아마 짐작할 수 있을 겁니다:\n\n * `pow_zero (a : ℕ) : a ^ 0 = 1`\n * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n\n이 둘만 사용해서 최종 보스 레벨을 넘을 수 있을까요?\n\n이 월드의 레벨들은 2019년 여름 Imperial College London의 UROP 학생 Sian Carey가 설계했으며 Mary Lister McCammon Fellowship의 지원을 받았습니다. Sian과 그녀를 지원한 Imperial College에 감사드립니다.", + "This time, use the `left` tactic.": "이번에는 `left` 택틱을 사용하세요.", "This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\ninstead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory.": - "This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\ninstead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory.", + "이 상태는 증명불가능합니다! 혹시 `apply [add_left_eq_self] at h` 가 아니라\n`rw [add_left_eq_self] at h`을 사용하셨나요? 인벤토리에서 그 둘을 비교해보세요.", "This level proves that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`. One strategy\nis to write both `a` and `b` as `succ` of something, deduce that `a * b` is\nalso `succ` of something, and then `apply zero_ne_succ`.": - "이 level에서는 `a ≠ 0`와 `b ≠ 0`이면 `a * b ≠ 0`라는 것을 증명합니다. 한 전략은 `a`과 `b`를 각각 어떤 것의 `succ`로 쓰고, `a * b`도 어떤 것의 `succ`임을 이끌어낸 뒤 `apply zero_ne_succ`을 사용하는 것입니다.", + "이 레벨에서는 `a ≠ 0`와 `b ≠ 0`이면 `a * b ≠ 0`라는 것을 증명합니다. 한 전략은 `a`과 `b`를 각각 어떤 것의 `succ`로 쓰고, `a * b`도 어떤 것의 `succ`임을 이끌어낸 뒤 `apply zero_ne_succ`을 사용하는 것입니다.", "This level proves that if `a * b = 0` then `a = 0` or `b = 0`. It is\nlogically equivalent to the last level, so there is a very short proof.": - "이 level에서는 `a * b = 0`이면 `a = 0` 또는 `b = 0`라는 것을 증명합니다. 이전 level과 논리적으로 동치이므로 아주 짧은 증명이 있습니다.", + "이 레벨에서는 `a * b = 0`이면 `a = 0` 또는 `b = 0`라는 것을 증명합니다. 이전 레벨과 논리적으로 동치이므로 아주 짧은 증명이 있습니다.", "This level proves `x * y = 1 → x = 1`, the multiplicative analogue of Advanced Addition\nWorld's `x + y = 0 → x = 0`. The strategy is to prove that `x ≤ 1` and then use the\nlemma `le_one` from `≤` world.\n\nWe'll prove it using a new and very useful tactic called `have`.": - "이 레벨에서는 고급 덧셈 월드의 `x + y = 0 → x = 0`에 대응하는 곱셈 버전 `x * y = 1 → x = 1`를 증명합니다. 전략은 `x ≤ 1`를 증명한 다음 `≤` 월드에서 얻은 lemma `le_one`을 사용하는 것입니다.\n\n새롭고 매우 유용한 tactic `have`를 사용해 증명하겠습니다.", + "이 레벨에서는 고급 덧셈 월드의 `x + y = 0 → x = 0`에 대응하는 곱셈 버전 `x * y = 1 → x = 1`를 증명합니다. 전략은 `x ≤ 1`를 증명한 다음 `≤` 월드에서 얻은 정리 `le_one`을 사용하는 것입니다.\n\n새롭고 매우 유용한 택틱 `have`를 사용해 증명하겠습니다.", "This level is more important than you think; it plays\na useful role when battling a big boss later on.": - "이 level은 생각보다 중요합니다. 나중에 큰 boss와 싸울 때 유용한 역할을 합니다.", + "이 레벨은 생각보다 중요합니다. 나중에 큰 보스와 싸울 때 유용한 역할을 합니다.", "This level asks you to prove *antisymmetry* of $\\leq$.\nIn other words, if $x \\leq y$ and $y \\leq x$ then $x = y$.\nIt's the trickiest one so far. Good luck!": - "이 level에서는 $\\leq$의 *반대칭성*을 증명합니다. 즉 $x \\leq y$이고 $y \\leq x$이면 $x = y$임을 보입니다. 지금까지 중 가장 까다롭습니다. 행운을 빕니다!", + "이 레벨에서는 $\\leq$의 *반대칭성*을 증명합니다. 즉 $x \\leq y$이고 $y \\leq x$이면 $x = y$임을 보입니다. 지금까지 중 가장 까다롭습니다. 행운을 빕니다!", "This lemma would have been easy if we had known that `x + y = y + x`. That theorem\n is called `add_comm` and it is *true*, but unfortunately its proof *uses* both\n `add_zero` and `zero_add`!\n\n Let's continue on our journey to `add_comm`, the proof of `x + y = y + x`.": - "`x + y = y + x`를 알고 있었다면 이 lemma는 쉬웠을 겁니다. 그 정리는 `add_comm`이라고 하며 실제로 *참*이지만, 안타깝게도 그 증명은 `add_zero`와 `zero_add`을 모두 사용합니다!\n\n`x + y = y + x`의 증명 `add_comm`를 향한 여정을 계속합시다.", + "`x + y = y + x`를 알고 있었다면 이 정리는 쉬웠을 겁니다. 그 정리는 `add_comm`이라고 하며 실제로 *참*이지만, 안타깝게도 그 증명은 `add_zero`와 `zero_add`을 모두 사용합니다!\n\n`x + y = y + x`의 증명 `add_comm`를 향한 여정을 계속합시다.", "This is I think the toughest level yet. Tips: if `a` is a number\nthen `cases a with b` will split into cases `a = 0` and `a = succ b`.\nAnd don't go left or right until your hypotheses guarantee that\nyou can prove the resulting goal!\n\nI've left hidden hints; if you need them, retry from the beginning\nand click on \"Show more help!\"": - "제 생각에는 지금까지 가장 어려운 level입니다. 팁: `a`가 수라면 `cases a with b`은 `a = 0`와 `a = succ b`의 경우로 나눕니다. 그리고 가정이 결과 goal을 증명할 수 있음을 보장하기 전에는 왼쪽이나 오른쪽을 선택하지 마세요!\n\n숨겨 둔 힌트가 있습니다. 필요하면 처음부터 다시 시작하고 \"도움말 더 보기!\"를 누르세요.", + "제 생각에는 지금까지 가장 어려운 레벨입니다. 팁: `a`가 수라면 `cases a with b`은 `a = 0`와 `a = succ b`의 경우로 나눕니다. 그리고 가정이 결과 목표를 증명할 수 있음을 보장하기 전에는 왼쪽이나 오른쪽을 선택하지 마세요!\n\n숨겨 둔 힌트가 있습니다. 필요하면 처음부터 다시 시작하고 \"도움말 더 보기!\"를 누르세요.", "The way to start this proof is `induction b with d hd generalizing c`.": "이 증명은 `induction b with d hd generalizing c`로 시작해야 합니다.", "The rfl tactic": "rfl tactic", "The reason `«{x}» ≤ «{x}»` is because `«{x}» = «{x}» + 0`.\nSo you should start this proof with `use 0`.": "`«{x}» ≤ «{x}»`인 이유는 `«{x}» = «{x}» + 0`이기 때문입니다. 따라서 `use 0`로 증명을 시작해야 합니다.", "The previous lemma can be used to prove this one.": - "이전 lemma를 사용해 이 lemma를 증명할 수 있습니다.", + "이전 정리를 사용해 이 정리를 증명할 수 있습니다.", "The next result we'll need in `≤` World is that if `a + b = 0` then `a = 0` and `b = 0`.\nLet's prove one of these facts in this level, and the other in the next.\n\n## A new tactic: `cases`\n\nThe `cases` tactic will split an object or hypothesis up into the possible ways\nthat it could have been created.\n\nFor example, sometimes you want to deal with the two cases `b = 0` and `b = succ d` separately,\nbut don't need the inductive hypothesis `hd` that comes with `induction b with d hd`.\nIn this situation you can use `cases b with d` instead. There are two ways to make\na number: it's either zero or a successor. So you will end up with two goals, one\nwith `b = 0` and one with `b = succ d`.\n\nAnother example: if you have a hypothesis `h : False` then you are done, because a false statement implies\nany statement. Here `cases h` will close the goal, because there are *no* ways to\nmake a proof of `False`! So you will end up with no goals, meaning you have proved everything.": - "`≤` World에서 다음으로 필요한 결과는 `a + b = 0`이면 `a = 0`이고 `b = 0`이라는 것입니다. 이번 level에서 하나를 증명하고 다음 level에서 나머지 하나를 증명합시다.\n\n## 새로운 tactic: `cases`\n\n`cases` tactic은 object나 가정을 그것이 만들어질 수 있었던 가능한 경우들로 분해합니다.\n\n예를 들어 `b = 0`와 `b = succ d`의 두 경우를 따로 다루고 싶지만 `induction b with d hd`에 따라오는 귀납가정 `hd`은 필요하지 않을 때가 있습니다. 이때는 `a + b = 0`0을 사용할 수 있습니다. 수를 만드는 방법은 두 가지뿐입니다. 0이거나 successor입니다. 따라서 `a + b = 0`1인 goal과 `a + b = 0`2인 goal, 두 개가 생깁니다.\n\n또 다른 예로, 가정 `a + b = 0`3이 있다면 이미 끝난 것입니다. 거짓 명제에서는 어떤 명제든 따라오기 때문입니다. 여기서 `a + b = 0`4는 goal을 닫습니다. `a + b = 0`5의 증명을 만드는 방법은 *하나도 없기* 때문입니다! 따라서 goal이 하나도 남지 않고, 이는 모든 것을 증명했다는 뜻입니다.", + "`≤` 월드에서 다음으로 필요한 결과는 `a + b = 0`이면 `a = 0`이고 `b = 0`이라는 것입니다. 이번 레벨에서 하나를 증명하고 다음 레벨에서 나머지 하나를 증명합시다.\n\n## 새로운 택틱: `cases`\n\n`cases` 택틱은 객체나 가정을 그것이 만들어질 수 있었던 가능한 경우들로 분해합니다.\n\n예를 들어 `b = 0`와 `b = succ d`의 두 경우를 따로 다루고 싶지만 `induction b with d hd`에 따라오는 귀납가정\n`hd`은 필요하지 않을 때가 있습니다. 이때는 `cases b with d`를 사용할 수 있습니다. 수를 만드는 방법은 단 두 가지,\n0 또는 다음수입니다. 따라서 `b = 0`인 목표와 `b = succ d`인 목표, 두 개가 생깁니다.\n\n또 다른 예로, 가정 `h : False`이 있다면 이미 끝난 것입니다. 거짓 명제에서는 무엇이든지 증명할 수 있기 때문입니다.\n여기서 `cases h`는 목표를 끝냅니다. 왜냐하면 `False`의 증명을 만드는 방법은 단 *0*가지이기 때문입니다! 따라서 목표가 하나도 남지 않고, 이는 모든 것을 증명했다는 뜻입니다.", "The music gets ever more dramatic, as we explore\nthe interplay between exponentiation and multiplication.\n\nIf you're having trouble exchanging the right `a * b`\nbecause `rw [mul_comm]` swaps the wrong multiplication,\nthen read the documentation of `rw` for tips on how to fix this.": "거듭제곱과 곱셈의 상호작용을 살펴보면서 음악은 점점 더 극적으로 변합니다.\n\n`rw [mul_comm]`이 엉뚱한 곱셈을 바꿔서 원하는 `a * b`를 교환하기 어렵다면 `rw` 문서에서 해결법을 읽어 보세요.", "The music dies down. Is that it?\n\nCourse it isn't, you can\nclearly see that there are two levels left.\n\nA passing mathematician says that mathematicians don't have a name\nfor the structure you just constructed. You feel cheated.\n\nSuddenly the music starts up again. This really is the final boss.": "음악이 잦아듭니다. 설마 이게 끝인가요?\n\n그럴 리가요. 아직 두 관문이나 남아 있는 게 빤히 보이잖아요.\n\n지나가던 한 수학자가 방금 당신이 만든 구조에는 딱히 이름도 없다고 합니다.\n괜히 속은 기분이 듭니다.\n\n그 순간, 음악이 다시 울려 퍼집니다. *진짜 최종 보스*", "The lemma proved in the final level of this world will be helpful\nin Divisibility World.": - "이 world의 마지막 level에서 증명하는 lemma는 Divisibility World에서 유용합니다.", + "이 월드의 마지막 레벨에서 증명하는 정리는 나누어 떨어짐 월드에서 유용합니다.", "The inductive hypothesis `hd` is \"For all natural numbers `c`, `a * d = a * c → d = c`\".\nYou can `apply` it `at` any hypothesis of the form `a * d = a * ?`.": "귀납가정 `hd`는 \"모든 자연수 `c`에 대해 `a * d = a * c → d = c`\"입니다. `a * d = a * ?` 꼴의 어떤 가정에도 `apply`를 `at`할 수 있습니다.", "The goal in this level is one of our hypotheses. Solve the goal by executing `exact h1`.": - "이 level의 goal은 가정 중 하나입니다. `exact h1`를 실행해서 goal을 해결하세요.", + "이 레벨의 목표는 가정 중 하나입니다. `exact h1`를 실행해서 목표를 해결하세요.", "The first sub-boss of Multiplication World is `mul_comm x y : x * y = y * x`.\n\nWhen you've proved this theorem we will have \"spare\" proofs\nsuch as `zero_mul`, which is now easily deducible from `mul_zero`.\nBut we'll keep hold of these proofs anyway, because it's convenient\nto have exactly the right tool for a job.": - "Multiplication World의 첫 sub-boss는 `mul_comm x y : x * y = y * x`입니다.\n\n이 정리를 증명하면 `zero_mul`처럼 `mul_zero`에서 쉽게 따라오는 \"여분의\" 증명도 생깁니다. 그래도 정확히 필요한 도구를 바로 꺼내 쓸 수 있으면 편리하므로 이런 증명들도 그대로 가지고 있겠습니다.", + "곱셈 월드의 첫 중간 보스는 `mul_comm x y : x * y = y * x`입니다.\n\n이 정리를 증명하면 `zero_mul`처럼 `mul_zero`에서 쉽게 따라오는 \"여분의\" 증명도 생깁니다. 그래도 정확히 필요한 도구를 바로 꺼내 쓸 수 있으면 편리하므로 이런 증명들도 그대로 가지고 있겠습니다.", "The classical introduction game for Lean.": "Lean을 배우는 고전적인 입문 게임.", - "The `use` tactic": "`use` tactic", - "The `exact` tactic": "`exact` tactic", - "The `apply` tactic.": "`apply` tactic.", + "The `use` tactic": "`use` 택틱", + "The `exact` tactic": "`exact` 택틱", + "The `apply` tactic.": "`apply` 택틱.", "Start with induction on `n`.": "`n`에 대한 귀납법으로 시작하세요.", "Start with `rw [← pred_succ a]` and take it from there.": "`rw [← pred_succ a]`로 시작하고 나머지는 스스로 해 보세요.", @@ -402,12 +401,12 @@ "Start with `have h2 := mul_ne_zero a b`.": "`have h2 := mul_ne_zero a b`로 시작하세요.", "Start with `contrapose! h`, to change the goal into its\ncontrapositive, namely a hypothesis of `succ m = succ n` and a goal of `m = n`.": - "`contrapose! h`로 시작해 goal을 그 대우로 바꾸세요. 즉 가정 `succ m = succ n`과 goal `m = n`로 바꿉니다.", + "`contrapose! h`로 시작해 목표를 그 대우로 바꾸세요. 즉 가정 `succ m = succ n`과 목표 `m = n`로 바꿉니다.", "Start with `cases «{hxy}» with a ha`.": "`cases «{hxy}» with a ha`로 시작하세요.", "Start with `cases a with d` to do a case split on `a = 0` and `a = succ d`.": "`cases a with d`로 시작해 `a = 0`과 `a = succ d`에 대해 경우를 나누세요.", "Start with `apply succ_inj` to apply `succ_inj` to the *goal*.": - "`apply succ_inj`로 시작해 `succ_inj`을 *goal*에 적용하세요.", + "`apply succ_inj`로 시작해 `succ_inj`을 *목표*에 적용하세요.", "Start with `apply h2 at h1`. This will change `h1` to `y = 42`.": "`apply h2 at h1`부터 시작하세요. 그러면 `h1`이 `y = 42`로 바뀝니다.", "Start with `apply eq_succ_of_ne_zero at ha` and `... at hb`": @@ -416,38 +415,38 @@ "Split into cases `c = 0` and `c = succ e` with `cases c with e`.": "`cases c with e`를 사용해 `c = 0`와 `c = succ e`의 경우로 나누세요.", "Solve this level in one line with `simp only [add_left_comm, add_comm]`": - "`simp only [add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요.", + "`simp only [add_left_comm, add_comm]`를 사용해 이 레벨을 한 줄로 해결하세요.", "Solve this level in one line with `simp only [add_assoc, add_left_comm, add_comm]`": - "`simp only [add_assoc, add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요.", + "`simp only [add_assoc, add_left_comm, add_comm]`를 사용해 이 레벨을 한 줄로 해결하세요.", "So that's the algorithm: now let's use automation to perform it\nautomatically.": "알고리즘은 이것입니다. 이제 automation을 사용해 자동으로 실행해 봅시다.", "Similarly we have `mul_succ`\nbut we're going to need `succ_mul` (guess what it says -- maybe you\nare getting the hang of Lean's naming conventions).\n\nThe last level from addition world might help you in this level.\nIf you can't remember what it is, you can go back to the\nhome screen by clicking the house icon and then taking a look.\nYou won't lose any progress.": - "마찬가지로 `mul_succ`가 있지만 우리가 필요한 것은 `succ_mul`입니다(무슨 내용일지 맞혀 보세요. 이제 Lean의 이름 짓기 규칙이 좀 익숙해졌을지도 모르겠네요).\n\nAddition World의 마지막 level이 도움이 될 수 있습니다. 기억나지 않으면 집 모양 아이콘을 눌러 home 화면으로 돌아가 확인하세요. 진행 상황은 잃지 않습니다.", + "마찬가지로 `mul_succ`가 있지만 우리가 필요한 것은 `succ_mul`입니다(무슨 내용일지 맞혀 보세요. 이제 Lean의 이름 짓기 규칙이 좀 익숙해졌을지도 모르겠네요).\n\n덧셈 월드의 마지막 레벨이 도움이 될 수 있습니다. 기억나지 않으면 집 모양 아이콘을 눌러 home 화면으로 돌아가 확인하세요. 진행 상황은 잃지 않습니다.", "See the new \"*\" tab in your lemmas, containing `mul_zero` and `mul_succ`.\nRight now these are the only facts we know about multiplication.\nLet's prove nine more.\n\nLet's start with a warm-up: no induction needed for this one,\nbecause we know `1` is a successor.": - "lemma 목록에 새로 생긴 \"*\" 탭을 보세요. `mul_zero`와 `mul_succ`이 들어 있습니다. 지금은 이 둘만 곱셈에 대해 알고 있는 사실입니다. 이제 아홉 개를 더 증명합시다.\n\n먼저 준비운동부터 합니다. 이번에는 `1`가 successor라는 것을 알고 있으므로 귀납법이 필요 없습니다.", + "정리 목록에 새로 생긴 \"*\" 탭을 보세요. `mul_zero`와 `mul_succ`이 들어 있습니다. 지금은 이 둘만 곱셈에 대해 알고 있는 사실입니다. 이제 아홉 개를 더 증명합시다.\n\n먼저 준비운동부터 합니다. 이번에는 `1`이 다음수라는 것을 알고 있으므로 귀납법이 필요 없습니다.", "See if you can take it from here. Look at the new lemmas and tactic\navailable on the right.": - "이제부터는 스스로 해 보세요. 오른쪽에 새로 생긴 lemma와 tactic을 살펴보세요.", + "이제부터는 스스로 해 보세요. 오른쪽에 새로 생긴 정리와 택틱을 살펴보세요.", "Remember, `x ≠ y` is *notation* for `x = y → False`.": "`x ≠ y`는 `x = y → False`을 나타내는 *표기법*이라는 점을 기억하세요.", "Remember that when Lean writes `a + b + c`, it means `(a + b) + c`.\nIf you are not sure where the brackets are in an expression, just hover\nyour cursor over it and look at what gets highlighted. For example,\nhover over both `+` symbols on the left hand side of the goal and\nyou'll see where the invisible brackets are.": "Lean이 `a + b + c`라고 쓸 때는 `(a + b) + c`을 뜻한다는 점을 기억하세요. 식에서 괄호가 어디에 숨어 있는지 잘 모르겠다면 커서를 올려 어느 부분이 강조되는지 확인하면 됩니다. 예를 들어 목표의 왼쪽에 있는 두 `+` 기호 위에 각각 커서를 올려 보면 보이지 않는 괄호의 위치를 알 수 있습니다.", "Remember that `h2` is a proof of `x = y → False`. Try\n`apply`ing `h2` either `at h1` or directly to the goal.": - "`h2`가 `x = y → False`의 증명이라는 점을 기억하세요. `h2`에 `apply`를 `at h1`하거나 goal에 직접 `at h1`해 보세요.", + "`h2`가 `x = y → False`의 증명이라는 점을 기억하세요. `h2`에 `apply`를 `at h1`하거나 목표에 직접 `at h1`해 보세요.", "Reduce to the previous lemma with `nth_rewrite 2 [← mul_one a] at h`": - "`nth_rewrite 2 [← mul_one a] at h`를 사용해 이전 lemma로 환원하세요.", - "Ready for the boss level of this world?": "이 world의 boss level을 맞을 준비가 되었나요?", + "`nth_rewrite 2 [← mul_one a] at h`를 사용해 이전 정리로 환원하세요.", + "Ready for the boss level of this world?": "이 월드의 보스 레벨을 맞을 준비가 되었나요?", "Proofs like $2+2=4$ and $a+b+c+d+e=e+d+c+b+a$ are very tedious to do by hand.\nIn Algorithm World we learn how to get the computer to do them for us.\n\nClick on \"Start\" to proceed.": - "$2+2=4$나 $a+b+c+d+e=e+d+c+b+a$ 같은 증명을 손으로 하는 것은 아주 지루합니다. Algorithm World에서는 컴퓨터가 대신 하게 만드는 법을 배웁니다.\n\n\"Start\"를 눌러 진행하세요.", + "$2+2=4$나 $a+b+c+d+e=e+d+c+b+a$ 같은 증명을 손으로 하는 것은 아주 지루합니다. 알고리즘 월드에서는 컴퓨터가 대신 하게 만드는 법을 배웁니다.\n\n\"시작하기\"를 눌러 진행하세요.", "Precision rewriting": "정밀한 rewriting", - "Power World": "거듭제곱 월드", + "Power World": "지수 월드", "Our next goal is \"left and right distributivity\",\nmeaning $a(b+c)=ab+ac$ and $(b+c)a=ba+ca$. Rather than\nthese slightly pompous names, the name of the proofs\nin Lean are descriptive. Let's start with\n`mul_add a b c`, the proof of `a * (b + c) = a * b + a * c`.\nNote that the left hand side contains a multiplication\nand then an addition.": "다음 목표는 \"왼쪽과 오른쪽 분배법칙\", 즉 $a(b+c)=ab+ac$와 $(b+c)a=ba+ca$입니다. 이런 다소 거창한 이름 대신 Lean의 증명 이름은 내용을 그대로 설명합니다. 먼저 `mul_add a b c`, 즉 `a * (b + c) = a * b + a * c`의 증명부터 시작합시다. 왼쪽 항에는 먼저 곱셈이 있고 그다음 덧셈이 있다는 점에 주의하세요.", "Our first challenge is `mul_comm x y : x * y = y * x`,\nand we want to prove it by induction. The zero\ncase will need `mul_zero` (which we have)\nand `zero_mul` (which we don't), so let's\nstart with this.": "첫 도전은 `mul_comm x y : x * y = y * x`이며 귀납법으로 증명하려 합니다. 0 경우에는 `mul_zero`(이미 있음)과 `zero_mul`(아직 없음)가 필요하므로 이것부터 시작합시다.", "One of the best named levels in the game, a savage `pow_pow`\nsub-boss appears as the music reaches a frenzy. What\nelse could there be to prove about powers after this?": - "게임에서 이름이 가장 멋진 level 중 하나입니다. 음악이 절정으로 치닫는 가운데 흉악한 `pow_pow` sub-boss가 나타납니다. 이 뒤에 거듭제곱에 대해 또 무엇을 증명할 수 있을까요?", + "게임에서 이름이 가장 멋진 level 중 하나입니다. 음악이 절정으로 치닫는 가운데 흉악한 `pow_pow` 중간 보스가 나타납니다. 이 뒤에 거듭제곱에 대해 또 무엇을 증명할 수 있을까요?", "One day this game will have a Prime Number World, with a final boss\nof proving that $2$ is prime.\nTo do this, we will have to rule out things like $2 = 37 × 42.$\nWe will do this by proving that any factor of $2$ is at most $2$,\nwhich we will do using this lemma. The proof I have in mind manipulates the hypothesis\nuntil it becomes the goal, using `mul_left_ne_zero`, `one_le_of_ne_zero` and\n`mul_le_mul_right`.": - "언젠가 이 게임에는 소수 월드가 생기고, 최종 보스는 $2$가 소수임을 증명하는 문제가 될 겁니다. 이를 위해 $2 = 37 × 42.$ 같은 가능성을 배제해야 합니다. 어떤 $2$의 인수도 $2$ 이하임을 보임으로써 그렇게 할 것이고, 이 lemma를 사용합니다. 제가 생각한 증명은 `mul_left_ne_zero`, `one_le_of_ne_zero`, `mul_le_mul_right`를 이용해 가정을 goal이 될 때까지 변형합니다.", + "언젠가 이 게임에는 소수 월드가 생기고, 최종 보스는 $2$가 소수임을 증명하는 문제가 될 겁니다. 이를 위해 $2 = 37 × 42$ 같은 가능성을 배제해야 합니다. 어떤 $2$의 약수도 $2$ 이하임을 보임으로써 그렇게 할 것이고, 이 정리를 사용합니다. 제가 생각한 증명은 `mul_left_ne_zero`, `one_le_of_ne_zero`, `mul_le_mul_right`를 이용해 가정을 목표가 될 때까지 변형합니다.", "On the set of natural numbers, addition is commutative.\nIn other words, if `a` and `b` are arbitrary natural numbers, then\n$a + b = b + a$.": "자연수 집합에서 덧셈은 가환입니다. 즉 `a`와 `b`이 임의의 자연수라면 $a + b = b + a$입니다.", "On the set of natural numbers, addition is associative.\nIn other words, if $a, b$ and $c$ are arbitrary natural numbers, we have\n$ (a + b) + c = a + (b + c). $": @@ -455,12 +454,12 @@ "On the set of natural numbers, addition is associative.\nIn other words, for all natural numbers $a, b$ and $c$, we have\n$ (a + b) + c = a + (b + c). $": "On the set of natural numbers, addition is associative.\nIn other words, for all natural numbers $a, b$ and $c$, we have\n$ (a + b) + c = a + (b + c). $", "Oh no! On the way to `add_comm`, a wild `succ_add` appears. `succ_add a b`\nis the proof that `(succ a) + b = succ (a + b)` for `a` and `b` numbers.\nThis result is what's standing in the way of `x + y = y + x`. Again\nwe have the problem that we are adding `b` to things, so we need\nto use induction to split into the cases where `b = 0` and `b` is a successor.": - "이런! `add_comm`로 가는 길에 야생의 `succ_add`이 나타났습니다. `succ_add a b`는 `a`와 `b`가 수일 때 `(succ a) + b = succ (a + b)`이라는 것의 증명입니다. 이 결과가 `x + y = y + x`을 막고 있습니다. 다시 `b`을 어떤 것에 더하고 있으므로 귀납법으로 `b = 0`인 경우와 `b`가 successor인 경우를 나눠야 합니다.", + "이런! `add_comm`로 가는 길에 야생의 `succ_add`이 나타났습니다. `succ_add a b`는 `a`와 `b`가 수일 때 `(succ a) + b = succ (a + b)`이라는 것의 증명입니다. 이 결과가 `x + y = y + x`을 막고 있습니다. 다시 `b`을 어떤 것에 더하고 있으므로 귀납법으로 `b = 0`인 경우와 `b`가 다음수인 경우를 나눠야 합니다.", "Numbers": "수", "Now you need to figure out which number to `use`. See if you can take it from here.": "이제 어떤 수를 `use`해야 하는지 알아내야 합니다. 여기서부터는 스스로 해 보세요.", "Now you have two goals. Once you proved the first, you will jump to the second one.\nThis first goal is the base case $n = 0$.\n\nRecall that you can rewrite the proof of any lemma which is visible\nin your inventory, or of any assumption displayed above the goal,\nas long as it is of the form `X = Y`.": - "이제 goal이 두 개 생겼습니다. 첫 번째를 증명하면 두 번째로 넘어갑니다. 첫 goal은 기저 경우 $n = 0$입니다.\n\ninventory에 보이는 lemma의 증명이나 goal 위에 표시된 가정은 `X = Y` 꼴이기만 하면 언제든 rewrite에 사용할 수 있다는 점을 기억하세요.", + "이제 목표가 두 개 생겼습니다. 첫 번째를 증명하면 두 번째로 넘어갑니다. 첫 목표는 기저 단계 $n = 0$입니다.\n\n인벤토리에 보이는 정리의 증명이나 목표 위에 표시된 가정은 `X = Y` 꼴이기만 하면 언제든 rewrite에 사용할 수 있다는 점을 기억하세요.", "Now you could finish with `rw [«{h}»]` then `rfl`, but `exact «{h}»`\ndoes it in one line.": "이제 `rw [«{h}»]` 다음 `rfl`로 끝낼 수도 있지만, `exact «{h}»`면 한 줄에 됩니다.", "Now you can `rw [add_succ]`": "이제 `rw [add_succ]`할 수 있습니다.", @@ -469,24 +468,24 @@ "Now you can `apply le_mul_right at h2`.": "이제 `apply le_mul_right at h2`를 할 수 있습니다.", "Now we can prove the `or` statement by proving the statement on the right,\nso use the `right` tactic.": - "이제 오른쪽 명제를 증명함으로써 `or` 명제를 증명할 수 있으므로 `right` tactic을 사용하세요.", + "이제 오른쪽 명제를 증명함으로써 `or` 명제를 증명할 수 있으므로 `right` 택틱을 사용하세요.", "Now use `rw [add_left_comm b c]` to switch `b` and `c` on the left\nhand side.": "이제 `rw [add_left_comm b c]`를 사용해 왼쪽의 `b`과 `c`를 바꾸세요.", "Now the goal can be deduced from `h2` by pure logic, so use the `tauto`\ntactic.": - "이제 순수한 논리만으로 `h2`에서 goal이 따라오므로 `tauto` tactic을 사용하세요.", + "이제 순수한 논리만으로 `h2`에서 목표가 따라오므로 `tauto` 택틱을 사용하세요.", "Now take apart the existence statement with `cases ha with n hn`.": "이제 `cases ha with n hn`를 사용해 존재 명제를 분해하세요.", "Now rewrite `succ_eq_add_one` backwards at `h`\nto get the right hand side.": "이제 `h`에서 `succ_eq_add_one`를 거꾸로 rewrite해 오른쪽 항을 얻으세요.", "Now rewrite `four_eq_succ_three` backwards to make the goal\nequal to the hypothesis.": - "이제 `four_eq_succ_three`를 거꾸로 rewrite해서 goal을 가정과 같게 만드세요.", + "이제 `four_eq_succ_three`를 거꾸로 rewrite해서 목표를 가정과 같게 만드세요.", "Now let's `apply` our new theorem. Execute `apply succ_inj at h`\nto change `h` to a proof of `x = 3`.": "이제 새 정리를 `apply`해 봅시다. `apply succ_inj at h`을 실행해 `h`를 `x = 3`의 증명으로 바꾸세요.", "Now for to the second goal. Here you have the induction hypothesis\n`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`.": - "이제 for to the second goal. Here you have the induction hypothesis\n`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`.", + "이제 두 번째 목표를 보겠습니다. 여기에는 귀납 가설\n`«{hd}» : 0 + «{d}» = «{d}»`이 주어져 있고, `0 + succ «{d}» = succ «{d}»`를 증명해야 합니다.", "Now for the second goal. Here you have the induction hypothesis\n§0, and you need to prove that §1.": - "이제 두 번째 goal입니다. 여기에는 귀납가정 §0가 있고 §1을 증명해야 합니다.", - "Now finish using the `exact` tactic.": "이제 `exact` tactic을 사용해 마무리하세요.", + "이제 두 번째 목표입니다. 여기에는 귀납가정 §0가 있고 §1을 증명해야 합니다.", + "Now finish using the `exact` tactic.": "이제 `exact` 택틱을 사용해 마무리하세요.", "Now finish the job with `rfl`.": "이제 `rfl`로 마무리하세요.", "Now finish in one line.": "이제 한 줄로 마무리하세요.", "Now change `1` to `succ 0` in `h`.": "이제 `h`에서 `1`를 `succ 0`로 바꾸세요.", @@ -512,15 +511,15 @@ "Now `apply h` and you can probably take it from here.": "이제 `apply h`를 하고 나면 아마 나머지는 스스로 할 수 있을 겁니다.", "Note: this lemma will be useful for the final boss!": - "참고: 이 lemma는 final boss에서 유용합니다!", + "참고: 이 정리는 최종 보스에서 유용합니다!", "Note that you can do `rw [two_eq_succ_one, one_eq_succ_zero]`\nand then `rfl` to solve this level in two lines.": - "`rw [two_eq_succ_one, one_eq_succ_zero]` 다음 `rfl`을 하면 이 level을 두 줄로 해결할 수 있다는 점에 주의하세요.", + "`rw [two_eq_succ_one, one_eq_succ_zero]` 다음 `rfl`을 하면 이 레벨을 두 줄로 해결할 수 있다는 점에 주의하세요.", "Note that `succ a + «{d}»` means `(succ a) + «{d}»`. Put your cursor\non any `succ` in the goal or assumptions to see what exactly it's eating.": - "`succ a + «{d}»`가 `(succ a) + «{d}»`을 뜻한다는 점에 주의하세요. goal이나 가정에 있는 아무 `succ` 위에 커서를 올려 정확히 무엇을 먹고 있는지 확인해 보세요.", + "`succ a + «{d}»`가 `(succ a) + «{d}»`을 뜻한다는 점에 주의하세요. 목표가나 가정에 있는 아무 `succ` 위에 커서를 올려 정확히 무엇을 먹고 있는지 확인해 보세요.", "Nice! You've proved `succ_inj`!\nLet's now prove Peano's other axiom, that successors can't be $0$.": - "좋습니다! `succ_inj`를 증명했습니다! 이제 페아노의 다른 공리, successor는 $0$일 수 없다는 것을 증명합시다.", + "좋습니다! `succ_inj`를 증명했습니다! 이제 페아노의 다른 공리, 다음수는 $0$일 수 없다는 것을 증명합시다.", "Nice!\n\nThe next step in the development of order theory is to develop\nthe theory of the interplay between `≤` and multiplication.\nIf you've already done Multiplication World, you're now ready for\nAdvanced Multiplication World. Click on \"Home\" to access it.": - "좋습니다!\n\n순서론에서 다음 단계는 `≤`와 곱셈이 어떻게 상호작용하는지 알아보는 것입니다. Multiplication World를 이미 끝냈다면 이제 Advanced Multiplication World에 도전할 준비가 되었습니다. \"Home\"을 눌러 이동하세요.", + "좋습니다!\n\n순서론에서 다음 단계는 `≤`와 곱셈이 어떻게 상호작용하는지 알아보는 것입니다. 곱셈 월드를 이미 끝냈다면 이제 고급 곱셈 월드에 도전할 준비가 되었습니다. \"홈\"을 눌러 이동하세요.", "Nice!": "좋습니다!", "Next turn `1` into `succ 0` with `rw [one_eq_succ_zero]`.": "다음으로 `rw [one_eq_succ_zero]`를 사용해 `1`를 `succ 0`로 바꾸세요.", @@ -528,7 +527,7 @@ "My proof:\n```\ncases h with d hd\nuse d * t\nrw [hd, add_mul]\nrfl\n```": "제 증명:\n```\ncases h with d hd\nuse d * t\nrw [hd, add_mul]\nrfl\n```", "Multiplication usually makes a number bigger, but multiplication by zero can make\nit smaller. Thus many lemmas about inequalities and multiplication need the\nhypothesis `a ≠ 0`. Here is a key lemma that enables us to use this hypothesis.\nTo help us with the proof, we can use the `tauto` tactic. Click on the tactic's name\non the right to see what it does.": - "곱셈은 보통 수를 더 크게 만들지만 0을 곱하면 더 작게 만들 수도 있습니다. 그래서 부등식과 곱셈에 관한 많은 lemma에는 가정 `a ≠ 0`가 필요합니다. 여기서는 이 가정을 활용할 수 있게 해 주는 핵심 lemma를 증명합니다. 증명을 돕기 위해 `tauto` tactic을 사용할 수 있습니다. 오른쪽에서 tactic 이름을 눌러 무엇을 하는지 확인하세요.", + "곱셈은 보통 수를 더 크게 만들지만 0을 곱하면 더 작게 만들 수도 있습니다. 그래서 부등식과 곱셈에 관한 많은 정리에는 가정 `a ≠ 0`가 필요합니다. 여기서는 이 가정을 활용할 수 있게 해 주는 핵심 정리를 증명합니다. 증명을 돕기 위해 `tauto` 택틱을 사용할 수 있습니다. 오른쪽에서 택틱 이름을 눌러 무엇을 하는지 확인하세요.", "Multiplication is distributive over addition on the left.\nIn other words, for all natural numbers $a$, $b$ and $c$, we have\n$a(b + c) = ab + ac$.": "곱셈은 왼쪽에서 덧셈에 대해 분배법칙을 만족합니다. 즉 모든 자연수 $a$, $b$, $c$에 대해 $a(b + c) = ab + ac$이 성립합니다.", "Multiplication is commutative.": "곱셈은 가환입니다.", @@ -538,31 +537,30 @@ "곱셈은 왼쪽에서 덧셈에 대해 분배됩니다.\n\n`mul_add a b c`는 `a * (b + c) = a * b + a * c`의 증명입니다.", "Multiplication World": "곱셈 월드", "Mathematicians sometimes debate what `0 ^ 0` is;\nthe answer depends, of course, on your definitions. In this\ngame, `0 ^ 0 = 1`. See if you can prove it.\n\nCheck out the *Pow* tab in your list of theorems\nto see the new proofs which are available.": - "수학자들은 가끔 `0 ^ 0`가 무엇인지 논쟁합니다. 물론 답은 정의에 달려 있습니다. 이 게임에서는 `0 ^ 0 = 1`입니다. 증명해 보세요.\n\n새로 사용할 수 있는 증명은 theorem 목록의 *Pow* 탭에서 확인하세요.", + "수학자들은 가끔 `0 ^ 0`가 무엇인지 논쟁합니다. 물론 답은 정의에 달려 있습니다. 이 게임에서는 `0 ^ 0 = 1`입니다. 증명해 보세요.\n\n새로 사용할 수 있는 증명은 정리 목록의 ^ 탭에서 확인하세요.", "Mathematicians sometimes argue that `0 ^ 0 = 0` is also\na good convention. But it is not a good convention in this\ngame; all the later levels come out beautifully with the\nconvention that `0 ^ 0 = 1`.": - "수학자들은 가끔 `0 ^ 0 = 0`도 좋은 관례라고 주장합니다. 하지만 이 게임에서는 좋은 관례가 아닙니다. `0 ^ 0 = 1`이라는 관례를 택하면 뒤의 level들이 아주 아름답게 풀리기 때문입니다.", + "수학자들은 가끔 `0 ^ 0 = 0`도 좋은 관례라고 주장합니다. 하지만 이 게임에서는 좋은 관례가 아닙니다. `0 ^ 0 = 1`이라는 관례를 택하면 뒤의 레벨들이 아주 아름답게 풀리기 때문입니다.", "Many people find `apply t at h` easy, but some find `apply t` confusing.\nIf you find it confusing, then just argue forwards.\n\nYou can read more about the `apply` tactic in its documentation, which you can view by\nclicking on the tactic in the list on the right.": - "많은 사람은 `apply t at h`는 쉽다고 느끼지만 `apply t`은 헷갈려 합니다. 헷갈린다면 그냥 앞에서부터 추론하세요.\n\n`apply` tactic에 대한 자세한 설명은 오른쪽 tactic 목록에서 클릭해 볼 수 있습니다.", + "많은 사람은 `apply t at h`는 쉽다고 느끼지만 `apply t`은 헷갈려 합니다. 헷갈린다면 그냥 앞에서부터 추론하세요.\n\n`apply` 택틱에 대한 자세한 설명은 오른쪽 택틱 목록에서 클릭해 볼 수 있습니다.", "Let's warm up with an easy one, which works even if `t = 0`.": "`t = 0`인 경우에도 작동하는 쉬운 문제로 몸을 풀어 봅시다.", "Let's see if you can use the tactics we've learnt to prove $x+1=y+1\\implies x=y$.\nTry this one by yourself; if you need help then click on \"Show more help!\".": - "지금까지 배운 tactic들을 사용해 $x+1=y+1\\implies x=y$를 증명해 보세요. 먼저 혼자 시도해 보고, 도움이 필요하면 \"도움말 더 보기!\"를 누르세요.", + "지금까지 배운 택틱들을 사용해 $x+1=y+1\\implies x=y$를 증명해 보세요. 먼저 혼자 시도해 보고, 도움이 필요하면 \"도움말 더 보기!\"를 누르세요.", "Let's now move on to a more efficient approach to questions\ninvolving numerals, such as `20 + 20 = 40`.": "이제 `20 + 20 = 40` 같은 숫자 관련 문제를 더 효율적으로 푸는 방법으로 넘어갑시다.", - "Let's now make our own tactic to do this.": - "이제 이 일을 하는 우리만의 tactic을 만들어 봅시다.", + "Let's now make our own tactic to do this.": "이제 이 일을 하는 우리만의 택틱을 만들어 봅시다.", "Let's now learn about Peano's second axiom for addition, `add_succ`.": "이제 덧셈에 관한 페아노의 두 번째 공리 `add_succ`를 배워 봅시다.", "Let's now begin our approach to the final boss,\nby proving some more subtle facts about powers.": - "이제 거듭제곱에 관한 좀 더 미묘한 사실들을 증명하면서 final boss로 가는 길을 시작합시다.", + "이제 거듭제곱에 관한 좀 더 미묘한 사실들을 증명하면서 최종 보스로 가는 길을 시작합시다.", "Let's first get `h` into the form `succ x = succ 3` so we can\napply `succ_inj`. First execute `rw [four_eq_succ_three] at h`\nto change the 4 on the right hand side.": "먼저 `succ_inj`를 적용할 수 있도록 `h`를 `succ x = succ 3` 꼴로 바꿉시다. 오른쪽의 4를 바꾸기 위해 먼저 `rw [four_eq_succ_three] at h`을 해보세요..", "Lean's simplifier, `simp`, is \"`rw` on steroids\". It will rewrite every lemma\ntagged with `simp` and every lemma fed to it by the user, as much as it can.\n\nThis level is not a level which you want to solve by hand.\nGet the simplifier to solve it for you.": - "Lean의 simplifier `simp`는 \"`rw`에 스테로이드를 먹인 것\"과 같습니다. `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다.\n\n이 level은 손으로 풀고 싶을 만한 문제가 아닙니다. simplifier에게 맡기세요.", + "Lean의 simplifier `simp`는 \"`rw`에 스테로이드를 먹인 것\"과 같습니다. `simp` 태그가 붙은 모든 정리와 사용자가 넣어 준 모든 정리를 가능한 한 계속 rewrite합니다.\n\n이 레벨은 손으로 풀고 싶을 만한 문제가 아닙니다. simplifier에게 맡기세요.", "It's all over! You have proved a theorem which has tripped up\nschoolkids for generations (some of them think $(a+b)^2=a^2+b^2$:\nthis is \"the freshman's dream\").\n\nHow many rewrites did you use? I can do it in 12.\n\nBut wait! This boss is stirring...and mutating into a second more powerful form!": "끝났습니다! 여러 세대의 학생들을 괴롭혀 온 정리를 증명했습니다\n(어떤 학생들은 $(a+b)^2=a^2+b^2$라고 생각하죠. 이것이 바로 “새내기의 꿈”입니다).\n\nrewrite를 몇 번 썼나요? 저는 12번이면 됩니다.\n\n그런데 잠깐! 보스가 꿈틀거리더니... 더 강력한 두 번째 형태로 변신합니다!", "It's \"intuitively obvious\" that there are no numbers less than zero,\nbut to prove it you will need a result which you showed in advanced\naddition world.": - "0보다 작은 수가 없다는 것은 \"직관적으로 명백\"하지만, 이를 증명하려면 Advanced Addition World에서 증명한 결과가 필요합니다.", + "0보다 작은 수가 없다는 것은 \"직관적으로 명백\"하지만, 이를 증명하려면 고급 덧셈 월드에서 증명한 결과가 필요합니다.", "Induction on `a` will not work here. You are still stuck with an `+ b`.\nI suggest you delete this line and try a different approach.": "Induction on `a` will not work here. You are still stuck with an `+ b`.\nI suggest you delete this line and try a different approach.", "Induction on `a` or `b` -- it's all the same in this one.": @@ -570,52 +568,52 @@ "Induction on `a` is the most troublesome, then `b`,\nand `c` is the easiest.": "`a`에 대한 귀납이 가장 까다롭고, 그다음이 `b`, `c`가 가장 쉽습니다.", "In this world we'll learn how to prove theorems of the form $P\\implies Q$.\nIn other words, how to prove theorems of the form \"if $P$ is true, then $Q$ is true.\"\nTo do that we need to learn some more tactics.\n\nThe `exact` tactic can be used to close a goal which is exactly one of\nthe hypotheses. It takes the name of the hypothesis as argument: `exact h`.": - "이 world에서는 $P\\implies Q$ 꼴의 정리를 증명하는 법을 배웁니다. 즉 \"$P$이 참이면 $Q$가 참이다\" 꼴의 정리를 증명하는 법입니다. 이를 위해 몇 가지 tactic을 더 배워야 합니다.\n\n`exact` tactic은 goal이 가정 중 하나와 정확히 같을 때 goal을 닫을 수 있습니다. 인자로 가정의 이름을 받습니다: `exact h`.", + "이 월드에서는 $P\\implies Q$ 꼴의 정리를 증명하는 법을 배웁니다. 즉 \"$P$이 참이면 $Q$가 참이다\" 꼴의 정리를 증명하는 법입니다. 이를 위해 몇 가지 택틱을 더 배워야 합니다.\n\n`exact` 택틱은 목표가 가정 중 하나와 정확히 같을 때 목표를 닫을 수 있습니다. 인자로 가정의 이름을 받습니다: `exact h`.", "In this world we define `a ≤ b` and prove standard facts\nabout it, such as \"if `a ≤ b` and `b ≤ c` then `a ≤ c`.\"\n\nThe definition of `a ≤ b` is \"there exists a number `c`\nsuch that `b = a + c`. \" So we're going to have to learn\na tactic to prove \"exists\" theorems, and another one\nto use \"exists\" hypotheses.\n\nClick on \"Start\" to proceed.": - "이 world에서는 `a ≤ b`를 정의하고, \"`a ≤ b`이고 `b ≤ c`이면 `a ≤ c`\" 같은 표준적인 성질을 증명합니다.\n\n`a ≤ b`의 정의는 \"`b = a + c`를 만족하는 수 `c`가 존재한다\"입니다. 따라서 \"존재한다\"는 정리를 증명하는 tactic과 \"존재한다\"는 가정을 사용하는 tactic을 배워야 합니다.\n\n\"Start\"를 눌러 진행하세요.", + "이 월드에서는 `a ≤ b`를 정의하고, \"`a ≤ b`이고 `b ≤ c`이면 `a ≤ c`\" 같은 표준적인 성질을 증명합니다.\n\n`a ≤ b`의 정의는 \"`b = a + c`를 만족하는 수 `c`가 존재한다\"입니다. 따라서 \"존재한다\"는 정리를 증명하는 택틱과 \"존재한다\"는 가정을 사용하는 택틱을 배워야 합니다.\n\n\"시작하기\"를 눌러 진행하세요.", "In this world I will mostly leave you on your own.\n\n`add_right_cancel a b n` is the theorem that $a+n=b+n\\implies a=b$.": - "이 world에서는 대부분 여러분 스스로 하도록 두겠습니다.\n\n`add_right_cancel a b n`는 $a+n=b+n\\implies a=b$이라는 정리입니다.", + "이 월드에서는 대부분 여러분 스스로 하도록 두겠습니다.\n\n`add_right_cancel a b n`는 $a+n=b+n\\implies a=b$이라는 정리입니다.", "In this level, we see inequalities as *hypotheses*. We have not seen this before.\nThe `cases` tactic can be used to take `hxy` apart.": - "이 level에서는 부등식을 *가정*으로 처음 만나 봅니다. `cases` tactic을 사용하면 `hxy`을 분해할 수 있습니다.", + "이 레벨에서는 부등식을 *가정*으로 처음 만나 봅니다. `cases` 택틱을 사용하면 `hxy`을 분해할 수 있습니다.", "In this level, the hypothesis §0 is an *implication*. It says\nthat *if* §1 *then* §2. We can use this\nhypothesis with the §3 tactic. Remember you can click on\n§4 or any other tactic on the right to see a detailed explanation\nof what it does, with examples.": - "이 level의 가정 §0는 *함의*입니다. 즉 *§1이면 §2*라는 뜻입니다. 이 가정은 §3 tactic으로 사용할 수 있습니다. 오른쪽의 §4나 다른 tactic을 클릭하면 예시와 함께 자세한 설명을 볼 수 있다는 점을 기억하세요.", + "이 레벨의 가정 §0는 *조건문*입니다. 즉 *§1이면 §2*라는 뜻입니다. 이 가정은 §3 택틱으로 사용할 수 있습니다. 오른쪽의 §4나 다른 택틱을 클릭하면 예시와 함께 자세한 설명을 볼 수 있다는 점을 기억하세요.", "In this level, the hypotheses `h2` is an *implication*. It says\nthat *if* `x = 37` *then* `y = 42`. We can use this\nhypothesis with the `apply` tactic. Remember you can click on\n`apply` or any other tactic on the right to see a detailed explanation\nof what it does, with examples.": - "In this level, the hypotheses `h2` is an *implication*. It says\nthat *if* `x = 37` *then* `y = 42`. We can use this\nhypothesis with the `apply` tactic. Remember you can click on\n`apply` or any other tactic on the right to see a detailed explanation\nof what it does, with examples.", + "이 레벨에서 가정 `h2`는 *조건문*입니다. 즉,\n*만약* `x = 37`이라면 `y = 42`라는 뜻입니다.\n이 가정은 `apply` 택틱을 사용해 활용할 수 있습니다. 오른쪽에 있는\n`apply`나 다른 택틱을 클릭하면, 그 택틱이 무엇을 하는지 예시와 함께\n자세한 설명을 볼 수 있다는 점을 기억하세요.", "In this level we're going to prove that $0+n=n$, where $n$ is a secret natural number.\n\nWait, don't we already know that? No! We know that $n+0=n$, but that's `add_zero`.\nThis is `zero_add`, which is different.\n\nThe difficulty with proving `0 + n = n` is that we do not have a *formula* for\n`0 + n` in general, we can only use `add_zero` and `add_succ` once\nwe know whether `n` is `0` or a successor. The `induction` tactic splits into these two cases.\n\nThe base case will require us to prove `0 + 0 = 0`, and the inductive step\nwill ask us to show that if `0 + d = d` then `0 + succ d = succ d`. Because\n`0` and successor are the only way to make numbers, this will cover all the cases.\n\nSee if you can do your first induction proof in Lean.\n\n(By the way, if you are still in the \"Editor mode\" from the last world, you can swap\nback to \"Typewriter mode\" by clicking the `>_` button in the top right.)": - "이 level에서는 $0+n=n$를 증명합니다. 여기서 $n$은 값이 공개되지 않은 자연수입니다.\n\n잠깐, 이건 이미 아는 것 아닌가요? 아닙니다! 우리가 아는 것은 $n+0=n$인데, 그건 `add_zero`입니다. 지금 필요한 것은 `zero_add`이고, 둘은 다릅니다.\n\n`0 + n = n`를 증명하기 어려운 이유는 일반적인 `0 + n`에 대한 *공식*이 없기 때문입니다. `n`가 $n$0인지 successor인지 알아야만 `add_zero`과 `add_succ`을 사용할 수 있습니다. $n$1 tactic은 이 두 경우로 나눠 줍니다.\n\n기저 경우에서는 $n$2를 증명해야 하고, 귀납 단계에서는 $n$3이면 $n$4임을 보이라는 목표가 생깁니다. 수를 만드는 방법은 $n$5와 successor뿐이므로 이것으로 모든 경우를 다룹니다.\n\nLean에서 첫 귀납 증명을 해 보세요.\n\n(참고로 이전 world에서 아직 \"Editor mode\"에 있다면, 오른쪽 위의 $n$6 버튼을 눌러 \"Typewriter mode\"로 돌아갈 수 있습니다.)", + "이 레벨에서는 $0+n=n$를 증명합니다. 여기서 $n$은 값이 공개되지 않은 자연수입니다.\n\n잠깐, 이건 이미 아는 것 아닌가요? 아닙니다! 우리가 아는 것은 $n+0=n$인데, 그건 `add_zero`입니다. 지금 필요한 것은 `zero_add`이고, 둘은 다릅니다.\n\n`0 + n = n`를 증명하기 어려운 이유는 일반적인 `0 + n`에 대한 *공식*이 없기 때문입니다. `n`가 `0`인지 다음수인지 알아야만 `add_zero`과 `add_succ`을 사용할 수 있습니다. `induction` 택틱은 이 두 경우로 나눠 줍니다.\n\n기저 단계에서는 `0 + 0 = 0`를 증명해야 하고, 귀납 단계에서는 `0 + d = d`이면 `0 + succ d = succ d`임을 보이라는 목표가 생깁니다. 수를 만드는 방법은 `0`와 다음수뿐이므로 이것으로 모든 수에 대한 증명이 끝납니다.\n\nLean에서 첫 귀납 증명을 해 보세요.\n\n(참고로 이전 월드에서 아직 \"편집기 모드\"에 있다면, 오른쪽 위의 $n$6 버튼을 눌러 \"타자기 모드\"로 돌아갈 수 있습니다.)", "In this level we prove that if `a * b = a * c` and `a ≠ 0` then `b = c`. It is tricky, for\nseveral reasons. One of these is that\nwe need to introduce a new idea: we will need to understand the concept of\nmathematical induction a little better.\n\nStarting with `induction b with d hd` is too naive, because in the inductive step\nthe hypothesis is `a * d = a * c → d = c` but what we know is `a * succ d = a * c`,\nso the induction hypothesis does not apply!\n\nAssume `a ≠ 0` is fixed. The actual statement we want to prove by induction on `b` is\n\"for all `c`, if `a * b = a * c` then `b = c`\". This *can* be proved by induction,\nbecause we now have the flexibility to change `c`.": - "이 level에서는 `a * b = a * c`와 `a ≠ 0`이면 `b = c`임을 증명합니다. 여러 이유로 까다로운데, 그중 하나는 새로운 생각이 필요하다는 점입니다. 수학적 귀납법을 조금 더 깊이 이해해야 합니다.\n\n`induction b with d hd`으로 시작하는 것은 너무 순진합니다. 귀납 단계에서 귀납가정은 `a * d = a * c → d = c`인데 실제로 알고 있는 것은 `a * succ d = a * c`이므로 귀납가정을 적용할 수 없기 때문입니다!\n\n`a ≠ 0`가 고정되어 있다고 합시다. `b`에 대해 실제로 귀납하여 증명해야 하는 명제는 \"모든 `c`에 대해, `a * b = a * c`이면 `a ≠ 0`0\"입니다. 이렇게 하면 `a ≠ 0`1을 바꿀 수 있는 여지가 생기므로 귀납법으로 증명할 *수 있습니다*.", + "이 레벨에서는 `a * b = a * c`와 `a ≠ 0`이면 `b = c`임을 증명합니다. 여러 이유로 까다로운데, 그중 하나는 새로운 생각이 필요하다는 점입니다. 수학적 귀납법을 조금 더 깊이 이해해야 합니다.\n\n`induction b with d hd`으로 시작하는 것은 너무 순진합니다. 귀납 단계에서 귀납가정은 `a * d = a * c → d = c`인데 실제로 알고 있는 것은 `a * succ d = a * c`이므로 귀납가정을 적용할 수 없기 때문입니다!\n\n`a ≠ 0`가 고정되어 있다고 합시다. `b`에 대해 실제로 귀납하여 증명해야 하는 명제는\n\"모든 `c`에 대해, `a * b = a * c`이면 `b = c`\"입니다. 이렇게 하면 `c`를 바꿀 수 있는 여지가 생기므로 귀납법 증명이 *가능*해집니다.", "In this level the *goal* is §0 but to help us we\nhave an *assumption* §1 saying that §2. Check that you can see §3 in\nyour list of assumptions. Lean thinks of §4 as being a secret proof of the\nassumption, rather like §5 is a secret number.\n\nBefore we can use §6, we have to \"substitute in for §7\".\nWe do this in Lean by *rewriting* the goal with §8,\nusing the §9 tactic.": - "이 level의 *goal*은 §0이지만, 이를 돕기 위해 §2라고 말하는 *가정* §1이 있습니다. 가정 목록에서 §3이 보이는지 확인하세요. Lean은 §4를 이 가정의 비밀스러운 증명이라고 생각합니다. §5가 비밀스러운 수인 것과 비슷합니다.\n\n§6을 쓰기 전에 먼저 \"§7에 대입\"해야 합니다. Lean에서는 §9 tactic을 사용해 증명 §8을 *rewriting*함으로써 이를 수행합니다.", + "이 레벨의 *목표*는 §0이지만, 이를 돕기 위해 §2라고 말하는 *가정* §1이 있습니다. 가정 목록에서 §3이 보이는지 확인하세요. Lean은 §4를 이 가정의 비밀스러운 증명이라고 생각합니다. §5가 비밀스러운 수인 것과 비슷합니다.\n\n§6을 쓰기 전에 먼저 \"§7에 대입\"해야 합니다. Lean에서는 §9 택틱을 사용해 증명 §8을 *rewriting*함으로써 이를 수행합니다.", "In this level the *goal* is $2y=2(x+7)$ but to help us we\nhave an *assumption* `h` saying that $y = x + 7$. Check that you can see `h` in\nyour list of assumptions. Lean thinks of `h` as being a secret proof of the\nassumption, rather like `x` is a secret number.\n\nBefore we can use `rfl`, we have to \"substitute in for $y$\".\nWe do this in Lean by *rewriting* the proof `h`,\nusing the `rw` tactic.": - "In this level the *goal* is $2y=2(x+7)$ but to help us we\nhave an *assumption* `h` saying that $y = x + 7$. Check that you can see `h` in\nyour list of assumptions. Lean thinks of `h` as being a secret proof of the\nassumption, rather like `x` is a secret number.\n\nBefore we can use `rfl`, we have to \"substitute in for $y$\".\nWe do this in Lean by *rewriting* the proof `h`,\nusing the `rw` tactic.", + "이 레벨의 *목표*는 $2y=2(x+7)$ 이지만 도움을 위해\n$y = x + 7$라는 *가정* `h`가 있습니다. Assumption이라 적힌 목록에 `h`를\n볼 수 있는지 체크해보세요. Lean은 `h`를 그 가정의 비밀스런 증명으로 생각합니다.\n마치 `x`를 비밀스런 수로 생각하는 것처럼요.\n\n`rfl`을 사용할 수 있게 되려면, 우리는 \"$y$를 치환\"해야 합니다.\nLean에서는 `h`를 *재작성(rewrite)* 함으로써 치환이 가능합니다.\n`rw` 택틱을 사용해 보세요", "In this game you recreate the natural numbers $\\mathbb{N}$ from the Peano axioms,\nlearning the basics about theorem proving in Lean.\n\nThis is a good first introduction to Lean!": "이 게임에서는 페아노 공리로부터 자연수 $\\mathbb{N}$를 다시 만들어 가면서 Lean에서 정리를 증명하는 기초를 배웁니다.\n\nLean을 처음 접하기에 좋은 입문입니다!", "In the next level, we'll do the same proof but backwards.": - "다음 level에서는 같은 증명을 거꾸로 해 보겠습니다.", + "다음 레벨에서는 같은 증명을 거꾸로 해 보겠습니다.", "In the last level, we manipulated the hypothesis `x + 1 = 4`\n until it became the goal `x = 3`. In this level we'll manipulate\n the goal until it becomes our hypothesis! In other words, we\n will \"argue backwards\". The `apply` tactic can do this too.\n Again I will walk you through this one (assuming you're in\n command line mode).": - "지난 level에서는 가정 `x + 1 = 4`를 goal `x = 3`이 될 때까지 변형했습니다. 이번에는 반대로 goal을 가정이 될 때까지 변형합니다! 즉 \"거꾸로 추론\"할 것입니다. `apply` tactic도 이렇게 사용할 수 있습니다. 이번에도 command line mode라고 가정하고 단계별로 안내하겠습니다.", + "지난 레벨에서는 가정 `x + 1 = 4`를 목표 `x = 3`이 될 때까지 변형했습니다. 이번에는 반대로 목표를 가정이 될 때까지 변형합니다! 즉 \"거꾸로 추론\"할 것입니다. `apply` 택틱도 이렇게 사용할 수 있습니다. 이번에도 타자기 모드라고 가정하고 단계별로 안내하겠습니다.", "In the \"base case\" we have a hypothesis `ha : 0 ≠ 0`, and you can deduce anything\nfrom a false statement. The `tauto` tactic will close this goal.": - "\"기저 경우\"에서는 가정 `ha : 0 ≠ 0`가 있습니다. 거짓 명제에서는 무엇이든 이끌어낼 수 있으므로 `tauto` tactic이 이 goal을 닫습니다.", + "\"기저 단계\"에서는 가정 `ha : 0 ≠ 0`가 있습니다. 거짓 명제에서는 무엇이든 이끌어낼 수 있으므로 `tauto` 택틱이 이 목표를 닫습니다.", "In some later worlds, we're going to see some much nastier levels,\nlike `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`.\nBrackets need to be moved around, and variables need to be swapped.\n\nIn this level, `(a + b) + (c + d) = ((a + c) + d) + b`,\nlet's forget about the brackets and just think about\nthe variable order.\nTo turn `a+b+c+d` into `a+c+d+b` we need to swap `b` and `c`,\nand then swap `b` and `d`. But this is easier than you\nthink with `add_left_comm`.": - "뒤쪽 world에서는 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`처럼 훨씬 더 험악한 level들을 만나게 됩니다. 괄호를 옮기고 변수들의 순서도 바꿔야 합니다.\n\n이 level의 `(a + b) + (c + d) = ((a + c) + d) + b`에서는 괄호는 잠시 잊고 변수의 순서만 생각해 봅시다. `a+b+c+d`를 `a+c+d+b`으로 바꾸려면 `b`와 `c`를 바꾸고, 이어서 `b`와 `d`을 바꿔야 합니다. 하지만 `add_left_comm`을 쓰면 생각보다 쉽습니다.", + "뒤쪽 월드에서는 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`처럼 훨씬 더 험악한 레벨들을 만나게 됩니다. 괄호를 옮기고 변수들의 순서도 바꿔야 합니다.\n\n이 레벨의 `(a + b) + (c + d) = ((a + c) + d) + b`에서는 괄호는 잠시 잊고 변수의 순서만 생각해 봅시다. `a+b+c+d`를 `a+c+d+b`으로 바꾸려면 `b`와 `c`를 바꾸고, 이어서 `b`와 `d`을 바꿔야 합니다. 하지만 `add_left_comm`을 쓰면 생각보다 쉽습니다.", "In order to use the tactic `rfl` you can enter it in the text box\nunder the goal and hit \"Execute\".": - "`rfl` tactic을 사용하려면 goal 아래의 텍스트 상자에 입력한 뒤 \"Execute\"를 누르면 됩니다.", + "`rfl` 택틱을 사용하려면 목표 아래의 텍스트 상자에 입력한 뒤 \"Execute\"를 누르면 됩니다.", "In Advanced Addition World we will prove some basic\naddition facts such as $x+y=x\\implies y=0$. The theorems\nproved in this world will be used to build\na theory of inequalities in `≤` World.\n\nClick on \"Start\" to proceed.": - "Advanced Addition World에서는 $x+y=x\\implies y=0$ 같은 기본적인 덧셈의 성질을 증명합니다. 여기서 증명한 정리들은 `≤` World에서 부등식 이론을 만드는 데 사용됩니다.\n\n\"Start\"를 눌러 진행하세요.", - "Implication World": "함의 월드", + "고급 덧셈 월드에서는 $x+y=x\\implies y=0$ 같은 기본적인 덧셈의 성질을 증명합니다. 여기서 증명한 정리들은 `≤` 월드에서 부등식 이론을 만드는 데 사용됩니다.\n\n\"시작하기\"를 눌러 진행하세요.", + "Implication World": "조건문 월드", "Implementing the algorithm for equality of naturals, and the proof that it is correct,\nlooks like this:\n\n```\ninstance instDecidableEq : DecidableEq ℕ\n| 0, 0 => isTrue <| by\n show 0 = 0\n rfl\n| succ m, 0 => isFalse <| by\n show succ m ≠ 0\n exact succ_ne_zero m\n| 0, succ n => isFalse <| by\n show 0 ≠ succ n\n exact zero_ne_succ n\n| succ m, succ n =>\n match instDecidableEq m n with\n | isTrue (h : m = n) => isTrue <| by\n show succ m = succ n\n rw [h]\n rfl\n | isFalse (h : m ≠ n) => isFalse <| by\n show succ m ≠ succ n\n exact succ_ne_succ m n h\n```\n\nThis Lean code is a formally verified algorithm for deciding equality\nbetween two naturals. I've typed it in already, behind the scenes.\nBecause the algorithm is formally verified to be correct, we can\nuse it in Lean proofs. You can run the algorithm with the `decide` tactic.": - "자연수의 동등성을 판정하는 알고리즘과 그 정확성 증명을 구현하면 다음과 같습니다:\n\n```\ninstance instDecidableEq : DecidableEq ℕ\n| 0, 0 => isTrue <| by\n show 0 = 0\n rfl\n| succ m, 0 => isFalse <| by\n show succ m ≠ 0\n exact succ_ne_zero m\n| 0, succ n => isFalse <| by\n show 0 ≠ succ n\n exact zero_ne_succ n\n| succ m, succ n =>\n match instDecidableEq m n with\n | isTrue (h : m = n) => isTrue <| by\n show succ m = succ n\n rw [h]\n rfl\n | isFalse (h : m ≠ n) => isFalse <| by\n show succ m ≠ succ n\n exact succ_ne_succ m n h\n```\n\n이 Lean 코드는 두 자연수의 동등성을 판정하는 형식 검증된 알고리즘입니다. 이미 뒤에서 입력해 두었습니다. 알고리즘의 정확성까지 형식적으로 검증되었으므로 Lean 증명에서 사용할 수 있습니다. `decide` tactic으로 이 알고리즘을 실행할 수 있습니다.", + "자연수의 동등성을 판정하는 알고리즘과 그 정확성 증명을 구현하면 다음과 같습니다:\n\n```\ninstance instDecidableEq : DecidableEq ℕ\n| 0, 0 => isTrue <| by\n show 0 = 0\n rfl\n| succ m, 0 => isFalse <| by\n show succ m ≠ 0\n exact succ_ne_zero m\n| 0, succ n => isFalse <| by\n show 0 ≠ succ n\n exact zero_ne_succ n\n| succ m, succ n =>\n match instDecidableEq m n with\n | isTrue (h : m = n) => isTrue <| by\n show succ m = succ n\n rw [h]\n rfl\n | isFalse (h : m ≠ n) => isFalse <| by\n show succ m ≠ succ n\n exact succ_ne_succ m n h\n```\n\n이 Lean 코드는 두 자연수의 동등성을 판정하는 형식 검증된 알고리즘입니다. 이미 뒤에서 입력해 두었습니다. 알고리즘의 정확성까지 형식적으로 검증되었으므로 Lean 증명에서 사용할 수 있습니다. `decide` 택틱으로 이 알고리즘을 실행할 수 있습니다.", "If you have completed Algorithm World then you can use the `contrapose!` tactic\nhere. If not then I'll talk you through a manual approach.": - "만약 알고리듬 월드를 완료했다면 `contrapose!` tactic을 사용하실 수 있습니다. 그렇지 않다면 우회 방법에 대해 가르쳐 드릴게ㅇ", + "만약 알고리즘 월드를 완료했다면 `contrapose!` 택틱을 사용하실 수 있습니다. 그렇지 않다면 우회 방법에 대해 가르쳐 드리겠습니다.", "If you `use` the wrong number, you get stuck with a goal you can't prove.\nWhat number will you `use` here?": - "잘못된 수를 `use`하면 증명할 수 없는 goal에 막힙니다. 여기서는 어떤 수를 `use`해야 할까요?", + "잘못된 수를 `use`하면 증명할 수 없는 목표에 막힙니다. 여기서는 어떤 수를 `use`해야 할까요?", "If the goal is not *exactly* a hypothesis, we can sometimes\nuse rewrites to fix things up.": - "goal이 가정과 *정확히* 같지 않더라도 rewrite를 이용해 고칠 수 있는 경우가 있습니다.", + "목표가 가정과 *정확히* 같지 않더라도 rewrite를 이용해 고칠 수 있는 경우가 있습니다.", "If `h` is a proof of `X = Y` then `rw [h]` will\nturn `X`s into `Y`s. But what if we want to\nturn `Y`s into `X`s? To tell the `rw` tactic\nwe want this, we use a left arrow `←`. Type\n`\\l` and then hit the space bar to get this arrow.\n\nLet's prove that $2$ is the number after the number\nafter $0$ again, this time by changing `succ (succ 0)`\ninto `2`.": - "`h`가 `X = Y`의 증명이라면 `rw [h]`는 `X`을 `Y`로 바꿉니다. 그렇다면 반대로 `Y`를 `X`으로 바꾸고 싶을 때는 어떻게 해야 할까요? `rw` tactic에 이 방향으로 바꾸라고 알려 주려면 왼쪽 화살표 `←`를 사용합니다. `\\l`를 입력한 뒤 스페이스바를 누르면 이 화살표가 입력됩니다.\n\n이번에는 `X = Y`2를 `X = Y`3으로 바꾸는 방법으로, `X = Y`0이 `X = Y`1의 다음 수의 다음 수라는 사실을 다시 증명해 봅시다.", + "`h`가 `X = Y`의 증명이라면 `rw [h]`는 `X`을 `Y`로 바꿉니다. 그렇다면 반대로 `Y`를 `X`으로 바꾸고\n싶을 때는 어떻게 해야 할까요? `rw` 택틱에 이 방향으로 바꾸라고 알려 주려면 왼쪽 화살표 `←`를 사용합니다. `\\l`를 입력한 뒤 스페이스바를 누르면 이 화살표가 입력됩니다.\n\n이번에는 `succ (succ 0)`을 `2`로 바꾸는 방법으로, $2$가 $0$의 다음 수의 다음 수라는 사실을 다시 증명해 봅시다.", "If `a` and `b` are numbers, then `succ_inj a b` is a proof\nthat `succ a = succ b` implies `a = b`. Click on this theorem in the *Peano*\ntab for more information.\n\nPeano had this theorem as an axiom, but in Algorithm World\nwe will show how to prove it in Lean. Right now let's just assume it,\nand let's prove $x+1=4 \\implies x=3$ using it. Again, we will proceed\nby manipulating our hypothesis until it becomes the goal. I will\nwalk you through this level.": - "`a`와 `b`이 수라면 `succ_inj a b`는 `succ a = succ b`이면 `a = b`라는 것의 증명입니다. 더 알아보려면 *Peano* 탭에서 이 정리를 클릭하세요.\n\n페아노는 이 정리를 공리로 두었지만 Algorithm World에서는 Lean으로 이를 증명하는 방법을 보게 됩니다. 지금은 그냥 가정하고, 이를 이용해 $x+1=4 \\implies x=3$를 증명합시다. 이번에도 가정을 goal과 같아질 때까지 변형해 나가겠습니다. 이 level은 제가 단계별로 안내하겠습니다.", + "`a`와 `b`이 수라면 `succ_inj a b`는 `succ a = succ b`이면 `a = b`라는 것의 증명입니다. 더 알아보려면 *Peano* 탭에서 이 정리를 클릭하세요.\n\n페아노는 이 정리를 공리로 두었지만 알고리즘 월드에서는 Lean으로 이를 증명하는 방법을 보게 됩니다. 지금은 그냥 가정하고, 이를 이용해 $x+1=4 \\implies x=3$를 증명합시다. 이번에도 가정을 목표와 같아질 때까지 변형해 나가겠습니다. 이 레벨은 제가 단계별로 안내하겠습니다.", "If $x=y$ and $x \\neq y$ then we can deduce a contradiction.": "$x=y$와 $x \\neq y$이 모두 성립하면 모순을 이끌어낼 수 있습니다.", "If $x=37$ or $y=42$, then $y=42$ or $x=37$.": @@ -632,7 +630,7 @@ "If $x$ and $y$ are natural numbers, and $y = x + 7$, then $2y = 2(x + 7)$.": "$x$와 $y$이 자연수이고 $y = x + 7$라면 $2y = 2(x + 7)$입니다.", "If $x$ and $q$ are arbitrary natural numbers, then $37x+q=37x+q.$": - "$x$와 $q$이 임의의 자연수라면 $37x+q=37x+q.$입니다.", + "$x$와 $q$이 임의의 자연수라면 $37x+q=37x+q$입니다.", "If $x \\leq y$ and $y \\leq z$, then $x \\leq z$.": "$x \\leq y$이고 $y \\leq z$이면 $x \\leq z$입니다.", "If $x \\leq y$ and $y \\leq x$, then $x = y$.": @@ -647,7 +645,7 @@ "If $a, b, c$ are numbers, then $a+(b+c)=b+(a+c)$.": "$a, b, c$가 수라면 $a+(b+c)=b+(a+c)$입니다.", "If $a, b$, $c$ and $d$ are numbers, we have\n$(a + b) + (c + d) = ((a + c) + d) + b.$": - "$a, b$, $c$, $d$가 수라면 $(a + b) + (c + d) = ((a + c) + d) + b.$입니다.", + "$a, b$, $c$, $d$가 수라면 $(a + b) + (c + d) = ((a + c) + d) + b$입니다.", "If $a, b$ and $c$ are arbitrary natural numbers, we have\n$(a + b) + c = (a + c) + b$.": "$a, b$와 $c$이 임의의 자연수라면 $(a + b) + c = (a + c) + b$입니다.", "If $a+b=0$ then $b=0$.": "$a+b=0$이면 $b=0$입니다.", @@ -659,11 +657,11 @@ "If $\\operatorname{succ}(a)=\\operatorname{succ}(b)$ then $a=b$.": "$\\operatorname{succ}(a)=\\operatorname{succ}(b)$이면 $a=b$입니다.", "How should we define `37 * x`? Just like addition, we need to give definitions\nwhen $x=0$ and when $x$ is a successor.\n\nThe zero case is easy: we define `37 * 0` to be `0`. Now say we know\n`37 * d`. What should `37 * succ d` be? Well, that's $(d+1)$ $37$s,\nso it should be `37 * d + 37`.\n\nHere are the definitions in Lean.\n\n * `mul_zero a : a * 0 = 0`\n * `mul_succ a d : a * succ d = a * d + a`\n\nIn this world, we must not only prove facts about multiplication like `a * b = b * a`,\nwe must also prove facts about how multiplication interacts with addition, like `a * (b + c) = a * b + a * c`.\nLet's get started.": - "`37 * x`를 어떻게 정의해야 할까요? 덧셈과 마찬가지로 $x=0$일 때와 $x$가 successor일 때를 각각 정의해야 합니다.\n\n0인 경우는 쉽습니다. `37 * 0`을 `0`로 정의합니다. 이제 `37 * d`를 안다고 합시다. `37 * succ d`은 무엇이어야 할까요? 이는 $(d+1)$개의 $37$이므로 `37 * d + 37`여야 합니다.\n\nLean에서의 정의는 다음과 같습니다.\n\n * $x=0$0\n * $x=0$1\n\n이 world에서는 $x=0$2 같은 곱셈의 성질뿐 아니라 $x=0$3처럼 곱셈과 덧셈이 어떻게 상호작용하는지도 증명해야 합니다. 시작해 봅시다.", + "`37 * x`를 어떻게 정의해야 할까요? 덧셈과 마찬가지로 $x=0$일 때와 $x$가 다음수일 때를 각각 정의해야 합니다.\n\n0인 경우는 쉽습니다. `37 * 0`을 `0`로 정의합니다. 이제 `37 * d`를 안다고 합시다. `37 * succ d`은 무엇이어야 할까요? 이는 $(d+1)$개의 $37$이므로 `37 * d + 37`여야 합니다.\n\nLean에서의 정의는 다음과 같습니다.\n\n * $x=0$0\n * $x=0$1\n\n이 월드에서는 $x=0$2 같은 곱셈의 성질뿐 아니라 $x=0$3처럼 곱셈과 덧셈이 어떻게 상호작용하는지도 증명해야 합니다. 시작해 봅시다.", "How about this for a proof:\n```\nrepeat rw [add_comm n]\nexact add_right_cancel a b n\n```": "이런 증명은 어떤가요?\n```\nrepeat rw [add_comm n]\nexact add_right_cancel a b n\n```", "How about this for a proof:\n\n```\nrw [add_comm]\nexact add_right_eq_zero b a\n```\n\nThat's the end of Advanced Addition World! You'll need these theorems\nfor the next world, `≤` World. Click on \"Home\" to access it.": - "이런 증명은 어떤가요?\n\n```\nrw [add_comm]\nexact add_right_eq_zero b a\n```\n\nAdvanced Addition World는 여기까지입니다! 다음 `≤` World에서는 여기서 얻은 정리들이 필요합니다. \"Home\"을 눌러 이동하세요.", + "이런 증명은 어떤가요?\n\n```\nrw [add_comm]\nexact add_right_eq_zero b a\n```\n\n고급 덧셈 월드는 여기까지입니다! 다음 `≤` 월드에서는 여기서 얻은 정리들이 필요합니다. \"홈\"을 눌러 이동하세요.", "Here's what I was thinking of:\n```\napply mul_left_ne_zero at h\napply one_le_of_ne_zero at h\napply mul_le_mul_right 1 b a at h\nrw [one_mul, mul_comm] at h\nexact h\n```": "제가 생각한 증명은 이겁니다:\n```\napply mul_left_ne_zero at h\napply one_le_of_ne_zero at h\napply mul_le_mul_right 1 b a at h\nrw [one_mul, mul_comm] at h\nexact h\n```", "Here's the short proof:\n```\nhave h2 := mul_ne_zero a b\ntauto\n```\nThis works because, given `mul_ne_zero a b`,\nthe argument is reduced to pure logic.": @@ -677,11 +675,11 @@ "Here's my proof:\n```\nrw [mul_comm, mul_add]\nrepeat rw [mul_comm c]\nrfl\n```": "제 증명은 이렇습니다:\n```\nrw [mul_comm, mul_add]\nrepeat rw [mul_comm c]\nrfl\n```", "Here's my proof:\n```\nintro h\nrw [add_succ, add_succ, add_zero] at h\nrepeat apply succ_inj at h\napply zero_ne_succ at h\nexact h\n```\n\nEven though Lean is a theorem prover, right now it's pretty clear that we have not\ndeveloped enough material to make it an adequate calculator. In Algorithm\nWorld, a more computer-sciency world, we will develop machinery which makes\nquestions like this much easier, and goals like $20 + 20 ≠ 41$ feasible.\nAlternatively you can do more mathematics in Advanced Addition World, where we prove\nthe lemmas needed to get a working theory of inequalities. Click \"Home\" and\ndecide your route.": - "제 증명은 이렇습니다:\n```\nintro h\nrw [add_succ, add_succ, add_zero] at h\nrepeat apply succ_inj at h\napply zero_ne_succ at h\nexact h\n```\n\nLean은 정리 증명기지만, 지금까지 만든 것만으로는 계산기로 쓰기에 아직 부족하다는 게 분명합니다. 좀 더 컴퓨터과학적인 Algorithm World에서는 이런 문제를 훨씬 쉽게 만들고 $20 + 20 ≠ 41$ 같은 목표도 다룰 수 있게 해 주는 도구를 개발합니다.\n대신 Advanced Addition World로 가서 수학을 더 진행할 수도 있습니다. 거기서는 부등식 이론을 제대로 만들기 위해 필요한 보조정리들을 증명합니다. \"Home\"을 누르고 어느 길로 갈지 선택하세요.", + "제 증명은 이렇습니다:\n```\nintro h\nrw [add_succ, add_succ, add_zero] at h\nrepeat apply succ_inj at h\napply zero_ne_succ at h\nexact h\n```\n\nLean은 정리 증명기지만, 지금까지 만든 것만으로는 계산기로 쓰기에 아직 부족하다는 게 분명합니다. 좀 더 컴퓨터과학적인 알고리즘 월드에서는 이런 문제를 훨씬 쉽게 만들고 $20 + 20 ≠ 41$ 같은 목표도 다룰 수 있게 해 주는 도구를 개발합니다.\n대신 고급 덧셈 월드로 가서 수학을 더 진행할 수도 있습니다. 거기서는 부등식 이론을 제대로 만들기 위해 필요한 정리들을 증명합니다. \"홈\"을 누르고 어느 길로 갈지 선택하세요.", "Here's my proof:\n```\ncases x with y\nleft\nrfl\nrw [one_eq_succ_zero] at hx ⊢\napply succ_le_succ at hx\napply le_zero at hx\nrw [hx]\nright\nrfl\n```\n\nIf you solved this level then you should be fine with the next level!": - "제 증명은 이렇습니다:\n```\ncases x with y\nleft\nrfl\nrw [one_eq_succ_zero] at hx ⊢\napply succ_le_succ at hx\napply le_zero at hx\nrw [hx]\nright\nrfl\n```\n\n이 level을 풀었다면 다음 level도 문제없을 겁니다!", + "제 증명은 이렇습니다:\n```\ncases x with y\nleft\nrfl\nrw [one_eq_succ_zero] at hx ⊢\napply succ_le_succ at hx\napply le_zero at hx\nrw [hx]\nright\nrfl\n```\n\n이 레벨을 풀었다면 다음 레벨도 문제없을 겁니다!", "Here's my proof:\n```\ncases hxy with a ha\ncases hyx with b hb\nrw [ha]\nrw [ha, add_assoc] at hb\nsymm at hb\napply add_right_eq_self at hb\napply add_right_eq_zero at hb\nrw [hb, add_zero]\nrfl\n```\n\nA passing mathematician remarks that with antisymmetry as well,\nyou have proved that `≤` is a *partial order* on `ℕ`.\n\nThe boss level of this world is to prove\nthat `≤` is a total order. Let's learn two more easy tactics\nfirst.": - "제 증명은 이렇습니다:\n```\ncases hxy with a ha\ncases hyx with b hb\nrw [ha]\nrw [ha, add_assoc] at hb\nsymm at hb\napply add_right_eq_self at hb\napply add_right_eq_zero at hb\nrw [hb, add_zero]\nrfl\n```\n\n지나가던 수학자가 이제 반대칭성까지 있으므로 `ℕ` 위의 `≤`이 *partial order*임을 증명했다고 말합니다.\n\n이 world의 boss level은 `≤`가 total order임을 증명하는 것입니다. 그 전에 쉬운 tactic 두 개를 더 배워 봅시다.", + "제 증명은 이렇습니다:\n```\ncases hxy with a ha\ncases hyx with b hb\nrw [ha]\nrw [ha, add_assoc] at hb\nsymm at hb\napply add_right_eq_self at hb\napply add_right_eq_zero at hb\nrw [hb, add_zero]\nrfl\n```\n\n지나가던 수학자가 이제 반대칭성까지 있으므로 `ℕ` 위의 `≤`이 *partial order*임을 증명했다고 말합니다.\n\n이 월드의 보스 레벨은 `≤`가 전순서임을 증명하는 것입니다. 그 전에 쉬운 택틱 두 개를 더 배워 봅시다.", "Here's my proof:\n```\ncases hx with d hd\nuse d\nrw [succ_add] at hd\napply succ_inj at hd\nexact hd\n```": "제 증명은 이렇습니다:\n```\ncases hx with d hd\nuse d\nrw [succ_add] at hd\napply succ_inj at hd\nexact hd\n```", "Here's a two-liner:\n```\nuse 1\nexact succ_eq_add_one x\n```\n\nThis works because `succ_eq_add_one x` is a proof of `succ x = x + 1`.": @@ -695,9 +693,9 @@ "Here we want to deal with the cases `b = 0` and `b ≠ 0` separately,\nso start with `cases b with d`.": "여기서는 `b = 0`와 `b ≠ 0` 경우를 따로 다루고 싶으므로 `cases b with d`로 시작하세요.", "Here we begin to\ndevelop an algorithm which, given two naturals `a` and `b`, returns the answer\nto \"does `a = b`?\"\n\nHere is the algorithm. First note that `a` and `b` are numbers, and hence\nare either `0` or successors.\n\n*) If `a` and `b` are both `0`, return \"yes\".\n\n*) If one is `0` and the other is `succ n`, return \"no\".\n\n*) If `a = succ m` and `b = succ n`, then return the answer to \"does `m = n`?\"\n\nOur job now is to *prove* that this algorithm always gives the correct answer. The proof that\n`0 = 0` is `rfl`. The proof that `0 ≠ succ n` is `zero_ne_succ n`, and the proof\nthat `succ m ≠ 0` is `succ_ne_zero m`. The proof that if `h : m = n` then\n`succ m = succ n` is `rw [h]` and then `rfl`. This level is a proof of the one\nremaining job we have to do: if `a ≠ b` then `succ a ≠ succ b`.": - "여기서는 두 자연수 `a`와 `b`을 받아 \"`a = b`인가?\"에 대한 답을 돌려주는 알고리즘을 만들기 시작합니다.\n\n알고리즘은 다음과 같습니다. 먼저 `a`와 `b`는 수이므로 각각 `0`이거나 successor입니다.\n\n*) `a`와 `b`이 둘 다 `0`이면 \"yes\"를 반환합니다.\n\n*) 하나가 `0`이고 다른 하나가 `b`0이면 \"no\"를 반환합니다.\n\n*) `b`1이고 `b`2이면 \"`b`3인가?\"에 대한 답을 반환합니다.\n\n이제 이 알고리즘이 항상 올바른 답을 준다는 것을 *증명*해야 합니다. `b`4의 증명은 `b`5입니다. `b`6의 증명은 `b`7이고, `b`8의 증명은 `b`9입니다. `a = b`0이면 `a = b`1이라는 증명은 `a = b`2를 한 뒤 `a = b`3을 하면 됩니다. 이 level에서는 남은 마지막 경우, 즉 `a = b`4이면 `a = b`5라는 것을 증명합니다.", + "여기서는 두 자연수 `a`와 `b`을 받아 \"`a = b`인가?\"에 대한 답을 돌려주는 알고리즘을 만들기 시작합니다.\n\n알고리즘은 다음과 같습니다. 먼저 `a`와 `b`는 수이므로 각각 `0`이거나 다음수입니다.\n\n*) `a`와 `b`이 둘 다 `0`이면 \"yes\"를 반환합니다.\n\n*) 하나가 `0`이고 다른 하나가 `succ n`이면 \"no\"를 반환합니다.\n\n*) `a = succ m`이고 `b = succ n`이면 \"`m = n`인가?\"에 대한 답을 반환합니다.\n\n이제 이 알고리즘이 항상 올바른 답을 준다는 것을 *증명*해야 합니다.\n`0 = 0`의 증명은 `rfl`입니다. `0 ≠ succ n`의 증명은 `zero_ne_succ n`이고,\n`succ m ≠ 0`의 증명은 `succ_ne_zero m`입니다. `h : m = n`일 때\n`succ m = succ n`임을 증명하려면 `rw [h]`를 한 뒤 `rfl`을 사용하면 됩니다.\n이 레벨에서는 이제 남은 마지막 경우, 즉 `a ≠ b`이면\n`succ a ≠ succ b`라는 것을 증명합니다.", "Here is an example proof of 2+2=4 showing off various techniques.\n\n```lean\nnth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`.\nrw [add_succ]\nrw [one_eq_succ_zero]\nrw [add_succ, add_zero] -- two rewrites at once\nrw [← three_eq_succ_two] -- change `succ 2` to `3`\nrw [← four_eq_succ_three]\nrfl\n```\n\nOptional extra: you can run this proof yourself. Switch the game into \"Editor mode\" by clicking\non the `` button in the top right. You can now see your proof\nwritten as several lines of code. Move your cursor between lines to see\nthe goal state at any point. Now cut and paste your code elsewhere if you\nwant to save it, and paste the above proof in instead. Move your cursor\naround to investigate. When you've finished, click the `>_` button in the top right to\nmove back into \"Typewriter mode\".\n\nYou have finished tutorial world!\nClick \"Home\" to go back to the\noverworld, and select Addition World, where you will learn\nabout the `induction` tactic.": - "여러 기법을 보여 주는 2+2=4의 예시 증명입니다.\n\n```lean\nnth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`.\nrw [add_succ]\nrw [one_eq_succ_zero]\nrw [add_succ, add_zero] -- two rewrites at once\nrw [← three_eq_succ_two] -- change `succ 2` to `3`\nrw [← four_eq_succ_three]\nrfl\n```\n\n선택 사항: 이 증명을 직접 실행해 볼 수도 있습니다. 오른쪽 위의 `` 버튼을 눌러 게임을 \"Editor mode\"로 바꾸세요. 그러면 증명이 여러 줄의 코드로 보입니다. 줄 사이에 커서를 옮겨 각 지점의 goal state를 확인할 수 있습니다. 원한다면 코드를 다른 곳에 복사해 저장하고, 위 증명을 붙여 넣어 탐색해 보세요. 다 살펴봤으면 오른쪽 위의 `>_` 버튼을 눌러 \"Typewriter mode\"로 돌아가세요.\n\nTutorial World를 완료했습니다! \"Home\"을 눌러 overworld로 돌아간 뒤 Addition World를 선택하세요. 그곳에서 `induction` tactic을 배웁니다.", + "여러 기법을 보여 주는 2+2=4의 예시 증명입니다.\n\n```lean\nnth_rewrite 2 [two_eq_succ_one] -- only change the second `2` to `succ 1`.\nrw [add_succ]\nrw [one_eq_succ_zero]\nrw [add_succ, add_zero] -- two rewrites at once\nrw [← three_eq_succ_two] -- change `succ 2` to `3`\nrw [← four_eq_succ_three]\nrfl\n```\n\n선택 사항: 이 증명을 직접 실행해 볼 수도 있습니다. 오른쪽 위의 `` 버튼을 눌러 게임을 \"편집기 모드\"로 바꾸세요. 그러면 증명이 여러 줄의 코드로 보입니다. 줄 사이에 커서를 옮겨 각 지점의 목표 상태를 확인할 수 있습니다. 원한다면 코드를 다른 곳에 복사해 저장하고, 위 증명을 붙여 넣어 탐색해 보세요. 다 살펴봤으면 오른쪽 위의 `>_` 버튼을 눌러 \"타자기 모드\"로 돌아가세요.\n\n튜토리얼 월드를 완료했습니다! \"홈\"을 눌러 홈 월드로 돌아간 뒤 덧셈 월드를 선택하세요. 그곳에서 `induction` 택틱을 배웁니다.", "Having to rearrange variables manually using commutativity and\nassociativity is very tedious. We start by reminding you of this. `add_left_comm`\nis a key component in the first algorithm which we'll explain, but we need\nto prove it manually.\n\nRemember that you can do precision commutativity rewriting\nwith things like `rw [add_comm b c]`. And remember that\n`a + b + c` means `(a + b) + c`.": "가환법칙과 결합법칙을 이용해 변수를 손으로 재배열하는 것은 매우 지루합니다. 우선 그 사실을 다시 한번 체감해 봅시다. `add_left_comm`는 우리가 설명할 첫 알고리즘의 핵심 구성 요소이지만, 지금은 직접 증명해야 합니다.\n\n`rw [add_comm b c]` 같은 식으로 정밀한 가환성 rewrite를 할 수 있다는 점을 기억하세요. 그리고 `a + b + c`는 `(a + b) + c`을 뜻합니다.", "Good luck!\n\n One last hint. If `h : X = Y` then `rw [h]` will change *all* `X`s into `Y`s.\n If you only want to change one of them, say the 3rd one, then use\n `nth_rewrite 3 [h]`.": @@ -711,7 +709,7 @@ "For all numbers $m$, $0 ^{\\operatorname{succ} (m)} = 0$.": "모든 수 $m$에 대해 $0 ^{\\operatorname{succ} (m)} = 0$입니다.", "For all numbers $a$ and $b$, we have\n$$(a+b)^2=a^2+b^2+2ab.$$": - "모든 수 $a$와 $b$에 대해 $$(a+b)^2=a^2+b^2+2ab.$$입니다.", + "모든 수 $a$와 $b$에 대해 $$(a+b)^2=a^2+b^2+2ab$$입니다.", "For all naturals $m$, $1 ^ m = 1$.": "모든 자연수 $m$에 대해 $1 ^ m = 1$입니다.", "For all naturals $a$, $m$, $n$, we have $a^{m + n} = a ^ m a ^ n$.": "모든 자연수 $a$, $m$, $n$에 대해 $a^{m + n} = a ^ m a ^ n$입니다.", @@ -742,20 +740,20 @@ "Finally use a targeted `add_comm` to switch `b` and `d`", "Fermat's Last Theorem": "페르마의 마지막 정리", "Every number in Lean is either $0$ or a successor. We know how to add $0$,\nbut we need to figure out how to add successors. Let's say we already know\nthat `37 + d = q`. What should the answer to `37 + succ d` be? Well,\n`succ d` is one bigger than `d`, so `37 + succ d` should be `succ q`,\nthe number one bigger than `q`. More generally `x + succ d` should\nbe `succ (x + d)`. Let's add this as a lemma.\n\n* `add_succ x d : x + succ d = succ (x + d)`\n\nIf you ever see `... + succ ...` in your goal, `rw [add_succ]` is\nnormally a good idea.\n\nLet's now prove that `succ n = n + 1`. Figure out how to get `+ succ` into\nthe picture, and then `rw [add_succ]`. Switch between the `+` (addition) and\n`012` (numerals) tabs under \"Theorems\" on the right to\nsee which proofs you can rewrite.": - "Lean의 모든 수는 $0$이거나 successor입니다. $0$을 더하는 법은 알지만 successor를 더하는 법은 아직 모릅니다. 이미 `37 + d = q`를 안다고 합시다. 그렇다면 `37 + succ d`의 답은 무엇이어야 할까요? `succ d`는 `d`보다 1 큰 수이므로 `37 + succ d`는 `succ q`, 즉 `q`보다 1 큰 수여야 합니다. 더 일반적으로 `x + succ d`는 $0$0이어야 합니다. 이를 lemma로 추가합시다.\n\n* $0$1\n\ngoal에서 $0$2를 보게 되면 보통 $0$3을 쓰는 것이 좋은 생각입니다.\n\n이제 $0$4를 증명해 봅시다. 먼저 $0$5를 끌어들이는 방법을 찾고, 이어서 $0$6을 사용하세요. 오른쪽 \"Theorems\" 아래의 $0$7(덧셈) 탭과 $0$8(숫자) 탭을 오가며 어떤 증명으로 rewrite할 수 있는지 확인하세요.", + "Lean의 모든 수는 $0$이거나 다음수입니다. $0$을 더하는 법은 알지만 다음수를 더하는 법은 아직 모릅니다.\n이미 `37 + d = q`를 안다고 합시다. 그렇다면 `37 + succ d`의 답은 무엇이어야 할까요? `succ d`는 `d`보다 1 큰\n수이므로 `37 + succ d`는 `succ q`, 즉 `q`보다 1 큰 수여야 합니다. 더 일반적으로 `x + succ d`는 `succ (x + d)`이어야 합니다. 이를 정리로 추가합시다.\n\n* `add_succ x d : x + succ d = succ (x + d)`\n\n목표에서 `... + succ ...`를 보게 되면 보통 `rw [add_succ]`을 쓰는 것이 좋은 생각입니다.\n\n이제 `succ n = n + 1`를 증명해 봅시다. 먼저 `+ succ`를 화면에 띄우는 방법을 찾고, 이어서 `rw [add_succ]`을 사용하세요. 오른쪽 \"정리\" 아래의 `+`(덧셈) 탭과 `012`(숫자) 탭을 오가며 어떤 증명으로 rewrite할 수 있는지 확인하세요.", "Do that again!\n\n§0 tries to fill in\nthe arguments to §1 (finding §2) then it replaces all occurrences of\n§3 it finds. Therefore, it did not rewrite §4, yet.": "한 번 더 해 보세요!\n\n§0는 §1의 인자들을 채우려고 시도하고(§2를 찾아서) 발견한 §3의 모든 occurrence를 바꿉니다. 따라서 아직 §4는 rewrite하지 않았습니다.", "Do that again!\n\n`rw [zero_add] at «{h}»` tries to fill in\nthe arguments to `zero_add` (finding `«{x}»`) then it replaces all occurrences of\n`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet.": "Do that again!\n\n`rw [zero_add] at «{h}»` tries to fill in\nthe arguments to `zero_add` (finding `«{x}»`) then it replaces all occurrences of\n`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet.", "Did you use induction on `y`?\nHere's a two-line proof of `add_left_eq_self` which uses `add_right_cancel`.\nIf you want to inspect it, you can go into editor mode by clicking `` in the top right\nand then just cut and paste the proof and move your cursor around it\nto see the hypotheses and goal at any given point\n(although you'll lose your own proof this way). Click `>_` to get\nback to command line mode.\n```\nnth_rewrite 2 [← zero_add y]\nexact add_right_cancel x 0 y\n```": - "`y`에 대해 귀납법을 썼나요?\n`add_right_cancel`를 사용하는 `add_left_eq_self`의 두 줄짜리 증명은 다음과 같습니다. 살펴보고 싶다면 오른쪽 위의 ``을 눌러 editor mode로 들어간 뒤 증명을 복사해 붙여 넣고 커서를 옮기면서 각 지점의 가정과 goal을 확인할 수 있습니다(다만 이 과정에서 자신의 증명은 사라집니다). `>_`를 누르면 command line mode로 돌아옵니다.\n```\nnth_rewrite 2 [← zero_add y]\nexact add_right_cancel x 0 y\n```", + "`y`에 대해 귀납법을 썼나요?\n`add_right_cancel`를 사용하는 `add_left_eq_self`의 두 줄짜리 증명은 다음과 같습니다. 살펴보고 싶다면 오른쪽 위의 ``을 눌러 편집기 모드로 들어간 뒤 증명을 복사해 붙여 넣고 커서를 옮기면서 각 지점의 가정과 목표를 확인할 수 있습니다(다만 이 과정에서 자신의 증명은 사라집니다). `>_`를 누르면 command line mode로 돌아옵니다.\n```\nnth_rewrite 2 [← zero_add y]\nexact add_right_cancel x 0 y\n```", "Dealing with `or`": "`or` 다루기", "Congratulations! You've finished Algorithm World. These algorithms\nwill be helpful for you in Even-Odd World (when someone gets around to\nimplementing it).": - "축하합니다! Algorithm World를 끝냈습니다. 이 알고리즘들은 Even-Odd World가 언젠가 구현되면 그곳에서 유용하게 쓰일 겁니다.", + "축하합니다! 알고리즘 월드를 끝냈습니다. 이 알고리즘들은 홀짝 월드가 언젠가 구현되면 그곳에서 유용하게 쓰일 겁니다.", "Congratulations! You have proved Fermat's Last Theorem!\n\nEither that, or you used magic...": "축하합니다! 페르마의 마지막 정리를 증명했습니다!\n\n아니면 마법을 썼거나요...", "Congratulations! You completed your first verified proof!\n\nRemember that `rfl` is a *tactic*. If you ever want information about the `rfl` tactic,\nyou can click on `rfl` in the list of tactics on the right.\n\nNow click on \"Next\" to learn about the `rw` tactic.": - "축하합니다! 첫 번째 검증된 증명을 완성했습니다!\n\n`rfl`가 *tactic*이라는 점을 기억하세요. `rfl` tactic에 대해 궁금하면 오른쪽 tactic 목록의 `rfl`를 클릭하면 됩니다.\n\n이제 \"Next\"를 눌러 `rw` tactic을 배워 봅시다.", + "축하합니다! 첫 번째 검증된 증명을 완성했습니다!\n\n`rfl`가 *택틱*이라는 점을 기억하세요. `rfl` 택틱에 대해 궁금하면 오른쪽 택틱 목록의 `rfl`를 클릭하면 됩니다.\n\n이제 \"Next\"를 눌러 `rw` 택틱을 배워 봅시다.", "Concretely: `rw [← succ_eq_add_one] at h`.": "구체적으로는 `rw [← succ_eq_add_one] at h`입니다.", "Can you take it from here? Click on \"Show more help!\" if you need a hint.": @@ -763,53 +761,53 @@ "Can you take it from here? (note: if you try `contrapose! h` again, it will\ntake you back to where you started!)": "이제부터는 스스로 할 수 있겠나요? (주의: `contrapose! h`를 다시 시도하면 시작 지점으로 돌아옵니다!)", "Can you take it from here?": "이제부터는 스스로 할 수 있겠나요?", - "Can you now change the goal into `2 = 2`?": "이제 goal을 `2 = 2`로 바꿀 수 있나요?", + "Can you now change the goal into `2 = 2`?": "이제 목표를 `2 = 2`로 바꿀 수 있나요?", "At this point you see the term `0 + «{d}»`, so you can use the\ninduction hypothesis with `rw [«{hd}»]`.": "이제 항 `0 + «{d}»`가 보이므로 `rw [«{hd}»]`과 함께 귀납가정을 사용할 수 있습니다.", "Assuming $x+y=37$ and $3x+z=42$, we have $x+y=37$.": "$x+y=37$와 $3x+z=42$을 가정하면 $x+y=37$입니다.", "Assuming $0+x=(0+y)+2$, we have $x=y+2$.": "$0+x=(0+y)+2$를 가정하면 $x=y+2$입니다.", "As warm-up for `2 + 2 ≠ 5` let's prove `0 ≠ 1`. To do this we need to\nintroduce Peano's last axiom `zero_ne_succ n`, a proof that `0 ≠ succ n`.\nTo learn about this result, click on it in the list of lemmas on the right.": - "`2 + 2 ≠ 5`를 위한 준비운동으로 `0 ≠ 1`을 증명해 봅시다. 이를 위해 페아노의 마지막 공리 `zero_ne_succ n`, 즉 `0 ≠ succ n`의 증명을 도입해야 합니다. 이 결과에 대해 알아보려면 오른쪽 lemma 목록에서 클릭하세요.", + "`2 + 2 ≠ 5`를 위한 준비운동으로 `0 ≠ 1`을 증명해 봅시다. 이를 위해 페아노의 마지막 공리 `zero_ne_succ n`, 즉 `0 ≠ succ n`의 증명을 도입해야 합니다. 이 결과에 대해 알아보려면 오른쪽 정리 목록에서 클릭하세요.", "Arguing backwards": "거꾸로 추론하기", "Applying a proof of $P\\implies Q$ to the *goal* changes $Q$ to $P$.\nNow try `rw [succ_eq_add_one]` to make the goal more like the hypothesis.": - "$P\\implies Q$의 증명을 *goal*에 적용하면 $Q$이 $P$로 바뀝니다. 이제 `rw [succ_eq_add_one]`을 사용해 goal을 가정과 더 비슷하게 만들어 보세요.", + "$P\\implies Q$의 증명을 *goal*에 적용하면 $Q$이 $P$로 바뀝니다. 이제 `rw [succ_eq_add_one]`을 사용해 목표를 가정과 더 비슷하게 만들어 보세요.", "And now we've deduced what we wanted to prove: the goal is one of our assumptions.\nFinish the level with `exact h`.": - "이제 우리가 증명하고 싶던 것을 이끌어냈습니다. goal이 가정 중 하나입니다. `exact h`로 level을 마무리하세요.", + "이제 우리가 증명하고 싶던 것을 이끌어냈습니다. 목표가 가정 중 하나입니다. `exact h`로 레벨을 마무리하세요.", "And now `rw [add_zero]`": "그리고 이제 `rw [add_zero]`.", "And finally `rfl`.": "그리고 마지막으로 `rfl`.", "An algorithm for equality": "동등성 판정 알고리즘", "Although $0^0=1$ in this game, $0^n=0$ if $n>0$, i.e., if\n$n$ is a successor.": - "이 게임에서는 $0^0=1$이지만, $n>0$라면, 즉 $n$가 successor라면 $0^n=0$입니다.", + "이 게임에서는 $0^0=1$이지만, $n>0$라면, 즉 $n$가 다음수라면 $0^n=0$입니다.", "Algorithm World": "알고리즘 월드", "Advanced Multiplication World": "고급 곱셈 월드", "Advanced Addition World": "고급 덧셈 월드", "Advanced *Addition* World proved various implications\ninvolving addition, such as `x + y = 0 → x = 0` and `x + y = x → y = 0`.\nThese lemmas were used to prove basic facts about ≤ in ≤ World.\n\nIn Advanced Multiplication World we prove analogous\nfacts about multiplication, such as `x * y = 1 → x = 1`, and\n`x * y = x → y = 1` (assuming `x ≠ 0` in the latter result). This will prepare\nus for Divisibility World.\n\nMultiplication World is more complex than Addition World. In the same\nway, Advanced Multiplication world is more complex than Advanced Addition\nWorld. One reason for this is that certain intermediate results are only\ntrue under the additional hypothesis that one of the variables is non-zero.\nThis causes some unexpected extra twists.": - "Advanced *Addition* World에서는 `x + y = 0 → x = 0`와 `x + y = x → y = 0` 같은 덧셈 관련 여러 함의를 증명했습니다. 이 lemma들은 ≤ World에서 ≤의 기본 성질을 증명하는 데 사용되었습니다.\n\nAdvanced Multiplication World에서는 이에 대응하는 곱셈 관련 사실, 예를 들어 `x * y = 1 → x = 1`와 `x * y = x → y = 1`(후자는 `x ≠ 0`를 가정)을 증명합니다. 이것이 Divisibility World를 준비해 줍니다.\n\nMultiplication World는 Addition World보다 복잡합니다. 마찬가지로 Advanced Multiplication World도 Advanced Addition World보다 복잡합니다. 이유 중 하나는 몇몇 중간 결과가 변수 하나가 0이 아니라는 추가 가정 아래에서만 참이기 때문입니다. 그래서 예상하지 못한 꼬임이 몇 번 생깁니다.", + "고급 *덧셈* 월드에서는 `x + y = 0 → x = 0`와 `x + y = x → y = 0` 같은 덧셈 관련 여러 조건문을 증명했습니다. 이 정리들은 ≤ 월드에서 ≤의 기본 성질을 증명하는 데 사용되었습니다.\n\n고급 곱셈 월드에서는 이에 대응하는 곱셈 관련 사실, 예를 들어 `x * y = 1 → x = 1`와 `x * y = x → y = 1`(후자는 `x ≠ 0`를 가정)을 증명합니다. 이것이 나누어 떨어짐 월드를 준비해 줍니다.\n\n곱셈 월드는 덧셈 월드보다 복잡합니다. 마찬가지로 고급 곱셈 월드도 고급 덧셈 월드보다 복잡합니다. 이유 중 하나는 몇몇 중간 결과가 변수 하나가 0이 아니라는 추가 가정 아래에서만 참이기 때문입니다. 그래서 예상하지 못한 꼬임이 몇 번 생깁니다.", "Addition is distributive over multiplication.\nIn other words, for all natural numbers $a$, $b$ and $c$, we have\n$(a + b) \\times c = ac + bc$.": "덧셈은 곱셈에 대해 분배됩니다. 즉 모든 자연수 $a$, $b$, $c$에 대해\n$(a + b) times c = ac + bc$이 성립합니다.", "Addition World": "덧셈 월드", "Adding zero": "0 더하기", "A two-line proof is\n\n```\nnth_rewrite 2 [← mul_one a] at h\nexact mul_left_cancel a b 1 ha h\n```\n\nWe now have all the tools necessary to set up the basic theory of divisibility of naturals.": - "두 줄짜리 증명은\n\n```\nnth_rewrite 2 [← mul_one a] at h\nexact mul_left_cancel a b 1 ha h\n```\n\n입니다. 이제 자연수의 나눗셈 가능성(divisibility)에 대한 기본 이론을 세울 도구가 모두 준비되었습니다.", + "두 줄짜리 증명은\n\n```\nnth_rewrite 2 [← mul_one a] at h\nexact mul_left_cancel a b 1 ha h\n```\n\n입니다. 이제 자연수의 나눗셈 가능성에 대한 기본 이론을 세울 준비가 되었습니다.", "A proof that $a+b=0 \\implies b=0$.": "$a+b=0 \\implies b=0$라는 증명.", "A proof that $a+b=0 \\implies a=0$.": "$a+b=0 \\implies a=0$라는 증명.", "A passing mathematician remarks that with reflexivity and transitivity out of the way,\nyou have proved that `≤` is a *preorder* on `ℕ`.": - "지나가던 수학자가 반사성과 추이성을 증명했으므로 `ℕ` 위의 `≤`가 *preorder*임을 증명했다고 말합니다.", + "지나가던 수학자가 반사성과 추이성을 증명했으므로 `ℕ` 위의 `≤`가 *전순서(preorder)*임을 증명했다고 말합니다.", "A passing mathematician notes that you've proved\nthat the natural numbers are a commutative semiring.\n\nIf you want to begin your journey to the final boss, head for Power World.": - "지나가던 수학자가 자연수들이 가환 반환을 이룬다는 것을 증명했다고 알려 줍니다.\n\nfinal boss를 향한 여정을 시작하려면 Power World로 가세요.", + "지나가던 수학자가 자연수들이 가환 반환을 이룬다는 것을 증명했다고 알려 줍니다.\n\n최종 보스를 향한 여정을 시작하려면 지수 월드로 가세요.", "A passing mathematician congratulates you on proving that naturals\nare an additive commutative monoid.\n\nLet's practice using `add_assoc` and `add_comm` in one more level,\nbefore we leave addition world.": - "지나가던 수학자가 자연수들이 덧셈에 대해 가환 모노이드를 이룬다는 것을 증명했다며 축하합니다.\n\nAddition World를 떠나기 전에 `add_assoc`와 `add_comm`을 한 level만 더 연습해 봅시다.", + "지나가던 수학자가 자연수들이 덧셈에 대해 가환 모노이드를 이룬다는 것을 증명했다며 축하합니다.\n\n덧셈 월드를 떠나기 전에 `add_assoc`와 `add_comm`을 한 레벨만 더 연습해 봅시다.", "2+2=4": "2+2=4", "2 + 2 ≠ 5 is boring to prove in full, given only the tools we have currently.\nTo make it a bit less painful, I have unfolded all of the numerals for you.\nSee if you can use `zero_ne_succ` and `succ_inj` to prove this.": - "현재 가진 도구만으로 `zero_ne_succ`를 처음부터 증명하는 것은 꽤 지루합니다. 조금 덜 괴롭도록 숫자들을 모두 펼쳐 두었습니다. `zero_ne_succ`와 `succ_inj`을 이용해 증명해 보세요.", + "현재 가진 도구만으로 `2 + 2 ≠ 5`를 처음부터 증명하는 것은 꽤 지루합니다.\n조금 덜 괴롭도록 숫자들을 모두 펼쳐 두었습니다.\n`zero_ne_succ`와 `succ_inj`을 이용해 증명해 보세요.", "2 + 2 ≠ 5": "2 + 2 ≠ 5", "1 ≠ 0": "1 ≠ 0", "0 ≤ x": "0 ≤ x", "*Game version: 4.3*\n\n*Recent additions: bug fixes*\n\n## Progress saving\n\nThe game stores your progress in your local browser storage.\nIf you delete it, your progress will be lost!\n\nWarning: In most browsers, deleting cookies will also clear the local storage\n(or \"local site data\"). Make sure to download your game progress first!\n\n## Credits\n\n* **Creators:** Kevin Buzzard, Jon Eugster\n* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n* **Additional thanks:** All the student beta testers, all the schools\nwho invited Kevin to speak, and all the schoolkids who asked him questions\nabout the material.\n\n## Resources\n\n* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n* [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/) (no longer maintained)\n\n## Problems?\n\nPlease ask any questions about this game in the\n[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\nthe stream \"New Members\". The community will happily help. Note that\nthe Lean Zulip chat is a professional research forum.\nPlease use your full real name there, stay on topic, and be nice. If you're\nlooking for somewhere less formal (e.g. you want to post natural number\ngame memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n\nAlternatively, if you experience issues / bugs you can also open github issues:\n\n* For issues with the game engine, please open an\n[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n* For issues about the game's content, please open an\n[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo.": - "*Game version: 4.3*\n\n*Recent additions: bug fixes*\n\n## Progress saving\n\nThe game stores your progress in your local browser storage.\nIf you delete it, your progress will be lost!\n\nWarning: In most browsers, deleting cookies will also clear the local storage\n(or \"local site data\"). Make sure to download your game progress first!\n\n## Credits\n\n* **Creators:** Kevin Buzzard, Jon Eugster\n* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n* **Additional thanks:** All the student beta testers, all the schools\nwho invited Kevin to speak, and all the schoolkids who asked him questions\nabout the material.\n\n## Resources\n\n* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n* [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/) (no longer maintained)\n\n## Problems?\n\nPlease ask any questions about this game in the\n[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\nthe stream \"New Members\". The community will happily help. Note that\nthe Lean Zulip chat is a professional research forum.\nPlease use your full real name there, stay on topic, and be nice. If you're\nlooking for somewhere less formal (e.g. you want to post natural number\ngame memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n\nAlternatively, if you experience issues / bugs you can also open github issues:\n\n* For issues with the game engine, please open an\n[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n* For issues about the game's content, please open an\n[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo.", + "*게임 버전: 4.3*\n\n*최근 추가 사항: 버그 수정*\n\n## 진행 상황 저장\n\n게임은 진행 상황을 브라우저의 로컬 스토리지에 저장합니다. 이를 삭제하면 진행 상황도 사라집니다!\n\n주의: 대부분의 브라우저에서 쿠키를 삭제하면 로컬 스토리지(또는 \"로컬 사이트 데이터\")도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n\n## 크레딧\n\n* **제작:** Kevin Buzzard, Jon Eugster\n* **원래 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **추가 레벨:** Sian Carey, Ivan Farabella, Archie Browne\n* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n\n## 자료\n\n* [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼\n* [원래 Lean3 버전](https://github.com/ImperialCollegeLondon/natural_number_game/) (현재는 유지보수되지 않음)\n\n## 문제가 있나요?\n\n이 게임에 관한 질문은 [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼, 예를 들어 \"New Members\" stream에 올려 주세요. 커뮤니티가 기꺼이 도와줄 것입니다. Lean Zulip chat은 전문 연구 포럼이라는 점에 유의하세요. 실명을 사용하고, 주제에 맞게 대화하며, 서로 예의를 지켜 주세요. 좀 더 가벼운 공간을 찾는다면(예: natural number game 밈을 올리고 싶다면) [Lean Discord](https://discord.gg/WZ9bs9UCvx)로 가세요.\n\n문제나 버그가 있다면 GitHub issue를 열 수도 있습니다.\n\n* 게임 엔진 문제는 [lean4game](https://github.com/leanprover-community/lean4game/issues) repo에 issue를 열어 주세요.\n* 게임 내용 문제는 [NNG](https://github.com/hhu-adam/NNG4/issues) repo에 issue를 열어 주세요.", "*Game version: 4.3*\n\n*Recent additions: bug fixes*\n\n## Progress saving\n\nThe game stores your progress in your local browser storage.\nIf you delete it, your progress will be lost!\n\nWarning: In most browsers, deleting cookies will also clear the local storage\n(or \"local site data\"). Make sure to download your game progress first!\n\n## Credits\n\n* **Creators:** Kevin Buzzard, Jon Eugster\n* **Original Lean3-version:** Kevin Buzzard, Mohammad Pedramfar\n* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **Additional levels:** Sian Carey, Ivan Farabella, Archie Browne.\n* **Additional thanks:** All the student beta testers, all the schools\nwho invited Kevin to speak, and all the schoolkids who asked him questions\nabout the material.\n\n## Resources\n\n* The [Lean Zulip chat](https://leanprover.zulipchat.com/) forum\n* [Original Lean3 version](https://github.com/ImperialCollegeLondon/natural_number_game/) (no longer maintained)\n\n## Problems?\n\nPlease ask any questions about this game in the\n[Lean Zulip chat](https://leanprover.zulipchat.com/) forum, for example in\nthe stream \"New Members\". The community will happily help. Note that\nthe Lean Zulip chat is a professional research forum.\nPlease use your full real name there, stay on topic, and be nice. If you're\nlooking for somewhere less formal (e.g. you want to post natural number\ngame memes) then head on over to the [Lean Discord](https://discord.gg/WZ9bs9UCvx).\n\nAlternatively, if you experience issues / bugs you can also open github issues:\n\n* For issues with the game engine, please open an\n[issue at the lean4game](https://github.com/leanprover-community/lean4game/issues) repo.\n* For issues about the game's content, please open an\n[issue at the NNG](https://github.com/hhu-adam/NNG4/issues) repo.": - "*게임 버전: 4.3*\n\n*최근 추가 사항: 버그 수정*\n\n## 진행 상황 저장\n\n게임은 진행 상황을 브라우저의 local storage에 저장합니다. 이를 삭제하면 진행 상황도 사라집니다!\n\n주의: 대부분의 브라우저에서 쿠키를 삭제하면 local storage(또는 \"local site data\")도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n\n## 크레딧\n\n* **제작:** Kevin Buzzard, Jon Eugster\n* **원래 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **추가 level:** Sian Carey, Ivan Farabella, Archie Browne\n* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n\n## 자료\n\n* [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼\n* [원래 Lean3 버전](https://github.com/ImperialCollegeLondon/natural_number_game/) (현재는 유지보수되지 않음)\n\n## 문제가 있나요?\n\n이 게임에 관한 질문은 [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼, 예를 들어 \"New Members\" stream에 올려 주세요. 커뮤니티가 기꺼이 도와줄 것입니다. Lean Zulip chat은 전문 연구 포럼이라는 점에 유의하세요. 실명을 사용하고, 주제에 맞게 대화하며, 서로 예의를 지켜 주세요. 좀 더 가벼운 공간을 찾는다면(예: natural number game 밈을 올리고 싶다면) [Lean Discord](https://discord.gg/WZ9bs9UCvx)로 가세요.\n\n문제나 버그가 있다면 GitHub issue를 열 수도 있습니다.\n\n* 게임 엔진 문제는 [lean4game](https://github.com/leanprover-community/lean4game/issues) repo에 issue를 열어 주세요.\n* 게임 내용 문제는 [NNG](https://github.com/hhu-adam/NNG4/issues) repo에 issue를 열어 주세요.", + "*게임 버전: 4.3*\n\n*최근 추가 사항: 버그 수정*\n\n## 진행 상황 저장\n\n게임은 진행 상황을 브라우저의 로컬 스토리지에 저장합니다. 이를 삭제하면 진행 상황도 사라집니다!\n\n주의: 대부분의 브라우저에서 쿠키를 삭제하면 로컬 스토리지(또는 “로컬 사이트 “데이)도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n\n## 크레딧\n\n* **제작:** Kevin Buzzard, Jon Eugster\n* **오리지널 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **추가 레벨:** Sian Carey, Ivan Farabella, Archie Browne\n* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n\n## 자료\n\n* [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼\n* [원래 Lean3 버전](https://github.com/ImperialCollegeLondon/natural_number_game/) (현재는 유지보수되지 않음)\n\n## 문제가 있나요?\n\n이 게임에 관한 질문은 [Lean Zulip chat](https://leanprover.zulipchat.com/) 포럼, 예를 들어 \"New Members\" stream에 올려 주세요. 커뮤니티가 기꺼이 도와줄 것입니다. Lean Zulip chat은 전문 연구 포럼이라는 점에 유의하세요. 실명을 사용하고, 주제에 맞게 대화하며, 서로 예의를 지켜 주세요. 좀 더 가벼운 공간을 찾는다면(예: natural number game 밈을 올리고 싶다면) [Lean Discord](https://discord.gg/WZ9bs9UCvx)로 가세요.\n\n문제나 버그가 있다면 GitHub issue를 열 수도 있습니다.\n\n* 게임 엔진 문제는 [lean4game](https://github.com/leanprover-community/lean4game/issues) repo에 issue를 열어 주세요.\n* 게임 내용 문제는 [NNG](https://github.com/hhu-adam/NNG4/issues) repo에 issue를 열어 주세요.", "$x=37\\implies x=37$.": "$x=37\\implies x=37$.", "$x+y=x\\implies y=0$.": "$x+y=x\\implies y=0$.", "$x+1=y+1 \\implies x=y$.": "$x+1=y+1 \\implies x=y$.", @@ -827,66 +825,66 @@ "$0\\neq1$.": "$0\\neq1$.", "$0 ^ 0 = 1$": "$0 ^ 0 = 1$", "## The birth of number.\n\nNumbers in Lean are defined by two rules.\n\n* `0` is a number.\n* If `n` is a number, then the *successor* `succ n` of `n` is a number.\n\nThe successor of `n` means the number after `n`. Let's learn to\ncount, and name a few small numbers.\n\n## Counting to four.\n\n`0` is a number, so `succ 0` is a number. Let's call this new number `1`.\nSimilarly let's define `2 = succ 1`, `3 = succ 2` and `4 = succ 3`.\nThis gives us plenty of numbers to be getting along with.\n\nThe *proof* that `2 = succ 1` is called `two_eq_succ_one`.\nCheck out the \"012\" tab in the list of lemmas on the right\nfor this and other proofs.\n\nLet's prove that $2$ is the number after the number after zero.": - "## 수의 탄생\n\nLean의 수는 두 규칙으로 정의됩니다.\n\n* `0`는 수입니다.\n* `n`이 수라면 `n`의 *successor* `succ n`도 수입니다.\n\n`n`의 successor란 `n` 다음의 수를 뜻합니다. 이제 세는 법을 배우고 작은 수 몇 개에 이름을 붙여 봅시다.\n\n## 4까지 세기\n\n`0`는 수이므로 `succ 0`도 수입니다. 이 새 수를 `1`이라고 부릅시다. 같은 방식으로 `2 = succ 1`, `n`0, `n`1을 정의합니다. 이 정도면 당분간 쓸 수가 충분합니다.\n\n`n`2의 *증명*은 `n`3이라고 부릅니다. 오른쪽 lemma 목록의 \"012\" 탭에서 이 증명과 다른 증명들을 확인하세요.\n\n`n`4가 0 다음의 다음 수라는 것을 증명해 봅시다.", + "## 수의 탄생\n\nLean의 수는 두 규칙으로 정의됩니다.\n\n* `0`는 수입니다.\n* `n`이 수라면 `n`의 *다음수* `succ n`도 수입니다.\n\n`n`의 다음수란 `n+1`을 뜻합니다. 이제 세는 법을 배우고 작은 수 몇 개에 이름을 붙여 봅시다.\n\n## 4까지 세기\n\n`0`는 수이므로 `succ 0`도 수입니다. 이 새 수를 `1`이라고 부릅시다. 같은 방식으로 `2 = succ 1`, `3 = succ 2`, `4 = succ 3`을 정의하겠습니다. 이 정도면 당분간 쓸 수가 충분합니다.\n\n`2 = succ 1`의 *증명*은 `two_eq_succ_one`이라고 부릅니다. 오른쪽 정리 목록의 \"012\" 탭에서 이 증명과 다른 증명들을 확인하세요.\n\n`$2$가 0의 다음 수의 다음 수라는 것을 증명해 봅시다.", "## Summary\n\n§0 proves goals of the form §1.\n\nIn other words, the §2 tactic will close any goal of the\nform §3 if §4 and §5 are *identical*.\n\n§6 is short for \\\\\"reflexivity (of equality)\\\\\".\n\n## Example:\n\nIf the goal looks like this:\n\n§7\n\nthen §8 will close it. But if it looks like §9 then §10 won't work, because even\nthough §11 and §12 are always equal as *numbers*, they are not equal as *terms*.\nThe only term which is identical to §13 is §14.\n\n## Details\n\n§15 is short for \\\\\"reflexivity of equality\\\\\".\n\n## Game Implementation\n\n*Note that our §16 is weaker than the version used in core Lean and §17,\nfor pedagogical purposes; mathematicians do not distinguish between propositional\nand definitional equality because they think about definitions in a different way\nto type theorists (§18 and §19 are both \\\\\"facts\\\\\" as far\nas mathematicians are concerned, and who cares what the definition of addition is).*": - "## 요약\n\n§0는 §1 꼴의 goal을 증명합니다.\n\n즉 §4와 §5가 *동일한* 항이라면 §2 tactic은 §3 꼴의 모든 goal을 닫습니다.\n\n§6는 \"reflexivity (of equality)\"의 줄임말입니다.\n\n## 예시\n\ngoal이\n\n§7\n\n처럼 생겼다면 §8이 닫습니다. 하지만 §9처럼 생겼다면 §10은 작동하지 않습니다. §11과 §12가 *수로서는* 항상 같더라도 *항으로서* 동일하지 않기 때문입니다. §13과 동일한 항은 §14뿐입니다.\n\n## 자세한 설명\n\n§15는 \"reflexivity of equality\"의 줄임말입니다.\n\n## 게임 구현\n\n*교육적 목적 때문에 이 게임의 §16는 core Lean과 §17에서 쓰는 버전보다 약합니다. 수학자들은 명제적 동등성과 정의적 동등성을 잘 구분하지 않습니다. type theorist와는 정의를 생각하는 방식이 다르기 때문입니다(수학자에게 §18과 §19는 둘 다 그저 \"사실\"이고, 덧셈의 정의가 무엇인지는 별로 중요하지 않습니다).*", + "## 요약\n\n§0는 §1 꼴의 목표를 증명합니다.\n\n즉 §4와 §5가 *동일한* 항이라면 §2 택틱은 §3 꼴의 모든 목표를 닫습니다.\n\n§6는 \"reflexivity (of equality)\"의 줄임말입니다.\n\n## 예시\n\n목표가\n\n§7\n\n처럼 생겼다면 §8이 닫습니다. 하지만 §9처럼 생겼다면 §10은 작동하지 않습니다. §11과 §12가 *수로서는* 항상 같더라도 *항으로서* 동일하지 않기 때문입니다. §13과 동일한 항은 §14뿐입니다.\n\n## 자세한 설명\n\n§15는 \"reflexivity of equality\"의 줄임말입니다.\n\n## 게임 구현\n\n*교육적 목적 때문에 이 게임의 §16는 core Lean과 §17에서 쓰는 버전보다 약합니다. 수학자들은 명제적 동등성과 정의적 동등성을 잘 구분하지 않습니다. type theorist와는 정의를 생각하는 방식이 다르기 때문입니다(수학자에게 §18과 §19는 둘 다 그저 \"사실\"이고, 덧셈의 정의가 무엇인지는 별로 중요하지 않습니다).*", "## Summary\n\n`rfl` proves goals of the form `X = X`.\n\nIn other words, the `rfl` tactic will close any goal of the\nform `A = B` if `A` and `B` are *identical*.\n\n`rfl` is short for \\\"reflexivity (of equality)\\\".\n\n## Example:\n\nIf the goal looks like this:\n\n```\nx + 37 = x + 37\n```\n\nthen `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even\nthough $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.\nThe only term which is identical to `0 + x` is `0 + x`.\n\n## Details\n\n`rfl` is short for \\\"reflexivity of equality\\\".\n\n## Game Implementation\n\n*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,\nfor pedagogical purposes; mathematicians do not distinguish between propositional\nand definitional equality because they think about definitions in a different way\nto type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\nas mathematicians are concerned, and who cares what the definition of addition is).*": - "## Summary\n\n`rfl` proves goals of the form `X = X`.\n\nIn other words, the `rfl` tactic will close any goal of the\nform `A = B` if `A` and `B` are *identical*.\n\n`rfl` is short for \\\"reflexivity (of equality)\\\".\n\n## Example:\n\nIf the goal looks like this:\n\n```\nx + 37 = x + 37\n```\n\nthen `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even\nthough $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.\nThe only term which is identical to `0 + x` is `0 + x`.\n\n## Details\n\n`rfl` is short for \\\"reflexivity of equality\\\".\n\n## Game Implementation\n\n*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,\nfor pedagogical purposes; mathematicians do not distinguish between propositional\nand definitional equality because they think about definitions in a different way\nto type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\nas mathematicians are concerned, and who cares what the definition of addition is).*", + "## 요약\n\n`rfl`은 `X = X` 꼴의 목표를 증명합니다.\n\n즉 `A`와 `B`가 *동일한* 항이라면 `rfl` 택틱은\n`A = B` 꼴의 모든 목표를 닫습니다.\n\n`rfl`은 \\\"reflexivity (of equality)\\\"의 줄임말입니다.\n\n## 예시:\n\n목표가 다음과 같이 생겼다면:\n\n```\nx + 37 = x + 37\n```\n\n`rfl`로 목표를 닫을 수 있습니다. 하지만 목표가 `0 + x = x`라면 `rfl`은 작동하지 않습니다.\n$0+x$와 $x$는 *수로서는* 항상 같지만, *항으로서는* 동일하지 않기 때문입니다.\n`0 + x`와 동일한 항은 `0 + x`뿐입니다.\n\n## 자세한 설명\n\n`rfl`은 \\\"reflexivity of equality(등호의 반사성)\\\"의 줄임말입니다.\n\n## 게임 구현\n\n*교육적 목적 때문에 이 게임의 `rfl`은 core Lean과 `mathlib`에서 사용하는 버전보다 약합니다.\n수학자들은 명제적 동등성과 정의적 동등성을 잘 구분하지 않는데, 이는 타입 이론자들과\n정의를 바라보는 방식이 다르기 때문입니다. 수학자에게 `zero_add`와 `add_zero`는 둘 다\n그저 \\\"사실\\\"이고, 덧셈을 정확히 어떻게 정의했는지는 별로 중요하지 않습니다.*", "## Summary\n\n`repeat t` repeatedly applies the tactic `t`\nto the goal. You don't need to use this\ntactic, it just speeds things up sometimes.\n\n## Example\n\n`repeat rw [add_zero]` will turn the goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\ninto the goal\n`a = b`.\n\"\n\nTacticDoc nth_rewrite \"\n## Summary\n\nIf `h : X = Y` and there are several `X`s in the goal, then\n`nth_rewrite 3 [h]` will just change the third `X` to a `Y`.\n\n## Example\n\nIf the goal is `2 + 2 = 4` then `nth_rewrite 2 [two_eq_succ_one]`\nwill change the goal to `2 + succ 1 = 4`. In contrast, `rw [two_eq_succ_one]`\nwill change the goal to `succ 1 + succ 1 = 4`.": - "## 요약\n\n`repeat t`는 tactic `t`을 goal에 반복 적용합니다. 꼭 필요한 tactic은 아니지만 때때로 속도를 높여 줍니다.\n\n## 예시\n\n`repeat rw [add_zero]`는 goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n을 goal\n`a = b`\n로 바꿉니다.\n\nTacticDoc nth_rewrite\n## 요약\n\n`h : X = Y`이고 goal에 `X`가 여러 개 있다면 `nth_rewrite 3 [h]`은 세 번째 `X`만 `Y`로 바꿉니다.\n\n## 예시\n\ngoal이 `t`0이면 `t`1은 goal을 `t`2로 바꿉니다. 반면 `t`3은 goal을 `t`4로 바꿉니다.", + "## 요약\n\n`repeat t`는 택틱 `t`을 목표에 반복 적용합니다. 꼭 필요한 택틱은 아니지만 때때로 속도를 높여 줍니다.\n\n## 예시\n\n`repeat rw [add_zero]`는 목표\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n을 목표\n`a = b`\n로 바꿉니다.\n\nTacticDoc nth_rewrite\n## 요약\n\n`h : X = Y`이고 목표에 `X`가 여러 개 있다면 `nth_rewrite 3 [h]`은 세 번째 `X`만 `Y`로 바꿉니다.\n\n## 예시\n\n목표가 `2 + 2 = 4`이면 `nth_rewrite 2 [two_eq_succ+one]`은 목표를 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 목표를 `succ 1 + succ 1 = 4`로 바꿉니다.", "## Summary\n\n`repeat t` repeatedly applies the tactic `t`\nto the goal. You don't need to use this\ntactic, it just speeds things up sometimes.\n\n## Example\n\n`repeat rw [add_zero]` will turn the goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\ninto the goal\n`a = b`.": - "## 요약\n\n`repeat t`는 tactic `t`을 goal에 반복해서 적용합니다. 반드시 필요한 tactic은 아니지만 때로는 일을 빠르게 해 줍니다.\n\n## 예시\n\n`repeat rw [add_zero]`는 goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n을\n`a = b`\n로 바꿉니다.", + "## 요약\n\n`repeat t`는 택틱 `t`을 목표에 반복해서 적용합니다. 반드시 필요한 택틱은 아니지만 때로는 일을 빠르게 해 줍니다.\n\n## 예시\n\n`repeat rw [add_zero]`는 goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n을\n`a = b`\n로 바꿉니다.", "## Summary\n\nThe §0 tactic makes progress with goals which claim something *exists*.\nIf the goal claims that some §1 exists with some property, and you know\nthat §2 will work, then §3 will make progress.\n\nBecause §4 is notation for \\\\\"there exists §5 such that §6\\\\\",\nyou can make progress on goals of the form §7 by §8ing the\nnumber which is morally §9 (i.e. §10)\n\nAny of the following examples is possible assuming the type of the argument passed to the §11 function is accurate:\n\n- §12\n- §13\n- §14": - "## 요약\n\n§0 tactic은 어떤 것이 *존재한다*고 주장하는 goal에서 진행할 수 있게 해 줍니다. goal이 어떤 성질을 만족하는 §1이 존재한다고 말하고, §2가 그 역할을 한다는 것을 알고 있다면 §3으로 진행할 수 있습니다.\n\n§4가 \"§6를 만족하는 §5가 존재한다\"의 표기이므로, §7 꼴의 goal에서는 본질적으로 §9인 수(즉 §10)를 §8해서 진행할 수 있습니다.\n\n§11 함수에 주는 인자의 타입이 올바르다면 다음 예시는 모두 가능합니다:\n\n- §12\n- §13\n- §14", + "## 요약\n\n§0 택틱은 어떤 것이 *존재한다*고 주장하는 목표에서 진행할 수 있게 해 줍니다. 목표가 어떤 성질을 만족하는 §1이 존재한다고 말하고, §2가 그 역할을 한다는 것을 알고 있다면 §3으로 진행할 수 있습니다.\n\n§4가 \"§6를 만족하는 §5가 존재한다\"의 표기이므로, §7 꼴의 목표에서는 본질적으로 §9인 수(즉 §10)를 §8해서 진행할 수 있습니다.\n\n§11 함수에 주는 인자의 타입이 올바르다면 다음 예시는 모두 가능합니다:\n\n- §12\n- §13\n- §14", "## Summary\n\nThe `use` tactic makes progress with goals which claim something *exists*.\nIf the goal claims that some `x` exists with some property, and you know\nthat `x = 37` will work, then `use 37` will make progress.\n\nBecause `a ≤ b` is notation for \\\"there exists `c` such that `b = a + c`\\\",\nyou can make progress on goals of the form `a ≤ b` by `use`ing the\nnumber which is morally `b - a` (i.e. `use b - a`)\n\nAny of the following examples is possible assuming the type of the argument passed to the `use` function is accurate:\n\n- `use 37`\n- `use a`\n- `use a * a + 1`": - "## Summary\n\nThe `use` tactic makes progress with goals which claim something *exists*.\nIf the goal claims that some `x` exists with some property, and you know\nthat `x = 37` will work, then `use 37` will make progress.\n\nBecause `a ≤ b` is notation for \\\"there exists `c` such that `b = a + c`\\\",\nyou can make progress on goals of the form `a ≤ b` by `use`ing the\nnumber which is morally `b - a` (i.e. `use b - a`)\n\nAny of the following examples is possible assuming the type of the argument passed to the `use` function is accurate:\n\n- `use 37`\n- `use a`\n- `use a * a + 1`", + "## 요약\n\n`use` 택틱은 어떤 것이 *존재한다*고 주장하는 목표를 진행할 때 사용합니다.\n목표가 어떤 성질을 만족하는 `x`가 존재한다고 주장하고, `x = 37`이면 된다는 것을 알고 있다면,\n`use 37`을 사용해 진행할 수 있습니다.\n\n`a ≤ b`는 \\\"`b = a + c`를 만족하는 `c`가 존재한다\\\"는 뜻의 표기이므로,\n`a ≤ b` 꼴의 목표에서는 직관적으로 `b - a`에 해당하는 수를 `use`하여\n진행할 수 있습니다. 즉 `use b - a`와 같은 식입니다.\n\n`use`에 넘기는 항의 타입만 올바르다면 다음과 같은 예시를 사용할 수 있습니다:\n\n- `use 37`\n- `use a`\n- `use a * a + 1`", "## Summary\n\nThe `symm` tactic will change a goal or hypothesis of\nthe form `X = Y` to `Y = X`. It will also work on `X ≠ Y`\nand on `X ↔ Y`.\n\n### Example\n\nIf the goal is `2 + 2 = 4` then `symm` will change it to `4 = 2 + 2`.\n\n### Example\n\nIf `h : 2 + 2 ≠ 5` then `symm at h` will change `h` to `5 ≠ 2 + 2`.": - "## 요약\n\n`symm` tactic은 `X = Y` 꼴의 goal 또는 가정을 `Y = X` 꼴로 바꿉니다. `X ≠ Y`과 `X ↔ Y`에도 사용할 수 있습니다.\n\n### 예시\n\ngoal이 `2 + 2 = 4`라면 `symm`은 이를 `4 = 2 + 2`로 바꿉니다.\n\n### 예시\n\n`h : 2 + 2 ≠ 5`이라면 `symm at h`는 `X = Y`0을 `X = Y`1로 바꿉니다.", + "## 요약\n\n`symm` tactic은 `X = Y` 꼴의 목표 또는 가정을 `Y = X` 꼴로 바꿉니다. `X ≠ Y`과 `X ↔ Y`에도 사용할 수 있습니다.\n\n### 예시\n\n목표가 `2 + 2 = 4`라면 `symm`은 이를 `4 = 2 + 2`로 바꿉니다.\n\n### 예시\n\n`h : 2 + 2 ≠ 5`이라면 `symm at h`는 `h`을 `5 ≠ 2 + 2`로 바꿉니다.", "## Summary\n\nIf §0 is a proof that §1, and §2 is a proof of §3,\nthen §4 will change §5 to a proof of §6. The idea is that if\nyou know §7 is true, then you can deduce from §8 that §9 is true.\n\nIf the *goal* is §10, then §11 will \\\\\"argue backwards\\\\\" and change the\ngoal to §12. The idea here is that if you want to prove §13, then by §14\nit suffices to prove §15, so you can reduce the goal to proving §16.\n\n### Example:\n\n§17 is a proof that §18.\n\nSo if you have a hypothesis §19\nthen §20 will change §21 to §22.\nYou could write §23\nbut Lean is smart enough to figure out the inputs to §24.\n\n### Example\n\nIf the goal is §25, then §26 will turn the\ngoal into §27.": - "## 요약\n\n§0가 §1의 증명이고 §2가 §3의 증명이라면 §4는 §5를 §6의 증명으로 바꿉니다. 아이디어는 §7이 참이라는 것을 알면 §8로부터 §9가 참임을 이끌어낼 수 있다는 것입니다.\n\n*goal*이 §10이라면 §11은 \"거꾸로 추론\"해서 goal을 §12로 바꿉니다. §13을 증명하고 싶을 때 §14에 의해 §15만 증명하면 충분하므로 goal을 §16의 증명으로 환원하는 것입니다.\n\n### 예시\n\n§17은 §18의 증명입니다.\n\n따라서 가정 §19가 있다면 §20은 §21을 §22로 바꿉니다. §23이라고 직접 써도 되지만 Lean이 §24의 입력을 알아서 찾아 줍니다.\n\n### 예시\n\ngoal이 §25라면 §26은 goal을 §27로 바꿉니다.", + "## 요약\n\n§0가 §1의 증명이고 §2가 §3의 증명이라면 §4는 §5를 §6의 증명으로 바꿉니다. 아이디어는 §7이 참이라는 것을 알면 §8로부터 §9가 참임을 이끌어낼 수 있다는 것입니다.\n\n*목표*가 §10이라면 §11은 \"거꾸로 추론\"해서 목표를 §12로 바꿉니다. §13을 증명하고 싶을 때 §14에 의해 §15만 증명하면 충분하므로 목표를 §16의 증명으로 환원하는 것입니다.\n\n### 예시\n\n§17은 §18의 증명입니다.\n\n따라서 가정 §19가 있다면 §20은 §21을 §22로 바꿉니다. §23이라고 직접 써도 되지만 Lean이 §24의 입력을 알아서 찾아 줍니다.\n\n### 예시\n\n목표가 §25라면 §26은 목표를 §27로 바꿉니다.", "## Summary\n\nIf §0 is a proof of an equality §1, then §2 will change\nall §3s in the goal to §4s. It's the way to \\\\\"substitute in\\\\\".\n\n## Variants\n\n* §5 (changes §6s to §7s; get the back arrow by typing §8 or §9.)\n\n* §10 (a sequence of rewrites)\n\n* §11 (changes §12s to §13s in hypothesis §14)\n\n* §15 (changes §16s to §17s in two hypotheses and the goal;\nget the §18 symbol with §19.)\n\n* §20 will keep changing §21 to §22\nuntil there are no more matches for §23.\n\n* §24 will change only the second §25 in the goal to §26.\n\n### Example:\n\nIf you have the assumption §27 and your goal is\n§28\n\nthen\n\n§29\n\nwill change the goal into §30, and then\n\n§31\n\nwill change the goal into §32, which\ncan be solved with §33.\n\n### Example:\n\nYou can use §34 to change a hypothesis as well.\nFor example, if you have two hypotheses\n§35\nthen §36 will turn §37 into §38.\n\n## Common errors\n\n* You need the square brackets. §39 is never correct.\n\n* If §40 is not a *proof* of an *equality* (a statement of the form §41),\nfor example if §42 is a function or an implication,\nthen §43 is not the tactic you want to use. For example,\n§44 is never correct: §45 is the theorem *statement*,\nnot the proof. If §46 is the proof, then §47 will work.\n\n## Details\n\nThe §48 tactic is a way to do \\\\\"substituting in\\\\\". There\nare two distinct situations where you can use this tactic.\n\n1) Basic usage: if §49 is an assumption or\nthe proof of a theorem, and if the goal contains one or more §50s, then §51\nwill change them all to §52s. The tactic will error\nif there are no §53s in the goal.\n\n2) Advanced usage: Assumptions coming from theorem proofs\noften have missing pieces. For example §54\nis a proof that §55 because §56 really is a function,\nand §57 is the input. In this situation §58 will look through the goal\nfor any subterm of the form §59, and the moment it\nfinds one it fixes §60 to be §61 then changes all §62s to §63s.\n\nExercise: think about why §64 changes the term\n§65 to\n§66\n\nIf you can't remember the name of the proof of an equality, look it up in\nthe list of lemmas on the right.\n\n## Targeted usage\n\nIf your goal is §67 and you want to rewrite §68\nto §69, then §70 will not work because Lean finds another\naddition first and swaps those inputs instead. Use §71 to\nguarantee that Lean rewrites §72 to §73. This works because\n§74 is a proof that §75, §76 is a proof\nthat §77, and §78 is a proof that §79.\n\nIf §80 then §81 will turn all §82s into §83s.\nIf you only want to change the 37th occurrence of §84\nto §85 then do §86.": - "## 요약\n\n§0가 등식 §1의 증명이라면 §2는 goal의 모든 §3을 §4로 바꿉니다. 즉 \"대입\"하는 방법입니다.\n\n## 변형\n\n* §5 (§6을 §7로 바꿉니다. 뒤쪽 화살표는 §8 또는 §9를 입력해 얻을 수 있습니다.)\n* §10 (여러 번의 rewrite를 연속으로 수행)\n* §11 (가정 §14 안의 §12를 §13으로 바꿈)\n* §15 (두 가정과 goal에서 §16을 §17로 바꿈. §18 기호는 §19로 입력)\n* §20은 더 이상 §23과 일치하는 것이 없을 때까지 §21을 §22로 계속 바꿉니다.\n* §24는 goal의 두 번째 §25만 §26으로 바꿉니다.\n\n### 예시\n\n가정 §27이 있고 goal이\n§28\n이라면\n\n§29\n\n은 goal을 §30으로 바꾸고, 이어서\n\n§31\n\n은 goal을 §32로 바꿉니다. 이는 §33으로 해결할 수 있습니다.\n\n### 예시\n\n§34를 사용해 가정을 바꿀 수도 있습니다. 예를 들어 두 가정 §35가 있다면 §36은 §37을 §38로 바꿉니다.\n\n## 흔한 오류\n\n* 대괄호가 필요합니다. §39는 절대 올바르지 않습니다.\n* §40이 *등식* §41의 *증명*이 아니라 함수나 함의 같은 것이라면 §43은 원하는 tactic이 아닙니다. 예를 들어 §42가 함수나 함의라면 §44는 절대 올바르지 않습니다. §45는 정리의 *명제*이지 증명이 아닙니다. §46가 증명이라면 §47은 작동합니다.\n\n## 자세한 설명\n\n§48 tactic은 \"대입\"을 하는 방법입니다. 서로 다른 두 상황에서 사용할 수 있습니다.\n\n1) 기본 사용법: §49가 가정이나 정리의 증명이고 goal에 하나 이상의 §50가 있다면 §51은 그 모두를 §52로 바꿉니다. goal에 §53이 하나도 없으면 오류가 납니다.\n\n2) 고급 사용법: 정리의 증명에서 얻은 가정은 인자가 빠져 있는 경우가 많습니다. 예를 들어 §54가 §55의 증명인 것은 §56가 실제로 함수이고 §57이 입력이기 때문입니다. 이 상황에서 §58은 goal에서 §59 꼴의 부분항을 찾고, 찾는 즉시 §60을 §61로 정한 뒤 모든 §62를 §63으로 바꿉니다.\n\n연습: §64가 항 §65를 §66으로 바꾸는 이유를 생각해 보세요.\n\n등식의 증명 이름이 기억나지 않으면 오른쪽 lemma 목록에서 찾아보세요.\n\n## 정확히 지정해서 사용하기\n\ngoal이 §67이고 §68을 §69로 rewrite하고 싶다고 합시다. §70은 작동하지 않습니다. Lean이 다른 덧셈을 먼저 찾아 그 입력을 바꾸기 때문입니다. §71을 사용하면 Lean이 반드시 §72를 §73으로 rewrite하게 할 수 있습니다. 이는 §74가 §75의 증명, §76이 §77의 증명, §78이 §79의 증명이기 때문입니다.\n\n§80이라면 §81은 모든 §82를 §83으로 바꿉니다. §84의 37번째 occurrence만 §85로 바꾸고 싶다면 §86을 사용하세요.", + "## 요약\n\n§0가 등식 §1의 증명이라면 §2는 목표의 모든 §3을 §4로 바꿉니다. 즉 \"대입\"하는 방법입니다.\n\n## 변형\n\n* §5 (§6을 §7로 바꿉니다. 뒤쪽 화살표는 §8 또는 §9를 입력해 얻을 수 있습니다.)\n* §10 (여러 번의 rewrite를 연속으로 수행)\n* §11 (가정 §14 안의 §12를 §13으로 바꿈)\n* §15 (두 가정과 목표에서 §16을 §17로 바꿈. §18 기호는 §19로 입력)\n* §20은 더 이상 §23과 일치하는 것이 없을 때까지 §21을 §22로 계속 바꿉니다.\n* §24는 목표의 두 번째 §25만 §26으로 바꿉니다.\n\n### 예시\n\n가정 §27이 있고 목표가\n§28\n이라면\n\n§29\n\n은 목표를 §30으로 바꾸고, 이어서\n\n§31\n\n은 목표를 §32로 바꿉니다. 이는 §33으로 해결할 수 있습니다.\n\n### 예시\n\n§34를 사용해 가정을 바꿀 수도 있습니다. 예를 들어 두 가정 §35가 있다면 §36은 §37을 §38로 바꿉니다.\n\n## 흔한 오류\n\n* 대괄호가 필요합니다. §39는 절대 올바르지 않습니다.\n* §40이 *등식* §41의 *증명*이 아니라 함수나 조건문 같은 것이라면 §43은 원하는 택틱이 아닙니다. 예를 들어 §42가 함수나 조건문이라면 §44는 절대 올바르지 않습니다. §45는 정리의 *명제*이지 증명이 아닙니다. §46가 증명이라면 §47은 작동합니다.\n\n## 자세한 설명\n\n§48 택틱은 \"대입\"을 하는 방법입니다. 서로 다른 두 상황에서 사용할 수 있습니다.\n\n1) 기본 사용법: §49가 가정이나 정리의 증명이고 목표에 하나 이상의 §50가 있다면 §51은 그 모두를 §52로 바꿉니다. 목표에 §53이 하나도 없으면 오류가 납니다.\n\n2) 고급 사용법: 정리의 증명에서 얻은 가정은 인자가 빠져 있는 경우가 많습니다. 예를 들어 §54가 §55의 증명인 것은 §56가 실제로 함수이고 §57이 입력이기 때문입니다. 이 상황에서 §58은 목표에서 §59 꼴의 부분항을 찾고, 찾는 즉시 §60을 §61로 정한 뒤 모든 §62를 §63으로 바꿉니다.\n\n연습: §64가 항 §65를 §66으로 바꾸는 이유를 생각해 보세요.\n\n등식의 증명 이름이 기억나지 않으면 오른쪽 정리 목록에서 찾아보세요.\n\n## 정확히 지정해서 사용하기\n\n목표가 §67이고 §68을 §69로 rewrite하고 싶다고 합시다. §70은 작동하지 않습니다. Lean이 다른 덧셈을 먼저 찾아 그 입력을 바꾸기 때문입니다. §71을 사용하면 Lean이 반드시 §72를 §73으로 rewrite하게 할 수 있습니다. 이는 §74가 §75의 증명, §76이 §77의 증명, §78이 §79의 증명이기 때문입니다.\n\n§80이라면 §81은 모든 §82를 §83으로 바꿉니다. §84의 37번째 occurrence만 §85로 바꾸고 싶다면 §86을 사용하세요.", "## Summary\n\nIf the goal is a statement §0, then §1 will close the goal if §2 is a proof of §3.\n\n### Example\n\nIf the goal is §4 and you have a hypothesis §5\nthen §6 will solve the goal.\n\n### Example\n\nIf the goal is §7 then §8 will close the goal.\n\n### Exact needs to be exactly right\n\nNote that §9 will *not work* in the previous example;\nfor §10 to work, §11 has to be *exactly* a proof of the goal.\n§12 is a proof of §13 or, if you like,\na proof of §14 where §15 needs to be supplied by the user.\nThis is in contrast to §16 and §17, which will \\\\\"guess the inputs\\\\\"\nif necessary. If the goal is §18 then §19\nand §20 will both change the goal to §21,\nbecause §22 guesses the input to the function §23.": - "## 요약\n\ngoal이 명제 §0이고 §2가 §3의 증명이라면 §1이 goal을 닫습니다.\n\n### 예시\n\ngoal이 §4이고 가정 §5가 있다면 §6으로 goal을 해결할 수 있습니다.\n\n### 예시\n\ngoal이 §7이라면 §8로 goal을 닫을 수 있습니다.\n\n### exact는 정말 exact해야 합니다\n\n앞 예시에서 §9는 *작동하지 않습니다*. §10이 작동하려면 §11이 goal의 증명과 *정확히* 일치해야 합니다. §12는 §13의 증명이며, 달리 말하면 사용자가 §15를 넣어야 하는 §14의 증명입니다.\n이는 필요할 경우 \"입력을 추측\"해 주는 §16과 §17과 대비됩니다. goal이 §18이면 §19와 §20은 모두 goal을 §21로 바꿉니다. §22가 함수 §23의 입력을 추측하기 때문입니다.", + "## 요약\n\n목표가 명제 §0이고 §2가 §3의 증명이라면 §1이 목표를 닫습니다.\n\n### 예시\n\n목표가 §4이고 가정 §5가 있다면 §6으로 목표를 해결할 수 있습니다.\n\n### 예시\n\n목표가 §7이라면 §8로 목표를 닫을 수 있습니다.\n\n### exact는 정말 exact해야 합니다\n\n앞 예시에서 §9는 *작동하지 않습니다*. §10이 작동하려면 §11이 목표의 증명과 *정확히* 일치해야 합니다. §12는 §13의 증명이며, 달리 말하면 사용자가 §15를 넣어야 하는 §14의 증명입니다.\n이는 필요할 경우 \"입력을 추측\"해 주는 §16과 §17과 대비됩니다. 목표가 §18이면 §19와 §20은 모두 목표를 §21로 바꿉니다. §22가 함수 §23의 입력을 추측하기 때문입니다.", "## Summary\n\nIf the goal is a statement `P`, then `exact h` will close the goal if `h` is a proof of `P`.\n\n### Example\n\nIf the goal is `x = 37` and you have a hypothesis `h : x = 37`\nthen `exact h` will solve the goal.\n\n### Example\n\nIf the goal is `x + 0 = x` then `exact add_zero x` will close the goal.\n\n### Exact needs to be exactly right\n\nNote that `exact add_zero` will *not work* in the previous example;\nfor `exact h` to work, `h` has to be *exactly* a proof of the goal.\n`add_zero` is a proof of `∀ n, n + 0 = n` or, if you like,\na proof of `? + 0 = ?` where `?` needs to be supplied by the user.\nThis is in contrast to `rw` and `apply`, which will \\\"guess the inputs\\\"\nif necessary. If the goal is `x + 0 = x` then `rw [add_zero]`\nand `rw [add_zero x]` will both change the goal to `x = x`,\nbecause `rw` guesses the input to the function `add_zero`.": - "## Summary\n\nIf the goal is a statement `P`, then `exact h` will close the goal if `h`는 `P`.\n\n### Example\n\nIf the goal is `x = 37` and you have a hypothesis `h : x = 37`\nthen `exact h` will solve the goal.\n\n### Example\n\nIf the goal is `x + 0 = x` then `exact add_zero x` will close the goal.\n\n### Exact needs to be exactly right\n\nNote that `exact add_zero` will *not work* in the previous example;\nfor `exact h` to work, `h` has to be *exactly* a proof of the goal.\n`add_zero` is a proof of `∀ n, n + 0 = n` or, if you like,\na proof of `? + 0 = ?` where `?` needs to be supplied by the user.\nThis is in contrast to `rw` and `apply`, which will \\\"guess the inputs\\\"\nif necessary. If the goal is `x + 0 = x` then `rw [add_zero]`\nand `rw [add_zero x]` will both change the goal to `x = x`,\nbecause `rw` guesses the input to the function `add_zero`의 증명입니다.", + "## 요약\n\n목표가 명제 `P`라면, `h`가 `P`의 증명일 때 `exact h`로 목표를 닫을 수 있습니다.\n\n### 예시\n\n목표가 `x = 37`이고 가정 `h : x = 37`이 있다면,\n`exact h`로 목표를 해결할 수 있습니다.\n\n### 예시\n\n목표가 `x + 0 = x`라면 `exact add_zero x`로 목표를 닫을 수 있습니다.\n\n### Exact는 정확히 맞아야 합니다\n\n앞의 예시에서 `exact add_zero`는 *작동하지 않습니다*.\n`exact h`가 작동하려면 `h`가 목표의 *정확한* 증명이어야 합니다.\n`add_zero`는 `∀ n, n + 0 = n`의 증명입니다. 또는 원한다면,\n사용자가 `?`에 들어갈 값을 지정해야 하는 `? + 0 = ?`의 증명이라고 생각해도 됩니다.\n이는 필요할 경우 입력값을 \\\"추측\\\"하는 `rw`나 `apply`와는 다릅니다.\n목표가 `x + 0 = x`라면 `rw [add_zero]`와 `rw [add_zero x]`는\n둘 다 목표를 `x = x`로 바꿉니다. `rw`가 함수 `add_zero`에 들어갈\n입력값을 추측하기 때문입니다.", "## Summary\n\nIf the goal is `P → Q`, then `intro h` will introduce `h : P` as a hypothesis,\nand change the goal to `Q`. Mathematically, it says that to prove $P \\implies Q$,\nwe can assume $P$ and then prove $Q$.\n\n### Example:\n\nIf your goal is `x + 1 = y + 1 → x = y` (the way Lean writes $x+1=y+1 \\implies x=y$)\nthen `intro h` will give you a hypothesis $x+1=y+1$ named `h`, and the goal\nwill change to $x=y$.": - "## 요약\n\n만약 goal이 `P → Q`라면, `intro h`는 가정에 `h : P`을 남기고,\ngoal을 `Q`로 바꿀 것입니다. 수학적으로, $P \\implies Q$를 증명한다는 것은,\n$P$를 먼저 가정하고 $Q$를 증명하는 것과 같습니다..\n\n### 예시:\n\n만약 goal이 `x + 1 = y + 1 → x = y`라면, Lean이 $x+1=y+1 \\implies x=y$을 일컫는 방법\n`intro h`를 했을 때 `h`라고 하는 $x+1=y+1$ 가 남고,\ngoal은 $x=y$로 바뀔 것입니다.", + "## 요약\n\n만약 목표가 `P → Q`라면, `intro h`는 가정에 `h : P`을 남기고,\n목표를 `Q`로 바꿀 것입니다. 수학적으로, $P \\implies Q$를 증명한다는 것은,\n$P$를 먼저 가정하고 $Q$를 증명하는 것과 같습니다..\n\n### 예시:\n\n만약 목표가 `x + 1 = y + 1 → x = y`라면, Lean이 $x+1=y+1 \\implies x=y$을 일컫는 방법\n`intro h`를 했을 때 `h`라고 하는 $x+1=y+1$ 가 남고,\n목표는 $x=y$로 바뀔 것입니다.", "## Summary\n\nIf `t : P → Q` is a proof that $P \\implies Q$, and `h : P` is a proof of `P`,\nthen `apply t at h` will change `h` to a proof of `Q`. The idea is that if\nyou know `P` is true, then you can deduce from `t` that `Q` is true.\n\nIf the *goal* is `Q`, then `apply t` will \\\"argue backwards\\\" and change the\ngoal to `P`. The idea here is that if you want to prove `Q`, then by `t`\nit suffices to prove `P`, so you can reduce the goal to proving `P`.\n\n### Example:\n\n`succ_inj x y` is a proof that `succ x = succ y → x = y`.\n\nSo if you have a hypothesis `h : succ (a + 37) = succ (b + 42)`\nthen `apply succ_inj at h` will change `h` to `a + 37 = b + 42`.\nYou could write `apply succ_inj (a + 37) (b + 42) at h`\nbut Lean is smart enough to figure out the inputs to `succ_inj`.\n\n### Example\n\nIf the goal is `a * b = 7`, then `apply succ_inj` will turn the\ngoal into `succ (a * b) = succ 7`.": - "## Summary\n\nIf `t : P → Q`는 $P \\implies Q$, and `h : P` is a proof of `P`,\nthen `apply t at h` will change `h` to a proof of `Q`. The idea is that if\nyou know `P` is true, then you can deduce from `t` that `Q` is true.\n\nIf the *goal* is `Q`, then `apply t` will \\\"argue backwards\\\" and change the\ngoal to `P`. The idea here is that if you want to prove `Q`, then by `t`\nit suffices to prove `P`, so you can reduce the goal to proving `P`.\n\n### Example:\n\n`succ_inj x y` is a proof that `succ x = succ y → x = y`.\n\nSo if you have a hypothesis `h : succ (a + 37) = succ (b + 42)`\nthen `apply succ_inj at h` will change `h` to `a + 37 = b + 42`.\nYou could write `apply succ_inj (a + 37) (b + 42) at h`\nbut Lean is smart enough to figure out the inputs to `succ_inj`.\n\n### Example\n\nIf the goal is `a * b = 7`, then `apply succ_inj` will turn the\ngoal into `succ (a * b) = succ 7`.의 증명입니다.", + "## 요약\n\n`t : P → Q`가 $P \\implies Q$의 증명이고, `h : P`가 `P`의 증명이라고 합시다.\n그러면 `apply t at h`는 `h`를 `Q`의 증명으로 바꿉니다. 아이디어는 간단합니다.\n`P`가 참이라는 것을 알고 있다면, `t`를 이용해 `Q`도 참이라고 결론낼 수 있습니다.\n\n*목표*가 `Q`라면, `apply t`는 이 논증을 \\\"거꾸로\\\" 적용하여 목표를 `P`로 바꿉니다.\n`Q`를 증명하고 싶을 때 `t`에 의해 `P`만 증명하면 충분하므로, 목표를 `P`의 증명으로\n줄일 수 있다는 뜻입니다.\n\n### 예시:\n\n`succ_inj x y`는 `succ x = succ y → x = y`의 증명입니다.\n\n따라서 가정 `h : succ (a + 37) = succ (b + 42)`가 있다면,\n`apply succ_inj at h`는 `h`를 `a + 37 = b + 42`의 증명으로 바꿉니다.\n`apply succ_inj (a + 37) (b + 42) at h`라고 직접 써도 되지만,\nLean은 `succ_inj`에 들어갈 입력을 스스로 알아낼 만큼 똑똑합니다.\n\n### 예시\n\n목표가 `a * b = 7`이라면, `apply succ_inj`는 목표를\n`succ (a * b) = succ 7`로 바꿉니다.", "## Summary\n\nIf `n` is a number, then `cases n with d` will break the goal into two goals,\none with `n = 0` and the other with `n = succ d`.\n\nIf `h` is a proof (for example a hypothesis), then `cases h with...` will break the\nproof up into the pieces used to prove it.\n\n## Example\n\nIf `n : ℕ` is a number, then `cases n with d` will break the goal into two goals,\none with `n` replaced by 0 and the other with `n` replaced by `succ d`. This\ncorresponds to the mathematical idea that every natural number is either `0`\nor a successor.\n\n## Example\n\nIf `h : P ∨ Q` is a hypothesis, then `cases h with hp hq` will turn one goal\ninto two goals, one with a hypothesis `hp : P` and the other with a\nhypothesis `hq : Q`.\n\n## Example\n\nIf `h : False` is a hypothesis, then `cases h` will turn one goal into no goals,\nbecause there are no ways to make a proof of `False`! And if you have no goals left,\nyou have finished the level.\n\n## Example\n\nIf `h : a ≤ b` is a hypothesis, then `cases h with c hc` will create a new number `c`\nand a proof `hc : b = a + c`. This is because the *definition* of `a ≤ b` is\n`∃ c, b = a + c`.": - "## 요약\n\n`n`가 수라면 `cases n with d`은 goal을 둘로 나눕니다. 하나에서는 `n = 0`이고 다른 하나에서는 `n = succ d`입니다.\n\n`h`가 증명(예: 가정)이라면 `cases h with...`는 그 증명을 구성한 조각들로 분해합니다.\n\n## 예시\n\n`n : ℕ`가 수라면 `cases n with d`은 goal을 두 개로 나눕니다. 하나에서는 `n`이 0으로 바뀌고, 다른 하나에서는 `n`가 `cases n with d`0으로 바뀝니다. 이는 모든 자연수가 `cases n with d`1이거나 successor라는 수학적 생각에 해당합니다.\n\n## 예시\n\n`cases n with d`2가 가정이라면 `cases n with d`3은 하나의 goal을 두 goal로 바꿉니다. 하나에는 가정 `cases n with d`4가 있고 다른 하나에는 가정 `cases n with d`5가 있습니다.\n\n## 예시\n\n`cases n with d`6가 가정이라면 `cases n with d`7은 goal 하나를 goal 0개로 바꿉니다. `cases n with d`8의 증명을 만드는 방법이 없기 때문입니다! goal이 하나도 남지 않으면 level을 끝낸 것입니다.\n\n## 예시\n\n`cases n with d`9가 가정이라면 `n = 0`0은 새 수 `n = 0`1과 증명 `n = 0`2를 만듭니다. `n = 0`3의 *정의*가 `n = 0`4이기 때문입니다.", + "## 요약\n\n`n`이 수라면 `cases n with d`는 목표를 두 개로 나눕니다.\n하나는 `n = 0`인 경우이고, 다른 하나는 `n = succ d`인 경우입니다.\n\n`h`가 증명(예를 들어 가정)이라면 `cases h with...`는 그 증명을\n구성하는 데 사용된 부분들로 분해합니다.\n\n## 예시\n\n`n : ℕ`이 수라면 `cases n with d`는 목표를 두 개로 나눕니다.\n하나에서는 `n`이 `0`으로 바뀌고, 다른 하나에서는 `n`이 `succ d`로\n바뀝니다. 이는 모든 자연수가 `0`이거나 어떤 자연수의 후속자라는\n수학적 사실에 해당합니다.\n\n## 예시\n\n`h : P ∨ Q`가 가정이라면 `cases h with hp hq`는 하나의 목표를\n두 개의 목표로 바꿉니다. 하나에는 가정 `hp : P`가 있고,\n다른 하나에는 가정 `hq : Q`가 있습니다.\n\n## 예시\n\n`h : False`가 가정이라면 `cases h`는 하나의 목표를 목표 0개로\n바꿉니다. `False`의 증명을 만드는 방법은 없기 때문입니다!\n목표가 하나도 남지 않았다면 레벨을 끝낸 것입니다.\n\n## 예시\n\n`h : a ≤ b`가 가정이라면 `cases h with c hc`는 새로운 수 `c`와\n증명 `hc : b = a + c`를 만듭니다. 이는 `a ≤ b`의 *정의*가\n`∃ c, b = a + c`이기 때문입니다.", "## Summary\n\nIf `n : ℕ` is an object, and the goal mentions `n`, then `induction n with d hd`\nattempts to prove the goal by induction on `n`, with the inductive\nvariable in the successor case being `d`, and the inductive hypothesis being `hd`.\n\n### Example:\nIf the goal is\n```\n0 + n = n\n```\n\nthen\n\n`induction n with d hd`\n\nwill turn it into two goals. The first is `0 + 0 = 0`;\nthe second has an assumption `hd : 0 + d = d` and goal\n`0 + succ d = succ d`.\n\nNote that you must prove the first\ngoal before you can access the second one.": - "## 요약\n\n`n : ℕ`가 object이고 goal에 `n`이 등장하면 `induction n with d hd`는 `n`에 대한 귀납법으로 goal을 증명하려 합니다. successor 경우의 귀납 변수는 `d`이고 귀납가정은 `hd`입니다.\n\n### 예시\n\ngoal이\n```\n0 + n = n\n```\n이라면\n\n`induction n with d hd`\n\n은 이를 두 goal로 바꿉니다. 첫 번째는 `0 + 0 = 0`이고, 두 번째는 가정 `hd : 0 + d = d`와 goal `n`0을 가집니다.\n\n두 번째 goal에 접근하려면 먼저 첫 번째 goal을 증명해야 한다는 점에 주의하세요.", + "## 요약\n\n`n : ℕ`가 객체이고 목표에 `n`이 등장하면 `induction n with d hd`는 `n`에 대한 귀납법으로 목표를 증명하려 합니다. `succ` 경우의 귀납 변수는 `d`이고 귀납가정은 `hd`입니다.\n\n### 예시\n\n목표가\n```\n0 + n = n\n```\n이라면\n\n`induction n with d hd`\n\n은 이를 두 목표로 바꿉니다. 첫 번째는 `0 + 0 = 0`이고, 두 번째는 가정 `hd : 0 + d = d`와 목표 `0 + succ d = succ d`입니다.\n\n두 번째 목표에 접근하려면 먼저 첫 번째 목표를 증명해야 한다는 점에 주의하세요.", "## Summary\n\nIf `h` is a proof of an equality `X = Y`, then `rw [h]` will change\nall `X`s in the goal to `Y`s. It's the way to \\\"substitute in\\\".\n\n## Variants\n\n* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\n\n* `rw [h1, h2]` (a sequence of rewrites)\n\n* `rw [h] at h2` (changes `X`s to `Y`s in hypothesis `h2`)\n\n* `rw [h] at h1 h2 ⊢` (changes `X`s to `Y`s in two hypotheses and the goal;\nget the `⊢` symbol with `\\|-`.)\n\n* `repeat rw [add_zero]` will keep changing `? + 0` to `?`\nuntil there are no more matches for `? + 0`.\n\n* `nth_rewrite 2 [h]` will change only the second `X` in the goal to `Y`.\n\n### Example:\n\nIf you have the assumption `h : x = y + y` and your goal is\n```\nsucc (x + 0) = succ (y + y)\n```\n\nthen\n\n`rw [add_zero]`\n\nwill change the goal into `succ x = succ (y + y)`, and then\n\n`rw [h]`\n\nwill change the goal into `succ (y + y) = succ (y + y)`, which\ncan be solved with `rfl`.\n\n### Example:\n\nYou can use `rw` to change a hypothesis as well.\nFor example, if you have two hypotheses\n```\nh1 : x = y + 3\nh2 : 2 * y = x\n```\nthen `rw [h1] at h2` will turn `h2` into `h2 : 2 * y = y + 3`.\n\n## Common errors\n\n* You need the square brackets. `rw h` is never correct.\n\n* If `h` is not a *proof* of an *equality* (a statement of the form `A = B`),\nfor example if `h` is a function or an implication,\nthen `rw` is not the tactic you want to use. For example,\n`rw [P = Q]` is never correct: `P = Q` is the theorem *statement*,\nnot the proof. If `h : P = Q` is the proof, then `rw [h]` will work.\n\n## Details\n\nThe `rw` tactic is a way to do \\\"substituting in\\\". There\nare two distinct situations where you can use this tactic.\n\n1) Basic usage: if `h : A = B` is an assumption or\nthe proof of a theorem, and if the goal contains one or more `A`s, then `rw [h]`\nwill change them all to `B`s. The tactic will error\nif there are no `A`s in the goal.\n\n2) Advanced usage: Assumptions coming from theorem proofs\noften have missing pieces. For example `add_zero`\nis a proof that `? + 0 = ?` because `add_zero` really is a function,\nand `?` is the input. In this situation `rw` will look through the goal\nfor any subterm of the form `x + 0`, and the moment it\nfinds one it fixes `?` to be `x` then changes all `x + 0`s to `x`s.\n\nExercise: think about why `rw [add_zero]` changes the term\n`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` to\n`0 + (x + 0) + 0 + (x + 0)`\n\nIf you can't remember the name of the proof of an equality, look it up in\nthe list of lemmas on the right.\n\n## Targeted usage\n\nIf your goal is `b + c + a = b + (a + c)` and you want to rewrite `a + c`\nto `c + a`, then `rw [add_comm]` will not work because Lean finds another\naddition first and swaps those inputs instead. Use `rw [add_comm a c]` to\nguarantee that Lean rewrites `a + c` to `c + a`. This works because\n`add_comm` is a proof that `?1 + ?2 = ?2 + ?1`, `add_comm a` is a proof\nthat `a + ? = ? + a`, and `add_comm a c` is a proof that `a + c = c + a`.\n\nIf `h : X = Y` then `rw [h]` will turn all `X`s into `Y`s.\nIf you only want to change the 37th occurrence of `X`\nto `Y` then do `nth_rewrite 37 [h]`.": "## Summary\n\nIf `h` is a proof of an equality `X = Y`, then `rw [h]` will change\nall `X`s in the goal to `Y`s. It's the way to \\\"substitute in\\\".\n\n## Variants\n\n* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\n\n* `rw [h1, h2]` (a sequence of rewrites)\n\n* `rw [h] at h2` (changes `X`s to `Y`s in hypothesis `h2`)\n\n* `rw [h] at h1 h2 ⊢` (changes `X`s to `Y`s in two hypotheses and the goal;\nget the `⊢` symbol with `\\|-`.)\n\n* `repeat rw [add_zero]` will keep changing `? + 0` to `?`\nuntil there are no more matches for `? + 0`.\n\n* `nth_rewrite 2 [h]` will change only the second `X` in the goal to `Y`.\n\n### Example:\n\nIf you have the assumption `h : x = y + y` and your goal is\n```\nsucc (x + 0) = succ (y + y)\n```\n\nthen\n\n`rw [add_zero]`\n\nwill change the goal into `succ x = succ (y + y)`, and then\n\n`rw [h]`\n\nwill change the goal into `succ (y + y) = succ (y + y)`, which\ncan be solved with `rfl`.\n\n### Example:\n\nYou can use `rw` to change a hypothesis as well.\nFor example, if you have two hypotheses\n```\nh1 : x = y + 3\nh2 : 2 * y = x\n```\nthen `rw [h1] at h2` will turn `h2` into `h2 : 2 * y = y + 3`.\n\n## Common errors\n\n* You need the square brackets. `rw h` is never correct.\n\n* If `h` is not a *proof* of an *equality* (a statement of the form `A = B`),\nfor example if `h` is a function or an implication,\nthen `rw` is not the tactic you want to use. For example,\n`rw [P = Q]` is never correct: `P = Q` is the theorem *statement*,\nnot the proof. If `h : P = Q` is the proof, then `rw [h]` will work.\n\n## Details\n\nThe `rw` tactic is a way to do \\\"substituting in\\\". There\nare two distinct situations where you can use this tactic.\n\n1) Basic usage: if `h : A = B` is an assumption or\nthe proof of a theorem, and if the goal contains one or more `A`s, then `rw [h]`\nwill change them all to `B`s. The tactic will error\nif there are no `A`s in the goal.\n\n2) Advanced usage: Assumptions coming from theorem proofs\noften have missing pieces. For example `add_zero`\nis a proof that `? + 0 = ?` because `add_zero` really is a function,\nand `?` is the input. In this situation `rw` will look through the goal\nfor any subterm of the form `x + 0`, and the moment it\nfinds one it fixes `?` to be `x` then changes all `x + 0`s to `x`s.\n\nExercise: think about why `rw [add_zero]` changes the term\n`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` to\n`0 + (x + 0) + 0 + (x + 0)`\n\nIf you can't remember the name of the proof of an equality, look it up in\nthe list of lemmas on the right.\n\n## Targeted usage\n\nIf your goal is `b + c + a = b + (a + c)` and you want to rewrite `a + c`\nto `c + a`, then `rw [add_comm]` will not work because Lean finds another\naddition first and swaps those inputs instead. Use `rw [add_comm a c]` to\nguarantee that Lean rewrites `a + c` to `c + a`. This works because\n`add_comm`는 `?1 + ?2 = ?2 + ?1`, `add_comm a` is a proof\nthat `a + ? = ? + a`, and `add_comm a c` is a proof that `a + c = c + a`.\n\nIf `h : X = Y` then `rw [h]` will turn all `X`s into `Y`s.\nIf you only want to change the 37th occurrence of `X`\nto `Y` then do `nth_rewrite 37 [h]`.의 증명입니다.", "## Summary\n\nIf `h : X = Y` and there are several `X`s in the goal, then\n`nth_rewrite 3 [h]` will just change the third `X` to a `Y`.\n\n## Example\n\nIf the goal is `2 + 2 = 4` then `nth_rewrite 2 [two_eq_succ_one]`\nwill change the goal to `2 + succ 1 = 4`. In contrast, `rw [two_eq_succ_one]`\nwill change the goal to `succ 1 + succ 1 = 4`.": - "## 요약\n\n`h : X = Y`이고 goal에 `X`이 여러 개 있다면 `nth_rewrite 3 [h]`는 세 번째 `X`만 `Y`로 바꿉니다.\n\n## 예시\n\ngoal이 `2 + 2 = 4`라면 `nth_rewrite 2 [two_eq_succ_one]`은 goal을 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 goal을 `succ 1 + succ 1 = 4`로 바꿉니다.", + "## 요약\n\n`h : X = Y`이고 목표에 `X`이 여러 개 있다면 `nth_rewrite 3 [h]`는 세 번째 `X`만 `Y`로 바꿉니다.\n\n## 예시\n\n목표가 `2 + 2 = 4`라면 `nth_rewrite 2 [two_eq_succ_one]`은 목표를 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 목표를 `succ 1 + succ 1 = 4`로 바꿉니다.", "## Precision rewriting\n\nIn the last level, there was `b + 0` and `c + 0`,\nand `rw [add_zero]` changed the first one it saw,\nwhich was `b + 0`. Let's learn how to tell Lean\nto change `c + 0` first by giving `add_zero` an\nexplicit input.": - "## 정밀한 rewriting\n\n지난 level에는 `b + 0`와 `c + 0`이 있었고, `rw [add_zero]`는 처음 발견한 `b + 0`을 바꿨습니다. 이제 `add_zero`에 입력을 명시해서 Lean에게 `c + 0`를 먼저 바꾸라고 지시하는 법을 배워 봅시다.", + "## 정밀한 rewriting\n\n지난 레벨에는 `b + 0`와 `c + 0`이 있었고, `rw [add_zero]`는 처음 발견한 `b + 0`을 바꿨습니다. 이제 `add_zero`에 입력을 명시해서 Lean에게 `c + 0`를 먼저 바꾸라고 지시하는 법을 배워 봅시다.", "# Welcome to the Natural Number Game\n#### An introduction to mathematical proof.\n\nIn this game, we will build the basic theory of the natural\nnumbers `{0,1,2,3,4,...}` from scratch. Our first goal is to prove\nthat `2 + 2 = 4`. Next we'll prove that `x + y = y + x`.\nAnd at the end we'll see if we can prove Fermat's Last Theorem.\nWe'll do this by solving levels of a computer puzzle game called Lean.\n\n# Read this.\n\nLearning how to use an interactive theorem prover takes time.\nTests show that the people who get the most out of this game are\nthose who read the help texts like this one.\n\nTo start, click on \"Tutorial World\".\n\nNote: this is a new Lean 4 version of the game containing several\nworlds which were not present in the old Lean 3 version. More new worlds\nsuch as Strong Induction World, Even/Odd World and Prime Number World\nare in development; if you want to see their state or even help out, checkout\nout the [issues in the github repo](https://github.com/leanprover-community/NNG4/issues).\n\n## More\n\nClick on the three lines in the top right and select \"Game Info\" for resources,\nlinks, and ways to interact with the Lean community.": - "# 자연수 게임에 오신 것을 환영합니다\n#### 수학적 증명 입문\n\n이 게임에서는 자연수 `{0,1,2,3,4,...}`의 기본 이론을 기초부터 만들어 갑니다. 첫 목표는 `2 + 2 = 4`을 증명하는 것입니다. 다음으로는 `x + y = y + x`를 증명합니다. 마지막에는 페르마의 마지막 정리를 증명할 수 있는지 보겠습니다. Lean이라는 컴퓨터 퍼즐 게임의 level들을 풀면서 진행합니다.\n\n# 일러두기\n\n대화형 정리 증명기를 사용하는 법을 익히는 데에는 시간이 걸립니다. 테스트 결과 이 게임을 가장 잘 활용하는 사람들은 이런 도움말을 꼼꼼히 읽는 사람들이었습니다.\n\n시작하려면 “튜토리얼 세계”를 클릭하세요.\n\n참고: 이것은 새로운 Lean 4 버전으로, 예전 Lean 3 버전에는 없던 여러 월드가 포함되어 있습니다. 강한 귀납법 월드, 홀짝 월드, 소수 월드 같은 새로운 월드도 개발 중입니다. 진행 상황을 보거나 직접 돕고 싶다면 [GitHub repo의 issues](https://github.com/leanprover-community/NNG4/issues)를 확인하세요.\n\n## 더 보기\n\n오른쪽 위의 세 줄 메뉴를 누르고 \"게임 정보\"를 선택하면 자료, 링크, Lean 커뮤니티와 소통하는 방법을 볼 수 있습니다.", + "# 자연수 게임에 오신 것을 환영합니다\n#### 수학적 증명 입문\n\n이 게임에서는 자연수 `{0,1,2,3,4,...}`의 기본 이론을 기초부터 만들어 갑니다. 첫 목표는 `2 + 2 = 4`을 증명하는 것입니다. 다음으로는 `x + y = y + x`를 증명합니다. 마지막에는 페르마의 마지막 정리를 증명할 수 있는지 보겠습니다. Lean이라는 컴퓨터 퍼즐 게임의 레벨들을 풀면서 진행합니다.\n\n# 일러두기\n\n대화형 정리 증명기를 사용하는 법을 익히는 데에는 시간이 걸립니다. 테스트 결과 이 게임을 가장 잘 활용하는 사람들은 이런 도움말을 꼼꼼히 읽는 사람들이었습니다.\n\n시작하려면 “튜토리얼 월드”를 클릭하세요.\n\n참고: 이것은 새로운 Lean 4 버전으로, 예전 Lean 3 버전에는 없던 여러 월드가 포함되어 있습니다. 강한 귀납법 월드, 홀짝 월드, 소수 월드 같은 새로운 월드도 개발 중입니다. 진행 상황을 보거나 직접 돕고 싶다면 [GitHub repo의 issues](https://github.com/leanprover-community/NNG4/issues)를 확인하세요.\n\n## 더 보기\n\n오른쪽 위의 세 줄 메뉴를 누르고 \"게임 정보\"를 선택하면 자료, 링크, Lean 커뮤니티와 소통하는 방법을 볼 수 있습니다.", "# Summary\nThe `right` tactic changes a goal of `P ∨ Q` into a goal of `Q`.\nUse it when your hypotheses guarantee that the reason that `P ∨ Q`\nis true is because in fact `Q` is true.\n\nInternally this tactic is just `apply`ing a theorem\nsaying that $Q \\implies P \\lor Q.$\n\nNote that this tactic can turn a solvable goal into an unsolvable\none.": - "# 요약\n`right` tactic은 `P ∨ Q`이라는 goal을 `Q`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `Q`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n\n내부적으로 이 tactic은 $Q \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n\n이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요.", + "# 요약\n`right` 택틱은 `P ∨ Q`이라는 목표를 `Q`라는 목표로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `Q`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n\n내부적으로 이 택틱은 $Q \\implies P \\lor Q$이라는 정리를 `apply`하는 것뿐입니다.\n\n이 택틱은 풀 수 있는 목표를 풀 수 없는 목표로 바꿀 수도 있다는 점에 주의하세요.", "# Summary\nThe `left` tactic changes a goal of `P ∨ Q` into a goal of `P`.\nUse it when your hypotheses guarantee that the reason that `P ∨ Q`\nis true is because in fact `P` is true.\n\nInternally this tactic is just `apply`ing a theorem\nsaying that $P \\implies P \\lor Q.$\n\nNote that this tactic can turn a solvable goal into an unsolvable\none.": - "# 요약\n`left` tactic은 `P ∨ Q`이라는 goal을 `P`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `P`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n\n내부적으로 이 tactic은 $P \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n\n이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요.", + "# 요약\n`left` 택틱은 `P ∨ Q`이라는 목표를 `P`라는 목표로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `P`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n\n내부적으로 이 택틱은 $P \\implies P \\lor Q$이라는 정리를 `apply`하는 것뿐입니다.\n\n이 택틱은 풀 수 있는 목표를 풀 수 없는 목표로 바꿀 수도 있다는 점에 주의하세요.", "# Summary\n\n`trivial` will solve the goal `True`.": - "# 요약\n\n`trivial`는 goal `True`을 해결합니다.", + "# 요약\n\n`trivial`는 목표 `True`을 해결합니다.", "# Summary\n\n`decide` will attempt to solve a goal if it can find an algorithm which it\ncan run to solve it.\n\n## Example\n\nA term of type `DecidableEq ℕ` is an algorithm to decide whether two naturals\nare equal or different. Hence, once this term is made and made into an `instance`,\nthe `decide` tactic can use it to solve goals of the form `a = b` or `a ≠ b`.": - "# 요약\n\n`decide`는 실행 가능한 알고리즘을 찾을 수 있다면 그 알고리즘으로 goal을 해결하려 시도합니다.\n\n## 예시\n\n`DecidableEq ℕ` 타입의 항은 두 자연수가 같은지 다른지를 판정하는 알고리즘입니다. 따라서 이 항을 만들고 `instance`로 등록하면 `decide` tactic이 `a = b`나 `a ≠ b` 꼴의 goal을 해결하는 데 사용할 수 있습니다.", + "# 요약\n\n`decide`는 실행 가능한 알고리즘을 찾을 수 있다면 그 알고리즘으로 목표를 해결하려 시도합니다.\n\n## 예시\n\n`DecidableEq ℕ` 타입의 항은 두 자연수가 같은지 다른지를 판정하는 알고리즘입니다. 따라서 이 항을 만들고 `instance`로 등록하면 `decide` 택틱이 `a = b`나 `a ≠ b` 꼴의 목표를 해결하는 데 사용할 수 있습니다.", "# Summary\n\nThe `tauto` tactic will solve any goal which can be solved purely by logic (that is, by\ntruth tables).\n\n## Details\n\n`tauto` *does not do magic*! It doesn't know *anything* about addition or multiplication,\nit doesn't even know `add_zero`. The only things that `tauto` knows about numbers\nare firstly that `a = a` and secondly that `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` and so on.\nWhat `tauto`'s strength is, is *logic*. If you have a hypothesis `x < 37`\nand another hypothesis `x < 37 → y + z = 42` and your goal is `y + z = 42` then `tauto` will\nsolve this goal, because to solve that goal you don't need to know any facts\nabout inequalities or addition, all you need to know is the rules of logic.\n\n## Example\n\nIf you have `False` as a hypothesis, then `tauto` will solve\nthe goal. This is because a false hypothesis implies any hypothesis.\n\n## Example\n\nIf your goal is `True`, then `tauto` will solve the goal.\n\n## Example\n\nIf you have two hypotheses `h1 : a = 37` and `h2 : a ≠ 37` then `tauto` will\nsolve the goal because it can prove `False` from your hypotheses, and thus\nprove the goal (as `False` implies anything).\n\n## Example\n\nIf you have one hypothesis `h : a ≠ a` then `tauto` will solve the goal because\n`tauto` is smart enough to know that `a = a` is true, which gives the contradiction we seek.\n\n## Example\n\nIf you have a hypothesis `h : 0 = 1` then `tauto` will solve the goal, because\n`tauto` knows `0 ≠ 1` and this is enough to prove `False`, which implies any goal.\n\n## Example\n\nIf you have a hypothesis of the form `a = 0 → a * b = 0` and your goal is `a * b ≠ 0 → a ≠ 0`, then\n`tauto` will solve the goal, because the goal is logically equivalent to the hypothesis.\nIf you switch the goal and hypothesis in this example, `tauto` would solve it too.": - "# 요약\n\n`tauto` tactic은 순수하게 논리만으로(즉 진리표만으로) 해결할 수 있는 모든 goal을 해결합니다.\n\n## 자세한 설명\n\n`tauto`은 *마법을 쓰지 않습니다*! 덧셈이나 곱셈에 대해서는 *아무것도* 모르고, `add_zero`조차 모릅니다. `tauto`이 수에 대해 아는 것은 첫째 `a = a`이고, 둘째 `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` 등이 있다는 것뿐입니다. `tauto`의 강점은 *논리*입니다. 가정 `x < 37`와 가정 `tauto`0이 있고 goal이 `tauto`1이라면 `tauto`2가 해결합니다. 부등식이나 덧셈에 관한 사실은 하나도 필요 없고 논리의 규칙만 알면 되기 때문입니다.\n\n## 예시\n\n가정 `tauto`3이 있으면 `tauto`4가 goal을 해결합니다. 거짓 가정에서는 어떤 명제든 따라오기 때문입니다.\n\n## 예시\n\ngoal이 `tauto`5라면 `tauto`6이 해결합니다.\n\n## 예시\n\n가정 `tauto`7과 `tauto`8이 있으면 `tauto`9가 goal을 해결합니다. 두 가정에서 `add_zero`0을 증명할 수 있고, `add_zero`1은 무엇이든 함의하기 때문입니다.\n\n## 예시\n\n가정 `add_zero`2 하나만 있어도 `add_zero`3이 goal을 해결합니다. `add_zero`4는 `add_zero`5가 참이라는 것을 알아내 모순을 얻을 수 있을 만큼 영리합니다.\n\n## 예시\n\n가정 `add_zero`6이 있으면 `add_zero`7이 goal을 해결합니다. `add_zero`8은 `add_zero`9를 알고 있고 이것으로 `tauto`0을 증명할 수 있으며, `tauto`0에서는 어떤 goal이든 따라옵니다.\n\n## 예시\n\n`tauto`1 꼴의 가정이 있고 goal이 `tauto`2라면 `tauto`3이 해결합니다. goal이 가정과 논리적으로 동치이기 때문입니다. 이 예시에서 goal과 가정을 뒤바꿔도 `tauto`4가 해결합니다.", + "# 요약\n\n`tauto` 택틱은 순수하게 논리만으로, 즉 진리표만으로 해결할 수 있는\n모든 목표를 해결합니다.\n\n## 자세한 설명\n\n`tauto`는 *마법을 쓰지 않습니다*! 덧셈이나 곱셈에 대해서는 *아무것도*\n모르며, 심지어 `add_zero`도 모릅니다. `tauto`가 수에 대해 아는 것은\n첫째로 `a = a`라는 것과, 둘째로 `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` 등이\n성립한다는 것뿐입니다. `tauto`의 강점은 *논리*입니다. 가정 `x < 37`과\n또 다른 가정 `x < 37 → y + z = 42`가 있고 목표가 `y + z = 42`라면,\n`tauto`는 이 목표를 해결합니다. 이 목표를 해결하는 데에는 부등식이나\n덧셈에 관한 어떤 사실도 필요하지 않고, 논리의 규칙만 알면 되기 때문입니다.\n\n## 예시\n\n가정으로 `False`가 주어져 있다면 `tauto`는 목표를 해결합니다.\n거짓인 가정으로부터는 어떤 명제든 따라오기 때문입니다.\n\n## 예시\n\n목표가 `True`라면 `tauto`는 목표를 해결합니다.\n\n## 예시\n\n두 가정 `h1 : a = 37`과 `h2 : a ≠ 37`이 있다면 `tauto`는\n목표를 해결합니다. 이 가정들로부터 `False`를 증명할 수 있고,\n`False`에서는 무엇이든 따라오므로 목표도 증명할 수 있기 때문입니다.\n\n## 예시\n\n가정 `h : a ≠ a`가 하나 있다면 `tauto`는 목표를 해결합니다.\n`tauto`는 `a = a`가 참이라는 것을 알 만큼 영리하므로, 여기서 필요한\n모순을 얻을 수 있기 때문입니다.\n\n## 예시\n\n가정 `h : 0 = 1`이 있다면 `tauto`는 목표를 해결합니다.\n`tauto`는 `0 ≠ 1`을 알고 있으므로 `False`를 증명할 수 있고,\n`False`에서는 어떤 목표든 따라오기 때문입니다.\n\n## 예시\n\n`a = 0 → a * b = 0` 꼴의 가정이 있고 목표가 `a * b ≠ 0 → a ≠ 0`이라면,\n`tauto`는 목표를 해결합니다. 목표가 가정과 논리적으로 동치이기 때문입니다.\n이 예시에서 목표와 가정을 서로 뒤바꾸어도 `tauto`는 해결할 수 있습니다.", "# Summary\n\nThe `have` tactic can be used to add new hypotheses to a level, but of course\nyou have to prove them.\n\n\n## Example\n\nThe simplest usage is like this. If you have `a` in your context and you execute\n\n`have ha : a = 0`\n\nthen you will get a new goal `a = 0` to prove, and after you've proved\nit you will have a new hypothesis `ha : a = 0` in your original goal.\n\n## Example\n\nIf you already have a proof of what you want to `have`, you\ncan just create it immediately. For example, if you have `a` and `b`\nnumber objects, then\n\n`have h2 : succ a = succ b → a = b := succ_inj a b`\n\nwill directly add a new hypothesis `h2 : succ a = succ b → a = b`\nto the context, because you just supplied the proof of it (`succ_inj a b`).\n\n## Example\n\nIf you have a proof to hand, then you don't even need to state what you\nare proving. For example\n\n`have h2 := succ_inj a b`\n\nwill add `h2 : succ a = succ b → a = b` as a hypothesis.": - "# 요약\n\n`have` tactic을 사용하면 level에 새로운 가정을 추가할 수 있습니다. 물론 그 가정도 직접 증명해야 합니다.\n\n## 예시\n\n가장 간단한 사용법은 다음과 같습니다. context에 `a`이 있을 때\n\n`have ha : a = 0`\n\n를 실행하면 새로운 목표 `a = 0`이 생깁니다. 이를 증명하고 나면 원래 목표에 새로운 가정 `ha : a = 0`가 추가됩니다.\n\n## 예시\n\n`have`하고 싶은 명제의 증명을 이미 가지고 있다면 바로 만들 수도 있습니다. 예를 들어 `a`와 `b`이 number object라면\n\n`have h2 : succ a = succ b → a = b := succ_inj a b`\n\n을 실행하면 context에 새로운 가정 `h2 : succ a = succ b → a = b`가 바로 추가됩니다. 그 증명 `a`0을 직접 제공했기 때문입니다.\n\n## 예시\n\n이미 증명을 가지고 있다면 무엇을 증명하는지 굳이 명시할 필요도 없습니다. 예를 들어\n\n`a`1\n\n은 `a`2를 가정으로 추가합니다.", + "# 요약\n\n`have` 택틱을 사용하면 레벨에 새로운 가정을 추가할 수 있습니다. 물론 그 가정도 직접 증명해야 합니다.\n\n## 예시\n\n가장 간단한 사용법은 다음과 같습니다. context에 `a`이 있을 때\n\n`have ha : a = 0`\n\n를 실행하면 새로운 목표 `a = 0`이 생깁니다. 이를 증명하고 나면 원래 목표에 새로운 가정 `ha : a = 0`가 추가됩니다.\n\n## 예시\n\n`have`하고 싶은 명제의 증명을 이미 가지고 있다면 바로 만들 수도 있습니다. 예를 들어 `a`와 `b`이 수 객체라면\n\n`have h2 : succ a = succ b → a = b := succ_inj a b`\n\n을 실행하면 context에 새로운 가정 `h2 : succ a = succ b → a = b`가 바로 추가됩니다. 그 증명 `succ_inj a b`을 직접 제공했기 때문입니다.\n\n## 예시\n\n이미 증명을 가지고 있다면 무엇을 증명하는지 굳이 명시할 필요도 없습니다. 예를 들어\n\n`have h2 := succ_inj a b`\n\n은 `h2 : succ a = succ b → a = b`를 가정으로 추가합니다.", "# Summary\n\nIf you have a hypothesis\n\n§0\n\nand goal\n\n§1\n\nthen §2 replaces the set-up with its so-called \\\\\"contrapositive\\\\\":\na hypothesis\n\n§3\n\nand goal\n\n§4.": - "# 요약\n\n가정이\n\n§0\n\n이고 goal이\n\n§1\n\n이라면 §2는 이를 이른바 \"대우\"로 바꿉니다. 즉 가정\n\n§3\n\n과 goal\n\n§4\n\n로 바꿉니다.", + "# 요약\n\n가정이\n\n§0\n\n이고 목표가\n\n§1\n\n이라면 §2는 이를 이른바 \\\\\"대우\\\\\"로 바꿉니다. 즉 가정\n\n§3\n\n과 목표\n\n§4\n\n로 바꿉니다.", "# Summary\n\nIf you have a hypothesis\n\n`h : a ≠ b`\n\nand goal\n\n`c ≠ d`\n\nthen `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\na hypothesis\n\n`h : c = d`\n\nand goal\n\n`a = b`.": - "# Summary\n\nIf you have a hypothesis\n\n`h : a ≠ b`\n\nand goal\n\n`c ≠ d`\n\nthen `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\na hypothesis\n\n`h : c = d`\n\nand goal\n\n`a = b`.", + "# 요약\n\n다음과 같은 가정\n\n`h : a ≠ b`\n\n과 목표\n\n`c ≠ d`\n\n가 있다고 합시다. 그러면 `contrapose! h`는 현재 상황을 이른바 \\\"대우\\\"로 바꿉니다. 즉,\n가정은\n\n`h : c = d`\n\n가 되고, 목표는\n\n`a = b`\n\n가 됩니다.", "# Statement\n\nIf $a$ and $b$ are numbers, then\n`succ_inj a b` is the proof that\n$ (\\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n\n## More technical details\n\nThere are other ways to think about `succ_inj`.\n\nYou can think about `succ_inj` itself as a function which takes two\nnumbers $$a$$ and $$b$$ as input, and outputs a proof of\n$ ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n\nYou can think of `succ_inj` itself as a proof; it is the proof\nthat `succ` is an injective function. In other words,\n`succ_inj` is a proof of\n$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n\n`succ_inj` was postulated as an axiom by Peano, but\nin Lean it can be proved using `pred`, a mathematically\npathological function.": "# 진술\n\n$a$와 $b$가 수이면\n`succ_inj a b`는\n$ (\\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$의 증명입니다.\n\n## 까다로운 세부사항\n\n사실 `succ_inj`에 대해 여러 다른 방법으로 생각할 수도 있습니다.\n\n`succ_inj` 자체를 함수로 보아 두 수 $$a$$와 $$b$$를 입력으로 받고,\n출력으로는 $ ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$의\n증명을 내놓는 함수로 생각할 수 있습니다.\n\n`succ_inj` 자체를 증명으로 보아 `succ`이 단사함수라는 증명으로 생각할 수 있습니다.\n즉 `succ_inj`은\n$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$\n의 증명이 됩니다.\n\n`succ_inj`는 페아노에 의해 공리로 세워졌으나,\niLean에서는 수학적으로 병적인 함수 `pred`에 의해 증명될 수있습니다.", "# Read this first\n\nEach level in this game involves proving a mathematical theorem (the \"Goal\").\nThe goal will be a statement about *numbers*. Some numbers in this game have known values.\nThose numbers have names like $37$. Other numbers will be secret. They're called things\nlike $x$ and $q$. We know $x$ is a number, we just don't know which one.\n\nIn this first level we're going to prove the theorem that $37x + q = 37x + q$.\nYou can see `x q : ℕ` in the *Objects* below, which means that `x` and `q`\nare numbers.\n\nWe solve goals in Lean using *Tactics*, and the first tactic we're\ngoing to learn is called `rfl`, which proves all theorems of the form $X = X$.\n\nProve that $37x+q=37x+q$ by executing the `rfl` tactic.": - "# 먼저 읽어 주세요\n\n이 게임의 각 level에서는 하나의 수학 정리(\"Goal\")를 증명합니다. goal은 *수*에 관한 명제입니다. 이 게임의 어떤 수들은 값이 알려져 있습니다. 그런 수에는 $37$ 같은 이름이 붙습니다. 다른 수들의 값은 비밀이며 $x$, $q$ 같은 이름으로 불립니다. $x$이 수라는 것은 알지만 정확히 어떤 수인지는 모릅니다.\n\n첫 level에서는 $37x + q = 37x + q$라는 정리를 증명합니다. 아래 *Objects*에 `x q : ℕ`가 보일 텐데, 이는 `x`와 `q`이 수라는 뜻입니다.\n\nLean에서는 *Tactics*를 이용해 goal을 해결합니다. 처음 배울 tactic은 `rfl`이며, $X = X$ 꼴의 모든 정리를 증명합니다.\n\n$x$1 tactic을 실행해 $x$0을 증명하세요.", + "# 일러두기\n\n이 게임의 각 레벨에서는 하나의 수학 정리(\"목표\")를 증명합니다. 목표는 *수*에 관한 명제입니다. 이 게임의 어떤 수들은 값이 알려져 있습니다. 그런 수에는 $37$ 같은 이름이 붙습니다. 다른 수들의 값은 비밀이며 $x$, $q$ 같은 이름으로 불립니다. $x$이 수라는 것은 알지만 정확히 어떤 수인지는 모릅니다.\n\n첫 레벨에서는 $37x + q = 37x + q$라는 정리를 증명합니다. 아래 *객체*에 `x q : ℕ`가 보일 텐데, 이는 `x`와 `q`이 수라는 뜻입니다.\n\nLean에서는 *택틱*를 이용해 목표를 해결합니다. 처음 배울 택틱은 `rfl`이며, $X = X$ 꼴의 모든 정리를 증명합니다.\n\n`rfl` 택틱을 실행해 $37x+q=37x+q$를 증명하세요.", "# Overview\n\nOur home-made tactic `simp_add` will solve arbitrary goals of\nthe form `a + (b + c) + (d + e) = e + (d + (c + b)) + a`.": - "# 개요\n\n직접 만든 tactic `simp_add`는 `a + (b + c) + (d + e) = e + (d + (c + b)) + a` 꼴의 임의의 goal을 해결합니다.", + "# 개요\n\n직접 만든 택틱 `simp_add`는 `a + (b + c) + (d + e) = e + (d + (c + b)) + a` 꼴의 임의의 목표를 해결합니다.", "# Overview\n\nLean's simplifier, `simp`, will rewrite every lemma\ntagged with `simp` and every lemma fed to it by the user, as much as it can.\nFurthermore, it will attempt to order variables into an internal order if fed\nlemmas such as `add_comm`, so that it does not go into an infinite loop.": - "# 개요\n\nLean의 simplifier `simp`는 `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다. 또 `add_comm` 같은 lemma를 주면 무한 루프를 피하기 위해 변수들을 내부적인 순서에 맞춰 정렬하려고 합니다."} \ No newline at end of file + "# 개요\n\nLean의 simplifier `simp`는 `simp` 태그가 붙은 모든 정리와 사용자가 넣어 준 모든 정리를 가능한 한 계속 rewrite합니다. 또 `add_comm` 같은 정리를 주면 무한 루프를 피하기 위해 변수들을 내부적인 순서에 맞춰 정렬하려고 합니다."} \ No newline at end of file diff --git a/.i18n/ko/Game.po b/.i18n/ko/Game.po index 0e0d7619..864436f7 100644 --- a/.i18n/ko/Game.po +++ b/.i18n/ko/Game.po @@ -103,9 +103,10 @@ msgid "" "after $0$ again, this time by changing `succ (succ 0)`\n" "into `2`." msgstr "" -"`h`가 `X = Y`의 증명이라면 `rw [h]`는 `X`을 `Y`로 바꿉니다. 그렇다면 반대로 `Y`를 `X`으로 바꾸고 싶을 때는 어떻게 해야 할까요? `rw` tactic에 이 방향으로 바꾸라고 알려 주려면 왼쪽 화살표 `←`를 사용합니다. `\\l`를 입력한 뒤 스페이스바를 누르면 이 화살표가 입력됩니다.\n" +"`h`가 `X = Y`의 증명이라면 `rw [h]`는 `X`을 `Y`로 바꿉니다. 그렇다면 반대로 `Y`를 `X`으로 바꾸고\n" +"싶을 때는 어떻게 해야 할까요? `rw` 택틱에 이 방향으로 바꾸라고 알려 주려면 왼쪽 화살표 `←`를 사용합니다. `\\l`를 입력한 뒤 스페이스바를 누르면 이 화살표가 입력됩니다.\n" "\n" -"이번에는 `X = Y`2를 `X = Y`3으로 바꾸는 방법으로, `X = Y`0이 `X = Y`1의 다음 수의 다음 수라는 사실을 다시 증명해 봅시다." +"이번에는 `succ (succ 0)`을 `2`로 바꾸는 방법으로, $2$가 $0$의 다음 수의 다음 수라는 사실을 다시 증명해 봅시다." #: Game.Levels.AdvMultiplication.L06mul_right_eq_one msgid "" @@ -146,7 +147,7 @@ msgid "" msgstr "" "# 요약\n" "\n" -"`have` tactic을 사용하면 level에 새로운 가정을 추가할 수 있습니다. 물론 그 가정도 직접 증명해야 합니다.\n" +"`have` 택틱을 사용하면 레벨에 새로운 가정을 추가할 수 있습니다. 물론 그 가정도 직접 증명해야 합니다.\n" "\n" "## 예시\n" "\n" @@ -158,19 +159,19 @@ msgstr "" "\n" "## 예시\n" "\n" -"`have`하고 싶은 명제의 증명을 이미 가지고 있다면 바로 만들 수도 있습니다. 예를 들어 `a`와 `b`이 number object라면\n" +"`have`하고 싶은 명제의 증명을 이미 가지고 있다면 바로 만들 수도 있습니다. 예를 들어 `a`와 `b`이 수 객체라면\n" "\n" "`have h2 : succ a = succ b → a = b := succ_inj a b`\n" "\n" -"을 실행하면 context에 새로운 가정 `h2 : succ a = succ b → a = b`가 바로 추가됩니다. 그 증명 `a`0을 직접 제공했기 때문입니다.\n" +"을 실행하면 context에 새로운 가정 `h2 : succ a = succ b → a = b`가 바로 추가됩니다. 그 증명 `succ_inj a b`을 직접 제공했기 때문입니다.\n" "\n" "## 예시\n" "\n" "이미 증명을 가지고 있다면 무엇을 증명하는지 굳이 명시할 필요도 없습니다. 예를 들어\n" "\n" -"`a`1\n" +"`have h2 := succ_inj a b`\n" "\n" -"은 `a`2를 가정으로 추가합니다." +"은 `h2 : succ a = succ b → a = b`를 가정으로 추가합니다." #: Game.Levels.Addition.L04add_assoc msgid "" @@ -191,7 +192,7 @@ msgstr "먼저 `1`을 풀어 써 보세요." #: Game.Levels.Tutorial.L02rw msgid "the rw tactic" -msgstr "rw tactic" +msgstr "rw 택틱" #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -218,11 +219,11 @@ msgid "" "Let's learn some basic tactics. Click on \"Start\" below\n" "to begin your quest." msgstr "" -"Tutorial World에 오신 것을 환영합니다! 이 world에서는 정리를 증명하는 기초를 배웁니다. 이 world의 boss level은 정리 `2 + 2 = 4`입니다.\n" +"튜토리얼 월드에 오신 것을 환영합니다! 이 월드에서는 정리를 증명하는 기초를 배웁니다. 이 월드의 보스 레벨은 정리 `2 + 2 = 4`입니다.\n" "\n" -"정리는 *tactic*이라는 도구를 이용해 퍼즐을 풀듯 증명합니다. tactic들을 올바른 순서로 적용해 정리를 증명하는 것이 목표입니다.\n" +"정리는 *택틱*이라는 도구를 이용해 퍼즐을 풀듯 증명합니다. 택틱들을 올바른 순서로 적용해 정리를 증명하는 것이 목표입니다.\n" "\n" -"기본적인 tactic 몇 가지를 배워 봅시다. 아래의 \"Start\"를 눌러 여정을 시작하세요." +"기본적인 택틱 몇 가지를 배워 봅시다. 아래의 \"시작하기\"를 눌러 여정을 시작하세요." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -248,7 +249,7 @@ msgstr "`x ≠ y`는 `x = y → False`을 나타내는 *표기법*이라는 점 msgid "" "This level proves that if `a * b = 0` then `a = 0` or `b = 0`. It is\n" "logically equivalent to the last level, so there is a very short proof." -msgstr "이 level에서는 `a * b = 0`이면 `a = 0` 또는 `b = 0`라는 것을 증명합니다. 이전 level과 논리적으로 동치이므로 아주 짧은 증명이 있습니다." +msgstr "이 레벨에서는 `a * b = 0`이면 `a = 0` 또는 `b = 0`라는 것을 증명합니다. 이전 레벨과 논리적으로 동치이므로 아주 짧은 증명이 있습니다." #: Game.Levels.Addition.L01zero_add msgid "" @@ -270,17 +271,17 @@ msgid "" "(By the way, if you are still in the \"Editor mode\" from the last world, you can swap\n" "back to \"Typewriter mode\" by clicking the `>_` button in the top right.)" msgstr "" -"이 level에서는 $0+n=n$를 증명합니다. 여기서 $n$은 값이 공개되지 않은 자연수입니다.\n" +"이 레벨에서는 $0+n=n$를 증명합니다. 여기서 $n$은 값이 공개되지 않은 자연수입니다.\n" "\n" "잠깐, 이건 이미 아는 것 아닌가요? 아닙니다! 우리가 아는 것은 $n+0=n$인데, 그건 `add_zero`입니다. 지금 필요한 것은 `zero_add`이고, 둘은 다릅니다.\n" "\n" -"`0 + n = n`를 증명하기 어려운 이유는 일반적인 `0 + n`에 대한 *공식*이 없기 때문입니다. `n`가 $n$0인지 successor인지 알아야만 `add_zero`과 `add_succ`을 사용할 수 있습니다. $n$1 tactic은 이 두 경우로 나눠 줍니다.\n" +"`0 + n = n`를 증명하기 어려운 이유는 일반적인 `0 + n`에 대한 *공식*이 없기 때문입니다. `n`가 `0`인지 다음수인지 알아야만 `add_zero`과 `add_succ`을 사용할 수 있습니다. `induction` 택틱은 이 두 경우로 나눠 줍니다.\n" "\n" -"기저 경우에서는 $n$2를 증명해야 하고, 귀납 단계에서는 $n$3이면 $n$4임을 보이라는 목표가 생깁니다. 수를 만드는 방법은 $n$5와 successor뿐이므로 이것으로 모든 경우를 다룹니다.\n" +"기저 단계에서는 `0 + 0 = 0`를 증명해야 하고, 귀납 단계에서는 `0 + d = d`이면 `0 + succ d = succ d`임을 보이라는 목표가 생깁니다. 수를 만드는 방법은 `0`와 다음수뿐이므로 이것으로 모든 수에 대한 증명이 끝납니다.\n" "\n" "Lean에서 첫 귀납 증명을 해 보세요.\n" "\n" -"(참고로 이전 world에서 아직 \"Editor mode\"에 있다면, 오른쪽 위의 $n$6 버튼을 눌러 \"Typewriter mode\"로 돌아갈 수 있습니다.)" +"(참고로 이전 월드에서 아직 \"편집기 모드\"에 있다면, 오른쪽 위의 $n$6 버튼을 눌러 \"타자기 모드\"로 돌아갈 수 있습니다.)" #: Game.Levels.LessOrEqual.L11le_two msgid "" @@ -290,7 +291,7 @@ msgid "" "`x = 0 ∨ x = 1 ∨ x = 2` actually means `x = 0 ∨ (x = 1 ∨ x = 2)`.\n" "This affects how `left` and `right` work." msgstr "" -"2가 소수라는 것을 증명하려면 이 lemma가 필요합니다!\n" +"2가 소수라는 것을 증명하려면 이 정리가 필요합니다!\n" "\n" "`∨`가 오른쪽 결합이라는 점을 알아야 합니다. 즉 `x = 0 ∨ x = 1 ∨ x = 2`은 실제로 `x = 0 ∨ (x = 1 ∨ x = 2)`를 뜻합니다. 이 때문에 `left`과 `right`의 작동 방식도 달라집니다." @@ -329,7 +330,7 @@ msgstr "" #: Game.Levels.Power.L05pow_two msgid "Note: this lemma will be useful for the final boss!" -msgstr "참고: 이 lemma는 final boss에서 유용합니다!" +msgstr "참고: 이 정리는 최종 보스에서 유용합니다!" #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -339,7 +340,7 @@ msgstr "intro" #: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero msgid "Use the previous lemma with `apply eq_succ_of_ne_zero at ha`." -msgstr "이전 lemma를 `apply eq_succ_of_ne_zero at ha`와 함께 사용하세요." +msgstr "이전 정리를 `apply eq_succ_of_ne_zero at ha`와 함께 사용하세요." #: Game.Levels.Multiplication.L09mul_assoc msgid "" @@ -350,14 +351,14 @@ msgid "" msgstr "" "지나가던 수학자가 자연수들이 가환 반환을 이룬다는 것을 증명했다고 알려 줍니다.\n" "\n" -"final boss를 향한 여정을 시작하려면 Power World로 가세요." +"최종 보스를 향한 여정을 시작하려면 지수 월드로 가세요." #: Game.Levels.Power.L08pow_pow msgid "" "One of the best named levels in the game, a savage `pow_pow`\n" "sub-boss appears as the music reaches a frenzy. What\n" "else could there be to prove about powers after this?" -msgstr "게임에서 이름이 가장 멋진 level 중 하나입니다. 음악이 절정으로 치닫는 가운데 흉악한 `pow_pow` sub-boss가 나타납니다. 이 뒤에 거듭제곱에 대해 또 무엇을 증명할 수 있을까요?" +msgstr "게임에서 이름이 가장 멋진 level 중 하나입니다. 음악이 절정으로 치닫는 가운데 흉악한 `pow_pow` 중간 보스가 나타납니다. 이 뒤에 거듭제곱에 대해 또 무엇을 증명할 수 있을까요?" #: Game.Levels.Algorithm.L01add_left_comm msgid "If $a, b, c$ are numbers, then $a+(b+c)=b+(a+c)$." @@ -420,7 +421,7 @@ msgid "" msgstr "" "`a`와 `b`이 수라면 `succ_inj a b`는 `succ a = succ b`이면 `a = b`라는 것의 증명입니다. 더 알아보려면 *Peano* 탭에서 이 정리를 클릭하세요.\n" "\n" -"페아노는 이 정리를 공리로 두었지만 Algorithm World에서는 Lean으로 이를 증명하는 방법을 보게 됩니다. 지금은 그냥 가정하고, 이를 이용해 $x+1=4 \\implies x=3$를 증명합시다. 이번에도 가정을 goal과 같아질 때까지 변형해 나가겠습니다. 이 level은 제가 단계별로 안내하겠습니다." +"페아노는 이 정리를 공리로 두었지만 알고리즘 월드에서는 Lean으로 이를 증명하는 방법을 보게 됩니다. 지금은 그냥 가정하고, 이를 이용해 $x+1=4 \\implies x=3$를 증명합시다. 이번에도 가정을 목표와 같아질 때까지 변형해 나가겠습니다. 이 레벨은 제가 단계별로 안내하겠습니다." #: Game.Levels.AdvMultiplication.L02mul_left_ne_zero msgid "Now `apply h` and you can probably take it from here." @@ -435,7 +436,7 @@ msgid "" "But we'll keep hold of these proofs anyway, because it's convenient\n" "to have exactly the right tool for a job." msgstr "" -"Multiplication World의 첫 sub-boss는 `mul_comm x y : x * y = y * x`입니다.\n" +"곱셈 월드의 첫 중간 보스는 `mul_comm x y : x * y = y * x`입니다.\n" "\n" "이 정리를 증명하면 `zero_mul`처럼 `mul_zero`에서 쉽게 따라오는 \"여분의\" 증명도 생깁니다. 그래도 정확히 필요한 도구를 바로 꺼내 쓸 수 있으면 편리하므로 이런 증명들도 그대로 가지고 있겠습니다." @@ -460,7 +461,7 @@ msgstr "decide" msgid "" "You can use `rw [zero_add] at «{h}»` to rewrite at `«{h}»` instead\n" "of at the goal." -msgstr "`rw [zero_add] at «{h}»`를 사용하면 goal이 아니라 `«{h}»`에서 rewrite할 수 있습니다." +msgstr "`rw [zero_add] at «{h}»`를 사용하면 목표가 아니라 `«{h}»`에서 rewrite할 수 있습니다." #: Game.Levels.Tutorial.L05add_zero msgid "" @@ -479,7 +480,7 @@ msgid "" msgstr "" "## 요약\n" "\n" -"`repeat t`는 tactic `t`을 goal에 반복해서 적용합니다. 반드시 필요한 tactic은 아니지만 때로는 일을 빠르게 해 줍니다.\n" +"`repeat t`는 택틱 `t`을 목표에 반복해서 적용합니다. 반드시 필요한 택틱은 아니지만 때로는 일을 빠르게 해 줍니다.\n" "\n" "## 예시\n" "\n" @@ -519,24 +520,24 @@ msgid "" msgstr "" "## 요약\n" "\n" -"`repeat t`는 tactic `t`을 goal에 반복 적용합니다. 꼭 필요한 tactic은 아니지만 때때로 속도를 높여 줍니다.\n" +"`repeat t`는 택틱 `t`을 목표에 반복 적용합니다. 꼭 필요한 택틱은 아니지만 때때로 속도를 높여 줍니다.\n" "\n" "## 예시\n" "\n" -"`repeat rw [add_zero]`는 goal\n" +"`repeat rw [add_zero]`는 목표\n" "`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\n" -"을 goal\n" +"을 목표\n" "`a = b`\n" "로 바꿉니다.\n" "\n" "TacticDoc nth_rewrite\n" "## 요약\n" "\n" -"`h : X = Y`이고 goal에 `X`가 여러 개 있다면 `nth_rewrite 3 [h]`은 세 번째 `X`만 `Y`로 바꿉니다.\n" +"`h : X = Y`이고 목표에 `X`가 여러 개 있다면 `nth_rewrite 3 [h]`은 세 번째 `X`만 `Y`로 바꿉니다.\n" "\n" "## 예시\n" "\n" -"goal이 `t`0이면 `t`1은 goal을 `t`2로 바꿉니다. 반면 `t`3은 goal을 `t`4로 바꿉니다." +"목표가 `2 + 2 = 4`이면 `nth_rewrite 2 [two_eq_succ+one]`은 목표를 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 목표를 `succ 1 + succ 1 = 4`로 바꿉니다." #: Game.Levels.Addition msgid "Addition World" @@ -594,20 +595,20 @@ msgid "" msgstr "" "## 요약\n" "\n" -"goal이 명제 §0이고 §2가 §3의 증명이라면 §1이 goal을 닫습니다.\n" +"목표가 명제 §0이고 §2가 §3의 증명이라면 §1이 목표를 닫습니다.\n" "\n" "### 예시\n" "\n" -"goal이 §4이고 가정 §5가 있다면 §6으로 goal을 해결할 수 있습니다.\n" +"목표가 §4이고 가정 §5가 있다면 §6으로 목표를 해결할 수 있습니다.\n" "\n" "### 예시\n" "\n" -"goal이 §7이라면 §8로 goal을 닫을 수 있습니다.\n" +"목표가 §7이라면 §8로 목표를 닫을 수 있습니다.\n" "\n" "### exact는 정말 exact해야 합니다\n" "\n" -"앞 예시에서 §9는 *작동하지 않습니다*. §10이 작동하려면 §11이 goal의 증명과 *정확히* 일치해야 합니다. §12는 §13의 증명이며, 달리 말하면 사용자가 §15를 넣어야 하는 §14의 증명입니다.\n" -"이는 필요할 경우 \"입력을 추측\"해 주는 §16과 §17과 대비됩니다. goal이 §18이면 §19와 §20은 모두 goal을 §21로 바꿉니다. §22가 함수 §23의 입력을 추측하기 때문입니다." +"앞 예시에서 §9는 *작동하지 않습니다*. §10이 작동하려면 §11이 목표의 증명과 *정확히* 일치해야 합니다. §12는 §13의 증명이며, 달리 말하면 사용자가 §15를 넣어야 하는 §14의 증명입니다.\n" +"이는 필요할 경우 \"입력을 추측\"해 주는 §16과 §17과 대비됩니다. 목표가 §18이면 §19와 §20은 모두 목표를 §21로 바꿉니다. §22가 함수 §23의 입력을 추측하기 때문입니다." #: Game.Levels.Implication.L07intro2 msgid "Now `apply succ_inj at h` to cancel the `succ`s." @@ -626,11 +627,11 @@ msgid "" "want to explore the game further (for example if you decide to 100%\n" "the game)." msgstr "" -"Addition World에 오신 것을 환영합니다! 이 world에서는 `induction` tactic을 배웁니다. 이를 이용해 이 world의 boss level인 `x + y = y + x`을 쓰러뜨릴 수 있습니다.\n" +"덧셈 월드에 오신 것을 환영합니다! 이 월드에서는 `induction` 택틱을 배웁니다. 이를 이용해 이 월드의 보스 레벨인 `x + y = y + x`을 쓰러뜨릴 수 있습니다.\n" "\n" -"`rw`, `rfl`, `induction` 세 tactic만 알면 Addition World, Multiplication World, Power World의 모든 level을 깰 수 있습니다. Power World에는 이 게임의 final boss가 있습니다.\n" +"`rw`, `rfl`, `induction` 세 택틱만 알면 덧셈 월드, 곱셈 월드, 지수 월드의 모든 레벨을 깰 수 있습니다. 지수 월드에는 이 게임의 최종 보스가 있습니다.\n" "\n" -"이 게임에는 훨씬 많은 tactic이 있지만, 더 깊이 탐험하고 싶을 때만 필요합니다(예를 들어 게임을 100% 완료하고 싶을 때)." +"이 게임에는 훨씬 많은 택틱이 있지만, 더 깊이 탐험하고 싶을 때만 필요합니다(예를 들어 게임을 100% 완료하고 싶을 때)." #: Game.Levels.Algorithm.L02add_algo1 msgid "" @@ -645,9 +646,9 @@ msgid "" "and then swap `b` and `d`. But this is easier than you\n" "think with `add_left_comm`." msgstr "" -"뒤쪽 world에서는 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`처럼 훨씬 더 험악한 level들을 만나게 됩니다. 괄호를 옮기고 변수들의 순서도 바꿔야 합니다.\n" +"뒤쪽 월드에서는 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`처럼 훨씬 더 험악한 레벨들을 만나게 됩니다. 괄호를 옮기고 변수들의 순서도 바꿔야 합니다.\n" "\n" -"이 level의 `(a + b) + (c + d) = ((a + c) + d) + b`에서는 괄호는 잠시 잊고 변수의 순서만 생각해 봅시다. `a+b+c+d`를 `a+c+d+b`으로 바꾸려면 `b`와 `c`를 바꾸고, 이어서 `b`와 `d`을 바꿔야 합니다. 하지만 `add_left_comm`을 쓰면 생각보다 쉽습니다." +"이 레벨의 `(a + b) + (c + d) = ((a + c) + d) + b`에서는 괄호는 잠시 잊고 변수의 순서만 생각해 봅시다. `a+b+c+d`를 `a+c+d+b`으로 바꾸려면 `b`와 `c`를 바꾸고, 이어서 `b`와 `d`을 바꿔야 합니다. 하지만 `add_left_comm`을 쓰면 생각보다 쉽습니다." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -673,15 +674,15 @@ msgid "" msgstr "" "## 요약\n" "\n" -"`symm` tactic은 `X = Y` 꼴의 goal 또는 가정을 `Y = X` 꼴로 바꿉니다. `X ≠ Y`과 `X ↔ Y`에도 사용할 수 있습니다.\n" +"`symm` tactic은 `X = Y` 꼴의 목표 또는 가정을 `Y = X` 꼴로 바꿉니다. `X ≠ Y`과 `X ↔ Y`에도 사용할 수 있습니다.\n" "\n" "### 예시\n" "\n" -"goal이 `2 + 2 = 4`라면 `symm`은 이를 `4 = 2 + 2`로 바꿉니다.\n" +"목표가 `2 + 2 = 4`라면 `symm`은 이를 `4 = 2 + 2`로 바꿉니다.\n" "\n" "### 예시\n" "\n" -"`h : 2 + 2 ≠ 5`이라면 `symm at h`는 `X = Y`0을 `X = Y`1로 바꿉니다." +"`h : 2 + 2 ≠ 5`이라면 `symm at h`는 `h`을 `5 ≠ 2 + 2`로 바꿉니다." #: Game.Levels.Multiplication.L07mul_add msgid "" @@ -692,11 +693,11 @@ msgstr "곱셈은 왼쪽에서 덧셈에 대해 분배법칙을 만족합니다. #: Game.Levels.Implication.L03apply msgid "The `apply` tactic." -msgstr "`apply` tactic." +msgstr "`apply` 택틱." #: Game.Levels.Implication.L01exact msgid "The goal in this level is one of our hypotheses. Solve the goal by executing `exact h1`." -msgstr "이 level의 goal은 가정 중 하나입니다. `exact h1`를 실행해서 goal을 해결하세요." +msgstr "이 레벨의 목표는 가정 중 하나입니다. `exact h1`를 실행해서 목표를 해결하세요." #: Game.Levels.AdvAddition.L05add_right_eq_zero msgid "" @@ -718,28 +719,31 @@ msgid "" "any statement. Here `cases h` will close the goal, because there are *no* ways to\n" "make a proof of `False`! So you will end up with no goals, meaning you have proved everything." msgstr "" -"`≤` World에서 다음으로 필요한 결과는 `a + b = 0`이면 `a = 0`이고 `b = 0`이라는 것입니다. 이번 level에서 하나를 증명하고 다음 level에서 나머지 하나를 증명합시다.\n" +"`≤` 월드에서 다음으로 필요한 결과는 `a + b = 0`이면 `a = 0`이고 `b = 0`이라는 것입니다. 이번 레벨에서 하나를 증명하고 다음 레벨에서 나머지 하나를 증명합시다.\n" "\n" -"## 새로운 tactic: `cases`\n" +"## 새로운 택틱: `cases`\n" "\n" -"`cases` tactic은 object나 가정을 그것이 만들어질 수 있었던 가능한 경우들로 분해합니다.\n" +"`cases` 택틱은 객체나 가정을 그것이 만들어질 수 있었던 가능한 경우들로 분해합니다.\n" "\n" -"예를 들어 `b = 0`와 `b = succ d`의 두 경우를 따로 다루고 싶지만 `induction b with d hd`에 따라오는 귀납가정 `hd`은 필요하지 않을 때가 있습니다. 이때는 `a + b = 0`0을 사용할 수 있습니다. 수를 만드는 방법은 두 가지뿐입니다. 0이거나 successor입니다. 따라서 `a + b = 0`1인 goal과 `a + b = 0`2인 goal, 두 개가 생깁니다.\n" +"예를 들어 `b = 0`와 `b = succ d`의 두 경우를 따로 다루고 싶지만 `induction b with d hd`에 따라오는 귀납가정\n" +"`hd`은 필요하지 않을 때가 있습니다. 이때는 `cases b with d`를 사용할 수 있습니다. 수를 만드는 방법은 단 두 가지,\n" +"0 또는 다음수입니다. 따라서 `b = 0`인 목표와 `b = succ d`인 목표, 두 개가 생깁니다.\n" "\n" -"또 다른 예로, 가정 `a + b = 0`3이 있다면 이미 끝난 것입니다. 거짓 명제에서는 어떤 명제든 따라오기 때문입니다. 여기서 `a + b = 0`4는 goal을 닫습니다. `a + b = 0`5의 증명을 만드는 방법은 *하나도 없기* 때문입니다! 따라서 goal이 하나도 남지 않고, 이는 모든 것을 증명했다는 뜻입니다." +"또 다른 예로, 가정 `h : False`이 있다면 이미 끝난 것입니다. 거짓 명제에서는 무엇이든지 증명할 수 있기 때문입니다.\n" +"여기서 `cases h`는 목표를 끝냅니다. 왜냐하면 `False`의 증명을 만드는 방법은 단 *0*가지이기 때문입니다! 따라서 목표가 하나도 남지 않고, 이는 모든 것을 증명했다는 뜻입니다." #: Game.Levels.Tutorial.L01rfl msgid "" "In order to use the tactic `rfl` you can enter it in the text box\n" "under the goal and hit \"Execute\"." -msgstr "`rfl` tactic을 사용하려면 goal 아래의 텍스트 상자에 입력한 뒤 \"Execute\"를 누르면 됩니다." +msgstr "`rfl` 택틱을 사용하려면 목표 아래의 텍스트 상자에 입력한 뒤 \"Execute\"를 누르면 됩니다." #: Game.Levels.Algorithm.L09decide2 msgid "" "Congratulations! You've finished Algorithm World. These algorithms\n" "will be helpful for you in Even-Odd World (when someone gets around to\n" "implementing it)." -msgstr "축하합니다! Algorithm World를 끝냈습니다. 이 알고리즘들은 Even-Odd World가 언젠가 구현되면 그곳에서 유용하게 쓰일 겁니다." +msgstr "축하합니다! 알고리즘 월드를 끝냈습니다. 이 알고리즘들은 홀짝 월드가 언젠가 구현되면 그곳에서 유용하게 쓰일 겁니다." #: Game.Levels.Tutorial.L08twoaddtwo msgid "" @@ -763,7 +767,7 @@ msgid "" msgstr "" "지나가던 수학자가 자연수들이 덧셈에 대해 가환 모노이드를 이룬다는 것을 증명했다며 축하합니다.\n" "\n" -"Addition World를 떠나기 전에 `add_assoc`와 `add_comm`을 한 level만 더 연습해 봅시다." +"덧셈 월드를 떠나기 전에 `add_assoc`와 `add_comm`을 한 레벨만 더 연습해 봅시다." #: Game.Levels.Implication.L05succ_inj2 msgid "Arguing backwards" @@ -777,7 +781,7 @@ msgstr "mul_right_eq_one" #: Game.Levels.Power.L09add_sq msgid "`add_sq a b` is the statement that $(a+b)^2=a^2+b^2+2ab.$" -msgstr "`add_sq a b`는 $(a+b)^2=a^2+b^2+2ab.$이라는 명제입니다." +msgstr "`add_sq a b`는 $(a+b)^2=a^2+b^2+2ab$이라는 명제입니다." #: Game.Levels.Implication.L08ne msgid "If $x=y$ and $x \\neq y$ then we can deduce a contradiction." @@ -812,13 +816,13 @@ msgstr "" "\n" "## 덧셈 정의하기\n" "\n" -"임의의 수 $x$에 $37$을 어떻게 더할까요? 이 게임에서 수를 만드는 방법은 $0$과 successor뿐입니다. 따라서 `37 + x`를 정의하려면 `37 + 0`와 `37 + succ x`가 무엇인지 정해야 합니다. 먼저 `0`을 더하는 것부터 시작합시다.\n" +"임의의 수 $x$에 $37$을 어떻게 더할까요? 이 게임에서 수를 만드는 방법은 $0$과 다음수뿐입니다. 따라서 `37 + x`를 정의하려면 `37 + 0`와 `37 + succ x`가 무엇인지 정해야 합니다. 먼저 `0`을 더하는 것부터 시작합시다.\n" "\n" "### 0 더하기\n" "\n" -"덧셈이 우리의 직관과 맞으려면 `37 + 0`을 `37`로 “정의”해야 합니다. 더 일반적으로는 모든 수 $a$에 대해 $a+0$을 $a$로 정의해야 합니다. Lean에서 이 증명의 이름은 $add_zero a$입니다. 예를 들어 $add_zero x$는 $ x + 0 = x$의 증명이고, $add_zero 37$은 $37 + 0 = 37$의 증명이며, $add_zero$은 $> + 0 = ?$의 증명입니다.\n" +"덧셈이 우리의 직관과 맞으려면 `37 + 0`을 `37`로 “정의”해야 합니다. 더 일반적으로는 모든 수 `a`에 대해 `a+0`을 `a`로 정의해야 합니다. Lean에서 이 증명의 이름은 `add_zero a`입니다. 예를 들어 `add_zero x`는 `x + 0 = x의 증명이고, `add_zero 37`은 `37 + 0 = 37`의 증명이며, `add_zero`은 `? + 0 = ?`의 증명입니다.\n" "\n" -"우리는 $add_zero x : x + 0 = x$처럼 씁니다. 따라서 Lean 코드에서 $statement$의 증명을 $poof$라고 하면, $proof:statement$입니다." +"우리는 `add_zero x : x + 0 = x`처럼 씁니다. 따라서 Lean 코드에서 `statement`의 증명을 `poof`라고 하면, `proof:statement`입니다." #: Game.Levels.AdvMultiplication.L01mul_le_mul_right msgid "Let's warm up with an easy one, which works even if `t = 0`." @@ -828,7 +832,7 @@ msgstr "`t = 0`인 경우에도 작동하는 쉬운 문제로 몸을 풀어 봅 msgid "" "Let's see if you can use the tactics we've learnt to prove $x+1=y+1\\implies x=y$.\n" "Try this one by yourself; if you need help then click on \"Show more help!\"." -msgstr "지금까지 배운 tactic들을 사용해 $x+1=y+1\\implies x=y$를 증명해 보세요. 먼저 혼자 시도해 보고, 도움이 필요하면 \"도움말 더 보기!\"를 누르세요." +msgstr "지금까지 배운 택틱들을 사용해 $x+1=y+1\\implies x=y$를 증명해 보세요. 먼저 혼자 시도해 보고, 도움이 필요하면 \"도움말 더 보기!\"를 누르세요." #: Game.Levels.Implication.L09zero_ne_succ #: Game.Levels.AdvMultiplication.L06mul_right_eq_one @@ -858,7 +862,7 @@ msgid "" "hypothesis with the §3 tactic. Remember you can click on\n" "§4 or any other tactic on the right to see a detailed explanation\n" "of what it does, with examples." -msgstr "이 level의 가정 §0는 *함의*입니다. 즉 *§1이면 §2*라는 뜻입니다. 이 가정은 §3 tactic으로 사용할 수 있습니다. 오른쪽의 §4나 다른 tactic을 클릭하면 예시와 함께 자세한 설명을 볼 수 있다는 점을 기억하세요." +msgstr "이 레벨의 가정 §0는 *조건문*입니다. 즉 *§1이면 §2*라는 뜻입니다. 이 가정은 §3 택틱으로 사용할 수 있습니다. 오른쪽의 §4나 다른 택틱을 클릭하면 예시와 함께 자세한 설명을 볼 수 있다는 점을 기억하세요." #: Game.Levels.Tutorial.L01rfl msgid "" @@ -878,15 +882,15 @@ msgid "" "\n" "Prove that $37x+q=37x+q$ by executing the `rfl` tactic." msgstr "" -"# 먼저 읽어 주세요\n" +"# 일러두기\n" "\n" -"이 게임의 각 level에서는 하나의 수학 정리(\"Goal\")를 증명합니다. goal은 *수*에 관한 명제입니다. 이 게임의 어떤 수들은 값이 알려져 있습니다. 그런 수에는 $37$ 같은 이름이 붙습니다. 다른 수들의 값은 비밀이며 $x$, $q$ 같은 이름으로 불립니다. $x$이 수라는 것은 알지만 정확히 어떤 수인지는 모릅니다.\n" +"이 게임의 각 레벨에서는 하나의 수학 정리(\"목표\")를 증명합니다. 목표는 *수*에 관한 명제입니다. 이 게임의 어떤 수들은 값이 알려져 있습니다. 그런 수에는 $37$ 같은 이름이 붙습니다. 다른 수들의 값은 비밀이며 $x$, $q$ 같은 이름으로 불립니다. $x$이 수라는 것은 알지만 정확히 어떤 수인지는 모릅니다.\n" "\n" -"첫 level에서는 $37x + q = 37x + q$라는 정리를 증명합니다. 아래 *Objects*에 `x q : ℕ`가 보일 텐데, 이는 `x`와 `q`이 수라는 뜻입니다.\n" +"첫 레벨에서는 $37x + q = 37x + q$라는 정리를 증명합니다. 아래 *객체*에 `x q : ℕ`가 보일 텐데, 이는 `x`와 `q`이 수라는 뜻입니다.\n" "\n" -"Lean에서는 *Tactics*를 이용해 goal을 해결합니다. 처음 배울 tactic은 `rfl`이며, $X = X$ 꼴의 모든 정리를 증명합니다.\n" +"Lean에서는 *택틱*를 이용해 목표를 해결합니다. 처음 배울 택틱은 `rfl`이며, $X = X$ 꼴의 모든 정리를 증명합니다.\n" "\n" -"$x$1 tactic을 실행해 $x$0을 증명하세요." +"`rfl` 택틱을 실행해 $37x+q=37x+q$를 증명하세요." #. repeat rw [zero_add] at h #. exact h @@ -914,14 +918,14 @@ msgid "" msgstr "" "`zero_add n`는 `0 + n = n`의 증명입니다.\n" "\n" -"`zero_add`는 `simp` lemma입니다. 식을 단순화할 때 `0 + n`를 `n`로 바꾸는 것은 거의 항상 우리가 원하는 일이기 때문입니다." +"`zero_add`는 `simp` 정리입니다. 식을 단순화할 때 `0 + n`를 `n`로 바꾸는 것은 거의 항상 우리가 원하는 일이기 때문입니다." #: Game.Levels.Implication.L09zero_ne_succ msgid "" "As warm-up for `2 + 2 ≠ 5` let's prove `0 ≠ 1`. To do this we need to\n" "introduce Peano's last axiom `zero_ne_succ n`, a proof that `0 ≠ succ n`.\n" "To learn about this result, click on it in the list of lemmas on the right." -msgstr "`2 + 2 ≠ 5`를 위한 준비운동으로 `0 ≠ 1`을 증명해 봅시다. 이를 위해 페아노의 마지막 공리 `zero_ne_succ n`, 즉 `0 ≠ succ n`의 증명을 도입해야 합니다. 이 결과에 대해 알아보려면 오른쪽 lemma 목록에서 클릭하세요." +msgstr "`2 + 2 ≠ 5`를 위한 준비운동으로 `0 ≠ 1`을 증명해 봅시다. 이를 위해 페아노의 마지막 공리 `zero_ne_succ n`, 즉 `0 ≠ succ n`의 증명을 도입해야 합니다. 이 결과에 대해 알아보려면 오른쪽 정리 목록에서 클릭하세요." #: Game.Levels.Implication.L01exact msgid "Assuming $x+y=37$ and $3x+z=42$, we have $x+y=37$." @@ -949,17 +953,18 @@ msgid "" "\"for all `c`, if `a * b = a * c` then `b = c`\". This *can* be proved by induction,\n" "because we now have the flexibility to change `c`." msgstr "" -"이 level에서는 `a * b = a * c`와 `a ≠ 0`이면 `b = c`임을 증명합니다. 여러 이유로 까다로운데, 그중 하나는 새로운 생각이 필요하다는 점입니다. 수학적 귀납법을 조금 더 깊이 이해해야 합니다.\n" +"이 레벨에서는 `a * b = a * c`와 `a ≠ 0`이면 `b = c`임을 증명합니다. 여러 이유로 까다로운데, 그중 하나는 새로운 생각이 필요하다는 점입니다. 수학적 귀납법을 조금 더 깊이 이해해야 합니다.\n" "\n" "`induction b with d hd`으로 시작하는 것은 너무 순진합니다. 귀납 단계에서 귀납가정은 `a * d = a * c → d = c`인데 실제로 알고 있는 것은 `a * succ d = a * c`이므로 귀납가정을 적용할 수 없기 때문입니다!\n" "\n" -"`a ≠ 0`가 고정되어 있다고 합시다. `b`에 대해 실제로 귀납하여 증명해야 하는 명제는 \"모든 `c`에 대해, `a * b = a * c`이면 `a ≠ 0`0\"입니다. 이렇게 하면 `a ≠ 0`1을 바꿀 수 있는 여지가 생기므로 귀납법으로 증명할 *수 있습니다*." +"`a ≠ 0`가 고정되어 있다고 합시다. `b`에 대해 실제로 귀납하여 증명해야 하는 명제는\n" +"\"모든 `c`에 대해, `a * b = a * c`이면 `b = c`\"입니다. 이렇게 하면 `c`를 바꿀 수 있는 여지가 생기므로 귀납법 증명이 *가능*해집니다." #: Game.Levels.AdvMultiplication.L08mul_eq_zero msgid "" "Now the goal can be deduced from `h2` by pure logic, so use the `tauto`\n" "tactic." -msgstr "이제 순수한 논리만으로 `h2`에서 goal이 따라오므로 `tauto` tactic을 사용하세요." +msgstr "이제 순수한 논리만으로 `h2`에서 목표가 따라오므로 `tauto` 택틱을 사용하세요." #: Game.Levels.Tutorial.L02rw msgid "Now `rfl` will work." @@ -967,7 +972,7 @@ msgstr "이제 `rfl`가 작동합니다." #: Game.Levels.LessOrEqual.L05le_zero msgid "`le_zero x` is a proof of the implication `x ≤ 0 → x = 0`." -msgstr "`le_zero x`는 함의 `x ≤ 0 → x = 0`의 증명입니다." +msgstr "`le_zero x`는 조건문 `x ≤ 0 → x = 0`의 증명입니다." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -998,7 +1003,7 @@ msgstr "" "§0는 자연수이며, 이 게임에서는 그냥 \\\"수\\\"라고 부릅니다. 자연수는 다음 두 규칙으로 정의됩니다.\n" "\n" "* §1 (0은 수이다)\n" -"* §2 (수의 successor도 수이다)\n" +"* §2 (수의 다음수도 수이다)\n" "\n" "## 게임 구현\n" "\n" @@ -1011,13 +1016,13 @@ msgid "" "hypothesis `a ≠ 0`. Here is a key lemma that enables us to use this hypothesis.\n" "To help us with the proof, we can use the `tauto` tactic. Click on the tactic's name\n" "on the right to see what it does." -msgstr "곱셈은 보통 수를 더 크게 만들지만 0을 곱하면 더 작게 만들 수도 있습니다. 그래서 부등식과 곱셈에 관한 많은 lemma에는 가정 `a ≠ 0`가 필요합니다. 여기서는 이 가정을 활용할 수 있게 해 주는 핵심 lemma를 증명합니다. 증명을 돕기 위해 `tauto` tactic을 사용할 수 있습니다. 오른쪽에서 tactic 이름을 눌러 무엇을 하는지 확인하세요." +msgstr "곱셈은 보통 수를 더 크게 만들지만 0을 곱하면 더 작게 만들 수도 있습니다. 그래서 부등식과 곱셈에 관한 많은 정리에는 가정 `a ≠ 0`가 필요합니다. 여기서는 이 가정을 활용할 수 있게 해 주는 핵심 정리를 증명합니다. 증명을 돕기 위해 `tauto` 택틱을 사용할 수 있습니다. 오른쪽에서 택틱 이름을 눌러 무엇을 하는지 확인하세요." #: Game.Levels.LessOrEqual.L04le_trans msgid "" "In this level, we see inequalities as *hypotheses*. We have not seen this before.\n" "The `cases` tactic can be used to take `hxy` apart." -msgstr "이 level에서는 부등식을 *가정*으로 처음 만나 봅니다. `cases` tactic을 사용하면 `hxy`을 분해할 수 있습니다." +msgstr "이 레벨에서는 부등식을 *가정*으로 처음 만나 봅니다. `cases` 택틱을 사용하면 `hxy`을 분해할 수 있습니다." #: Game.Levels.Algorithm.L07succ_ne_succ msgid "" @@ -1042,15 +1047,20 @@ msgid "" msgstr "" "여기서는 두 자연수 `a`와 `b`을 받아 \"`a = b`인가?\"에 대한 답을 돌려주는 알고리즘을 만들기 시작합니다.\n" "\n" -"알고리즘은 다음과 같습니다. 먼저 `a`와 `b`는 수이므로 각각 `0`이거나 successor입니다.\n" +"알고리즘은 다음과 같습니다. 먼저 `a`와 `b`는 수이므로 각각 `0`이거나 다음수입니다.\n" "\n" "*) `a`와 `b`이 둘 다 `0`이면 \"yes\"를 반환합니다.\n" "\n" -"*) 하나가 `0`이고 다른 하나가 `b`0이면 \"no\"를 반환합니다.\n" +"*) 하나가 `0`이고 다른 하나가 `succ n`이면 \"no\"를 반환합니다.\n" "\n" -"*) `b`1이고 `b`2이면 \"`b`3인가?\"에 대한 답을 반환합니다.\n" +"*) `a = succ m`이고 `b = succ n`이면 \"`m = n`인가?\"에 대한 답을 반환합니다.\n" "\n" -"이제 이 알고리즘이 항상 올바른 답을 준다는 것을 *증명*해야 합니다. `b`4의 증명은 `b`5입니다. `b`6의 증명은 `b`7이고, `b`8의 증명은 `b`9입니다. `a = b`0이면 `a = b`1이라는 증명은 `a = b`2를 한 뒤 `a = b`3을 하면 됩니다. 이 level에서는 남은 마지막 경우, 즉 `a = b`4이면 `a = b`5라는 것을 증명합니다." +"이제 이 알고리즘이 항상 올바른 답을 준다는 것을 *증명*해야 합니다.\n" +"`0 = 0`의 증명은 `rfl`입니다. `0 ≠ succ n`의 증명은 `zero_ne_succ n`이고,\n" +"`succ m ≠ 0`의 증명은 `succ_ne_zero m`입니다. `h : m = n`일 때\n" +"`succ m = succ n`임을 증명하려면 `rw [h]`를 한 뒤 `rfl`을 사용하면 됩니다.\n" +"이 레벨에서는 이제 남은 마지막 경우, 즉 `a ≠ b`이면\n" +"`succ a ≠ succ b`라는 것을 증명합니다." #: Game.Levels.LessOrEqual.L06le_antisymm msgid "x ≤ y and y ≤ x implies x = y" @@ -1070,11 +1080,11 @@ msgid "" "one." msgstr "" "# 요약\n" -"`left` tactic은 `P ∨ Q`이라는 goal을 `P`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `P`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n" +"`left` 택틱은 `P ∨ Q`이라는 목표를 `P`라는 목표로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `P`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n" "\n" -"내부적으로 이 tactic은 $P \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n" +"내부적으로 이 택틱은 $P \\implies P \\lor Q$이라는 정리를 `apply`하는 것뿐입니다.\n" "\n" -"이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요." +"이 택틱은 풀 수 있는 목표를 풀 수 없는 목표로 바꿀 수도 있다는 점에 주의하세요." #: Game.Levels.LessOrEqual.L07or_symm msgid "" @@ -1090,11 +1100,11 @@ msgid "" "one." msgstr "" "# 요약\n" -"`right` tactic은 `P ∨ Q`이라는 goal을 `Q`라는 goal로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `Q`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n" +"`right` 택틱은 `P ∨ Q`이라는 목표를 `Q`라는 목표로 바꿉니다. 가정들을 볼 때 `P ∨ Q`이 참인 이유가 실제로 `Q`가 참이기 때문이라고 확신할 수 있을 때 사용하세요.\n" "\n" -"내부적으로 이 tactic은 $Q \\implies P \\lor Q.$이라는 정리를 `apply`하는 것뿐입니다.\n" +"내부적으로 이 택틱은 $Q \\implies P \\lor Q$이라는 정리를 `apply`하는 것뿐입니다.\n" "\n" -"이 tactic은 풀 수 있는 goal을 풀 수 없는 goal로 바꿀 수도 있다는 점에 주의하세요." +"이 택틱은 풀 수 있는 목표를 풀 수 없는 목표로 바꿀 수도 있다는 점에 주의하세요." #: Game.Levels.Multiplication msgid "Multiplication World" @@ -1177,7 +1187,6 @@ msgstr "$x+1=4$이면 $x=3$입니다." msgid "If $x=37$ and we know that $x=37\\implies y=42$ then we can deduce $y=42$." msgstr "$x=37$이고 $x=37\\implies y=42$임을 알고 있다면 $y=42$를 이끌어낼 수 있습니다." -# World=월드 #: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 #: Game.Levels.Algorithm.L05pred Game.Levels.Algorithm.L07succ_ne_succ #: Game.Levels.AdvAddition.L05add_right_eq_zero @@ -1186,7 +1195,7 @@ msgstr "$x=37$이고 $x=37\\implies y=42$임을 알고 있다면 $y=42$를 이 msgid "" "If you have completed Algorithm World then you can use the `contrapose!` tactic\n" "here. If not then I'll talk you through a manual approach." -msgstr "만약 알고리듬 월드를 완료했다면 `contrapose!` tactic을 사용하실 수 있습니다. 그렇지 않다면 우회 방법에 대해 가르쳐 드릴게ㅇ" +msgstr "만약 알고리즘 월드를 완료했다면 `contrapose!` 택틱을 사용하실 수 있습니다. 그렇지 않다면 우회 방법에 대해 가르쳐 드리겠습니다." #: Game.Levels.Addition.L04add_assoc msgid "" @@ -1199,7 +1208,7 @@ msgid "" "\n" " That's true, but we didn't prove it yet. Let's prove it now by induction." msgstr "" -"지금까지는 수 두 개를 더했습니다. 이번 level에서는 세 개를 더합니다.\n" +"지금까지는 수 두 개를 더했습니다. 이번 레벨에서는 세 개를 더합니다.\n" "\n" "$x+y+z$는 무슨 *뜻*일까요? $(x+y)+z$을 뜻할 수도 있고 $x+(y+z)$를 뜻할 수도 있습니다. Lean에서 $x+y+z$은 $(x+y)+z$를 뜻합니다.\n" "\n" @@ -1326,11 +1335,11 @@ msgid "" msgstr "" "## 요약\n" "\n" -"`n : ℕ`가 object이고 goal에 `n`이 등장하면 `induction n with d hd`는 `n`에 대한 귀납법으로 goal을 증명하려 합니다. successor 경우의 귀납 변수는 `d`이고 귀납가정은 `hd`입니다.\n" +"`n : ℕ`가 객체이고 목표에 `n`이 등장하면 `induction n with d hd`는 `n`에 대한 귀납법으로 목표를 증명하려 합니다. `succ` 경우의 귀납 변수는 `d`이고 귀납가정은 `hd`입니다.\n" "\n" "### 예시\n" "\n" -"goal이\n" +"목표가\n" "```\n" "0 + n = n\n" "```\n" @@ -1338,9 +1347,9 @@ msgstr "" "\n" "`induction n with d hd`\n" "\n" -"은 이를 두 goal로 바꿉니다. 첫 번째는 `0 + 0 = 0`이고, 두 번째는 가정 `hd : 0 + d = d`와 goal `n`0을 가집니다.\n" +"은 이를 두 목표로 바꿉니다. 첫 번째는 `0 + 0 = 0`이고, 두 번째는 가정 `hd : 0 + d = d`와 목표 `0 + succ d = succ d`입니다.\n" "\n" -"두 번째 goal에 접근하려면 먼저 첫 번째 goal을 증명해야 한다는 점에 주의하세요." +"두 번째 목표에 접근하려면 먼저 첫 번째 목표를 증명해야 한다는 점에 주의하세요." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -1359,7 +1368,7 @@ msgstr "$1\\times m=m$는 적어도 세 가지 방법으로 증명할 수 있습 msgid "" "Note that `succ a + «{d}»` means `(succ a) + «{d}»`. Put your cursor\n" "on any `succ` in the goal or assumptions to see what exactly it's eating." -msgstr "`succ a + «{d}»`가 `(succ a) + «{d}»`을 뜻한다는 점에 주의하세요. goal이나 가정에 있는 아무 `succ` 위에 커서를 올려 정확히 무엇을 먹고 있는지 확인해 보세요." +msgstr "`succ a + «{d}»`가 `(succ a) + «{d}»`을 뜻한다는 점에 주의하세요. 목표가나 가정에 있는 아무 `succ` 위에 커서를 올려 정확히 무엇을 먹고 있는지 확인해 보세요." #: Game.Levels.LessOrEqual.L07or_symm msgid "We don't know whether to go left or right yet. So start with `cases «{h}» with hx hy`." @@ -1374,7 +1383,7 @@ msgid "" "which we will do using this lemma. The proof I have in mind manipulates the hypothesis\n" "until it becomes the goal, using `mul_left_ne_zero`, `one_le_of_ne_zero` and\n" "`mul_le_mul_right`." -msgstr "언젠가 이 게임에는 소수 월드가 생기고, 최종 보스는 $2$가 소수임을 증명하는 문제가 될 겁니다. 이를 위해 $2 = 37 × 42.$ 같은 가능성을 배제해야 합니다. 어떤 $2$의 인수도 $2$ 이하임을 보임으로써 그렇게 할 것이고, 이 lemma를 사용합니다. 제가 생각한 증명은 `mul_left_ne_zero`, `one_le_of_ne_zero`, `mul_le_mul_right`를 이용해 가정을 goal이 될 때까지 변형합니다." +msgstr "언젠가 이 게임에는 소수 월드가 생기고, 최종 보스는 $2$가 소수임을 증명하는 문제가 될 겁니다. 이를 위해 $2 = 37 × 42$ 같은 가능성을 배제해야 합니다. 어떤 $2$의 약수도 $2$ 이하임을 보임으로써 그렇게 할 것이고, 이 정리를 사용합니다. 제가 생각한 증명은 `mul_left_ne_zero`, `one_le_of_ne_zero`, `mul_le_mul_right`를 이용해 가정을 목표가 될 때까지 변형합니다." #: Game.Levels.Algorithm.L06is_zero msgid "" @@ -1404,15 +1413,15 @@ msgid "" msgstr "" "## 요약\n" "\n" -"만약 goal이 `P → Q`라면, `intro h`는 가정에 `h : P`을 남기고,\n" -"goal을 `Q`로 바꿀 것입니다. 수학적으로, $P \\implies Q$를 증명한다는 것은,\n" +"만약 목표가 `P → Q`라면, `intro h`는 가정에 `h : P`을 남기고,\n" +"목표를 `Q`로 바꿀 것입니다. 수학적으로, $P \\implies Q$를 증명한다는 것은,\n" "$P$를 먼저 가정하고 $Q$를 증명하는 것과 같습니다..\n" "\n" "### 예시:\n" "\n" -"만약 goal이 `x + 1 = y + 1 → x = y`라면, Lean이 $x+1=y+1 \\implies x=y$을 일컫는 방법\n" +"만약 목표가 `x + 1 = y + 1 → x = y`라면, Lean이 $x+1=y+1 \\implies x=y$을 일컫는 방법\n" "`intro h`를 했을 때 `h`라고 하는 $x+1=y+1$ 가 남고,\n" -"goal은 $x=y$로 바뀔 것입니다." +"목표는 $x=y$로 바뀔 것입니다." #: Game.Levels.Power.L05pow_two msgid "" @@ -1456,7 +1465,7 @@ msgid "" "Peano assumed as an axiom and which we have already used extensively without justification." msgstr "" "이제 덧셈을 더 효율적으로 계산하는 알고리즘을 만들어 봅시다. 앞서\n" -"`0`과 후속자에서 어떻게 작동하는지를 정하여 덧셈을 재귀적으로\n" +"`0`과 다음수에서 어떻게 작동하는지를 정하여 덧셈을 재귀적으로\n" "정의했다는 것을 떠올려 보세요. Lean에서는 자연수 같은 타입에서\n" "재귀를 사용해 함수를 정의할 수 있다는 것을 공리로 받아들입니다.\n" "\n" @@ -1469,7 +1478,7 @@ msgstr "" "```\n" "\n" "0에서는 1을 뺄 수 없으므로 그냥 아무 값이나 반환합니다. 이 정의와\n" -"함께 `pred_succ`라는 새로운 보조정리도 만듭니다. 이 정리는\n" +"함께 `pred_succ`라는 새로운 정리도 만듭니다. 이 정리는\n" "`pred (succ n) = n`이라고 말합니다. 이제 이 정리를 사용하여\n" "`succ_inj`를 증명해 봅시다. `succ_inj`는 페아노가 공리로 가정했고,\n" "우리는 지금까지 정당화 없이 여러 번 사용해 온 정리입니다." @@ -1482,9 +1491,11 @@ msgid "" "defined to be `a ^ 0 * a` so it's `1 * a`, and to prove\n" "that this is equal to `a` you need to use induction somewhere." msgstr "" -"`pow_one a`는 `a ^ 1 = a`이라고 말합니다.\n" +"`pow_one a`는 `a ^ 1 = a`라는 뜻입니다.\n" "\n" -"정의만으로 바로 참인 것은 아닙니다. `a ^ 1`는 `a ^ 0 * a`으로 정의되므로 `1 * a`이고, 이것이 `a`와 같음을 보이려면 어딘가에서 귀납법을 사용해야 합니다." +"이는 정의만으로 바로 참인 것은 아닙니다. `a ^ 1`은\n" +"`a ^ 0 * a`로 정의되므로 `1 * a`이고, 이것이 `a`와 같다는 것을\n" +"보이려면 어딘가에서 귀납법을 사용해야 합니다." #: Game.Levels.Power.L05pow_two msgid "`pow_two a` says that `a ^ 2 = a * a`." @@ -1492,7 +1503,7 @@ msgstr "`pow_two a`는 `a ^ 2 = a * a`압니다." #: Game.Levels.Implication.L04succ_inj msgid "In the next level, we'll do the same proof but backwards." -msgstr "다음 level에서는 같은 증명을 거꾸로 해 보겠습니다." +msgstr "다음 레벨에서는 같은 증명을 거꾸로 해 보겠습니다." #. rw [mul_comm, mul_add] #. repeat rw [mul_comm c] @@ -1566,7 +1577,7 @@ msgstr "" "\n" "지나가던 수학자가 이제 반대칭성까지 있으므로 `ℕ` 위의 `≤`이 *partial order*임을 증명했다고 말합니다.\n" "\n" -"이 world의 boss level은 `≤`가 total order임을 증명하는 것입니다. 그 전에 쉬운 tactic 두 개를 더 배워 봅시다." +"이 월드의 보스 레벨은 `≤`가 전순서임을 증명하는 것입니다. 그 전에 쉬운 택틱 두 개를 더 배워 봅시다." #. cases x with y #. left @@ -1608,7 +1619,7 @@ msgstr "" "rfl\n" "```\n" "\n" -"이 level을 풀었다면 다음 level도 문제없을 겁니다!" +"이 레벨을 풀었다면 다음 레벨도 문제없을 겁니다!" #. intro h #. rw [add_succ, add_succ, add_zero] at h @@ -1644,8 +1655,8 @@ msgstr "" "exact h\n" "```\n" "\n" -"Lean은 정리 증명기지만, 지금까지 만든 것만으로는 계산기로 쓰기에 아직 부족하다는 게 분명합니다. 좀 더 컴퓨터과학적인 Algorithm World에서는 이런 문제를 훨씬 쉽게 만들고 $20 + 20 ≠ 41$ 같은 목표도 다룰 수 있게 해 주는 도구를 개발합니다.\n" -"대신 Advanced Addition World로 가서 수학을 더 진행할 수도 있습니다. 거기서는 부등식 이론을 제대로 만들기 위해 필요한 보조정리들을 증명합니다. \"Home\"을 누르고 어느 길로 갈지 선택하세요." +"Lean은 정리 증명기지만, 지금까지 만든 것만으로는 계산기로 쓰기에 아직 부족하다는 게 분명합니다. 좀 더 컴퓨터과학적인 알고리즘 월드에서는 이런 문제를 훨씬 쉽게 만들고 $20 + 20 ≠ 41$ 같은 목표도 다룰 수 있게 해 주는 도구를 개발합니다.\n" +"대신 고급 덧셈 월드로 가서 수학을 더 진행할 수도 있습니다. 거기서는 부등식 이론을 제대로 만들기 위해 필요한 정리들을 증명합니다. \"홈\"을 누르고 어느 길로 갈지 선택하세요." #. rw [mul_comm, mul_add] #. repeat rw [mul_comm c] @@ -1670,7 +1681,7 @@ msgstr "" #: Game.Levels.Implication.L03apply msgid "Now finish using the `exact` tactic." -msgstr "이제 `exact` tactic을 사용해 마무리하세요." +msgstr "이제 `exact` 택틱을 사용해 마무리하세요." #: Game.Levels.Power msgid "" @@ -1697,9 +1708,9 @@ msgstr "" " * `pow_zero (a : ℕ) : a ^ 0 = 1`\n" " * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n" "\n" -"이 둘만 사용해서 최종 보스 level을 넘을 수 있을까요?\n" +"이 둘만 사용해서 최종 보스 레벨을 넘을 수 있을까요?\n" "\n" -"이 세계의 level들은 2019년 여름 Imperial College London의 UROP 학생 Sian Carey가 설계했으며 Mary Lister McCammon Fellowship의 지원을 받았습니다. Sian과 그녀를 지원한 Imperial College에 감사드립니다." +"이 월드의 레벨들은 2019년 여름 Imperial College London의 UROP 학생 Sian Carey가 설계했으며 Mary Lister McCammon Fellowship의 지원을 받았습니다. Sian과 그녀를 지원한 Imperial College에 감사드립니다." #: Game.Levels.Implication.L04succ_inj msgid "" @@ -1751,11 +1762,11 @@ msgstr "고급 덧셈 월드" #: Game.Levels.Tutorial.L01rfl msgid "If $x$ and $q$ are arbitrary natural numbers, then $37x+q=37x+q.$" -msgstr "$x$와 $q$이 임의의 자연수라면 $37x+q=37x+q.$입니다." +msgstr "$x$와 $q$이 임의의 자연수라면 $37x+q=37x+q$입니다." #: Game.Levels.LessOrEqual.L07or_symm msgid "This time, use the `left` tactic." -msgstr "이번에는 `left` tactic을 사용하세요." +msgstr "이번에는 `left` 택틱을 사용하세요." #: Game.Levels.Power.L09add_sq msgid "" @@ -1857,7 +1868,7 @@ msgid "" msgstr "" "`zero_mul m`는 `0 * m = 0`의 증명입니다.\n" "\n" -"참고: `zero_mul`는 `simp` lemma입니다." +"참고: `zero_mul`는 `simp` 정리입니다." #: Game.Levels.Implication.L09zero_ne_succ msgid "" @@ -1880,7 +1891,7 @@ msgstr "간단하게 만들기" msgid "" "Now rewrite `four_eq_succ_three` backwards to make the goal\n" "equal to the hypothesis." -msgstr "이제 `four_eq_succ_three`를 거꾸로 rewrite해서 goal을 가정과 같게 만드세요." +msgstr "이제 `four_eq_succ_three`를 거꾸로 rewrite해서 목표를 가정과 같게 만드세요." #: Game.Levels.Addition.L04add_assoc msgid "add_assoc (associativity of addition)" @@ -1917,9 +1928,9 @@ msgid "" "in your inventory, or of any assumption displayed above the goal,\n" "as long as it is of the form `X = Y`." msgstr "" -"이제 goal이 두 개 생겼습니다. 첫 번째를 증명하면 두 번째로 넘어갑니다. 첫 goal은 기저 경우 $n = 0$입니다.\n" +"이제 목표가 두 개 생겼습니다. 첫 번째를 증명하면 두 번째로 넘어갑니다. 첫 목표는 기저 단계 $n = 0$입니다.\n" "\n" -"inventory에 보이는 lemma의 증명이나 goal 위에 표시된 가정은 `X = Y` 꼴이기만 하면 언제든 rewrite에 사용할 수 있다는 점을 기억하세요." +"인벤토리에 보이는 정리의 증명이나 목표 위에 표시된 가정은 `X = Y` 꼴이기만 하면 언제든 rewrite에 사용할 수 있다는 점을 기억하세요." #: Game.Levels.Implication.L05succ_inj2 msgid "" @@ -1929,7 +1940,7 @@ msgid "" " will \"argue backwards\". The `apply` tactic can do this too.\n" " Again I will walk you through this one (assuming you're in\n" " command line mode)." -msgstr "지난 level에서는 가정 `x + 1 = 4`를 goal `x = 3`이 될 때까지 변형했습니다. 이번에는 반대로 goal을 가정이 될 때까지 변형합니다! 즉 \"거꾸로 추론\"할 것입니다. `apply` tactic도 이렇게 사용할 수 있습니다. 이번에도 command line mode라고 가정하고 단계별로 안내하겠습니다." +msgstr "지난 레벨에서는 가정 `x + 1 = 4`를 목표 `x = 3`이 될 때까지 변형했습니다. 이번에는 반대로 목표를 가정이 될 때까지 변형합니다! 즉 \"거꾸로 추론\"할 것입니다. `apply` 택틱도 이렇게 사용할 수 있습니다. 이번에도 타자기 모드라고 가정하고 단계별로 안내하겠습니다." #: Game.Levels.Tutorial.L06add_zero2 msgid "" @@ -1954,7 +1965,7 @@ msgstr "이제 `h`에서 `succ_eq_add_one`를 거꾸로 rewrite해 오른쪽 항 msgid "" "You can read more about the `decide` tactic by clicking\n" "on it in the top right." -msgstr "오른쪽 위에서 `decide` tactic을 클릭하면 자세한 설명을 읽을 수 있습니다." +msgstr "오른쪽 위에서 `decide` 택틱을 클릭하면 자세한 설명을 읽을 수 있습니다." #: Game.Levels.Implication.L08ne msgid "" @@ -1976,7 +1987,10 @@ msgstr "" "\n" "이것이 수학적으로 타당한 이유는 `P`가 참/거짓 명제라면 `P → False`이 `P`의 논리적 반대이기 때문입니다. 실제로 `True → False`는 거짓이고 `False → False`는 참입니다!\n" "\n" -"따라서 `a ≠ b`은 다른 함의 `P → Q`과 똑같이 다룰 수 있습니다. 예를 들어 *goal*이 `a ≠ b` 꼴이라면 `(a = b) → False`0으로 진행할 수 있고, `(a = b) → False`2 꼴의 가정 `(a = b) → False`1이 있다면 `(a = b) → False`4가 `(a = b) → False`5의 증명일 때 `(a = b) → False`3할 수 있습니다." +"따라서 `a ≠ b`는 다른 함의 `P → Q`와 완전히 같은 방식으로 다룰 수 있습니다.\n" +"예를 들어 *목표*가 `a ≠ b` 꼴이라면 `intro h`를 사용해 진행할 수 있습니다.\n" +"또 `a ≠ b` 꼴의 가정 `h`가 있고, `h1`이 `a = b`의 증명이라면\n" +"`apply h at h1`을 사용할 수 있습니다." #. §0: `mul_assoc a b c` #. §1: `(a * b) * c = a * (b * c)` @@ -2009,13 +2023,13 @@ msgstr "add_left_eq_self" #: GameServer.RpcHandlers msgid "level completed with warnings… 🎭" -msgstr "level 완료(그러나 경고가 남은…) 🎭" +msgstr "레벨 완료(그러나 경고가 남은…) 🎭" #: Game.Levels.Implication.L08ne msgid "" "Remember that `h2` is a proof of `x = y → False`. Try\n" "`apply`ing `h2` either `at h1` or directly to the goal." -msgstr "`h2`가 `x = y → False`의 증명이라는 점을 기억하세요. `h2`에 `apply`를 `at h1`하거나 goal에 직접 `at h1`해 보세요." +msgstr "`h2`가 `x = y → False`의 증명이라는 점을 기억하세요. `h2`에 `apply`를 `at h1`하거나 목표에 직접 `at h1`해 보세요." #: Game.Levels.AdvMultiplication.L10mul_right_eq_self msgid "You can now `apply mul_left_cancel at h`" @@ -2033,9 +2047,9 @@ msgid "" "\n" "We'll prove it using a new and very useful tactic called `have`." msgstr "" -"이 레벨에서는 고급 덧셈 월드의 `x + y = 0 → x = 0`에 대응하는 곱셈 버전 `x * y = 1 → x = 1`를 증명합니다. 전략은 `x ≤ 1`를 증명한 다음 `≤` 월드에서 얻은 lemma `le_one`을 사용하는 것입니다.\n" +"이 레벨에서는 고급 덧셈 월드의 `x + y = 0 → x = 0`에 대응하는 곱셈 버전 `x * y = 1 → x = 1`를 증명합니다. 전략은 `x ≤ 1`를 증명한 다음 `≤` 월드에서 얻은 정리 `le_one`을 사용하는 것입니다.\n" "\n" -"새롭고 매우 유용한 tactic `have`를 사용해 증명하겠습니다." +"새롭고 매우 유용한 택틱 `have`를 사용해 증명하겠습니다." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -2084,13 +2098,13 @@ msgstr "" "# 자연수 게임에 오신 것을 환영합니다\n" "#### 수학적 증명 입문\n" "\n" -"이 게임에서는 자연수 `{0,1,2,3,4,...}`의 기본 이론을 기초부터 만들어 갑니다. 첫 목표는 `2 + 2 = 4`을 증명하는 것입니다. 다음으로는 `x + y = y + x`를 증명합니다. 마지막에는 페르마의 마지막 정리를 증명할 수 있는지 보겠습니다. Lean이라는 컴퓨터 퍼즐 게임의 level들을 풀면서 진행합니다.\n" +"이 게임에서는 자연수 `{0,1,2,3,4,...}`의 기본 이론을 기초부터 만들어 갑니다. 첫 목표는 `2 + 2 = 4`을 증명하는 것입니다. 다음으로는 `x + y = y + x`를 증명합니다. 마지막에는 페르마의 마지막 정리를 증명할 수 있는지 보겠습니다. Lean이라는 컴퓨터 퍼즐 게임의 레벨들을 풀면서 진행합니다.\n" "\n" "# 일러두기\n" "\n" "대화형 정리 증명기를 사용하는 법을 익히는 데에는 시간이 걸립니다. 테스트 결과 이 게임을 가장 잘 활용하는 사람들은 이런 도움말을 꼼꼼히 읽는 사람들이었습니다.\n" "\n" -"시작하려면 “튜토리얼 세계”를 클릭하세요.\n" +"시작하려면 “튜토리얼 월드”를 클릭하세요.\n" "\n" "참고: 이것은 새로운 Lean 4 버전으로, 예전 Lean 3 버전에는 없던 여러 월드가 포함되어 있습니다. 강한 귀납법 월드, 홀짝 월드, 소수 월드 같은 새로운 월드도 개발 중입니다. 진행 상황을 보거나 직접 돕고 싶다면 [GitHub repo의 issues](https://github.com/leanprover-community/NNG4/issues)를 확인하세요.\n" "\n" @@ -2143,11 +2157,11 @@ msgid "" msgstr "" "# 요약\n" "\n" -"`decide`는 실행 가능한 알고리즘을 찾을 수 있다면 그 알고리즘으로 goal을 해결하려 시도합니다.\n" +"`decide`는 실행 가능한 알고리즘을 찾을 수 있다면 그 알고리즘으로 목표를 해결하려 시도합니다.\n" "\n" "## 예시\n" "\n" -"`DecidableEq ℕ` 타입의 항은 두 자연수가 같은지 다른지를 판정하는 알고리즘입니다. 따라서 이 항을 만들고 `instance`로 등록하면 `decide` tactic이 `a = b`나 `a ≠ b` 꼴의 goal을 해결하는 데 사용할 수 있습니다." +"`DecidableEq ℕ` 타입의 항은 두 자연수가 같은지 다른지를 판정하는 알고리즘입니다. 따라서 이 항을 만들고 `instance`로 등록하면 `decide` 택틱이 `a = b`나 `a ≠ b` 꼴의 목표를 해결하는 데 사용할 수 있습니다." #: Game.Levels.Implication.L04succ_inj msgid "" @@ -2174,12 +2188,12 @@ msgid "" "`simp only [add_assoc, add_left_comm, add_comm]`.\n" "Try running `simp_add` to solve this level!" msgstr "" -"Lean에서는 자신만의 tactic을 만들 수 있습니다. 여기의 코드\n" +"Lean에서는 자신만의 택틱을 만들 수 있습니다. 여기의 코드\n" "```\n" "macro \"simp_add\" : tactic => `(tactic|(\n" " simp only [add_assoc, add_left_comm, add_comm]))\n" "```\n" -"로 새로운 tactic `simp_add`을 만들었고, 이 tactic은 `simp only [add_assoc, add_left_comm, add_comm]`를 실행합니다. `simp_add`을 실행해서 이 level을 해결해 보세요!" +"로 새로운 택틱 `simp_add`을 만들었고, 이 택틱은 `simp only [add_assoc, add_left_comm, add_comm]`를 실행합니다. `simp_add`을 실행해서 이 레벨을 해결해 보세요!" #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -2206,7 +2220,7 @@ msgid "" msgstr "" "좋습니다!\n" "\n" -"순서론에서 다음 단계는 `≤`와 곱셈이 어떻게 상호작용하는지 알아보는 것입니다. Multiplication World를 이미 끝냈다면 이제 Advanced Multiplication World에 도전할 준비가 되었습니다. \"Home\"을 눌러 이동하세요." +"순서론에서 다음 단계는 `≤`와 곱셈이 어떻게 상호작용하는지 알아보는 것입니다. 곱셈 월드를 이미 끝냈다면 이제 고급 곱셈 월드에 도전할 준비가 되었습니다. \"홈\"을 눌러 이동하세요." #: Game.Levels.Multiplication.L07mul_add msgid "" @@ -2225,7 +2239,7 @@ msgid "" msgstr "" "# 개요\n" "\n" -"Lean의 simplifier `simp`는 `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다. 또 `add_comm` 같은 lemma를 주면 무한 루프를 피하기 위해 변수들을 내부적인 순서에 맞춰 정렬하려고 합니다." +"Lean의 simplifier `simp`는 `simp` 태그가 붙은 모든 정리와 사용자가 넣어 준 모든 정리를 가능한 한 계속 rewrite합니다. 또 `add_comm` 같은 정리를 주면 무한 루프를 피하기 위해 변수들을 내부적인 순서에 맞춰 정렬하려고 합니다." #: Game.Levels.Algorithm.L04add_algo3 msgid "" @@ -2236,7 +2250,7 @@ msgid "" msgstr "" "# 개요\n" "\n" -"직접 만든 tactic `simp_add`는 `a + (b + c) + (d + e) = e + (d + (c + b)) + a` 꼴의 임의의 goal을 해결합니다." +"직접 만든 택틱 `simp_add`는 `a + (b + c) + (d + e) = e + (d + (c + b)) + a` 꼴의 임의의 목표를 해결합니다." #: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro #: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ @@ -2266,24 +2280,26 @@ msgid "" "\n" "`a = b`." msgstr "" -"# Summary\n" +"# 요약\n" "\n" -"If you have a hypothesis\n" +"다음과 같은 가정\n" "\n" "`h : a ≠ b`\n" "\n" -"and goal\n" +"과 목표\n" "\n" "`c ≠ d`\n" "\n" -"then `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\n" -"a hypothesis\n" +"가 있다고 합시다. 그러면 `contrapose! h`는 현재 상황을 이른바 \\\"대우\\\"로 바꿉니다. 즉,\n" +"가정은\n" "\n" "`h : c = d`\n" "\n" -"and goal\n" +"가 되고, 목표는\n" "\n" -"`a = b`." +"`a = b`\n" +"\n" +"가 됩니다." #: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero msgid "" @@ -2335,35 +2351,51 @@ msgid "" msgstr "" "# 요약\n" "\n" -"`tauto` tactic은 순수하게 논리만으로(즉 진리표만으로) 해결할 수 있는 모든 goal을 해결합니다.\n" +"`tauto` 택틱은 순수하게 논리만으로, 즉 진리표만으로 해결할 수 있는\n" +"모든 목표를 해결합니다.\n" "\n" "## 자세한 설명\n" "\n" -"`tauto`은 *마법을 쓰지 않습니다*! 덧셈이나 곱셈에 대해서는 *아무것도* 모르고, `add_zero`조차 모릅니다. `tauto`이 수에 대해 아는 것은 첫째 `a = a`이고, 둘째 `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` 등이 있다는 것뿐입니다. `tauto`의 강점은 *논리*입니다. 가정 `x < 37`와 가정 `tauto`0이 있고 goal이 `tauto`1이라면 `tauto`2가 해결합니다. 부등식이나 덧셈에 관한 사실은 하나도 필요 없고 논리의 규칙만 알면 되기 때문입니다.\n" +"`tauto`는 *마법을 쓰지 않습니다*! 덧셈이나 곱셈에 대해서는 *아무것도*\n" +"모르며, 심지어 `add_zero`도 모릅니다. `tauto`가 수에 대해 아는 것은\n" +"첫째로 `a = a`라는 것과, 둘째로 `0 ≠ 1`, `0 ≠ 2`, `1 ≠ 2` 등이\n" +"성립한다는 것뿐입니다. `tauto`의 강점은 *논리*입니다. 가정 `x < 37`과\n" +"또 다른 가정 `x < 37 → y + z = 42`가 있고 목표가 `y + z = 42`라면,\n" +"`tauto`는 이 목표를 해결합니다. 이 목표를 해결하는 데에는 부등식이나\n" +"덧셈에 관한 어떤 사실도 필요하지 않고, 논리의 규칙만 알면 되기 때문입니다.\n" "\n" "## 예시\n" "\n" -"가정 `tauto`3이 있으면 `tauto`4가 goal을 해결합니다. 거짓 가정에서는 어떤 명제든 따라오기 때문입니다.\n" +"가정으로 `False`가 주어져 있다면 `tauto`는 목표를 해결합니다.\n" +"거짓인 가정으로부터는 어떤 명제든 따라오기 때문입니다.\n" "\n" "## 예시\n" "\n" -"goal이 `tauto`5라면 `tauto`6이 해결합니다.\n" +"목표가 `True`라면 `tauto`는 목표를 해결합니다.\n" "\n" "## 예시\n" "\n" -"가정 `tauto`7과 `tauto`8이 있으면 `tauto`9가 goal을 해결합니다. 두 가정에서 `add_zero`0을 증명할 수 있고, `add_zero`1은 무엇이든 함의하기 때문입니다.\n" +"두 가정 `h1 : a = 37`과 `h2 : a ≠ 37`이 있다면 `tauto`는\n" +"목표를 해결합니다. 이 가정들로부터 `False`를 증명할 수 있고,\n" +"`False`에서는 무엇이든 따라오므로 목표도 증명할 수 있기 때문입니다.\n" "\n" "## 예시\n" "\n" -"가정 `add_zero`2 하나만 있어도 `add_zero`3이 goal을 해결합니다. `add_zero`4는 `add_zero`5가 참이라는 것을 알아내 모순을 얻을 수 있을 만큼 영리합니다.\n" +"가정 `h : a ≠ a`가 하나 있다면 `tauto`는 목표를 해결합니다.\n" +"`tauto`는 `a = a`가 참이라는 것을 알 만큼 영리하므로, 여기서 필요한\n" +"모순을 얻을 수 있기 때문입니다.\n" "\n" "## 예시\n" "\n" -"가정 `add_zero`6이 있으면 `add_zero`7이 goal을 해결합니다. `add_zero`8은 `add_zero`9를 알고 있고 이것으로 `tauto`0을 증명할 수 있으며, `tauto`0에서는 어떤 goal이든 따라옵니다.\n" +"가정 `h : 0 = 1`이 있다면 `tauto`는 목표를 해결합니다.\n" +"`tauto`는 `0 ≠ 1`을 알고 있으므로 `False`를 증명할 수 있고,\n" +"`False`에서는 어떤 목표든 따라오기 때문입니다.\n" "\n" "## 예시\n" "\n" -"`tauto`1 꼴의 가정이 있고 goal이 `tauto`2라면 `tauto`3이 해결합니다. goal이 가정과 논리적으로 동치이기 때문입니다. 이 예시에서 goal과 가정을 뒤바꿔도 `tauto`4가 해결합니다." +"`a = 0 → a * b = 0` 꼴의 가정이 있고 목표가 `a * b ≠ 0 → a ≠ 0`이라면,\n" +"`tauto`는 목표를 해결합니다. 목표가 가정과 논리적으로 동치이기 때문입니다.\n" +"이 예시에서 목표와 가정을 서로 뒤바꾸어도 `tauto`는 해결할 수 있습니다." #: Game.Levels.Algorithm.L06is_zero msgid "" @@ -2373,7 +2405,7 @@ msgid "" msgstr "" "# 요약\n" "\n" -"`trivial`는 goal `True`을 해결합니다." +"`trivial`는 목표 `True`을 해결합니다." #: Game.Levels.Tutorial.L06add_zero2 msgid "" @@ -2387,7 +2419,7 @@ msgid "" msgstr "" "## 정밀한 rewriting\n" "\n" -"지난 level에는 `b + 0`와 `c + 0`이 있었고, `rw [add_zero]`는 처음 발견한 `b + 0`을 바꿨습니다. 이제 `add_zero`에 입력을 명시해서 Lean에게 `c + 0`를 먼저 바꾸라고 지시하는 법을 배워 봅시다." +"지난 레벨에는 `b + 0`와 `c + 0`이 있었고, `rw [add_zero]`는 처음 발견한 `b + 0`을 바꿨습니다. 이제 `add_zero`에 입력을 명시해서 Lean에게 `c + 0`를 먼저 바꾸라고 지시하는 법을 배워 봅시다." #: Game.Levels.Tutorial.L02rw msgid "" @@ -2404,11 +2436,11 @@ msgid "" msgstr "" "## 요약\n" "\n" -"`h : X = Y`이고 goal에 `X`이 여러 개 있다면 `nth_rewrite 3 [h]`는 세 번째 `X`만 `Y`로 바꿉니다.\n" +"`h : X = Y`이고 목표에 `X`이 여러 개 있다면 `nth_rewrite 3 [h]`는 세 번째 `X`만 `Y`로 바꿉니다.\n" "\n" "## 예시\n" "\n" -"goal이 `2 + 2 = 4`라면 `nth_rewrite 2 [two_eq_succ_one]`은 goal을 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 goal을 `succ 1 + succ 1 = 4`로 바꿉니다." +"목표가 `2 + 2 = 4`라면 `nth_rewrite 2 [two_eq_succ_one]`은 목표를 `2 + succ 1 = 4`로 바꿉니다. 반면 `rw [two_eq_succ_one]`은 목표를 `succ 1 + succ 1 = 4`로 바꿉니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow @@ -2642,25 +2674,36 @@ msgid "" msgstr "" "## 요약\n" "\n" -"`n`가 수라면 `cases n with d`은 goal을 둘로 나눕니다. 하나에서는 `n = 0`이고 다른 하나에서는 `n = succ d`입니다.\n" +"`n`이 수라면 `cases n with d`는 목표를 두 개로 나눕니다.\n" +"하나는 `n = 0`인 경우이고, 다른 하나는 `n = succ d`인 경우입니다.\n" "\n" -"`h`가 증명(예: 가정)이라면 `cases h with...`는 그 증명을 구성한 조각들로 분해합니다.\n" +"`h`가 증명(예를 들어 가정)이라면 `cases h with...`는 그 증명을\n" +"구성하는 데 사용된 부분들로 분해합니다.\n" "\n" "## 예시\n" "\n" -"`n : ℕ`가 수라면 `cases n with d`은 goal을 두 개로 나눕니다. 하나에서는 `n`이 0으로 바뀌고, 다른 하나에서는 `n`가 `cases n with d`0으로 바뀝니다. 이는 모든 자연수가 `cases n with d`1이거나 successor라는 수학적 생각에 해당합니다.\n" +"`n : ℕ`이 수라면 `cases n with d`는 목표를 두 개로 나눕니다.\n" +"하나에서는 `n`이 `0`으로 바뀌고, 다른 하나에서는 `n`이 `succ d`로\n" +"바뀝니다. 이는 모든 자연수가 `0`이거나 어떤 자연수의 후속자라는\n" +"수학적 사실에 해당합니다.\n" "\n" "## 예시\n" "\n" -"`cases n with d`2가 가정이라면 `cases n with d`3은 하나의 goal을 두 goal로 바꿉니다. 하나에는 가정 `cases n with d`4가 있고 다른 하나에는 가정 `cases n with d`5가 있습니다.\n" +"`h : P ∨ Q`가 가정이라면 `cases h with hp hq`는 하나의 목표를\n" +"두 개의 목표로 바꿉니다. 하나에는 가정 `hp : P`가 있고,\n" +"다른 하나에는 가정 `hq : Q`가 있습니다.\n" "\n" "## 예시\n" "\n" -"`cases n with d`6가 가정이라면 `cases n with d`7은 goal 하나를 goal 0개로 바꿉니다. `cases n with d`8의 증명을 만드는 방법이 없기 때문입니다! goal이 하나도 남지 않으면 level을 끝낸 것입니다.\n" +"`h : False`가 가정이라면 `cases h`는 하나의 목표를 목표 0개로\n" +"바꿉니다. `False`의 증명을 만드는 방법은 없기 때문입니다!\n" +"목표가 하나도 남지 않았다면 레벨을 끝낸 것입니다.\n" "\n" "## 예시\n" "\n" -"`cases n with d`9가 가정이라면 `n = 0`0은 새 수 `n = 0`1과 증명 `n = 0`2를 만듭니다. `n = 0`3의 *정의*가 `n = 0`4이기 때문입니다." +"`h : a ≤ b`가 가정이라면 `cases h with c hc`는 새로운 수 `c`와\n" +"증명 `hc : b = a + c`를 만듭니다. 이는 `a ≤ b`의 *정의*가\n" +"`∃ c, b = a + c`이기 때문입니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow @@ -2689,29 +2732,29 @@ msgid "" "If the goal is `a * b = 7`, then `apply succ_inj` will turn the\n" "goal into `succ (a * b) = succ 7`." msgstr "" -"## Summary\n" +"## 요약\n" "\n" -"If `t : P → Q`는 $P \\implies Q$, and `h : P` is a proof of `P`,\n" -"then `apply t at h` will change `h` to a proof of `Q`. The idea is that if\n" -"you know `P` is true, then you can deduce from `t` that `Q` is true.\n" +"`t : P → Q`가 $P \\implies Q$의 증명이고, `h : P`가 `P`의 증명이라고 합시다.\n" +"그러면 `apply t at h`는 `h`를 `Q`의 증명으로 바꿉니다. 아이디어는 간단합니다.\n" +"`P`가 참이라는 것을 알고 있다면, `t`를 이용해 `Q`도 참이라고 결론낼 수 있습니다.\n" "\n" -"If the *goal* is `Q`, then `apply t` will \\\"argue backwards\\\" and change the\n" -"goal to `P`. The idea here is that if you want to prove `Q`, then by `t`\n" -"it suffices to prove `P`, so you can reduce the goal to proving `P`.\n" +"*목표*가 `Q`라면, `apply t`는 이 논증을 \\\"거꾸로\\\" 적용하여 목표를 `P`로 바꿉니다.\n" +"`Q`를 증명하고 싶을 때 `t`에 의해 `P`만 증명하면 충분하므로, 목표를 `P`의 증명으로\n" +"줄일 수 있다는 뜻입니다.\n" "\n" -"### Example:\n" +"### 예시:\n" "\n" -"`succ_inj x y` is a proof that `succ x = succ y → x = y`.\n" +"`succ_inj x y`는 `succ x = succ y → x = y`의 증명입니다.\n" "\n" -"So if you have a hypothesis `h : succ (a + 37) = succ (b + 42)`\n" -"then `apply succ_inj at h` will change `h` to `a + 37 = b + 42`.\n" -"You could write `apply succ_inj (a + 37) (b + 42) at h`\n" -"but Lean is smart enough to figure out the inputs to `succ_inj`.\n" +"따라서 가정 `h : succ (a + 37) = succ (b + 42)`가 있다면,\n" +"`apply succ_inj at h`는 `h`를 `a + 37 = b + 42`의 증명으로 바꿉니다.\n" +"`apply succ_inj (a + 37) (b + 42) at h`라고 직접 써도 되지만,\n" +"Lean은 `succ_inj`에 들어갈 입력을 스스로 알아낼 만큼 똑똑합니다.\n" "\n" -"### Example\n" +"### 예시\n" "\n" -"If the goal is `a * b = 7`, then `apply succ_inj` will turn the\n" -"goal into `succ (a * b) = succ 7`.의 증명입니다." +"목표가 `a * b = 7`이라면, `apply succ_inj`는 목표를\n" +"`succ (a * b) = succ 7`로 바꿉니다." #: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm #: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred @@ -2741,29 +2784,29 @@ msgid "" "and `rw [add_zero x]` will both change the goal to `x = x`,\n" "because `rw` guesses the input to the function `add_zero`." msgstr "" -"## Summary\n" +"## 요약\n" "\n" -"If the goal is a statement `P`, then `exact h` will close the goal if `h`는 `P`.\n" +"목표가 명제 `P`라면, `h`가 `P`의 증명일 때 `exact h`로 목표를 닫을 수 있습니다.\n" "\n" -"### Example\n" +"### 예시\n" "\n" -"If the goal is `x = 37` and you have a hypothesis `h : x = 37`\n" -"then `exact h` will solve the goal.\n" +"목표가 `x = 37`이고 가정 `h : x = 37`이 있다면,\n" +"`exact h`로 목표를 해결할 수 있습니다.\n" "\n" -"### Example\n" +"### 예시\n" "\n" -"If the goal is `x + 0 = x` then `exact add_zero x` will close the goal.\n" +"목표가 `x + 0 = x`라면 `exact add_zero x`로 목표를 닫을 수 있습니다.\n" "\n" -"### Exact needs to be exactly right\n" +"### Exact는 정확히 맞아야 합니다\n" "\n" -"Note that `exact add_zero` will *not work* in the previous example;\n" -"for `exact h` to work, `h` has to be *exactly* a proof of the goal.\n" -"`add_zero` is a proof of `∀ n, n + 0 = n` or, if you like,\n" -"a proof of `? + 0 = ?` where `?` needs to be supplied by the user.\n" -"This is in contrast to `rw` and `apply`, which will \\\"guess the inputs\\\"\n" -"if necessary. If the goal is `x + 0 = x` then `rw [add_zero]`\n" -"and `rw [add_zero x]` will both change the goal to `x = x`,\n" -"because `rw` guesses the input to the function `add_zero`의 증명입니다." +"앞의 예시에서 `exact add_zero`는 *작동하지 않습니다*.\n" +"`exact h`가 작동하려면 `h`가 목표의 *정확한* 증명이어야 합니다.\n" +"`add_zero`는 `∀ n, n + 0 = n`의 증명입니다. 또는 원한다면,\n" +"사용자가 `?`에 들어갈 값을 지정해야 하는 `? + 0 = ?`의 증명이라고 생각해도 됩니다.\n" +"이는 필요할 경우 입력값을 \\\"추측\\\"하는 `rw`나 `apply`와는 다릅니다.\n" +"목표가 `x + 0 = x`라면 `rw [add_zero]`와 `rw [add_zero x]`는\n" +"둘 다 목표를 `x = x`로 바꿉니다. `rw`가 함수 `add_zero`에 들어갈\n" +"입력값을 추측하기 때문입니다." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -2785,17 +2828,17 @@ msgid "" "- `use a`\n" "- `use a * a + 1`" msgstr "" -"## Summary\n" +"## 요약\n" "\n" -"The `use` tactic makes progress with goals which claim something *exists*.\n" -"If the goal claims that some `x` exists with some property, and you know\n" -"that `x = 37` will work, then `use 37` will make progress.\n" +"`use` 택틱은 어떤 것이 *존재한다*고 주장하는 목표를 진행할 때 사용합니다.\n" +"목표가 어떤 성질을 만족하는 `x`가 존재한다고 주장하고, `x = 37`이면 된다는 것을 알고 있다면,\n" +"`use 37`을 사용해 진행할 수 있습니다.\n" "\n" -"Because `a ≤ b` is notation for \\\"there exists `c` such that `b = a + c`\\\",\n" -"you can make progress on goals of the form `a ≤ b` by `use`ing the\n" -"number which is morally `b - a` (i.e. `use b - a`)\n" +"`a ≤ b`는 \\\"`b = a + c`를 만족하는 `c`가 존재한다\\\"는 뜻의 표기이므로,\n" +"`a ≤ b` 꼴의 목표에서는 직관적으로 `b - a`에 해당하는 수를 `use`하여\n" +"진행할 수 있습니다. 즉 `use b - a`와 같은 식입니다.\n" "\n" -"Any of the following examples is possible assuming the type of the argument passed to the `use` function is accurate:\n" +"`use`에 넘기는 항의 타입만 올바르다면 다음과 같은 예시를 사용할 수 있습니다:\n" "\n" "- `use 37`\n" "- `use a`\n" @@ -2838,38 +2881,37 @@ msgid "" "to type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\n" "as mathematicians are concerned, and who cares what the definition of addition is).*" msgstr "" -"## Summary\n" +"## 요약\n" "\n" -"`rfl` proves goals of the form `X = X`.\n" +"`rfl`은 `X = X` 꼴의 목표를 증명합니다.\n" "\n" -"In other words, the `rfl` tactic will close any goal of the\n" -"form `A = B` if `A` and `B` are *identical*.\n" +"즉 `A`와 `B`가 *동일한* 항이라면 `rfl` 택틱은\n" +"`A = B` 꼴의 모든 목표를 닫습니다.\n" "\n" -"`rfl` is short for \\\"reflexivity (of equality)\\\".\n" +"`rfl`은 \\\"reflexivity (of equality)\\\"의 줄임말입니다.\n" "\n" -"## Example:\n" +"## 예시:\n" "\n" -"If the goal looks like this:\n" +"목표가 다음과 같이 생겼다면:\n" "\n" "```\n" "x + 37 = x + 37\n" "```\n" "\n" -"then `rfl` will close it. But if it looks like `0 + x = x` then `rfl` won't work, because even\n" -"though $0+x$ and $x$ are always equal as *numbers*, they are not equal as *terms*.\n" -"The only term which is identical to `0 + x` is `0 + x`.\n" +"`rfl`로 목표를 닫을 수 있습니다. 하지만 목표가 `0 + x = x`라면 `rfl`은 작동하지 않습니다.\n" +"$0+x$와 $x$는 *수로서는* 항상 같지만, *항으로서는* 동일하지 않기 때문입니다.\n" +"`0 + x`와 동일한 항은 `0 + x`뿐입니다.\n" "\n" -"## Details\n" +"## 자세한 설명\n" "\n" -"`rfl` is short for \\\"reflexivity of equality\\\".\n" +"`rfl`은 \\\"reflexivity of equality(등호의 반사성)\\\"의 줄임말입니다.\n" "\n" -"## Game Implementation\n" +"## 게임 구현\n" "\n" -"*Note that our `rfl` is weaker than the version used in core Lean and `mathlib`,\n" -"for pedagogical purposes; mathematicians do not distinguish between propositional\n" -"and definitional equality because they think about definitions in a different way\n" -"to type theorists (`zero_add` and `add_zero` are both \\\"facts\\\" as far\n" -"as mathematicians are concerned, and who cares what the definition of addition is).*" +"*교육적 목적 때문에 이 게임의 `rfl`은 core Lean과 `mathlib`에서 사용하는 버전보다 약합니다.\n" +"수학자들은 명제적 동등성과 정의적 동등성을 잘 구분하지 않는데, 이는 타입 이론자들과\n" +"정의를 바라보는 방식이 다르기 때문입니다. 수학자에게 `zero_add`와 `add_zero`는 둘 다\n" +"그저 \\\"사실\\\"이고, 덧셈을 정확히 어떻게 정의했는지는 별로 중요하지 않습니다.*" #: Game.Levels.Tutorial.L03two_eq_ss0 msgid "" @@ -2900,17 +2942,17 @@ msgstr "" "Lean의 수는 두 규칙으로 정의됩니다.\n" "\n" "* `0`는 수입니다.\n" -"* `n`이 수라면 `n`의 *successor* `succ n`도 수입니다.\n" +"* `n`이 수라면 `n`의 *다음수* `succ n`도 수입니다.\n" "\n" -"`n`의 successor란 `n` 다음의 수를 뜻합니다. 이제 세는 법을 배우고 작은 수 몇 개에 이름을 붙여 봅시다.\n" +"`n`의 다음수란 `n+1`을 뜻합니다. 이제 세는 법을 배우고 작은 수 몇 개에 이름을 붙여 봅시다.\n" "\n" "## 4까지 세기\n" "\n" -"`0`는 수이므로 `succ 0`도 수입니다. 이 새 수를 `1`이라고 부릅시다. 같은 방식으로 `2 = succ 1`, `n`0, `n`1을 정의합니다. 이 정도면 당분간 쓸 수가 충분합니다.\n" +"`0`는 수이므로 `succ 0`도 수입니다. 이 새 수를 `1`이라고 부릅시다. 같은 방식으로 `2 = succ 1`, `3 = succ 2`, `4 = succ 3`을 정의하겠습니다. 이 정도면 당분간 쓸 수가 충분합니다.\n" "\n" -"`n`2의 *증명*은 `n`3이라고 부릅니다. 오른쪽 lemma 목록의 \"012\" 탭에서 이 증명과 다른 증명들을 확인하세요.\n" +"`2 = succ 1`의 *증명*은 `two_eq_succ_one`이라고 부릅니다. 오른쪽 정리 목록의 \"012\" 탭에서 이 증명과 다른 증명들을 확인하세요.\n" "\n" -"`n`4가 0 다음의 다음 수라는 것을 증명해 봅시다." +"`$2$가 0의 다음 수의 다음 수라는 것을 증명해 봅시다." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -3120,9 +3162,9 @@ msgstr "" "## 크레딧\n" "\n" "* **제작:** Kevin Buzzard, Jon Eugster\n" -"* **원래 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n" +"* **오리지널 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n" "* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" -"* **추가 level:** Sian Carey, Ivan Farabella, Archie Browne\n" +"* **추가 레벨:** Sian Carey, Ivan Farabella, Archie Browne\n" "* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n" "\n" "## 자료\n" @@ -3200,14 +3242,14 @@ msgstr "" "\n" "게임은 진행 상황을 브라우저의 로컬 스토리지에 저장합니다. 이를 삭제하면 진행 상황도 사라집니다!\n" "\n" -"주의: 대부분의 브라우저에서 쿠키를 삭제하면 로컬 스토리지(또는 “로컬 사이트 “데이)도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n" +"주의: 대부분의 브라우저에서 쿠키를 삭제하면 로컬 스토리지(또는 \"로컬 사이트 데이터\")도 함께 지워집니다. 먼저 게임 진행 상황을 다운로드해 두세요!\n" "\n" "## 크레딧\n" "\n" "* **제작:** Kevin Buzzard, Jon Eugster\n" "* **원래 Lean3 버전:** Kevin Buzzard, Mohammad Pedramfar\n" "* **게임 엔진:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" -"* **추가 level:** Sian Carey, Ivan Farabella, Archie Browne\n" +"* **추가 레벨:** Sian Carey, Ivan Farabella, Archie Browne\n" "* **추가 감사:** 학생 베타 테스터 여러분, Kevin을 초청해 강연을 들은 모든 학교, 그리고 내용에 대해 질문해 준 모든 학생들\n" "\n" "## 자료\n" @@ -3237,13 +3279,16 @@ msgid "" "2 + 2 ≠ 5 is boring to prove in full, given only the tools we have currently.\n" "To make it a bit less painful, I have unfolded all of the numerals for you.\n" "See if you can use `zero_ne_succ` and `succ_inj` to prove this." -msgstr "현재 가진 도구만으로 `zero_ne_succ`를 처음부터 증명하는 것은 꽤 지루합니다. 조금 덜 괴롭도록 숫자들을 모두 펼쳐 두었습니다. `zero_ne_succ`와 `succ_inj`을 이용해 증명해 보세요." +msgstr "" +"현재 가진 도구만으로 `2 + 2 ≠ 5`를 처음부터 증명하는 것은 꽤 지루합니다.\n" +"조금 덜 괴롭도록 숫자들을 모두 펼쳐 두었습니다.\n" +"`zero_ne_succ`와 `succ_inj`을 이용해 증명해 보세요." #: Game.Levels.LessOrEqual.L04le_trans msgid "" "A passing mathematician remarks that with reflexivity and transitivity out of the way,\n" "you have proved that `≤` is a *preorder* on `ℕ`." -msgstr "지나가던 수학자가 반사성과 추이성을 증명했으므로 `ℕ` 위의 `≤`가 *preorder*임을 증명했다고 말합니다." +msgstr "지나가던 수학자가 반사성과 추이성을 증명했으므로 `ℕ` 위의 `≤`가 *전순서(preorder)*임을 증명했다고 말합니다." #: Game.Levels.AdvAddition.L05add_right_eq_zero #: Game.Levels.AdvAddition.L06add_left_eq_zero @@ -3276,7 +3321,7 @@ msgstr "" "exact mul_left_cancel a b 1 ha h\n" "```\n" "\n" -"입니다. 이제 자연수의 나눗셈 가능성(divisibility)에 대한 기본 이론을 세울 도구가 모두 준비되었습니다." +"입니다. 이제 자연수의 나눗셈 가능성에 대한 기본 이론을 세울 준비가 되었습니다." #: Game.Levels.Tutorial.L05add_zero msgid "Adding zero" @@ -3299,11 +3344,11 @@ msgid "" "true under the additional hypothesis that one of the variables is non-zero.\n" "This causes some unexpected extra twists." msgstr "" -"Advanced *Addition* World에서는 `x + y = 0 → x = 0`와 `x + y = x → y = 0` 같은 덧셈 관련 여러 함의를 증명했습니다. 이 lemma들은 ≤ World에서 ≤의 기본 성질을 증명하는 데 사용되었습니다.\n" +"고급 *덧셈* 월드에서는 `x + y = 0 → x = 0`와 `x + y = x → y = 0` 같은 덧셈 관련 여러 조건문을 증명했습니다. 이 정리들은 ≤ 월드에서 ≤의 기본 성질을 증명하는 데 사용되었습니다.\n" "\n" -"Advanced Multiplication World에서는 이에 대응하는 곱셈 관련 사실, 예를 들어 `x * y = 1 → x = 1`와 `x * y = x → y = 1`(후자는 `x ≠ 0`를 가정)을 증명합니다. 이것이 Divisibility World를 준비해 줍니다.\n" +"고급 곱셈 월드에서는 이에 대응하는 곱셈 관련 사실, 예를 들어 `x * y = 1 → x = 1`와 `x * y = x → y = 1`(후자는 `x ≠ 0`를 가정)을 증명합니다. 이것이 나누어 떨어짐 월드를 준비해 줍니다.\n" "\n" -"Multiplication World는 Addition World보다 복잡합니다. 마찬가지로 Advanced Multiplication World도 Advanced Addition World보다 복잡합니다. 이유 중 하나는 몇몇 중간 결과가 변수 하나가 0이 아니라는 추가 가정 아래에서만 참이기 때문입니다. 그래서 예상하지 못한 꼬임이 몇 번 생깁니다." +"곱셈 월드는 덧셈 월드보다 복잡합니다. 마찬가지로 고급 곱셈 월드도 고급 덧셈 월드보다 복잡합니다. 이유 중 하나는 몇몇 중간 결과가 변수 하나가 0이 아니라는 추가 가정 아래에서만 참이기 때문입니다. 그래서 예상하지 못한 꼬임이 몇 번 생깁니다." #: Game.Levels.AdvMultiplication msgid "Advanced Multiplication World" @@ -3317,7 +3362,7 @@ msgstr "알고리즘 월드" msgid "" "Although $0^0=1$ in this game, $0^n=0$ if $n>0$, i.e., if\n" "$n$ is a successor." -msgstr "이 게임에서는 $0^0=1$이지만, $n>0$라면, 즉 $n$가 successor라면 $0^n=0$입니다." +msgstr "이 게임에서는 $0^0=1$이지만, $n>0$라면, 즉 $n$가 다음수라면 $0^n=0$입니다." #: Game.Levels.Algorithm.L07succ_ne_succ msgid "An algorithm for equality" @@ -3335,13 +3380,13 @@ msgstr "그리고 이제 `rw [add_zero]`." msgid "" "And now we've deduced what we wanted to prove: the goal is one of our assumptions.\n" "Finish the level with `exact h`." -msgstr "이제 우리가 증명하고 싶던 것을 이끌어냈습니다. goal이 가정 중 하나입니다. `exact h`로 level을 마무리하세요." +msgstr "이제 우리가 증명하고 싶던 것을 이끌어냈습니다. 목표가 가정 중 하나입니다. `exact h`로 레벨을 마무리하세요." #: Game.Levels.Implication.L05succ_inj2 msgid "" "Applying a proof of $P\\implies Q$ to the *goal* changes $Q$ to $P$.\n" "Now try `rw [succ_eq_add_one]` to make the goal more like the hypothesis." -msgstr "$P\\implies Q$의 증명을 *goal*에 적용하면 $Q$이 $P$로 바뀝니다. 이제 `rw [succ_eq_add_one]`을 사용해 goal을 가정과 더 비슷하게 만들어 보세요." +msgstr "$P\\implies Q$의 증명을 *goal*에 적용하면 $Q$이 $P$로 바뀝니다. 이제 `rw [succ_eq_add_one]`을 사용해 목표를 가정과 더 비슷하게 만들어 보세요." #: Game.Levels.Implication.L02exact2 msgid "Assuming $0+x=(0+y)+2$, we have $x=y+2$." @@ -3355,7 +3400,7 @@ msgstr "이제 항 `0 + «{d}»`가 보이므로 `rw [«{hd}»]`과 함께 귀 #: Game.Levels.Tutorial.L04rw_backwards msgid "Can you now change the goal into `2 = 2`?" -msgstr "이제 goal을 `2 = 2`로 바꿀 수 있나요?" +msgstr "이제 목표를 `2 = 2`로 바꿀 수 있나요?" #: Game.Levels.Tutorial.L03two_eq_ss0 msgid "Can you take it from here?" @@ -3380,9 +3425,9 @@ msgid "" msgstr "" "축하합니다! 첫 번째 검증된 증명을 완성했습니다!\n" "\n" -"`rfl`가 *tactic*이라는 점을 기억하세요. `rfl` tactic에 대해 궁금하면 오른쪽 tactic 목록의 `rfl`를 클릭하면 됩니다.\n" +"`rfl`가 *택틱*이라는 점을 기억하세요. `rfl` 택틱에 대해 궁금하면 오른쪽 택틱 목록의 `rfl`를 클릭하면 됩니다.\n" "\n" -"이제 \"Next\"를 눌러 `rw` tactic을 배워 봅시다." +"이제 \"Next\"를 눌러 `rw` 택틱을 배워 봅시다." #: Game.Levels.Power.L10FLT msgid "" @@ -3416,7 +3461,7 @@ msgid "" "```" msgstr "" "`y`에 대해 귀납법을 썼나요?\n" -"`add_right_cancel`를 사용하는 `add_left_eq_self`의 두 줄짜리 증명은 다음과 같습니다. 살펴보고 싶다면 오른쪽 위의 ``을 눌러 editor mode로 들어간 뒤 증명을 복사해 붙여 넣고 커서를 옮기면서 각 지점의 가정과 goal을 확인할 수 있습니다(다만 이 과정에서 자신의 증명은 사라집니다). `>_`를 누르면 command line mode로 돌아옵니다.\n" +"`add_right_cancel`를 사용하는 `add_left_eq_self`의 두 줄짜리 증명은 다음과 같습니다. 살펴보고 싶다면 오른쪽 위의 ``을 눌러 편집기 모드로 들어간 뒤 증명을 복사해 붙여 넣고 커서를 옮기면서 각 지점의 가정과 목표를 확인할 수 있습니다(다만 이 과정에서 자신의 증명은 사라집니다). `>_`를 누르면 command line mode로 돌아옵니다.\n" "```\n" "nth_rewrite 2 [← zero_add y]\n" "exact add_right_cancel x 0 y\n" @@ -3462,13 +3507,15 @@ msgid "" "`012` (numerals) tabs under \"Theorems\" on the right to\n" "see which proofs you can rewrite." msgstr "" -"Lean의 모든 수는 $0$이거나 successor입니다. $0$을 더하는 법은 알지만 successor를 더하는 법은 아직 모릅니다. 이미 `37 + d = q`를 안다고 합시다. 그렇다면 `37 + succ d`의 답은 무엇이어야 할까요? `succ d`는 `d`보다 1 큰 수이므로 `37 + succ d`는 `succ q`, 즉 `q`보다 1 큰 수여야 합니다. 더 일반적으로 `x + succ d`는 $0$0이어야 합니다. 이를 lemma로 추가합시다.\n" +"Lean의 모든 수는 $0$이거나 다음수입니다. $0$을 더하는 법은 알지만 다음수를 더하는 법은 아직 모릅니다.\n" +"이미 `37 + d = q`를 안다고 합시다. 그렇다면 `37 + succ d`의 답은 무엇이어야 할까요? `succ d`는 `d`보다 1 큰\n" +"수이므로 `37 + succ d`는 `succ q`, 즉 `q`보다 1 큰 수여야 합니다. 더 일반적으로 `x + succ d`는 `succ (x + d)`이어야 합니다. 이를 정리로 추가합시다.\n" "\n" -"* $0$1\n" +"* `add_succ x d : x + succ d = succ (x + d)`\n" "\n" -"goal에서 $0$2를 보게 되면 보통 $0$3을 쓰는 것이 좋은 생각입니다.\n" +"목표에서 `... + succ ...`를 보게 되면 보통 `rw [add_succ]`을 쓰는 것이 좋은 생각입니다.\n" "\n" -"이제 $0$4를 증명해 봅시다. 먼저 $0$5를 끌어들이는 방법을 찾고, 이어서 $0$6을 사용하세요. 오른쪽 \"Theorems\" 아래의 $0$7(덧셈) 탭과 $0$8(숫자) 탭을 오가며 어떤 증명으로 rewrite할 수 있는지 확인하세요." +"이제 `succ n = n + 1`를 증명해 봅시다. 먼저 `+ succ`를 화면에 띄우는 방법을 찾고, 이어서 `rw [add_succ]`을 사용하세요. 오른쪽 \"정리\" 아래의 `+`(덧셈) 탭과 `012`(숫자) 탭을 오가며 어떤 증명으로 rewrite할 수 있는지 확인하세요." #: Game.Levels.Power.L10FLT msgid "Fermat's Last Theorem" @@ -3509,7 +3556,7 @@ msgstr "모든 자연수 $a$, $b$, $c$, $n$에 대해 $$(a+1)^{n+3}+(b+1)^{n+3}\ msgid "" "For all numbers $a$ and $b$, we have\n" "$$(a+b)^2=a^2+b^2+2ab.$$" -msgstr "모든 수 $a$와 $b$에 대해 $$(a+b)^2=a^2+b^2+2ab.$$입니다." +msgstr "모든 수 $a$와 $b$에 대해 $$(a+b)^2=a^2+b^2+2ab$$입니다." #: Game.Levels.Power.L02zero_pow_succ msgid "For all numbers $m$, $0 ^{\\operatorname{succ} (m)} = 0$." @@ -3592,9 +3639,9 @@ msgstr "" "rfl\n" "```\n" "\n" -"선택 사항: 이 증명을 직접 실행해 볼 수도 있습니다. 오른쪽 위의 `` 버튼을 눌러 게임을 \"Editor mode\"로 바꾸세요. 그러면 증명이 여러 줄의 코드로 보입니다. 줄 사이에 커서를 옮겨 각 지점의 goal state를 확인할 수 있습니다. 원한다면 코드를 다른 곳에 복사해 저장하고, 위 증명을 붙여 넣어 탐색해 보세요. 다 살펴봤으면 오른쪽 위의 `>_` 버튼을 눌러 \"Typewriter mode\"로 돌아가세요.\n" +"선택 사항: 이 증명을 직접 실행해 볼 수도 있습니다. 오른쪽 위의 `` 버튼을 눌러 게임을 \"편집기 모드\"로 바꾸세요. 그러면 증명이 여러 줄의 코드로 보입니다. 줄 사이에 커서를 옮겨 각 지점의 목표 상태를 확인할 수 있습니다. 원한다면 코드를 다른 곳에 복사해 저장하고, 위 증명을 붙여 넣어 탐색해 보세요. 다 살펴봤으면 오른쪽 위의 `>_` 버튼을 눌러 \"타자기 모드\"로 돌아가세요.\n" "\n" -"Tutorial World를 완료했습니다! \"Home\"을 눌러 overworld로 돌아간 뒤 Addition World를 선택하세요. 그곳에서 `induction` tactic을 배웁니다." +"튜토리얼 월드를 완료했습니다! \"홈\"을 눌러 홈 월드로 돌아간 뒤 덧셈 월드를 선택하세요. 그곳에서 `induction` 택틱을 배웁니다." #: Game.Levels.AdvAddition.L05add_right_eq_zero msgid "" @@ -3755,7 +3802,7 @@ msgstr "" "exact add_right_eq_zero b a\n" "```\n" "\n" -"Advanced Addition World는 여기까지입니다! 다음 `≤` World에서는 여기서 얻은 정리들이 필요합니다. \"Home\"을 눌러 이동하세요." +"고급 덧셈 월드는 여기까지입니다! 다음 `≤` 월드에서는 여기서 얻은 정리들이 필요합니다. \"홈\"을 눌러 이동하세요." #. repeat rw [add_comm n] #. exact add_right_cancel a b n @@ -3792,7 +3839,7 @@ msgid "" "we must also prove facts about how multiplication interacts with addition, like `a * (b + c) = a * b + a * c`.\n" "Let's get started." msgstr "" -"`37 * x`를 어떻게 정의해야 할까요? 덧셈과 마찬가지로 $x=0$일 때와 $x$가 successor일 때를 각각 정의해야 합니다.\n" +"`37 * x`를 어떻게 정의해야 할까요? 덧셈과 마찬가지로 $x=0$일 때와 $x$가 다음수일 때를 각각 정의해야 합니다.\n" "\n" "0인 경우는 쉽습니다. `37 * 0`을 `0`로 정의합니다. 이제 `37 * d`를 안다고 합시다. `37 * succ d`은 무엇이어야 할까요? 이는 $(d+1)$개의 $37$이므로 `37 * d + 37`여야 합니다.\n" "\n" @@ -3801,7 +3848,7 @@ msgstr "" " * $x=0$0\n" " * $x=0$1\n" "\n" -"이 world에서는 $x=0$2 같은 곱셈의 성질뿐 아니라 $x=0$3처럼 곱셈과 덧셈이 어떻게 상호작용하는지도 증명해야 합니다. 시작해 봅시다." +"이 월드에서는 $x=0$2 같은 곱셈의 성질뿐 아니라 $x=0$3처럼 곱셈과 덧셈이 어떻게 상호작용하는지도 증명해야 합니다. 시작해 봅시다." #: Game.Levels.Addition.L05add_right_comm msgid "" @@ -3813,7 +3860,7 @@ msgstr "$a, b$와 $c$이 임의의 자연수라면 $(a + b) + c = (a + c) + b$ msgid "" "If $a, b$, $c$ and $d$ are numbers, we have\n" "$(a + b) + (c + d) = ((a + c) + d) + b.$" -msgstr "$a, b$, $c$, $d$가 수라면 $(a + b) + (c + d) = ((a + c) + d) + b.$입니다." +msgstr "$a, b$, $c$, $d$가 수라면 $(a + b) + (c + d) = ((a + c) + d) + b$입니다." #: Game.Levels.Algorithm.L03add_algo2 Game.Levels.Algorithm.L04add_algo3 msgid "" @@ -3825,13 +3872,13 @@ msgstr "$a, b,\\ldots h$가 임의의 자연수라면 $(d + f) + (h + (a + c)) + msgid "" "If the goal is not *exactly* a hypothesis, we can sometimes\n" "use rewrites to fix things up." -msgstr "goal이 가정과 *정확히* 같지 않더라도 rewrite를 이용해 고칠 수 있는 경우가 있습니다." +msgstr "목표가 가정과 *정확히* 같지 않더라도 rewrite를 이용해 고칠 수 있는 경우가 있습니다." #: Game.Levels.LessOrEqual.L03le_succ_self msgid "" "If you `use` the wrong number, you get stuck with a goal you can't prove.\n" "What number will you `use` here?" -msgstr "잘못된 수를 `use`하면 증명할 수 없는 goal에 막힙니다. 여기서는 어떤 수를 `use`해야 할까요?" +msgstr "잘못된 수를 `use`하면 증명할 수 없는 목표에 막힙니다. 여기서는 어떤 수를 `use`해야 할까요?" #. instance instDecidableEq : DecidableEq ℕ #. | 0, 0 => isTrue <| by @@ -3909,11 +3956,11 @@ msgstr "" " exact succ_ne_succ m n h\n" "```\n" "\n" -"이 Lean 코드는 두 자연수의 동등성을 판정하는 형식 검증된 알고리즘입니다. 이미 뒤에서 입력해 두었습니다. 알고리즘의 정확성까지 형식적으로 검증되었으므로 Lean 증명에서 사용할 수 있습니다. `decide` tactic으로 이 알고리즘을 실행할 수 있습니다." +"이 Lean 코드는 두 자연수의 동등성을 판정하는 형식 검증된 알고리즘입니다. 이미 뒤에서 입력해 두었습니다. 알고리즘의 정확성까지 형식적으로 검증되었으므로 Lean 증명에서 사용할 수 있습니다. `decide` 택틱으로 이 알고리즘을 실행할 수 있습니다." #: Game.Levels.Implication msgid "Implication World" -msgstr "함의 월드" +msgstr "조건문 월드" #: Game.Levels.AdvAddition msgid "" @@ -3924,15 +3971,15 @@ msgid "" "\n" "Click on \"Start\" to proceed." msgstr "" -"Advanced Addition World에서는 $x+y=x\\implies y=0$ 같은 기본적인 덧셈의 성질을 증명합니다. 여기서 증명한 정리들은 `≤` World에서 부등식 이론을 만드는 데 사용됩니다.\n" +"고급 덧셈 월드에서는 $x+y=x\\implies y=0$ 같은 기본적인 덧셈의 성질을 증명합니다. 여기서 증명한 정리들은 `≤` 월드에서 부등식 이론을 만드는 데 사용됩니다.\n" "\n" -"\"Start\"를 눌러 진행하세요." +"\"시작하기\"를 눌러 진행하세요." #: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero msgid "" "In the \"base case\" we have a hypothesis `ha : 0 ≠ 0`, and you can deduce anything\n" "from a false statement. The `tauto` tactic will close this goal." -msgstr "\"기저 경우\"에서는 가정 `ha : 0 ≠ 0`가 있습니다. 거짓 명제에서는 무엇이든 이끌어낼 수 있으므로 `tauto` tactic이 이 goal을 닫습니다." +msgstr "\"기저 단계\"에서는 가정 `ha : 0 ≠ 0`가 있습니다. 거짓 명제에서는 무엇이든 이끌어낼 수 있으므로 `tauto` 택틱이 이 목표를 닫습니다." #: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro #: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ @@ -3952,14 +3999,14 @@ msgid "" "We do this in Lean by *rewriting* the proof `h`,\n" "using the `rw` tactic." msgstr "" -"In this level the *goal* is $2y=2(x+7)$ but to help us we\n" -"have an *assumption* `h` saying that $y = x + 7$. Check that you can see `h` in\n" -"your list of assumptions. Lean thinks of `h` as being a secret proof of the\n" -"assumption, rather like `x` is a secret number.\n" +"이 레벨의 *목표*는 $2y=2(x+7)$ 이지만 도움을 위해\n" +"$y = x + 7$라는 *가정* `h`가 있습니다. Assumption이라 적힌 목록에 `h`를\n" +"볼 수 있는지 체크해보세요. Lean은 `h`를 그 가정의 비밀스런 증명으로 생각합니다.\n" +"마치 `x`를 비밀스런 수로 생각하는 것처럼요.\n" "\n" -"Before we can use `rfl`, we have to \"substitute in for $y$\".\n" -"We do this in Lean by *rewriting* the proof `h`,\n" -"using the `rw` tactic." +"`rfl`을 사용할 수 있게 되려면, 우리는 \"$y$를 치환\"해야 합니다.\n" +"Lean에서는 `h`를 *재작성(rewrite)* 함으로써 치환이 가능합니다.\n" +"`rw` 택틱을 사용해 보세요" #: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro #: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ @@ -3976,11 +4023,11 @@ msgid "" "`apply` or any other tactic on the right to see a detailed explanation\n" "of what it does, with examples." msgstr "" -"In this level, the hypotheses `h2` is an *implication*. It says\n" -"that *if* `x = 37` *then* `y = 42`. We can use this\n" -"hypothesis with the `apply` tactic. Remember you can click on\n" -"`apply` or any other tactic on the right to see a detailed explanation\n" -"of what it does, with examples." +"이 레벨에서 가정 `h2`는 *조건문*입니다. 즉,\n" +"*만약* `x = 37`이라면 `y = 42`라는 뜻입니다.\n" +"이 가정은 `apply` 택틱을 사용해 활용할 수 있습니다. 오른쪽에 있는\n" +"`apply`나 다른 택틱을 클릭하면, 그 택틱이 무엇을 하는지 예시와 함께\n" +"자세한 설명을 볼 수 있다는 점을 기억하세요." #: Game.Levels.AdvAddition.L01add_right_cancel msgid "" @@ -3988,7 +4035,7 @@ msgid "" "\n" "`add_right_cancel a b n` is the theorem that $a+n=b+n\\implies a=b$." msgstr "" -"이 world에서는 대부분 여러분 스스로 하도록 두겠습니다.\n" +"이 월드에서는 대부분 여러분 스스로 하도록 두겠습니다.\n" "\n" "`add_right_cancel a b n`는 $a+n=b+n\\implies a=b$이라는 정리입니다." @@ -4004,11 +4051,11 @@ msgid "" "\n" "Click on \"Start\" to proceed." msgstr "" -"이 world에서는 `a ≤ b`를 정의하고, \"`a ≤ b`이고 `b ≤ c`이면 `a ≤ c`\" 같은 표준적인 성질을 증명합니다.\n" +"이 월드에서는 `a ≤ b`를 정의하고, \"`a ≤ b`이고 `b ≤ c`이면 `a ≤ c`\" 같은 표준적인 성질을 증명합니다.\n" "\n" -"`a ≤ b`의 정의는 \"`b = a + c`를 만족하는 수 `c`가 존재한다\"입니다. 따라서 \"존재한다\"는 정리를 증명하는 tactic과 \"존재한다\"는 가정을 사용하는 tactic을 배워야 합니다.\n" +"`a ≤ b`의 정의는 \"`b = a + c`를 만족하는 수 `c`가 존재한다\"입니다. 따라서 \"존재한다\"는 정리를 증명하는 택틱과 \"존재한다\"는 가정을 사용하는 택틱을 배워야 합니다.\n" "\n" -"\"Start\"를 눌러 진행하세요." +"\"시작하기\"를 눌러 진행하세요." #: Game.Levels.Implication.L01exact msgid "" @@ -4019,9 +4066,9 @@ msgid "" "The `exact` tactic can be used to close a goal which is exactly one of\n" "the hypotheses. It takes the name of the hypothesis as argument: `exact h`." msgstr "" -"이 world에서는 $P\\implies Q$ 꼴의 정리를 증명하는 법을 배웁니다. 즉 \"$P$이 참이면 $Q$가 참이다\" 꼴의 정리를 증명하는 법입니다. 이를 위해 몇 가지 tactic을 더 배워야 합니다.\n" +"이 월드에서는 $P\\implies Q$ 꼴의 정리를 증명하는 법을 배웁니다. 즉 \"$P$이 참이면 $Q$가 참이다\" 꼴의 정리를 증명하는 법입니다. 이를 위해 몇 가지 택틱을 더 배워야 합니다.\n" "\n" -"`exact` tactic은 goal이 가정 중 하나와 정확히 같을 때 goal을 닫을 수 있습니다. 인자로 가정의 이름을 받습니다: `exact h`." +"`exact` 택틱은 목표가 가정 중 하나와 정확히 같을 때 목표를 닫을 수 있습니다. 인자로 가정의 이름을 받습니다: `exact h`." #: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro #: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ @@ -4043,7 +4090,7 @@ msgid "" "It's \"intuitively obvious\" that there are no numbers less than zero,\n" "but to prove it you will need a result which you showed in advanced\n" "addition world." -msgstr "0보다 작은 수가 없다는 것은 \"직관적으로 명백\"하지만, 이를 증명하려면 Advanced Addition World에서 증명한 결과가 필요합니다." +msgstr "0보다 작은 수가 없다는 것은 \"직관적으로 명백\"하지만, 이를 증명하려면 고급 덧셈 월드에서 증명한 결과가 필요합니다." #: Game.Levels.Algorithm.L03add_algo2 msgid "" @@ -4053,15 +4100,15 @@ msgid "" "This level is not a level which you want to solve by hand.\n" "Get the simplifier to solve it for you." msgstr "" -"Lean의 simplifier `simp`는 \"`rw`에 스테로이드를 먹인 것\"과 같습니다. `simp` 태그가 붙은 모든 lemma와 사용자가 넣어 준 모든 lemma를 가능한 한 계속 rewrite합니다.\n" +"Lean의 simplifier `simp`는 \"`rw`에 스테로이드를 먹인 것\"과 같습니다. `simp` 태그가 붙은 모든 정리와 사용자가 넣어 준 모든 정리를 가능한 한 계속 rewrite합니다.\n" "\n" -"이 level은 손으로 풀고 싶을 만한 문제가 아닙니다. simplifier에게 맡기세요." +"이 레벨은 손으로 풀고 싶을 만한 문제가 아닙니다. simplifier에게 맡기세요." #: Game.Levels.Power.L06pow_add msgid "" "Let's now begin our approach to the final boss,\n" "by proving some more subtle facts about powers." -msgstr "이제 거듭제곱에 관한 좀 더 미묘한 사실들을 증명하면서 final boss로 가는 길을 시작합시다." +msgstr "이제 거듭제곱에 관한 좀 더 미묘한 사실들을 증명하면서 최종 보스로 가는 길을 시작합시다." #: Game.Levels.Tutorial.L06add_zero2 msgid "Let's now learn about Peano's second axiom for addition, `add_succ`." @@ -4069,7 +4116,7 @@ msgstr "이제 덧셈에 관한 페아노의 두 번째 공리 `add_succ`를 배 #: Game.Levels.Algorithm.L03add_algo2 msgid "Let's now make our own tactic to do this." -msgstr "이제 이 일을 하는 우리만의 tactic을 만들어 봅시다." +msgstr "이제 이 일을 하는 우리만의 택틱을 만들어 봅시다." #: Game.Levels.Algorithm.L04add_algo3 msgid "" @@ -4087,7 +4134,7 @@ msgid "" msgstr "" "많은 사람은 `apply t at h`는 쉽다고 느끼지만 `apply t`은 헷갈려 합니다. 헷갈린다면 그냥 앞에서부터 추론하세요.\n" "\n" -"`apply` tactic에 대한 자세한 설명은 오른쪽 tactic 목록에서 클릭해 볼 수 있습니다." +"`apply` 택틱에 대한 자세한 설명은 오른쪽 택틱 목록에서 클릭해 볼 수 있습니다." #: Game.Levels.Power.L01zero_pow_zero msgid "" @@ -4095,7 +4142,7 @@ msgid "" "a good convention. But it is not a good convention in this\n" "game; all the later levels come out beautifully with the\n" "convention that `0 ^ 0 = 1`." -msgstr "수학자들은 가끔 `0 ^ 0 = 0`도 좋은 관례라고 주장합니다. 하지만 이 게임에서는 좋은 관례가 아닙니다. `0 ^ 0 = 1`이라는 관례를 택하면 뒤의 level들이 아주 아름답게 풀리기 때문입니다." +msgstr "수학자들은 가끔 `0 ^ 0 = 0`도 좋은 관례라고 주장합니다. 하지만 이 게임에서는 좋은 관례가 아닙니다. `0 ^ 0 = 1`이라는 관례를 택하면 뒤의 레벨들이 아주 아름답게 풀리기 때문입니다." #: Game.Levels.Power.L01zero_pow_zero msgid "" @@ -4108,7 +4155,7 @@ msgid "" msgstr "" "수학자들은 가끔 `0 ^ 0`가 무엇인지 논쟁합니다. 물론 답은 정의에 달려 있습니다. 이 게임에서는 `0 ^ 0 = 1`입니다. 증명해 보세요.\n" "\n" -"새로 사용할 수 있는 증명은 theorem 목록의 *Pow* 탭에서 확인하세요." +"새로 사용할 수 있는 증명은 정리 목록의 ^ 탭에서 확인하세요." #: Game.Levels.Multiplication.L09mul_assoc msgid "" @@ -4157,13 +4204,13 @@ msgstr "좋습니다!" msgid "" "Nice! You've proved `succ_inj`!\n" "Let's now prove Peano's other axiom, that successors can't be $0$." -msgstr "좋습니다! `succ_inj`를 증명했습니다! 이제 페아노의 다른 공리, successor는 $0$일 수 없다는 것을 증명합시다." +msgstr "좋습니다! `succ_inj`를 증명했습니다! 이제 페아노의 다른 공리, 다음수는 $0$일 수 없다는 것을 증명합시다." #: Game.Levels.Tutorial.L03two_eq_ss0 msgid "" "Note that you can do `rw [two_eq_succ_one, one_eq_succ_zero]`\n" "and then `rfl` to solve this level in two lines." -msgstr "`rw [two_eq_succ_one, one_eq_succ_zero]` 다음 `rfl`을 하면 이 level을 두 줄로 해결할 수 있다는 점에 주의하세요." +msgstr "`rw [two_eq_succ_one, one_eq_succ_zero]` 다음 `rfl`을 하면 이 레벨을 두 줄로 해결할 수 있다는 점에 주의하세요." #: Game.Levels.AdvMultiplication.L06mul_right_eq_one msgid "" @@ -4216,8 +4263,8 @@ msgid "" "Now for to the second goal. Here you have the induction hypothesis\n" "`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`." msgstr "" -"이제 for to the second goal. Here you have the induction hypothesis\n" -"`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = succ «{d}»`." +"이제 두 번째 목표를 보겠습니다. 여기에는 귀납 가설\n" +"`«{hd}» : 0 + «{d}» = «{d}»`이 주어져 있고, `0 + succ «{d}» = succ «{d}»`를 증명해야 합니다." #: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero msgid "Now take apart the existence statement with `cases ha with n hn`." @@ -4233,7 +4280,7 @@ msgstr "이제 `rw [add_left_comm b c]`를 사용해 왼쪽의 `b`과 `c`를 바 msgid "" "Now we can prove the `or` statement by proving the statement on the right,\n" "so use the `right` tactic." -msgstr "이제 오른쪽 명제를 증명함으로써 `or` 명제를 증명할 수 있으므로 `right` tactic을 사용하세요." +msgstr "이제 오른쪽 명제를 증명함으로써 `or` 명제를 증명할 수 있으므로 `right` 택틱을 사용하세요." #: Game.Levels.Tutorial.L07add_succ Game.Levels.Tutorial.L08twoaddtwo msgid "Now you can `rw [add_succ]`" @@ -4260,7 +4307,7 @@ msgid "" "This result is what's standing in the way of `x + y = y + x`. Again\n" "we have the problem that we are adding `b` to things, so we need\n" "to use induction to split into the cases where `b = 0` and `b` is a successor." -msgstr "이런! `add_comm`로 가는 길에 야생의 `succ_add`이 나타났습니다. `succ_add a b`는 `a`와 `b`가 수일 때 `(succ a) + b = succ (a + b)`이라는 것의 증명입니다. 이 결과가 `x + y = y + x`을 막고 있습니다. 다시 `b`을 어떤 것에 더하고 있으므로 귀납법으로 `b = 0`인 경우와 `b`가 successor인 경우를 나눠야 합니다." +msgstr "이런! `add_comm`로 가는 길에 야생의 `succ_add`이 나타났습니다. `succ_add a b`는 `a`와 `b`가 수일 때 `(succ a) + b = succ (a + b)`이라는 것의 증명입니다. 이 결과가 `x + y = y + x`을 막고 있습니다. 다시 `b`을 어떤 것에 더하고 있으므로 귀납법으로 `b = 0`인 경우와 `b`가 다음수인 경우를 나눠야 합니다." #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 #: Game.Levels.Power.L01zero_pow_zero Game.Levels.Algorithm.L09decide2 @@ -4303,7 +4350,7 @@ msgstr "다음 목표는 \"왼쪽과 오른쪽 분배법칙\", 즉 $a(b+c)=ab+ac #: Game.Levels.Power msgid "Power World" -msgstr "거듭제곱 월드" +msgstr "지수 월드" #: Game.Levels.Tutorial.L06add_zero2 msgid "Precision rewriting" @@ -4316,23 +4363,23 @@ msgid "" "\n" "Click on \"Start\" to proceed." msgstr "" -"$2+2=4$나 $a+b+c+d+e=e+d+c+b+a$ 같은 증명을 손으로 하는 것은 아주 지루합니다. Algorithm World에서는 컴퓨터가 대신 하게 만드는 법을 배웁니다.\n" +"$2+2=4$나 $a+b+c+d+e=e+d+c+b+a$ 같은 증명을 손으로 하는 것은 아주 지루합니다. 알고리즘 월드에서는 컴퓨터가 대신 하게 만드는 법을 배웁니다.\n" "\n" -"\"Start\"를 눌러 진행하세요." +"\"시작하기\"를 눌러 진행하세요." #: Game.Levels.LessOrEqual.L07or_symm msgid "Ready for the boss level of this world?" -msgstr "이 world의 boss level을 맞을 준비가 되었나요?" +msgstr "이 월드의 보스 레벨을 맞을 준비가 되었나요?" #: Game.Levels.AdvMultiplication.L10mul_right_eq_self msgid "Reduce to the previous lemma with `nth_rewrite 2 [← mul_one a] at h`" -msgstr "`nth_rewrite 2 [← mul_one a] at h`를 사용해 이전 lemma로 환원하세요." +msgstr "`nth_rewrite 2 [← mul_one a] at h`를 사용해 이전 정리로 환원하세요." #: Game.Levels.Algorithm.L06is_zero msgid "" "See if you can take it from here. Look at the new lemmas and tactic\n" "available on the right." -msgstr "이제부터는 스스로 해 보세요. 오른쪽에 새로 생긴 lemma와 tactic을 살펴보세요." +msgstr "이제부터는 스스로 해 보세요. 오른쪽에 새로 생긴 정리와 택틱을 살펴보세요." #: Game.Levels.Multiplication.L01mul_one msgid "" @@ -4343,9 +4390,9 @@ msgid "" "Let's start with a warm-up: no induction needed for this one,\n" "because we know `1` is a successor." msgstr "" -"lemma 목록에 새로 생긴 \"*\" 탭을 보세요. `mul_zero`와 `mul_succ`이 들어 있습니다. 지금은 이 둘만 곱셈에 대해 알고 있는 사실입니다. 이제 아홉 개를 더 증명합시다.\n" +"정리 목록에 새로 생긴 \"*\" 탭을 보세요. `mul_zero`와 `mul_succ`이 들어 있습니다. 지금은 이 둘만 곱셈에 대해 알고 있는 사실입니다. 이제 아홉 개를 더 증명합시다.\n" "\n" -"먼저 준비운동부터 합니다. 이번에는 `1`가 successor라는 것을 알고 있으므로 귀납법이 필요 없습니다." +"먼저 준비운동부터 합니다. 이번에는 `1`이 다음수라는 것을 알고 있으므로 귀납법이 필요 없습니다." #: Game.Levels.Multiplication.L03succ_mul msgid "" @@ -4360,7 +4407,7 @@ msgid "" msgstr "" "마찬가지로 `mul_succ`가 있지만 우리가 필요한 것은 `succ_mul`입니다(무슨 내용일지 맞혀 보세요. 이제 Lean의 이름 짓기 규칙이 좀 익숙해졌을지도 모르겠네요).\n" "\n" -"Addition World의 마지막 level이 도움이 될 수 있습니다. 기억나지 않으면 집 모양 아이콘을 눌러 home 화면으로 돌아가 확인하세요. 진행 상황은 잃지 않습니다." +"덧셈 월드의 마지막 레벨이 도움이 될 수 있습니다. 기억나지 않으면 집 모양 아이콘을 눌러 home 화면으로 돌아가 확인하세요. 진행 상황은 잃지 않습니다." #: Game.Levels.Algorithm.L02add_algo1 msgid "" @@ -4370,11 +4417,11 @@ msgstr "알고리즘은 이것입니다. 이제 automation을 사용해 자동 #: Game.Levels.Algorithm.L03add_algo2 msgid "Solve this level in one line with `simp only [add_assoc, add_left_comm, add_comm]`" -msgstr "`simp only [add_assoc, add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요." +msgstr "`simp only [add_assoc, add_left_comm, add_comm]`를 사용해 이 레벨을 한 줄로 해결하세요." #: Game.Levels.Algorithm.L03add_algo2 msgid "Solve this level in one line with `simp only [add_left_comm, add_comm]`" -msgstr "`simp only [add_left_comm, add_comm]`를 사용해 이 level을 한 줄로 해결하세요." +msgstr "`simp only [add_left_comm, add_comm]`를 사용해 이 레벨을 한 줄로 해결하세요." #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "Split into cases `c = 0` and `c = succ e` with `cases c with e`." @@ -4390,7 +4437,7 @@ msgstr "`apply h2 at h1`부터 시작하세요. 그러면 `h1`이 `y = 42`로 #: Game.Levels.Implication.L05succ_inj2 msgid "Start with `apply succ_inj` to apply `succ_inj` to the *goal*." -msgstr "`apply succ_inj`로 시작해 `succ_inj`을 *goal*에 적용하세요." +msgstr "`apply succ_inj`로 시작해 `succ_inj`을 *목표*에 적용하세요." #: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero msgid "Start with `cases a with d` to do a case split on `a = 0` and `a = succ d`." @@ -4407,7 +4454,7 @@ msgstr "`cases «{hxy}» with a ha`로 시작하세요." msgid "" "Start with `contrapose! h`, to change the goal into its\n" "contrapositive, namely a hypothesis of `succ m = succ n` and a goal of `m = n`." -msgstr "`contrapose! h`로 시작해 goal을 그 대우로 바꾸세요. 즉 가정 `succ m = succ n`과 goal `m = n`로 바꿉니다." +msgstr "`contrapose! h`로 시작해 목표를 그 대우로 바꾸세요. 즉 가정 `succ m = succ n`과 목표 `m = n`로 바꿉니다." #: Game.Levels.Implication.L09zero_ne_succ Game.Levels.LessOrEqual.L04le_trans #: Game.Levels.LessOrEqual.L08le_total @@ -4465,11 +4512,11 @@ msgstr "`n`에 대한 귀납법으로 시작하세요." #: Game.Levels.Implication.L01exact Game.Levels.LessOrEqual.L01le_refl msgid "The `exact` tactic" -msgstr "`exact` tactic" +msgstr "`exact` 택틱" #: Game.Levels.Implication.L01exact Game.Levels.LessOrEqual.L01le_refl msgid "The `use` tactic" -msgstr "`use` tactic" +msgstr "`use` 택틱" #: Game msgid "The classical introduction game for Lean." @@ -4485,7 +4532,7 @@ msgstr "귀납가정 `hd`는 \"모든 자연수 `c`에 대해 `a * d = a * c → msgid "" "The lemma proved in the final level of this world will be helpful\n" "in Divisibility World." -msgstr "이 world의 마지막 level에서 증명하는 lemma는 Divisibility World에서 유용합니다." +msgstr "이 월드의 마지막 레벨에서 증명하는 정리는 나누어 떨어짐 월드에서 유용합니다." #: Game.Levels.Power.L07mul_pow msgid "" @@ -4502,7 +4549,7 @@ msgstr "" #: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero msgid "The previous lemma can be used to prove this one." -msgstr "이전 lemma를 사용해 이 lemma를 증명할 수 있습니다." +msgstr "이전 정리를 사용해 이 정리를 증명할 수 있습니다." #: Game.Levels.LessOrEqual.L01le_refl msgid "" @@ -4524,7 +4571,7 @@ msgid "" "I've left hidden hints; if you need them, retry from the beginning\n" "and click on \"Show more help!\"" msgstr "" -"제 생각에는 지금까지 가장 어려운 level입니다. 팁: `a`가 수라면 `cases a with b`은 `a = 0`와 `a = succ b`의 경우로 나눕니다. 그리고 가정이 결과 goal을 증명할 수 있음을 보장하기 전에는 왼쪽이나 오른쪽을 선택하지 마세요!\n" +"제 생각에는 지금까지 가장 어려운 레벨입니다. 팁: `a`가 수라면 `cases a with b`은 `a = 0`와 `a = succ b`의 경우로 나눕니다. 그리고 가정이 결과 목표를 증명할 수 있음을 보장하기 전에는 왼쪽이나 오른쪽을 선택하지 마세요!\n" "\n" "숨겨 둔 힌트가 있습니다. 필요하면 처음부터 다시 시작하고 \"도움말 더 보기!\"를 누르세요." @@ -4536,7 +4583,7 @@ msgid "" "\n" " Let's continue on our journey to `add_comm`, the proof of `x + y = y + x`." msgstr "" -"`x + y = y + x`를 알고 있었다면 이 lemma는 쉬웠을 겁니다. 그 정리는 `add_comm`이라고 하며 실제로 *참*이지만, 안타깝게도 그 증명은 `add_zero`와 `zero_add`을 모두 사용합니다!\n" +"`x + y = y + x`를 알고 있었다면 이 정리는 쉬웠을 겁니다. 그 정리는 `add_comm`이라고 하며 실제로 *참*이지만, 안타깝게도 그 증명은 `add_zero`와 `zero_add`을 모두 사용합니다!\n" "\n" "`x + y = y + x`의 증명 `add_comm`를 향한 여정을 계속합시다." @@ -4545,20 +4592,20 @@ msgid "" "This level asks you to prove *antisymmetry* of $\\leq$.\n" "In other words, if $x \\leq y$ and $y \\leq x$ then $x = y$.\n" "It's the trickiest one so far. Good luck!" -msgstr "이 level에서는 $\\leq$의 *반대칭성*을 증명합니다. 즉 $x \\leq y$이고 $y \\leq x$이면 $x = y$임을 보입니다. 지금까지 중 가장 까다롭습니다. 행운을 빕니다!" +msgstr "이 레벨에서는 $\\leq$의 *반대칭성*을 증명합니다. 즉 $x \\leq y$이고 $y \\leq x$이면 $x = y$임을 보입니다. 지금까지 중 가장 까다롭습니다. 행운을 빕니다!" #: Game.Levels.Multiplication.L06two_mul msgid "" "This level is more important than you think; it plays\n" "a useful role when battling a big boss later on." -msgstr "이 level은 생각보다 중요합니다. 나중에 큰 boss와 싸울 때 유용한 역할을 합니다." +msgstr "이 레벨은 생각보다 중요합니다. 나중에 큰 보스와 싸울 때 유용한 역할을 합니다." #: Game.Levels.AdvMultiplication.L07mul_ne_zero msgid "" "This level proves that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`. One strategy\n" "is to write both `a` and `b` as `succ` of something, deduce that `a * b` is\n" "also `succ` of something, and then `apply zero_ne_succ`." -msgstr "이 level에서는 `a ≠ 0`와 `b ≠ 0`이면 `a * b ≠ 0`라는 것을 증명합니다. 한 전략은 `a`과 `b`를 각각 어떤 것의 `succ`로 쓰고, `a * b`도 어떤 것의 `succ`임을 이끌어낸 뒤 `apply zero_ne_succ`을 사용하는 것입니다." +msgstr "이 레벨에서는 `a ≠ 0`와 `b ≠ 0`이면 `a * b ≠ 0`라는 것을 증명합니다. 한 전략은 `a`과 `b`를 각각 어떤 것의 `succ`로 쓰고, `a * b`도 어떤 것의 `succ`임을 이끌어낸 뒤 `apply zero_ne_succ`을 사용하는 것입니다." #: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro #: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ @@ -4572,8 +4619,8 @@ msgid "" "This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\n" "instead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory." msgstr "" -"This state is not provable! Did you maybe use `rw [add_left_eq_self] at h`\n" -"instead of `apply [add_left_eq_self] at h`? You can complare the two in the inventory." +"이 상태는 증명불가능합니다! 혹시 `apply [add_left_eq_self] at h` 가 아니라\n" +"`rw [add_left_eq_self] at h`을 사용하셨나요? 인벤토리에서 그 둘을 비교해보세요." #: Game.Levels.Tutorial.L05add_zero msgid "" @@ -4583,7 +4630,7 @@ msgstr "게임을 speedrun하고 싶은 분들은 `repeat rw [add_zero]`가 두 #: Game.Levels.LessOrEqual.L02zero_le msgid "To solve this level, you need to `use` a number `c` such that `x = 0 + c`." -msgstr "이 level을 해결하려면 `x = 0 + c`를 만족하는 수 `c`을 `use`해야 합니다." +msgstr "이 레벨을 해결하려면 `x = 0 + c`를 만족하는 수 `c`을 `use`해야 합니다." #: Game.Levels.Tutorial.L08twoaddtwo Game.Levels.Implication.L06intro #: Game.Levels.Implication.L07intro2 Game.Levels.Implication.L09zero_ne_succ @@ -4609,20 +4656,20 @@ msgid "" "`cases h with h1 h2` will create two goals, one where you went left,\n" "and the other where you went right." msgstr "" -"Totality of `≤` is the boss level of this world, and it's coming up next. It says that\n" -"if `a` and `b` are naturals then either `a ≤ b` or `b ≤ a`.\n" -"But we haven't talked about `or` at all. Here's a run-through.\n" +"`≤`의 전순서성은 이 월드의 보스 레벨이며, 바로 다음에 등장합니다. 이는\n" +"`a`와 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a` 중 하나가 성립한다는 뜻입니다.\n" +"하지만 아직 `or`에 대해서는 전혀 이야기하지 않았습니다. 간단히 알아봅시다.\n" "\n" -"1) The notation for \"or\" is `∨`. You won't need to type it, but you can\n" -"type it with `\\or`.\n" +"1) \"or\"를 나타내는 기호는 `∨`입니다. 직접 입력할 필요는 없지만,\n" +"`\\or`를 입력해서 쓸 수 있습니다.\n" "\n" -"2) If you have an \"or\" statement in the *goal*, then two tactics made\n" -"progress: `left` and `right`. But don't choose a direction unless your\n" -"hypotheses guarantee that it's the correct one.\n" +"2) *목표*에 \"or\" 명제가 있다면 `left`와 `right`, 두 택틱 중 하나를 사용해\n" +"진행할 수 있습니다. 다만 가정들로부터 어느 쪽이 맞는지가 확실하지 않다면\n" +"섣불리 방향을 고르지 마세요.\n" "\n" -"3) If you have an \"or\" statement as a *hypothesis* `h`, then\n" -"`cases h with h1 h2` will create two goals, one where you went left,\n" -"and the other where you went right." +"3) \"or\" 명제가 *가정* `h`로 주어져 있다면,\n" +"`cases h with h1 h2`를 사용해 두 개의 목표를 만들 수 있습니다. 하나는 왼쪽이\n" +"성립하는 경우이고, 다른 하나는 오른쪽이 성립하는 경우입니다." #: Game.Levels.LessOrEqual.L07or_symm msgid "" @@ -4641,13 +4688,20 @@ msgid "" "`cases h with h1 h2` will create two goals, one where you went left,\n" "and the other where you went right." msgstr "" -"`≤`의 전칭성(totality)은 이 world의 boss level이며 바로 다음에 나옵니다. `a`과 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a`라는 명제입니다. 하지만 아직 `or`에 대해 전혀 이야기하지 않았으니 먼저 살펴봅시다.\n" +"`≤`의 전순서성은 이 월드의 보스 레벨이며, 바로 다음에 등장합니다. 이는\n" +"`a`와 `b`가 자연수라면 `a ≤ b` 또는 `b ≤ a` 중 하나가 성립한다는 뜻입니다.\n" +"하지만 아직 `or`에 대해서는 전혀 이야기하지 않았습니다. 간단히 알아봅시다.\n" "\n" -"1) \"or\"의 표기는 `∨`입니다. 직접 입력할 필요는 없지만 `\\or`로 입력할 수 있습니다.\n" +"1) \"or\"를 나타내는 기호는 `∨`입니다. 직접 입력할 필요는 없지만,\n" +"`\\or`를 입력해서 쓸 수 있습니다.\n" "\n" -"2) goal에 \"or\" 명제가 있으면 `left`과 `right` 두 tactic으로 진행할 수 있습니다. 하지만 어느 방향이 옳은지 가정으로 확실해지기 전에는 방향을 선택하지 마세요.\n" +"2) *목표*에 \"or\" 명제가 있다면 `left`와 `right`, 두 택틱 중 하나를 사용해\n" +"진행할 수 있습니다. 다만 가정들로부터 어느 쪽이 맞는지가 확실하지 않다면\n" +"섣불리 방향을 고르지 마세요.\n" "\n" -"3) \"or\" 명제가 가정 `a`0으로 있다면 `a`1은 goal을 두 개 만듭니다. 하나는 왼쪽 경우, 다른 하나는 오른쪽 경우입니다." +"3) \"or\" 명제가 *가정* `h`로 주어져 있다면,\n" +"`cases h with h1 h2`를 사용해 두 개의 목표를 만들 수 있습니다. 하나는 왼쪽이\n" +"성립하는 경우이고, 다른 하나는 오른쪽이 성립하는 경우입니다." #: Game.Levels.Tutorial msgid "Tutorial World" @@ -4661,7 +4715,7 @@ msgstr "`add_succ`를 사용하세요." msgid "" "Use `mul_eq_zero` and remember that `tauto` will solve a goal\n" "if there are hypotheses `a = 0` and `a ≠ 0`." -msgstr "`mul_eq_zero`를 사용하세요. 가정 `a = 0`와 `a ≠ 0`이 있으면 `tauto`이 goal을 해결한다는 점을 기억하세요." +msgstr "`mul_eq_zero`를 사용하세요. 가정 `a = 0`와 `a ≠ 0`이 있으면 `tauto`이 목표를 해결한다는 점을 기억하세요." #: Game.Levels.LessOrEqual.L08le_total msgid "" @@ -4676,7 +4730,7 @@ msgstr "" "\n" "지나가던 수학자가 방금 `ℕ`가 전순서(total order)임을 증명했다고 말합니다.\n" "\n" -"이 world의 마지막 몇 level은 훨씬 쉽습니다." +"이 월드의 마지막 몇 레벨은 훨씬 쉽습니다." #. is_zero 0 := True #. is_zero (succ n) := False @@ -4706,12 +4760,9 @@ msgstr "" "is_zero (succ n) := False\n" "```\n" "\n" -"또 `is_zero 0 = True`와 `is_zero (succ n) = False`라고 말하는 두 lemma `is_zero_zero`와 `is_zero_succ n`을 만듭니다. 이 lemma들을 사용해 페아노의 마지막 공리 `succ_ne_zero`을 증명합시다. 사실 `zero_ne_succ`은 이전부터 사용해 왔지만, 반대 방향 버전도 있으면 편리하고 같은 방식으로 증명할 수 있습니다. 참고로 `zero_ne_succ`을 쓰면 여기서 치팅할 수 있지만, 이 world의 목적은 그런 결과를 *직접 증명*하는 방법을 보여 주는 것입니다.\n" +"또 `is_zero 0 = True`와 `is_zero (succ n) = False`라고 말하는 두 정리 `is_zero_zero`와 `is_zero_succ n`을 만듭니다. 이 정리들을 사용해 페아노의 마지막 공리 `succ_ne_zero`을 증명합시다. 사실 `zero_ne_succ`은 이전부터 사용해 왔지만, 반대 방향 버전도 있으면 편리하고 같은 방식으로 증명할 수 있습니다. 참고로 `zero_ne_succ`을 쓰면 여기서 치팅할 수 있지만, 이 월드의 목적은 그런 결과를 *직접 증명*하는 방법을 보여 주는 것입니다.\n" "\n" -"goal을 `True`로 바꿀 수 있다면 ```\n" -"is_zero 0 := True\n" -"is_zero (succ n) := False\n" -"```0 tactic이 해결합니다." +"목표를 `True`로 바꿀 수만 있다면 `trivial` 택틱이 해결할 수 있습니다." #: Game.Levels.Implication.L06intro msgid "" @@ -4719,7 +4770,7 @@ msgid "" "of the form `P → Q`. But what if our *goal* is of the form `P → Q`?\n" "To prove this goal, we need to know how to say \"let's assume `P` and deduce `Q`\"\n" "in Lean. We do this with the `intro` tactic." -msgstr "지금까지 `P → Q` 꼴의 정리와 가정을 `apply`하는 법을 봤습니다. 그런데 *goal*이 `P → Q` 꼴이라면 어떨까요? 이 goal을 증명하려면 Lean에서 \"`P`을 가정하고 `Q`를 이끌어내자\"라고 말하는 법을 알아야 합니다. 이를 `intro` tactic으로 합니다." +msgstr "지금까지 `P → Q` 꼴의 정리와 가정을 `apply`하는 법을 봤습니다. 그런데 *목표*가 `P → Q` 꼴이라면 어떨까요? 이 목표를 증명하려면 Lean에서 \"`P`를 가정하고 `Q` 보이자.\"라고 말하는 법을 알아야 합니다. 이를 `intro` 택틱으로 합니다." #: Game.Levels.Implication.L10one_ne_zero msgid "" @@ -4733,13 +4784,14 @@ msgid "" msgstr "" "`zero_ne_succ n`가 `0 = succ n → False`의 증명이라는 것은 알고 있습니다. 그런데 가정이 `succ n = 0`라면 어떨까요? 방향이 반대입니다!\n" "\n" -"`symm` tactic은 goal `x = y`를 `y = x`로, goal `x ≠ y`을 `y ≠ x`로 바꿉니다. `symm at h`은 가정 `h`에 대해 같은 일을 합니다. 우리는 `0 = succ n → False`0을 증명하고 그 증명을 `0 = succ n → False`1이라고 불렀습니다. 이제 `0 = succ n → False`2를 증명해 보세요." +"`symm` 택틱은 목표 `x = y`를 `y = x`로, 목표 `x ≠ y`을 `y ≠ x`로 바꿉니다. `symm at h`은 가정 `h`에 대해 같은 일을 합니다.\n" +"우리는 $0 \\neq 1$을 증명하고 그 증명을 `zero_ne_one`이라고 불렀습니다. 이제 $1 \\neq 0$를 증명해 보세요." #: Game.Levels.Multiplication.L09mul_assoc msgid "" "We now have enough to prove that multiplication is associative,\n" "the boss level of multiplication world. Good luck!" -msgstr "이제 곱셈의 결합법칙, 즉 Multiplication World의 boss level을 증명할 준비가 되었습니다. 행운을 빕니다!" +msgstr "이제 곱셈의 결합법칙, 즉 곱셈 월드의 보스 레벨을 증명할 준비가 되었습니다. 행운을 빕니다!" #: Game.Levels.Power.L10FLT msgid "" @@ -4769,9 +4821,9 @@ msgid "" msgstr "" "이제 수학적으로 정확하지만 조금 투박한 형태의 페르마의 마지막 정리를 진술할 준비가 되었습니다.\n" "\n" -"페르마의 마지막 정리는 $x,y,z>0$이고 $m \\geq 3$이면 $x^m+y^m\\not =z^m$라는 정리입니다. Inequality World를 하지 않았다면 $m \\geq 3$에 대해 말할 수 없으므로 `m` 대신 `n + 3`를 쓰는 편법을 사용해야 합니다. 이렇게 하면 충분히 큰 수라는 것이 보장됩니다. 마찬가지로 `x > 0` 대신 `a + 1`을 사용합니다.\n" +"페르마의 마지막 정리는 $x,y,z>0$이고 $m \\geq 3$이면 $x^m+y^m\\not =z^m$라는 정리입니다. `≤` 세계를 하지 않았다면 $m \\geq 3$에 대해 말할 수 없으므로 `m` 대신 `n + 3`를 쓰는 편법을 사용해야 합니다. 이렇게 하면 충분히 큰 수라는 것이 보장됩니다. 마찬가지로 `x > 0` 대신 `a + 1`을 사용합니다.\n" "\n" -"겉보기에는 이전 level들과 비슷하지만, 인간이 아는 가장 짧은 해법도 Lean 코드로 옮기면 수백만 줄이 될 것입니다. 이 게임의 저자 Kevin Buzzard는 Wiles와 Taylor의 증명을 Lean으로 옮기는 작업을 하고 있지만, 이 작업은 여러 해가 걸릴 것입니다.\n" +"겉보기에는 이전 레벨들과 비슷하지만, 인간이 아는 가장 짧은 해법도 Lean 코드로 옮기면 수백만 줄이 될 것입니다. 이 게임의 저자 Kevin Buzzard는 Wiles와 Taylor의 증명을 Lean으로 옮기는 작업을 하고 있지만, 이 작업은 여러 해가 걸릴 것입니다.\n" "\n" "## 축하합니다!\n" "\n" @@ -4793,18 +4845,21 @@ msgid "" "So if your goal is `False` then you had better hope that your hypotheses\n" "are contradictory, which they are in this level." msgstr "" -"아직 `2 + 2 ≠ 5`를 증명할 수 없습니다. `≠`의 정의에 대해 이야기하지 않았기 때문입니다. Lean에서 `a ≠ b`는 `a = b → False`의 *표기법*입니다. 여기서 `False`는 일반적인 거짓 명제이고, `→`는 Lean의 \"implies\" 표기입니다. 논리학에서 `True → False`은 거짓이지만 `False → False`은 참임을 배웁니다. 따라서 `X → False`은 `X`의 논리적 반대입니다.\n" +"아직 `2 + 2 ≠ 5`를 증명할 수 없습니다. `≠`의 정의에 대해 이야기하지 않았기 때문입니다.\n" +"Lean에서 `a ≠ b`는 `a = b → False`의 *표기법*입니다. 여기서 `False`는 일반적인\n" +"거짓 명제이고, `→`는 Lean의 \"조건문\" 표기입니다. 논리학을 배웠다면 `True → False`은\n" +"거짓이지만 `False → False`은 참이라고 알고 있을 겁니다. 따라서 `X → False`은 `X`과 논리적으로 정반대입니다.\n" "\n" -"`≠`0은 겉보기에는 함의처럼 보이지 않지만 함의처럼 다뤄야 합니다. 다음 두 level에서 방법을 봅니다.\n" +"`a ≠ b`는 겉보기에는 조건문처럼 보이지 않지만 조건문처럼 다뤄야 합니다. 다음 두 레벨에서 방법을 봅니다.\n" "\n" -"`≠`1은 모순 없는 가정들에서는 도저히 이끌어낼 수 없는 goal입니다! 그러므로 goal이 `≠`2라면 가정들이 모순이기를 바라야 하는데, 이 level에서는 실제로 그렇습니다." +"`False`은 모순 없는 가정들에서는 도저히 이끌어낼 수 없는 목표입니다! 그러므로 목표가 `False`라면 가정들이 모순이기를 바라야 하는데, 이 레벨에서는 실제로 그렇습니다." #: Game.Levels.AdvMultiplication.L02mul_left_ne_zero msgid "" "We want to reduce this to a hypothesis `b = 0` and a goal `a * b = 0`,\n" "which is logically equivalent but much easier to prove. Remember that `X ≠ 0`\n" "is notation for `X = 0 → False`. Click on `Show more help!` if you need hints." -msgstr "이를 가정 `b = 0`와 goal `a * b = 0`으로 환원하고 싶습니다. 논리적으로 동치지만 훨씬 증명하기 쉽습니다. `X ≠ 0`가 `X = 0 → False`의 표기법이라는 점을 기억하세요. 힌트가 필요하면 `도움말 더 보기!`를 클릭하세요." +msgstr "이를 가정 `b = 0`와 목표 `a * b = 0`으로 환원하고 싶습니다. 논리적으로 동치지만 훨씬 증명하기 쉽습니다. `X ≠ 0`가 `X = 0 → False`의 표기법이라는 점을 기억하세요. 힌트가 필요하면 `도움말 더 보기!`를 클릭하세요." #: Game.Levels.AdvMultiplication.L06mul_right_eq_one msgid "" @@ -4813,13 +4868,13 @@ msgid "" "You'll be asked to\n" "prove it, and then you'll have a new hypothesis which you can apply\n" "`le_mul_right` to." -msgstr "`le_mul_right`를 쓰고 싶지만 필요한 가정 `x * y ≠ 0`이 아직 없습니다. `have h2 : x * y ≠ 0`를 실행하세요(`≠`은 `\\ne`로 입력할 수 있습니다). 그 명제를 증명하라는 goal이 생기고, 증명하고 나면 `le_mul_right`를 적용할 수 있는 새 가정이 생깁니다." +msgstr "`le_mul_right`를 쓰고 싶지만 필요한 가정 `x * y ≠ 0`이 아직 없습니다. `have h2 : x * y ≠ 0`를 실행하세요(`≠`은 `\\ne`로 입력할 수 있습니다). 그 명제를 증명하라는 목표가 생기고, 증명하고 나면 `le_mul_right`를 적용할 수 있는 새 가정이 생깁니다." #: Game.Levels.Power.L02zero_pow_succ msgid "" "We've just seen that `0 ^ 0 = 1`, but if `n`\n" "is a successor, then `0 ^ n = 0`. We prove that here." -msgstr "방금 `0 ^ 0 = 1`를 보았습니다. 하지만 `n`이 successor라면 `0 ^ n = 0`입니다. 여기서 이를 증명합니다." +msgstr "방금 `0 ^ 0 = 1`를 보았습니다. 하지만 `n`이 다음수라면 `0 ^ n = 0`입니다. 여기서 이를 증명합니다." #: Game.Levels.Implication msgid "" @@ -4836,20 +4891,20 @@ msgid "" "\n" "Click on \"Start\" to proceed." msgstr "" -"$2+2=4$를 증명했습니다. Implication World에서는 $2+2\\neq 5$을 증명하는 법을 배웁니다.\n" +"$2+2=4$를 증명했습니다. 조건문 월드에서는 $2+2\\neq 5$을 증명하는 법을 배웁니다.\n" "\n" -"Addition World에서는 $x + y = y + x$ 같은 *등식*을 증명했습니다. 이 두 번째 tutorial world에서는 새로운 tactic들을 배워 $x+1=4 \\implies x=3.$ 같은 *함의*를 증명할 수 있게 됩니다.\n" +"덧셈 월드에서는 $x + y = y + x$ 같은 *등식*을 증명했습니다. 이 두 번째 튜토리얼 월드에서는 새로운 택틱들을 배워 $x+1=4 \\implies x=3$ 같은 *조건문*를 증명할 수 있게 됩니다.\n" "\n" "또 페아노가 공리로 도입한 자연수에 관한 새로운 기본 사실 두 가지를 배웁니다.\n" "\n" -"\"Start\"를 눌러 진행하세요." +"\"시작하기\"를 눌러 진행하세요." #: Game.Levels.LessOrEqual.L09succ_le_succ msgid "" "We've proved that `x ≤ 0` implies `x = 0`. The last two levels\n" "in this world will prove which numbers are `≤ 1` and `≤ 2`.\n" "This lemma will be helpful for them." -msgstr "`x ≤ 0`가 `x = 0`을 함의함을 증명했습니다. 이 world의 마지막 두 level에서는 어떤 수들이 `≤ 1`와 `≤ 2`인지 증명합니다. 이 lemma가 도움이 됩니다." +msgstr "`x ≤ 0`가 `x = 0`을 함의함을 증명했습니다. 이 월드의 마지막 두 레벨에서는 어떤 수들이 `≤ 1`와 `≤ 2`인지 증명합니다. 이 정리가 도움이 됩니다." #: Game.Levels.AdvAddition.L05add_right_eq_zero msgid "Well done!" @@ -4857,7 +4912,7 @@ msgstr "잘했습니다!" #: Game.Levels.Addition.L02succ_add msgid "Well done! You now have enough tools to tackle the main boss of this level." -msgstr "잘했습니다! 이제 이 level의 main boss에 도전할 도구가 충분합니다." +msgstr "잘했습니다! 이제 이 레벨의 메인 보스에 도전할 도구가 충분합니다." #. symm #. exact zero_ne_one @@ -4885,7 +4940,7 @@ msgstr "" msgid "" "Why did we not just define `succ n` to be `n + 1`? Because we have not\n" "even *defined* addition yet! We'll do that in the next level." -msgstr "왜 `succ n`를 그냥 `n + 1`로 정의하지 않았을까요? 아직 덧셈 자체를 *정의하지 않았기* 때문입니다! 다음 level에서 하겠습니다." +msgstr "왜 `succ n`를 그냥 `n + 1`로 정의하지 않았을까요? 아직 덧셈 자체를 *정의하지 않았기* 때문입니다! 다음 레벨에서 하겠습니다." #: Game.Levels.Multiplication.L07mul_add msgid "" @@ -4922,7 +4977,7 @@ msgstr "`a`와 `b` 중 어느 것에 귀납하는 편이 더 좋은지 생각해 #: Game.Levels.Tutorial.L02rw msgid "You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey." -msgstr "이제 `2 + 2 = 4`를 증명할 tactic을 충분히 알고 있습니다! 여정을 시작합시다." +msgstr "이제 `2 + 2 = 4`를 증명할 택틱을 충분히 알고 있습니다! 여정을 시작합시다." #: Game.Levels.LessOrEqual.L08le_total msgid "You still don't know which way to go, so do `cases «{e}» with a`." @@ -4939,11 +4994,11 @@ msgid "" "\n" "Click \"Home\" and make your choice." msgstr "" -"이제 게임의 final boss를 이기는 데 필요한 tactic을 모두 배웠습니다. Multiplication World로 들어가 boss를 향한 여정을 시작할 수 있습니다.\n" +"이제 게임의 최종 보스를 이기는 데 필요한 택틱을 모두 배웠습니다. 곱셈 월드로 들어가 보스를 향한 여정을 시작할 수 있습니다.\n" "\n" -"또는 정석 길을 벗어나 Implication World에서 새 tactic을 배울 수도 있습니다. 이 tactic들을 이용하면 `x + a = x`에서 `a = 0`를 이끌어내는 법처럼 덧셈에 관한 더 많은 사실을 증명할 수 있습니다.\n" +"또는 정석 길을 벗어나 조건문 월드에서 새 택틱을 배울 수도 있습니다. 이 택틱들을 이용하면 `x + a = x`에서 `a = 0`를 이끌어내는 법처럼 덧셈에 관한 더 많은 사실을 증명할 수 있습니다.\n" "\n" -"\"Home\"을 누르고 선택하세요." +"\"홈\"을 누르고 선택하세요." #: Game.Levels.Addition.L03add_comm msgid "" @@ -4952,17 +5007,17 @@ msgid "" "Look in your inventory to see the proofs you have available.\n" "These should be enough." msgstr "" -"[boss battle 음악]\n" +"[보스 전투 음악]\n" "\n" -"inventory를 보고 사용할 수 있는 증명들을 확인하세요. 이것이면 충분할 겁니다." +"인벤토리를 보고 사용할 수 있는 증명들을 확인하세요. 이것들로 충분할 겁니다." #: Game.Levels.Tutorial.L07add_succ msgid "[dramatic music]. Now are you ready to face the first boss of the game?" -msgstr "[극적인 음악]. 이제 게임의 첫 boss를 상대할 준비가 되었나요?" +msgstr "[극적인 음악]. 이제 게임의 첫 보스를 상대할 준비가 되었나요?" #: Game.Levels.Power.L09add_sq msgid "[final boss music]" -msgstr "[final boss 음악]" +msgstr "[최종 보스 음악]" #: Game.Levels.Tutorial.L05add_zero msgid "" @@ -5018,7 +5073,7 @@ msgid "" "\n" "Note in particular that `0 ^ 0 = 1`." msgstr "" -"`Pow a b`는 `a ^ b`로 표기하며 자연수의 보통 거듭제곱입니다. 내부적으로는 두 공리로 정의됩니다.\n" +"`Pow a b`는 `a ^ b`로 표기하며 자연수의 보통 거듭제곱입니다. 내부적으로는 다음 두 공리로 정의됩니다.\n" "\n" " * `pow_zero a : a ^ 0 = 1`\n" "\n" @@ -5041,7 +5096,7 @@ msgstr "" "\n" "이 게임에는 음수가 없으므로 이 정의는 수학적으로 타당합니다.\n" "\n" -"따라서 `a ≤ b` 꼴의 goal이 있으면 `use` tactic으로 진행할 수 있고, 가정 `h : a ≤ b`가 있으면 `cases h with c hc`로 진행할 수 있습니다." +"따라서 `a ≤ b` 꼴의 목표가 있으면 `use` 택틱으로 진행할 수 있고, 가정 `h : a ≤ b`가 있으면 `cases h with c hc`로 진행할 수 있습니다." #: Game.Levels.LessOrEqual.L01le_refl msgid "" @@ -5055,7 +5110,7 @@ msgid "" msgstr "" "`a ≤ b`는 `∃ c, b = a + c`의 *표기법*입니다. 이 \"거꾸로 된 E\"는 \"존재한다\"는 뜻입니다. 따라서 `a ≤ b`는 `b = a + c`를 만족하는 수 `c`가 존재한다는 뜻입니다. 이 게임에는 음수가 없으므로 이 정의가 작동합니다.\n" "\n" -"\"존재한다\"는 명제를 *증명*하려면 `use` tactic을 사용합니다. 예시를 봅시다." +"\"존재한다\"는 명제를 *증명*하려면 `use` 택틱을 사용합니다. 예시를 봅시다." #: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Addition.L03add_comm #: Game.Levels.Implication.L09zero_ne_succ Game.Levels.Algorithm.L05pred @@ -5079,18 +5134,19 @@ msgid "" "will only do rewrites of the form `b + ? = ? + b`, and `rw [add_comm b c]`\n" "will only do rewrites of the form `b + c = c + b`." msgstr "" -"`add_comm b c`는 `b + c = c + b`의 증명입니다. 하지만 goal이 `a + b + c = a + c + b`라면 `rw [add_comm b c]`은 작동하지 않습니다! goal의 뜻이 `(a + b) + c = (a + c) + b`이므로 goal 안에 `b + c` 항이 *직접* 나타나지 않기 때문입니다.\n" +"`add_comm b c`는 `b + c = c + b`의 증명입니다. 하지만 목표가 `a + b + c = a + c + b`라면 `rw [add_comm b c]`은 작동하지 않습니다! goal의 뜻이 `(a + b) + c = (a + c) + b`이므로 goal 안에 `b + c` 항이 *직접* 나타나지 않기 때문입니다.\n" "\n" "결합법칙과 가환법칙을 이용해 `add_right_comm`을 증명하세요. 귀납법은 필요 없습니다. `add_assoc`은 괄호를 옮기고 `add_comm`은 변수의 순서를 바꿉니다.\n" "\n" -"정리를 적용할 때 변수를 명시하면 더 정밀한 rewrite를 할 수 있다는 점을 기억하세요. 예를 들어 `rw [add_comm b]`는 `b + c = c + b`0 꼴만 rewrite하고, `b + c = c + b`1은 `b + c = c + b`2 꼴만 rewrite합니다." +"정리를 적용할 때 변수를 명시하면 더 정밀한 rewrite를 할 수 있다는 점을 기억하세요. 예를 들어 `rw [add_comm b]`는\n" +"`b + ? = ? + b` 꼴만 rewrite하고, `rw [add_comm b c]`은 `b + c = c + b` 꼴만 rewrite합니다." #: Game.Levels.AdvAddition.L01add_right_cancel #: Game.Levels.AdvAddition.L02add_left_cancel #: Game.Levels.AdvAddition.L03add_left_eq_self #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "`add_left_cancel a b n` is the theorem that $n+a=n+b \\implies a=b.$" -msgstr "`add_left_cancel a b n`는 $n+a=n+b \\implies a=b.$이라는 정리입니다." +msgstr "`add_left_cancel a b n`는 $n+a=n+b \\implies a=b$이라는 정리입니다." #: Game.Levels.AdvAddition.L02add_left_cancel msgid "" @@ -5108,14 +5164,14 @@ msgstr "`add_left_comm a b c`는 `a + (b + c) = b + (a + c)`.의 증명입니다 #: Game.Levels.AdvAddition.L03add_left_eq_self #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "`add_left_eq_self x y` is the theorem that $x + y = y \\implies x=0.$" -msgstr "`add_left_eq_self x y`는 $x + y = y \\implies x=0.$이라는 정리입니다." +msgstr "`add_left_eq_self x y`는 $x + y = y \\implies x=0$이라는 정리입니다." #: Game.Levels.AdvAddition.L01add_right_cancel #: Game.Levels.AdvAddition.L02add_left_cancel #: Game.Levels.AdvAddition.L03add_left_eq_self #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "`add_left_eq_self x y` is the theorem that $x + y = y\\implies x=0.$" -msgstr "`add_left_eq_self x y`는 $x + y = y\\implies x=0.$이라는 정리입니다." +msgstr "`add_left_eq_self x y`는 $x + y = y\\implies x=0$이라는 정리입니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow @@ -5133,20 +5189,20 @@ msgstr "`add_mul`도 귀납법으로 증명하려면 꽤 번거롭습니다. 하 #: Game.Levels.AdvAddition.L03add_left_eq_self #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "`add_right_cancel a b n` is the theorem that $a+n=b+n \\implies a=b.$" -msgstr "`add_right_cancel a b n`는 $a+n=b+n \\implies a=b.$이라는 정리입니다." +msgstr "`add_right_cancel a b n`는 $a+n=b+n \\implies a=b$이라는 정리입니다." #: Game.Levels.AdvAddition.L01add_right_cancel #: Game.Levels.AdvAddition.L02add_left_cancel #: Game.Levels.AdvAddition.L03add_left_eq_self #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "`add_right_eq_self x y` is the theorem that $x + y = x \\implies y=0.$" -msgstr "`add_right_eq_self x y`는 $x + y = x \\implies y=0.$이라는 정리입니다." +msgstr "`add_right_eq_self x y`는 $x + y = x \\implies y=0$이라는 정리입니다." #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "" "`add_right_eq_self x y` is the theorem that $x + y = x\\implies y=0.$\n" "Two ways to do it spring to mind; I'll mention them when you've solved it." -msgstr "`add_right_eq_self x y`는 $x + y = x\\implies y=0.$이라는 정리입니다. 두 가지 방법이 떠오르는데, 해결하고 나면 말씀드리겠습니다." +msgstr "`add_right_eq_self x y`는 $x + y = x\\implies y=0$이라는 정리입니다. 두 가지 방법이 떠오르는데, 해결하고 나면 말씀드리겠습니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow @@ -5234,7 +5290,7 @@ msgid "" msgstr "" "`le_mul_right a b`는 `a * b ≠ 0 → a ≤ a * b`의 증명입니다.\n" "\n" -"양수의 약수는 그 수 이하이어야 한다는 사실을 표현하는 한 방법입니다." +"이는 어떤 양수의 약수는 그 수 이하라는 것을 의미합니다." #: Game.Levels.LessOrEqual.L10le_one #: Game.Levels.AdvMultiplication.L08mul_eq_zero @@ -5249,7 +5305,7 @@ msgid "" msgstr "" "`le_refl x`는 `x ≤ x`의 증명입니다.\n" "\n" -"이 이름은 이 lemma가 \"$\\le$의 반사성(reflexivity)\"을 나타내기 때문에 붙었습니다." +"이 이름은 이 정리가 \"$\\le$의 반사성(reflexivity)\"을 나타내기 때문에 붙었습니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow @@ -5276,9 +5332,12 @@ msgid "" msgstr "" "`le_trans x y z`는 `x ≤ y`이고 `y ≤ z`이면 `x ≤ z`이라는 것의 증명입니다. 더 정확히는 `x ≤ y → (y ≤ z → x ≤ z)`의 증명입니다. 말로 하면 \"$x \\le y$이면, (잠깐 쉬고) $y \\le z$이면 $x \\le z$\"입니다.\n" "\n" -"## 결합법칙에 관한 주의\n" +"## 결합법칙에 관한 사항\n" "\n" -"Lean에서 `a + b + c`은 `(a + b) + c`를 뜻합니다. `x ≤ y`0이 왼쪽 결합이기 때문입니다. 하지만 `x ≤ y`1은 오른쪽 결합입니다. 따라서 Lean에서 `x ≤ y`2는 정확히 `x ≤ y`3이 추이적이라는 뜻입니다. 이는 수학자들이 `x ≤ y`4를 쓰는 방식과 다릅니다. 수학자에게는 보통 `x ≤ y`5이고 `x ≤ y`6이라는 뜻입니다." +"Lean에서 `a + b + c`은 `(a + b) + c`를 뜻합니다.\n" +"`+`이 좌결합적(왼쪽부터 계산하는 우선순위를 따름)이기 때문입니다. 하지만 `→`은 우결합적(오른쪽부터 해석하는 우선순위를 따름)입니다.\n" +"따라서 Lean에서 `x ≤ y → y ≤ z → x ≤ z`는 정확히 `≤`이 추이적이라는 뜻입니다. 이는 수학자들이 $P \\implies Q \\implies R$를 쓰는 방식과 다릅니다. 수학자에게는 보통 $P \\implies Q$이고 $Q \\implies R$이라는 뜻입니다.\n" +"즉, 수학자들은 `→`를 좌결합적으로 사용합니다." #: Game.Levels.LessOrEqual.L11le_two msgid "`le_two x` is a proof that if `x ≤ 2` then `x = 0` or `x = 1` or `x = 2`." @@ -5301,13 +5360,12 @@ msgid "" "for example subtraction is not associative, as `(6 - 2) - 1` is not\n" "equal to `6 - (2 - 1)`." msgstr "" -"`mul_assoc a b c`는 `(a * b) * c = a * (b * c)`.\n" +"`mul_assoc a b c`는 `(a * b) * c = a * (b * c)`의 증명입니다.\n" "\n" -"Note that when Lean says `a * b * c` it means `(a * b) * c`.\n" +"참고로 Lean 코드에서의 `a * b * c`의 의미는 `(a * b) * c`입니다.\n" "\n" -"Note that `(a * b) * c = a * (b * c)` cannot be proved by \\\"pure thought\\\":\n" -"for example subtraction is not associative, as `(6 - 2) - 1` is not\n" -"equal to `6 - (2 - 1)`.의 증명입니다." +"참고로 `(a * b) * c = a * (b * c)`는 \\\"단순 생각\\\"만으로 증명할 수 없습니다:\n" +"예를 들어 뺄셈은 결합적이지 않죠. `(6 - 2) - 1`가 `6 - (2 - 1)`이 아니듯이요." #: Game.Levels.LessOrEqual.L10le_one #: Game.Levels.AdvMultiplication.L08mul_eq_zero @@ -5341,7 +5399,7 @@ msgstr "`mul_ne_zero a b`는 `a ≠ 0`이고 `b ≠ 0`이면 `a * b ≠ 0`이라 #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow msgid "`mul_pow a b n` is a proof that $(ab)^n=a^nb^n.$" -msgstr "`mul_pow a b n`는 $(ab)^n=a^nb^n.$의 증명입니다." +msgstr "`mul_pow a b n`는 $(ab)^n=a^nb^n$의 증명입니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow @@ -5383,12 +5441,12 @@ msgstr "`one_pow n`는 $1^n=1$.의 증명입니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow msgid "`pow_add a m n` is a proof that $a^{m+n}=a^ma^n.$" -msgstr "`pow_add a m n`는 $a^{m+n}=a^ma^n.$의 증명입니다." +msgstr "`pow_add a m n`는 $a^{m+n}=a^ma^n$의 증명입니다." #: Game.Levels.Power.L06pow_add Game.Levels.Power.L07mul_pow #: Game.Levels.Power.L08pow_pow msgid "`pow_pow a m n` is a proof that $(a^m)^n=a^{mn}.$" -msgstr "`pow_pow a m n`는 $(a^m)^n=a^{mn}.$의 증명입니다." +msgstr "`pow_pow a m n`는 $(a^m)^n=a^{mn}$의 증명입니다." #: Game.Levels.Power.L02zero_pow_succ msgid "" @@ -5488,21 +5546,21 @@ msgid "" "It is distinct from the Lean natural numbers `Nat`, which should hopefully\n" "never leak into the natural number game.*" msgstr "" -"`ℕ` is the natural numbers, just called \\\"numbers\\\" in this game. It's\n" -"defined via two rules:\n" +"`ℕ`은 자연수입니다. 이 게임에서는 간단히 \\\"수\\\"라고 부릅니다. 자연수는\n" +"다음 두 규칙으로 정의됩니다:\n" "\n" -"* `0 : ℕ` (zero is a number)\n" -"* `succ (n : ℕ) : ℕ` (the successor of a number is a number)\n" +"* `0 : ℕ` (`0`은 수입니다)\n" +"* `succ (n : ℕ) : ℕ` (어떤 수의 다음수는 수입니다)\n" "\n" -"## Game Implementation\n" +"## 게임 구현\n" "\n" -"*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\n" -"It is distinct from the Lean natural numbers `Nat`, which should hopefully\n" -"never leak into the natural number game.*" +"*이 게임에서는 `ℕ`이라는 표기를 사용하는 `MyNat`이라는 자체적인 자연수 타입을 사용합니다.\n" +"이는 Lean의 자연수 `Nat`과는 별개의 타입이며, `Nat`이 자연수 게임 안으로\n" +"섞여 들어오는 일은 없기를 바랍니다.*" #: Game.Levels.Addition.L03add_comm msgid "add_comm (level boss)" -msgstr "add_comm (level boss)" +msgstr "add_comm (레벨 보스)" #: Game.Levels.AdvAddition.L06add_left_eq_zero msgid "add_left_eq_zero" @@ -5542,7 +5600,7 @@ msgstr "eq_succ_of_ne_zero" #: GameServer.RpcHandlers msgid "intermediate goal solved! 🎉" -msgstr "중간 goal 해결! 🎉" +msgstr "중간 목표 해결! 🎉" #: Game.Levels.Algorithm.L06is_zero msgid "is_zero" @@ -5558,7 +5616,7 @@ msgstr "le_two" #: GameServer.RpcHandlers msgid "level completed! 🎉" -msgstr "level 완료! 🎉" +msgstr "레벨 완료! 🎉" #: Game.Levels.Algorithm.L02add_algo1 msgid "making life easier" @@ -5630,7 +5688,7 @@ msgstr "succ x ≤ succ y → x ≤ y" #: Game.Levels.Implication.L04succ_inj msgid "succ_inj : the successor function is injective" -msgstr "succ_inj : successor 함수는 단사입니다." +msgstr "succ_inj : 다음수 함수는 단사입니다." #: Game.Levels.Multiplication.L03succ_mul msgid "succ_mul" @@ -5737,15 +5795,15 @@ msgid "" msgstr "" "## 요약\n" "\n" -"§0는 §1 꼴의 goal을 증명합니다.\n" +"§0는 §1 꼴의 목표를 증명합니다.\n" "\n" -"즉 §4와 §5가 *동일한* 항이라면 §2 tactic은 §3 꼴의 모든 goal을 닫습니다.\n" +"즉 §4와 §5가 *동일한* 항이라면 §2 택틱은 §3 꼴의 모든 목표를 닫습니다.\n" "\n" "§6는 \"reflexivity (of equality)\"의 줄임말입니다.\n" "\n" "## 예시\n" "\n" -"goal이\n" +"목표가\n" "\n" "§7\n" "\n" @@ -5946,30 +6004,30 @@ msgid "" msgstr "" "## 요약\n" "\n" -"§0가 등식 §1의 증명이라면 §2는 goal의 모든 §3을 §4로 바꿉니다. 즉 \"대입\"하는 방법입니다.\n" +"§0가 등식 §1의 증명이라면 §2는 목표의 모든 §3을 §4로 바꿉니다. 즉 \"대입\"하는 방법입니다.\n" "\n" "## 변형\n" "\n" "* §5 (§6을 §7로 바꿉니다. 뒤쪽 화살표는 §8 또는 §9를 입력해 얻을 수 있습니다.)\n" "* §10 (여러 번의 rewrite를 연속으로 수행)\n" "* §11 (가정 §14 안의 §12를 §13으로 바꿈)\n" -"* §15 (두 가정과 goal에서 §16을 §17로 바꿈. §18 기호는 §19로 입력)\n" +"* §15 (두 가정과 목표에서 §16을 §17로 바꿈. §18 기호는 §19로 입력)\n" "* §20은 더 이상 §23과 일치하는 것이 없을 때까지 §21을 §22로 계속 바꿉니다.\n" -"* §24는 goal의 두 번째 §25만 §26으로 바꿉니다.\n" +"* §24는 목표의 두 번째 §25만 §26으로 바꿉니다.\n" "\n" "### 예시\n" "\n" -"가정 §27이 있고 goal이\n" +"가정 §27이 있고 목표가\n" "§28\n" "이라면\n" "\n" "§29\n" "\n" -"은 goal을 §30으로 바꾸고, 이어서\n" +"은 목표를 §30으로 바꾸고, 이어서\n" "\n" "§31\n" "\n" -"은 goal을 §32로 바꿉니다. 이는 §33으로 해결할 수 있습니다.\n" +"은 목표를 §32로 바꿉니다. 이는 §33으로 해결할 수 있습니다.\n" "\n" "### 예시\n" "\n" @@ -5978,23 +6036,23 @@ msgstr "" "## 흔한 오류\n" "\n" "* 대괄호가 필요합니다. §39는 절대 올바르지 않습니다.\n" -"* §40이 *등식* §41의 *증명*이 아니라 함수나 함의 같은 것이라면 §43은 원하는 tactic이 아닙니다. 예를 들어 §42가 함수나 함의라면 §44는 절대 올바르지 않습니다. §45는 정리의 *명제*이지 증명이 아닙니다. §46가 증명이라면 §47은 작동합니다.\n" +"* §40이 *등식* §41의 *증명*이 아니라 함수나 조건문 같은 것이라면 §43은 원하는 택틱이 아닙니다. 예를 들어 §42가 함수나 조건문이라면 §44는 절대 올바르지 않습니다. §45는 정리의 *명제*이지 증명이 아닙니다. §46가 증명이라면 §47은 작동합니다.\n" "\n" "## 자세한 설명\n" "\n" -"§48 tactic은 \"대입\"을 하는 방법입니다. 서로 다른 두 상황에서 사용할 수 있습니다.\n" +"§48 택틱은 \"대입\"을 하는 방법입니다. 서로 다른 두 상황에서 사용할 수 있습니다.\n" "\n" -"1) 기본 사용법: §49가 가정이나 정리의 증명이고 goal에 하나 이상의 §50가 있다면 §51은 그 모두를 §52로 바꿉니다. goal에 §53이 하나도 없으면 오류가 납니다.\n" +"1) 기본 사용법: §49가 가정이나 정리의 증명이고 목표에 하나 이상의 §50가 있다면 §51은 그 모두를 §52로 바꿉니다. 목표에 §53이 하나도 없으면 오류가 납니다.\n" "\n" -"2) 고급 사용법: 정리의 증명에서 얻은 가정은 인자가 빠져 있는 경우가 많습니다. 예를 들어 §54가 §55의 증명인 것은 §56가 실제로 함수이고 §57이 입력이기 때문입니다. 이 상황에서 §58은 goal에서 §59 꼴의 부분항을 찾고, 찾는 즉시 §60을 §61로 정한 뒤 모든 §62를 §63으로 바꿉니다.\n" +"2) 고급 사용법: 정리의 증명에서 얻은 가정은 인자가 빠져 있는 경우가 많습니다. 예를 들어 §54가 §55의 증명인 것은 §56가 실제로 함수이고 §57이 입력이기 때문입니다. 이 상황에서 §58은 목표에서 §59 꼴의 부분항을 찾고, 찾는 즉시 §60을 §61로 정한 뒤 모든 §62를 §63으로 바꿉니다.\n" "\n" "연습: §64가 항 §65를 §66으로 바꾸는 이유를 생각해 보세요.\n" "\n" -"등식의 증명 이름이 기억나지 않으면 오른쪽 lemma 목록에서 찾아보세요.\n" +"등식의 증명 이름이 기억나지 않으면 오른쪽 정리 목록에서 찾아보세요.\n" "\n" "## 정확히 지정해서 사용하기\n" "\n" -"goal이 §67이고 §68을 §69로 rewrite하고 싶다고 합시다. §70은 작동하지 않습니다. Lean이 다른 덧셈을 먼저 찾아 그 입력을 바꾸기 때문입니다. §71을 사용하면 Lean이 반드시 §72를 §73으로 rewrite하게 할 수 있습니다. 이는 §74가 §75의 증명, §76이 §77의 증명, §78이 §79의 증명이기 때문입니다.\n" +"목표가 §67이고 §68을 §69로 rewrite하고 싶다고 합시다. §70은 작동하지 않습니다. Lean이 다른 덧셈을 먼저 찾아 그 입력을 바꾸기 때문입니다. §71을 사용하면 Lean이 반드시 §72를 §73으로 rewrite하게 할 수 있습니다. 이는 §74가 §75의 증명, §76이 §77의 증명, §78이 §79의 증명이기 때문입니다.\n" "\n" "§80이라면 §81은 모든 §82를 §83으로 바꿉니다. §84의 37번째 occurrence만 §85로 바꾸고 싶다면 §86을 사용하세요." @@ -6056,7 +6114,7 @@ msgstr "" "\n" "§0가 §1의 증명이고 §2가 §3의 증명이라면 §4는 §5를 §6의 증명으로 바꿉니다. 아이디어는 §7이 참이라는 것을 알면 §8로부터 §9가 참임을 이끌어낼 수 있다는 것입니다.\n" "\n" -"*goal*이 §10이라면 §11은 \"거꾸로 추론\"해서 goal을 §12로 바꿉니다. §13을 증명하고 싶을 때 §14에 의해 §15만 증명하면 충분하므로 goal을 §16의 증명으로 환원하는 것입니다.\n" +"*목표*가 §10이라면 §11은 \"거꾸로 추론\"해서 목표를 §12로 바꿉니다. §13을 증명하고 싶을 때 §14에 의해 §15만 증명하면 충분하므로 목표를 §16의 증명으로 환원하는 것입니다.\n" "\n" "### 예시\n" "\n" @@ -6066,7 +6124,7 @@ msgstr "" "\n" "### 예시\n" "\n" -"goal이 §25라면 §26은 goal을 §27로 바꿉니다." +"목표가 §25라면 §26은 목표를 §27로 바꿉니다." #. §0: $2y=2(x+7)$ #. §1: `h` @@ -6098,9 +6156,9 @@ msgid "" "We do this in Lean by *rewriting* the goal with §8,\n" "using the §9 tactic." msgstr "" -"이 level의 *goal*은 §0이지만, 이를 돕기 위해 §2라고 말하는 *가정* §1이 있습니다. 가정 목록에서 §3이 보이는지 확인하세요. Lean은 §4를 이 가정의 비밀스러운 증명이라고 생각합니다. §5가 비밀스러운 수인 것과 비슷합니다.\n" +"이 레벨의 *목표*는 §0이지만, 이를 돕기 위해 §2라고 말하는 *가정* §1이 있습니다. 가정 목록에서 §3이 보이는지 확인하세요. Lean은 §4를 이 가정의 비밀스러운 증명이라고 생각합니다. §5가 비밀스러운 수인 것과 비슷합니다.\n" "\n" -"§6을 쓰기 전에 먼저 \"§7에 대입\"해야 합니다. Lean에서는 §9 tactic을 사용해 증명 §8을 *rewriting*함으로써 이를 수행합니다." +"§6을 쓰기 전에 먼저 \"§7에 대입\"해야 합니다. Lean에서는 §9 택틱을 사용해 증명 §8을 *rewriting*함으로써 이를 수행합니다." #. §0: `add_zero a` #. §1: `a + 0 = a` @@ -6140,7 +6198,7 @@ msgstr "" "\n" "§2는 사실 함수입니다. 수 하나를 받아 그 수에 관한 정리의 증명을 반환합니다. 예를 들어 §3은 §4의 증명입니다.\n" "\n" -"§5 tactic은 §6을 받아 사용자가 생략한 입력 수가 무엇인지 알아내려 합니다.\n" +"§5 택틱은 §6을 받아 사용자가 생략한 입력 수가 무엇인지 알아내려 합니다.\n" "\n" "## 자세한 설명\n" "\n" @@ -6178,15 +6236,15 @@ msgstr "" "\n" "§0\n" "\n" -"이고 goal이\n" +"이고 목표가\n" "\n" "§1\n" "\n" -"이라면 §2는 이를 이른바 \"대우\"로 바꿉니다. 즉 가정\n" +"이라면 §2는 이를 이른바 \\\\\"대우\\\\\"로 바꿉니다. 즉 가정\n" "\n" "§3\n" "\n" -"과 goal\n" +"과 목표\n" "\n" "§4\n" "\n" @@ -6198,7 +6256,7 @@ msgstr "" msgid "" "Now for the second goal. Here you have the induction hypothesis\n" "§0, and you need to prove that §1." -msgstr "이제 두 번째 goal입니다. 여기에는 귀납가정 §0가 있고 §1을 증명해야 합니다." +msgstr "이제 두 번째 목표입니다. 여기에는 귀납가정 §0가 있고 §1을 증명해야 합니다." #. §0: `use` #. §1: `x` @@ -6235,9 +6293,9 @@ msgid "" msgstr "" "## 요약\n" "\n" -"§0 tactic은 어떤 것이 *존재한다*고 주장하는 goal에서 진행할 수 있게 해 줍니다. goal이 어떤 성질을 만족하는 §1이 존재한다고 말하고, §2가 그 역할을 한다는 것을 알고 있다면 §3으로 진행할 수 있습니다.\n" +"§0 택틱은 어떤 것이 *존재한다*고 주장하는 목표에서 진행할 수 있게 해 줍니다. 목표가 어떤 성질을 만족하는 §1이 존재한다고 말하고, §2가 그 역할을 한다는 것을 알고 있다면 §3으로 진행할 수 있습니다.\n" "\n" -"§4가 \"§6를 만족하는 §5가 존재한다\"의 표기이므로, §7 꼴의 goal에서는 본질적으로 §9인 수(즉 §10)를 §8해서 진행할 수 있습니다.\n" +"§4가 \"§6를 만족하는 §5가 존재한다\"의 표기이므로, §7 꼴의 목표에서는 본질적으로 §9인 수(즉 §10)를 §8해서 진행할 수 있습니다.\n" "\n" "§11 함수에 주는 인자의 타입이 올바르다면 다음 예시는 모두 가능합니다:\n" "\n"