From 582fffdb3872cce6f4652994e81f692b2738169c Mon Sep 17 00:00:00 2001 From: Federico Date: Thu, 20 Mar 2025 00:46:26 +0100 Subject: [PATCH] merge it/Game.po and zh/Game.po with Game.pot, regenerate jsons --- .i18n/it/Game.json | 44 +- .i18n/it/Game.po | 2002 ++++++++++++++++++++++++++++++-------------- .i18n/zh/Game.json | 48 +- .i18n/zh/Game.po | 1596 ++++++++++++++++++++++------------- 4 files changed, 2408 insertions(+), 1282 deletions(-) diff --git a/.i18n/it/Game.json b/.i18n/it/Game.json index d1cfc05..03b30de 100644 --- a/.i18n/it/Game.json +++ b/.i18n/it/Game.json @@ -229,7 +229,7 @@ "`a ≤ b` è *notazione* per `∃ c, b = a + c`. La \"E rovesciata\"\nsi legge \"esiste\". Quindi `a ≤ b` vuol dire che esiste\nun numero `c` tale che `b = a + c`. Questa definizione è valida\nperché non abbiamo i numeri negativi in questo gioco.\n\nPer *dimostrare* un \"esiste\", puoi usare la tattica `use`.\nVediamo un esempio.", "`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` è *notazione* per `∃ c, b = a + c`.\n\nDato che in questo gioco non abbiamo i numeri negativi, questa definizione\nè matematicamente valida.\n\nUna conseguenza pratica di tale definizione è che se hai un goal della forma `a ≤ b` puoi\nscomporlo con la tattica `use`, e se hai un'ipotesi\n`h : a ≤ b`, puoi scomporla tramite `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 use 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` 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` è *notazione* per `(a = b) → False`.\n\nQuesta interpretazione è valida in matematica\nperché se `P` è una proposizione vero-falso allora `P → False`\nè la negazione logica di `P`. Infatti `True → False` è falso,\ne `False → False` è vero!\n\nIl vantaggio di questa notazione è che possiamo trattare una disuguaglianza `a ≠ b`\ncome se fosse un implicazione `P → Q`, che sappiamo già come manipolare. Ad esempio,\nse il tuo *goal* è una disuguaglianza `a ≠ b`, puoi fare progresso\ncon `intro h`, e se un'ipotesi `h` è una disuguaglianza\n`a ≠ b` allora puoi fare `apply h at h1` se `h1` è la prova di\ndi `a = b`.", "`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`, con notazione `a ^ b`, è\n l'elevamento a potenza sui numeri naturali. Dentro Lean è\n definita tramite due assiomi:\n\n * `pow_zero a : a ^ 0 = 1`\n\n * `pow_succ a b : a ^ succ b = a ^ b * a`\n\nIn particolare, dal primo segue che `0 ^ 0 = 1`.", @@ -369,9 +369,9 @@ "Il lemma precedente può essere usato per dimostrare questo.", "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.": "Il prossimo risultato di cui abbiamo bisogno per il Mondo `≤` è: se `a + b = 0` allora `a = 0` e `b = 0`.\nIn questo livello dimostriamo solo la prima parte della conclusione, la seconda nel livello successivo.\n\n## Nuova tattica: `cases`\n\nLa tattica `cases` scompone un oggetto o un'ipotesi in tutti i modi possibili\nin cui può essere stato creato.\n\nAd esempio, su un numero naturale a volte è sufficiente ragionare con i due casi `b = 0` e `b = succ d` separatamente,\ntralasciando l'ipotesi induttiva `hd` prodotta da `induction b with d hd`.\nIn questa situazione puoi usare `cases b with d`. Ci sono due modi per creare un numero:\ncome zero o come successore di qualcosa. `case` riprodurrà proprio queste due alternative, spezzando la dimostrazione in due sotto-goal, uno\ncon l'ipotesi `b = 0` e un'altro con l'ipotesi `b = succ d`.\n\nChiariamo con un altro esempio: se hai l'ipotesi `h : False` allora hai finito, perché un'affermazione falsa implica\nqualsiasi cosa. Qua `cases h` chiuderà la dimostrazione, perché *non* vi è alcun modo\ndi costruire una dimostrazione di `False`! Quindi rimarrai con zero sotto-goal da dimostrare, ossia hai dimostrato tutto.", - "The music gets ever more dramatic, as we explore\nthe interplay between exponentiation and multiplication.\n\nIf you're having trouble exchanging the right `x * y`\nbecause `rw [mul_comm]` swaps the wrong multiplication,\nthen read the documentation of `rw` for tips on how to fix this.": + "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.": "La musica si fa sempre più drammatica nel mentre che ci addentriamo\nnella relazione tra elevamento a potenza e prodotto.\n\nSe stai avendo difficoltà a scambiare il giusto `x * y`\nperché `rw [mul_comm]` sta operando su un prodotto diverso,\nleggi la documentazione di `rw` per ripassare come fare sostituzioni mirate.", - "The music dies down. Is that it?\n\nCourse it isn't, you can\nclearly see that there are two worlds 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.": + "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.": "La musica cessa di suonare. È finita?\n\nOvvio che no, come vedi\nci sono ancora due livelli da battere.\n\nIntanto, un matematico di passaggio ti svela che i matematici non hanno dato un nome\nalla struttura che hai appena costruito. Questa notizia ti lascia l'amaro in bocca.\n\nLa musica riparte improvvisamente. Ti lasci alle spalle il passato: lo scontro con il boss finale è vicino.", "The lemma proved in the final level of this world will be helpful\nin Divisibility World.": "Il lemma dimostrato nel livello finale di questo mondo ci sarà d'aiuto\nnel Mondo Divisibilità.", @@ -405,7 +405,7 @@ "Inizia con `induction «{y}» with d hd`.", "Start with `have h2 := mul_ne_zero a b`.": "Inizia con `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 m` and a goal of `m = n`.": + "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`.": "Inizia con `contrapose! h`, che ti fa dimostrare la\ncontronominale del goal, cioè avrai tra le ipotesi la negazione del goal, `succ m = succ m`, e come nuovo goal avrai la negazione dell'ipotesi `h`, `m = n`.", "Start with `cases «{hxy}» with a ha`.": "Inizia con `cases «{hxy}» with a ha`.", @@ -450,6 +450,8 @@ "La prima sfida è dimostrare `mul_comm x y : x * y = y * x`,\ne vogliamo farlo per induzione. Per dimostrare il caso\nbase utilizzeremo `mul_zero` (che abbiamo come assioma)\ne `zero_mul`, che non abbiamo ancora, dunque partiamo\nda quest'ultimo.", "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?": "Con il suo nome degno di premio Oscar, il mini-boss `pow_pow`\nsalta nel ring e la musica si fa ancora più intensa. Cos'altro c'è da\ndimostrare sulle potenze dopo di lui?!", + "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`.": + "Nel Mondo Numeri Primi dimostreremo che $2$ è primo.\nMa per arrivarci, dobbiamo escludere falsità del tipo $2 ≠ 37 × 42.$\nLo faremo mostrando che ogni fattore di $2$ è al più $2$,\nche avremo gratis grazie a questo lemma. La dimostrazione che ho in mente io manipola l'ipotesi finché\nnon diventa il goal, usando praticamente tutto ciò che abbiamo dimostrato in questo mondo finora.", "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$.": "L'addizione è commutativa sull'insieme dei naturali.\nEquivalentemente, se `a` e `b` sono due numeri naturali qualsiasi, allora\n$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). $": @@ -493,14 +495,14 @@ "Ora `«{ha}»` è una dimostrazione di `«{y}» = «{x}» + «{a}»`, mentre `hxy` è scomparso. In modo simile, puoi scomporre\n`«{hyz}»` nelle sue varie parti tramite `cases «{hyz}» with b hb`.", "Now `rw [← two_eq_succ_one]` will change `succ 1` into `2`.": "Ora con `rw [← two_eq_succ_one]` `succ 1` diventa `2`.", + "Now `rw [«{h}»] at «{h2}»` so you can `apply le_one at «{h2}»`.": + "Adesso `rw [h] at h2` così puoi fare `apply le_one at hx`.", "Now `rw [h]` then `rfl` works, but `exact h` is quicker.": "Ora potresti usare `rw [h]` e `rfl` in successione, ma `exact h` è più elegante.", - "Now `rw [h] at h2` so you can `apply le_one at hx`.": - "Adesso `rw [h] at h2` così puoi fare `apply le_one at hx`.", "Now `rw [add_zero]` will change `c + 0` into `c`.": "Ora `rw [add_zero]` trasformerà `c + 0` in `c`.", "Now `rfl` will work.": "Adesso `rfl` funzionerà.", - "Now `repeat rw [← succ_eq_add_one] at h` is the quickest way to\nchange `succ x = succ y`.": + "Now `repeat rw [← succ_eq_add_one] at h` is the quickest way to\nchange `h` to `succ x = succ y`.": "Adesso puoi fare `repeat rw [← succ_eq_add_one] at h` per fare due sostituzioni in un colpo\ne avrai `succ x = succ y`.", "Now `exact h` finishes the job.": "Ora concludi con `exact h`.", "Now `cases «{h2}» with e he`.": "Ora `cases «{h2}» with e he`.", @@ -526,7 +528,7 @@ "Natural Number Game": "Il Gioco dei Numeri Naturali", "My proof:\n```\ncases h with d hd\nuse d * t\nrw [hd, add_mul]\nrfl\n```": "La mia dimostrazione:\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 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.": + "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.": "La moltiplicazione di norma fa crescere un numero, ma moltiplicare per zero lo rende\npiù piccolo, o meglio, lo azzera. Ecco perché gran parte dei teoremi che mischiano le disuguaglianze con la moltiplicazione hanno\nl'ipotesi `a ≠ 0`. Questo livello è un lemma chiave che ci permette di mettere a frutto questa ipotesi.\nPer aiutarci nella dimostrazione, possiamo usare la tattica `tauto`. Clicca sul nome della tattica\nsulla destra per una descrizione dettagliata su cosa fa.", "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$.": "La moltiplicazione è distributiva a sinistra rispetto all'addizione.\nEquivalentemente, per tutti i numeri naturali $a$, $b$ e $c$, si ha che\n$a(b + c) = ab + ac$.", @@ -576,14 +578,14 @@ "In questo mondo non parlerò troppo.\n\n`add_right_cancel a b n` è il teorema che afferma $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.": "In questo livello, abbiamo delle disuguaglianze tra le *ipotesi*. Non abbiamo ancora visto questo caso.\nLa tattica `cases` può essere usata per scomporre l'ipotesi `hxy`.", + "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.)": "In questo livello dimostreremo l'enunciato $0+n=n$, dove $n$ è un numero naturale incognito.\n\nMa come, non l'abbiamo già dimostrato? No! Abbiamo dimostrato $n+0=n$, che abbiamo chiamato `add_zero`.\nQuesto è `zero_add`, un teorema diverso.\n\nCiò che complica le cose nel dimostrare `0 + n = n` è che non abbiamo una *formula* per riscrivere\n`0 + n` in generale, possiamo solo applicare `add_zero` o `add_succ` una volta che sappiamo che\n`n` è `0` oppure un successore. La tattica `induction` spezza la dimostrazione in questi due casi.\n\nNel caso base dovremo dimostrare `0 + 0 = 0`, e nel caso induttivo dovremo dimostrare\nche se `0 + d = d` allora `0 + succ d = succ d`. Dato che\n`0` e il successore sono i due soli modi per costruire i numeri naturali, la dimostrazione coprirà tutti i casi possibili.\n\nOra prova a svolgere la tua prima dimostrazione per induzione su Lean.\n\n(Se sei ancora nella \"Modalità editor\" dallo scorso mondo, puoi rientrare nella\n\"Modalità interattiva\" cliccando sul pulsante `>_` in alto a destra.)", - "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`.\"": + "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`.": "In questo livello dimostriamo se `a * b = a * c` e `a ≠ 0` allora `b = c`. È un pò complicato, per\ndiverse ragioni. Una di queste è che\nabbiamo bisogno di introdurre una nuova idea, approfondendo la nozione di\ninduzione matematica.\n\nSarebbe ingenuo partire con `induction b with d hd`, perché nel passo induttivo\nl'ipotesi è `a * d = a * c → d = c` ma quello che sappiamo è solo che `a * succ d = a * c`,\ndunque non possiamo applicare l'ipotesi ipotesi induttiva!\n\nSupponiamo di fissare la variabile `a ≠ 0`. Il vero enunciato che vogliamo dimostrare per induzione su `b` è\n\"per tutte le `c`, se `a * b = a * c` allora `b = c`\". Questo *può* essere dimostrato per induzione,\nperché abbiamo permesso alla `c` di variare.", "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 questo livello il *goal* è $2y=2(x+7)$ e l'unica informazione che\npuò aiutarci a dimostrarlo è l'*ipotesi* `h` che dice $y = x + 7$. Verifica di avere `h` sotto la voce \"Ipotesi\".\nLean vede `h` come una dimostrazione segreta dell'ipotesi,\nun po' come il valore della variabile `x` è un'incognita.\n\nPrima di poter usare la tattica `rfl`, dobbiamo \"sostituire per la variabile $y$\".\nIn Lean possiamo *riscrivere* la dimostrazione `h`\nattraverso la tattica `rw`.", - "In this level one of our hypotheses is an *implication*. We can use this\nhypothesis with the `apply` tactic.": - "In questo livello una delle nostre ipotesi è un'*implicazione*. Possiamo usare\nquesta ipotesi con la tattica `apply`.", "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!": "In questo gioco ricreerai l'insieme dei numeri naturali $\\mathbb{N}$ partendo dagli assiomi di Peano,\ne lungo il percorso imparerai le basi del *theorem proving* su Lean.\n\nQuesto gioco è un'ottima introduzione a Lean!", "In the next level, we'll do the same proof but backwards.": @@ -596,8 +598,6 @@ "Nei mondi successivi ci sono livelli molto più brutti\ncome `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`.\nQui le parentesi vanno spostate, e le variabili vanno scambiate tra di loro.\n\nIn questo livello, `(a + b) + (c + d) = ((a + c) + d) + b`,\ndimentichiamoci delle parentesi e concentriamoci solamente\nsull'ordine delle variabili.\nPer portare `a+b+c+d` a `a+c+d+b` dobbiamo scambiare `b` con `c`,\ne poi scambiare `b` con `d`. Questo è più facile di quanto\npensi tramite `add_left_comm`.", "In order to use the tactic `rfl` you can enter it in the text box\nunder the goal and hit \"Execute\".": "Per utilizzare la tattica `rfl` digitala nella casella di testo\nsotto il goal e premi \"Esegui\".", - "In Prime Number World we will be 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 pretty much everything which we've proved in this world so far.": - "Nel Mondo Numeri Primi dimostreremo che $2$ è primo.\nMa per arrivarci, dobbiamo escludere falsità del tipo $2 ≠ 37 × 42.$\nLo faremo mostrando che ogni fattore di $2$ è al più $2$,\nche avremo gratis grazie a questo lemma. La dimostrazione che ho in mente io manipola l'ipotesi finché\nnon diventa il goal, usando praticamente tutto ciò che abbiamo dimostrato in questo mondo finora.", "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.": "Nel Mondo Addizione Avanzata dimostreremo delle proprietà\nbasilari dell'addizione come $x+y=x\\implies y=0$. I teoremi\ndimostrati in questo mondo servono da mattoncini teorici con cui costruiremo\nla teoria delle disuguaglianze nel Mondo `≤`.\n\nPremi su \"Via\" per iniziare.", "Implication World": "Mondo Implicazione", @@ -665,6 +665,8 @@ "Come ti sembra questa dimostrazione:\n\n```\nrw [add_comm]\nexact add_right_eq_zero b a\n```\n\nQuesto è tutto per il Mondo Addizione Avanzata! I teoremi di questo mondo ti torneranno utili\nnel prossimo mondo, il Mondo `≤`. Clicca su \"Abbandona mondo\" per navigarci.", "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```": "Ecco quello che avevo in mente:\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.": + "", "Here's my solution:\n```\nrw [two_eq_succ_one, succ_mul, one_mul]\nrfl\n```": "Ecco come l'ho fatta io:\n```\nrw [two_eq_succ_one, succ_mul, one_mul]\nrfl\n```", "Here's my solution:\n```\nrw [mul_comm, mul_one]\nrfl\n```": @@ -685,7 +687,7 @@ "Ecco una dimostrazione di due righe:\n```\nuse 1\nexact succ_eq_add_one x\n```\n\nQuesto funziona perché `succ_eq_add_one x` è la dimostrazione di `succ x = x + 1`.", "Here's a two-line proof:\n```\nrepeat rw [zero_add] at h\nexact h\n```": "Ecco una dimostrazione di due righe:\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(the dots in the proof just indicate the two goals and\ncan be omitted):\n\n```\n induction x with d hd\n · intro h\n rw [zero_add] at h\n assumption\n · intro h\n rw [succ_add] at h\n apply succ_inj at h\n apply hd at h\n assumption\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```": "Ecco una dimostrazione che usa `add_left_eq_self`:\n```\nrw [add_comm]\nintro h\napply add_left_eq_self at h\nexact h\n```\n\ned eccone una più breve che condensa le ultime tre righe in una sola:\n```\nrw [add_comm]\nexact add_left_eq_self y x\n```\n\nVolendo puoi anche dimostrarlo per induzione su `x`\n(i pallini nel codice qui sotto hanno solo funzione decorativa,\nassieme all'indentazione servono per riconoscere più facilmente i due sottogoal, ma possono essere omessi):\n\n```\n induction x with d hd\n · intro h\n rw [zero_add] at h\n assumption\n · intro h\n rw [succ_add] at h\n apply succ_inj at h\n apply hd at h\n assumption\n```", "Here's a completely backwards proof:\n```\nintro h\napply succ_inj\nrepeat rw [succ_eq_add_one]\nexact h\n```": "Ecco una dimostrazione che procede all'indietro:\n```\nintro h\napply succ_inj\nrepeat rw [succ_eq_add_one]\nexact h\n```", @@ -745,7 +747,7 @@ "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```": "Per caso hai fatto induzione su `y`?\nEcco una dimostrazione in due righe `add_left_eq_self` che sfrutta `add_right_cancel`.\nSe vuoi vedere come funziona, vai in editor mode cliccando su `` in alto a destra,\ncopia e incolla la mia dimostrazione e muoviti tra le linee con il cursore\nper vedere le ipotesi e il goal in ogni punto\n(prima salva la tua dimostrazione però, altrimenti la perdi). Premi su `>_` per\ntornare alla modalità command line.\n```\nnth_rewrite 2 [← zero_add y]\nexact add_right_cancel x 0 y\n```", "Dealing with `or`": "Come ragionare con `or`", - "Congratulations! You've finished Algorithm World. These algorithms\nwill be helpful for you in Even-Odd World.": + "Congratulations! You've finished Algorithm World. These algorithms\nwill be helpful for you in Even-Odd World (when someone gets around to\nimplementing it).": "Congratulazioni! Hai finito il Mondo Algoritmi. Questi algoritmi\nti saranno sicuramente utili per il Mondo Pari-Dispari.", "Congratulations! You have proved Fermat's Last Theorem!\n\nEither that, or you used magic...": "Congratulazioni! Hai dimostrato l'ultimo teorema di Fermat!\n\nO forse no... ti ho visto usare la polvere magica...", @@ -805,7 +807,7 @@ "2 + 2 ≠ 5": "2 + 2 ≠ 5", "1 ≠ 0": "1 ≠ 0", "0 ≤ x": "0 ≤ x", - "*Game version: 4.2*\n\n*Recent additions: Inequality world, algorithm world*\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.": "*Versione del gioco: 4.2*\n\n*Aggiunti di recente: Mondo Disequazioni, Mondo Algoritmi*\n\n## Salvataggio del gioco\n\nIl gioco salva il tuo progresso nella memoria locale del browser.\nSe cancelli la memoria, perderai anche i dati del gioco! (le tue preziose dimostrazioni!)\n\nAttenzione: nella maggior parte dei browser, cancellare i cookies cancella anche la memoria di un sito\n(o \"i dati locali del sito\"). In ogni caso, assicurati di esportare il tuo progresso del gioco!\n\n## Riconoscimenti\n\n* **Autori:** Kevin Buzzard, Jon Eugster\n* **Versione originale per Lean3:** Kevin Buzzard, Mohammad Pedramfar\n* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n* **Livelli extra:** Sian Carey, Ivan Farabella, Archie Browne.\n* **Traduzione italiana**: Federico Dal Pio Luogo\n* **Grazie anche a:** Gli studenti che si sono offerti come beta testers, tutte le scuole\nche hanno invitato Kevin a parlare, e gli studenti che gli hanno fatto domande\nsul materiale.\n\n## Risorse\n\n* La [chat di Lean su Zulip](https://leanprover.zulipchat.com/)\n* Il [gioco originale per Lean3](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/) (no longer maintained)\n\n## Problemi?\n\nRivolgi le tue domande sul gioco nella\n[chat di Lean su Zulip](https://leanprover.zulipchat.com/), utilizzando\nlo stream \"New Members\". I membri della comunità sono felici di aiutare. Nota che\nla chat di Lean su Zulip è un forum professionale di ricerca.\nPerciò usa il tuo nome reale e per intero, rimani in tema, e sii cortese. Se cerchi\nun forum più informale (dove puoi ad esempio postare\ni meme sui numeri naturali) allora il [server Discord di Lean](https://discord.gg/WZ9bs9UCvx) fa per te.\n\nIn alternativa, se il gioco funziona male o dovessi trovare un bug puoi aprire una issue su github:\n\n* Per problemi relativi al game engine, apri una\n[issue sul repo lean4game](https://github.com/leanprover-community/lean4game/issues).\n* Per problemi relativi ai contenuti del the gioco, apri una\n[issue sul repo NNG](https://github.com/hhu-adam/NNG4/issues).", "$x=37\\implies x=37$.": "$x=37\\implies x=37$.", "$x+y=x\\implies y=0$.": "$x+y=x\\implies y=0$.", @@ -832,7 +834,7 @@ "## Descrizione\n\n`repeat t` applica la tattica `t`\nnel goal ripetitivamente. Non è necessario usare questa tattica\nper completare il gioco, ma a volte è utile nel rendere le dimostrazioni più succinte.\n\n## Esempio\n\n`repeat rw [add_zero]` trasformerà il goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\nnel nuovo goal\n`a = b`.\n\"\n\nTacticDoc nth_rewrite \"\n## Descrizione\n\nSe hai `h : X = Y` e ci sono diverse `X` nel goal, allora\n`nth_rewrite 3 [h]` sostituirà solo la terza `X` in `Y`.\n\n## Esempio\n\nSe nel goal hai `2 + 2 = 4` allora con `nth_rewrite 2 [two_eq_succ_one]`\nsostituisce la seconda occorrenza del lato sinistro di `two_eq_succ_one`, e il goal diventa `2 + succ 1 = 4`. Invece il normale `rw [two_eq_succ_one]`\nsostituira la prima occorrenza di `2` nel goal, che diventa `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`.": "## Descrizione\n\n`repeat t` applica la tattica `t`\nnel goal ripetitivamente. Non è strettamente necessaria al fine di\ncompletare il gioco, ma a volte è utile per velocizzare le dimostrazioni.\n\n## Esempio\n\n`repeat rw [add_zero]` trasformerà il goal\n`a + 0 + (0 + (0 + 0)) = b + 0 + 0`\nnel nuovo goal\n`a = b`.", - "## 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`.": + "## 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`": "## Descrizione\n\nLa tattica `use` permette di avanzare su goal che postulano l'*esistenza* di qualcosa.\nSe il goal afferma che esiste una certa `x`con qualche proprietà, e sei sicuro\nche `x = 37` la soddisfi, allora con `use 37` farai progresso nella dimostrazione.\n\nDato che `a ≤ b` è notazione per \\\"there exists `c` such that `b = a + c`\\\",\npuoi fare progresso su goal della forma `a ≤ b` passando a `use`\nquel numero che corrisponde a `b - a`, la distanza tra `a` e `b`.", "## 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`.": "## Descrizione\n\nLa tattica `symm` trasformerà un goal o un'ipotesi della forma di\nun'uguaglianza `X = Y` in `Y = X`. Funziona anche sulla disuguaglianza `X ≠ Y`\ne sull'equivalenza `X ↔ Y`.\n\n### Esempio\n\nSe il goal è `2 + 2 = 4`, `symm` lo trasformerà in `4 = 2 + 2`.\n\n### Esempio\n\nSe hai `h : 2 + 2 ≠ 5` allora `symm at h` trasformerà `h` in `5 ≠ 2 + 2`.", @@ -846,13 +848,13 @@ "## Descrizione\n\nSe `n` è un numero, allora `cases n with d` spezzerà il goal in due goal,\nuno dove `n = 0` e un altro dove `n = succ d`.\n\nSe `h` è una dimostrazione (per esempio tra le ipotesi), allora `cases h with...` spezzerà\nla dimostrazione in tante parti quante quanti i modi di derivare `h`.\n\n## Esempio\n\nSe `n : ℕ` è un numero, allora `cases n with d` spezzerà il goal in due subgoal,\nuno dove `n` è stato rimpiazzato da 0 e l'altro dove `n` è stato rimpiazzato da `succ d`. Questo\ncorrisponde all'intuizione matematica che ogni numero naturale è o `0`\noppure un successore.\n\n## Esempio\n\nSe `h : P ∨ Q` è un'ipotesi, allora `cases h with hp hq` trasformerà il goal\nin due goal, uno con l'ipotesi `hp : P` e l'altro con\nl'ipotesi `hq : Q`.\n\n## Esempio\n\nSe `h : False` è un'ipotesi, allora `cases h` trasformerà il goal in zero goal,\nperché non vi è alcun modo di dimostrare `False`! E se rimani con zero cose da dimostrare\nvuol dire che hai completato il livello.\n\n## Esempio\n\nSe `h : a ≤ b` è un'ipotesi, allora `cases h with c hc` istanzierà un nuovo numero `c`\ne una dimostrazione di `hc : b = a + c`. Questo deriva dalla *definizione* di `a ≤ b`, che è\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.": "## Descrizione\n\nSe `n : ℕ` è un oggetto, e il goal fa il nome di `n`, allora `induction n with d hd`\navvia la dimostrazione per induzione attorno alla variabile `n`, con la variabile\ninduttiva nel caso del successore chiamata `d` e l'ipotesi induttiva chiamata`hd`.\n\n### Esempio:\nSe il goal è\n```\n0 + n = n\n```\n\nallora\n\n`induction n with d hd`\n\nlo spezzerà in sue sotto-goal. Il primo è `0 + 0 = 0`;\nil secondo porta ha con sé un ipotesi `hd : 0 + d = d` e il goal\n`0 + succ d = succ d`.\n\nTieni presente che devi dimostrare il primo\ngoal prima di avere accesso al secondo.", - "## 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## Targetted 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## Targetted 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]`.": "## Descrizione\n\nSe `h` è una prova dell'uguaglianza `X = Y`, allora `rw [h]` scriverà\n`Y` al posto di ogni `X` nel goal. `rw` svolge l'operazione di \\\"sostituzione\\\".\n\n## Varianti di `rw`\n\n* `rw [← h]` (riscrive le `Y` con `X`; per avere la freccetta all'indietro si digita `\\left ` oppure `\\l`.)\n\n* `rw [h1, h2]` (sostituzioni in sequenza)\n\n* `rw [h] at h2` (riscrive le `X` in `Y` nell'ipotesi `h2`)\n\n* `rw [h] at h1 h2 ⊢` (riscrive le `X` in `Y` in due ipotesi e nel goal;\nper avere il simbolo `⊢` digita `\\|-`.)\n\n* `repeat rw [add_zero]` riscriverà continuamente `? + 0` in `?`\nfinché non riesce più a trovare espressioni della forma `? + 0`.\n\n* `nth_rewrite 2 [h]` riscriverà solo la seconda `X` nel goal in `Y`.\n\n### Esempio:\n\nSe hai l'ipotesi `h : x = y + y` e il goal è\n```\nsucc (x + 0) = succ (y + y)\n```\n\nallora il comando\n\n`rw [add_zero]`\n\nriscriverà il goal in `succ x = succ (y + y)`, e poi il comando\n\n`rw [h]`\n\nriscriverà il goal in `succ (y + y) = succ (y + y)`, il quale\npuò essere risolto con `rfl`.\n\n### Esempio:\n\n`rw` può anche riscrivere nelle ipotesi.\nAd esempio, se hai le seguenti due ipotesi:\n```\nh1 : x = y + 3\nh2 : 2 * y = x\n```\neseguendo `rw [h1] at h2` sostituirà la `x` dentro `h2`, che diventerà `h2 : 2 * y = y + 3`.\n\n## Errori comuni\n\n* `rw` accetta una lista di teoremi, dunque le parentesi quadre sono sempre da mettere. Scrivere `rw h` è un errore di sintassi.\n\n* Inoltre, gli argomenti che passi a `rw` devono essere *prove* di *uguaglianza*, dunque dei teoremi che hai dimostrato in precedenza e che hanno la forma`A = B`).\nScrivere `rw [P = Q]` è sbagliato: `P = Q` è solo l'*affermazione* dell'uguaglianza,\nnon la sua dimostrazione. Se invece hai `h : P = Q` nel contesto, `h` è una dimostrazione di `P = Q` e allora potrai scrivere `rw [h]`.\n\n## Dettagli\n\n`rw` è la tattica che svolge la \\\"sostituzione\\\". Ci sono due casi in cui può\nessere usata:\n\n1) Uso basilare: se `h : A = B` è un'ipotesi del contesto\noppure la dimostrazione di un teorema, e se il goal contiene una o più `A`, allora `rw [h]`\nle sostituirà tutte con `B`. La tattica darà un errore\nse non ci sono `A` nel goal.\n\n2) Uso avanzato: certi teoremi hanno delle incognite.\n Ad esempio, `add_zero`\npuò essere trattato come un funzione il cui corpo è `? + 0 = ?`\ndove `?` è l'input. Applicando `rw` a `add_zero`, `rw` cercherà all'interno del goal\nun termine della forma `x + 0`; appena lo trova\nfissa l'incognita `?` a `x` e cambierà tutte le occorrenze di `x + 0` a `x`.\n\nEsercizio: prova a spiegare perché `rw [add_zero]` trasforma il termine\n`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` in\n`0 + (x + 0) + 0 + (x + 0)`\n\nSe non ti ricordi il nome di una dimostrazione di un'uguaglianza, puoi cercarlo\nnell'elenco di lemma sulla destra.\n\n## Uso mirato\n\nSe nel goal hai `b + c + a = b + (a + c)` e vuoi riscrivere solo il termine `a + c`\na `c + a`, invocare semplicemente `rw [add_comm]` non darà il risultato che ti aspetti perché Lean\napplica il teorema sulla prima espressione che ha un match con un'addizione. Puoi usare `rw [add_comm a c]` per\nfar sì che Lean riscriva `a + c` a `c + a`. In questo modo stai fissando le incognite del teorema:\n`add_comm` è la prova di `?1 + ?2 = ?2 + ?1`, `add_comm a` è la prova\ndi `a + ? = ? + a`, e infine `add_comm a c` è la prova di `a + c = c + a`.\n\nData la dimostrazione `h : X = Y`, `rw [h]` riscriverà tutte le `X` a `Y` nel goal.\nPer cambiare solo la trentasettesima occorrenza di `X`\na `Y`, il metodo giusto è `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`.": "## Descrizione\n\nSe hai `h : X = Y` e nel goal ci sono diverse `X`, con\n`nth_rewrite 3 [h]` puoi cambiare solo la terza `X` in `Y`.\n\n## Esempio\n\nSe il goal è `2 + 2 = 4` allora `nth_rewrite 2 [two_eq_succ_one]`\nsostituirà la seconda occorrenza di `2`, e il goal diventerà `2 + succ 1 = 4`. Invece, il semplice `rw [two_eq_succ_one]`\nsostituirà tutte le occorrenze di `2` e il goal diventerà `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 mirato\n\nNell'ultimo livello vi erano sia `b + 0` che `c + 0` da riscrivere,\ne `rw [add_zero]` ha scelto il primo che ha trovato,\nossia `b + 0`. Impariamo come dire a Lean\ndi riscrivere `c + 0` per primo dando ad `add_zero` un\ninput esplicito.", - "# 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. A new version\nof Advanced Multiplication World is in preparation, and worlds\nsuch as Prime Number World and more will be appearing during October and\nNovember 2023.\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.": + "# 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.": "# Benvenuto nel Gioco dei Numeri Naturali!\n#### Un'introduzione alla dimostrazione matematica.\n\nIn questo gioco costruiremo la teoria elementare dei numeri naturali\n`{0,1,2,3,4,...}` a partire da zero. Il nostro primo obiettivo è dimostrare\n`2 + 2 = 4`. Dopodiché dimostreremo `x + y = y + x`.\nInfine cercheremo di dimostrare l'Ultimo Teorema di Fermat.\nRisolveremo questi puzzle matematici in un ambiente interattivo chiamato Lean.\n\n# Leggi le istruzioni!\n\nImparare a usare un *interactive theorem prover* richiede tempo e impegno.\nLe statistiche mostrano che le persone che imparano di più da questo gioco sono\ncoloro che leggono attentamente il testo delle istruzioni, come questo.\n\nPer iniziare, clicca su \"Mondo Tutorial\".\n\nNota: questa è la versione del gioco per Lean 4 contenente diversi\nmondi che non erano presenti nella versione per Lean 3. Stiamo lavorando a una\nnuova versione del Mondo Moltiplicazione Avanzata e nuovi mondi\ntra cui Mondo Numeri Primi arriveranno durante Ottobre e\nNovembre 2023.\n\n## Altro\n\nClicca sulle tree lineette in alto a destra e seleziona \"Game Info\" per risorse,\nlink utili e vari modi per connetterti alla comunità di 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.": "# Descrizione\nLa tattica `right` trasforma un goal della forma `P ∨ Q` nel nuovo goal `Q`.\nUsala quando le tue ipotesi garantiscono che si può dedurre `P ∨ Q`\n\ndalla verità di `Q`.\n\nL'implementazione di Lean di questa tattica non fa altro che `apply` di un teorema\nche dice che $Q \\implies P \\lor Q.$\n\nNota bene che questa tattica può portare il tuo goal a uno stato irrisolvibile.", @@ -862,9 +864,9 @@ "# Descrizione\n\n`trivial` risolve il 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`.": "# Descrizione\n\nLa tattica `decide` cercherà di risolvere il goal se esiste un algoritmo\nche possiamo eseguire per risolverlo.\n\n## Esempio\n\nUn termine di tipo `DecidableEq ℕ` è un algoritmo che decide se due naturali\nsono uguali o diversi. Dunque, se abbiamo un'istanza di questo tipo,\nla tattica `decide` può usare la sua implementazione per risolvere i goal della forma `a = b` or `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## 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 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.": + "# 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.": "# Descrizione\n\nLa tattica `tauto` risolverà qualsiasi goal che può essere tramite puro ragionamento logico (ossia, tramite le\ntavole di verità).\n\n## Esempio\n\nSe hai `False` come ipotesi, allora `tauto` risolverà\nil goal. Questo perché un'ipotesi false implica qualsiasi cosa.\n\n## Esempio\n\nSe hai il goal `True`, allora `tauto` risolverà il goal.\n\n## Esempio\n\nSe hai due ipotesi `h1 : a = 37` e `h2 : a ≠ 37` allora `tauto` risolverà\nsolve il goal perché può dedurre `False` dalle tue ipotesi, e quindi\ndimostrare il goal (dato che `False` implica qualsiasi cosa).\n\n## Esempio\n\nSe hai un'ipotesi `h : a ≠ a` allora `tauto` risolverà il goal perché\nè abbastanza intelligente da capire che `a = a` è vero, arrivando alla contraddizione che cerchiamo.\n\n## Esempio\n\nSe hai un'ipotesi della forma `a = 0 → a * b = 0` e hai il goal `a * b ≠ 0 → a ≠ 0`, allora\n`tauto` risolverà il goal, because esso è logicamente equivalente all'ipotesi.\nE se scambi il ruolo del goal e dell'ipotesi in questo esempio, `tauto` lo risolverebbe lo stesso.", - "# 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. example\n\n`have h2 := succ_inj a b`\n\nwill add `h2 : succ a = succ b → a = b` as a hypothesis.": + "# 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.": "# Descrizione\n\nLa tattica `have` può essere usata per aggiungere un'ipotesi a un livello, ma ovviamente ti chiede\ndi dimostrarla.\n\n\n## Esempio\n\nIl suo utilizzo più semplice e così. Se hai `a` nel contesto e vuoi eseguire\n\n`have ha : a = 0`\n\nallora otterrai un nuovo goal `a = 0` da dimostrare, e dopo che l'hai dimostrato\navrai l'ipotesi `ha : a = 0` nel contesto originale.\n\n## Esempio\n\nSe hai già pronta la dimostrazione di ciò che vuoi introdurre con `have`,\npuoi farlo in un unico comando. Ad esempio, se hai `a` e `b`\ncome numeri, allora\n\n`have h2 : succ a = succ b → a = b := succ_inj a b`\n\naggiungerà direttamente l'ipotesi `h2 : succ a = succ b → a = b`\nal contesto, dato che hai fornito assieme la sua dimostrazione (`succ_inj a b`).\n\n## Esempio\n\nSe hai in mano una dimostrazione, puoi omettere il lemma che vuoi introdurre (quello tra i simboli `:` e `:=`).\nAd esempio:\n\n`have h2 := succ_inj a b`\n\naggiungerà `h2 : succ a = succ b → a = b` come ipotesi.", "# 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`.": "# Descrizione\n\nSe hai un'ipotesi\n\n`h : a ≠ b`\n\ne il goal\n\n`c ≠ d`\n\nallora `contrapose! h` cambierà l'impostazione con la cosiddetta \\\"contronominale\\\":\nun ipotesi\n\n`h : c = d`\n\ne il goal\n\n`a = b`.", diff --git a/.i18n/it/Game.po b/.i18n/it/Game.po index 3851f05..6ea7a6c 100644 --- a/.i18n/it/Game.po +++ b/.i18n/it/Game.po @@ -5,7 +5,7 @@ msgid "" msgstr "" "Project-Id-Version: Game v4.7.0\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: Mon Apr 29 13:18:35 2024\n" +"POT-Creation-Date: Wed Mar 19 21:43:40 2025\n" "PO-Revision-Date: 2024-12-03 12:15+0100\n" "Last-Translator: Federico Dal Pio Luogo \n" "Language-Team: Italian \n" @@ -52,8 +52,10 @@ msgid "" "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" +"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" @@ -62,18 +64,23 @@ msgid "" "\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" +"*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).*" +"as mathematicians are concerned, and who cares what the definition of " +"addition is).*" msgstr "" "## Riassunto\n" "\n" "`rfl` dimostra obiettivi della forma `X = X`.\n" "\n" "Detto in altre parole, la tattica `rfl` chiuderà qualsiasi goal della forma\n" -"forma `A = B` se `A` e `B` sono termini *identici*, ovvero sono scritti nello stesso modo.\n" +"forma `A = B` se `A` e `B` sono termini *identici*, ovvero sono scritti " +"nello stesso modo.\n" "\n" "`rfl` è l'abbreviazione di \"riflessività (di uguaglianza)\".\n" "\n" @@ -85,7 +92,9 @@ msgstr "" "x + 37 = x + 37\n" "```\n" "\n" -"allora `rfl` lo chiuderà. Ma su questo `0 + x = x` `rfl` non funzionerà, perché sebbene $0+x$ e $x$ *rappresentino* lo stesso numero, non sono termini identici.\n" +"allora `rfl` lo chiuderà. Ma su questo `0 + x = x` `rfl` non funzionerà, " +"perché sebbene $0+x$ e $x$ *rappresentino* lo stesso numero, non sono " +"termini identici.\n" "Perciò, l'unico termine identico a `0 + x` è `0 + x`.\n" "\n" "## Nel dettaglio\n" @@ -94,42 +103,56 @@ msgstr "" "\n" "## Note di implementazione\n" "\n" -"*Per motivi didattici questo gioco usa una versione di `rfl` più debole della versione di Lean e della sua libreria `mathlib`;\n" -"infatti nella matematica classica non vi è distinzione tra uguaglianza proposizionale e\n" -"e uguaglianza denotazionale, questa distinzione è rilevante solo nella teoria dei tipi.\n" -"(ad esempio, `zero_add` e `add_zero` sono entrambi dei \\\"fatti\\\" per quanto riguarda i matematici,\n" +"*Per motivi didattici questo gioco usa una versione di `rfl` più debole " +"della versione di Lean e della sua libreria `mathlib`;\n" +"infatti nella matematica classica non vi è distinzione tra uguaglianza " +"proposizionale e\n" +"e uguaglianza denotazionale, questa distinzione è rilevante solo nella " +"teoria dei tipi.\n" +"(ad esempio, `zero_add` e `add_zero` sono entrambi dei \\\"fatti\\\" per " +"quanto riguarda i matematici,\n" "a loro non interessa quale sia la definizione precisa di addizione).*" #: 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" +"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" +"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" +"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 "" "# Leggi questo prima\n" "\n" -"Ciascun livello di questo gioco consiste nel dimostrare un teorema matematico (il cosiddetto \"goal\").\n" -"Il goal è tipicamente un'affermazione che riguarda dei numeri. Certi numeri avranno dei valori ben precisi,\n" -"come $37$. Altri numeri saranno invece dati come incognite, e queste verranno denotate con delle lettere quali $x$ o $q$.\n" +"Ciascun livello di questo gioco consiste nel dimostrare un teorema " +"matematico (il cosiddetto \"goal\").\n" +"Il goal è tipicamente un'affermazione che riguarda dei numeri. Certi numeri " +"avranno dei valori ben precisi,\n" +"come $37$. Altri numeri saranno invece dati come incognite, e queste " +"verranno denotate con delle lettere quali $x$ o $q$.\n" "Possiamo dire con certezza che $x$ è un numero, ma non sappiamo quale!\n" "\n" "In questo primo livello dimostreremo il teorema $37x + q = 37x + q$.\n" -"Nella sezione *Oggetti* in basso puoi vedere `x q : ℕ`, che significa che `x` e `q`\n" +"Nella sezione *Oggetti* in basso puoi vedere `x q : ℕ`, che significa che " +"`x` e `q`\n" "sono numeri naturali.\n" "\n" -"Per risolvere i goal in Lean usiamo le *tattiche*. La prima tattica che vedremo si chiama `rfl`, che\n" +"Per risolvere i goal in Lean usiamo le *tattiche*. La prima tattica che " +"vedremo si chiama `rfl`, che\n" "dimostra tutti i goal della forma $X = X$.\n" "\n" "Adesso tocca a te! Dimostra $37x+q=37x+q$ eseguendo la tattica `rfl`." @@ -150,14 +173,16 @@ msgstr "" 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" +"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 "" "Congratulazioni! Hai completato la tua prima dimostrazione formale!\n" "\n" -"Ricorda che `rfl` è una *tattica*. Se vuoi sapere di più sulla tattica `rfl`,\n" +"Ricorda che `rfl` è una *tattica*. Se vuoi sapere di più sulla tattica " +"`rfl`,\n" "clicca su `rfl` nella lista di tattiche a destra.\n" "\n" "Adesso vedremo la tattica `rw`. Premi \"Avanti\"." @@ -167,6 +192,7 @@ msgid "the rw tactic" msgstr "la tattica rw" #: Game.Levels.Tutorial.L02rw +#, fuzzy msgid "" "## Summary\n" "\n" @@ -175,7 +201,8 @@ msgid "" "\n" "## Variants\n" "\n" -"* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\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" @@ -221,7 +248,8 @@ msgid "" "\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" +"* 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" @@ -233,8 +261,9 @@ msgid "" "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" +"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" @@ -267,11 +296,13 @@ msgstr "" "## Descrizione\n" "\n" "Se `h` è una prova dell'uguaglianza `X = Y`, allora `rw [h]` scriverà\n" -"`Y` al posto di ogni `X` nel goal. `rw` svolge l'operazione di \\\"sostituzione\\\".\n" +"`Y` al posto di ogni `X` nel goal. `rw` svolge l'operazione di \\" +"\"sostituzione\\\".\n" "\n" "## Varianti di `rw`\n" "\n" -"* `rw [← h]` (riscrive le `Y` con `X`; per avere la freccetta all'indietro si digita `\\left ` oppure `\\l`.)\n" +"* `rw [← h]` (riscrive le `Y` con `X`; per avere la freccetta all'indietro " +"si digita `\\left ` oppure `\\l`.)\n" "\n" "* `rw [h1, h2]` (sostituzioni in sequenza)\n" "\n" @@ -311,50 +342,66 @@ msgstr "" "h1 : x = y + 3\n" "h2 : 2 * y = x\n" "```\n" -"eseguendo `rw [h1] at h2` sostituirà la `x` dentro `h2`, che diventerà `h2 : 2 * y = y + 3`.\n" +"eseguendo `rw [h1] at h2` sostituirà la `x` dentro `h2`, che diventerà `h2 : " +"2 * y = y + 3`.\n" "\n" "## Errori comuni\n" "\n" -"* `rw` accetta una lista di teoremi, dunque le parentesi quadre sono sempre da mettere. Scrivere `rw h` è un errore di sintassi.\n" +"* `rw` accetta una lista di teoremi, dunque le parentesi quadre sono sempre " +"da mettere. Scrivere `rw h` è un errore di sintassi.\n" "\n" -"* Inoltre, gli argomenti che passi a `rw` devono essere *prove* di *uguaglianza*, dunque dei teoremi che hai dimostrato in precedenza e che hanno la forma`A = B`).\n" -"Scrivere `rw [P = Q]` è sbagliato: `P = Q` è solo l'*affermazione* dell'uguaglianza,\n" -"non la sua dimostrazione. Se invece hai `h : P = Q` nel contesto, `h` è una dimostrazione di `P = Q` e allora potrai scrivere `rw [h]`.\n" +"* Inoltre, gli argomenti che passi a `rw` devono essere *prove* di " +"*uguaglianza*, dunque dei teoremi che hai dimostrato in precedenza e che " +"hanno la forma`A = B`).\n" +"Scrivere `rw [P = Q]` è sbagliato: `P = Q` è solo l'*affermazione* " +"dell'uguaglianza,\n" +"non la sua dimostrazione. Se invece hai `h : P = Q` nel contesto, `h` è una " +"dimostrazione di `P = Q` e allora potrai scrivere `rw [h]`.\n" "\n" "## Dettagli\n" "\n" -"`rw` è la tattica che svolge la \\\"sostituzione\\\". Ci sono due casi in cui può\n" +"`rw` è la tattica che svolge la \\\"sostituzione\\\". Ci sono due casi in " +"cui può\n" "essere usata:\n" "\n" "1) Uso basilare: se `h : A = B` è un'ipotesi del contesto\n" -"oppure la dimostrazione di un teorema, e se il goal contiene una o più `A`, allora `rw [h]`\n" +"oppure la dimostrazione di un teorema, e se il goal contiene una o più `A`, " +"allora `rw [h]`\n" "le sostituirà tutte con `B`. La tattica darà un errore\n" "se non ci sono `A` nel goal.\n" "\n" "2) Uso avanzato: certi teoremi hanno delle incognite.\n" " Ad esempio, `add_zero`\n" "può essere trattato come un funzione il cui corpo è `? + 0 = ?`\n" -"dove `?` è l'input. Applicando `rw` a `add_zero`, `rw` cercherà all'interno del goal\n" +"dove `?` è l'input. Applicando `rw` a `add_zero`, `rw` cercherà all'interno " +"del goal\n" "un termine della forma `x + 0`; appena lo trova\n" -"fissa l'incognita `?` a `x` e cambierà tutte le occorrenze di `x + 0` a `x`.\n" +"fissa l'incognita `?` a `x` e cambierà tutte le occorrenze di `x + 0` a " +"`x`.\n" "\n" "Esercizio: prova a spiegare perché `rw [add_zero]` trasforma il termine\n" "`(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` in\n" "`0 + (x + 0) + 0 + (x + 0)`\n" "\n" -"Se non ti ricordi il nome di una dimostrazione di un'uguaglianza, puoi cercarlo\n" +"Se non ti ricordi il nome di una dimostrazione di un'uguaglianza, puoi " +"cercarlo\n" "nell'elenco di lemma sulla destra.\n" "\n" "## Uso mirato\n" "\n" -"Se nel goal hai `b + c + a = b + (a + c)` e vuoi riscrivere solo il termine `a + c`\n" -"a `c + a`, invocare semplicemente `rw [add_comm]` non darà il risultato che ti aspetti perché Lean\n" -"applica il teorema sulla prima espressione che ha un match con un'addizione. Puoi usare `rw [add_comm a c]` per\n" -"far sì che Lean riscriva `a + c` a `c + a`. In questo modo stai fissando le incognite del teorema:\n" +"Se nel goal hai `b + c + a = b + (a + c)` e vuoi riscrivere solo il termine " +"`a + c`\n" +"a `c + a`, invocare semplicemente `rw [add_comm]` non darà il risultato che " +"ti aspetti perché Lean\n" +"applica il teorema sulla prima espressione che ha un match con un'addizione. " +"Puoi usare `rw [add_comm a c]` per\n" +"far sì che Lean riscriva `a + c` a `c + a`. In questo modo stai fissando le " +"incognite del teorema:\n" "`add_comm` è la prova di `?1 + ?2 = ?2 + ?1`, `add_comm a` è la prova\n" "di `a + ? = ? + a`, e infine `add_comm a c` è la prova di `a + c = c + a`.\n" "\n" -"Data la dimostrazione `h : X = Y`, `rw [h]` riscriverà tutte le `X` a `Y` nel goal.\n" +"Data la dimostrazione `h : X = Y`, `rw [h]` riscriverà tutte le `X` a `Y` " +"nel goal.\n" "Per cambiare solo la trentasettesima occorrenza di `X`\n" "a `Y`, il metodo giusto è `nth_rewrite 37 [h]`." @@ -383,14 +430,16 @@ msgid "" "## 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 `2 + succ 1 = 4`. In contrast, `rw " +"[two_eq_succ_one]`\n" "will change the goal to `succ 1 + succ 1 = 4`." msgstr "" "## Descrizione\n" "\n" "`repeat t` applica la tattica `t`\n" "nel goal ripetitivamente. Non è necessario usare questa tattica\n" -"per completare il gioco, ma a volte è utile nel rendere le dimostrazioni più succinte.\n" +"per completare il gioco, ma a volte è utile nel rendere le dimostrazioni più " +"succinte.\n" "\n" "## Esempio\n" "\n" @@ -409,8 +458,10 @@ msgstr "" "## Esempio\n" "\n" "Se nel goal hai `2 + 2 = 4` allora con `nth_rewrite 2 [two_eq_succ_one]`\n" -"sostituisce la seconda occorrenza del lato sinistro di `two_eq_succ_one`, e il goal diventa `2 + succ 1 = 4`. Invece il normale `rw [two_eq_succ_one]`\n" -"sostituira la prima occorrenza di `2` nel goal, che diventa `succ 1 + succ 1 = 4`." +"sostituisce la seconda occorrenza del lato sinistro di `two_eq_succ_one`, e " +"il goal diventa `2 + succ 1 = 4`. Invece il normale `rw [two_eq_succ_one]`\n" +"sostituira la prima occorrenza di `2` nel goal, che diventa `succ 1 + succ 1 " +"= 4`." #: Game.Levels.Tutorial.L02rw msgid "" @@ -422,7 +473,8 @@ msgid "" "## 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 `2 + succ 1 = 4`. In contrast, `rw " +"[two_eq_succ_one]`\n" "will change the goal to `succ 1 + succ 1 = 4`." msgstr "" "## Descrizione\n" @@ -433,13 +485,16 @@ msgstr "" "## Esempio\n" "\n" "Se il goal è `2 + 2 = 4` allora `nth_rewrite 2 [two_eq_succ_one]`\n" -"sostituirà la seconda occorrenza di `2`, e il goal diventerà `2 + succ 1 = 4`. Invece, il semplice `rw [two_eq_succ_one]`\n" -"sostituirà tutte le occorrenze di `2` e il goal diventerà `succ 1 + succ 1 = 4`." +"sostituirà la seconda occorrenza di `2`, e il goal diventerà `2 + succ 1 = " +"4`. Invece, il semplice `rw [two_eq_succ_one]`\n" +"sostituirà tutte le occorrenze di `2` e il goal diventerà `succ 1 + succ 1 = " +"4`." #: Game.Levels.Tutorial.L02rw 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" +"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" @@ -448,33 +503,43 @@ msgid "" "using the `rw` tactic." msgstr "" "In questo livello il *goal* è $2y=2(x+7)$ e l'unica informazione che\n" -"può aiutarci a dimostrarlo è l'*ipotesi* `h` che dice $y = x + 7$. Verifica di avere `h` sotto la voce \"Ipotesi\".\n" +"può aiutarci a dimostrarlo è l'*ipotesi* `h` che dice $y = x + 7$. Verifica " +"di avere `h` sotto la voce \"Ipotesi\".\n" "Lean vede `h` come una dimostrazione segreta dell'ipotesi,\n" "un po' come il valore della variabile `x` è un'incognita.\n" "\n" -"Prima di poter usare la tattica `rfl`, dobbiamo \"sostituire per la variabile $y$\".\n" +"Prima di poter usare la tattica `rfl`, dobbiamo \"sostituire per la " +"variabile $y$\".\n" "In Lean possiamo *riscrivere* la dimostrazione `h`\n" "attraverso la tattica `rw`." #: Game.Levels.Tutorial.L02rw -msgid "If $x$ and $y$ are natural numbers, and $y = x + 7$, then $2y = 2(x + 7)$." -msgstr "Se $x$ e $y$ sono numeri naturali, e $y = x + 7$, allora $2y = 2(x + 7)$." +msgid "" +"If $x$ and $y$ are natural numbers, and $y = x + 7$, then $2y = 2(x + 7)$." +msgstr "" +"Se $x$ e $y$ sono numeri naturali, e $y = x + 7$, allora $2y = 2(x + 7)$." #: Game.Levels.Tutorial.L02rw msgid "First execute `rw [h]` to replace the `y` with `x + 7`." msgstr "Innanzitutto, esegui `rw [h]` per sostituire `y` con `x + 7`." #: Game.Levels.Tutorial.L02rw -msgid "Can you take it from here? Click on \"Show more help!\" if you need a hint." -msgstr "Riesci a finire la dimostrazione da solo? Clicca su \"Aiutami!\" se hai bisogno di un indizio." +msgid "" +"Can you take it from here? Click on \"Show more help!\" if you need a hint." +msgstr "" +"Riesci a finire la dimostrazione da solo? Clicca su \"Aiutami!\" se hai " +"bisogno di un indizio." #: Game.Levels.Tutorial.L02rw msgid "Now `rfl` will work." msgstr "Adesso `rfl` funzionerà." #: Game.Levels.Tutorial.L02rw -msgid "You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey." -msgstr "Ora conosci abbastanza tattiche per dimostrare `2 + 2 = 4`! Proseguiamo l'avventura." +msgid "" +"You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey." +msgstr "" +"Ora conosci abbastanza tattiche per dimostrare `2 + 2 = 4`! Proseguiamo " +"l'avventura." #: Game.Levels.Tutorial.L03two_eq_ss0 msgid "Numbers" @@ -490,11 +555,13 @@ msgid "" "\n" "## Game Implementation\n" "\n" -"*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\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 "" -"`ℕ` denota l'insieme dei numeri naturali, che chiameremo semplicemente \\\"numeri \\\" nel resto del gioco. Questo insieme è\n" +"`ℕ` denota l'insieme dei numeri naturali, che chiameremo semplicemente \\" +"\"numeri \\\" nel resto del gioco. Questo insieme è\n" "definito tramite due regole:\n" "\n" "* `0 : ℕ` (zero è un numero)\n" @@ -502,7 +569,8 @@ msgstr "" "\n" "## Implementazione del gioco \n" "\n" -"*Il gioco usa una versione propria dei numeri naturali - chiamata `Mynat` con notazione` ℕ` -\n" +"*Il gioco usa una versione propria dei numeri naturali - chiamata `Mynat` " +"con notazione` ℕ` -\n" "diversa dal tipo primitivo dei numeri naturali di Lean `Nat`; quest'ultimo\n" "non dovrebbe venire utilizzato nel contesto del gioco.*" @@ -553,28 +621,37 @@ msgstr "" "* `0` è un numero.\n" "* Se `n` è un numero, allora il *successore* `succ n` di `n` è un numero.\n" "\n" -"Il successore di `n` è il numero che viene dopo `n`. Impariamo a contare in questo sistema,\n" +"Il successore di `n` è il numero che viene dopo `n`. Impariamo a contare in " +"questo sistema,\n" "provando a scrivere alcuni numeri piccoli.\n" "\n" "## Contiamo fino a quattro\n" "\n" -"`0` è un numero, e `succ 0` è un numero. Diamo a quest'ultimo numero il nome `1`.\n" +"`0` è un numero, e `succ 0` è un numero. Diamo a quest'ultimo numero il nome " +"`1`.\n" "In modo simile, definiamo `2 = succ 1`, `3 = succ 2` e `4 = succ 3`.\n" -"Questi primi quattro numeri sono più che sufficienti per proseguire il nostro ragionamento.\n" +"Questi primi quattro numeri sono più che sufficienti per proseguire il " +"nostro ragionamento.\n" "\n" "La *dimostrazione* di `2 = succ 1` si chiama `two_eq_succ_one`.\n" -"Puoi trovarla cliccando sul tab \"012\" nella lista di lemmi a destra nell'interfaccia,\n" +"Puoi trovarla cliccando sul tab \"012\" nella lista di lemmi a destra " +"nell'interfaccia,\n" "dove vedrai lei e altre dimostrazioni.\n" "\n" -"Ora dimostriamo che $2$ è il numero che viene dopo il numero che viene dopo zero." +"Ora dimostriamo che $2$ è il numero che viene dopo il numero che viene dopo " +"zero." #: Game.Levels.Tutorial.L03two_eq_ss0 Game.Levels.Tutorial.L04rw_backwards msgid "$2$ is the number after the number after $0$." msgstr "$2$ è il numero che viene dopo il numero che viene dopo $0$." #: Game.Levels.Tutorial.L03two_eq_ss0 -msgid "Start with `rw [two_eq_succ_one]` to begin to break `2` down into its definition." -msgstr "Inizia eseguendo `rw [two_eq_succ_one]` per sostituire `2` con la sua definizione." +msgid "" +"Start with `rw [two_eq_succ_one]` to begin to break `2` down into its " +"definition." +msgstr "" +"Inizia eseguendo `rw [two_eq_succ_one]` per sostituire `2` con la sua " +"definizione." #: Game.Levels.Tutorial.L03two_eq_ss0 msgid "Can you take it from here?" @@ -615,11 +692,13 @@ msgstr "" "Se `h` è una prova di `X = Y` allora `rw [h]` riscriverà\n" "le `X` in `Y`. E se volessimo invece riscrive\n" "le `Y` in `X`? Per dire alla tattica `rw` che vogliamo\n" -"riscrivere nell'altro verso, usiamo una freccetta a sinistra `←`. Per ottenere questa freccetta, digita\n" +"riscrivere nell'altro verso, usiamo una freccetta a sinistra `←`. Per " +"ottenere questa freccetta, digita\n" "`\\l` e premi la barra spaziatrice.\n" "\n" "Dimostriamo che $2$ è il numero che viene dopo il numero che viene dopo\n" -"$0$ di nuovo, però questa volta procediamo nel senso opposto, trasformando `succ (succ 0)`\n" +"$0$ di nuovo, però questa volta procediamo nel senso opposto, trasformando " +"`succ (succ 0)`\n" "in `2`." #: Game.Levels.Tutorial.L04rw_backwards @@ -639,8 +718,10 @@ 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 "" -"Come mai non abbiamo definito `succ n` semplicemente come `n + 1`? Perché non abbiamo\n" -"ancora *definito* il concetto di addizione! Provvederemo nel prossimo livello." +"Come mai non abbiamo definito `succ n` semplicemente come `n + 1`? Perché " +"non abbiamo\n" +"ancora *definito* il concetto di addizione! Provvederemo nel prossimo " +"livello." #: Game.Levels.Tutorial.L05add_zero msgid "Adding zero" @@ -667,7 +748,8 @@ msgstr "" "\n" "* `add_succ a b : a + succ b = succ (a + b)`\n" "\n" -"Gli altri teoremi sui numeri naturali e l'addizione, come `zero_add a : 0 + a = a`, si dimostrano\n" +"Gli altri teoremi sui numeri naturali e l'addizione, come `zero_add a : 0 + " +"a = a`, si dimostrano\n" "per induzione usando questi due teoremi fondamentali.\"" #: Game.Levels.Tutorial.L05add_zero @@ -708,7 +790,8 @@ msgstr "" "## Dettagli\n" "\n" "Ai matematici piace pensare a `add_zero`\n" -"come un'\\\"unica cosa\\\", ossia la dimostrazione che $\\forall n ∈ ℕ, n + 0 = n$.\n" +"come un'\\\"unica cosa\\\", ossia la dimostrazione che $\\forall n ∈ ℕ, n + " +"0 = n$.\n" "Questa è un'altra notazione per dire che è una funzione che\n" "prende un qualsiasi numero n e restituisce una dimostrazione che `n + 0 = n`." @@ -779,11 +862,13 @@ msgstr "" "\n" "### Aggiungere zero\n" "\n" -"Per far sì che l'addizione rispetti la nostra intuizione, *definiamo* `37 + 0`\n" +"Per far sì che l'addizione rispetti la nostra intuizione, *definiamo* `37 + " +"0`\n" "come `37`. In generale, definiamo `a + 0` uguale ad `a` per\n" "qualsiasi numero `a`. Questa dimostrazione in Lean si chiama `add_zero a`.\n" "Ad esempio `add_zero 37` è la dimostrazione di `37 + 0 = 37`,\n" -"`add_zero x` è la dimostrazione di `x + 0 = x`, `add_zero` da solo è la dimostrazione\n" +"`add_zero x` è la dimostrazione di `x + 0 = x`, `add_zero` da solo è la " +"dimostrazione\n" "di `? + 0 = ?`.\n" "\n" "La sintassi è `add_zero x : x + 0 = x`, dunque `dimostrazione : enunciato`." @@ -837,11 +922,14 @@ msgstr "Esegui `rw [add_zero c]`." #: 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" +"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` è la dimostrazione di `c + 0 = c`, proprio quello che è stato riscritto.\n" -"Ora puoi scambiare `b + 0` con `b` scrivendo `rw [add_zero]` o `rw [add_zero b]`. Nella pratica, usa\n" +"`add_zero c` è la dimostrazione di `c + 0 = c`, proprio quello che è stato " +"riscritto.\n" +"Ora puoi scambiare `b + 0` con `b` scrivendo `rw [add_zero]` o `rw [add_zero " +"b]`. Nella pratica, usa\n" "`rw [add_zero]` quando non hai bisogno di precisare il termine da sostituire." #: Game.Levels.Tutorial.L06add_zero2 @@ -875,14 +963,18 @@ msgid "" "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" +"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 "" -"Ogni numero in Lean è $0$ oppure il successore di un altro numero. Abbiamo già visto come aggiungere $0$,\n" +"Ogni numero in Lean è $0$ oppure il successore di un altro numero. Abbiamo " +"già visto come aggiungere $0$,\n" "e ci rimane da capire come aggiungere un successore. Ipotizziamo di sapere\n" -"che vale l'uguaglianza `37 + d = q`. A cosa dovrebbe essere uguale `37 + succ d`? Beh,\n" -"`succ d` è un'unità più grande di `d`, quindi `37 + succ d` dovrebbe essere `succ q`,\n" +"che vale l'uguaglianza `37 + d = q`. A cosa dovrebbe essere uguale `37 + " +"succ d`? Beh,\n" +"`succ d` è un'unità più grande di `d`, quindi `37 + succ d` dovrebbe essere " +"`succ q`,\n" "ossia un'unità più grande di `q`. In generale `x + succ d` dovrebbe\n" "dare `succ (x + d)`. Formalizziamo questo ragionamento in un lemma.\n" "\n" @@ -892,13 +984,15 @@ msgstr "" "buona idea.\n" "\n" "Dimostriamo ora che `succ n = n + 1`. Cerca di introdurre un `+ succ` nel\n" -"goal, poi esegui `rw [add_succ]`. Controlla entrambi i tab `+` (addizione) e\n" +"goal, poi esegui `rw [add_succ]`. Controlla entrambi i tab `+` (addizione) " +"e\n" "`012` (numeri) nella sezione \"Teoremi\" a destra\n" "per vedere quali teoremi da riscrivere hai a disposizione." #: Game.Levels.Tutorial.L07add_succ msgid "For all natural numbers $a$, we have $\\operatorname{succ}(a) = a+1$." -msgstr "Per ogni numero naturale $a$, si ha che $\\operatorname{succ}(a) = a+1$." +msgstr "" +"Per ogni numero naturale $a$, si ha che $\\operatorname{succ}(a) = a+1$." #: Game.Levels.Tutorial.L07add_succ msgid "Start by unravelling the `1`." @@ -932,13 +1026,15 @@ msgstr "2+2=4" msgid "" "Good luck!\n" "\n" -" One last hint. If `h : X = Y` then `rw [h]` will change *all* `X`s into `Y`s.\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 "" "Buona fortuna!\n" "\n" -" Un'ultima cosa. Se hai `h : X = Y`, con `rw [h]` cambierai *tutte* le `X` in`Y`.\n" +" Un'ultima cosa. Se hai `h : X = Y`, con `rw [h]` cambierai *tutte* le `X` " +"in`Y`.\n" " Se vuoi cambiarne solo una, la terza ad esempio, allora devi scrivere\n" "`nth_rewrite 3 [h]`." @@ -947,8 +1043,12 @@ msgid "$2+2=4$." msgstr "$2+2=4$." #: 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]` più veloce di `rw [two_eq_succ_one]`, secondo me." +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]` più veloce di `rw [two_eq_succ_one]`, " +"secondo me." #: Game.Levels.Tutorial.L08twoaddtwo msgid "" @@ -964,12 +1064,14 @@ msgid "" "rfl\n" "```\n" "\n" -"Optional extra: you can run this proof yourself. Switch the game into \"Editor mode\" by clicking\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" +"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" @@ -989,12 +1091,17 @@ msgstr "" "rfl\n" "```\n" "\n" -"Esercizio facoltativo: prova ad eseguire questa dimostrazione. Entra nella \"Modalità editor\" cliccando sul pulsante\n" +"Esercizio facoltativo: prova ad eseguire questa dimostrazione. Entra nella " +"\"Modalità editor\" cliccando sul pulsante\n" "`` in alto a destra. Dovresti vedere la tua dimostrazione estesa su\n" "diverse linee di codice. Muovendo il cursore da una linea all'altra vedrai\n" -"lo stato della dimostrazione in ogni punto. Ora copia la tua dimostrazione e salvala da qualche parte per non\n" -"perderla, e incolla la dimostrazione che abbiamo riportato qui sopra al posto del tuo codice. Muovi il cursore\n" -"tra le linee per vedere come si comporta, sperimenta un po' con l'interfaccia. Quando hai finito, premi il pulsante `>_` in alto a destra per\n" +"lo stato della dimostrazione in ogni punto. Ora copia la tua dimostrazione e " +"salvala da qualche parte per non\n" +"perderla, e incolla la dimostrazione che abbiamo riportato qui sopra al " +"posto del tuo codice. Muovi il cursore\n" +"tra le linee per vedere come si comporta, sperimenta un po' con " +"l'interfaccia. Quando hai finito, premi il pulsante `>_` in alto a destra " +"per\n" "ritornare nella \"Modalità interattiva\".\n" "\n" "Hai completato il Mondo Tutorial!\n" @@ -1023,11 +1130,13 @@ msgstr "" "della dimostrazione formale. Il livello boss di questo mondo\n" "è il teorema `2 + 2 = 4`.\n" "\n" -"Dimostrare i teoremi consiste nel risolvere dei puzzle matematici utilizzando degli strumenti chiamati *tactics* (tattiche).\n" +"Dimostrare i teoremi consiste nel risolvere dei puzzle matematici " +"utilizzando degli strumenti chiamati *tactics* (tattiche).\n" "Per dimostrare un teorema dovrai applicare le tattiche nell'ordine\n" "giusto.\n" "\n" -"Impariamo subito qualche tattica basilare. Premi sul pulsante \"Via\" qui sotto\n" +"Impariamo subito qualche tattica basilare. Premi sul pulsante \"Via\" qui " +"sotto\n" "per cominciare l'avventura." #: Game.Levels.Addition.L01zero_add @@ -1036,40 +1145,54 @@ msgstr "zero_add" #: 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" +"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" +"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" +"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" +"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" +"`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" +"(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 "" -"In questo livello dimostreremo l'enunciato $0+n=n$, dove $n$ è un numero naturale incognito.\n" +"In questo livello dimostreremo l'enunciato $0+n=n$, dove $n$ è un numero " +"naturale incognito.\n" "\n" -"Ma come, non l'abbiamo già dimostrato? No! Abbiamo dimostrato $n+0=n$, che abbiamo chiamato `add_zero`.\n" +"Ma come, non l'abbiamo già dimostrato? No! Abbiamo dimostrato $n+0=n$, che " +"abbiamo chiamato `add_zero`.\n" "Questo è `zero_add`, un teorema diverso.\n" "\n" -"Ciò che complica le cose nel dimostrare `0 + n = n` è che non abbiamo una *formula* per riscrivere\n" -"`0 + n` in generale, possiamo solo applicare `add_zero` o `add_succ` una volta che sappiamo che\n" -"`n` è `0` oppure un successore. La tattica `induction` spezza la dimostrazione in questi due casi.\n" +"Ciò che complica le cose nel dimostrare `0 + n = n` è che non abbiamo una " +"*formula* per riscrivere\n" +"`0 + n` in generale, possiamo solo applicare `add_zero` o `add_succ` una " +"volta che sappiamo che\n" +"`n` è `0` oppure un successore. La tattica `induction` spezza la " +"dimostrazione in questi due casi.\n" "\n" -"Nel caso base dovremo dimostrare `0 + 0 = 0`, e nel caso induttivo dovremo dimostrare\n" +"Nel caso base dovremo dimostrare `0 + 0 = 0`, e nel caso induttivo dovremo " +"dimostrare\n" "che se `0 + d = d` allora `0 + succ d = succ d`. Dato che\n" -"`0` e il successore sono i due soli modi per costruire i numeri naturali, la dimostrazione coprirà tutti i casi possibili.\n" +"`0` e il successore sono i due soli modi per costruire i numeri naturali, la " +"dimostrazione coprirà tutti i casi possibili.\n" "\n" "Ora prova a svolgere la tua prima dimostrazione per induzione su Lean.\n" "\n" -"(Se sei ancora nella \"Modalità editor\" dallo scorso mondo, puoi rientrare nella\n" +"(Se sei ancora nella \"Modalità editor\" dallo scorso mondo, puoi rientrare " +"nella\n" "\"Modalità interattiva\" cliccando sul pulsante `>_` in alto a destra.)" #: Game.Levels.Addition.L01zero_add @@ -1081,8 +1204,10 @@ msgid "" msgstr "" "`zero_add x` è la dimostrazione di `0 + x = x`.\n" "\n" -"`zero_add` è un lemma del tipo `simp` (semplificazione), infatti sostituire `0 + x` con `x`\n" -"è quasi sempre uno dei passi più ovvi della semplificazione di un'espressione." +"`zero_add` è un lemma del tipo `simp` (semplificazione), infatti sostituire " +"`0 + x` con `x`\n" +"è quasi sempre uno dei passi più ovvi della semplificazione di " +"un'espressione." #: Game.Levels.Addition.L01zero_add msgid "For all natural numbers $n$, we have $0 + n = n$." @@ -1098,17 +1223,20 @@ msgstr "" #: Game.Levels.Addition.L01zero_add msgid "" -"Now you have two goals. Once you proved the first, you will jump to the second one.\n" +"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 "" -"Ora hai due goal. Appena dimostrerai il primo, ti verrà dato il secondo goal da dimostrare.\n" +"Ora hai due goal. Appena dimostrerai il primo, ti verrà dato il secondo goal " +"da dimostrare.\n" "Questo primo goal rappresenta il caso base $n = 0$.\n" "\n" -"Ricorda che puoi riscrivere la dimostrazione di qualsiasi lemma che è visibile\n" +"Ricorda che puoi riscrivere la dimostrazione di qualsiasi lemma che è " +"visibile\n" "nell'inventario, o una qualsiasi ipotesi presente al di sopra del goal,\n" "a patto che abbia la forma `X = Y`." @@ -1119,10 +1247,12 @@ msgstr "prova a riscrivere `add_zero`." #: Game.Levels.Addition.L01zero_add 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}»`." +"`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = " +"succ «{d}»`." msgstr "" "Adesso viene il secondo goal. Qui hai l'ipotesi induttiva\n" -"`«{hd}» : 0 + «{d}» = «{d}»`, e devi dimostrare che `0 + succ «{d}» = succ «{d}»`." +"`«{hd}» : 0 + «{d}» = «{d}»`, e devi dimostrare che `0 + succ «{d}» = succ " +"«{d}»`." #: Game.Levels.Addition.L01zero_add msgid "Use `add_succ`." @@ -1140,9 +1270,11 @@ msgstr "" msgid "" "## Summary\n" "\n" -"If `n : ℕ` is an object, and the goal mentions `n`, then `induction n with d hd`\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" +"variable in the successor case being `d`, and the inductive hypothesis being " +"`hd`.\n" "\n" "### Example:\n" "If the goal is\n" @@ -1163,9 +1295,12 @@ msgid "" msgstr "" "## Descrizione\n" "\n" -"Se `n : ℕ` è un oggetto, e il goal fa il nome di `n`, allora `induction n with d hd`\n" -"avvia la dimostrazione per induzione attorno alla variabile `n`, con la variabile\n" -"induttiva nel caso del successore chiamata `d` e l'ipotesi induttiva chiamata`hd`.\n" +"Se `n : ℕ` è un oggetto, e il goal fa il nome di `n`, allora `induction n " +"with d hd`\n" +"avvia la dimostrazione per induzione attorno alla variabile `n`, con la " +"variabile\n" +"induttiva nel caso del successore chiamata `d` e l'ipotesi induttiva " +"chiamata`hd`.\n" "\n" "### Esempio:\n" "Se il goal è\n" @@ -1186,17 +1321,22 @@ msgstr "" #: 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" +"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 "" -"Questo lemma sarebbe stato semplice se avessimo potuto usare `x + y = y + x`. Quel teorema\n" -" si chiama `add_comm` e, sebbene sia *vero*, la sua dimostrazione *dipende* sia da\n" +"Questo lemma sarebbe stato semplice se avessimo potuto usare `x + y = y + " +"x`. Quel teorema\n" +" si chiama `add_comm` e, sebbene sia *vero*, la sua dimostrazione *dipende* " +"sia da\n" " `add_zero` che da `zero_add`!\n" "\n" -" Proseguiamo la nostra avventura verso `add_comm`, la dimostrazione di `x + y = y + x`." +" Proseguiamo la nostra avventura verso `add_comm`, la dimostrazione di `x + " +"y = y + x`." #: Game.Levels.Addition.L02succ_add msgid "succ_add" @@ -1208,13 +1348,18 @@ msgid "" "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." +"to use induction to split into the cases where `b = 0` and `b` is a " +"successor." msgstr "" -"Oh no! Lungo la strada per `add_comm`, salta fuori un `succ_add` selvatico. `succ_add a b`\n" -"è la dimostrazione dell'enunciato `(succ a) + b = succ (a + b)` per due numeri `a` e `b` qualsiasi.\n" -"Questo risultato è ciò che ci manca per dimostrare `x + y = y + x`. E ancora una volta,\n" +"Oh no! Lungo la strada per `add_comm`, salta fuori un `succ_add` selvatico. " +"`succ_add a b`\n" +"è la dimostrazione dell'enunciato `(succ a) + b = succ (a + b)` per due " +"numeri `a` e `b` qualsiasi.\n" +"Questo risultato è ciò che ci manca per dimostrare `x + y = y + x`. E ancora " +"una volta,\n" "abbiamo il problema di sommare una `b` generica a destra, dunque dobbiamo\n" -"ricorrere all'induzione per spezzare questa `b` nei casi in cui `b = 0` e `b` è un successore." +"ricorrere all'induzione per spezzare questa `b` nei casi in cui `b = 0` e " +"`b` è un successore." #: Game.Levels.Addition.L02succ_add msgid "`succ_add a b` is a proof that `succ a + b = succ (a + b)`." @@ -1250,11 +1395,15 @@ msgid "" "on any `succ` in the goal or assumptions to see what exactly it's eating." msgstr "" "Attento che `succ a + «{d}»` sta per `(succ a) + «{d}»`. Sposta il mouse\n" -"sopra `succ` o nel goal o nelle ipotesi per capire su cosa agisce esattamente." +"sopra `succ` o nel goal o nelle ipotesi per capire su cosa agisce " +"esattamente." #: Game.Levels.Addition.L02succ_add -msgid "Well done! You now have enough tools to tackle the main boss of this level." -msgstr "Ottimo lavoro! Ora sei abbastanza pratico per affrontare il boss principale di questo mondo." +msgid "" +"Well done! You now have enough tools to tackle the main boss of this level." +msgstr "" +"Ottimo lavoro! Ora sei abbastanza pratico per affrontare il boss principale " +"di questo mondo." #: Game.Levels.Addition.L03add_comm msgid "add_comm (level boss)" @@ -1301,18 +1450,23 @@ msgid "" " 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" +" 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 "" -"Finora abbiamo sommato solo due numeri alla volta; in questo livello ne sommeremo tre.\n" +"Finora abbiamo sommato solo due numeri alla volta; in questo livello ne " +"sommeremo tre.\n" "\n" -" Ma per cosa sta $x+y+z$ *esattamente*? Può stare per $(x+y)+z$, oppure può stare\n" +" Ma per cosa sta $x+y+z$ *esattamente*? Può stare per $(x+y)+z$, oppure può " +"stare\n" " per $x+(y+z)$. In Lean, $x+y+z$ sta per $(x+y)+z$.\n" "\n" -" La posizione delle parentesi potrebbe sembrarti irrilevante; d'altronde $(x+y)+z$ e $x+(y+z)$ sono *uguali*!\n" +" La posizione delle parentesi potrebbe sembrarti irrilevante; d'altronde " +"$(x+y)+z$ e $x+(y+z)$ sono *uguali*!\n" "\n" -" Hai ragione, ma non l'abbiamo ancora dimostrato. Dimostriamolo subito tramite induzione." +" Hai ragione, ma non l'abbiamo ancora dimostrato. Dimostriamolo subito " +"tramite induzione." #: Game.Levels.Addition.L04add_assoc msgid "" @@ -1344,10 +1498,13 @@ msgid "" "hover over both `+` symbols on the left hand side of the goal and\n" "you'll see where the invisible brackets are." msgstr "" -"Ricorda che, per pura brevità, Lean mostra `a + b + c` al posto di `(a + b) + c`.\n" -"Se non sei sicuro di dove si trovino le parentesi in un'espressione, puoi spostare il\n" +"Ricorda che, per pura brevità, Lean mostra `a + b + c` al posto di `(a + b) " +"+ c`.\n" +"Se non sei sicuro di dove si trovino le parentesi in un'espressione, puoi " +"spostare il\n" "mouse al di sopra e guardare cosa viene evidenziato. Ad esempio,\n" -"se sposti il puntatore sopra entrambi i simboli `+` nel membro sinistro del goal\n" +"se sposti il puntatore sopra entrambi i simboli `+` nel membro sinistro del " +"goal\n" "avrai un'idea di dove Lean ha messo le parentesi invisibili." #: Game.Levels.Addition.L04add_assoc @@ -1358,7 +1515,8 @@ msgid "" "Let's practice using `add_assoc` and `add_comm` in one more level,\n" "before we leave addition world." msgstr "" -"Un matematico di passaggio si congratula con te per aver dimostrato che i naturali\n" +"Un matematico di passaggio si congratula con te per aver dimostrato che i " +"naturali\n" "sono un monoide additivo commutativo.\n" "\n" "Esercitiamoci a usare `add_assoc` e `add_comm` in un ultimo livello,\n" @@ -1380,13 +1538,15 @@ msgid "" "and `add_comm` moves variables around.\n" "\n" "Remember that you can do more targetted rewrites by\n" -"adding explicit variables as inputs to theorems. For example `rw [add_comm b]`\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` è una dimostrazione di `b + c = c + b`. Ma se il goal\n" "è `a + b + c = a + c + b`, `rw [add_comm b c]` non funzionerà!\n" -"Questo perché il goal sta in realtà per `(a + b) + c = (a + c) + b`, e se guardi bene questo goal non include\n" +"Questo perché il goal sta in realtà per `(a + b) + c = (a + c) + b`, e se " +"guardi bene questo goal non include\n" "il termine `b + c` *direttamente*.\n" "\n" "Usa l'associatività e la commutatività per dimostrare `add_right_comm`.\n" @@ -1394,7 +1554,8 @@ msgstr "" "e `add_comm` sposta le variabili.\n" "\n" "Ricorda che puoi fare sostituzioni mirate fornendo\n" -"esplicitamente le variabili in input ai teoremi. Ad esempio `rw [add_comm b]`\n" +"esplicitamente le variabili in input ai teoremi. Ad esempio `rw [add_comm " +"b]`\n" "farà solo sostituzioni della forma `b + ? = ? + b`, e `rw [add_comm b c]`\n" "farà solo sostituzioni della forma `b + c = c + b`." @@ -1407,7 +1568,8 @@ msgid "" msgstr "" "`add_right_comm a b c` è la dimostrazione di `(a + b) + c = (a + c) + b`\n" "\n" -"Su Lean, `a + b + c` è zucchero sintattico per `(a + b) + c`, quindi il nostro risultato verrà visualizzato\n" +"Su Lean, `a + b + c` è zucchero sintattico per `(a + b) + c`, quindi il " +"nostro risultato verrà visualizzato\n" "come `a + b + c = a + c + b`." #: Game.Levels.Addition.L05add_right_comm @@ -1420,20 +1582,27 @@ msgstr "" #: 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" +"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" +"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 \"Leave World\" and make your choice." msgstr "" -"Ora hai incontrato tutte le tattiche che ti servono per sconfiggere il boss finale del gioco.\n" -"Puoi proseguire spedito la tua marcia verso il boss finale passando dal Mondo Moltiplicazione.\n" +"Ora hai incontrato tutte le tattiche che ti servono per sconfiggere il boss " +"finale del gioco.\n" +"Puoi proseguire spedito la tua marcia verso il boss finale passando dal " +"Mondo Moltiplicazione.\n" "\n" -"Oppure puoi fare una deviazione e imparare qualche nuova tattica esotica nel Mondo Implicazione.\n" -"Queste tattiche ti permetteranno di dimostrare altre proprietà dell'addizione, ad esempio\n" +"Oppure puoi fare una deviazione e imparare qualche nuova tattica esotica nel " +"Mondo Implicazione.\n" +"Queste tattiche ti permetteranno di dimostrare altre proprietà " +"dell'addizione, ad esempio\n" "come dedurre `a = 0` da `x + a = x`.\n" "\n" "Premi \"Abbandona mondo\" e scegli la tua strada." @@ -1443,26 +1612,36 @@ msgid "Addition World" msgstr "Mondo Addizione" #: 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" +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" +"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" +"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 "" -"Benvenuto nel Mondo Addizione! In questo mondo impareremo la tattica `induction`,\n" -"che ci permetterà di sconfiggere il boss di questo mondo, il teorema `x + y = y + x`.\n" +"Benvenuto nel Mondo Addizione! In questo mondo impareremo la tattica " +"`induction`,\n" +"che ci permetterà di sconfiggere il boss di questo mondo, il teorema `x + y " +"= y + x`.\n" "\n" -"Le tattiche `rw`, `rfl` e `induction` sono le uniche tattiche di cui avrai bisogno per\n" -"per battere tutti i livelli del Mondo Addizione, del Mondo Moltiplicazione e del Mondo Potenza.\n" +"Le tattiche `rw`, `rfl` e `induction` sono le uniche tattiche di cui avrai " +"bisogno per\n" +"per battere tutti i livelli del Mondo Addizione, del Mondo Moltiplicazione e " +"del Mondo Potenza.\n" "Il Mondo Potenza contiene il boss finale del gioco.\n" "\n" "Ci sono tante altre tattiche in questo gioco, ma ne avrai bisogno solo se\n" -"desideri immergerti ulteriormente nel gioco (o hai intenzione di completarlo al 100%)." +"desideri immergerti ulteriormente nel gioco (o hai intenzione di completarlo " +"al 100%)." #: Game.Levels.Multiplication.L01mul_one msgid "mul_one" @@ -1477,11 +1656,14 @@ msgid "" "Let's start with a warm-up: no induction needed for this one,\n" "because we know `1` is a successor." msgstr "" -"Nell'inventario è comparso il nuovo tab \"*\", dove vedrai `mul_zero` e `mul_succ`.\n" -"Per ora queste sono le uniche due proprietà della moltiplicazione che conosciamo.\n" +"Nell'inventario è comparso il nuovo tab \"*\", dove vedrai `mul_zero` e " +"`mul_succ`.\n" +"Per ora queste sono le uniche due proprietà della moltiplicazione che " +"conosciamo.\n" "Insieme ne dimostreremo altre nove.\n" "\n" -"Cominciamo con un esercizio di riscaldamento: non hai bisogno dell'induzione qua,\n" +"Cominciamo con un esercizio di riscaldamento: non hai bisogno dell'induzione " +"qua,\n" "perché sappiamo che `1` è un successore." #: Game.Levels.Multiplication.L01mul_one @@ -1505,7 +1687,8 @@ msgstr "" "\n" " * `mul_succ a b : a * succ b = a * b + a`\n" "\n" -"Tutti gli altri teoremi sulla moltiplicazione e i naturali, come `zero_mul`,\n" +"Tutti gli altri teoremi sulla moltiplicazione e i naturali, come " +"`zero_mul`,\n" "si dimostrano per induzione usando questi due assiomi fondamentali." #: Game.Levels.Multiplication.L01mul_one @@ -1576,7 +1759,8 @@ msgstr "" "familiarizzato con le convenzioni di nomenclatura di Lean).\n" "\n" "L'ultimo livello del Mondo Addizione potrebbe aiutarti qui.\n" -"Per ridargli un'occhiata, puoi tornare al menu principale cliccando sull'icona della casetta.\n" +"Per ridargli un'occhiata, puoi tornare al menu principale cliccando " +"sull'icona della casetta.\n" "Non perderai il progresso fatto in questo livello." #: Game.Levels.Multiplication.L03succ_mul @@ -1588,8 +1772,10 @@ msgid "" msgstr "" "`succ_mul a b` è la dimostrazione di `succ a * b = a * b + b`.\n" "\n" -"Questo lemma potrebbe essere dedotto da `mul_succ` e `mul_comm`, ma risulterebbe\n" -"in un ragionamento circolare in quanto la dimostrazione di `mul_comm` dipende da `mul_succ`." +"Questo lemma potrebbe essere dedotto da `mul_succ` e `mul_comm`, ma " +"risulterebbe\n" +"in un ragionamento circolare in quanto la dimostrazione di `mul_comm` " +"dipende da `mul_succ`." #: Game.Levels.Multiplication.L03succ_mul msgid "" @@ -1605,16 +1791,19 @@ msgstr "mul_comm" #: Game.Levels.Multiplication.L04mul_comm msgid "" -"The first sub-boss of Multiplication World is `mul_comm x y : x * y = y * x`.\n" +"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 "" -"Il primo mini-boss del Mondo Moltiplicazione è `mul_comm x y : x * y = y * x`.\n" +"Il primo mini-boss del Mondo Moltiplicazione è `mul_comm x y : x * y = y * " +"x`.\n" "\n" -"Una volta dimostrata la commutatività della moltiplicazione certe dimostrazioni che abbiamo fatto diventano \"superflue\",\n" +"Una volta dimostrata la commutatività della moltiplicazione certe " +"dimostrazioni che abbiamo fatto diventano \"superflue\",\n" "come `zero_mul`, il quale ora può essere dedotto facilmente da `mul_zero`.\n" "Ma ce le teniamo care comunque, perché sono strumenti specializzati che\n" "possono rivelarsi sempre utili." @@ -1624,7 +1813,8 @@ 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` è la dimostrazione che la moltiplicazione è commutativa. Più precisamente,\n" +"`mul_comm` è la dimostrazione che la moltiplicazione è commutativa. Più " +"precisamente,\n" "`mul_comm a b` è la dimostrazione che `a * b = b * a`." #: Game.Levels.Multiplication.L04mul_comm @@ -1715,7 +1905,8 @@ msgid "" "Note that the left hand side contains a multiplication\n" "and then an addition." msgstr "" -"Il nostro nuovo obiettivo è dimostrare la \"distributività sinistra e destra\",\n" +"Il nostro nuovo obiettivo è dimostrare la \"distributività sinistra e " +"destra\",\n" "ossia $a(b+c)=ab+ac$ e $(b+c)a=ba+ca$. Al posto di questo nome\n" "un po' tecnico e altisonante, le dimostrazioni di Lean\n" "hanno nomi descrittivi. Partiamo da\n" @@ -1751,8 +1942,10 @@ msgid "" "are harder to push through than others. Can you do the inductive step in\n" "5 rewrites only?" msgstr "" -"Puoi procedere per induzione su una qualsiasi delle tre variabili. Scegli bene, perché\n" -"con certe scelte la dimostrazione si aggroviglia più che con altre. Riesci a dimostrare il caso induttivo in\n" +"Puoi procedere per induzione su una qualsiasi delle tre variabili. Scegli " +"bene, perché\n" +"con certe scelte la dimostrazione si aggroviglia più che con altre. Riesci a " +"dimostrare il caso induttivo in\n" "sole cinque sostituzioni?" #: Game.Levels.Multiplication.L07mul_add @@ -1785,7 +1978,8 @@ msgstr "" "rfl\n" "```\n" "\n" -"Si poteva risolvere anche per induzione su `a` or `b`, ma avrebbe richiesto più passi." +"Si poteva risolvere anche per induzione su `a` or `b`, ma avrebbe richiesto " +"più passi." #: Game.Levels.Multiplication.L08add_mul msgid "add_mul" @@ -1796,7 +1990,8 @@ 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` è altrettanto macchinoso da dimostrare per induzione; ma c'è un trucco\n" +"`add_mul` è altrettanto macchinoso da dimostrare per induzione; ma c'è un " +"trucco\n" "che ci permette di evitarla. Sai individuarlo?" #: Game.Levels.Multiplication.L08add_mul @@ -1838,7 +2033,8 @@ msgid "" "We now have enough to prove that multiplication is associative,\n" "the boss level of multiplication world. Good luck!" msgstr "" -"Adesso abbiamo abbastanza informazioni per dimostrare che la moltiplicazione è associativa,\n" +"Adesso abbiamo abbastanza informazioni per dimostrare che la moltiplicazione " +"è associativa,\n" "il boss del Mondo Moltiplicazione. Avanti guerriero!" #: Game.Levels.Multiplication.L09mul_assoc @@ -1847,7 +2043,8 @@ msgid "" "\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" +"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 "" @@ -1855,8 +2052,10 @@ msgstr "" "\n" "Ricorda che Lean per `a * b * c` intende `(a * b) * c`.\n" "\n" -"Ricorda che `(a * b) * c = a * (b * c)` non è una legge universale della matematica\":\n" -"un esempio famoso di operazione non associativa è la sottrazione, dato che `(6 - 2) - 1` non è\n" +"Ricorda che `(a * b) * c = a * (b * c)` non è una legge universale della " +"matematica\":\n" +"un esempio famoso di operazione non associativa è la sottrazione, dato che " +"`(6 - 2) - 1` non è\n" "uguale a `6 - (2 - 1)`." #: Game.Levels.Multiplication.L09mul_assoc @@ -1879,7 +2078,8 @@ msgstr "" "Un matematico di passaggio nota che hai appena dimostrato\n" "che i numeri naturali sono un semianello commutativo.\n" "\n" -"Se ti senti pronto per incamminarti verso il boss finale, dirigiti verso il Mondo Potenza." +"Se ti senti pronto per incamminarti verso il boss finale, dirigiti verso il " +"Mondo Potenza." #: Game.Levels.Multiplication msgid "Multiplication World" @@ -1887,7 +2087,8 @@ msgstr "Mondo Moltiplicazione" #: Game.Levels.Multiplication msgid "" -"How should we define `37 * x`? Just like addition, we need to give definitions\n" +"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" @@ -1899,15 +2100,20 @@ msgid "" " * `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" +"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 "" -"Come si può definire `37 * x`? Come per l'addizione, dobbiamo dare la definizione per\n" +"Come si può definire `37 * x`? Come per l'addizione, dobbiamo dare la " +"definizione per\n" "quando $x=0$ e quando $x$ è un successore.\n" "\n" -"Il caso di zero è facile: definiamo `37 * 0` uguale a `0`. Ora, immaginiamo di sapere quanto fa\n" -"`37 * d`. Quanto fa allora `37 * succ d`? Beh, non è altro che $37$ sommato a se stesso $(d+1)$ volte,\n" +"Il caso di zero è facile: definiamo `37 * 0` uguale a `0`. Ora, immaginiamo " +"di sapere quanto fa\n" +"`37 * d`. Quanto fa allora `37 * succ d`? Beh, non è altro che $37$ sommato " +"a se stesso $(d+1)$ volte,\n" "quindi `37 * d + 37`.\n" "\n" "Ecco le due definizioni in Lean.\n" @@ -1915,8 +2121,10 @@ msgstr "" " * `mul_zero a : a * 0 = 0`\n" " * `mul_succ a d : a * succ d = a * d + a`\n" "\n" -"In questo mondo non ci limiteremo a dimostrare fatti riguardanti solo la moltiplicazione come `a * b = b * a`,\n" -"ma anche fatti su come la moltiplicazione interagisce con l'addizione, come `a * (b + c) = a * b + a * c`.\n" +"In questo mondo non ci limiteremo a dimostrare fatti riguardanti solo la " +"moltiplicazione come `a * b = b * a`,\n" +"ma anche fatti su come la moltiplicazione interagisce con l'addizione, come " +"`a * (b + c) = a * b + a * c`.\n" "Iniziamo!" #: Game.Levels.Power.L01zero_pow_zero @@ -1977,8 +2185,10 @@ msgid "" "convention that `0 ^ 0 = 1`." msgstr "" "Certi matematici sostengono che `0 ^ 0 = 0` sia pure una\n" -"convenzione ragionevole. Tuttavia non va d'accordo con il modo in cui abbiamo strutturato\n" -"i livelli successivi del gioco, e nell'intento di difendere la loro eleganza matematica\n" +"convenzione ragionevole. Tuttavia non va d'accordo con il modo in cui " +"abbiamo strutturato\n" +"i livelli successivi del gioco, e nell'intento di difendere la loro eleganza " +"matematica\n" "rimaniamo fermi sulla convenzione `0 ^ 0 = 1`." #: Game.Levels.Power.L01zero_pow_zero @@ -2072,7 +2282,8 @@ msgid "pow_add" msgstr "pow_add" #: Game.Levels.Power.L06pow_add -msgid "Let's now begin our approach to the final boss,\n" +msgid "" +"Let's now begin our approach to the final boss,\n" "by proving some more subtle facts about powers." msgstr "" "Vediamo meglio come affrontare il boss finale,\n" @@ -2084,20 +2295,25 @@ msgstr "`pow_add a m n` è la dimostrazione che $a^{m+n}=a^ma^n.$" #: Game.Levels.Power.L06pow_add msgid "For all naturals $a$, $m$, $n$, we have $a^{m + n} = a ^ m a ^ n$." -msgstr "Per tutti i numeri naturali $a$, $m$, $n$, si ha che $a^{m + n} = a ^ m a ^ n$." +msgstr "" +"Per tutti i numeri naturali $a$, $m$, $n$, si ha che $a^{m + n} = a ^ m a ^ " +"n$." #: Game.Levels.Power.L07mul_pow msgid "mul_pow" msgstr "mul_pow" #: Game.Levels.Power.L07mul_pow -msgid "The music gets ever more dramatic, as we explore\n" +#, fuzzy +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 `x * y`\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 "La musica si fa sempre più drammatica nel mentre che ci addentriamo\n" +msgstr "" +"La musica si fa sempre più drammatica nel mentre che ci addentriamo\n" "nella relazione tra elevamento a potenza e prodotto.\n" "\n" "Se stai avendo difficoltà a scambiare il giusto `x * y`\n" @@ -2110,7 +2326,8 @@ msgstr "`mul_pow a b n` è la dimostrazione che $(ab)^n=a^nb^n.$" #: Game.Levels.Power.L07mul_pow msgid "For all naturals $a$, $b$, $n$, we have $(ab) ^ n = a ^ nb ^ n$." -msgstr "Per tutti i numeri naturali $a$, $b$, $n$, si ha che $(ab) ^ n = a ^ nb ^ n$." +msgstr "" +"Per tutti i numeri naturali $a$, $b$, $n$, si ha che $(ab) ^ n = a ^ nb ^ n$." #: Game.Levels.Power.L08pow_pow msgid "pow_pow" @@ -2133,14 +2350,17 @@ msgstr "`pow_pow a m n` è la dimostrazione di $(a^m)^n=a^{mn}.$" #: Game.Levels.Power.L08pow_pow msgid "For all naturals $a$, $m$, $n$, we have $(a ^ m) ^ n = a ^ {mn}$." -msgstr "Per tutti i numeri naturali $a$, $m$, $n$, si ha che $(a ^ m) ^ n = a ^ {mn}$." +msgstr "" +"Per tutti i numeri naturali $a$, $m$, $n$, si ha che $(a ^ m) ^ n = a ^ " +"{mn}$." #: Game.Levels.Power.L08pow_pow +#, fuzzy msgid "" "The music dies down. Is that it?\n" "\n" "Course it isn't, you can\n" -"clearly see that there are two worlds left.\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" @@ -2152,10 +2372,13 @@ msgstr "" "Ovvio che no, come vedi\n" "ci sono ancora due livelli da battere.\n" "\n" -"Intanto, un matematico di passaggio ti svela che i matematici non hanno dato un nome\n" -"alla struttura che hai appena costruito. Questa notizia ti lascia l'amaro in bocca.\n" +"Intanto, un matematico di passaggio ti svela che i matematici non hanno dato " +"un nome\n" +"alla struttura che hai appena costruito. Questa notizia ti lascia l'amaro in " +"bocca.\n" "\n" -"La musica riparte improvvisamente. Ti lasci alle spalle il passato: lo scontro con il boss finale è vicino." +"La musica riparte improvvisamente. Ti lasci alle spalle il passato: lo " +"scontro con il boss finale è vicino." #: Game.Levels.Power.L09add_sq msgid "add_sq" @@ -2185,7 +2408,8 @@ msgid "" "\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!" +"But wait! This boss is stirring...and mutating into a second more powerful " +"form!" msgstr "" "Hai vinto tutto! Hai dimostrato un teorema che ha tormentato\n" "intere generazioni di alunni (alcuni credono che $(a+b)^2=a^2+b^2$:\n" @@ -2193,7 +2417,8 @@ msgstr "" "\n" "Quante sostituzioni hai fatto? Io ci sono riuscito in 12.\n" "\n" -"In guardia! Il boss si agita...si sta trasformando nella sua seconda forma ancora più letale!" +"In guardia! Il boss si agita...si sta trasformando nella sua seconda forma " +"ancora più letale!" #: Game.Levels.Power.L10FLT msgid "Fermat's Last Theorem" @@ -2204,7 +2429,8 @@ 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" +"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" @@ -2221,23 +2447,32 @@ msgid "" "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" +"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 "" -"Ora abbiamo abbastanza materiale per asserire una versione matematicamente accurata, tuttavia un po' goffa, dell'Ultimo Teorema di Fermat.\n" +"Ora abbiamo abbastanza materiale per asserire una versione matematicamente " +"accurata, tuttavia un po' goffa, dell'Ultimo Teorema di Fermat.\n" "\n" -"L'Ultimo Teorema di Fermat afferma che se $x,y,z>0$ e $m \\geq 3$ allora $x^m+y^m\\not =z^m$.\n" -"Se non sei ancora stato nel Mondo Disequazioni, non possiamo parlare ancora di $m \\geq 3$,\n" +"L'Ultimo Teorema di Fermat afferma che se $x,y,z>0$ e $m \\geq 3$ allora " +"$x^m+y^m\\not =z^m$.\n" +"Se non sei ancora stato nel Mondo Disequazioni, non possiamo parlare ancora " +"di $m \\geq 3$,\n" "quindi dobbiamo ricorrere all'espediente `n + 3` per `m`,\n" -"che garantisce che sia abbastanza grande. Allo stesso modo, simuliamo `x > 0`\n" +"che garantisce che sia abbastanza grande. Allo stesso modo, simuliamo `x > " +"0`\n" "tramite `a + 1`.\n" "\n" -"A primo sguardo, questo livello assomiglia ad altri livelli che abbiamo visto,\n" -"ma in realtà è impossibile da dimostrare a mano. Purtroppo, la soluzione più breve nota all'uomo\n" -"corrisponde a milioni di righe di codice Lean. Questo boss imbattibile ti lascia tutti perplessi, ma\n" +"A primo sguardo, questo livello assomiglia ad altri livelli che abbiamo " +"visto,\n" +"ma in realtà è impossibile da dimostrare a mano. Purtroppo, la soluzione più " +"breve nota all'uomo\n" +"corrisponde a milioni di righe di codice Lean. Questo boss imbattibile ti " +"lascia tutti perplessi, ma\n" "non perdiamoci d'animo! L'autore di questo gioco,\n" -"Kevin Buzzard, sta lavorando al traduzione della prova di Wiles e Taylor in Lean,\n" +"Kevin Buzzard, sta lavorando al traduzione della prova di Wiles e Taylor in " +"Lean,\n" "nonostante sia un compito che richiederà parecchi anni.\n" "\n" "## CONGRATULAZIONI!\n" @@ -2245,7 +2480,8 @@ msgstr "" "Hai completato la missione principale del Gioco dei Numeri Naturali!\n" "Se vuoi sapere di più su come si usa Lean per\n" "dimostrare i teoremi della matematica, ti indirizziamo a \n" -"[Mathematics In Lean](https://leanprover-community.github.io/mathematics_in_lean/),\n" +"[Mathematics In Lean](https://leanprover-community.github.io/" +"mathematics_in_lean/),\n" "un web book interattivo che puoi leggere dal tuo browser,\n" "che spiega come trattare tanti altri concetti matematici su Lean." @@ -2257,7 +2493,8 @@ msgid "" "prove anything with `xyzzy`." msgstr "" "`xyzzy` è un incantesimo arcaico, si crede che sia l'origine\n" -"della parola inglese `sorry`. Il gioco non si lamenterà - e nemmeno noterà - se\n" +"della parola inglese `sorry`. Il gioco non si lamenterà - e nemmeno noterà - " +"se\n" "risolvi tutti i livelli con `xyzzy`." #: Game.Levels.Power.L10FLT @@ -2300,11 +2537,13 @@ msgid "" "in the summer of 2019. Thanks to Sian and also thanks to Imperial\n" "College for funding her." msgstr "" -"Questo mondo è casa dell'elevamento a potenza. Come al solito, per definire `37 ^ n`,\n" +"Questo mondo è casa dell'elevamento a potenza. Come al solito, per definire " +"`37 ^ n`,\n" "dobbiamo stabilire cosa significa `37 ^ 0`, e poi\n" "cosa significa `37 ^ (succ d)` data la conoscenza `37 ^ d`.\n" "\n" -"Questi due assiomi, il cui nome allude al nome dell'operazione in inglese (\"power\"), sono:\n" +"Questi due assiomi, il cui nome allude al nome dell'operazione in inglese " +"(\"power\"), sono:\n" "\n" " * `pow_zero (a : ℕ) : a ^ 0 = 1`\n" " * `pow_succ (a b : ℕ) : a ^ succ b = a ^ b * a`\n" @@ -2312,7 +2551,8 @@ msgstr "" "Riuscirai a battere il livello boss usando solo questi due?\n" "\n" "Questo mondo è stato progettato da Sian Carey, studente UROP\n" -"al Imperial College London, finanziato dalla Mary Lister McCammon Fellowship\n" +"al Imperial College London, finanziato dalla Mary Lister McCammon " +"Fellowship\n" "nell'estate 2019. Grazie a Sian e grazie a Imperial\n" "College per averla sostenuta economicamente." @@ -2324,7 +2564,8 @@ msgstr "La tattica `exact`" 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" +"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" @@ -2341,14 +2582,16 @@ msgid "" "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" +"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 "" "## Descrizione\n" "\n" -"Se il goal è una proposizione `P`, `exact h` lo risolverà se `h` è una dimostrazione di `P`.\n" +"Se il goal è una proposizione `P`, `exact h` lo risolverà se `h` è una " +"dimostrazione di `P`.\n" "\n" "### Esempio\n" "\n" @@ -2362,28 +2605,36 @@ msgstr "" "### `exact` deve coincidere esattamente con il goal\n" "\n" "È bene notare che `exact add_zero` *non funzionerà* nell'esempio di prima;\n" -"come dice il nome, `exact h` ha successo solo se `h` coincide *esattamente* al goal.\n" -"`add_zero` è la dimostrazione dell'enunciato più generale `∀ n, n + 0 = n` o, con notazione più intuitiva,\n" +"come dice il nome, `exact h` ha successo solo se `h` coincide *esattamente* " +"al goal.\n" +"`add_zero` è la dimostrazione dell'enunciato più generale `∀ n, n + 0 = n` " +"o, con notazione più intuitiva,\n" "alla dimostrazione di `? + 0 = ?` dove `?` deve essere fornito dall'utente.\n" -"Diversamente da `rw` e `apply`, i quali tentano di \\\"indovinare i loro input\\\"\n" -"quando essi sono assenti, `exact` vuole la pappa pronta. Ad esempio, se il goal è `x + 0 = x` sia `rw [add_zero]`\n" +"Diversamente da `rw` e `apply`, i quali tentano di \\\"indovinare i loro " +"input\\\"\n" +"quando essi sono assenti, `exact` vuole la pappa pronta. Ad esempio, se il " +"goal è `x + 0 = x` sia `rw [add_zero]`\n" "che `rw [add_zero x]` porteranno il goal a `x = x`,\n" -"perché `rw` è in grado di indovinare (o meglio, dedurre dal contesto) gli input della funzione `add_zero`." +"perché `rw` è in grado di indovinare (o meglio, dedurre dal contesto) gli " +"input della funzione `add_zero`." #: 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" +"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 "" "In questo mondo vedremo come dimostrare teoremi della forma $P\\implies Q$.\n" -"In altre parole, verificheremo frasi della forma \"se $P$ è vero, allora $Q$ è vero\".\n" +"In altre parole, verificheremo frasi della forma \"se $P$ è vero, allora $Q$ " +"è vero\".\n" "Per farlo abbiamo bisogno di qualche tattica in più nel nostro arsenale.\n" "\n" -"La tattica `exact` può essere usata per risolvere un goal che coincide con una\n" +"La tattica `exact` può essere usata per risolvere un goal che coincide con " +"una\n" "delle ipotesi. Prende come argomento il nome dell'ipotesi: `exact h`." #: Game.Levels.Implication.L01exact @@ -2391,8 +2642,12 @@ msgid "Assuming $x+y=37$ and $3x+z=42$, we have $x+y=37$." msgstr "Ipotizzando che $x+y=37$ e $3x+z=42$, si ha che $x+y=37$." #: Game.Levels.Implication.L01exact -msgid "The goal in this level is one of our hypotheses. Solve the goal by executing `exact h1`." -msgstr "Il goal di questo livello è una delle nostre ipotesi. Risolvilo eseguendo `exact h1`." +msgid "" +"The goal in this level is one of our hypotheses. Solve the goal by executing " +"`exact h1`." +msgstr "" +"Il goal di questo livello è una delle nostre ipotesi. Risolvilo eseguendo " +"`exact h1`." #: Game.Levels.Implication.L02exact2 msgid "`exact` practice." @@ -2415,7 +2670,8 @@ msgid "" "You can use `rw [zero_add] at «{h}»` to rewrite at `«{h}»` instead\n" "of at the goal." msgstr "" -"Puoi eseguire `rw [zero_add] at «{h}»` per sostituire all'interno dell'ipotesi `«{h}»` invece che\n" +"Puoi eseguire `rw [zero_add] at «{h}»` per sostituire all'interno " +"dell'ipotesi `«{h}»` invece che\n" "nel goal." #: Game.Levels.Implication.L02exact2 @@ -2423,14 +2679,17 @@ 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 occurences of\n" +"the arguments to `zero_add` (finding `«{x}»`) then it replaces all " +"occurences of\n" "`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet." msgstr "" "Ripeti lo stesso comando!\n" "\n" "`rw [zero_add] at «{h}»` ha completato automaticamente\n" -"la chiamata a `zero_add` (trovando l'argomento `«{x}»`) e poi ha sostituito tutte le occorrenze di\n" -"`0 + «{x}»` in un solo colpo. Dunque non ha toccato `0 + «{y}»` ancora, perciò dovresti ripetere il comando." +"la chiamata a `zero_add` (trovando l'argomento `«{x}»`) e poi ha sostituito " +"tutte le occorrenze di\n" +"`0 + «{x}»` in un solo colpo. Dunque non ha toccato `0 + «{y}»` ancora, " +"perciò dovresti ripetere il comando." #: Game.Levels.Implication.L02exact2 msgid "" @@ -2462,11 +2721,13 @@ msgstr "La tattica `apply`." msgid "" "## Summary\n" "\n" -"If `t : P → Q` is a proof that $P \\implies Q$, and `h : P` is a proof of `P`,\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" +"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" @@ -2486,22 +2747,31 @@ msgid "" msgstr "" "## Descrizione\n" "\n" -"Se `t : P → Q` è una dimostrazione di $P \\implies Q$, e `h : P` è una dimostrazione di `P`,\n" -"allora `apply t at h` trasformerà `h` in una dimostrazione di `Q`. L'idea alla base di questo è\n" -"che se sai che `P` è vera, allora l'implicazione `t` ti permette di dedurre che `Q` è vera.\n" +"Se `t : P → Q` è una dimostrazione di $P \\implies Q$, e `h : P` è una " +"dimostrazione di `P`,\n" +"allora `apply t at h` trasformerà `h` in una dimostrazione di `Q`. L'idea " +"alla base di questo è\n" +"che se sai che `P` è vera, allora l'implicazione `t` ti permette di dedurre " +"che `Q` è vera.\n" "\n" -"Al contrario, se il *goal* è `Q`, allora `apply t` \\\"ragionerà all'indietro\\\" e trasformerà il\n" -"goal in `P`. È sempre l'implicazione che ci permette di farlo: `Q` è garantito da `t`\n" -"se riesci a dimostrare `P`, quindi il goal si riduce a una dimostrazione di `P`.\n" +"Al contrario, se il *goal* è `Q`, allora `apply t` \\\"ragionerà " +"all'indietro\\\" e trasformerà il\n" +"goal in `P`. È sempre l'implicazione che ci permette di farlo: `Q` è " +"garantito da `t`\n" +"se riesci a dimostrare `P`, quindi il goal si riduce a una dimostrazione di " +"`P`.\n" "\n" "### Esempio:\n" "\n" -"`succ_inj x y` è una dimostrazione di `succ x = succ y → x = y` (un'implicazione).\n" +"`succ_inj x y` è una dimostrazione di `succ x = succ y → x = y` " +"(un'implicazione).\n" "\n" "Quindi, se hai l'ipotesi `h : succ (a + 37) = succ (b + 42)`\n" "allora con `apply succ_inj at h` trasformerai `h` in `a + 37 = b + 42`.\n" -"Puoi anche fornire gli argomenti direttamente `apply succ_inj (a + 37) (b + 42) at h`\n" -"ma Lean fa questo lavoro per noi e capisce da solo cosa deve passare a `succ_inj`.\n" +"Puoi anche fornire gli argomenti direttamente `apply succ_inj (a + 37) (b + " +"42) at h`\n" +"ma Lean fa questo lavoro per noi e capisce da solo cosa deve passare a " +"`succ_inj`.\n" "\n" "### Esempio\n" "\n" @@ -2510,15 +2780,18 @@ msgstr "" #: Game.Levels.Implication.L03apply msgid "" -"In this level one of our hypotheses is an *implication*. We can use this\n" -"hypothesis with the `apply` tactic." +"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 questo livello una delle nostre ipotesi è un'*implicazione*. Possiamo usare\n" -"questa ipotesi con la tattica `apply`." #: Game.Levels.Implication.L03apply -msgid "If $x=37$ and we know that $x=37\\implies y=42$ then we can deduce $y=42$." -msgstr "Se $x=37$ e abbiamo che $x=37\\implies y=42$ allora possiamo dedurre $y=42$." +msgid "" +"If $x=37$ and we know that $x=37\\implies y=42$ then we can deduce $y=42$." +msgstr "" +"Se $x=37$ e abbiamo che $x=37\\implies y=42$ allora possiamo dedurre $y=42$." #: Game.Levels.Implication.L03apply msgid "Start with `apply h2 at h1`. This will change `h1` to `y = 42`." @@ -2535,7 +2808,8 @@ msgstr "succ_inj : la funzione successore è iniettiva" #: 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" +"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" @@ -2545,7 +2819,8 @@ msgid "" "walk you through this level." msgstr "" "Se `a` e `b` sono due numeri, allora `succ_inj a b` è una dimostrazione\n" -"che `succ a = succ b` implica `a = b`. Clicca su questo teorema nel tab *Peano*\n" +"che `succ a = succ b` implica `a = b`. Clicca su questo teorema nel tab " +"*Peano*\n" "per maggiori dettagli.\n" "\n" "Peano formulò questo teorema come assioma, ma nel Mondo Algoritmi\n" @@ -2573,7 +2848,8 @@ msgid "" "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" +"$\\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" @@ -2596,7 +2872,8 @@ msgstr "" "Ma `succ_inj` in sé e anche una dimostrazione; ovvero la dimostrazione\n" "che `succ` è una funzione iniettiva. In termini matematici,\n" "`succ_inj` è una dimostrazione di\n" -"$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = \\operatorname{succ}(b)) \\implies a=b$.\n" +"$\\forall a, b \\in \\mathbb{N}, ( \\operatorname{succ}(a) = " +"\\operatorname{succ}(b)) \\implies a=b$.\n" "\n" "`succ_inj` fu postulato da Peano come un'assioma, ma\n" "in Lean può essere dimostrato usando `pred`, una funzione che non va\n" @@ -2612,7 +2889,8 @@ msgid "" "apply `succ_inj`. First execute `rw [four_eq_succ_three] at h`\n" "to change the 4 on the right hand side." msgstr "" -"Prima di tutto portiamo `h` alla forma `succ x = succ 3` in modo da poter applicare\n" +"Prima di tutto portiamo `h` alla forma `succ x = succ 3` in modo da poter " +"applicare\n" "`succ_inj`. Esegui `rw [four_eq_succ_three] at h`\n" "per sostituire il 4 nel membro destro." @@ -2627,10 +2905,12 @@ 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`." +"the other way around. Look at the docs for `rw` for an explanation. Type `←` " +"with `\\l`." msgstr "" "Ricorda che mettendo `←` davanti a un teorema che passi a `rw` puoi\n" -"sostituire nel senso opposto. Guarda la documentazione di `rw` per capire meglio il suo funzionamento.\n" +"sostituire nel senso opposto. Guarda la documentazione di `rw` per capire " +"meglio il suo funzionamento.\n" "`←` si ottiene digitando `\\l`." #: Game.Levels.Implication.L04succ_inj @@ -2651,15 +2931,18 @@ msgstr "Ora concludi in una linea." #: Game.Levels.Implication.L04succ_inj msgid "" -"And now we've deduced what we wanted to prove: the goal is one of our assumptions.\n" +"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 "" -"Abbiamo dedotto esattamente ciò che volevamo dimostrare: il goal coincide con una delle ipotesi.\n" +"Abbiamo dedotto esattamente ciò che volevamo dimostrare: il goal coincide " +"con una delle ipotesi.\n" "Completa il livello con `exact h`." #: Game.Levels.Implication.L04succ_inj msgid "In the next level, we'll do the same proof but backwards." -msgstr "Nel livello successivo, dimostreremo lo stesso enunciato, al contrario." +msgstr "" +"Nel livello successivo, dimostreremo lo stesso enunciato, al contrario." #: Game.Levels.Implication.L05succ_inj2 msgid "Arguing backwards" @@ -2677,8 +2960,10 @@ msgstr "" "Nell'ultimo livello abbiamo manipolato l'ipotesi `x + 1 = 4`\n" " per farla coincidere con il goal `x = 3`. In questo livello manipoleremo\n" " il goal per farlo combaciare con una delle ipotesi! Si puo dire che\n" -" \"ragioneremo all'indietro\". È ancora la tattica `apply` che ce lo consente.\n" -" Ti guiderò io anche in questa dimostrazione (assicurati di essere in modalità\n" +" \"ragioneremo all'indietro\". È ancora la tattica `apply` che ce lo " +"consente.\n" +" Ti guiderò io anche in questa dimostrazione (assicurati di essere in " +"modalità\n" " interattiva)." #: Game.Levels.Implication.L05succ_inj2 @@ -2691,7 +2976,8 @@ msgid "" "Now try `rw [succ_eq_add_one]` to make the goal more like the hypothesis." msgstr "" "Applicando $P\\implies Q$ al *goal* ci siamo mossi da $Q$ a $P$.\n" -"Ora esegui `rw [succ_eq_add_one]` per iniziare a portare il goal a una delle ipotesi." +"Ora esegui `rw [succ_eq_add_one]` per iniziare a portare il goal a una delle " +"ipotesi." #: Game.Levels.Implication.L05succ_inj2 msgid "" @@ -2710,13 +2996,17 @@ 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" +"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 "" -"Molte persone trovano più facile ragionare in avanti con `apply t at h`, mentre ad alcuni ragionare all'indietro con `apply t` confonde le idee.\n" -"Se confonde le idee anche a te, puoi sempre ragionare in avanti, i due metodi sono equivalenti.\n" +"Molte persone trovano più facile ragionare in avanti con `apply t at h`, " +"mentre ad alcuni ragionare all'indietro con `apply t` confonde le idee.\n" +"Se confonde le idee anche a te, puoi sempre ragionare in avanti, i due " +"metodi sono equivalenti.\n" "\n" -"Trovi più informazioni sulla tattica `apply` nella sua documentazione, a cui puoi accedere\n" +"Trovi più informazioni sulla tattica `apply` nella sua documentazione, a cui " +"puoi accedere\n" "cliccando sul suo nome nell'elenco di tattiche a destra." #: Game.Levels.Implication.L06intro @@ -2727,25 +3017,30 @@ msgstr "intro" 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" +"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" +"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 "" "## Descrizione\n" "\n" "Se il goal è `P → Q`, allora `intro h` introdurrà `h : P` come ipotesi,\n" -"e lascerà nel goal solo `Q`. Nella matematica, per dimostrare l'implicazione $P \\implies Q$,\n" +"e lascerà nel goal solo `Q`. Nella matematica, per dimostrare l'implicazione " +"$P \\implies Q$,\n" "possiamo dare per vero $P$ e dimostrare $Q$.\n" "\n" "### Ad esempio:\n" "\n" -"Se il goal è `x + 1 = y + 1 → x = y` (codice Lean per $x+1=y+1 \\implies x=y$)\n" +"Se il goal è `x + 1 = y + 1 → x = y` (codice Lean per $x+1=y+1 \\implies " +"x=y$)\n" "allora `intro h` creerà un'ipotesi $x+1=y+1$ con nome `h`, e il goal\n" "diventerà $x=y$." @@ -2753,12 +3048,15 @@ msgstr "" 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" +"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 "" "Abbiamo visto come fare `apply` di teoremi e ipotesi\n" -"della forma `P → Q`. Ma come ci comportiamo se è il *goal* ad avere la forma `P → Q`?\n" -"Per dimostrare questo tipo di goal, ci serve un modo per dire a Lean \"supponiamo `P` e deduciamo `Q`\".\n" +"della forma `P → Q`. Ma come ci comportiamo se è il *goal* ad avere la forma " +"`P → Q`?\n" +"Per dimostrare questo tipo di goal, ci serve un modo per dire a Lean " +"\"supponiamo `P` e deduciamo `Q`\".\n" "Lo possiamo fare con la tattica `intro`." #: Game.Levels.Implication.L06intro @@ -2767,7 +3065,9 @@ msgstr "$x=37\\implies x=37$." #: Game.Levels.Implication.L06intro msgid "Start with `intro h` to assume the hypothesis and call its proof `h`." -msgstr "Comincia eseguendo `intro h` per introdurre l'ipotesi nel contesto e darle il nome `h`." +msgstr "" +"Comincia eseguendo `intro h` per introdurre l'ipotesi nel contesto e darle " +"il nome `h`." #: Game.Levels.Implication.L06intro msgid "Now `exact h` finishes the job." @@ -2779,11 +3079,14 @@ msgstr "esercizi su intro" #: 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" +"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 "" -"Mettiti alla prova applicando le tattiche che abbiamo appena visto per dimostrare $x+1=y+1\\implies x=y$.\n" -"Cerca di dimostrarlo da solo; se ti perdi e hai bisogno di una mano clicca su \"Aiutami!\"." +"Mettiti alla prova applicando le tattiche che abbiamo appena visto per " +"dimostrare $x+1=y+1\\implies x=y$.\n" +"Cerca di dimostrarlo da solo; se ti perdi e hai bisogno di una mano clicca " +"su \"Aiutami!\"." #: Game.Levels.Implication.L07intro2 msgid "$x+1=y+1 \\implies x=y$." @@ -2794,11 +3097,13 @@ msgid "Start with `intro h` to assume the hypothesis." msgstr "Inizia con `intro h` per supporre l'ipotesi." #: Game.Levels.Implication.L07intro2 +#, fuzzy msgid "" "Now `repeat rw [← succ_eq_add_one] at h` is the quickest way to\n" -"change `succ x = succ y`." +"change `h` to `succ x = succ y`." msgstr "" -"Adesso puoi fare `repeat rw [← succ_eq_add_one] at h` per fare due sostituzioni in un colpo\n" +"Adesso puoi fare `repeat rw [← succ_eq_add_one] at h` per fare due " +"sostituzioni in un colpo\n" "e avrai `succ x = succ y`." #: Game.Levels.Implication.L07intro2 @@ -2807,7 +3112,9 @@ msgstr "Ora esegui `apply succ_inj at h` per togliere i `succ`." #: Game.Levels.Implication.L07intro2 msgid "Now `rw [h]` then `rfl` works, but `exact h` is quicker." -msgstr "Ora potresti usare `rw [h]` e `rfl` in successione, ma `exact h` è più elegante." +msgstr "" +"Ora potresti usare `rw [h]` e `rfl` in successione, ma `exact h` è più " +"elegante." #: Game.Levels.Implication.L07intro2 msgid "" @@ -2841,24 +3148,32 @@ msgid "" "`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" +"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" +"`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 "" -"Non possiamo ancora dimostrare `2 + 2 ≠ 5` perché non abbiamo ancora dato la\n" -"definizione dell'operatore `≠`. In Lean, `a ≠ b` è *notazione* per `a = b → False`.\n" +"Non possiamo ancora dimostrare `2 + 2 ≠ 5` perché non abbiamo ancora dato " +"la\n" +"definizione dell'operatore `≠`. In Lean, `a ≠ b` è *notazione* per `a = b → " +"False`.\n" "`False` è la proposizione falsa più banale, e `→` è la notazione di Lean\n" -"per l'operatore \"implica\". Dalla tabella della verità dell'implicazione sappiamo\n" +"per l'operatore \"implica\". Dalla tabella della verità dell'implicazione " +"sappiamo\n" "che `True → False` è falso, mentre `False → False` è vero. Quindi\n" "`X → False` equivale alla negazione logica di `X`.\n" "\n" "Non si è abituati a vedere `a ≠ b` come un'implicazione, ma\n" -"in Lean è comodo trattarla come tale. I prossimi due livelli ti faranno vedere come.\n" +"in Lean è comodo trattarla come tale. I prossimi due livelli ti faranno " +"vedere come.\n" "\n" -"`False` è un goal insoddisfacibile, impossibile da dedurre da un insieme consistente di ipotesi!\n" -"Quindi se ti capita `False` come goal, puoi solo sperare di avere una contraddizione tra le\n" +"`False` è un goal insoddisfacibile, impossibile da dedurre da un insieme " +"consistente di ipotesi!\n" +"Quindi se ti capita `False` come goal, puoi solo sperare di avere una " +"contraddizione tra le\n" "tue ipotesi, come accade in questo livello." #: Game.Levels.Implication.L08ne @@ -2874,14 +3189,16 @@ msgstr "" "l'`apply` di `h2` con `at h1` o direttamente sul goal." #: Game.Levels.Implication.L08ne -msgid "`a ≠ b` is *notation* for `(a = b) → False`.\n" +#, fuzzy +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 use can treat `a ≠ b` in exactly\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" @@ -2895,8 +3212,10 @@ msgstr "" "è la negazione logica di `P`. Infatti `True → False` è falso,\n" "e `False → False` è vero!\n" "\n" -"Il vantaggio di questa notazione è che possiamo trattare una disuguaglianza `a ≠ b`\n" -"come se fosse un implicazione `P → Q`, che sappiamo già come manipolare. Ad esempio,\n" +"Il vantaggio di questa notazione è che possiamo trattare una disuguaglianza " +"`a ≠ b`\n" +"come se fosse un implicazione `P → Q`, che sappiamo già come manipolare. Ad " +"esempio,\n" "se il tuo *goal* è una disuguaglianza `a ≠ b`, puoi fare progresso\n" "con `intro h`, e se un'ipotesi `h` è una disuguaglianza\n" "`a ≠ b` allora puoi fare `apply h at h1` se `h1` è la prova di\n" @@ -2911,7 +3230,8 @@ msgid "zero_ne_succ" msgstr "zero_ne_succ" #: Game.Levels.Implication.L09zero_ne_succ -msgid "`zero_ne_succ n` is the proof that `0 ≠ succ n`.\n" +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" @@ -2923,16 +3243,20 @@ msgstr "" "In Lean, `a ≠ b` è *definito come* `a = b → False`. Dunque\n" "`zero_ne_succ n` è in realtà la dimostrazione di `0 = succ n → False`.\n" "Qui `False` è la proposizione false più banale. Essendo un'implicazione\n" -"puoi applicarla ad una `h` che dimostra `0 = succ n` con `apply zero_ne_succ at h`." +"puoi applicarla ad una `h` che dimostra `0 = succ n` con `apply zero_ne_succ " +"at h`." #: 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" +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 "" -"Come riscaldamento per il boss `2 + 2 ≠ 5` dimostriamo `0 ≠ 1`. A tal fine dobbiamo introdurre\n" +"Come riscaldamento per il boss `2 + 2 ≠ 5` dimostriamo `0 ≠ 1`. A tal fine " +"dobbiamo introdurre\n" "l'ultimo assioma di Peano, `zero_ne_succ n`, che dimostra che `0 ≠ succ n`.\n" -"Per capire meglio questo risultato, puoi consultare la sua voce nella lista di lemmi a destra." +"Per capire meglio questo risultato, puoi consultare la sua voce nella lista " +"di lemmi a destra." #: Game.Levels.Implication.L09zero_ne_succ msgid "`zero_ne_one` is a proof of `0 ≠ 1`." @@ -2964,7 +3288,8 @@ msgid "1 ≠ 0" msgstr "1 ≠ 0" #: Game.Levels.Implication.L10one_ne_zero -msgid "We know `zero_ne_succ n` is a proof of `0 = succ n → False` -- but what\n" +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" @@ -2972,16 +3297,21 @@ msgid "We know `zero_ne_succ n` is a proof of `0 = succ n → False` -- but what "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 "" -"Abbiamo visto che `zero_ne_succ n` è la dimostrazione di `0 = succ n → False` -- ma come possiamo applicarla\n" -"all'ipotesi `succ n = 0`? È la stessa uguaglianza, solo con i due lati scambiati!\n" +"Abbiamo visto che `zero_ne_succ n` è la dimostrazione di `0 = succ n → " +"False` -- ma come possiamo applicarla\n" +"all'ipotesi `succ n = 0`? È la stessa uguaglianza, solo con i due lati " +"scambiati!\n" "\n" -"La tattica `symm` ci viene in soccorso: riscrive un goal `x = y` in `y = x`, e un goal `x ≠ y`\n" +"La tattica `symm` ci viene in soccorso: riscrive un goal `x = y` in `y = x`, " +"e un goal `x ≠ y`\n" "in `y ≠ x`. `symm at h`\n" -"è la versione che opera sull'ipotesi `h`. Abbiamo dimostrato poco fa $0 \\neq 1$ e chiamato\n" +"è la versione che opera sull'ipotesi `h`. Abbiamo dimostrato poco fa $0 " +"\\neq 1$ e chiamato\n" "la sua dimostrazione `zero_ne_one`; ora prova a dimostrare $1 \\neq 0$." #: Game.Levels.Implication.L10one_ne_zero -msgid "## Summary\n" +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" @@ -2998,7 +3328,8 @@ msgstr "" "## Descrizione\n" "\n" "La tattica `symm` trasformerà un goal o un'ipotesi della forma di\n" -"un'uguaglianza `X = Y` in `Y = X`. Funziona anche sulla disuguaglianza `X ≠ Y`\n" +"un'uguaglianza `X = Y` in `Y = X`. Funziona anche sulla disuguaglianza `X ≠ " +"Y`\n" "e sull'equivalenza `X ↔ Y`.\n" "\n" "### Esempio\n" @@ -3018,7 +3349,8 @@ msgid "$1\\neq0$." msgstr "$1\\neq0$." #: Game.Levels.Implication.L10one_ne_zero -msgid "What do you think of this two-liner:\n" +msgid "" +"What do you think of this two-liner:\n" "```\n" "symm\n" "exact zero_ne_one\n" @@ -3041,12 +3373,16 @@ msgid "2 + 2 ≠ 5" msgstr "2 + 2 ≠ 5" #: 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" +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 "" -"2 + 2 ≠ 5 è noioso da dimostrare per intero con le tattiche che abbiamo a disposizione al momento.\n" -"Per salvarti un po' di lavoro, ho espanso in anticipo tutti i numeri per te.\n" +"2 + 2 ≠ 5 è noioso da dimostrare per intero con le tattiche che abbiamo a " +"disposizione al momento.\n" +"Per salvarti un po' di lavoro, ho espanso in anticipo tutti i numeri per " +"te.\n" "Completa la dimostrazione utilizzando `zero_ne_succ` e `succ_inj`." #: Game.Levels.Implication.L11two_add_two_ne_five @@ -3064,12 +3400,15 @@ msgid "" "exact h\n" "```\n" "\n" -"Even though Lean is a theorem prover, right now it's pretty clear that we have not\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 \"Leave World\" and\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 \"Leave " +"World\" and\n" "decide your route." msgstr "" "Ecco la mia dimostrazione:\n" @@ -3081,11 +3420,16 @@ msgstr "" "exact h\n" "```\n" "\n" -"Lean è un theorem prover, ma non abbiamo ancora parlato del fatto che può anche fungere da linguaggio di programmazione. Nel Mondo Algoritmi,\n" -"un mondo dal carattere più informatico, svilupperemo programmi per automatizzare le\n" -"dimostrazioni, grazie ai quali potremo dimostrare $20 + 20 ≠ 41$ senza diventare matti.\n" -"In alternativa, puoi proseguire lungo il filo matematico nel Mondo Addizione Avanzata, dove dimostreremo\n" -"i lemmi che supportano la teoria delle disuguaglianze. Clicca su \"Abbandona mondo\" e\n" +"Lean è un theorem prover, ma non abbiamo ancora parlato del fatto che può " +"anche fungere da linguaggio di programmazione. Nel Mondo Algoritmi,\n" +"un mondo dal carattere più informatico, svilupperemo programmi per " +"automatizzare le\n" +"dimostrazioni, grazie ai quali potremo dimostrare $20 + 20 ≠ 41$ senza " +"diventare matti.\n" +"In alternativa, puoi proseguire lungo il filo matematico nel Mondo Addizione " +"Avanzata, dove dimostreremo\n" +"i lemmi che supportano la teoria delle disuguaglianze. Clicca su \"Abbandona " +"mondo\" e\n" "scegli la tua strada." #: Game.Levels.Implication @@ -3110,7 +3454,8 @@ msgstr "" "Abbiamo dimostrato $2+2=4$; nel Mondo Implicazione vedremo\n" "come dimostrare $2+2\\neq 5$.\n" "\n" -"Nel Mondo Addizione abbiamo dimostrato *uguaglianze* del tipo $x + y = y + x$.\n" +"Nel Mondo Addizione abbiamo dimostrato *uguaglianze* del tipo $x + y = y + " +"x$.\n" "In questo mondo apprenderai le tattiche\n" "che ci permettono di dimostrare le *implicazioni*\n" "come $x+1=4 \\implies x=3.$\n" @@ -3126,12 +3471,14 @@ msgstr "add_left_comm" #: Game.Levels.Algorithm.L01add_left_comm msgid "`add_left_comm a b c` is a proof that `a + (b + c) = b + (a + c)`." -msgstr "`add_left_comm a b c` è la dimostrazione di `a + (b + c) = b + (a + c)`." +msgstr "" +"`add_left_comm a b c` è la dimostrazione di `a + (b + c) = b + (a + c)`." #: 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" +"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" @@ -3140,12 +3487,15 @@ msgid "" "`a + b + c` means `(a + b) + c`." msgstr "" "Ricollocare le variabili manualmente usando la commutatività e\n" -"l'associatività è un lavoraccio. Ma possiamo fare di meglio. `add_left_comm`\n" -"è un lemma chiave del primo algoritmo che spiegheremo, ma prima di impiegarlo dobbiamo\n" +"l'associatività è un lavoraccio. Ma possiamo fare di meglio. " +"`add_left_comm`\n" +"è un lemma chiave del primo algoritmo che spiegheremo, ma prima di " +"impiegarlo dobbiamo\n" "dimostrarlo.\n" "\n" "Ricorda che puoi applicare la commutatività precisando le \n" -"variabili che vuoi scambiare, scrivendo tipo `rw [add_comm b c]`. Ricorda anche che\n" +"variabili che vuoi scambiare, scrivendo tipo `rw [add_comm b c]`. Ricorda " +"anche che\n" "`a + b + c` sta per `(a + b) + c`." #: Game.Levels.Algorithm.L01add_left_comm @@ -3171,7 +3521,8 @@ msgid "" msgstr "" "Nei mondi successivi ci sono livelli molto più brutti\n" "come `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`.\n" -"Qui le parentesi vanno spostate, e le variabili vanno scambiate tra di loro.\n" +"Qui le parentesi vanno spostate, e le variabili vanno scambiate tra di " +"loro.\n" "\n" "In questo livello, `(a + b) + (c + d) = ((a + c) + d) + b`,\n" "dimentichiamoci delle parentesi e concentriamoci solamente\n" @@ -3189,8 +3540,10 @@ msgstr "" "$(a + b) + (c + d) = ((a + c) + d) + b.$" #: Game.Levels.Algorithm.L02add_algo1 -msgid "Start with `repeat rw [add_assoc]` to push all the brackets to the right." -msgstr "Inizia con `repeat rw [add_assoc]` per portare tutte le parentesi a destra." +msgid "" +"Start with `repeat rw [add_assoc]` to push all the brackets to the right." +msgstr "" +"Inizia con `repeat rw [add_assoc]` per portare tutte le parentesi a destra." #: Game.Levels.Algorithm.L02add_algo1 msgid "" @@ -3225,27 +3578,34 @@ 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" +"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 "" "# Overview\n" "\n" "Il semplificatore di Lean, `simp`, riscriverà ogni\n" "lemma con il tag `simp` e ogni lemma dato dall'utente, finché può.\n" -"Non solo, cercherà di ordinare le variabili secondo la sua logica interna affinché non entri\n" +"Non solo, cercherà di ordinare le variabili secondo la sua logica interna " +"affinché non entri\n" "in un loop infinito quando utilizza lemmi come `add_comm`" #: 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" +"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 "" -"Il semplificatore Lean, `simp`, può essere considerato una versione dopata di `rw`. Esso riscriverà ogni lemma\n" -"taggato `simp` e ogni lemma passato dall'utente fin tanto c'è qualcosa da riscrivere, più che può.\n" +"Il semplificatore Lean, `simp`, può essere considerato una versione dopata " +"di `rw`. Esso riscriverà ogni lemma\n" +"taggato `simp` e ogni lemma passato dall'utente fin tanto c'è qualcosa da " +"riscrivere, più che può.\n" "\n" "Questo è un livello che non vorresti risolvere a mano.\n" "Fai fare il lavoro sporco al semplificatore." @@ -3259,8 +3619,12 @@ msgstr "" "$(d + f) + (h + (a + c)) + (g + e + b) = a + b + c + d + e + f + g + h$." #: Game.Levels.Algorithm.L03add_algo2 -msgid "Solve this level in one line with `simp only [add_assoc, add_left_comm, add_comm]`" -msgstr "Completa questo livello in un'unica riga con `simp only [add_assoc, add_left_comm, add_comm]`" +msgid "" +"Solve this level in one line with `simp only [add_assoc, add_left_comm, " +"add_comm]`" +msgstr "" +"Completa questo livello in un'unica riga con `simp only [add_assoc, " +"add_left_comm, add_comm]`" #: Game.Levels.Algorithm.L03add_algo2 msgid "Let's now make our own tactic to do this." @@ -3318,7 +3682,8 @@ msgstr "pred" #: Game.Levels.Algorithm.L05pred msgid "" -"We now start work on an algorithm to do addition more efficiently. Recall that\n" +"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" @@ -3331,13 +3696,18 @@ msgid "" "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" +"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." +"Peano assumed as an axiom and which we have already used extensively without " +"justification." msgstr "" -"Ora svilupperemo un algoritmo che ci permette di svolgere le addizioni in maniera più efficiente. Se ricordi,\n" -"abbiamo definito l'addizione tramite la ricorsione, definendo il suo comportamento su `0` e sul successore.\n" +"Ora svilupperemo un algoritmo che ci permette di svolgere le addizioni in " +"maniera più efficiente. Se ricordi,\n" +"abbiamo definito l'addizione tramite la ricorsione, definendo il suo " +"comportamento su `0` e sul successore.\n" "Uno degli assiomi di Lean dice proprio che la ricorsione è un metodo valido\n" "per definire funzioni su tipi di dato induttivi, come i numeri naturali.\n" "\n" @@ -3349,10 +3719,13 @@ msgstr "" "pred (succ n) := n\n" "```\n" "\n" -"Non potendo sottrarre uno da 0, in tal caso restituiamo un valore spazzatura. In aggiunta a questa\n" -"definizione, creiamo un nuovo lemma `pred_succ` che dice `pred (succ n) = n`.\n" +"Non potendo sottrarre uno da 0, in tal caso restituiamo un valore " +"spazzatura. In aggiunta a questa\n" +"definizione, creiamo un nuovo lemma `pred_succ` che dice `pred (succ n) = " +"n`.\n" "Usiamo subito questo lemma per dimostrare `succ_inj`, il teorema che\n" -"Peano postulò come assioma e che abbiamo usato estensivamente finora senza mai motivarlo." +"Peano postulò come assioma e che abbiamo usato estensivamente finora senza " +"mai motivarlo." #: Game.Levels.Algorithm.L05pred msgid "`pred_succ n` is a proof of `pred (succ n) = n`." @@ -3372,7 +3745,8 @@ msgid "" "Let's now prove Peano's other axiom, that successors can't be $0$." msgstr "" "Bene! Hai dimostrato `succ_inj`!\n" -"Ora dimostriamo l'altro assioma di Peano, ossia che un successore non può essere $0$." +"Ora dimostriamo l'altro assioma di Peano, ossia che un successore non può " +"essere $0$." #: Game.Levels.Algorithm.L06is_zero msgid "is_zero" @@ -3387,14 +3761,19 @@ msgid "" "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" +"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." +"If you can turn your goal into `True`, then the `trivial` tactic will solve " +"it." msgstr "" "Definiamo la funzione `is_zero` così:\n" "\n" @@ -3403,14 +3782,18 @@ msgstr "" "is_zero (succ n) := False\n" "```\n" "\n" -"E creiamo due lemmi associati, `is_zero_zero` e `is_zero_succ n`, che dicono che `is_zero 0 = True`\n" -"e `is_zero (succ n) = False`. Usiamo questi due lemmi per dimostrare `succ_ne_zero`, l'ultimo assioma di\n" -"Peano. Può sembrare ripetitivo perché abbiamo già `zero_ne_succ` nel nostro arsenale, ma è comodo avere anche\n" +"E creiamo due lemmi associati, `is_zero_zero` e `is_zero_succ n`, che dicono " +"che `is_zero 0 = True`\n" +"e `is_zero (succ n) = False`. Usiamo questi due lemmi per dimostrare " +"`succ_ne_zero`, l'ultimo assioma di\n" +"Peano. Può sembrare ripetitivo perché abbiamo già `zero_ne_succ` nel nostro " +"arsenale, ma è comodo avere anche\n" "la versione opposta, la cui dimostrazione è identica. Nota: ora potresti\n" "barare usando `zero_ne_succ`, ma l'obiettivo di questo mondo\n" "è proprio insegnarti a *dimostrare* tali risultati.\n" "\n" -"Se riesci a riscrivere il goal a `True`, potrai risolverlo con la tattica `trivial`." +"Se riesci a riscrivere il goal a `True`, potrai risolverlo con la tattica " +"`trivial`." #: Game.Levels.Algorithm.L06is_zero msgid "`is_zero_zero` is a proof of `is_zero 0 = True`." @@ -3469,7 +3852,8 @@ msgstr "Un algoritmo per l'uguaglianza" #: 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" +"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" @@ -3479,19 +3863,24 @@ msgid "" "\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" +"*) 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" +"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" +"`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 "" "Cominciamo lo sviluppo\n" "di un algoritmo che, dati due naturali `a` e`b`, restituisce la risposta\n" "alla domanda \"does `a = b`?\"\n" "\n" -"Presentiamo l'algoritmo. Nota prima che `a` e `b` sono entrambi numeri, e dunque\n" +"Presentiamo l'algoritmo. Nota prima che `a` e `b` sono entrambi numeri, e " +"dunque\n" "sono `0` oppure dei successori.\n" "\n" "*) Se `a` e `b` sono entrambi `0`, restituiamo \"sì\".\n" @@ -3500,10 +3889,14 @@ msgstr "" "\n" "*) Se `a = succ m` e `b = succ n`, restituiamo la risposta a \"`m = n`?\"\n" "\n" -"Non ci rimane che *dimostrare* che questo algoritmo ci dà sempre la risposta corretta. Procediamo per casi. La dimostrazione di\n" -"`0 = 0` è `rfl`. La dimostrazione di `0 ≠ succ n` è `zero_ne_succ n`, e la dimostrazione di\n" -"`succ m ≠ 0` è `succ_ne_zero m`. La dimostrazione di \"se `h : m = n` allora\n" -"`succ m = succ n`\" è `rw [h]` e infine `rfl`. Questo livello ci salva una parte di\n" +"Non ci rimane che *dimostrare* che questo algoritmo ci dà sempre la risposta " +"corretta. Procediamo per casi. La dimostrazione di\n" +"`0 = 0` è `rfl`. La dimostrazione di `0 ≠ succ n` è `zero_ne_succ n`, e la " +"dimostrazione di\n" +"`succ m ≠ 0` è `succ_ne_zero m`. La dimostrazione di \"se `h : m = n` " +"allora\n" +"`succ m = succ n`\" è `rw [h]` e infine `rfl`. Questo livello ci salva una " +"parte di\n" "lavoro per dimostrare: se `a ≠ b` allora `succ a ≠ succ b`." #: Game.Levels.Algorithm.L07succ_ne_succ @@ -3518,7 +3911,8 @@ msgid "" "\n" "`c ≠ d`\n" "\n" -"then `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\n" +"then `contrapose! h` replaces the set-up with its so-called \\" +"\"contrapositive\\\":\n" "a hypothesis\n" "\n" "`h : c = d`\n" @@ -3537,7 +3931,8 @@ msgstr "" "\n" "`c ≠ d`\n" "\n" -"allora `contrapose! h` cambierà l'impostazione con la cosiddetta \\\"contronominale\\\":\n" +"allora `contrapose! h` cambierà l'impostazione con la cosiddetta \\" +"\"contronominale\\\":\n" "un ipotesi\n" "\n" "`h : c = d`\n" @@ -3551,16 +3946,22 @@ msgid "`succ_ne_succ m n` is the proof that `m ≠ n → succ m ≠ succ n`." msgstr "`succ_ne_succ m n` è la dimostrazione di `m ≠ n → succ m ≠ succ n`." #: Game.Levels.Algorithm.L07succ_ne_succ -msgid "If $a \\neq b$ then $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$." -msgstr "Se $a \\neq b$ allora $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$." +msgid "" +"If $a \\neq b$ then $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$." +msgstr "" +"Se $a \\neq b$ allora $\\operatorname{succ}(a) \\neq\\operatorname{succ}(b)$." #: Game.Levels.Algorithm.L07succ_ne_succ +#, fuzzy msgid "" "Start with `contrapose! h`, to change the goal into its\n" -"contrapositive, namely a hypothesis of `succ m = succ m` and a goal of `m = n`." +"contrapositive, namely a hypothesis of `succ m = succ n` and a goal of `m = " +"n`." msgstr "" "Inizia con `contrapose! h`, che ti fa dimostrare la\n" -"contronominale del goal, cioè avrai tra le ipotesi la negazione del goal, `succ m = succ m`, e come nuovo goal avrai la negazione dell'ipotesi `h`, `m = n`." +"contronominale del goal, cioè avrai tra le ipotesi la negazione del goal, " +"`succ m = succ m`, e come nuovo goal avrai la negazione dell'ipotesi `h`, `m " +"= n`." #: Game.Levels.Algorithm.L07succ_ne_succ msgid "" @@ -3583,8 +3984,10 @@ msgid "" "\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" +"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 "" "# Descrizione\n" @@ -3594,13 +3997,16 @@ msgstr "" "\n" "## Esempio\n" "\n" -"Un termine di tipo `DecidableEq ℕ` è un algoritmo che decide se due naturali\n" +"Un termine di tipo `DecidableEq ℕ` è un algoritmo che decide se due " +"naturali\n" "sono uguali o diversi. Dunque, se abbiamo un'istanza di questo tipo,\n" -"la tattica `decide` può usare la sua implementazione per risolvere i goal della forma `a = b` or `a ≠ b`." +"la tattica `decide` può usare la sua implementazione per risolvere i goal " +"della forma `a = b` or `a ≠ b`." #: Game.Levels.Algorithm.L08decide msgid "" -"Implementing the algorithm for equality of naturals, and the proof that it is correct,\n" +"Implementing the algorithm for equality of naturals, and the proof that it " +"is correct,\n" "looks like this:\n" "\n" "```\n" @@ -3630,7 +4036,8 @@ msgid "" "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 "" -"L'implementazione dell'algoritmo di uguaglianza tra naturali, e la sua dimostrazione di correttezza,\n" +"L'implementazione dell'algoritmo di uguaglianza tra naturali, e la sua " +"dimostrazione di correttezza,\n" "somigliano a questo:\n" "\n" "```\n" @@ -3655,10 +4062,12 @@ msgstr "" " exact succ_ne_succ m n h\n" "```\n" "\n" -"Questo codice Lean è un algoritmo formalmente verificato che risolve il problema decisionale dell'uguaglianza\n" +"Questo codice Lean è un algoritmo formalmente verificato che risolve il " +"problema decisionale dell'uguaglianza\n" "di due numeri naturali. L'ho già inserito dietro le quinte nel gioco.\n" "Dato che abbiamo prova formale della correttezza dell'algoritmo, possiamo\n" -"impiegarlo nelle dimostrazioni di Lean. Puoi eseguire l'algoritmo all'interno di una dimostrazione con la tattica `decide`." +"impiegarlo nelle dimostrazioni di Lean. Puoi eseguire l'algoritmo " +"all'interno di una dimostrazione con la tattica `decide`." #: Game.Levels.Algorithm.L08decide msgid "$20+20=40$." @@ -3677,17 +4086,23 @@ msgid "decide again" msgstr "decide, ancora" #: Game.Levels.Algorithm.L09decide2 -msgid "We gave a pretty unsatisfactory proof of `2 + 2 ≠ 5` earlier on; now give a nicer one." -msgstr "La dimostrazione che abbiamo dato prima per `2 + 2 ≠ 5` non è stata molto elegante; danne una più carina." +msgid "" +"We gave a pretty unsatisfactory proof of `2 + 2 ≠ 5` earlier on; now give a " +"nicer one." +msgstr "" +"La dimostrazione che abbiamo dato prima per `2 + 2 ≠ 5` non è stata molto " +"elegante; danne una più carina." #: Game.Levels.Algorithm.L09decide2 msgid "$2+2 \\neq 5.$" msgstr "$2+2 \\neq 5.$" #: Game.Levels.Algorithm.L09decide2 +#, fuzzy msgid "" "Congratulations! You've finished Algorithm World. These algorithms\n" -"will be helpful for you in Even-Odd World." +"will be helpful for you in Even-Odd World (when someone gets around to\n" +"implementing it)." msgstr "" "Congratulazioni! Hai finito il Mondo Algoritmi. Questi algoritmi\n" "ti saranno sicuramente utili per il Mondo Pari-Dispari." @@ -3698,13 +4113,16 @@ msgstr "Mondo Algoritmi" #: 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" +"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 "" -"Dimostrazioni come quelle di $2+2=4$ e $a+b+c+d+e=e+d+c+b+a$ sono una tortura da fare a mano.\n" -"Nel Mondo Algoritmi vedremo come farle risolvere al computer al posto nostro.\n" +"Dimostrazioni come quelle di $2+2=4$ e $a+b+c+d+e=e+d+c+b+a$ sono una " +"tortura da fare a mano.\n" +"Nel Mondo Algoritmi vedremo come farle risolvere al computer al posto " +"nostro.\n" "\n" "Premi su \"Via\" per cominciare." @@ -3745,10 +4163,12 @@ msgstr "`add_left_cancel a b n` è il teorema $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`." +"You can prove it by induction on `n` or you can deduce it from " +"`add_right_cancel`." msgstr "" "`add_left_cancel a b n` è il teorema che dice $n+a=n+b\\implies a=b$.\n" -"Puoi dimostrarlo facendo induzione su `n` oppure puoi dedurlo tramite `add_right_cancel`." +"Puoi dimostrarlo facendo induzione su `n` oppure puoi dedurlo tramite " +"`add_right_cancel`." #: Game.Levels.AdvAddition.L02add_left_cancel msgid "$n+a=n+b\\implies a=b$." @@ -3787,8 +4207,10 @@ msgstr "$x + y = y\\implies x=0.$" #: 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" +"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" @@ -3799,11 +4221,14 @@ msgid "" "```" msgstr "" "Per caso hai fatto induzione su `y`?\n" -"Ecco una dimostrazione in due righe `add_left_eq_self` che sfrutta `add_right_cancel`.\n" -"Se vuoi vedere come funziona, vai in editor mode cliccando su `` in alto a destra,\n" +"Ecco una dimostrazione in due righe `add_left_eq_self` che sfrutta " +"`add_right_cancel`.\n" +"Se vuoi vedere come funziona, vai in editor mode cliccando su `` in alto " +"a destra,\n" "copia e incolla la mia dimostrazione e muoviti tra le linee con il cursore\n" "per vedere le ipotesi e il goal in ogni punto\n" -"(prima salva la tua dimostrazione però, altrimenti la perdi). Premi su `>_` per\n" +"(prima salva la tua dimostrazione però, altrimenti la perdi). Premi su `>_` " +"per\n" "tornare alla modalità command line.\n" "```\n" "nth_rewrite 2 [← zero_add y]\n" @@ -3824,7 +4249,8 @@ msgid "" "Two ways to do it spring to mind; I'll mention them when you've solved it." msgstr "" "`add_right_eq_self x y` è il teorema $x + y = x\\implies y=0.$\n" -"Mi vengono in mente due modi per dimostrarlo, ma te li dirò una volta che lo dimostri." +"Mi vengono in mente due modi per dimostrarlo, ma te li dirò una volta che lo " +"dimostri." #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "$x+y=x\\implies y=0$." @@ -3833,12 +4259,16 @@ msgstr "$x+y=x\\implies y=0$." #: 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." +"instead of `apply [add_left_eq_self] at h`? You can complare the two in the " +"inventory." msgstr "" -"Questo stato non è dimostrabile! Per caso hai usato `rw [add_left_eq_self] at h`\n" -"anziché `apply [add_left_eq_self] at h`? Puoi confrontare il loro effetto nell'inventario." +"Questo stato non è dimostrabile! Per caso hai usato `rw [add_left_eq_self] " +"at h`\n" +"anziché `apply [add_left_eq_self] at h`? Puoi confrontare il loro effetto " +"nell'inventario." #: Game.Levels.AdvAddition.L04add_right_eq_self +#, fuzzy msgid "" "Here's a proof using `add_left_eq_self`:\n" "```\n" @@ -3854,20 +4284,18 @@ msgid "" "exact add_left_eq_self y x\n" "```\n" "\n" -"Alternatively you can just prove it by induction on `x`\n" -"(the dots in the proof just indicate the two goals and\n" -"can be omitted):\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" -" assumption\n" -" · intro h\n" -" rw [succ_add] at h\n" -" apply succ_inj at h\n" -" apply hd at h\n" -" assumption\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 "" "Ecco una dimostrazione che usa `add_left_eq_self`:\n" @@ -3886,7 +4314,8 @@ msgstr "" "\n" "Volendo puoi anche dimostrarlo per induzione su `x`\n" "(i pallini nel codice qui sotto hanno solo funzione decorativa,\n" -"assieme all'indentazione servono per riconoscere più facilmente i due sottogoal, ma possono essere omessi):\n" +"assieme all'indentazione servono per riconoscere più facilmente i due " +"sottogoal, ma possono essere omessi):\n" "\n" "```\n" " induction x with d hd\n" @@ -3906,75 +4335,103 @@ msgstr "add_right_eq_zero" #: 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" +"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" +"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" +"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." +"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 "" -"Il prossimo risultato di cui abbiamo bisogno per il Mondo `≤` è: se `a + b = 0` allora `a = 0` e `b = 0`.\n" -"In questo livello dimostriamo solo la prima parte della conclusione, la seconda nel livello successivo.\n" +"Il prossimo risultato di cui abbiamo bisogno per il Mondo `≤` è: se `a + b = " +"0` allora `a = 0` e `b = 0`.\n" +"In questo livello dimostriamo solo la prima parte della conclusione, la " +"seconda nel livello successivo.\n" "\n" "## Nuova tattica: `cases`\n" "\n" -"La tattica `cases` scompone un oggetto o un'ipotesi in tutti i modi possibili\n" +"La tattica `cases` scompone un oggetto o un'ipotesi in tutti i modi " +"possibili\n" "in cui può essere stato creato.\n" "\n" -"Ad esempio, su un numero naturale a volte è sufficiente ragionare con i due casi `b = 0` e `b = succ d` separatamente,\n" +"Ad esempio, su un numero naturale a volte è sufficiente ragionare con i due " +"casi `b = 0` e `b = succ d` separatamente,\n" "tralasciando l'ipotesi induttiva `hd` prodotta da `induction b with d hd`.\n" -"In questa situazione puoi usare `cases b with d`. Ci sono due modi per creare un numero:\n" -"come zero o come successore di qualcosa. `case` riprodurrà proprio queste due alternative, spezzando la dimostrazione in due sotto-goal, uno\n" +"In questa situazione puoi usare `cases b with d`. Ci sono due modi per " +"creare un numero:\n" +"come zero o come successore di qualcosa. `case` riprodurrà proprio queste " +"due alternative, spezzando la dimostrazione in due sotto-goal, uno\n" "con l'ipotesi `b = 0` e un'altro con l'ipotesi `b = succ d`.\n" "\n" -"Chiariamo con un altro esempio: se hai l'ipotesi `h : False` allora hai finito, perché un'affermazione falsa implica\n" -"qualsiasi cosa. Qua `cases h` chiuderà la dimostrazione, perché *non* vi è alcun modo\n" -"di costruire una dimostrazione di `False`! Quindi rimarrai con zero sotto-goal da dimostrare, ossia hai dimostrato tutto." +"Chiariamo con un altro esempio: se hai l'ipotesi `h : False` allora hai " +"finito, perché un'affermazione falsa implica\n" +"qualsiasi cosa. Qua `cases h` chiuderà la dimostrazione, perché *non* vi è " +"alcun modo\n" +"di costruire una dimostrazione di `False`! Quindi rimarrai con zero sotto-" +"goal da dimostrare, ossia hai dimostrato tutto." #: 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" +"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" +"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" +"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" +"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" +"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" +"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 "" "## Descrizione\n" @@ -3982,32 +4439,40 @@ msgstr "" "Se `n` è un numero, allora `cases n with d` spezzerà il goal in due goal,\n" "uno dove `n = 0` e un altro dove `n = succ d`.\n" "\n" -"Se `h` è una dimostrazione (per esempio tra le ipotesi), allora `cases h with...` spezzerà\n" +"Se `h` è una dimostrazione (per esempio tra le ipotesi), allora `cases h " +"with...` spezzerà\n" "la dimostrazione in tante parti quante quanti i modi di derivare `h`.\n" "\n" "## Esempio\n" "\n" -"Se `n : ℕ` è un numero, allora `cases n with d` spezzerà il goal in due subgoal,\n" -"uno dove `n` è stato rimpiazzato da 0 e l'altro dove `n` è stato rimpiazzato da `succ d`. Questo\n" +"Se `n : ℕ` è un numero, allora `cases n with d` spezzerà il goal in due " +"subgoal,\n" +"uno dove `n` è stato rimpiazzato da 0 e l'altro dove `n` è stato rimpiazzato " +"da `succ d`. Questo\n" "corrisponde all'intuizione matematica che ogni numero naturale è o `0`\n" "oppure un successore.\n" "\n" "## Esempio\n" "\n" -"Se `h : P ∨ Q` è un'ipotesi, allora `cases h with hp hq` trasformerà il goal\n" +"Se `h : P ∨ Q` è un'ipotesi, allora `cases h with hp hq` trasformerà il " +"goal\n" "in due goal, uno con l'ipotesi `hp : P` e l'altro con\n" "l'ipotesi `hq : Q`.\n" "\n" "## Esempio\n" "\n" -"Se `h : False` è un'ipotesi, allora `cases h` trasformerà il goal in zero goal,\n" -"perché non vi è alcun modo di dimostrare `False`! E se rimani con zero cose da dimostrare\n" +"Se `h : False` è un'ipotesi, allora `cases h` trasformerà il goal in zero " +"goal,\n" +"perché non vi è alcun modo di dimostrare `False`! E se rimani con zero cose " +"da dimostrare\n" "vuol dire che hai completato il livello.\n" "\n" "## Esempio\n" "\n" -"Se `h : a ≤ b` è un'ipotesi, allora `cases h with c hc` istanzierà un nuovo numero `c`\n" -"e una dimostrazione di `hc : b = a + c`. Questo deriva dalla *definizione* di `a ≤ b`, che è\n" +"Se `h : a ≤ b` è un'ipotesi, allora `cases h with c hc` istanzierà un nuovo " +"numero `c`\n" +"e una dimostrazione di `hc : b = a + c`. Questo deriva dalla *definizione* " +"di `a ≤ b`, che è\n" "`∃ c, b = a + c`." #: Game.Levels.AdvAddition.L05add_right_eq_zero @@ -4036,10 +4501,12 @@ msgstr "add_left_eq_zero" #: 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" +"You can just mimic the previous proof to do this one -- or you can figure " +"out a way\n" "of using it." msgstr "" -"Puoi imitare la dimostrazione precedente per risolvere questa qua -- oppure potresti cercare un\n" +"Puoi imitare la dimostrazione precedente per risolvere questa qua -- oppure " +"potresti cercare un\n" "modo di applicarla." #: Game.Levels.AdvAddition.L06add_left_eq_zero @@ -4051,7 +4518,8 @@ msgid "If $a+b=0$ then $b=0$." msgstr "Se $a+b=0$ allora $b=0$." #: Game.Levels.AdvAddition.L06add_left_eq_zero -msgid "How about this for a proof:\n" +msgid "" +"How about this for a proof:\n" "\n" "```\n" "rw [add_comm]\n" @@ -4068,8 +4536,10 @@ msgstr "" "exact add_right_eq_zero b a\n" "```\n" "\n" -"Questo è tutto per il Mondo Addizione Avanzata! I teoremi di questo mondo ti torneranno utili\n" -"nel prossimo mondo, il Mondo `≤`. Clicca su \"Abbandona mondo\" per navigarci." +"Questo è tutto per il Mondo Addizione Avanzata! I teoremi di questo mondo ti " +"torneranno utili\n" +"nel prossimo mondo, il Mondo `≤`. Clicca su \"Abbandona mondo\" per " +"navigarci." #: Game.Levels.AdvAddition msgid "Advanced Addition World" @@ -4086,7 +4556,8 @@ msgid "" msgstr "" "Nel Mondo Addizione Avanzata dimostreremo delle proprietà\n" "basilari dell'addizione come $x+y=x\\implies y=0$. I teoremi\n" -"dimostrati in questo mondo servono da mattoncini teorici con cui costruiremo\n" +"dimostrati in questo mondo servono da mattoncini teorici con cui " +"costruiremo\n" "la teoria delle disuguaglianze nel Mondo `≤`.\n" "\n" "Premi su \"Via\" per iniziare." @@ -4096,6 +4567,7 @@ msgid "The `use` tactic" msgstr "La tattica `use`" #: Game.Levels.LessOrEqual.L01le_refl +#, fuzzy msgid "" "## Summary\n" "\n" @@ -4103,17 +4575,29 @@ msgid "" "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" +"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`." +"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 "" "## Descrizione\n" "\n" -"La tattica `use` permette di avanzare su goal che postulano l'*esistenza* di qualcosa.\n" -"Se il goal afferma che esiste una certa `x`con qualche proprietà, e sei sicuro\n" -"che `x = 37` la soddisfi, allora con `use 37` farai progresso nella dimostrazione.\n" +"La tattica `use` permette di avanzare su goal che postulano l'*esistenza* di " +"qualcosa.\n" +"Se il goal afferma che esiste una certa `x`con qualche proprietà, e sei " +"sicuro\n" +"che `x = 37` la soddisfi, allora con `use 37` farai progresso nella " +"dimostrazione.\n" "\n" -"Dato che `a ≤ b` è notazione per \\\"there exists `c` such that `b = a + c`\\\",\n" +"Dato che `a ≤ b` è notazione per \\\"there exists `c` such that `b = a + c`\\" +"\",\n" "puoi fare progresso su goal della forma `a ≤ b` passando a `use`\n" "quel numero che corrisponde a `b - a`, la distanza tra `a` e `b`." @@ -4133,7 +4617,8 @@ msgstr "" "Dato che in questo gioco non abbiamo i numeri negativi, questa definizione\n" "è matematicamente valida.\n" "\n" -"Una conseguenza pratica di tale definizione è che se hai un goal della forma `a ≤ b` puoi\n" +"Una conseguenza pratica di tale definizione è che se hai un goal della forma " +"`a ≤ b` puoi\n" "scomporlo con la tattica `use`, e se hai un'ipotesi\n" "`h : a ≤ b`, puoi scomporla tramite `cases h with c hc`." @@ -4187,8 +4672,11 @@ msgid "0 ≤ x" msgstr "0 ≤ x" #: Game.Levels.LessOrEqual.L02zero_le -msgid "To solve this level, you need to `use` a number `c` such that `x = 0 + c`." -msgstr "Per risolvere questo livello, dovrai chiamare `use` su un numero `c` tale che `x = 0 + c`." +msgid "" +"To solve this level, you need to `use` a number `c` such that `x = 0 + c`." +msgstr "" +"Per risolvere questo livello, dovrai chiamare `use` su un numero `c` tale " +"che `x = 0 + c`." #: Game.Levels.LessOrEqual.L02zero_le msgid "`zero_le x` is a proof that `0 ≤ x`." @@ -4211,7 +4699,8 @@ 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 "" -"Se applichi `use` su un numero errato, rimarrai bloccato con un goal non dimostrabile.\n" +"Se applichi `use` su un numero errato, rimarrai bloccato con un goal non " +"dimostrabile.\n" "Su che numero applicherai `use` qui?" #: Game.Levels.LessOrEqual.L03le_succ_self @@ -4234,7 +4723,8 @@ msgstr "" "exact succ_eq_add_one x\n" "```\n" "\n" -"Questo funziona perché `succ_eq_add_one x` è la dimostrazione di `succ x = x + 1`." +"Questo funziona perché `succ_eq_add_one x` è la dimostrazione di `succ x = x " +"+ 1`." #: Game.Levels.LessOrEqual.L04le_trans msgid "x ≤ y and y ≤ z implies x ≤ z" @@ -4248,30 +4738,41 @@ msgid "" "\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" +"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" +"$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` è la dimostrazione che se `x ≤ y` e `y ≤ z` allora `x ≤ z`.\n" -"Riscritto in termini logici, è la dimostrazione che `x ≤ y → (y ≤ z → x ≤ z)`. Questa formula si legge ad alta voce così:\n" +"`le_trans x y z` è la dimostrazione che se `x ≤ y` e `y ≤ z` allora `x ≤ " +"z`.\n" +"Riscritto in termini logici, è la dimostrazione che `x ≤ y → (y ≤ z → x ≤ " +"z)`. Questa formula si legge ad alta voce così:\n" "Se $x \\le y$ allora (pausa) se $y \\le z$ allora $x \\le z$.\n" "\n" "## Nota sull'associatività\n" "\n" -"Come sai già, in Lean `a + b + c` sta per `(a + b) + c`, dato che `+` associa a sinistra. Invece l'implicazione\n" -"`→` associa a destra. Dunque su Lean possiamo scrivere direttamente `x ≤ y → y ≤ z → x ≤ z`, che codifica\n" -"proprio la proprietà transitiva di `≤`. Attenzione però, in quanto a volte i matematici interpretano le sequenze di `→` diversamente; \n" -"per alcuni, $P \\implies Q \\implies R$ si traduce nella congiunzione $P \\implies Q$\n" +"Come sai già, in Lean `a + b + c` sta per `(a + b) + c`, dato che `+` " +"associa a sinistra. Invece l'implicazione\n" +"`→` associa a destra. Dunque su Lean possiamo scrivere direttamente `x ≤ y → " +"y ≤ z → x ≤ z`, che codifica\n" +"proprio la proprietà transitiva di `≤`. Attenzione però, in quanto a volte i " +"matematici interpretano le sequenze di `→` diversamente; \n" +"per alcuni, $P \\implies Q \\implies R$ si traduce nella congiunzione $P " +"\\implies Q$\n" "e $Q \\implies R$." #: Game.Levels.LessOrEqual.L04le_trans msgid "" -"In this level, we see inequalities as *hypotheses*. We have not seen this before.\n" +"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 "" -"In questo livello, abbiamo delle disuguaglianze tra le *ipotesi*. Non abbiamo ancora visto questo caso.\n" +"In questo livello, abbiamo delle disuguaglianze tra le *ipotesi*. Non " +"abbiamo ancora visto questo caso.\n" "La tattica `cases` può essere usata per scomporre l'ipotesi `hxy`." #: Game.Levels.LessOrEqual.L04le_trans @@ -4284,22 +4785,29 @@ msgstr "Inizia con `cases «{hxy}» with a ha`." #: Game.Levels.LessOrEqual.L04le_trans msgid "" -"Now `«{ha}»` is a proof that `«{y}» = «{x}» + «{a}»`, and `hxy` has vanished. Similarly, you can destruct\n" +"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 "" -"Ora `«{ha}»` è una dimostrazione di `«{y}» = «{x}» + «{a}»`, mentre `hxy` è scomparso. In modo simile, puoi scomporre\n" +"Ora `«{ha}»` è una dimostrazione di `«{y}» = «{x}» + «{a}»`, mentre `hxy` è " +"scomparso. In modo simile, puoi scomporre\n" "`«{hyz}»` nelle sue varie parti tramite `cases «{hyz}» with b hb`." #: 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 "Ora devi individuare il numero su cui applicare `use`. Fai un tentativo!" +msgid "" +"Now you need to figure out which number to `use`. See if you can take it " +"from here." +msgstr "" +"Ora devi individuare il numero su cui applicare `use`. Fai un tentativo!" #: Game.Levels.LessOrEqual.L04le_trans msgid "" -"A passing mathematician remarks that with reflexivity and transitivity out of the way,\n" +"A passing mathematician remarks that with reflexivity and transitivity out " +"of the way,\n" "you have proved that `≤` is a *preorder* on `ℕ`." msgstr "" -"Un matematico di passaggio ti fa notare che avendo dimostrato le proprietà riflessiva e transitiva,\n" +"Un matematico di passaggio ti fa notare che avendo dimostrato le proprietà " +"riflessiva e transitiva,\n" "hai dimostrato che `≤` è un *preordine* su `ℕ`." #: Game.Levels.LessOrEqual.L05le_zero @@ -4317,7 +4825,8 @@ msgid "" "addition world." msgstr "" "È \"intuitivamente ovvio\" che non esistono numeri naturali minori di zero,\n" -"ma per dimostrarlo dovrai ricorrere a un risultato che abbiamo dimostrato nel mondo\n" +"ma per dimostrarlo dovrai ricorrere a un risultato che abbiamo dimostrato " +"nel mondo\n" "Addizione Avanzata." #: Game.Levels.LessOrEqual.L05le_zero @@ -4342,7 +4851,8 @@ msgstr "x ≤ y e y ≤ x implica x = y" #: Game.Levels.LessOrEqual.L06le_antisymm msgid "`le_antisymm x y` is a proof that if `x ≤ y` and `y ≤ x` then `x = y`." -msgstr "`le_antisymm x y` è la dimostrazione che `x ≤ y` e `y ≤ x` implica `x = y`." +msgstr "" +"`le_antisymm x y` è la dimostrazione che `x ≤ y` e `y ≤ x` implica `x = y`." #: Game.Levels.LessOrEqual.L06le_antisymm msgid "" @@ -4350,7 +4860,8 @@ msgid "" "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 "" -"Questo livello ti chiede di dimostrare la proprietà *antisimmetrica* di $\\leq$.\n" +"Questo livello ti chiede di dimostrare la proprietà *antisimmetrica* di $" +"\\leq$.\n" "In formula, se $x \\leq y$ e $y \\leq x$ allora $x = y$.\n" "È forse la più complicata tra quelle affrontate finora. Buona fortuna!" @@ -4393,7 +4904,8 @@ msgstr "" "rfl\n" "```\n" "\n" -"Un matematico di passaggio ti fa notare che con l'aggiunta dell'antisimmetria,\n" +"Un matematico di passaggio ti fa notare che con l'aggiunta " +"dell'antisimmetria,\n" "hai dimostrato che `≤` è un *ordine parziale* su `ℕ`.\n" "\n" "Il livello boss di questo mondo consiste nel dimostrare\n" @@ -4422,10 +4934,12 @@ msgstr "" "Usala quando le tue ipotesi garantiscono che si può dedurre `P ∨ Q`\n" "dalla verità di `P`.\n" "\n" -"L'implementazione di Lean di questa tattica non fa altro che l'`apply` di un teorema\n" +"L'implementazione di Lean di questa tattica non fa altro che l'`apply` di un " +"teorema\n" "che dice $P \\implies P \\lor Q.$\n" "\n" -"Nota bene che questa tattica può portare il tuo goal a uno stato irrisolvibile." +"Nota bene che questa tattica può portare il tuo goal a uno stato " +"irrisolvibile." #: Game.Levels.LessOrEqual.L07or_symm msgid "" @@ -4441,19 +4955,23 @@ msgid "" "one." msgstr "" "# Descrizione\n" -"La tattica `right` trasforma un goal della forma `P ∨ Q` nel nuovo goal `Q`.\n" +"La tattica `right` trasforma un goal della forma `P ∨ Q` nel nuovo goal " +"`Q`.\n" "Usala quando le tue ipotesi garantiscono che si può dedurre `P ∨ Q`\n" "\n" "dalla verità di `Q`.\n" "\n" -"L'implementazione di Lean di questa tattica non fa altro che `apply` di un teorema\n" +"L'implementazione di Lean di questa tattica non fa altro che `apply` di un " +"teorema\n" "che dice che $Q \\implies P \\lor Q.$\n" "\n" -"Nota bene che questa tattica può portare il tuo goal a uno stato irrisolvibile." +"Nota bene che questa tattica può portare il tuo goal a uno stato " +"irrisolvibile." #: 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" +"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" @@ -4468,19 +4986,25 @@ msgid "" "`cases h with h1 h2` will create two goals, one where you went left,\n" "and the other where you went right." msgstr "" -"La totalità di `≤` è il livello boss di questo mondo, ed è il prossimo livello. Essa afferma che\n" +"La totalità di `≤` è il livello boss di questo mondo, ed è il prossimo " +"livello. Essa afferma che\n" "se `a` e `b` sono due numeri naturali allora `a ≤ b` or `b ≤ a`.\n" "Ma non abbiamo mai parlato di `or` (o, oppure). In breve:\n" "\n" -"1) La notazione per \"or\" è `∨`. Non avrai bisogno di digitarlo, ma puoi ottenere quel simbolo\n" +"1) La notazione per \"or\" è `∨`. Non avrai bisogno di digitarlo, ma puoi " +"ottenere quel simbolo\n" "digitando `\\or`.\n" "\n" -"2) Se hai un enunciato \"or\" nel *goal*, due tattiche ti consentono di fare progresso:\n" -"`left` e `right`. Ma non avere mai fretta di prendere una direzione o l'altra \n" -"se le tue ipotesi non ti garantiscono che stai scegliendo la direzione giusta.\n" +"2) Se hai un enunciato \"or\" nel *goal*, due tattiche ti consentono di fare " +"progresso:\n" +"`left` e `right`. Ma non avere mai fretta di prendere una direzione o " +"l'altra \n" +"se le tue ipotesi non ti garantiscono che stai scegliendo la direzione " +"giusta.\n" "\n" "3) Se hai un enunciato \"or\" come *ipotesi* `h`, allora\n" -"`cases h with h1 h2` creerà due goal, in uno devi dimostrare il lato sinistro,\n" +"`cases h with h1 h2` creerà due goal, in uno devi dimostrare il lato " +"sinistro,\n" "e nel secondo devi dimostrare il lato destro." #: Game.Levels.LessOrEqual.L07or_symm @@ -4488,15 +5012,20 @@ msgid "If $x=37$ or $y=42$, then $y=42$ or $x=37$." msgstr "Se $x=37$ o $y=42$, allora $y=42$ o $x=37$." #: 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 "Non sappiamo ancora se andare a sinistra o a destra nel goal. Dunque lavoriamo sull'ipotesi, inizia con `cases «{h}» with hx hy`." +msgid "" +"We don't know whether to go left or right yet. So start with `cases «{h}» " +"with hx hy`." +msgstr "" +"Non sappiamo ancora se andare a sinistra o a destra nel goal. Dunque " +"lavoriamo sull'ipotesi, inizia con `cases «{h}» with hx hy`." #: 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 "" -"Ora possiamo dimostrare il goal con `or` dimostrando la proposizione a destra,\n" +"Ora possiamo dimostrare il goal con `or` dimostrando la proposizione a " +"destra,\n" "perciò usa `right`." #: Game.Levels.LessOrEqual.L07or_symm @@ -4525,12 +5054,15 @@ msgid "" "I've left hidden hints; if you need them, retry from the beginning\n" "and click on \"Show more help!\"" msgstr "" -"Questo è a mio parere il livello più tosto. Due consigli: se `a` è un numero naturale\n" +"Questo è a mio parere il livello più tosto. Due consigli: se `a` è un numero " +"naturale\n" "allora `cases a with b` lo scomporrà nei casi `a = 0` e `a = succ b`.\n" -"Non andare a sinistra o a destra fin quando le tue ipotesi non ti garantiscono che\n" +"Non andare a sinistra o a destra fin quando le tue ipotesi non ti " +"garantiscono che\n" "puoi dimostrare quel ramo!\n" "\n" -"Ti ho lasciato alcuni indizi nascosti; quando ne hai bisogno, riavvia il livello\n" +"Ti ho lasciato alcuni indizi nascosti; quando ne hai bisogno, riavvia il " +"livello\n" "e clicca su \"Aiutami!\"" #: Game.Levels.LessOrEqual.L08le_total @@ -4551,20 +5083,24 @@ msgstr "Ora `cases «{h2}» with e he`." #: Game.Levels.LessOrEqual.L08le_total msgid "You still don't know which way to go, so do `cases «{e}» with a`." -msgstr "Non sai ancora che direzione intraprendere, quindi esegui `cases «{e}» with a`." +msgstr "" +"Non sai ancora che direzione intraprendere, quindi esegui `cases «{e}» with " +"a`." #: 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" +"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 "" "Ben fatto.\n" "\n" -"Un matematico di passaggio ti fa notare che hai appena dimostrato che `ℕ` è ordinato\n" +"Un matematico di passaggio ti fa notare che hai appena dimostrato che `ℕ` è " +"ordinato\n" "totalmente.\n" "\n" "Il resto dei livelli di questo mondo sono tutti in discesa." @@ -4575,7 +5111,9 @@ msgstr "succ x ≤ succ y → x ≤ y" #: 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` è la dimostrazione che se `succ x ≤ succ y`, allora `x ≤ y`." +msgstr "" +"`succ_le_succ x y` è la dimostrazione che se `succ x ≤ succ y`, allora `x ≤ " +"y`." #: Game.Levels.LessOrEqual.L09succ_le_succ msgid "" @@ -4588,8 +5126,11 @@ msgstr "" "Questo lemma è propedeutico alle loro dimostrazioni." #: Game.Levels.LessOrEqual.L09succ_le_succ -msgid "If $\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$ then $x \\leq y$." -msgstr "Se $\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$ allora $x \\leq y$." +msgid "" +"If $\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$ then $x \\leq y$." +msgstr "" +"Se $\\operatorname{succ}(x) \\leq \\operatorname{succ}(y)$ allora $x \\leq " +"y$." #: Game.Levels.LessOrEqual.L09succ_le_succ msgid "" @@ -4617,7 +5158,8 @@ msgstr "x ≤ 1" #: Game.Levels.LessOrEqual.L10le_one msgid "`le_one x` is a proof that if `x ≤ 1` then `x = 0` or `x = 1`." -msgstr "`le_one x` è la dimostrazione che se `x ≤ 1` allora `x = 0` or `x = 1`." +msgstr "" +"`le_one x` è la dimostrazione che se `x ≤ 1` allora `x = 0` or `x = 1`." #: Game.Levels.LessOrEqual.L10le_one msgid "" @@ -4661,15 +5203,19 @@ msgstr "" "rfl\n" "```\n" "\n" -"Se hai risolto questo livello allora puoi risolvere tranquillamente anche il successivo!" +"Se hai risolto questo livello allora puoi risolvere tranquillamente anche il " +"successivo!" #: Game.Levels.LessOrEqual.L11le_two msgid "le_two" msgstr "le_two" #: 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` è la dimostrazione che se `x ≤ 2` allora `x = 0` o `x = 1` or `x = 2`." +msgid "" +"`le_two x` is a proof that if `x ≤ 2` then `x = 0` or `x = 1` or `x = 2`." +msgstr "" +"`le_two x` è la dimostrazione che se `x ≤ 2` allora `x = 0` o `x = 1` or `x " +"= 2`." #: Game.Levels.LessOrEqual.L11le_two msgid "" @@ -4721,7 +5267,8 @@ msgid "" "\n" "Click on \"Start\" to proceed." msgstr "" -"In questo mondo diamo la definizione `a ≤ b` e dimostreremo qualche fatto comune\n" +"In questo mondo diamo la definizione `a ≤ b` e dimostreremo qualche fatto " +"comune\n" "sulle diseguaglianze, come \"se ho `a ≤ b` e `b ≤ c`, allora `a ≤ c`\".\n" "\n" "La definizione di `a ≤ b` è \"esiste un numero `c`\n" @@ -4737,11 +5284,13 @@ msgstr "mul_le_mul_right" #: Game.Levels.AdvMultiplication.L01mul_le_mul_right 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` è la dimostrazione che `a ≤ b → a * t ≤ b * t`." +msgstr "" +"`mul_le_mul_right a b t` è la dimostrazione che `a ≤ b → a * t ≤ b * t`." #: Game.Levels.AdvMultiplication.L01mul_le_mul_right msgid "Let's warm up with an easy one, which works even if `t = 0`." -msgstr "Riscaldiamoci le dita con un teorema facile, che vale anche per `t = 0`." +msgstr "" +"Riscaldiamoci le dita con un teorema facile, che vale anche per `t = 0`." #: Game.Levels.AdvMultiplication.L01mul_le_mul_right msgid "" @@ -4771,21 +5320,28 @@ msgstr "`mul_left_ne_zero a b` è la dimostrazione che `a * b ≠ 0 → b ≠ 0` #: Game.Levels.AdvMultiplication.L02mul_left_ne_zero msgid "" -"If you have completed Algorithm World then you can use the `contrapose!` tactic\n" +"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 "" -"Se hai già completato il Mondo Algoritmi puoi usare la tattica `contrapose!`\n" +"Se hai già completato il Mondo Algoritmi puoi usare la tattica `contrapose!" +"`\n" "qui. Altrimenti ti farò vedere un approccio manuale." #: 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." +"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 "" -"Vogliamo ridurre questo teorema a un'ipotesi `b = 0` e a un goal `a * b = 0`,\n" -"che insieme sono logicamente equivalenti all'originale ma più facili da dimostrare. Ricorda che `X ≠ 0`\n" -"è zucchero sintattico per `X = 0 → False`. Clicca su `Aiutami!` se hai bisogno di un indizio." +"Vogliamo ridurre questo teorema a un'ipotesi `b = 0` e a un goal `a * b = " +"0`,\n" +"che insieme sono logicamente equivalenti all'originale ma più facili da " +"dimostrare. Ricorda che `X ≠ 0`\n" +"è zucchero sintattico per `X = 0 → False`. Clicca su `Aiutami!` se hai " +"bisogno di un indizio." #: Game.Levels.AdvMultiplication.L02mul_left_ne_zero msgid "Start with `intro hb`." @@ -4800,12 +5356,29 @@ msgid "eq_succ_of_ne_zero" msgstr "eq_succ_of_ne_zero" #: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +#, fuzzy msgid "" "# Summary\n" "\n" -"The `tauto` tactic will solve any goal which can be solved purely by logic (that is, by\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" @@ -4817,24 +5390,38 @@ msgid "" "\n" "## Example\n" "\n" -"If you have two hypotheses `h1 : a = 37` and `h2 : a ≠ 37` then `tauto` will\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" +"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 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." +"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 "" "# Descrizione\n" "\n" -"La tattica `tauto` risolverà qualsiasi goal che può essere tramite puro ragionamento logico (ossia, tramite le\n" +"La tattica `tauto` risolverà qualsiasi goal che può essere tramite puro " +"ragionamento logico (ossia, tramite le\n" "tavole di verità).\n" "\n" "## Esempio\n" @@ -4855,42 +5442,60 @@ msgstr "" "## Esempio\n" "\n" "Se hai un'ipotesi `h : a ≠ a` allora `tauto` risolverà il goal perché\n" -"è abbastanza intelligente da capire che `a = a` è vero, arrivando alla contraddizione che cerchiamo.\n" +"è abbastanza intelligente da capire che `a = a` è vero, arrivando alla " +"contraddizione che cerchiamo.\n" "\n" "## Esempio\n" "\n" -"Se hai un'ipotesi della forma `a = 0 → a * b = 0` e hai il goal `a * b ≠ 0 → a ≠ 0`, allora\n" -"`tauto` risolverà il goal, because esso è logicamente equivalente all'ipotesi.\n" -"E se scambi il ruolo del goal e dell'ipotesi in questo esempio, `tauto` lo risolverebbe lo stesso." +"Se hai un'ipotesi della forma `a = 0 → a * b = 0` e hai il goal `a * b ≠ 0 → " +"a ≠ 0`, allora\n" +"`tauto` risolverà il goal, because esso è logicamente equivalente " +"all'ipotesi.\n" +"E se scambi il ruolo del goal e dell'ipotesi in questo esempio, `tauto` lo " +"risolverebbe lo stesso." #: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero msgid "`eq_succ_of_ne_zero a` is a proof that `a ≠ 0 → ∃ n, a = succ n`." -msgstr "`eq_succ_of_ne_zero a` è la dimostrazione che `a ≠ 0 → ∃ n, a = succ n`." +msgstr "" +"`eq_succ_of_ne_zero a` è la dimostrazione che `a ≠ 0 → ∃ n, a = succ n`." #: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +#, fuzzy msgid "" -"Multiplication usually makes a number bigger, but multiplication by zero can make\n" +"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 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" +"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 "" -"La moltiplicazione di norma fa crescere un numero, ma moltiplicare per zero lo rende\n" -"più piccolo, o meglio, lo azzera. Ecco perché gran parte dei teoremi che mischiano le disuguaglianze con la moltiplicazione hanno\n" -"l'ipotesi `a ≠ 0`. Questo livello è un lemma chiave che ci permette di mettere a frutto questa ipotesi.\n" -"Per aiutarci nella dimostrazione, possiamo usare la tattica `tauto`. Clicca sul nome della tattica\n" +"La moltiplicazione di norma fa crescere un numero, ma moltiplicare per zero " +"lo rende\n" +"più piccolo, o meglio, lo azzera. Ecco perché gran parte dei teoremi che " +"mischiano le disuguaglianze con la moltiplicazione hanno\n" +"l'ipotesi `a ≠ 0`. Questo livello è un lemma chiave che ci permette di " +"mettere a frutto questa ipotesi.\n" +"Per aiutarci nella dimostrazione, possiamo usare la tattica `tauto`. Clicca " +"sul nome della tattica\n" "sulla destra per una descrizione dettagliata su cosa fa." #: 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 "Inizia con `cases a with d` per spezzare il numero nei casi `a = 0` e `a = succ d`." +msgid "" +"Start with `cases a with d` to do a case split on `a = 0` and `a = succ d`." +msgstr "" +"Inizia con `cases a with d` per spezzare il numero nei casi `a = 0` e `a = " +"succ d`." #: 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" +"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 "" -"Nel \"caso base\" abbiamo un'ipotesi `ha : 0 ≠ 0`, e sappiamo che puoi dedurre qualsiasi cosa\n" +"Nel \"caso base\" abbiamo un'ipotesi `ha : 0 ≠ 0`, e sappiamo che puoi " +"dedurre qualsiasi cosa\n" "da una proposizione falsa. La tattica `tauto` chiuderà il goal." #: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero @@ -4926,22 +5531,30 @@ msgid "" msgstr "" "`le_mul_right a b` è la dimostrazione che `a * b ≠ 0 → a ≤ a * b`.\n" "\n" -"È un modo di dire che un divisore di un numero positivo dev'essere per forza\n" +"È un modo di dire che un divisore di un numero positivo dev'essere per " +"forza\n" "al massimo il numero stesso." #: Game.Levels.AdvMultiplication.L05le_mul_right +#, fuzzy msgid "" -"In Prime Number World we will be proving that $2$ is prime.\n" -"To do this, we will have to rule out things like $2 ≠ 37 × 42.$\n" +"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 pretty much everything which we've proved in this world so far." +"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 "" "Nel Mondo Numeri Primi dimostreremo che $2$ è primo.\n" "Ma per arrivarci, dobbiamo escludere falsità del tipo $2 ≠ 37 × 42.$\n" "Lo faremo mostrando che ogni fattore di $2$ è al più $2$,\n" -"che avremo gratis grazie a questo lemma. La dimostrazione che ho in mente io manipola l'ipotesi finché\n" -"non diventa il goal, usando praticamente tutto ciò che abbiamo dimostrato in questo mondo finora." +"che avremo gratis grazie a questo lemma. La dimostrazione che ho in mente io " +"manipola l'ipotesi finché\n" +"non diventa il goal, usando praticamente tutto ciò che abbiamo dimostrato in " +"questo mondo finora." #: Game.Levels.AdvMultiplication.L05le_mul_right msgid "" @@ -4968,16 +5581,19 @@ msgid "mul_right_eq_one" msgstr "mul_right_eq_one" #: Game.Levels.AdvMultiplication.L06mul_right_eq_one +#, fuzzy msgid "" "# Summary\n" "\n" -"The `have` tactic can be used to add new hypotheses to a level, but of course\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" +"The simplest usage is like this. If you have `a` in your context and you " +"execute\n" "\n" "`have ha : a = 0`\n" "\n" @@ -4998,7 +5614,7 @@ msgid "" "## Example\n" "\n" "If you have a proof to hand, then you don't even need to state what you\n" -"are proving. example\n" +"are proving. For example\n" "\n" "`have h2 := succ_inj a b`\n" "\n" @@ -5006,17 +5622,20 @@ msgid "" msgstr "" "# Descrizione\n" "\n" -"La tattica `have` può essere usata per aggiungere un'ipotesi a un livello, ma ovviamente ti chiede\n" +"La tattica `have` può essere usata per aggiungere un'ipotesi a un livello, " +"ma ovviamente ti chiede\n" "di dimostrarla.\n" "\n" "\n" "## Esempio\n" "\n" -"Il suo utilizzo più semplice e così. Se hai `a` nel contesto e vuoi eseguire\n" +"Il suo utilizzo più semplice e così. Se hai `a` nel contesto e vuoi " +"eseguire\n" "\n" "`have ha : a = 0`\n" "\n" -"allora otterrai un nuovo goal `a = 0` da dimostrare, e dopo che l'hai dimostrato\n" +"allora otterrai un nuovo goal `a = 0` da dimostrare, e dopo che l'hai " +"dimostrato\n" "avrai l'ipotesi `ha : a = 0` nel contesto originale.\n" "\n" "## Esempio\n" @@ -5028,11 +5647,13 @@ msgstr "" "`have h2 : succ a = succ b → a = b := succ_inj a b`\n" "\n" "aggiungerà direttamente l'ipotesi `h2 : succ a = succ b → a = b`\n" -"al contesto, dato che hai fornito assieme la sua dimostrazione (`succ_inj a b`).\n" +"al contesto, dato che hai fornito assieme la sua dimostrazione (`succ_inj a " +"b`).\n" "\n" "## Esempio\n" "\n" -"Se hai in mano una dimostrazione, puoi omettere il lemma che vuoi introdurre (quello tra i simboli `:` e `:=`).\n" +"Se hai in mano una dimostrazione, puoi omettere il lemma che vuoi introdurre " +"(quello tra i simboli `:` e `:=`).\n" "Ad esempio:\n" "\n" "`have h2 := succ_inj a b`\n" @@ -5045,14 +5666,18 @@ msgstr "`mul_right_eq_one a b` è la dimostrazione che `a * b = 1 → a = 1`." #: 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" +"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 "" -"Questo livello dimostra `x * y = 1 → x = 1`, l'analogo moltiplicativo del lemma `x + y = 0 → x = 0`\n" -"incontrato del Mondo Addizione Avanzata. La strategia è dimostrare prima che `x ≤ 1` e poi usare il\n" +"Questo livello dimostra `x * y = 1 → x = 1`, l'analogo moltiplicativo del " +"lemma `x + y = 0 → x = 0`\n" +"incontrato del Mondo Addizione Avanzata. La strategia è dimostrare prima che " +"`x ≤ 1` e poi usare il\n" "lemma `le_one` del Mondo `≤`.\n" "\n" "Lo dimostreremo con una nuova tattica assai utile, `have`." @@ -5060,13 +5685,16 @@ msgstr "" #: 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" +"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 "" -"Il piano è applicare `le_mul_right`, ma per farlo abbiamo bisogno dell'ipotesi `x * y ≠ 0`\n" -"che non è presente tra le ipotesi, per ora. Esegui `have h2 : x * y ≠ 0` (digita `≠` tramite `\\ne`).\n" +"Il piano è applicare `le_mul_right`, ma per farlo abbiamo bisogno " +"dell'ipotesi `x * y ≠ 0`\n" +"che non è presente tra le ipotesi, per ora. Esegui `have h2 : x * y ≠ 0` " +"(digita `≠` tramite `\\ne`).\n" "Lean ti chiederà di\n" "dimostrarlo, e dopo avrai un'ipotesi nuova di zecca a cui puoi applicare\n" "`le_mul_right`." @@ -5076,7 +5704,8 @@ msgid "Now you can `apply le_mul_right at h2`." msgstr "Ora puoi eseguire `apply le_mul_right at h2`." #: Game.Levels.AdvMultiplication.L06mul_right_eq_one -msgid "Now `rw [h] at h2` so you can `apply le_one at hx`." +#, fuzzy +msgid "Now `rw [«{h}»] at «{h2}»` so you can `apply le_one at «{h2}»`." msgstr "Adesso `rw [h] at h2` così puoi fare `apply le_one at hx`." #: Game.Levels.AdvMultiplication.L06mul_right_eq_one @@ -5096,17 +5725,23 @@ msgid "mul_ne_zero" msgstr "mul_ne_zero" #: Game.Levels.AdvMultiplication.L07mul_ne_zero -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` è la dimostrazione che se `a ≠ 0` e `b ≠ 0` allora `a * b ≠ 0`." +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` è la dimostrazione che se `a ≠ 0` e `b ≠ 0` allora `a * b " +"≠ 0`." #: Game.Levels.AdvMultiplication.L07mul_ne_zero msgid "" -"This level proves that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`. One strategy\n" +"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 "" -"Questo livello dimostra che se `a ≠ 0` e `b ≠ 0` allora `a * b ≠ 0`. Una strategia vincente\n" -"è riscrivere sia `a` che `b` come `succ` di qualcosa, dedurre che `a * b` è \n" +"Questo livello dimostra che se `a ≠ 0` e `b ≠ 0` allora `a * b ≠ 0`. Una " +"strategia vincente\n" +"è riscrivere sia `a` che `b` come `succ` di qualcosa, dedurre che `a * b` " +"è \n" "anche lui `succ` di qualcosa, e infine fare `apply zero_ne_succ`." #: Game.Levels.AdvMultiplication.L07mul_ne_zero @@ -5118,8 +5753,11 @@ msgid "mul_eq_zero" msgstr "mul_eq_zero" #: 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` è la dimostrazione che se `a * b = 0` allora `a = 0` or `b = 0`." +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` è la dimostrazione che se `a * b = 0` allora `a = 0` or `b " +"= 0`." #: Game.Levels.AdvMultiplication.L08mul_eq_zero msgid "" @@ -5127,7 +5765,8 @@ msgid "" "logically equivalent to the last level, so there is a very short proof." msgstr "" "Questo livello dimostra che se `a * b = 0` allora `a = 0` or `b = 0`. È\n" -"logicamente equivalente allo scorso livello, quindi puoi dare una dimostrazione veramente corta." +"logicamente equivalente allo scorso livello, quindi puoi dare una " +"dimostrazione veramente corta." #: Game.Levels.AdvMultiplication.L08mul_eq_zero msgid "Start with `have h2 := mul_ne_zero a b`." @@ -5138,48 +5777,77 @@ msgid "" "Now the goal can be deduced from `h2` by pure logic, so use the `tauto`\n" "tactic." msgstr "" -"Adesso il goal può essere dedotto da `h2` tramite pura logica, dunque usa la tattica\n" +"Adesso il goal può essere dedotto da `h2` tramite pura logica, dunque usa la " +"tattica\n" "`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 "" + #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "mul_left_cancel" msgstr "mul_left_cancel" #: Game.Levels.AdvMultiplication.L09mul_left_cancel -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` è la dimostrazione che se `a ≠ 0` e `a * b = a * c` allora `b = c`." +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` è la dimostrazione che se `a ≠ 0` e `a * b = a * c` " +"allora `b = c`." #: Game.Levels.AdvMultiplication.L09mul_left_cancel +#, fuzzy msgid "" -"In this level we prove that if `a * b = a * c` and `a ≠ 0` then `b = c`. It is tricky, for\n" +"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" +"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`.\"" +"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 "" -"In questo livello dimostriamo se `a * b = a * c` e `a ≠ 0` allora `b = c`. È un pò complicato, per\n" +"In questo livello dimostriamo se `a * b = a * c` e `a ≠ 0` allora `b = c`. È " +"un pò complicato, per\n" "diverse ragioni. Una di queste è che\n" "abbiamo bisogno di introdurre una nuova idea, approfondendo la nozione di\n" "induzione matematica.\n" "\n" -"Sarebbe ingenuo partire con `induction b with d hd`, perché nel passo induttivo\n" -"l'ipotesi è `a * d = a * c → d = c` ma quello che sappiamo è solo che `a * succ d = a * c`,\n" +"Sarebbe ingenuo partire con `induction b with d hd`, perché nel passo " +"induttivo\n" +"l'ipotesi è `a * d = a * c → d = c` ma quello che sappiamo è solo che `a * " +"succ d = a * c`,\n" "dunque non possiamo applicare l'ipotesi ipotesi induttiva!\n" "\n" -"Supponiamo di fissare la variabile `a ≠ 0`. Il vero enunciato che vogliamo dimostrare per induzione su `b` è\n" -"\"per tutte le `c`, se `a * b = a * c` allora `b = c`\". Questo *può* essere dimostrato per induzione,\n" +"Supponiamo di fissare la variabile `a ≠ 0`. Il vero enunciato che vogliamo " +"dimostrare per induzione su `b` è\n" +"\"per tutte le `c`, se `a * b = a * c` allora `b = c`\". Questo *può* essere " +"dimostrato per induzione,\n" "perché abbiamo permesso alla `c` di variare." #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "The way to start this proof is `induction b with d hd generalizing c`." -msgstr "Il modo giusto di aprire questa dimostrazione è `induction b with d hd generalizing c`." +msgstr "" +"Il modo giusto di aprire questa dimostrazione è `induction b with d hd " +"generalizing c`." #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "" @@ -5191,23 +5859,31 @@ msgstr "" #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "" -"The inductive hypothesis `hd` is \"For all natural numbers `c`, `a * d = a * c → d = c`\".\n" +"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 "" -"L'ipotesi induttiva `hd` è \"Per tutti i numeri naturali `c`, `a * d = a * c → d = c`\".\n" +"L'ipotesi induttiva `hd` è \"Per tutti i numeri naturali `c`, `a * d = a * c " +"→ d = c`\".\n" "Puoi sfruttarla con `apply` e `at` su un'ipotesi della forma `a * d = a * ?`." #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "Split into cases `c = 0` and `c = succ e` with `cases c with e`." -msgstr "Suddividi la dimostrazione nei casi `c = 0` e `c = succ e` con `cases c with e`." +msgstr "" +"Suddividi la dimostrazione nei casi `c = 0` e `c = succ e` con `cases c with " +"e`." #: Game.Levels.AdvMultiplication.L10mul_right_eq_self msgid "mul_right_eq_self" msgstr "mul_right_eq_self" #: 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` è la dimostrazione che se `a ≠ 0` e `a * b = a` allora `b = 1`." +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` è la dimostrazione che se `a ≠ 0` e `a * b = a` " +"allora `b = 1`." #: Game.Levels.AdvMultiplication.L10mul_right_eq_self msgid "" @@ -5234,7 +5910,8 @@ msgid "" "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." +"We now have all the tools necessary to set up the basic theory of " +"divisibility of naturals." msgstr "" "Una dimostrazione di due righe è la seguente\n" "\n" @@ -5243,7 +5920,8 @@ msgstr "" "exact mul_left_cancel a b 1 ha h\n" "```\n" "\n" -"Ora abbiamo tutti gli strumenti necessari per costruire la teoria basilare della divisibilità dei numeri naturali." +"Ora abbiamo tutti gli strumenti necessari per costruire la teoria basilare " +"della divisibilità dei numeri naturali." #: Game.Levels.AdvMultiplication msgid "Advanced Multiplication World" @@ -5257,7 +5935,8 @@ msgid "" "\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" +"`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" @@ -5268,16 +5947,22 @@ msgid "" msgstr "" "Nel Mondo *Addizione* Avanzata abbiamo dimostrato varie implicazioni\n" "sull'addizione, ad esempio `x + y = 0 → x = 0` e `x + y = x → y = 0`.\n" -"In seguito abbiamo usato questi lemmi per dimostrare fatti basilari su ≤ nel Mondo ≤.\n" +"In seguito abbiamo usato questi lemmi per dimostrare fatti basilari su ≤ nel " +"Mondo ≤.\n" "\n" "Nel Mondo Moltiplicazione Avanzata dimostreremo dei fatti\n" "analoghi sulla moltiplicazione, ad esempio `x * y = 1 → x = 1`, e\n" -"`x * y = x → y = 1` (assumendo che `x ≠ 0` nel secondo enunciato). Questi saranno propedeutici\n" +"`x * y = x → y = 1` (assumendo che `x ≠ 0` nel secondo enunciato). Questi " +"saranno propedeutici\n" "per il Mondo Divisibilità.\n" "\n" -"Il Mondo Moltiplicazione è più complesso del Mondo Addizione. Allo stesso modo,\n" -"il Mondo Moltiplicazione Avanzata è più complesso del Mondo Addizione Avanzata.\n" -"La maggiore complessità di questo mondo è dovuta al fatto che certi teoremi valgono a condizione che una delle variabili non possa assumere il valore zero (sia non-nulla).\n" +"Il Mondo Moltiplicazione è più complesso del Mondo Addizione. Allo stesso " +"modo,\n" +"il Mondo Moltiplicazione Avanzata è più complesso del Mondo Addizione " +"Avanzata.\n" +"La maggiore complessità di questo mondo è dovuta al fatto che certi teoremi " +"valgono a condizione che una delle variabili non possa assumere il valore " +"zero (sia non-nulla).\n" "Questo ulteriore vincolo ha dei risvolti inaspettati." #: Game @@ -5285,6 +5970,7 @@ msgid "Natural Number Game" msgstr "Il Gioco dei Numeri Naturali" #: Game +#, fuzzy msgid "" "# Welcome to the Natural Number Game\n" "#### An introduction to mathematical proof.\n" @@ -5304,14 +5990,17 @@ msgid "" "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. A new version\n" -"of Advanced Multiplication World is in preparation, and worlds\n" -"such as Prime Number World and more will be appearing during October and\n" -"November 2023.\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" +"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 "" "# Benvenuto nel Gioco dei Numeri Naturali!\n" @@ -5321,39 +6010,45 @@ msgstr "" "`{0,1,2,3,4,...}` a partire da zero. Il nostro primo obiettivo è dimostrare\n" "`2 + 2 = 4`. Dopodiché dimostreremo `x + y = y + x`.\n" "Infine cercheremo di dimostrare l'Ultimo Teorema di Fermat.\n" -"Risolveremo questi puzzle matematici in un ambiente interattivo chiamato Lean.\n" +"Risolveremo questi puzzle matematici in un ambiente interattivo chiamato " +"Lean.\n" "\n" "# Leggi le istruzioni!\n" "\n" "Imparare a usare un *interactive theorem prover* richiede tempo e impegno.\n" -"Le statistiche mostrano che le persone che imparano di più da questo gioco sono\n" +"Le statistiche mostrano che le persone che imparano di più da questo gioco " +"sono\n" "coloro che leggono attentamente il testo delle istruzioni, come questo.\n" "\n" "Per iniziare, clicca su \"Mondo Tutorial\".\n" "\n" "Nota: questa è la versione del gioco per Lean 4 contenente diversi\n" -"mondi che non erano presenti nella versione per Lean 3. Stiamo lavorando a una\n" +"mondi che non erano presenti nella versione per Lean 3. Stiamo lavorando a " +"una\n" "nuova versione del Mondo Moltiplicazione Avanzata e nuovi mondi\n" "tra cui Mondo Numeri Primi arriveranno durante Ottobre e\n" "Novembre 2023.\n" "\n" "## Altro\n" "\n" -"Clicca sulle tree lineette in alto a destra e seleziona \"Game Info\" per risorse,\n" +"Clicca sulle tree lineette in alto a destra e seleziona \"Game Info\" per " +"risorse,\n" "link utili e vari modi per connetterti alla comunità di Lean." #: Game +#, fuzzy msgid "" -"*Game version: 4.2*\n" +"*Game version: 4.3*\n" "\n" -"*Recent additions: Inequality world, algorithm world*\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" +"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" @@ -5369,7 +6064,8 @@ msgid "" "## 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" +"* [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/" +"natural_number_game/) (no longer maintained)\n" "\n" "## Problems?\n" "\n" @@ -5379,12 +6075,15 @@ msgid "" "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" +"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" +"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" +"[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 "" @@ -5395,10 +6094,13 @@ msgstr "" "## Salvataggio del gioco\n" "\n" "Il gioco salva il tuo progresso nella memoria locale del browser.\n" -"Se cancelli la memoria, perderai anche i dati del gioco! (le tue preziose dimostrazioni!)\n" +"Se cancelli la memoria, perderai anche i dati del gioco! (le tue preziose " +"dimostrazioni!)\n" "\n" -"Attenzione: nella maggior parte dei browser, cancellare i cookies cancella anche la memoria di un sito\n" -"(o \"i dati locali del sito\"). In ogni caso, assicurati di esportare il tuo progresso del gioco!\n" +"Attenzione: nella maggior parte dei browser, cancellare i cookies cancella " +"anche la memoria di un sito\n" +"(o \"i dati locali del sito\"). In ogni caso, assicurati di esportare il tuo " +"progresso del gioco!\n" "\n" "## Riconoscimenti\n" "\n" @@ -5407,29 +6109,37 @@ msgstr "" "* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" "* **Livelli extra:** Sian Carey, Ivan Farabella, Archie Browne.\n" "* **Traduzione italiana**: Federico Dal Pio Luogo\n" -"* **Grazie anche a:** Gli studenti che si sono offerti come beta testers, tutte le scuole\n" -"che hanno invitato Kevin a parlare, e gli studenti che gli hanno fatto domande\n" +"* **Grazie anche a:** Gli studenti che si sono offerti come beta testers, " +"tutte le scuole\n" +"che hanno invitato Kevin a parlare, e gli studenti che gli hanno fatto " +"domande\n" "sul materiale.\n" "\n" "## Risorse\n" "\n" "* La [chat di Lean su Zulip](https://leanprover.zulipchat.com/)\n" -"* Il [gioco originale per Lean3](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/) (no longer maintained)\n" +"* Il [gioco originale per Lean3](https://www.ma.imperial.ac.uk/~buzzard/xena/" +"natural_number_game/) (no longer maintained)\n" "\n" "## Problemi?\n" "\n" "Rivolgi le tue domande sul gioco nella\n" "[chat di Lean su Zulip](https://leanprover.zulipchat.com/), utilizzando\n" -"lo stream \"New Members\". I membri della comunità sono felici di aiutare. Nota che\n" +"lo stream \"New Members\". I membri della comunità sono felici di aiutare. " +"Nota che\n" "la chat di Lean su Zulip è un forum professionale di ricerca.\n" -"Perciò usa il tuo nome reale e per intero, rimani in tema, e sii cortese. Se cerchi\n" +"Perciò usa il tuo nome reale e per intero, rimani in tema, e sii cortese. Se " +"cerchi\n" "un forum più informale (dove puoi ad esempio postare\n" -"i meme sui numeri naturali) allora il [server Discord di Lean](https://discord.gg/WZ9bs9UCvx) fa per te.\n" +"i meme sui numeri naturali) allora il [server Discord di Lean](https://" +"discord.gg/WZ9bs9UCvx) fa per te.\n" "\n" -"In alternativa, se il gioco funziona male o dovessi trovare un bug puoi aprire una issue su github:\n" +"In alternativa, se il gioco funziona male o dovessi trovare un bug puoi " +"aprire una issue su github:\n" "\n" "* Per problemi relativi al game engine, apri una\n" -"[issue sul repo lean4game](https://github.com/leanprover-community/lean4game/issues).\n" +"[issue sul repo lean4game](https://github.com/leanprover-community/lean4game/" +"issues).\n" "* Per problemi relativi ai contenuti del the gioco, apri una\n" "[issue sul repo NNG](https://github.com/hhu-adam/NNG4/issues)." @@ -5439,12 +6149,14 @@ msgstr "Il classico gioco introduttivo per Lean." #: Game msgid "" -"In this game you recreate the natural numbers $\\mathbb{N}$ from the Peano axioms,\n" +"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 "" -"In questo gioco ricreerai l'insieme dei numeri naturali $\\mathbb{N}$ partendo dagli assiomi di Peano,\n" +"In questo gioco ricreerai l'insieme dei numeri naturali $\\mathbb{N}$ " +"partendo dagli assiomi di Peano,\n" "e lungo il percorso imparerai le basi del *theorem proving* su Lean.\n" "\n" "Questo gioco è un'ottima introduzione a Lean!" diff --git a/.i18n/zh/Game.json b/.i18n/zh/Game.json index dff47b0..d7299f1 100644 --- a/.i18n/zh/Game.json +++ b/.i18n/zh/Game.json @@ -217,7 +217,7 @@ "`a ≤ b` 是 `∃ c, b = a + c` 的*符号表示*。这个“倒 E”代表“存在”。所以 `a ≤ b` 意味着存在一个数字 `c` 使得 `b = a + c`。这个定义有效是因为在这个游戏中没有负数。\n\n要*证明*一个“存在性”定理，可以使用 `use` 策略。\n让我们看一个例子。", "`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` 的目标，你可以用 `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 use 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` 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`\n 与 `P` 的逻辑相反。确实 `True → False` 是假的，\n `False → False` 是真的！\n\n 这样做的结果是我们可以用处理任何 `P → Q` 的方式处理 `a ≠ b`。例如，\n 如果 *目标* 的形式为 `a ≠ b` 那么您可以用 `intro h`取得进展；\n 如果你有一个假设 `h : a ≠ b` 那么你可以 `apply h at h1` 如果 `h1` 是\n `a = b`的假设。", "`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`。", @@ -330,6 +330,8 @@ "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仅用这些定理，你能通过最后的boss关卡吗？\n\n这个世界中的关卡由帝国理工学院的 UROP 学生 Sian Carey 在 2019 年夏天设计，她的项目得到了 Mary Lister McCammon 奖学金的资助。感谢 Sian，也感谢帝国理工学院对她的资助。", "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 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`.": "这个关卡要证明如果 `a ≠ 0` 且 `b ≠ 0`，那么 `a * b ≠ 0`。\n一种策略是将 `a` 和 `b` 都写成某物的 `succ`（后继），推断出 `a * b` 也是某物的 `succ`，然后应用 `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.": @@ -352,9 +354,9 @@ "The previous lemma can be used to prove this one.": "先前的引理可以用来证明这个引理。", "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.": "在这一关中，让我们证明其中一个事实，而在下一关证明另一个。\n\n## 一种新的策略：`cases`\n\n`cases` 策略会将一个对象或假设分解为可能的创建方式。\n\n例如，有时你想分别处理 `b = 0` 和 `b = succ d` 这两种情况，但不需要与 `induction b with d hd` 一起来的归纳假设 `hd`。在这种情况下，你可以使用 `cases b with d`。制造一个数字有两种方式：它要么是零，要么是后继者。所以你最终会得到两个目标，一个是 `b = 0`，另一个是 `b = succ d`。\n\n另一个例子：如果你有一个假设 `h : False`，那么你就完成证明了，因为从 `False` 可以推出任何证明。这里 `cases h` 将证明目标，因为没有 *任何* 方法可以证明 `False`！所以你最终会没有目标，意味着你已经证明了一切。", - "The music gets ever more dramatic, as we explore\nthe interplay between exponentiation and multiplication.\n\nIf you're having trouble exchanging the right `x * y`\nbecause `rw [mul_comm]` swaps the wrong multiplication,\nthen read the documentation of `rw` for tips on how to fix this.": + "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\n如果您在更换正确的 `x * y` 时遇到问题\n因为 `rw [mul_comm]` 交换了错误的乘法，\n然后阅读 `rw` 的文档以获取有关如何解决此问题的提示。", - "The music dies down. Is that it?\n\nCourse it isn't, you can\nclearly see that there are two worlds 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.": + "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突然，音乐再次响起。这真的是最终的Boss。", "The lemma proved in the final level of this world will be helpful\nin Divisibility World.": "在这个世界的最后一个关卡证明的引理将在可除性世界中很有帮助。", @@ -385,7 +387,7 @@ "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 m` and a goal of `m = n`.": + "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` 开始，将目标转变为其逆否命题，即假设为 `succ m = succ m`，目标为 `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`.": @@ -428,6 +430,8 @@ "我们的第一个挑战是`mul_comm x y : x * y = y * x`，\n我们想通过归纳法来证明这一点。在证明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?": "游戏中最名副其实的关卡之一。\n随着音乐达到狂热，一个凶猛的 `pow_pow` 小boss出现了。\n在这之后，还有什么关于幂的性质需要证明呢？", + "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$ 这样的情况。\n我们将通过证明 $2$ 的任何因数最多是 $2$ 来做到这一点，我们将使用这个引理来实现。\n我脑海中的证明会操作假设，直到它变成目标，几乎使用我们到目前为止在这个世界中已经证明的所有内容。", "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$.": "在自然数集上，加法是可交换的。\n换句话说，如果 `a` 和 `b` 是任意自然数，那么\n$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). $": @@ -468,14 +472,14 @@ "现在 `«{ha}»` 是 `«{y}» = «{x}» + «{a}»`, 的证明，而 `hxy` 已经消失了。同样，你可以通过 `cases «{hyz}» with b hb` 将 `«{hyz}»` 分解。", "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 hx`。", "Now `rw [h]` then `rfl` works, but `exact h` is quicker.": "现在 `rw [h]` 和 `rfl` 可以完成证明，但 `exact h` 更快。", - "Now `rw [h] at h2` so you can `apply le_one at hx`.": - "现在`rw [h] at h2`，这样就可以`apply le_one at hx`。", "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 `succ x = succ y`.": + "Now `repeat rw [← succ_eq_add_one] at h` is the quickest way to\nchange `h` to `succ x = succ y`.": "现在 `repeat rw [← succ_eq_add_one] at h` 是改写 `succ x = succ y` 的最快方法。", "Now `exact h` finishes the job.": "现在，用 `exact h ` 完成证明。", "Now `cases «{h2}» with e he`.": "现在使用 `cases «{h2}» with e he`。", @@ -501,7 +505,7 @@ "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 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.": + "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.": "乘法通常会使一个数字变大，但是乘以零可以使它变小。因此，关于不等式和乘法的许多引理需要假设 `a ≠ 0`。\n这里有一个关键的引理使我们能够使用这个假设。我们可以使用 `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$.": "乘法对左边的加法具有分配性。\n换句话说，对于所有自然数 $a$、$b$ 和 $c$，我们有\n$a(b + c) = ab + ac$。", @@ -542,7 +546,7 @@ "对 `a` 或 `b` 进行归纳证明 —— 它们都是相同的。", "Induction on `a` is the most troublesome, then `b`,\nand `c` is the easiest.": "对 `a` 的归纳最麻烦，然后是 `b`、\n而 `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.": + "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`.": "在这个世界中，我们将学习如何证明形式为 $P\\implies Q$ 的定理。\n换句话说，就是如何证明“如果 $P$ 为真，则 $Q$ 也为真”的形式的定理。\n为此，我们需要学习一些更多的策略。\n\n`exact` 策略可以用来解决一个存在于假设中的目标。", "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.": "在这个世界中，我们定义 `a ≤ b` 并证明关于它的一些事实，例如“如果 `a ≤ b` 且 `b ≤ c` 那么 `a ≤ c`。”\n\n`a ≤ b` 的定义是“存在一个数字 `c` 使得 `b = a + c`。”所以我们将不得不学习一种策略来证明“存在”定理，以及另一种策略来使用“存在”假设。\n\n点击“开始”继续。", @@ -550,14 +554,14 @@ "在这个世界中，探险将主要由您独自完成。\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.": "在本关，我们将不等视为 *假设* 。我们以前没有见过这个。\n`cases` 策略可用于拆解 `hxy` 假设。", + "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.)": "在这个关卡中，我们将证明 $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\n看看你是否能在 Lean 中完成你的第一个归纳证明。\n\n(顺便说一句，如果你还在上一个世界的 \"编辑器模式 \"下，你可以通过点击 \"编辑器模式 \"下的\n点击右上角的 `>_` 按钮换回 \"模式\"）。", - "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`.\"": + "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`.": "在这个关卡中，我们证明了如果 `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` 那么 `b = c`。这*可以*通过归纳来证明，因为我们现在有了改变 `c` 的灵活性。”", "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)$。现在我们有一条*假设* `h`，它指出 $y = x + 7$。请检查假设列表中是否包含了 `h`。在 Lean 中，`h` 被视为一种假设存在的证据，这有点像 `x` 是一个未知的具体数值。\n\n要想使用 `rfl` 完成证明，我们首先需要对 $y$ 进行替换。在 Lean 中，我们可以通过*重写*证明 `h` 来实现这一点，即使用 `rw` 策略。", - "In this level one of our hypotheses is an *implication*. We can use this\nhypothesis with the `apply` tactic.": - "在这个关卡中，我们的一个假设是一个*蕴含式*。我们可以使用 `apply` 策略来利用这个假设。", "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\n这是对 Lean 的一个很好的初步介绍！", "In the next level, we'll do the same proof but backwards.": @@ -570,8 +574,6 @@ "在一些后续的世界中，我们将看到一些更棘手的关卡，比如 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + b + 1)`。需要移动括号，还需要交换变量。\n\n在这个关卡中，`(a + b) + (c + d) = ((a + c) + d) + b`，让我们忘掉括号，只考虑变量的顺序。\n要将 `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\"，您可以在目标下的文本框中输入它，然后点击 \"执行\"。", - "In Prime Number World we will be 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 pretty much everything which we've proved in this world so far.": - "在质数世界中，我们将证明 $2$ 是质数。为此，我们必须排除像 $2 ≠ 37 × 42$ 这样的情况。\n我们将通过证明 $2$ 的任何因数最多是 $2$ 来做到这一点，我们将使用这个引理来实现。\n我脑海中的证明会操作假设，直到它变成目标，几乎使用我们到目前为止在这个世界中已经证明的所有内容。", "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.": "在高级加法世界中，我们将证明一些基本的加法事实，如 $x+y=x\\implies y=0$。在这个世界中证明的定理将被用来在 `≤` 世界中构建不等式理论。\n\n点击“开始”继续。", "Implication World": "蕴含世界", @@ -637,6 +639,8 @@ "这个证明怎么样：\n\n```\nrw [add_comm]\nexact add_right_eq_zero b a\n```\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.": + "", "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```": @@ -657,7 +661,7 @@ "这是两行的证明：\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(the dots in the proof just indicate the two goals and\ncan be omitted):\n\n```\n induction x with d hd\n · intro h\n rw [zero_add] at h\n assumption\n · intro h\n rw [succ_add] at h\n apply succ_inj at h\n apply hd at h\n assumption\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可以省略）：\n\n```\n induction x with d hd\n · intro h\n rw [zero_add] at h\n assumption\n · intro h\n rw [succ_add] at h\n apply succ_inj at h\n apply hd at h\n assumption\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```", @@ -715,7 +719,7 @@ "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`的两行证明。如果你想查看它，你可以通过点击右上角的 `` 进入编辑器模式，然后只需剪切和粘贴证明，并在其周围移动你的光标，以查看在任何给定点的假设和目标（尽管这样做你会失去自己的证明）。点击 `>_` 返回命令行模式。\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.": + "Congratulations! You've finished Algorithm World. These algorithms\nwill be helpful for you in Even-Odd World (when someone gets around to\nimplementing it).": "恭喜！您已经完成了《算法世界》。这些算法\n将对您在奇偶世界中有所帮助。", "Congratulations! You have proved Fermat's Last Theorem!\n\nEither that, or you used magic...": "恭喜！您已经证明了费马大定理！\n\n要么就是，要么你使用了魔法……", @@ -771,7 +775,7 @@ "2 + 2 ≠ 5": "2 + 2 ≠ 5", "1 ≠ 0": "1 ≠ 0", "0 ≤ x": "0 ≤ x", - "*Game version: 4.2*\n\n*Recent additions: Inequality world, algorithm world*\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.2*\n\n*最近新增：不等式世界，算法世界*\n\n## 进度保存\n\n游戏会将你的进度存储在本地浏览器存储中。\n如果你删除它，你的进度将会丢失！\n\n警告：在大多数浏览器中，删除 cookie 也会清除本地存储（或“本地网站数据”）。确保首先下载你的游戏进度！\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 聊天](https://leanprover.zulipchat.com/) 论坛\n* [原始 Lean3 版本](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/)（不再维护）\n\n## 有问题吗？\n\n请在 [Lean Zulip 聊天](https://leanprover.zulipchat.com/) 论坛提出关于这个游戏的任何问题，例如在 “新成员” 流中。社区会乐意帮忙。请注意，Lean Zulip 聊天是一个专业研究论坛。请使用您的全名，保持话题相关，且友好。如果你正在寻找一个不那么正式的地方（例如，你想发布自然数游戏的表情包），那么可以前往 [Lean Discord](https://discord.gg/WZ9bs9UCvx)。\n\n另外，如果你遇到问题/漏洞，你也可以在 github 上提出问题：\n\n* 对于游戏引擎的问题，请在 [lean4game](https://github.com/leanprover-community/lean4game/issues) 仓库提出问题。\n* 对于游戏内容的问题，请在 [NNG](https://github.com/hhu-adam/NNG4/issues) 仓库提出问题。", "$x=37\\implies x=37$.": "$x=37\\implies x=37$ 。", "$x+y=x\\implies y=0$.": "$x+y=x\\implies y=0$.", @@ -797,7 +801,7 @@ "## 小结\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`。", "## 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` 会重复应用策略 `t` 到目标上。你不一定要使用这个策略，它有时只是加快了速度。\n\n## 示例\n\n`repeat rw [add_zero]` 会将目标 `a + 0 + (0 + (0 + 0)) = b + 0 + 0` 转变为目标 `a = b`。", - "## 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`.": + "## 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` 存在并具有某些属性，并且您知道\n`x = 37` 将起作用，那么使用 `use 37` 来改写目标。\n\n因为 `a ≤ b` 是用 “存在 `c` 使得 `b = a + c`” 定义的，\n所以可以通过`use (b - a)` 在 `a ≤ b` 形式的目标上取得进展。", "## 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` 策略会将形如 `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`。", @@ -811,13 +815,13 @@ "## 概述\n\n如果 `n` 是一个数字，那么 `cases n with d` 会将目标分解成两个目标，一个是 `n = 0`，另一个是 `n = succ d`。\n\n如果 `h` 是一个证明（例如一个假设），那么 `cases h with...` 会将证明分解成用来证明它的各个部分。\n\n## 示例\n\n如果 `n : ℕ` 是一个数字，那么 `cases n with d` 会将目标分解成两个目标，一个是 `n` 被替换为 0，另一个是 `n` 被替换为 `succ d`。这对应于数学上的观点，即每个自然数要么是 `0`，要么是一个后继数。\n\n## 示例\n\n如果 `h : P ∨ Q` 是一个假设，那么 `cases h with hp hq` 会将一个目标变成两个目标，一个有假设 `hp : P`，另一个有假设 `hq : Q`。\n\n## 示例\n\n如果 `h : False` 是一个假设，那么 `cases h` 会将一个目标变成没有目标，因为没有方法可以证明 `False`！如果你没有剩余的目标，你就完成了这个关卡。\n\n## 示例\n\n如果 `h : a ≤ b` 是一个假设，那么 `cases h with c hc` 会创建一个新的数字 `c` 和一个证明 `hc : b = a + c`。这是因为 `a ≤ b` 的*定义*是 `∃ 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 : ℕ` 是一个对象，并且目标提到了 `n`，那么 `induction n with d hd`\n尝试通过对 `n` 进行归纳来证明目标，其中后继数情况下的归纳变量是 `d`，归纳假设是 `hd`。\n\n### 例子:\n如果目标是\n```\n0 + n = n\n```\n\n那么\n\n`induction n with d hd`\n\n将把它变成两个目标。第一个是 `0 + 0 = 0`；\n第二个有一个假设 `hd : 0 + d = d` 和目标\n`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## Targetted 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## Targetted 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]`.": "## 概述\n\n如果 `h` 是一个等式 `X = Y` 的证明，那么 `rw [h]` 将会把目标中所有的 `X` 改为 `Y`。这是一种“代入”的方式。\n\n## 变体\n\n* `rw [← h]`（将 `Y` 改为 `X`；通过输入 `\\left ` 或 `\\l` 获取反向箭头。）\n\n* `rw [h1, h2]`（一系列重写）\n\n* `rw [h] at h2`（在假设 `h2` 中将 `X` 改为 `Y`）\n\n* `rw [h] at h1 h2 ⊢`（在两个假设和目标中将 `X` 改为 `Y`；通过输入 `\\|-` 获取 `⊢` 符号。）\n\n* `repeat rw [add_zero]` 将会不断地把 `? + 0` 改为 `?`，直到没有更多的 `? + 0` 匹配为止。\n\n* `nth_rewrite 2 [h]` 只会把目标中的第二个 `X` 改为 `Y`。\n\n### 示例：\n\n如果你有假设 `h : x = y + y` 并且你的目标是\n```\nsucc (x + 0) = succ (y + y)\n```\n\n那么\n\n`rw [add_zero]`\n\n将会把目标改为 `succ x = succ (y + y)`，然后\n\n`rw [h]`\n\n将会把目标改为 `succ (y + y) = succ (y + y)`，这个可以通过 `rfl` 解决。\n\n### 示例：\n\n你也可以使用 `rw` 来改变一个假设。例如，如果你有两个假设\n```\nh1 : x = y + 3\nh2 : 2 * y = x\n```\n那么 `rw [h1] at h2` 将会把 `h2` 变为 `h2 : 2 * y = y + 3`。\n\n## 常见错误\n\n* 你需要方括号。`rw h` 是不正确的。\n\n* 如果 `h` 不是一个*等式*的*证明*（形式为 `A = B` 的声明），例如如果 `h` 是一个函数或蕴含，那么 `rw` 不是你想要使用的策略。例如，`rw [P = Q]` 永远不正确， 因为`P = Q` 是定理的*陈述*，而不是证明。但如果 `h : P = Q` 是证明，那么 `rw [h]` 将会起作用。\n\n## 详情\n\n`rw` 策略是一种进行“代入”的方式。有两种不同的情况你可以使用这个策略。\n\n1) 基本使用：如果 `h : A = B` 是一个假设或定理的证明，并且目标中包含一个或多个 `A`，那么 `rw [h]` 会把它们全部改为 `B`。如果目标中没有 `A`，策略会报错。\n\n2) 高级使用：来自定理证明的假设经常有缺失的部分。例如 `add_zero` 是一个证明，表示 `? + 0 = ?`，因为 `add_zero` 实际上是一个函数，而 `?` 是输入。在这种情况下，`rw` 会在目标中查找任何形式为 `x + 0` 的子项，一旦找到，它就将 `?` 定位为 `x`，然后把所有的 `x + 0` 改为 `x`。\n\n练习：思考为什么 `rw [add_zero]` 会把项 `(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` 改为 `0 + (x + 0) + 0 + (x + 0)`\n\n如果你不能记住等式证明的名称，请在右侧的定理列表中查找。\n\n## 针对性使用\n\n如果你的目标是 `b + c + a = b + (a + c)` 并且你想把 `a + c` 重写为 `c + a`，那么 `rw [add_comm]` 将不起作用，因为 Lean 会先找到另一个加法并交换它。使用 `rw [add_comm a c]` 来保证 Lean 将 `a + c` 重写为 `c + a`。这是因为 `add_comm` 是一个证明，表示 `?1 + ?2 = ?2 + ?1`，`add_comm a` 是一个证明，表示 `a + ? = ? + a`，而 `add_comm a c` 是另一个证明，表示 `a + c = c + a`。\n\n如果 `h : X = Y`，那么 `rw [h]` 将会把所有的 `X` 变为 `Y`。如果你只想改变第37次出现的 `X` 为 `Y`，那么可以使用 `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` 并且在目标中有多个 `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.": "## 精准重写\n\n在上一个关卡中，有 `b + 0` 和 `c + 0`，\n而 `rw [add_zero]` 改变了它看到的第一个加0，\n也就是 `b + 0`。让我们学习如何告诉 Lean\n通过给 `add_zero` 一个明确的输入来首先改变 `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. A new version\nof Advanced Multiplication World is in preparation, and worlds\nsuch as Prime Number World and more will be appearing during October and\nNovember 2023.\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.": + "# 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`。\n最终，我们将尝试证明费马大定理。\n请通过完成本游戏中的关卡来完成这些挑战。\n\n## 阅读提示\n\n掌握交互式定理证明工具需要花费时间。\n经过测试发现，那些阅读了本帮助指南的玩家能够更好地享受本游戏并从中受益。\n\n开始游戏，请点击“教程世界”。\n\n请注意：这是基于全新 Lean 4 开发的游戏版本，新增了许多旧版 Lean 3 中未包含的世界。高级乘法世界的新版本正在开发中，其他新世界如素数世界等将于2023年10月至11月陆续推出。\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` 策略将 `P ∨ Q` 的目标更改为 `Q` 的目标。\n当您的假设`Q` 为真是 `P ∨ Q`为真的原因时使用它。\n\n在策略内部，它只是 `apply` （应用） 了 $Q \\implies P \\lor Q$ 这个定理\n\n请注意，这种策略可以将可解决的目标变成无法解决的目标。", @@ -827,9 +831,9 @@ "## 概述\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` 可以找到一种算法来解决目标，它将尝试解决该目标。\n\n### 示例\n\n类型为 `DecidableEq ℕ` 的项是用于判断两个自然数是否相等或不同的算法（的实现函数）。\n因此，一旦这个项被创建并成为一个 `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## 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 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.": + "# 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` 策略将解决任何只靠命题逻辑就可以解决的目标（即，通过真值表）。\n\n### 示例\n\n如果你有一个假设为 `False`，那么 `tauto` 将解决目标。这是因为一个假的假设意味着任何假设。\n\n### 示例\n\n如果你的目标是 `True`，那么 `tauto` 将解决目标。\n\n### 示例\n\n如果你有两个假设 `h1 : a = 37` 和 `h2 : a ≠ 37`，那么 `tauto` 将解决目标，因为它可以从你的假设中证明 `False`，从而证明目标（因为 `False` 意味着任何事情）。\n\n### 示例\n\n如果你有一个假设 `h : a ≠ a`，那么 `tauto` 将解决目标，因为 `tauto` 足够聪明以知道 `a = a` 是真的，这提供了我们寻求的矛盾。\n\n### 示例\n\n如果你有一个形式为 `a = 0 → a * b = 0` 的假设，而你的目标是 `a * b ≠ 0 → a ≠ 0`，那么 `tauto` 将解决目标，因为目标在逻辑上等同于假设。\n如果你在这个示例中交换目标和假设，`tauto` 也会解决它。\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如果你有一个形式为 `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. example\n\n`have h2 := succ_inj a b`\n\nwill add `h2 : succ a = succ b → a = b` as a hypothesis.": + "# 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` 策略可以用来向一个关卡添加新的假设，但当然，你必须证明它们。\n\n## 示例\n\n最简单的使用方式是这样的。如果你在你的上下文中有 `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将直接向上下文中添加一个新的假设 `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`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`。", diff --git a/.i18n/zh/Game.po b/.i18n/zh/Game.po index 9f1e228..a226110 100644 --- a/.i18n/zh/Game.po +++ b/.i18n/zh/Game.po @@ -4,7 +4,7 @@ msgid "" msgstr "" "Project-Id-Version: Game v4.6.0\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2024-04-11 11:25+0800\n" +"POT-Creation-Date: Thu Mar 20 00:18:32 2025\n" "PO-Revision-Date: \n" "Last-Translator: @JiechengZhao\n" "Language-Team: none\n" @@ -49,8 +49,10 @@ msgid "" "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" +"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" @@ -59,11 +61,15 @@ msgid "" "\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" +"*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).*" +"as mathematicians are concerned, and who cares what the definition of " +"addition is).*" msgstr "" "## 概述\n" "\n" @@ -81,8 +87,9 @@ msgstr "" "x + 37 = x + 37\n" "```\n" "\n" -"那么 `rfl` 将证明它。但如果它看起来像 `0 + x = x`，那么 `rfl` 将无法工作，因为即使 $0+x$ 和 $x$ 作为*" -"数字*总是相等，但它们作为*项*并不相等。唯一与 `0 + x` 相同的项是 `0 + x`。\n" +"那么 `rfl` 将证明它。但如果它看起来像 `0 + x = x`，那么 `rfl` 将无法工作，因" +"为即使 $0+x$ 和 $x$ 作为*数字*总是相等，但它们作为*项*并不相等。唯一与 `0 + " +"x` 相同的项是 `0 + x`。\n" "\n" "\n" "## 详细信息\n" @@ -91,42 +98,49 @@ msgstr "" "\n" "## 游戏实现\n" "\n" -"*请注意，出于教学目的，我们的 `rfl` 比核心 Lean 和 `mathlib` 中使用的版本弱一些；数学家不区分命题等价" -"和定义等价，因为他们以不同于类型理论家的方式思考定义（就数学家而言，`zero_add` 和 `add_zero` 都是 “事" -"实”，谁会在乎加法的定义是什么呢）。*\n" -"（译注：因为 `add_zero` 是加法定义的一部分，而定义等价是可以直接用 `rfl` 证明的。也就是说 `x + 0 = " -"x` 可以用 `rfl` 证明。所以作者多了一嘴，但实际上因为很少有人知道类型理论家怎么思考，所以这个注解看起" -"来会有些奇怪。）" +"*请注意，出于教学目的，我们的 `rfl` 比核心 Lean 和 `mathlib` 中使用的版本弱一" +"些；数学家不区分命题等价和定义等价，因为他们以不同于类型理论家的方式思考定义" +"（就数学家而言，`zero_add` 和 `add_zero` 都是 “事实”，谁会在乎加法的定义是什" +"么呢）。*\n" +"（译注：因为 `add_zero` 是加法定义的一部分，而定义等价是可以直接用 `rfl` 证明" +"的。也就是说 `x + 0 = x` 可以用 `rfl` 证明。所以作者多了一嘴，但实际上因为很" +"少有人知道类型理论家怎么思考，所以这个注解看起来会有些奇怪。）" #: 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" +"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" +"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" +"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" -"在这个游戏的每个关卡中，你都将挑战证明一个数学定理，这里称之为“目标”。这些目标主要与*自然数*相关。游" -"戏中，一些数具有明确的值，例如 $37$ 这类具体的数。然而，还有一些数是未知数，它们被称为 $x$、$q$ 等。" -"虽然我们不知道 $x$ 的具体值，但我们知道它代表一个自然数。\n" +"在这个游戏的每个关卡中，你都将挑战证明一个数学定理，这里称之为“目标”。这些目" +"标主要与*自然数*相关。游戏中，一些数具有明确的值，例如 $37$ 这类具体的数。然" +"而，还有一些数是未知数，它们被称为 $x$、$q$ 等。虽然我们不知道 $x$ 的具体值，" +"但我们知道它代表一个自然数。\n" "\n" -"在游戏的第一关，我们的任务是证明定理 $37x + q = 37x + q$。你将在下方的*对象*中看到 `x q : ℕ`，这表示 " -"`x` 和 `q` 都是自然数。\n" +"在游戏的第一关，我们的任务是证明定理 $37x + q = 37x + q$。你将在下方的*对象*" +"中看到 `x q : ℕ`，这表示 `x` 和 `q` 都是自然数。\n" "\n" -"为了在 Lean 中证明这些目标，我们将学习和使用各种*策略*。首先介绍的策略是 `rfl`，它用于证明所有形式为 " -"$X = X$ 的定理。\n" +"为了在 Lean 中证明这些目标，我们将学习和使用各种*策略*。首先介绍的策略是 " +"`rfl`，它用于证明所有形式为 $X = X$ 的定理。\n" "\n" "要证明 $37x+q=37x+q$，请使用 `rfl` 策略。" @@ -138,21 +152,23 @@ msgstr "如果 $x$ 和 $q$ 是任意自然数，那么 $37x+q=37x+q$ 。" 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\"，您可以在目标下的文本框中输入它，然后点击 \"执行\"。" +msgstr "" +"要使用策略 \"rfl\"，您可以在目标下的文本框中输入它，然后点击 \"执行\"。" #: 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" +"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` 是一种*策略*。如果你对 `rfl` 策略有更多的兴趣想要深入了解，可以尝试点击右侧策略列表中" -"的 `rfl` 查看详情。\n" +"请记得，`rfl` 是一种*策略*。如果你对 `rfl` 策略有更多的兴趣想要深入了解，可以" +"尝试点击右侧策略列表中的 `rfl` 查看详情。\n" "\n" "现在，请点击“下一关”，继续学习 `rw`（重写）策略。" @@ -161,6 +177,7 @@ msgid "the rw tactic" msgstr "rw 策略" #: Game.Levels.Tutorial.L02rw +#, fuzzy msgid "" "## Summary\n" "\n" @@ -169,7 +186,8 @@ msgid "" "\n" "## Variants\n" "\n" -"* `rw [← h]` (changes `Y`s to `X`s; get the back arrow by typing `\\left ` or `\\l`.)\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" @@ -215,7 +233,8 @@ msgid "" "\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" +"* 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" @@ -227,8 +246,9 @@ msgid "" "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" +"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" @@ -260,8 +280,8 @@ msgid "" msgstr "" "## 概述\n" "\n" -"如果 `h` 是一个等式 `X = Y` 的证明，那么 `rw [h]` 将会把目标中所有的 `X` 改为 `Y`。这是一种“代入”的方" -"式。\n" +"如果 `h` 是一个等式 `X = Y` 的证明，那么 `rw [h]` 将会把目标中所有的 `X` 改" +"为 `Y`。这是一种“代入”的方式。\n" "\n" "## 变体\n" "\n" @@ -271,9 +291,11 @@ msgstr "" "\n" "* `rw [h] at h2`（在假设 `h2` 中将 `X` 改为 `Y`）\n" "\n" -"* `rw [h] at h1 h2 ⊢`（在两个假设和目标中将 `X` 改为 `Y`；通过输入 `\\|-` 获取 `⊢` 符号。）\n" +"* `rw [h] at h1 h2 ⊢`（在两个假设和目标中将 `X` 改为 `Y`；通过输入 `\\|-` 获" +"取 `⊢` 符号。）\n" "\n" -"* `repeat rw [add_zero]` 将会不断地把 `? + 0` 改为 `?`，直到没有更多的 `? + 0` 匹配为止。\n" +"* `repeat rw [add_zero]` 将会不断地把 `? + 0` 改为 `?`，直到没有更多的 `? + " +"0` 匹配为止。\n" "\n" "* `nth_rewrite 2 [h]` 只会把目标中的第二个 `X` 改为 `Y`。\n" "\n" @@ -307,35 +329,39 @@ msgstr "" "\n" "* 你需要方括号。`rw h` 是不正确的。\n" "\n" -"* 如果 `h` 不是一个*等式*的*证明*（形式为 `A = B` 的声明），例如如果 `h` 是一个函数或蕴含，那么 `rw` " -"不是你想要使用的策略。例如，`rw [P = Q]` 永远不正确， 因为`P = Q` 是定理的*陈述*，而不是证明。但如果 " -"`h : P = Q` 是证明，那么 `rw [h]` 将会起作用。\n" +"* 如果 `h` 不是一个*等式*的*证明*（形式为 `A = B` 的声明），例如如果 `h` 是一" +"个函数或蕴含，那么 `rw` 不是你想要使用的策略。例如，`rw [P = Q]` 永远不正" +"确， 因为`P = Q` 是定理的*陈述*，而不是证明。但如果 `h : P = Q` 是证明，那么 " +"`rw [h]` 将会起作用。\n" "\n" "## 详情\n" "\n" "`rw` 策略是一种进行“代入”的方式。有两种不同的情况你可以使用这个策略。\n" "\n" -"1) 基本使用：如果 `h : A = B` 是一个假设或定理的证明，并且目标中包含一个或多个 `A`，那么 `rw [h]` 会" -"把它们全部改为 `B`。如果目标中没有 `A`，策略会报错。\n" +"1) 基本使用：如果 `h : A = B` 是一个假设或定理的证明，并且目标中包含一个或多" +"个 `A`，那么 `rw [h]` 会把它们全部改为 `B`。如果目标中没有 `A`，策略会报" +"错。\n" "\n" -"2) 高级使用：来自定理证明的假设经常有缺失的部分。例如 `add_zero` 是一个证明，表示 `? + 0 = ?`，因为 " -"`add_zero` 实际上是一个函数，而 `?` 是输入。在这种情况下，`rw` 会在目标中查找任何形式为 `x + 0` 的子" -"项，一旦找到，它就将 `?` 定位为 `x`，然后把所有的 `x + 0` 改为 `x`。\n" +"2) 高级使用：来自定理证明的假设经常有缺失的部分。例如 `add_zero` 是一个证明，" +"表示 `? + 0 = ?`，因为 `add_zero` 实际上是一个函数，而 `?` 是输入。在这种情况" +"下，`rw` 会在目标中查找任何形式为 `x + 0` 的子项，一旦找到，它就将 `?` 定位" +"为 `x`，然后把所有的 `x + 0` 改为 `x`。\n" "\n" -"练习：思考为什么 `rw [add_zero]` 会把项 `(0 + 0) + (x + 0) + (0 + 0) + (x + 0)` 改为 `0 + (x + 0) + " -"0 + (x + 0)`\n" +"练习：思考为什么 `rw [add_zero]` 会把项 `(0 + 0) + (x + 0) + (0 + 0) + (x + " +"0)` 改为 `0 + (x + 0) + 0 + (x + 0)`\n" "\n" "如果你不能记住等式证明的名称，请在右侧的定理列表中查找。\n" "\n" "## 针对性使用\n" "\n" -"如果你的目标是 `b + c + a = b + (a + c)` 并且你想把 `a + c` 重写为 `c + a`，那么 `rw [add_comm]` 将不" -"起作用，因为 Lean 会先找到另一个加法并交换它。使用 `rw [add_comm a c]` 来保证 Lean 将 `a + c` 重写为 " -"`c + a`。这是因为 `add_comm` 是一个证明，表示 `?1 + ?2 = ?2 + ?1`，`add_comm a` 是一个证明，表示 `a " -"+ ? = ? + a`，而 `add_comm a c` 是另一个证明，表示 `a + c = c + a`。\n" +"如果你的目标是 `b + c + a = b + (a + c)` 并且你想把 `a + c` 重写为 `c + a`，" +"那么 `rw [add_comm]` 将不起作用，因为 Lean 会先找到另一个加法并交换它。使用 " +"`rw [add_comm a c]` 来保证 Lean 将 `a + c` 重写为 `c + a`。这是因为 " +"`add_comm` 是一个证明，表示 `?1 + ?2 = ?2 + ?1`，`add_comm a` 是一个证明，表" +"示 `a + ? = ? + a`，而 `add_comm a c` 是另一个证明，表示 `a + c = c + a`。\n" "\n" -"如果 `h : X = Y`，那么 `rw [h]` 将会把所有的 `X` 变为 `Y`。如果你只想改变第37次出现的 `X` 为 `Y`，那" -"么可以使用 `nth_rewrite 37 [h]`。" +"如果 `h : X = Y`，那么 `rw [h]` 将会把所有的 `X` 变为 `Y`。如果你只想改变第37" +"次出现的 `X` 为 `Y`，那么可以使用 `nth_rewrite 37 [h]`。" #: Game.Levels.Tutorial.L02rw msgid "" @@ -362,12 +388,14 @@ msgid "" "## 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 `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` 反复应用策略 `t` 到目标上。这个是个可选策略，它只是有时可以节省步骤。\n" +"`repeat t` 反复应用策略 `t` 到目标上。这个是个可选策略，它只是有时可以节省步" +"骤。\n" "\n" "## 示例\n" "\n" @@ -386,22 +414,26 @@ msgid "" "## 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 `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` 并且在目标中有多个 `X`，那么 `nth_rewrite 3 [h]` 将仅更改第三个 `X` 为 `Y`。\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`。" +"如果目标是 `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.Tutorial.L02rw 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" +"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" @@ -409,14 +441,16 @@ msgid "" "We do this in Lean by *rewriting* the proof `h`,\n" "using the `rw` tactic." msgstr "" -"在这个关卡里，*目标*是证明 $2y=2(x+7)$。现在我们有一条*假设* `h`，它指出 $y = x + 7$。请检查假设列表" -"中是否包含了 `h`。在 Lean 中，`h` 被视为一种假设存在的证据，这有点像 `x` 是一个未知的具体数值。\n" +"在这个关卡里，*目标*是证明 $2y=2(x+7)$。现在我们有一条*假设* `h`，它指出 $y " +"= x + 7$。请检查假设列表中是否包含了 `h`。在 Lean 中，`h` 被视为一种假设存在" +"的证据，这有点像 `x` 是一个未知的具体数值。\n" "\n" -"要想使用 `rfl` 完成证明，我们首先需要对 $y$ 进行替换。在 Lean 中，我们可以通过*重写*证明 `h` 来实现这" -"一点，即使用 `rw` 策略。" +"要想使用 `rfl` 完成证明，我们首先需要对 $y$ 进行替换。在 Lean 中，我们可以通" +"过*重写*证明 `h` 来实现这一点，即使用 `rw` 策略。" #: Game.Levels.Tutorial.L02rw -msgid "If $x$ and $y$ are natural numbers, and $y = x + 7$, then $2y = 2(x + 7)$." +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.Tutorial.L02rw @@ -424,7 +458,8 @@ msgid "First execute `rw [h]` to replace the `y` with `x + 7`." msgstr "首先执行 `rw [h]` 将 `y` 替换为 `x + 7`。" #: Game.Levels.Tutorial.L02rw -msgid "Can you take it from here? Click on \"Show more help!\" if you need a hint." +msgid "" +"Can you take it from here? Click on \"Show more help!\" if you need a hint." msgstr "你能从这里开始吗？如果您需要提示，请点击 \"显示更多帮助！\"。" #: Game.Levels.Tutorial.L02rw @@ -432,7 +467,8 @@ msgid "Now `rfl` will work." msgstr "现在可以用 `rfl` 了。" #: Game.Levels.Tutorial.L02rw -msgid "You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey." +msgid "" +"You now know enough tactics to prove `2 + 2 = 4`! Let's begin the journey." msgstr "你现在已经学会了足够的策略来证明 `2 + 2 = 4`！让我们开始这段旅程吧。" #: Game.Levels.Tutorial.L03two_eq_ss0 @@ -449,7 +485,8 @@ msgid "" "\n" "## Game Implementation\n" "\n" -"*The game uses its own copy of the natural numbers, called `MyNat` with notation `ℕ`.\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 "" @@ -460,8 +497,8 @@ msgstr "" "\n" "## 游戏实现\n" "\n" -"*游戏使用自己重新定义的自然数，称为 `MyNat`，标记为 `ℕ`。它不同于 Lean 自然数 `Nat`，后者不应泄露到自" -"然数游戏中。*" +"*游戏使用自己重新定义的自然数，称为 `MyNat`，标记为 `ℕ`。它不同于 Lean 自然" +"数 `Nat`，后者不应泄露到自然数游戏中。*" #: Game.Levels.Tutorial.L03two_eq_ss0 msgid "`one_eq_succ_zero` is a proof of `1 = succ 0`.\"" @@ -510,11 +547,13 @@ msgstr "" "* `0` 被认为是一个自然数。\n" "* 如果 `n` 是一个自然数，那么 `n` 的*后继数* `succ n` 也是一个自然数。\n" "\n" -"这里，`n`的后继数指的是紧跟在 `n` 之后的自然数。让我们通过这种方式来计数，并为一些小数字命名。\n" +"这里，`n`的后继数指的是紧跟在 `n` 之后的自然数。让我们通过这种方式来计数，并" +"为一些小数字命名。\n" "\n" "## 计数至四\n" "\n" -"由于 `0` 是自然数，因此 `succ 0`（`0`的后继数）也是自然数。我们将这个新的自然数命名为 `1`。\n" +"由于 `0` 是自然数，因此 `succ 0`（`0`的后继数）也是自然数。我们将这个新的自然" +"数命名为 `1`。\n" "同样的逻辑，我们定义 `2 = succ 1`、`3 = succ 2` 和 `4 = succ 3`。\n" "这样，我们就拥有了足够的数字去应对接下来的挑战。\n" "\n" @@ -528,7 +567,9 @@ msgid "$2$ is the number after the number after $0$." msgstr "$2$ 是 $0$ 之后再之后的数字。" #: Game.Levels.Tutorial.L03two_eq_ss0 -msgid "Start with `rw [two_eq_succ_one]` to begin to break `2` down into its definition." +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.Tutorial.L03two_eq_ss0 @@ -650,15 +691,15 @@ msgstr "" "\n" "## 小结\n" "\n" -"`add_zero` 实际上是一个函数，它接受一个数字，并返回关于那个数字的定理的证明。例如，`add_zero 37` 是 " -"`37 + 0 = 37` 的证明。\n" +"`add_zero` 实际上是一个函数，它接受一个数字，并返回关于那个数字的定理的证明。" +"例如，`add_zero 37` 是 `37 + 0 = 37` 的证明。\n" "\n" "`rw` 策略会接受 `rw [add_zero]` 并尝试推断出你省略输入的数字。\n" "\n" "## 细节\n" "\n" -"数学家有时将 `add_zero` 视为“一个东西”，即 $∀ n ∈ ℕ, n + 0 = n$ 的证明。这只是另一种说法，它是一个函" -"数，可以接受任何数字 n 并返回 `n + 0 = n` 的证明。" +"数学家有时将 `add_zero` 视为“一个东西”，即 $∀ n ∈ ℕ, n + 0 = n$ 的证明。这只" +"是另一种说法，它是一个函数，可以接受任何数字 n 并返回 `n + 0 = n` 的证明。" #: Game.Levels.Tutorial.L05add_zero msgid "" @@ -677,11 +718,13 @@ msgid "" msgstr "" "## 小结\n" "\n" -"`repeat t` 会重复应用策略 `t` 到目标上。你不一定要使用这个策略，它有时只是加快了速度。\n" +"`repeat t` 会重复应用策略 `t` 到目标上。你不一定要使用这个策略，它有时只是加" +"快了速度。\n" "\n" "## 示例\n" "\n" -"`repeat rw [add_zero]` 会将目标 `a + 0 + (0 + (0 + 0)) = b + 0 + 0` 转变为目标 `a = b`。" +"`repeat rw [add_zero]` 会将目标 `a + 0 + (0 + (0 + 0)) = b + 0 + 0` 转变为目" +"标 `a = b`。" #: Game.Levels.Tutorial.L05add_zero msgid "" @@ -708,21 +751,24 @@ msgid "" "\n" "We write `add_zero x : x + 0 = x`, so `proof : statement`." msgstr "" -"我们正寻求证明 `2 + 2 = 4`，但目前我们连*表述*它都做不到，因为加法尚未被定义。\n" +"我们正寻求证明 `2 + 2 = 4`，但目前我们连*表述*它都做不到，因为加法尚未被定" +"义。\n" "\n" "## 加法的定义\n" "\n" -"如何实现将任意数字 $x$ 加到 $37$ 上呢？在这个游戏里，我们只有两种方式生成数字：$0$ 和后继数。因此，为" -"了定义 `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 37` 证明" -"了 `37 + 0 = 37`，`add_zero x` 证明了 `x + 0 = x`，而 `add_zero` 则证明了 `? + 0 = ?`。\n" +"为了让加法操作符合直觉，我们应当*定义* `37 + 0` 为 `37`。更广泛来说，对于任何" +"数字 `a`，我们定义 `a + 0` 应等于 `a`。在 Lean 中，从这个定义直接衍生出的定理" +"被命名为 `add_zero a`。比如，`add_zero 37` 证明了 `37 + 0 = 37`，`add_zero " +"x` 证明了 `x + 0 = x`，而 `add_zero` 则证明了 `? + 0 = ?`。\n" "\n" -"我们将定理记作 `add_zero x : x + 0 = x`，其中定理的名称位于前面，而定理的表述则位于后面。这和之前在*" -"假设*中的记法很像。" +"我们将定理记作 `add_zero x : x + 0 = x`，其中定理的名称位于前面，而定理的表述" +"则位于后面。这和之前在*假设*中的记法很像。" #: Game.Levels.Tutorial.L05add_zero Game.Levels.Tutorial.L06add_zero2 msgid "$a+(b+0)+(c+0)=a+b+c.$" @@ -741,8 +787,8 @@ 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 "" -"对于那些对快速通关游戏感兴趣的玩家，一个小技巧是使用 `repeat rw [add_zero]` 可以一次性完成两次重写操" -"作。" +"对于那些对快速通关游戏感兴趣的玩家，一个小技巧是使用 `repeat rw [add_zero]` " +"可以一次性完成两次重写操作。" #: Game.Levels.Tutorial.L06add_zero2 msgid "Precision rewriting" @@ -772,11 +818,13 @@ msgstr "尝试使用 `rw [add_zero c]`。" #: 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" +"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` 的证明，所以可以用来改写目标了。现在你可以用 `rw [add_zero]` 或 `rw " -"[add_zero b]` 把 `b + 0` 改成 `b`。您通常可以使用 `rw [add_zero]`，除非你需要精准控制改写的内容。" +"`add_zero c` 是 `c + 0 = c` 的证明，所以可以用来改写目标了。现在你可以用 `rw " +"[add_zero]` 或 `rw [add_zero b]` 把 `b + 0` 改成 `b`。您通常可以使用 `rw " +"[add_zero]`，除非你需要精准控制改写的内容。" #: Game.Levels.Tutorial.L06add_zero2 msgid "Let's now learn about Peano's second axiom for addition, `add_succ`." @@ -809,7 +857,8 @@ msgid "" "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" +"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 "" @@ -830,17 +879,20 @@ msgstr "" " `012`（数字）选项卡里\n" "看看你可以用哪些证明重写目标。\n" "\n" -"在 Lean 中，每个数字要么是 $0$，要么是某个数字的后继数。我们已经掌握了如何加上 $0$，下一步需要明白如" -"何加上后继数。设想我们已经知道 `37 + d = q`。那么 `37 + succ d` 应该是什么呢？由于 `succ d` 比 `d` " -"多 $1$，所以 `37 + succ d` 应该等于 `succ q`，也就是 `q` 加 $1$。更一般地，`x + succ d` 应等于 `succ " -"(x + d)`。我们把这个规则加为一个引理：\n" +"在 Lean 中，每个数字要么是 $0$，要么是某个数字的后继数。我们已经掌握了如何加" +"上 $0$，下一步需要明白如何加上后继数。设想我们已经知道 `37 + d = q`。那么 " +"`37 + succ d` 应该是什么呢？由于 `succ d` 比 `d` 多 $1$，所以 `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" +"当你在证明目标中遇到 `... + succ ...` 形式时，使用 `rw [add_succ]` 来重写通常" +"是一个好策略。\n" "\n" -"现在，让我们来证明 `succ n = n + 1`。思考如何先引入 `+ succ` 形式，然后再应用 `rw [add_succ]` 策略。" -"请在右侧“定理”部分的 `+`（代表加法）和 `012`（代表数字）标签页中查找可以用来重写目标的定理。" +"现在，让我们来证明 `succ n = n + 1`。思考如何先引入 `+ succ` 形式，然后再应" +"用 `rw [add_succ]` 策略。请在右侧“定理”部分的 `+`（代表加法）和 `012`（代表数" +"字）标签页中查找可以用来重写目标的定理。" #: Game.Levels.Tutorial.L07add_succ msgid "For all natural numbers $a$, we have $\\operatorname{succ}(a) = a+1$." @@ -878,22 +930,26 @@ msgstr "2+2=4" msgid "" "Good luck!\n" "\n" -" One last hint. If `h : X = Y` then `rw [h]` will change *all* `X`s into `Y`s.\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`。如果你只想替换其中一个，" -"比如第 3 个，那么请使用 `nth_rewrite 3 [h]`。" +"最后一个提示。如果 `h : X = Y`，那么 `rw [h]` 会将 *所有* 的 `X` 替换为 `Y`。" +"如果你只想替换其中一个，比如第 3 个，那么请使用 `nth_rewrite 3 [h]`。" #: Game.Levels.Tutorial.L08twoaddtwo msgid "$2+2=4$." msgstr "$2+2=4$。" #: 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]` 更快。" +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.L08twoaddtwo msgid "" @@ -909,12 +965,14 @@ msgid "" "rfl\n" "```\n" "\n" -"Optional extra: you can run this proof yourself. Switch the game into \"Editor mode\" by clicking\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" +"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" @@ -964,13 +1022,14 @@ msgid "" "Let's learn some basic tactics. Click on \"Start\" below\n" "to begin your quest." msgstr "" -"欢迎进入教程世界！在这里，我们将掌握证明定理的初步技能。这个世界中的终极挑战是证明 `2 + 2 = 4` 这一定" -"理。\n" +"欢迎进入教程世界！在这里，我们将掌握证明定理的初步技能。这个世界中的终极挑战" +"是证明 `2 + 2 = 4` 这一定理。\n" "\n" -"解决这些谜题并证明定理的过程中，你将使用一种名为*策略*的强大工具。证明定理的关键在于准确地应用这些策" -"略。\n" +"解决这些谜题并证明定理的过程中，你将使用一种名为*策略*的强大工具。证明定理的" +"关键在于准确地应用这些策略。\n" "\n" -"现在，让我们开始学习一些基本策略吧。请点击下面的“开始”按钮，开启你的证明之旅。" +"现在，让我们开始学习一些基本策略吧。请点击下面的“开始”按钮，开启你的证明之" +"旅。" #: Game.Levels.Addition.L01zero_add msgid "zero_add" @@ -978,38 +1037,47 @@ msgstr "zero_add" #: 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" +"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" +"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" +"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" +"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" +"`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" +"(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 "" "在这个关卡中，我们将证明 $0+n=n$，其中 $n$ 是一个未知的自然数。\n" "\n" -"等等，我们不是已经知道这个了吗？不！我们知道的是 $n+0=n$，但那是 `add_zero`。这里的 `zero_add` 是不同" -"的。\n" +"等等，我们不是已经知道这个了吗？不！我们知道的是 $n+0=n$，但那是 `add_zero`。" +"这里的 `zero_add` 是不同的。\n" "\n" -"证明 `0 + n = n` 的难点在于我们没有一个一般的*公式*来表示 `0 + n`，我们只能在知道 `n` 是 `0` 还是后继" -"数后，使用 `add_zero` 和 `add_succ`。`induction` （归纳）策略会把目标分解成这两种情况。\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" +"基础情况将要求我们证明 `0 + 0 = 0`，归纳步骤将要求我们证明如果 `0 + d = d` 那" +"么 `0 + succ d = succ d`。因为 `0` 和后继数是构造数字的唯一方式，这将涵盖所有" +"情况。\n" "\n" "看看你是否能在 Lean 中完成你的第一个归纳证明。\n" "\n" -"(顺便说一句，如果你还在上一个世界的 \"编辑器模式 \"下，你可以通过点击 \"编辑器模式 \"下的\n" +"(顺便说一句，如果你还在上一个世界的 \"编辑器模式 \"下，你可以通过点击 \"编辑" +"器模式 \"下的\n" "点击右上角的 `>_` 按钮换回 \"模式\"）。" #: Game.Levels.Addition.L01zero_add @@ -1021,8 +1089,8 @@ msgid "" msgstr "" "`zero_add x` 是 `0 + x = x` 的证明。\n" "\n" -"`zero_add` 是一个有 `simp` 标记的引理，因为如果你正在简化一个表达式，几乎总是想要将 `0 + x` 替换为 " -"`x`。" +"`zero_add` 是一个有 `simp` 标记的引理，因为如果你正在简化一个表达式，几乎总是" +"想要将 `0 + x` 替换为 `x`。" #: Game.Levels.Addition.L01zero_add msgid "For all natural numbers $n$, we have $0 + n = n$." @@ -1038,7 +1106,8 @@ msgstr "" #: Game.Levels.Addition.L01zero_add msgid "" -"Now you have two goals. Once you proved the first, you will jump to the second one.\n" +"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" @@ -1048,7 +1117,8 @@ msgstr "" "现在你有两个目标。一旦你证明了第一个，你会自动跳到第二个。\n" "第一个目标是基础情形 $n = 0$。\n" "\n" -"回想一下，你可以使用任何在你的清单中可见的引理的证明，或者任何显示在目标上方的假设\n" +"回想一下，你可以使用任何在你的清单中可见的引理的证明，或者任何显示在目标上方" +"的假设\n" "（只要它是形如 `X = Y` 的形式）来重写目标。" #: Game.Levels.Addition.L01zero_add @@ -1058,7 +1128,8 @@ msgstr "尝试重写 `add_zero`。" #: Game.Levels.Addition.L01zero_add 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}»`." +"`«{hd}» : 0 + «{d}» = «{d}»`, and you need to prove that `0 + succ «{d}» = " +"succ «{d}»`." msgstr "" "现在来到第二个目标。这里你有归纳假设\n" "`«{hd}» : 0 + «{d}» = «{d}»`，你需要证明 `0 + succ «{d}» = succ «{d}»`。" @@ -1071,15 +1142,19 @@ msgstr "使用 `add_succ`。" 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}»]` 来使用归纳假设。" +msgstr "" +"在这一点上，你看到了项 `0 + «{d}»`，所以你可以通过 `rw [«{hd}»]` 来使用归纳假" +"设。" #: 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" +"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" +"variable in the successor case being `d`, and the inductive hypothesis being " +"`hd`.\n" "\n" "### Example:\n" "If the goal is\n" @@ -1101,7 +1176,8 @@ msgstr "" "## 概述\n" "\n" "如果 `n : ℕ` 是一个对象，并且目标提到了 `n`，那么 `induction n with d hd`\n" -"尝试通过对 `n` 进行归纳来证明目标，其中后继数情况下的归纳变量是 `d`，归纳假设是 `hd`。\n" +"尝试通过对 `n` 进行归纳来证明目标，其中后继数情况下的归纳变量是 `d`，归纳假设" +"是 `hd`。\n" "\n" "### 例子:\n" "如果目标是\n" @@ -1121,8 +1197,10 @@ msgstr "" #: 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" +"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`." @@ -1143,11 +1221,14 @@ msgid "" "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." +"to use induction to split into the cases where `b = 0` and `b` is a " +"successor." msgstr "" "哦不！在前往 `add_comm` 的路上，一个野生的 `succ_add` 出现了。\n" -"`succ_add a b` 是 `(succ a) + b = succ (a + b)` 的证明，对于数字 `a` 和 `b`。\n" -"这个结果是证明 `x + y = y + x` 的中间步骤。这里我们再次遇到了向事物中加入 `b` 的问题，\n" +"`succ_add a b` 是 `(succ a) + b = succ (a + b)` 的证明，对于数字 `a` 和 " +"`b`。\n" +"这个结果是证明 `x + y = y + x` 的中间步骤。这里我们再次遇到了向事物中加入 " +"`b` 的问题，\n" "所以我们需要使用归纳法来分解成 `b = 0` 和 `b` 是后继数的情况。" #: Game.Levels.Addition.L02succ_add @@ -1181,11 +1262,12 @@ 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}»`。将你的光标放在目标或假设中的任何 `succ` 上，以" -"查看它确切的含义。" +"请注意，`succ a + «{d}»` 的意思是 `(succ a) + «{d}»`。将你的光标放在目标或假" +"设中的任何 `succ` 上，以查看它确切的含义。" #: Game.Levels.Addition.L02succ_add -msgid "Well done! You now have enough tools to tackle the main boss of this level." +msgid "" +"Well done! You now have enough tools to tackle the main boss of this level." msgstr "做得好！现在你有足够的工具来对付这个关卡的大Boss了。" #: Game.Levels.Addition.L03add_comm @@ -1233,14 +1315,15 @@ msgid "" " 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" +" 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 "" "我们已经学会了将两个数相加；在这个关卡中，我们将学习如何将三个数相加。\n" "\n" -"$x+y+z$ *意味*着什么？它可以意味着 $(x+y)+z$，也可以意味着 $x+(y+z)$。在 Lean 中，$x+y+z$ 意味着 $(x" -"+y)+z$。\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" @@ -1309,20 +1392,21 @@ msgid "" "and `add_comm` moves variables around.\n" "\n" "Remember that you can do more targetted rewrites by\n" -"adding explicit variables as inputs to theorems. For example `rw [add_comm b]`\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` 的证明。但如果您的目标是 `a + b + c = a + c + b`，那么 `rw " -"[add_comm b c]` 将不起作用！因为目标是 `(a + b) + c = (a + c) + b`，所以目标中*直接*没有 `b + c` " -"项。\n" +"`add_comm b c` 是一个 `b + c = c + b` 的证明。但如果您的目标是 `a + b + c = " +"a + c + b`，那么 `rw [add_comm b c]` 将不起作用！因为目标是 `(a + b) + c = " +"(a + c) + b`，所以目标中*直接*没有 `b + c` 项。\n" "\n" -"使用结合律和交换律来证明 `add_right_comm`。您不需要使用归纳法。`add_assoc` 移动括号，`add_comm` 移动" -"变量。\n" +"使用结合律和交换律来证明 `add_right_comm`。您不需要使用归纳法。`add_assoc` 移" +"动括号，`add_comm` 移动变量。\n" "\n" "请记住，您可以通过将显式变量添加为定理的输入来进行更有针对性的重写。\n" -"例如，`rw [add_comm b]` 只会重写形如 `b + ? = ? + b` 的形式，而 `rw [add_comm b c]` 只会重写形如 `b " -"+ c = c + b` 的形式。" +"例如，`rw [add_comm b]` 只会重写形如 `b + ? = ? + b` 的形式，而 `rw " +"[add_comm b c]` 只会重写形如 `b + c = c + b` 的形式。" #: Game.Levels.Addition.L05add_right_comm msgid "" @@ -1333,7 +1417,8 @@ msgid "" 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`。" +"在 Lean 中，`a + b + c` 意味着 `(a + b) + c`，所以这个结果被显示为 `a + b + " +"c = a + c + b`。" #: Game.Levels.Addition.L05add_right_comm msgid "" @@ -1345,10 +1430,13 @@ msgstr "" #: 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" +"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" +"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" @@ -1368,25 +1456,29 @@ msgstr "加法世界" #: 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" +"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" +"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" +"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 "" -"欢迎来到加法世界！在这个世界中，我们将学习 `induction`（归纳）策略。这将使我们能够击败这个世界的Boss" -"级别，即 `x + y = y + x`。\n" +"欢迎来到加法世界！在这个世界中，我们将学习 `induction`（归纳）策略。这将使我" +"们能够击败这个世界的Boss级别，即 `x + y = y + x`。\n" "\n" -"策略 `rw`（重写）、`rfl`（反射）和 `induction`（归纳）是你在加法世界、乘法世界和幂世界中击败所有关卡" -"所需要策略。幂世界包含了游戏的最终Boss。\n" +"策略 `rw`（重写）、`rfl`（反射）和 `induction`（归纳）是你在加法世界、乘法世" +"界和幂世界中击败所有关卡所需要策略。幂世界包含了游戏的最终Boss。\n" "\n" -"这个游戏中还有更多的策略，但只有当你想进一步探索游戏时（例如如果你决定完成游戏的100%）才需要了解它" -"们。" +"这个游戏中还有更多的策略，但只有当你想进一步探索游戏时（例如如果你决定完成游" +"戏的100%）才需要了解它们。" #: Game.Levels.Multiplication.L01mul_one msgid "mul_one" @@ -1421,13 +1513,15 @@ msgid "" "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" +"`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`，都是通过从这两个基本定理进行归纳证明得到的。" +"关于自然数的其他定理，比如 `zero_mul`，都是通过从这两个基本定理进行归纳证明得" +"到的。" #: Game.Levels.Multiplication.L01mul_one msgid "`mul_zero m` is the proof that `m * 0 = 0`." @@ -1458,8 +1552,8 @@ msgid "" "start with this." msgstr "" "我们的第一个挑战是`mul_comm x y : x * y = y * x`，\n" -"我们想通过归纳法来证明这一点。在证明0的目标下我们需要 `mul_zero` （我们有）和 `zero_mul` （我们没" -"有），所以让我们从这里开始。" +"我们想通过归纳法来证明这一点。在证明0的目标下我们需要 `mul_zero` （我们有）" +"和 `zero_mul` （我们没有），所以让我们从这里开始。" #: Game.Levels.Multiplication.L02zero_mul msgid "" @@ -1491,7 +1585,8 @@ msgid "" "You won't lose any progress." msgstr "" "同样，我们有 `mul_succ`，\n" -"但我们需要 `succ_mul`（猜猜它是什么意思 —— 也许你已经掌握了 Lean 的命名范式）。\n" +"但我们需要 `succ_mul`（猜猜它是什么意思 —— 也许你已经掌握了 Lean 的命名范" +"式）。\n" "\n" "加法世界中的最后一关会在这个关卡中帮助你。\n" "如果你忘记了它是什么，你可以通过点击房屋图标回到主界面，然后看一看。\n" @@ -1523,7 +1618,8 @@ msgstr "mul_comm" #: Game.Levels.Multiplication.L04mul_comm msgid "" -"The first sub-boss of Multiplication World is `mul_comm x y : x * y = y * x`.\n" +"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" @@ -1631,10 +1727,10 @@ msgid "" "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 中的证明名称，它们是描述性的。\n" -"让我们从 `mul_add a b c` 开始，这是 `a * (b + c) = a * b + a * c` 的证明。注意左边包含一个乘法然后是" -"一个加法。" +"我们的下一个目标是“左右分配律”，意思是 $a(b+c)=ab+ac$ 和 $(b+c)a=ba+ca$。与其" +"用这样稍显浮夸的名字，不如使用 Lean 中的证明名称，它们是描述性的。\n" +"让我们从 `mul_add a b c` 开始，这是 `a * (b + c) = a * b + a * c` 的证明。注" +"意左边包含一个乘法然后是一个加法。" #: Game.Levels.Multiplication.L07mul_add msgid "" @@ -1663,8 +1759,8 @@ msgid "" "are harder to push through than others. Can you do the inductive step in\n" "5 rewrites only?" msgstr "" -"你可以对任何三个变量中的任何一个进行归纳。有些选择比其他选择更难以推进。你能仅用5次改写完成归纳步骤" -"吗？" +"你可以对任何三个变量中的任何一个进行归纳。有些选择比其他选择更难以推进。你能" +"仅用5次改写完成归纳步骤吗？" #: Game.Levels.Multiplication.L07mul_add msgid "" @@ -1757,7 +1853,8 @@ msgid "" "\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" +"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 "" @@ -1765,8 +1862,8 @@ msgstr "" "\n" "请注意，当 Lean 表示 `a * b * c` 时，它的意思是 `(a * b) * c`。\n" "\n" -"请注意，`(a * b) * c = a * (b * c)` 不能仅凭“空想”来证明：例如，减法不是结合的，因为 `(6 - 2) - 1` 不" -"等于 `6 - (2 - 1)`。" +"请注意，`(a * b) * c = a * (b * c)` 不能仅凭“空想”来证明：例如，减法不是结合" +"的，因为 `(6 - 2) - 1` 不等于 `6 - (2 - 1)`。" #: Game.Levels.Multiplication.L09mul_assoc msgid "" @@ -1795,7 +1892,8 @@ msgstr "乘法世界" #: Game.Levels.Multiplication msgid "" -"How should we define `37 * x`? Just like addition, we need to give definitions\n" +"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" @@ -1807,23 +1905,25 @@ msgid "" " * `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" +"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$ 是后继数时给出定义。\n" +"我们应该如何定义 `37 * x`？就像加法一样，我们需要在 $x=0$ 和 $x$ 是后继数时给" +"出定义。\n" "\n" -"0的情况很简单：我们定义 `37 * 0` 为 `0`。现在假设我们知道 `37 * d`。`37 * succ d` 应该是什么呢？嗯，" -"那是 $d+1$ 个 $37$，它应该是 `37 * d + 37`。\n" +"0的情况很简单：我们定义 `37 * 0` 为 `0`。现在假设我们知道 `37 * d`。`37 * " +"succ d` 应该是什么呢？嗯，那是 $d+1$ 个 $37$，它应该是 `37 * d + 37`。\n" "\n" "以下是 Lean 中的定义。\n" "\n" " * `mul_zero a : a * 0 = 0`\n" " * `mul_succ a d : a * succ d = a * d + a`\n" "\n" -"在这个世界中，我们不仅要证明关于乘法的事实，如 `a * b = b * a`，我们还必须证明乘法与加法相互作用的事" -"实，如 `a * (b + c) = a * b + a * c`。\n" +"在这个世界中，我们不仅要证明关于乘法的事实，如 `a * b = b * a`，我们还必须证" +"明乘法与加法相互作用的事实，如 `a * (b + c) = a * b + a * c`。\n" "让我们开始吧。" #: Game.Levels.Power.L01zero_pow_zero @@ -1858,7 +1958,8 @@ 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" @@ -1904,13 +2005,16 @@ msgstr "" 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` 是定义这个游戏中幂的两个公理中的一个。" +msgstr "" +"`pow_succ a b : a ^ (succ b) = a ^ b * a` 是定义这个游戏中幂的两个公理中的一" +"个。" #: 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$ 是后继数，那么 $0^n=0$。" +msgstr "" +"虽然在这个游戏中 $0^0=1$，但如果 $n>0$，即如果 $n$ 是后继数，那么 $0^n=0$。" #: Game.Levels.Power.L02zero_pow_succ msgid "For all numbers $m$, $0 ^{\\operatorname{succ} (m)} = 0$." @@ -1930,8 +2034,8 @@ msgid "" msgstr "" "`pow_one a` 表示 `a ^ 1 = a`。\n" "\n" -"请注意，这并不是完全根据定义来的：`a ^ 1` 被定义为 `a ^ 0 * a`，所以它是 `1 * a`，要证明这等于 `a`，" -"你需要在某处使用数学归纳。" +"请注意，这并不是完全根据定义来的：`a ^ 1` 被定义为 `a ^ 0 * a`，所以它是 `1 " +"* a`，要证明这等于 `a`，你需要在某处使用数学归纳。" #: Game.Levels.Power.L03pow_one msgid "For all naturals $a$, $a ^ 1 = a$." @@ -1988,11 +2092,12 @@ msgid "mul_pow" msgstr "mul_pow" #: Game.Levels.Power.L07mul_pow +#, fuzzy 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 `x * y`\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 "" @@ -2034,11 +2139,12 @@ 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.L08pow_pow +#, fuzzy msgid "" "The music dies down. Is that it?\n" "\n" "Course it isn't, you can\n" -"clearly see that there are two worlds left.\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" @@ -2081,7 +2187,8 @@ msgid "" "\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!" +"But wait! This boss is stirring...and mutating into a second more powerful " +"form!" msgstr "" "一切都结束了！你已经证明了一个困扰了几代学生的定理\n" "（他们中的一些人认为 $(a+b)^2=a^2+b^2$ ：这就是“新生的错觉”）。\n" @@ -2099,7 +2206,8 @@ 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" +"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" @@ -2116,25 +2224,30 @@ msgid "" "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" +"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$。\n" -"如果你还没学习过不等式世界，那么我们不能讨论 $m \\geq 3$，所以我们不得不采用使用 `n + 3` 代替 `m` 的" -"方法，这保证了它足够大。同样，我们用 `a + 1` 代替 `x > 0`。\n" +"如果你还没学习过不等式世界，那么我们不能讨论 $m \\geq 3$，所以我们不得不采用" +"使用 `n + 3` 代替 `m` 的方法，这保证了它足够大。同样，我们用 `a + 1` 代替 `x " +"> 0`。\n" "\n" -"这一关表面上看起来像我们见过的其他关卡，但人类已知的最短解法也将转化为数百万行的 Lean 代码。\n" -"这个游戏的作者，Kevin Buzzard，正在将 Wiles 和 Taylor 的证明翻译成 Lean，尽管这项任务将花费许多年。\n" +"这一关表面上看起来像我们见过的其他关卡，但人类已知的最短解法也将转化为数百万" +"行的 Lean 代码。\n" +"这个游戏的作者，Kevin Buzzard，正在将 Wiles 和 Taylor 的证明翻译成 Lean，尽管" +"这项任务将花费许多年。\n" "\n" "## 祝贺！\n" "\n" "你已经完成了自然数游戏的主线任务！\n" -"如果你想了解更多关于如何使用 Lean 来证明数学定理的信息，请查看 [Mathematics In Lean](https://" -"leanprover-community.github.io/mathematics_in_lean/)，\n" -"这是一本互动教科书，你可以在浏览器中阅读它，它解释了如何在 Lean 中处理更多的数学概念。" +"如果你想了解更多关于如何使用 Lean 来证明数学定理的信息，请查看 [Mathematics " +"In Lean](https://leanprover-community.github.io/mathematics_in_lean/)，\n" +"这是一本互动教科书，你可以在浏览器中阅读它，它解释了如何在 Lean 中处理更多的" +"数学概念。" #: Game.Levels.Power.L10FLT msgid "" @@ -2142,8 +2255,8 @@ msgid "" "modern word `sorry`. The game won't complain - or notice - if you\n" "prove anything with `xyzzy`." msgstr "" -"`xyzzy` 是一个古老的魔法咒语，被认为是现代词汇 `sorry` 的起源。游戏不会发现——或者注意到你用 `xyzzy` " -"证明任何东西。" +"`xyzzy` 是一个古老的魔法咒语，被认为是现代词汇 `sorry` 的起源。游戏不会发现——" +"或者注意到你用 `xyzzy` 证明任何东西。" #: Game.Levels.Power.L10FLT msgid "" @@ -2185,8 +2298,8 @@ msgid "" "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" +"这个世界引入了幂运算。如果你想定义 `37 ^ n`，那么像往常一样，你需要知道 `37 " +"^ 0` 是什么，以及在仅知 `37 ^ d` 的情况下，`37 ^ (succ d)` 是什么。\n" "\n" "你可能已经猜到了这些一般定理的名称：\n" "\n" @@ -2195,8 +2308,9 @@ msgstr "" "\n" "仅用这些定理，你能通过最后的boss关卡吗？\n" "\n" -"这个世界中的关卡由帝国理工学院的 UROP 学生 Sian Carey 在 2019 年夏天设计，她的项目得到了 Mary Lister " -"McCammon 奖学金的资助。感谢 Sian，也感谢帝国理工学院对她的资助。" +"这个世界中的关卡由帝国理工学院的 UROP 学生 Sian Carey 在 2019 年夏天设计，她" +"的项目得到了 Mary Lister McCammon 奖学金的资助。感谢 Sian，也感谢帝国理工学院" +"对她的资助。" #: Game.Levels.Implication.L01exact msgid "The `exact` tactic" @@ -2206,7 +2320,8 @@ msgstr "`exact` 策略" 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" +"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" @@ -2223,7 +2338,8 @@ msgid "" "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" +"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`." @@ -2244,18 +2360,21 @@ msgstr "" "要让 `exact h` 起作用，`h` 必须和目标的证明*完全*匹配。\n" "`add_zero` 是 `∀ n, n + 0 = n` 的证明，或者，如果你想要的话也可以是\n" "`? + 0 = ?` 的证明，其中 `?` 需要由你提供。\n" -"这与 `rw` 和 `apply` 不同，它们会在必要时“猜测输入”。如果目标是 `x + 0 = x`，那么 `rw [add_zero]`\n" +"这与 `rw` 和 `apply` 不同，它们会在必要时“猜测输入”。如果目标是 `x + 0 = x`，" +"那么 `rw [add_zero]`\n" "和 `rw [add_zero x]` 都会将目标改为 `x = x`、\n" "因为 `rw` 猜到了函数 `add_zero` 的输入。" #: Game.Levels.Implication.L01exact +#, fuzzy 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" +"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." +"the hypotheses. It takes the name of the hypothesis as argument: `exact h`." msgstr "" "在这个世界中，我们将学习如何证明形式为 $P\\implies Q$ 的定理。\n" "换句话说，就是如何证明“如果 $P$ 为真，则 $Q$ 也为真”的形式的定理。\n" @@ -2268,7 +2387,9 @@ 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.Implication.L01exact -msgid "The goal in this level is one of our hypotheses. Solve the goal by executing `exact h1`." +msgid "" +"The goal in this level is one of our hypotheses. Solve the goal by executing " +"`exact h1`." msgstr "这一层的目标是我们的一个假设。通过执行 `exact h1` 来解决目标。" #: Game.Levels.Implication.L02exact2 @@ -2289,26 +2410,31 @@ msgstr "假设 $0+x=(0+y)+2$，我们有 $x=y+2$。" 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}»` 来在 `«{h}»` 处进行重写，而不是在目标处进行。" +msgstr "" +"你可以使用 `rw [zero_add] at «{h}»` 来在 `«{h}»` 处进行重写，而不是在目标处进" +"行。" #: Game.Levels.Implication.L02exact2 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 occurences of\n" +"the arguments to `zero_add` (finding `«{x}»`) then it replaces all " +"occurences of\n" "`0 + «{x}»` it finds. Therefor, it did not rewrite `0 + «{y}»`, yet." msgstr "" "再做一次！\n" "\n" -"`rw [zero_add] at «{h}»` 试图填充 `zero_add` 的参数（找到 `«{x}»`），然后替换它找到的所有 `0 + " -"«{x}»` 出现的地方。因此，`0 + «{y}»`还没有被重写 。" +"`rw [zero_add] at «{h}»` 试图填充 `zero_add` 的参数（找到 `«{x}»`），然后替换" +"它找到的所有 `0 + «{x}»` 出现的地方。因此，`0 + «{y}»`还没有被重写 。" #: 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}»` 可以在一行中做到同样的事。" +msgstr "" +"现在你可以用 `rw [«{h}»]` 然后 `rfl` 来完成证明，但 `exact «{h}»` 可以在一行" +"中做到同样的事。" #: Game.Levels.Implication.L02exact2 msgid "" @@ -2332,11 +2458,13 @@ msgstr "`apply` 策略。" msgid "" "## Summary\n" "\n" -"If `t : P → Q` is a proof that $P \\implies Q$, and `h : P` is a proof of `P`,\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" +"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" @@ -2356,33 +2484,42 @@ msgid "" msgstr "" "## 概述\n" "\n" -"如果 `t : P → Q` 是一个 $P\\implies Q$ 的证明，而 `h : P` 是一个 `P` 的证明，那么 `apply t at h` 会" -"将 `h` 转换为证明 `Q`。其原理是，如果您知道 `P` 为真，那么您可以从 `t` 推断出 `Q` 为真。\n" +"如果 `t : P → Q` 是一个 $P\\implies Q$ 的证明，而 `h : P` 是一个 `P` 的证明，" +"那么 `apply t at h` 会将 `h` 转换为证明 `Q`。其原理是，如果您知道 `P` 为真，" +"那么您可以从 `t` 推断出 `Q` 为真。\n" "\n" -"如果*目标*是 `Q`，那么 `apply t` 会“逆向推理”并将目标转换为 `P`。在这里，如果您想证明 `Q`，那么根据 " -"`t`，只需证明 `P` 即可，因此您可以将目标简化为证明 `P`。\n" +"如果*目标*是 `Q`，那么 `apply t` 会“逆向推理”并将目标转换为 `P`。在这里，如果" +"您想证明 `Q`，那么根据 `t`，只需证明 `P` 即可，因此您可以将目标简化为证明 " +"`P`。\n" "\n" "### 示例：\n" "\n" "`succ_inj x y` 是一个 `succ x = succ y → x = y` 的证明。\n" "\n" -"因此，如果您有一个假设 `h : succ (a + 37) = succ (b + 42)`，那么 `apply succ_inj at h` 会将 `h` 转换" -"为 `a + 37 = b + 42`。您可以写 `apply succ_inj (a + 37) (b + 42) at h`，但 Lean 足够聪明，可以自行推" -"断出 `succ_inj` 的输入。\n" +"因此，如果您有一个假设 `h : succ (a + 37) = succ (b + 42)`，那么 `apply " +"succ_inj at h` 会将 `h` 转换为 `a + 37 = b + 42`。您可以写 `apply succ_inj " +"(a + 37) (b + 42) at h`，但 Lean 足够聪明，可以自行推断出 `succ_inj` 的输" +"入。\n" "\n" "### 示例：\n" "\n" -"如果目标是 `a * b = 7`，那么 `apply succ_inj` 会将目标转换为 `succ (a * b) = succ 7`。" +"如果目标是 `a * b = 7`，那么 `apply succ_inj` 会将目标转换为 `succ (a * b) = " +"succ 7`。" #: Game.Levels.Implication.L03apply msgid "" -"In this level one of our hypotheses is an *implication*. We can use this\n" -"hypothesis with the `apply` tactic." -msgstr "在这个关卡中，我们的一个假设是一个*蕴含式*。我们可以使用 `apply` 策略来利用这个假设。" +"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 "" #: 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$。" +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$。" #: Game.Levels.Implication.L03apply msgid "Start with `apply h2 at h1`. This will change `h1` to `y = 42`." @@ -2399,7 +2536,8 @@ msgstr "succ_inj ：后继数是单射的" #: 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" +"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" @@ -2408,12 +2546,13 @@ msgid "" "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" +"如果 `a` 和 `b` 是数字，那么 `succ_inj a b` 是一个证明，表明 `succ a = succ " +"b` 意味着 `a = b`。点击 *Peano* 标签中的这个定理以获取更多信息。\n" "\n" -"皮亚诺将这个定理作为一个公理，但在算法世界中我们将展示如何在 Lean 中证明它。\n" -"现在让我们先假设它，然后让我们使用它证明 $x+1=4 \\implies x=3$。再一次，我们将通过操纵我们的假设直到" -"它变成目标来进行。我将引导你通过这个关卡。" +"皮亚诺将这个定理作为一个公理，但在算法世界中我们将展示如何在 Lean 中证明" +"它。\n" +"现在让我们先假设它，然后让我们使用它证明 $x+1=4 \\implies x=3$。再一次，我们" +"将通过操纵我们的假设直到它变成目标来进行。我将引导你通过这个关卡。" #: Game.Levels.Implication.L04succ_inj msgid "" @@ -2434,8 +2573,8 @@ msgid "" "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" +"$\\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" @@ -2445,21 +2584,26 @@ msgstr "" "\n" "如果 \\( a \\) 和 \\( b \\) 是数字，那么\n" "`succ_inj a b` 是\n" -"$ (\\operatorname{succ}(a) = \\operatorname{succ}(b))\\implies 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" +"你可以把 `succ_inj` 本身想象成一个函数，它接受两个数字 $$a$$ 和 $$b$$ 作为输" +"入，并输出\n" +"$ (\\operatorname{succ}(a) = \\operatorname{succ}(b))\\implies a=b $ 的证" +"明。\n" "\n" -"你可以把 `succ_inj` 本身看作是一个证明；它是 `succ` 是一个单射函数的证明。换句话说，\n" +"你可以把 `succ_inj` 本身看作是一个证明；它是 `succ` 是一个单射函数的证明。换" +"句话说，\n" "`succ_inj` 是\n" -"$ \\forall a, b \\in \\mathbb{N}, (\\operatorname{succ}(a) = \\operatorname{succ}(b))\\implies a=b $ " -"的证明。\n" +"$ \\forall a, b \\in \\mathbb{N}, (\\operatorname{succ}(a) = " +"\\operatorname{succ}(b))\\implies a=b $ 的证明。\n" "\n" -"`succ_inj` 被皮亚诺假设为一个公理，但在 Lean 中可以使用 `pred` 来证明，这是一个在数学上有病态的函数。" +"`succ_inj` 被皮亚诺假设为一个公理，但在 Lean 中可以使用 `pred` 来证明，这是一" +"个在数学上有病态的函数。" #: Game.Levels.Implication.L04succ_inj Game.Levels.Implication.L05succ_inj2 msgid "If $x+1=4$ then $x=3$." @@ -2471,8 +2615,8 @@ msgid "" "apply `succ_inj`. First execute `rw [four_eq_succ_three] at h`\n" "to change the 4 on the right hand side." msgstr "" -"首先让 `h` 变为 `succ x = succ 3` 的形式，这样我们就可以应用 `succ_inj`。首先执行 `rw " -"[four_eq_succ_three] at h` 来改变右手边的4。" +"首先让 `h` 变为 `succ x = succ 3` 的形式，这样我们就可以应用 `succ_inj`。首先" +"执行 `rw [four_eq_succ_three] at h` 来改变右手边的4。" #: Game.Levels.Implication.L04succ_inj msgid "" @@ -2483,10 +2627,11 @@ msgstr "现在在 `h` 处反向重写 `succ_eq_add_one` 来得到右边式子。 #: 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`." +"the other way around. Look at the docs for `rw` for an explanation. Type `←` " +"with `\\l`." msgstr "" -"你可以在提供给 `rw` 的任何定理前面放一个 `←` 来进行反向重写。查看 `rw` 的文档以获得解释。使用 `\\l` " -"输入 `←`。" +"你可以在提供给 `rw` 的任何定理前面放一个 `←` 来进行反向重写。查看 `rw` 的文档" +"以获得解释。使用 `\\l` 输入 `←`。" #: Game.Levels.Implication.L04succ_inj msgid "Concretely: `rw [← succ_eq_add_one] at h`." @@ -2497,8 +2642,8 @@ 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` 的证" -"据。" +"现在让我们应用（ `apply` ）我们的新定理。执行 `apply succ_inj at h` 来将 `h` " +"变为证明 `x = 3` 的证据。" #: Game.Levels.Implication.L04succ_inj msgid "Now finish in one line." @@ -2506,7 +2651,8 @@ msgstr "现在再用一行完成证明。" #: Game.Levels.Implication.L04succ_inj msgid "" -"And now we've deduced what we wanted to prove: the goal is one of our assumptions.\n" +"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 "" "现在我们已经推导出了我们想要证明的了：目标是我们的假设之一。\n" @@ -2563,7 +2709,8 @@ 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" +"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" @@ -2580,13 +2727,16 @@ msgstr "intro" 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" +"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" +"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 "" @@ -2598,7 +2748,8 @@ msgstr "" "\n" "### 例子：\n" "\n" -"如果您的目标是 `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" "也同时更改为 $x=y$。" @@ -2606,13 +2757,14 @@ msgstr "" 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" +"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 "" "我们已经看到了如何 `apply` 形式为 `P → Q` 的定理和假设。\n" "但如果我们的 *目标* 是形式为 `P → Q` 的呢？\n" -"要证明这个目标，我们需要知道如何在 Lean 中表示 “假设 `P` 并推导出 `Q`”。我们用 `intro` 策略来做这件" -"事。" +"要证明这个目标，我们需要知道如何在 Lean 中表示 “假设 `P` 并推导出 `Q`”。我们" +"用 `intro` 策略来做这件事。" #: Game.Levels.Implication.L06intro msgid "$x=37\\implies x=37$." @@ -2632,7 +2784,8 @@ msgstr "练习 `intro` 策略" #: 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" +"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 "" "让我们看看您能否利用我们学到的策略来证明 $x+1=y+1\\implies x=y$。\n" @@ -2647,10 +2800,13 @@ msgid "Start with `intro h` to assume the hypothesis." msgstr "用 `intro h` 开始设假设。" #: Game.Levels.Implication.L07intro2 +#, fuzzy msgid "" "Now `repeat rw [← succ_eq_add_one] at h` is the quickest way to\n" -"change `succ x = succ y`." -msgstr "现在 `repeat rw [← succ_eq_add_one] at h` 是改写 `succ x = succ y` 的最快方法。" +"change `h` to `succ x = succ y`." +msgstr "" +"现在 `repeat rw [← succ_eq_add_one] at h` 是改写 `succ x = succ y` 的最快方" +"法。" #: Game.Levels.Implication.L07intro2 msgid "Now `apply succ_inj at h` to cancel the `succ`s." @@ -2692,22 +2848,26 @@ msgid "" "`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" +"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" +"`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 中表示“蕴含”的符号\n" +"我们仍然不能证明 `2 + 2 ≠ 5`，因为我们还没有讨论 `≠` 的定义。在 Lean 中，`a " +"≠ b` 是 `a = b → False` 的*符号表示*。这里的 `False` 是一个通用的假命题，`→` " +"是 Lean 中表示“蕴含”的符号\n" "。\n" -"在逻辑学中我们学到，`True → False` 是假的，但 `False → False` 是真的。因此，`X → false` 是 `X` 的逻辑" -"取反。\n" +"在逻辑学中我们学到，`True → False` 是假的，但 `False → False` 是真的。因此，" +"`X → false` 是 `X` 的逻辑取反。\n" "\n" -"尽管 `a ≠ b` 看起来不像蕴含，你应该将其视为蕴含。接下来的两关将向你展示怎样使用它。\n" +"尽管 `a ≠ b` 看起来不像蕴含，你应该将其视为蕴含。接下来的两关将向你展示怎样使" +"用它。\n" "\n" -"`False` 是一个无法从一致的假设集中推导出的目标！所以如果你的目标是 `False`，那么你最好希望你的假设是" -"矛盾的，就像在本关中一样。" +"`False` 是一个无法从一致的假设集中推导出的目标！所以如果你的目标是 `False`，" +"那么你最好希望你的假设是矛盾的，就像在本关中一样。" #: Game.Levels.Implication.L08ne msgid "If $x=y$ and $x \\neq y$ then we can deduce a contradiction." @@ -2717,9 +2877,12 @@ msgstr "如果 $x=y$ 且 $x \\neq y$ 那么我们可以推出矛盾。" 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`）于 `h1` 或直接应用于目标。" +msgstr "" +"记住，`h2` 是 `x = y → False` 的证明。尝试将 `h2` 应用（`apply`）于 `h1` 或直" +"接应用于目标。" #: Game.Levels.Implication.L08ne +#, fuzzy msgid "" "`a ≠ b` is *notation* for `(a = b) → False`.\n" "\n" @@ -2728,7 +2891,7 @@ msgid "" "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 use can treat `a ≠ b` in exactly\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" @@ -2767,8 +2930,8 @@ msgstr "" "\n" "在 Lean 中，`a ≠ b` *被定义为* `a = b → False`。\n" "因此，`zero_ne_succ n` 实际上是 `0 = succ n → False` 的证明。\n" -"这里的 `False` 是一个通用的假命题。这意味着如果 `h` 是 `0 = succ n` 的证明，你可以 `apply " -"zero_ne_succ at h`。" +"这里的 `False` 是一个通用的假命题。这意味着如果 `h` 是 `0 = succ n` 的证明，" +"你可以 `apply zero_ne_succ at h`。" #: Game.Levels.Implication.L09zero_ne_succ msgid "" @@ -2800,7 +2963,8 @@ msgstr "现在将 `h` 中的 `1` 改写为 `succ 0`。" msgid "Now you can `apply zero_ne_succ at h`." msgstr "现在可以使用 `apply zero_ne_succ at h`。" -#: Game.Levels.Implication.L09zero_ne_succ Game.Levels.AdvAddition.L01add_right_cancel +#: Game.Levels.Implication.L09zero_ne_succ +#: Game.Levels.AdvAddition.L01add_right_cancel msgid "Nice!" msgstr "好的！" @@ -2818,12 +2982,13 @@ msgid "" "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" +"我们知道 `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$。" +"`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.Implication.L10one_ne_zero msgid "" @@ -2843,7 +3008,8 @@ msgid "" msgstr "" "## 小结\n" "\n" -"`symm` 策略会将形如 `X = Y` 的目标或假设转换为 `Y = X`。它也适用于 `X ≠ Y` 和 `X ↔ Y`。\n" +"`symm` 策略会将形如 `X = Y` 的目标或假设转换为 `Y = X`。它也适用于 `X ≠ Y` " +"和 `X ↔ Y`。\n" "\n" "### 例子\n" "\n" @@ -2887,7 +3053,8 @@ msgstr "2 + 2 ≠ 5" #: 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" +"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 "" @@ -2910,12 +3077,15 @@ msgid "" "exact h\n" "```\n" "\n" -"Even though Lean is a theorem prover, right now it's pretty clear that we have not\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 \"Leave World\" and\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 \"Leave " +"World\" and\n" "decide your route." msgstr "" "这是一个证明：\n" @@ -2928,10 +3098,11 @@ msgstr "" "```\n" "\n" "\n" -"尽管 Lean 是一个定理证明器，但很明显我们还没有开发足够的材料使其成为一个合适的计算器。在算法世界，一" -"个更具计算机科学色彩的世界中，我们将开发使这类问题变得更容易的机制（比如快速证明 $20 + 20 \\neq " -"41$ ）。或者，你也可以在高级加法世界中进行更多数学学习，我们在那里证明了建立不等式理论所需的引理。点" -"击“离开世界”并决定你的路线。" +"尽管 Lean 是一个定理证明器，但很明显我们还没有开发足够的材料使其成为一个合适" +"的计算器。在算法世界，一个更具计算机科学色彩的世界中，我们将开发使这类问题变" +"得更容易的机制（比如快速证明 $20 + 20 \\neq 41$ ）。或者，你也可以在高级加法" +"世界中进行更多数学学习，我们在那里证明了建立不等式理论所需的引理。点击“离开世" +"界”并决定你的路线。" #: Game.Levels.Implication msgid "Implication World" @@ -2954,8 +3125,9 @@ msgid "" msgstr "" "我们已经证明了 $2+2=4$；在“蕴含世界”中，我们将学习如何证明 $2+2\\neq 5$。\n" "\n" -"在加法世界中，我们证明了像 $x + y = y + x$ 这样的*等式*。在这第二个教程世界中，我们将学习一些新的策" -"略，使我们能够证明像 $x+1=4 \\implies x=3$ 这样的*蕴含*。\n" +"在加法世界中，我们证明了像 $x + y = y + x$ 这样的*等式*。在这第二个教程世界" +"中，我们将学习一些新的策略，使我们能够证明像 $x+1=4 \\implies x=3$ 这样的*蕴" +"含*。\n" "\n" "我们还将学习关于自然数的两个新的基本事实，这些是皮亚诺作为公理引入的。\n" "\n" @@ -2972,7 +3144,8 @@ msgstr "`add_left_comm a b c` 是 `a + (b + c) = b + (a + c)` 的证明。" #: 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" +"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" @@ -2981,10 +3154,11 @@ msgid "" "`a + b + c` means `(a + b) + c`." msgstr "" "我们首先提醒您一点，手动使用交换律和结合律来重新排列变量是非常繁琐的。\n" -"`add_left_comm` 是我们将要解释的第一个算法中的关键组件，但我们需要手动证明它。\n" +"`add_left_comm` 是我们将要解释的第一个算法中的关键组件，但我们需要手动证明" +"它。\n" "\n" -"请记住，您可以使用 `rw [add_comm b c]` 之类的命令进行精确的交换律重写。并记住 `a + b + c` 表示 `(a + " -"b) + c`。" +"请记住，您可以使用 `rw [add_comm b c]` 之类的命令进行精确的交换律重写。并记" +"住 `a + b + c` 表示 `(a + b) + c`。" #: Game.Levels.Algorithm.L01add_left_comm msgid "If $a, b, c$ are numbers, then $a+(b+c)=b+(a+c)$." @@ -3007,12 +3181,13 @@ msgid "" "and then swap `b` and `d`. But this is easier than you\n" "think with `add_left_comm`." msgstr "" -"在一些后续的世界中，我们将看到一些更棘手的关卡，比如 `(a + a + 1) + (b + b + 1) = (a + b + 1) + (a + " -"b + 1)`。需要移动括号，还需要交换变量。\n" +"在一些后续的世界中，我们将看到一些更棘手的关卡，比如 `(a + a + 1) + (b + b + " +"1) = (a + b + 1) + (a + b + 1)`。需要移动括号，还需要交换变量。\n" "\n" -"在这个关卡中，`(a + b) + (c + d) = ((a + c) + d) + b`，让我们忘掉括号，只考虑变量的顺序。\n" -"要将 `a+b+c+d` 转换成 `a+c+d+b`，我们需要交换 `b` 和 `c`，然后交换 `b` 和 `d`。但是使用 " -"`add_left_comm` 比你想象的要简单。" +"在这个关卡中，`(a + b) + (c + d) = ((a + c) + d) + b`，让我们忘掉括号，只考虑" +"变量的顺序。\n" +"要将 `a+b+c+d` 转换成 `a+c+d+b`，我们需要交换 `b` 和 `c`，然后交换 `b` 和 " +"`d`。但是使用 `add_left_comm` 比你想象的要简单。" #: Game.Levels.Algorithm.L02add_algo1 msgid "" @@ -3023,7 +3198,8 @@ msgstr "" "$(a + b) + (c + d) = ((a + c) + d) + b.$" #: Game.Levels.Algorithm.L02add_algo1 -msgid "Start with `repeat rw [add_assoc]` to push all the brackets to the right." +msgid "" +"Start with `repeat rw [add_assoc]` to push all the brackets to the right." msgstr "从 `repeat rw [add_assoc]` 开始，将所有的括号推到右边。" #: Game.Levels.Algorithm.L02add_algo1 @@ -3055,20 +3231,25 @@ 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" +"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 的简化器 `simp` 将它将用每个用户提供给它的引理\n" "以及所有标记为 `simp` 的引理重写目标。\n" -"此外，如果提供了如`add_comm`这样的引理，它将尝试将对变量排序，以避免陷入无限循环。" +"此外，如果提供了如`add_comm`这样的引理，它将尝试将对变量排序，以避免陷入无限" +"循环。" #: 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" +"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." @@ -3088,7 +3269,9 @@ msgstr "" "$(d + f) + (h + (a + c)) + (g + e + b) = a + b + c + d + e + f + g + h$。" #: Game.Levels.Algorithm.L03add_algo2 -msgid "Solve this level in one line with `simp only [add_assoc, add_left_comm, add_comm]`" +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]` 在一行中证明这一关" #: Game.Levels.Algorithm.L03add_algo2 @@ -3147,7 +3330,8 @@ msgstr "pred" #: Game.Levels.Algorithm.L05pred msgid "" -"We now start work on an algorithm to do addition more efficiently. Recall that\n" +"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" @@ -3160,24 +3344,30 @@ msgid "" "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" +"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." +"Peano assumed as an axiom and which we have already used extensively without " +"justification." msgstr "" -"我们现在开始研究一个更高效进行加法计算的算法。回想一下，我们通过递归定义了加法，说明了它对 `0` 和后继" -"者的作用。Lean 的一个公理是递归是从像自然数这样的类型定义函数的有效方式。\n" +"我们现在开始研究一个更高效进行加法计算的算法。回想一下，我们通过递归定义了加" +"法，说明了它对 `0` 和后继者的作用。Lean 的一个公理是递归是从像自然数这样的类" +"型定义函数的有效方式。\n" "\n" -"让我们定义一个从自然数到自然数的新函数 `pred`，它试图从输入中减去 1。定义如下：\n" +"让我们定义一个从自然数到自然数的新函数 `pred`，它试图从输入中减去 1。定义如" +"下：\n" "\n" "```\n" "pred 0 := 37\n" "pred (succ n) := n\n" "```\n" "\n" -"我们不能从 0 中减去 1，所以我们只是返回一个无用的值。除了这个定义之外，我们还创建了一个新的引理 " -"`pred_succ`，它说 `pred (succ n) = n`。让我们使用这个引理来证明 `succ_inj`，这是皮亚诺假设为公理的定" -"理，我们在没有证明它的情况下已经广泛使用了。" +"我们不能从 0 中减去 1，所以我们只是返回一个无用的值。除了这个定义之外，我们还" +"创建了一个新的引理 `pred_succ`，它说 `pred (succ n) = n`。让我们使用这个引理" +"来证明 `succ_inj`，这是皮亚诺假设为公理的定理，我们在没有证明它的情况下已经广" +"泛使用了。" #: Game.Levels.Algorithm.L05pred msgid "`pred_succ n` is a proof of `pred (succ n) = n`." @@ -3212,14 +3402,19 @@ msgid "" "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" +"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." +"If you can turn your goal into `True`, then the `trivial` tactic will solve " +"it." msgstr "" "我们这样定义一个函数 `is_zero` ：\n" "\n" @@ -3228,9 +3423,12 @@ msgstr "" "is_zero (succ n) := False\n" "```\n" "\n" -"我们还创建两个引理 `is_zero_zero` 和 `is_zero_succ n`，表示 `is_zero 0 = True`\n" -"和 `is_zero (succ n) = False`。让我们使用这些引理来证明 `succ_ne_zero`，Peano 的\n" -"最后的公理。实际上，我们之前一直在使用 `zero_ne_succ`，但是有一个逆向的版本会很方便。\n" +"我们还创建两个引理 `is_zero_zero` 和 `is_zero_succ n`，表示 `is_zero 0 = " +"True`\n" +"和 `is_zero (succ n) = False`。让我们使用这些引理来证明 `succ_ne_zero`，" +"Peano 的\n" +"最后的公理。实际上，我们之前一直在使用 `zero_ne_succ`，但是有一个逆向的版本会" +"很方便。\n" "它可以用同样的方式证明。注意：你可以\n" "通过使用 `zero_ne_succ` 在这里作弊，但这个世界的重点是展示\n" "你如何 *证明* 这样的结果。\n" @@ -3274,8 +3472,8 @@ 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]` 把它变成 `is_zero (succ " -"a)`。" +"我们将要把那个 `False` 变成 `True`。首先通过执行 `rw [← is_zero_succ a]` 把它" +"变成 `is_zero (succ a)`。" #: Game.Levels.Algorithm.L06is_zero msgid "" @@ -3290,7 +3488,8 @@ msgstr "用于证明等价的算法" #: 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" +"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" @@ -3300,12 +3499,16 @@ msgid "" "\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" +"*) 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" +"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" +"`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" @@ -3316,10 +3519,11 @@ msgstr "" "* 如果一个是 `0` 而另一个是 `succ n`，返回“否”。\n" "* 如果 `a = succ m` 且 `b = succ n`，那么返回对“`m = n`？”的答案。\n" "\n" -"现在我们的任务是*证明*这个算法总能给出正确的答案。证明 `0 = 0` 是 `rfl`。证明 `0 ≠ succ n` 的是 " -"`zero_ne_succ n`，证明 `succ m ≠ 0` 的是 `succ_ne_zero m`。如果有假设 `h : m = n`，那么证明 `succ m " -"= succ n` 可以使用 `rw [h]` 然后 `rfl`。这一关是证明我们要做的剩余工作之一：如果 `a ≠ b`，那么 `succ " -"a ≠ succ b`。" +"现在我们的任务是*证明*这个算法总能给出正确的答案。证明 `0 = 0` 是 `rfl`。证" +"明 `0 ≠ succ n` 的是 `zero_ne_succ n`，证明 `succ m ≠ 0` 的是 `succ_ne_zero " +"m`。如果有假设 `h : m = n`，那么证明 `succ m = succ n` 可以使用 `rw [h]` 然" +"后 `rfl`。这一关是证明我们要做的剩余工作之一：如果 `a ≠ b`，那么 `succ a ≠ " +"succ b`。" #: Game.Levels.Algorithm.L07succ_ne_succ msgid "" @@ -3333,7 +3537,8 @@ msgid "" "\n" "`c ≠ d`\n" "\n" -"then `contrapose! h` replaces the set-up with its so-called \\\"contrapositive\\\":\n" +"then `contrapose! h` replaces the set-up with its so-called \\" +"\"contrapositive\\\":\n" "a hypothesis\n" "\n" "`h : c = d`\n" @@ -3366,20 +3571,29 @@ 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.Algorithm.L07succ_ne_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)$。" +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.Algorithm.L07succ_ne_succ +#, fuzzy msgid "" "Start with `contrapose! h`, to change the goal into its\n" -"contrapositive, namely a hypothesis of `succ m = succ m` and a goal of `m = n`." -msgstr "从 `contrapose! h` 开始，将目标转变为其逆否命题，即假设为 `succ m = succ m`，目标为 `m = n`。" +"contrapositive, namely a hypothesis of `succ m = succ n` and a goal of `m = " +"n`." +msgstr "" +"从 `contrapose! h` 开始，将目标转变为其逆否命题，即假设为 `succ m = succ m`，" +"目标为 `m = n`。" #: 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`，它会把你带回到开始的地方！）" +msgstr "" +"你能处理接下来的证明吗？（注意：如果你再次尝试 `contrapose! h`，它会把你带回" +"到开始的地方！）" #: Game.Levels.Algorithm.L08decide msgid "decide" @@ -3394,8 +3608,10 @@ msgid "" "\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" +"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" @@ -3404,13 +3620,15 @@ msgstr "" "\n" "### 示例\n" "\n" -"类型为 `DecidableEq ℕ` 的项是用于判断两个自然数是否相等或不同的算法（的实现函数）。\n" -"因此，一旦这个项被创建并成为一个 `instance`，`decide` 策略就可以使用它来解决形式为 `a = b` 或 `a ≠ " -"b` 的目标。" +"类型为 `DecidableEq ℕ` 的项是用于判断两个自然数是否相等或不同的算法（的实现函" +"数）。\n" +"因此，一旦这个项被创建并成为一个 `instance`，`decide` 策略就可以使用它来解决" +"形式为 `a = b` 或 `a ≠ b` 的目标。" #: Game.Levels.Algorithm.L08decide msgid "" -"Implementing the algorithm for equality of naturals, and the proof that it is correct,\n" +"Implementing the algorithm for equality of naturals, and the proof that it " +"is correct,\n" "looks like this:\n" "\n" "```\n" @@ -3465,7 +3683,8 @@ msgstr "" "```\n" "\n" "这段 Lean 代码是一个用于判断两个自然数之间等式的正式验证算法。\n" -"我已经在游戏幕后输入了它。因为这个算法已经正式验证为正确，我们可以在 Lean 证明中使用它。\n" +"我已经在游戏幕后输入了它。因为这个算法已经正式验证为正确，我们可以在 Lean 证" +"明中使用它。\n" "你可以用 `decide` 策略运行这个算法。" #: Game.Levels.Algorithm.L08decide @@ -3483,7 +3702,9 @@ msgid "decide again" msgstr "还是`decide`" #: Game.Levels.Algorithm.L09decide2 -msgid "We gave a pretty unsatisfactory proof of `2 + 2 ≠ 5` earlier on; now give a nicer one." +msgid "" +"We gave a pretty unsatisfactory proof of `2 + 2 ≠ 5` earlier on; now give a " +"nicer one." msgstr "我们前面给出的 `2 + 2 ≠ 5` 证明并不令人满意，现在给出一个更好的证明。" #: Game.Levels.Algorithm.L09decide2 @@ -3491,9 +3712,11 @@ msgid "$2+2 \\neq 5.$" msgstr "$2+2 \\neq 5.$" #: Game.Levels.Algorithm.L09decide2 +#, fuzzy msgid "" "Congratulations! You've finished Algorithm World. These algorithms\n" -"will be helpful for you in Even-Odd World." +"will be helpful for you in Even-Odd World (when someone gets around to\n" +"implementing it)." msgstr "" "恭喜！您已经完成了《算法世界》。这些算法\n" "将对您在奇偶世界中有所帮助。" @@ -3504,13 +3727,14 @@ msgstr "算法世界" #: 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" +"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$ 这样的证明如果手工完成会非常繁琐。在算法世界中，我们将学习如何让" -"计算机帮我们完成它们。\n" +"像 $2+2=4$ 和 $a+b+c+d+e=e+d+c+b+a$ 这样的证明如果手工完成会非常繁琐。在算法" +"世界中，我们将学习如何让计算机帮我们完成它们。\n" "\n" "点击“开始”继续。" @@ -3551,10 +3775,11 @@ 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`." +"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` 推导出它。" +"`add_left_cancel a b n` 是定理 $n+a=n+b\\implies a=b$。你可以通过对 `n` 进行" +"归纳来证明它，或者你可以从 `add_right_cancel` 推导出它。" #: Game.Levels.AdvAddition.L02add_left_cancel msgid "$n+a=n+b\\implies a=b$." @@ -3593,8 +3818,10 @@ msgstr "$x + y = y\\implies x=0$ 。" #: 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" +"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" @@ -3605,9 +3832,10 @@ msgid "" "```" msgstr "" "你是否对 `y` 使用了归纳法？\n" -"这里有一个使用 `add_right_cancel` 证明 `add_left_eq_self`的两行证明。如果你想查看它，你可以通过点击右" -"上角的 `` 进入编辑器模式，然后只需剪切和粘贴证明，并在其周围移动你的光标，以查看在任何给定点的假设" -"和目标（尽管这样做你会失去自己的证明）。点击 `>_` 返回命令行模式。\n" +"这里有一个使用 `add_right_cancel` 证明 `add_left_eq_self`的两行证明。如果你想" +"查看它，你可以通过点击右上角的 `` 进入编辑器模式，然后只需剪切和粘贴证明，" +"并在其周围移动你的光标，以查看在任何给定点的假设和目标（尽管这样做你会失去自" +"己的证明）。点击 `>_` 返回命令行模式。\n" "```\n" "nth_rewrite 2 [← zero_add y]\n" "exact add_right_cancel x 0 y\n" @@ -3626,7 +3854,8 @@ 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$ 的定理。我想到了两种方法，等你解出来了我再提。" +"`add_right_eq_self x y` 是 $x + y = x\\implies y=0$ 的定理。我想到了两种方" +"法，等你解出来了我再提。" #: Game.Levels.AdvAddition.L04add_right_eq_self msgid "$x+y=x\\implies y=0$." @@ -3634,6 +3863,14 @@ msgstr "$x+y=x\\implies y=0$." #: 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 "" + +#: Game.Levels.AdvAddition.L04add_right_eq_self +#, fuzzy +msgid "" "Here's a proof using `add_left_eq_self`:\n" "```\n" "rw [add_comm]\n" @@ -3648,20 +3885,18 @@ msgid "" "exact add_left_eq_self y x\n" "```\n" "\n" -"Alternatively you can just prove it by induction on `x`\n" -"(the dots in the proof just indicate the two goals and\n" -"can be omitted):\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" -" assumption\n" -" · intro h\n" -" rw [succ_add] at h\n" -" apply succ_inj at h\n" -" apply hd at h\n" -" assumption\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" @@ -3700,24 +3935,32 @@ msgstr "add_right_eq_zero" #: 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" +"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" +"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" +"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." +"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 "" "在这一关中，让我们证明其中一个事实，而在下一关证明另一个。\n" "\n" @@ -3725,75 +3968,88 @@ msgstr "" "\n" "`cases` 策略会将一个对象或假设分解为可能的创建方式。\n" "\n" -"例如，有时你想分别处理 `b = 0` 和 `b = succ d` 这两种情况，但不需要与 `induction b with d hd` 一起来" -"的归纳假设 `hd`。在这种情况下，你可以使用 `cases b with d`。制造一个数字有两种方式：它要么是零，要么" -"是后继者。所以你最终会得到两个目标，一个是 `b = 0`，另一个是 `b = succ d`。\n" +"例如，有时你想分别处理 `b = 0` 和 `b = succ d` 这两种情况，但不需要与 " +"`induction b with d hd` 一起来的归纳假设 `hd`。在这种情况下，你可以使用 " +"`cases b with d`。制造一个数字有两种方式：它要么是零，要么是后继者。所以你最" +"终会得到两个目标，一个是 `b = 0`，另一个是 `b = succ d`。\n" "\n" -"另一个例子：如果你有一个假设 `h : False`，那么你就完成证明了，因为从 `False` 可以推出任何证明。这里 " -"`cases h` 将证明目标，因为没有 *任何* 方法可以证明 `False`！所以你最终会没有目标，意味着你已经证明了" -"一切。" +"另一个例子：如果你有一个假设 `h : False`，那么你就完成证明了，因为从 `False` " +"可以推出任何证明。这里 `cases h` 将证明目标，因为没有 *任何* 方法可以证明 " +"`False`！所以你最终会没有目标，意味着你已经证明了一切。" #: 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" +"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" +"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" +"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" +"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" +"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" +"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` 会将目标分解成两个目标，一个是 `n = 0`，另一个是 `n = " -"succ d`。\n" +"如果 `n` 是一个数字，那么 `cases n with d` 会将目标分解成两个目标，一个是 `n " +"= 0`，另一个是 `n = succ d`。\n" "\n" -"如果 `h` 是一个证明（例如一个假设），那么 `cases h with...` 会将证明分解成用来证明它的各个部分。\n" +"如果 `h` 是一个证明（例如一个假设），那么 `cases h with...` 会将证明分解成用" +"来证明它的各个部分。\n" "\n" "## 示例\n" "\n" -"如果 `n : ℕ` 是一个数字，那么 `cases n with d` 会将目标分解成两个目标，一个是 `n` 被替换为 0，另一个" -"是 `n` 被替换为 `succ d`。这对应于数学上的观点，即每个自然数要么是 `0`，要么是一个后继数。\n" +"如果 `n : ℕ` 是一个数字，那么 `cases n with d` 会将目标分解成两个目标，一个" +"是 `n` 被替换为 0，另一个是 `n` 被替换为 `succ d`。这对应于数学上的观点，即每" +"个自然数要么是 `0`，要么是一个后继数。\n" "\n" "## 示例\n" "\n" -"如果 `h : P ∨ Q` 是一个假设，那么 `cases h with hp hq` 会将一个目标变成两个目标，一个有假设 `hp : " -"P`，另一个有假设 `hq : Q`。\n" +"如果 `h : P ∨ Q` 是一个假设，那么 `cases h with hp hq` 会将一个目标变成两个目" +"标，一个有假设 `hp : P`，另一个有假设 `hq : Q`。\n" "\n" "## 示例\n" "\n" -"如果 `h : False` 是一个假设，那么 `cases h` 会将一个目标变成没有目标，因为没有方法可以证明 `False`！" -"如果你没有剩余的目标，你就完成了这个关卡。\n" +"如果 `h : False` 是一个假设，那么 `cases h` 会将一个目标变成没有目标，因为没" +"有方法可以证明 `False`！如果你没有剩余的目标，你就完成了这个关卡。\n" "\n" "## 示例\n" "\n" -"如果 `h : a ≤ b` 是一个假设，那么 `cases h with c hc` 会创建一个新的数字 `c` 和一个证明 `hc : b = a " -"+ c`。这是因为 `a ≤ b` 的*定义*是 `∃ c, b = a + c`。" +"如果 `h : a ≤ b` 是一个假设，那么 `cases h with c hc` 会创建一个新的数字 `c` " +"和一个证明 `hc : b = a + c`。这是因为 `a ≤ b` 的*定义*是 `∃ c, b = a + c`。" #: Game.Levels.AdvAddition.L05add_right_eq_zero msgid "A proof that $a+b=0 \\implies a=0$." @@ -3821,7 +4077,8 @@ msgstr "add_left_eq_zero" #: 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" +"You can just mimic the previous proof to do this one -- or you can figure " +"out a way\n" "of using it." msgstr "" "你可以模仿之前的证明来完成这个——或者你可以想出一种方法\n" @@ -3870,8 +4127,8 @@ msgid "" "\n" "Click on \"Start\" to proceed." msgstr "" -"在高级加法世界中，我们将证明一些基本的加法事实，如 $x+y=x\\implies y=0$。在这个世界中证明的定理将被用" -"来在 `≤` 世界中构建不等式理论。\n" +"在高级加法世界中，我们将证明一些基本的加法事实，如 $x+y=x\\implies y=0$。在这" +"个世界中证明的定理将被用来在 `≤` 世界中构建不等式理论。\n" "\n" "点击“开始”继续。" @@ -3880,6 +4137,7 @@ msgid "The `use` tactic" msgstr "`use` 策略" #: Game.Levels.LessOrEqual.L01le_refl +#, fuzzy msgid "" "## Summary\n" "\n" @@ -3887,9 +4145,17 @@ msgid "" "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" +"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`." +"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 "" "## 概述\n" "\n" @@ -3915,8 +4181,8 @@ msgstr "" "\n" "因为这个游戏没有负数，这个定义在数学上是有效的。\n" "\n" -"这意味着如果你有一个形式为 `a ≤ b` 的目标，你可以用 `use` 策略来取得进展，如果你有一个假设 `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 "" @@ -3928,8 +4194,9 @@ msgid "" "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` 意味着存在一个数字 `c` " -"使得 `b = a + c`。这个定义有效是因为在这个游戏中没有负数。\n" +"`a ≤ b` 是 `∃ c, b = a + c` 的*符号表示*。这个“倒 E”代表“存在”。所以 `a ≤ b` " +"意味着存在一个数字 `c` 使得 `b = a + c`。这个定义有效是因为在这个游戏中没有负" +"数。\n" "\n" "要*证明*一个“存在性”定理，可以使用 `use` 策略。\n" "让我们看一个例子。" @@ -3965,7 +4232,8 @@ msgid "0 ≤ x" msgstr "0 ≤ x" #: Game.Levels.LessOrEqual.L02zero_le -msgid "To solve this level, you need to `use` a number `c` such that `x = 0 + c`." +msgid "" +"To solve this level, you need to `use` a number `c` such that `x = 0 + c`." msgstr "要通过本关卡，您需要 `use` 一个数字 `c` 使得 `x = 0 + c`。" #: Game.Levels.LessOrEqual.L02zero_le @@ -4026,10 +4294,13 @@ msgid "" "\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" +"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" +"$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`。\n" @@ -4041,12 +4312,14 @@ msgstr "" "在 Lean 中，`a + b + c` 表示 `(a + b) + c`，因为 `+` 是左关联。但是\n" "`→` 是右关联式。这意味着Lean中的 `x ≤ y → y ≤ z → x ≤ z` 表示\n" "`≤` 是传递式的。这与数学家使用\n" -"$P\\implies Q\\implies R$ 的用法不同；对他们来说，这通常意味着 $P\\implies Q$\n" +"$P\\implies Q\\implies R$ 的用法不同；对他们来说，这通常意味着 $P\\implies " +"Q$\n" "和 $Q\\implies R$。" #: Game.Levels.LessOrEqual.L04le_trans msgid "" -"In this level, we see inequalities as *hypotheses*. We have not seen this before.\n" +"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 "" "在本关，我们将不等视为 *假设* 。我们以前没有见过这个。\n" @@ -4062,22 +4335,27 @@ msgstr "从 `cases «{hxy}» with a ha` 开始。" #: Game.Levels.LessOrEqual.L04le_trans msgid "" -"Now `«{ha}»` is a proof that `«{y}» = «{x}» + «{a}»`, and `hxy` has vanished. Similarly, you can " -"destruct\n" +"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` 已经消失了。同样，你可以通过 `cases " -"«{hyz}» with b hb` 将 `«{hyz}»` 分解。" +"现在 `«{ha}»` 是 `«{y}» = «{x}» + «{a}»`, 的证明，而 `hxy` 已经消失了。同样，" +"你可以通过 `cases «{hyz}» with b hb` 将 `«{hyz}»` 分解。" #: Game.Levels.LessOrEqual.L04le_trans -msgid "Now you need to figure out which number to `use`. See if you can take it from here." +msgid "" +"Now you need to figure out which number to `use`. See if you can take it " +"from here." msgstr "现在你需要弄清楚使用（ `use` ）哪个数字。看看你是否可以从这里继续。" #: Game.Levels.LessOrEqual.L04le_trans msgid "" -"A passing mathematician remarks that with reflexivity and transitivity out of the way,\n" +"A passing mathematician remarks that with reflexivity and transitivity out " +"of the way,\n" "you have proved that `≤` is a *preorder* on `ℕ`." -msgstr "一个路过的数学家指出，随着自反性和传递性的解决，你已经证明了 `≤` 是 `ℕ` 上的一个*预序*。" +msgstr "" +"一个路过的数学家指出，随着自反性和传递性的解决，你已经证明了 `≤` 是 `ℕ` 上的" +"一个*预序*。" #: Game.Levels.LessOrEqual.L05le_zero msgid "x ≤ 0 → x = 0" @@ -4108,7 +4386,9 @@ msgstr "如果是 $x \\leq 0$，那么 $x=0$。" 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` 开始。" +msgstr "" +"你想使用 `add_right_eq_zero`，这是你已经证明过的，但你需要从对你的假设使用 " +"`symm at` 开始。" #: Game.Levels.LessOrEqual.L06le_antisymm msgid "x ≤ y and y ≤ x implies x = y" @@ -4124,8 +4404,8 @@ msgid "" "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 "" -"这一关卡要求你证明 $\\leq$ 的 *反对称性* 。换句话说，如果 $x \\leq y$ 且 $y \\leq x$，那么 $x = y" -"$。\n" +"这一关卡要求你证明 $\\leq$ 的 *反对称性* 。换句话说，如果 $x \\leq y$ 且 $y " +"\\leq x$，那么 $x = y$。\n" "这是本游戏到目前最棘手的证明之一。祝你好运！" #: Game.Levels.LessOrEqual.L06le_antisymm @@ -4168,7 +4448,8 @@ msgstr "" "```\n" "\n" "\n" -"一位路过的数学家评论说，你已经运用“反对称性”证明了 `≤` 在 `ℕ` 上是一个*偏序*。\n" +"一位路过的数学家评论说，你已经运用“反对称性”证明了 `≤` 在 `ℕ` 上是一个*偏序" +"*。\n" "\n" "这个世界中的 Boss 关卡是证明 `≤` 是一个全序。我们先学习两个更简单的策略。" @@ -4190,8 +4471,8 @@ msgid "" "one." msgstr "" "## 概述\n" -"`left` 策略将目标 `P ∨ Q` 转换为目标 `P`。当您的假设保证 `P ∨ Q` 为真的原因是由于 `P` 为真时，请使用" -"它。\n" +"`left` 策略将目标 `P ∨ Q` 转换为目标 `P`。当您的假设保证 `P ∨ Q` 为真的原因是" +"由于 `P` 为真时，请使用它。\n" "\n" "在内部，这个策略只是应用了一个定理，该定理是 $P\\implies P\\lor Q$ 。\n" "\n" @@ -4220,7 +4501,8 @@ msgstr "" #: 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" +"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" @@ -4235,21 +4517,26 @@ msgid "" "`cases h with h1 h2` will create two goals, one where you went left,\n" "and the other where you went right." msgstr "" -"`≤`的完全性是这个世界的Boss关卡了，接下来就是它了。它表明如果`a`和`b`是自然数，\n" -"那么`a ≤ b`或`b ≤ a`。但我们根本没有讨论过“或”（`or`）。这里有一个简要说明。\n" +"`≤`的完全性是这个世界的Boss关卡了，接下来就是它了。它表明如果`a`和`b`是自然" +"数，\n" +"那么`a ≤ b`或`b ≤ a`。但我们根本没有讨论过“或”（`or`）。这里有一个简要说" +"明。\n" "\n" "1. “或”的符号是`∨`，你可以用`\\or`来输入它。\n" -"2. 如果你的 *目标* 是一个“或”命题，那么有两个策略可以取得进展：`left`和`right`。\n" +"2. 如果你的 *目标* 是一个“或”命题，那么有两个策略可以取得进展：`left`和" +"`right`。\n" "但除非你的知道哪边是真的，否则不要选择一个方向。\n" -"3. 如果你在 *假设* 中有一个“或”命题`h`，那么`cases h with h1 h2`会创建两个目标，一个假设左边是真的，" -"另一个假设右边是真的。" +"3. 如果你在 *假设* 中有一个“或”命题`h`，那么`cases h with h1 h2`会创建两个目" +"标，一个假设左边是真的，另一个假设右边是真的。" #: 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.LessOrEqual.L07or_symm -msgid "We don't know whether to go left or right yet. So start with `cases «{h}» with hx hy`." +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.LessOrEqual.L07or_symm @@ -4286,8 +4573,9 @@ msgid "" "I've left hidden hints; if you need them, retry from the beginning\n" "and click on \"Show more help!\"" msgstr "" -"我认为这是迄今为止最难的关卡。提示：如果 `a` 是一个数字，那么 `cases a with b` 会分解为 `a = 0` 和 " -"`a = succ b` 两种情况。不要在你的假设不能保证你能证明最终目标之前选择证明左边或右边！\n" +"我认为这是迄今为止最难的关卡。提示：如果 `a` 是一个数字，那么 `cases a with " +"b` 会分解为 `a = 0` 和 `a = succ b` 两种情况。不要在你的假设不能保证你能证明" +"最终目标之前选择证明左边或右边！\n" "\n" "我留下了一些隐藏的提示；如果你需要，请从头开始重试并点击“显示更多帮助”！" @@ -4315,7 +4603,8 @@ msgstr "你仍然不知道该走哪个分支，所以要做 `cases «{e}» with msgid "" "Very well done.\n" "\n" -"A passing mathematician remarks that with you've just proved that `ℕ` is totally\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." @@ -4345,8 +4634,11 @@ msgstr "" "这个引理对证明它们将是有帮助的。" #: 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$。" +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.LessOrEqual.L09succ_le_succ msgid "" @@ -4425,7 +4717,8 @@ msgid "le_two" msgstr "le_two" #: 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`." +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.LessOrEqual.L11le_two @@ -4438,8 +4731,8 @@ msgid "" msgstr "" "我们需要这个引理来证明二是质数！\n" "\n" -"你需要知道 `∨` 是右结合的。这意味着 `x = 0 ∨ x = 1 ∨ x = 2` 实际上意味着 `x = 0 ∨ (x = 1 ∨ x = 2)`。" -"这会影响 `left` 和 `right` 的工作方式。" +"你需要知道 `∨` 是右结合的。这意味着 `x = 0 ∨ x = 1 ∨ x = 2` 实际上意味着 `x " +"= 0 ∨ (x = 1 ∨ x = 2)`。这会影响 `left` 和 `right` 的工作方式。" #: Game.Levels.LessOrEqual.L11le_two msgid "If $x \\leq 2$ then $x = 0$ or $1$ or $2$." @@ -4457,7 +4750,8 @@ msgstr "" "很棒！\n" "\n" "发展序理论的下一步是发展 `≤` 与乘法之间相互作用的理论。\n" -"如果你已经完成了乘法世界，那么就可以进入高级乘法世界。点击 \"离开世界 \"进入。" +"如果你已经完成了乘法世界，那么就可以进入高级乘法世界。点击 \"离开世界 \"进" +"入。" #: Game.Levels.LessOrEqual msgid "≤ World" @@ -4475,10 +4769,11 @@ msgid "" "\n" "Click on \"Start\" to proceed." msgstr "" -"在这个世界中，我们定义 `a ≤ b` 并证明关于它的一些事实，例如“如果 `a ≤ b` 且 `b ≤ c` 那么 `a ≤ c`。”\n" +"在这个世界中，我们定义 `a ≤ b` 并证明关于它的一些事实，例如“如果 `a ≤ b` 且 " +"`b ≤ c` 那么 `a ≤ c`。”\n" "\n" -"`a ≤ b` 的定义是“存在一个数字 `c` 使得 `b = a + c`。”所以我们将不得不学习一种策略来证明“存在”定理，以" -"及另一种策略来使用“存在”假设。\n" +"`a ≤ b` 的定义是“存在一个数字 `c` 使得 `b = a + c`。”所以我们将不得不学习一种" +"策略来证明“存在”定理，以及另一种策略来使用“存在”假设。\n" "\n" "点击“开始”继续。" @@ -4522,7 +4817,8 @@ msgstr "`mul_left_ne_zero a b` 是`a * b ≠ 0 → b ≠ 0` 的证明。" #: Game.Levels.AdvMultiplication.L02mul_left_ne_zero msgid "" -"If you have completed Algorithm World then you can use the `contrapose!` tactic\n" +"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!` 策略。\n" @@ -4531,11 +4827,15 @@ msgstr "" #: 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." +"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` 和目标 `a * b = 0`，这在逻辑上是等价的，但更容易证明。\n" -"记住，`x ≠ 0` 是 `x = 0 → False` 的符号表示。如果你需要提示，请点击`显示更多帮助！`。" +"我们想将这个问题简化为假设 `b = 0` 和目标 `a * b = 0`，这在逻辑上是等价的，但" +"更容易证明。\n" +"记住，`x ≠ 0` 是 `x = 0 → False` 的符号表示。如果你需要提示，请点击`显示更多" +"帮助！`。" #: Game.Levels.AdvMultiplication.L02mul_left_ne_zero msgid "Start with `intro hb`." @@ -4550,12 +4850,29 @@ msgid "eq_succ_of_ne_zero" msgstr "eq_succ_of_ne_zero" #: Game.Levels.AdvMultiplication.L03eq_succ_of_ne_zero +#, fuzzy msgid "" "# Summary\n" "\n" -"The `tauto` tactic will solve any goal which can be solved purely by logic (that is, by\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" @@ -4567,20 +4884,33 @@ msgid "" "\n" "## Example\n" "\n" -"If you have two hypotheses `h1 : a = 37` and `h2 : a ≠ 37` then `tauto` will\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" +"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 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." +"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" @@ -4588,7 +4918,8 @@ msgstr "" "\n" "### 示例\n" "\n" -"如果你有一个假设为 `False`，那么 `tauto` 将解决目标。这是因为一个假的假设意味着任何假设。\n" +"如果你有一个假设为 `False`，那么 `tauto` 将解决目标。这是因为一个假的假设意味" +"着任何假设。\n" "\n" "### 示例\n" "\n" @@ -4596,18 +4927,19 @@ msgstr "" "\n" "### 示例\n" "\n" -"如果你有两个假设 `h1 : a = 37` 和 `h2 : a ≠ 37`，那么 `tauto` 将解决目标，因为它可以从你的假设中证明 " -"`False`，从而证明目标（因为 `False` 意味着任何事情）。\n" +"如果你有两个假设 `h1 : a = 37` 和 `h2 : a ≠ 37`，那么 `tauto` 将解决目标，因" +"为它可以从你的假设中证明 `False`，从而证明目标（因为 `False` 意味着任何事" +"情）。\n" "\n" "### 示例\n" "\n" -"如果你有一个假设 `h : a ≠ a`，那么 `tauto` 将解决目标，因为 `tauto` 足够聪明以知道 `a = a` 是真的，这" -"提供了我们寻求的矛盾。\n" +"如果你有一个假设 `h : a ≠ a`，那么 `tauto` 将解决目标，因为 `tauto` 足够聪明" +"以知道 `a = a` 是真的，这提供了我们寻求的矛盾。\n" "\n" "### 示例\n" "\n" -"如果你有一个形式为 `a = 0 → a * b = 0` 的假设，而你的目标是 `a * b ≠ 0 → a ≠ 0`，那么 `tauto` 将解决" -"目标，因为目标在逻辑上等同于假设。\n" +"如果你有一个形式为 `a = 0 → a * b = 0` 的假设，而你的目标是 `a * b ≠ 0 → a ≠ " +"0`，那么 `tauto` 将解决目标，因为目标在逻辑上等同于假设。\n" "如果你在这个示例中交换目标和假设，`tauto` 也会解决它。\n" "如果你有两个假设 `h1 : a = 37` 和 `h2 : a ≠ 37` 那么 `tauto` 将解决目标\n" "就能解决这个目标，因为它能从你的假设中证明 `False`，从而\n" @@ -4620,7 +4952,8 @@ msgstr "" "\n" "### 示例\n" "\n" -"如果你有一个形式为 `a = 0 → a * b = 0` 的假设，而你的目标是 `a * b ≠ 0 → a ≠ 0`，那么\n" +"如果你有一个形式为 `a = 0 → a * b = 0` 的假设，而你的目标是 `a * b ≠ 0 → a ≠ " +"0`，那么\n" "`tauto` 将证明目标，因为目标在逻辑上等同于假设。\n" "如果把这个例子中的目标和假设换一下，`tauto` 也会解决它。" @@ -4629,29 +4962,35 @@ 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.AdvMultiplication.L03eq_succ_of_ne_zero +#, fuzzy msgid "" -"Multiplication usually makes a number bigger, but multiplication by zero can make\n" +"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 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" +"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 "" -"乘法通常会使一个数字变大，但是乘以零可以使它变小。因此，关于不等式和乘法的许多引理需要假设 `a ≠ " -"0`。\n" -"这里有一个关键的引理使我们能够使用这个假设。我们可以使用 `tauto` 策略帮助我们进行证明。点击右侧的策略" -"名称查看它的作用。" +"乘法通常会使一个数字变大，但是乘以零可以使它变小。因此，关于不等式和乘法的许" +"多引理需要假设 `a ≠ 0`。\n" +"这里有一个关键的引理使我们能够使用这个假设。我们可以使用 `tauto` 策略帮助我们" +"进行证明。点击右侧的策略名称查看它的作用。" #: 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`." +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.AdvMultiplication.L03eq_succ_of_ne_zero msgid "" -"In the \"base case\" we have a hypothesis `ha : 0 ≠ 0`, and you can deduce anything\n" +"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` 策略将证明这" -"个目标。" +"在“基础情形”中，我们有一个假设 `ha : 0 ≠ 0`，你可以从一个假命题中推导出任何东" +"西。`tauto` 策略将证明这个目标。" #: Game.Levels.AdvMultiplication.L04one_le_of_ne_zero msgid "one_le_of_ne_zero" @@ -4689,16 +5028,24 @@ msgstr "" "这是表达一个正数的除数不会大于这个数的一种方式。" #: Game.Levels.AdvMultiplication.L05le_mul_right +#, fuzzy msgid "" -"In Prime Number World we will be proving that $2$ is prime.\n" -"To do this, we will have to rule out things like $2 ≠ 37 × 42.$\n" +"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 pretty much everything which we've proved in this world so far." +"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$ 这样的情况。\n" -"我们将通过证明 $2$ 的任何因数最多是 $2$ 来做到这一点，我们将使用这个引理来实现。\n" -"我脑海中的证明会操作假设，直到它变成目标，几乎使用我们到目前为止在这个世界中已经证明的所有内容。" +"在质数世界中，我们将证明 $2$ 是质数。为此，我们必须排除像 $2 ≠ 37 × 42$ 这样" +"的情况。\n" +"我们将通过证明 $2$ 的任何因数最多是 $2$ 来做到这一点，我们将使用这个引理来实" +"现。\n" +"我脑海中的证明会操作假设，直到它变成目标，几乎使用我们到目前为止在这个世界中" +"已经证明的所有内容。" #: Game.Levels.AdvMultiplication.L05le_mul_right msgid "" @@ -4725,16 +5072,19 @@ msgid "mul_right_eq_one" msgstr "mul_right_eq_one" #: Game.Levels.AdvMultiplication.L06mul_right_eq_one +#, fuzzy msgid "" "# Summary\n" "\n" -"The `have` tactic can be used to add new hypotheses to a level, but of course\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" +"The simplest usage is like this. If you have `a` in your context and you " +"execute\n" "\n" "`have ha : a = 0`\n" "\n" @@ -4755,7 +5105,7 @@ msgid "" "## Example\n" "\n" "If you have a proof to hand, then you don't even need to state what you\n" -"are proving. example\n" +"are proving. For example\n" "\n" "`have h2 := succ_inj a b`\n" "\n" @@ -4771,18 +5121,18 @@ msgstr "" "\n" "`have ha : a = 0`\n" "\n" -"那么你将得到一个新的目标 `a = 0` 来证明，一旦你证明了它，你将在你原始的目标中有一个新的假设 `ha : a " -"= 0`。\n" +"那么你将得到一个新的目标 `a = 0` 来证明，一旦你证明了它，你将在你原始的目标中" +"有一个新的假设 `ha : a = 0`。\n" "\n" "## 示例\n" "\n" -"如果你已经有了你想要 `have` 的证明，你可以立即创建它。例如，如果你有 `a` 和 `b` 这两个数字对象，那" -"么\n" +"如果你已经有了你想要 `have` 的证明，你可以立即创建它。例如，如果你有 `a` 和 " +"`b` 这两个数字对象，那么\n" "\n" "`have h2 : succ a = succ b → a = b := succ_inj a b`\n" "\n" -"将直接向上下文中添加一个新的假设 `h2 : succ a = succ b → a = b`，因为你刚刚提供了它的证明（`succ_inj " -"a b`）。\n" +"将直接向上下文中添加一个新的假设 `h2 : succ a = succ b → a = b`，因为你刚刚提" +"供了它的证明（`succ_inj a b`）。\n" "\n" "## 示例\n" "\n" @@ -4798,35 +5148,41 @@ msgstr "`mul_right_eq_one a b`证明了`a * b = 1 → a = 1`。" #: 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" +"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 = 1 → x = 1`，这是高级加法世界中 `x + y = 0 → x = 0` 的乘法类比。策略是" -"证明 `x ≤ 1`，然后使用来自 `≤` 世界的引理 `le_one`。\n" +"在这个关卡，我们证明了 `x * y = 1 → x = 1`，这是高级加法世界中 `x + y = 0 → " +"x = 0` 的乘法类比。策略是证明 `x ≤ 1`，然后使用来自 `≤` 世界的引理 " +"`le_one`。\n" "\n" "我们将使用一个新的非常有用的策略叫做 `have` 来证明它。" #: 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" +"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`。\n" "现在执行 `have h2 : x * y ≠ 0`（你可以用 `\\ne` 输入 `≠`）。\n" -"你将被要求证明它，然后你将有一个新的假设，你可以应用 `le_mul_right` 到这个假设上。" +"你将被要求证明它，然后你将有一个新的假设，你可以应用 `le_mul_right` 到这个假" +"设上。" #: 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.AdvMultiplication.L06mul_right_eq_one -msgid "Now `rw [h] at h2` so you can `apply le_one at hx`." +#, fuzzy +msgid "Now `rw [«{h}»] at «{h2}»` so you can `apply le_one at «{h2}»`." msgstr "现在`rw [h] at h2`，这样就可以`apply le_one at hx`。" #: Game.Levels.AdvMultiplication.L06mul_right_eq_one @@ -4844,18 +5200,20 @@ msgid "mul_ne_zero" msgstr "mul_ne_zero" #: Game.Levels.AdvMultiplication.L07mul_ne_zero -msgid "`mul_ne_zero a b` is a proof that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`." +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.AdvMultiplication.L07mul_ne_zero msgid "" -"This level proves that if `a ≠ 0` and `b ≠ 0` then `a * b ≠ 0`. One strategy\n" +"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 "" "这个关卡要证明如果 `a ≠ 0` 且 `b ≠ 0`，那么 `a * b ≠ 0`。\n" -"一种策略是将 `a` 和 `b` 都写成某物的 `succ`（后继），推断出 `a * b` 也是某物的 `succ`，然后应用 " -"`zero_ne_succ`。" +"一种策略是将 `a` 和 `b` 都写成某物的 `succ`（后继），推断出 `a * b` 也是某物" +"的 `succ`，然后应用 `zero_ne_succ`。" #: Game.Levels.AdvMultiplication.L07mul_ne_zero msgid "Start with `apply eq_succ_of_ne_zero at ha` and `... at hb`" @@ -4866,7 +5224,8 @@ msgid "mul_eq_zero" msgstr "mul_eq_zero" #: 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`." +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.AdvMultiplication.L08mul_eq_zero @@ -4874,8 +5233,8 @@ 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 "" -"这个关卡要证明如果 `a * b = 0` 那么 `a = 0` 或者 `b = 0`。这在逻辑上等同上一个关卡，所以有一个非常简" -"短的证明。" +"这个关卡要证明如果 `a * b = 0` 那么 `a = 0` 或者 `b = 0`。这在逻辑上等同上一" +"个关卡，所以有一个非常简短的证明。" #: Game.Levels.AdvMultiplication.L08mul_eq_zero msgid "Start with `have h2 := mul_ne_zero a b`." @@ -4887,37 +5246,59 @@ msgid "" "tactic." msgstr "现在，目标可以通过纯粹的逻辑从 `h2` 推导出来，所以使用 `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 "" + #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "mul_left_cancel" msgstr "mul_left_cancel" #: Game.Levels.AdvMultiplication.L09mul_left_cancel -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` 。" +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.AdvMultiplication.L09mul_left_cancel +#, fuzzy msgid "" -"In this level we prove that if `a * b = a * c` and `a ≠ 0` then `b = c`. It is tricky, for\n" +"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" +"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`.\"" +"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 "" -"在这个关卡中，我们证明了如果 `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" +"从 `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` 那" -"么 `b = c`。这*可以*通过归纳来证明，因为我们现在有了改变 `c` 的灵活性。”" +"现在假设 `a ≠ 0` 是固定的。我们想要通过对 `b` 进行归纳来证明“对于所有的 `c`，" +"如果 `a * b = a * c` 那么 `b = c`。这*可以*通过归纳来证明，因为我们现在有了改" +"变 `c` 的灵活性。”" #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "The way to start this proof is `induction b with d hd generalizing c`." @@ -4927,15 +5308,18 @@ msgstr "开始证明的方法是 `induction b with d hd generalizing c`。" 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` 将解决一个目标。" +msgstr "" +"使用 `mul_eq_zero` 并记住，如果存在假设 `a = 0` 和 `a ≠ 0`，那么 `tauto` 将解" +"决一个目标。" #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "" -"The inductive hypothesis `hd` is \"For all natural numbers `c`, `a * d = a * c → d = c`\".\n" +"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`）它。" +"归纳假设 `hd` 是“对于所有自然数 `c`，`a * d = a * c → d = c`”的证明。你可以在" +"任何形式为 `a * d = a * ?` 的假设上应用（`apply`）它。" #: Game.Levels.AdvMultiplication.L09mul_left_cancel msgid "Split into cases `c = 0` and `c = succ e` with `cases c with e`." @@ -4946,8 +5330,12 @@ msgid "mul_right_eq_self" msgstr "mul_right_eq_self" #: 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` 的证明。" +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.AdvMultiplication.L10mul_right_eq_self msgid "" @@ -4972,7 +5360,8 @@ msgid "" "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." +"We now have all the tools necessary to set up the basic theory of " +"divisibility of naturals." msgstr "" "这里有个两行的证明\n" "\n" @@ -4995,7 +5384,8 @@ msgid "" "\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" +"`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" @@ -5004,20 +5394,23 @@ msgid "" "true under the additional hypothesis that one of the variables is non-zero.\n" "This causes some unexpected extra twists." msgstr "" -"高级 *加法* 世界证明了涉及加法的各种引理，例如 `x + y = 0 → x = 0` 和 `x + y = x → y = 0`。这些引理被" -"用来证明 ≤ 世界中关于 ≤ 的基本事实。\n" +"高级 *加法* 世界证明了涉及加法的各种引理，例如 `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" +"在高级乘法世界中，我们证明了关于乘法的类似事实，例如 `x * y = 1 → x = 1`，以" +"及 `x * y = x → y = 1`（在后一个结果中假设 `x ≠ 0`）。这将为我们进入可除性世" +"界做准备。\n" "\n" -"乘法世界比加法世界更为复杂。同样，高级乘法世界比高级加法世界更为复杂。其中一个原因是某些中间结果只在" -"额外假设下为真，即变量之一非零。这导致了一些意想不到的转折。" +"乘法世界比加法世界更为复杂。同样，高级乘法世界比高级加法世界更为复杂。其中一" +"个原因是某些中间结果只在额外假设下为真，即变量之一非零。这导致了一些意想不到" +"的转折。" #: Game msgid "Natural Number Game" msgstr "自然数游戏" #: Game +#, fuzzy msgid "" "# Welcome to the Natural Number Game\n" "#### An introduction to mathematical proof.\n" @@ -5037,21 +5430,24 @@ msgid "" "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. A new version\n" -"of Advanced Multiplication World is in preparation, and worlds\n" -"such as Prime Number World and more will be appearing during October and\n" -"November 2023.\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" +"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`。\n" +"本游戏将带领我们从头开始构建自然数 `{0,1,2,3,4,...}` 的基础理论体系。我们首先" +"要证明的是 `2 + 2 = 4`。紧接着，我们会证明 `x + y = y + x`。\n" "最终，我们将尝试证明费马大定理。\n" "请通过完成本游戏中的关卡来完成这些挑战。\n" "\n" @@ -5062,25 +5458,29 @@ msgstr "" "\n" "开始游戏，请点击“教程世界”。\n" "\n" -"请注意：这是基于全新 Lean 4 开发的游戏版本，新增了许多旧版 Lean 3 中未包含的世界。高级乘法世界的新版" -"本正在开发中，其他新世界如素数世界等将于2023年10月至11月陆续推出。\n" +"请注意：这是基于全新 Lean 4 开发的游戏版本，新增了许多旧版 Lean 3 中未包含的" +"世界。高级乘法世界的新版本正在开发中，其他新世界如素数世界等将于2023年10月至" +"11月陆续推出。\n" "\n" "## 更多信息\n" "\n" -"请点击屏幕右上角的“☰”，选择“游戏信息”，这里提供了资源链接以及如何与 Lean 社区互动的方法。" +"请点击屏幕右上角的“☰”，选择“游戏信息”，这里提供了资源链接以及如何与 Lean 社区" +"互动的方法。" #: Game +#, fuzzy msgid "" -"*Game version: 4.2*\n" +"*Game version: 4.3*\n" "\n" -"*Recent additions: Inequality world, algorithm world*\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" +"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" @@ -5096,8 +5496,8 @@ msgid "" "## 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" +"* [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/" +"natural_number_game/) (no longer maintained)\n" "\n" "## Problems?\n" "\n" @@ -5107,12 +5507,15 @@ msgid "" "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" +"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" +"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" +"[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 "" @@ -5125,8 +5528,8 @@ msgstr "" "游戏会将你的进度存储在本地浏览器存储中。\n" "如果你删除它，你的进度将会丢失！\n" "\n" -"警告：在大多数浏览器中，删除 cookie 也会清除本地存储（或“本地网站数据”）。确保首先下载你的游戏进" -"度！\n" +"警告：在大多数浏览器中，删除 cookie 也会清除本地存储（或“本地网站数据”）。确" +"保首先下载你的游戏进度！\n" "\n" "## 致谢\n" "\n" @@ -5134,26 +5537,29 @@ msgstr "" "* **原始 Lean3 版本：** Kevin Buzzard, Mohammad Pedramfar\n" "* **游戏引擎：** Alexander Bentkamp, Jon Eugster, Patrick Massot\n" "* **额外关卡：** Sian Carey, Ivan Farabella, Archie Browne.\n" -"* **特别感谢：** 所有学生测试者，所有邀请 Kevin 发表演讲的学校，以及向他提出关于材料问题的所有学" -"生。\n" +"* **特别感谢：** 所有学生测试者，所有邀请 Kevin 发表演讲的学校，以及向他提出" +"关于材料问题的所有学生。\n" "\n" "## 资源\n" "\n" "* [Lean Zulip 聊天](https://leanprover.zulipchat.com/) 论坛\n" -"* [原始 Lean3 版本](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/)（不再维护）\n" +"* [原始 Lean3 版本](https://www.ma.imperial.ac.uk/~buzzard/xena/" +"natural_number_game/)（不再维护）\n" "\n" "## 有问题吗？\n" "\n" -"请在 [Lean Zulip 聊天](https://leanprover.zulipchat.com/) 论坛提出关于这个游戏的任何问题，例如在 “新" -"成员” 流中。社区会乐意帮忙。请注意，Lean Zulip 聊天是一个专业研究论坛。请使用您的全名，保持话题相关，" -"且友好。如果你正在寻找一个不那么正式的地方（例如，你想发布自然数游戏的表情包），那么可以前往 [Lean " +"请在 [Lean Zulip 聊天](https://leanprover.zulipchat.com/) 论坛提出关于这个游" +"戏的任何问题，例如在 “新成员” 流中。社区会乐意帮忙。请注意，Lean Zulip 聊天是" +"一个专业研究论坛。请使用您的全名，保持话题相关，且友好。如果你正在寻找一个不" +"那么正式的地方（例如，你想发布自然数游戏的表情包），那么可以前往 [Lean " "Discord](https://discord.gg/WZ9bs9UCvx)。\n" "\n" "另外，如果你遇到问题/漏洞，你也可以在 github 上提出问题：\n" "\n" -"* 对于游戏引擎的问题，请在 [lean4game](https://github.com/leanprover-community/lean4game/issues) 仓库" -"提出问题。\n" -"* 对于游戏内容的问题，请在 [NNG](https://github.com/hhu-adam/NNG4/issues) 仓库提出问题。" +"* 对于游戏引擎的问题，请在 [lean4game](https://github.com/leanprover-" +"community/lean4game/issues) 仓库提出问题。\n" +"* 对于游戏内容的问题，请在 [NNG](https://github.com/hhu-adam/NNG4/issues) 仓" +"库提出问题。" #: Game msgid "The classical introduction game for Lean." @@ -5161,11 +5567,13 @@ msgstr "经典的Lean入门游戏。" #: Game msgid "" -"In this game you recreate the natural numbers $\\mathbb{N}$ from the Peano axioms,\n" +"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" +"在这个游戏中，你将根据皮亚诺公理重新构建自然数集 $\\mathbb{N}$，学习在 Lean " +"中证明定理的基础知识。\n" "\n" "这是对 Lean 的一个很好的初步介绍！"