├── LICENSE
├── README-CAT.md
├── README-CZE.md
└── README.md


/LICENSE:
--------------------------------------------------------------------------------
 1 | This is free and unencumbered software released into the public domain.
 2 | 
 3 | Anyone is free to copy, modify, publish, use, compile, sell, or
 4 | distribute this software, either in source code form or as a compiled
 5 | binary, for any purpose, commercial or non-commercial, and by any
 6 | means.
 7 | 
 8 | In jurisdictions that recognize copyright laws, the author or authors
 9 | of this software dedicate any and all copyright interest in the
10 | software to the public domain. We make this dedication for the benefit
11 | of the public at large and to the detriment of our heirs and
12 | successors. We intend this dedication to be an overt act of
13 | relinquishment in perpetuity of all present and future rights to this
14 | software under copyright law.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 | IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
20 | OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
21 | ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
22 | OTHER DEALINGS IN THE SOFTWARE.
23 | 
24 | For more information, please refer to <https://unlicense.org>
25 | 


--------------------------------------------------------------------------------
/README-CAT.md:
--------------------------------------------------------------------------------
 1 | # Tàctiques Lean 4 per principiants
 2 | 
 3 | En les taules que segueixen, <code>*nom*</code> sempre fa referència a un nom que Lean ja coneix
 4 | mentre que <code>*nom_nou*</code> és un nom nou que podem escollir;
 5 | <code>*expr*</code> denota una expressió,
 6 | per exemple el nom d'un objecte en el context,
 7 | una expressió aritmètica que depèn d'aquests objectes,
 8 | una hipòtesi que tenim al context,
 9 | o un lema aplicat a qualsevol d'aquests;
10 | <code>*proposició*</code> és una expressió de l'estil <code>Prop</code> (e.g. <code>0 < x</code>). 
11 | Quan una d'aquestes paraules apareix dues vegades a la mateixa cel·la,
12 | no vol dir que els noms o expressions hagin de ser les mateixes.
13 | 
14 | | Símbol lògic                        | Apareix a l'objectiu                        | Apareix en una hipòtesi                                                                                                           |
15 | |---------------------------------------|-----------------------------------------|---------------------------------------------------------------------------------------------------------------------------------|
16 | | <code>∀</code>&ensp; (per tot)        | <code>intro *nom_nou*</code>           | <code>apply *expr*</code> o <code>specialize *nom* *expr*</code>                                                     <tr></tr>|
17 | | <code>∃</code>&ensp; (existeix)   | <code>use *expr*</code>                 | <code>obtain ⟨*nom_nou*, *nom_nou*⟩ := *expr*</code>                                <tr></tr>|
18 | | <code>→</code>&ensp; (implica)        | <code>intro *nom_nou*</code>           | <code>apply *expr*</code> o <code>specialize *nom* *expr*</code>                                                     <tr></tr>|
19 | | <code>↔</code>&ensp; (si i només si) | <code>constructor</code>                | <code>rw [*expr*]</code> o <code>rw [←*expr*]</code>                                                                 <tr></tr>|
20 | | <code>∧</code>&ensp; (i)            | <code>constructor</code>                | <code>obtain ⟨*nom_nou*, *nom_nou*⟩ := *expr*</code>                                <tr></tr>|
21 | | <code>∨</code>&ensp; (o)             | <code>left</code> o <code>right</code> | <code>cases *expr* with</code> <br><code>\| inl *nom_nou* => ...</code> <br><code>\| inr *nom_nou* => ...</code> <tr></tr>|
22 | | <code>¬</code>&ensp; (no)            | <code>intro *nom_nou*</code>           | <code>apply *expr*</code> o <code>specialize *nom* *expr*</code>                                                              |
23 | 
24 | A l'esquerra de la taula següent les parts entre parèntesis són opcionals.
25 | L'efecte d'aquestes parts també està escrit entre parèntesis.
26 | 
27 | | Tàctica                                                      | Efecte                                                                                                                                                                                                                                      |
28 | |-------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
29 | | <code>exact *expr*</code>                                   | demostra que l'objectiu es pot provar amb <code>*expr*</code>                                                                                                                                                                       <tr></tr>|
30 | | <code>refine</code>                                         | Igual que <code>exact *expr*</code>, però podem deixar <code>?_</code> en algunes dades i crearà nous objectius                                                                                                                                                                                                                               <tr></tr>|
31 | | <code>convert *expr*</code>                                 | demostra l'objectiu transformant-lo en un fet ja existent <code>*expr*</code> i crea nous objectius per aquelles proposicions utilitzades en la transformació que no s'hagin demostrat automàticament <tr></tr>|
32 | | <code>convert_to *proposition*</code>                       | transforma l'objectiu en el nou objectiu <code>*proposició*</code> i crea nous objectius per aquells proposicions utilitzades en la transformació que no s'hagin demostrat automàticament                                                             <tr></tr>|
33 | | <code>have *nom_nou* : *proposition*</code>                | introduceis un nom <code>*nom_nou*</code> enunciant que la <code>*proposició*</code> és certa; simultàniament, crea un nou objectiu per demostrar la <code>*proposició*</code>                                                               <tr></tr>|
34 | | <code>unfold *nom*</code>&ensp;(<code>at *hyp*</code>)     | reescriu la definició de <code>*nom*</code> a l'objectiu (o a la hipòtesi <code>*hyp*</code>)                                                                                                                                 <tr></tr>|
35 | | <code>rw [*expr*]</code>&ensp;(<code>at *hyp*</code>)       | a l'objectiu (o a la hipòtesi <code>*hyp*</code>), canvia (totes es instàncies de) la part esquerra de la igualtat o equivalència <code>*expr*</code> per la part dreta                                                   <tr></tr>|
36 | | <code>rw [←*expr*]</code>&ensp;(<code>at *hyp*</code>)      | a l'objectiu (o a la hipòtesi <code>*hyp*</code>), canvia (totes es instàncies de) la part dreta de la igualtat o equivalència <code>*expr*</code> per la part esquerra                                                  <tr></tr>|
37 | | <code>rw [*expr*, *expr*, ←*expr*, ←*expr*, *expr*]</code>  | fer diverses reescriptures l'una darrera l'altra (es pot fer servir a l'objectiu o a una hipòtesi donada; es pot alternar canvis esquerra-dreta amb dreta-esquerra)                                                         <tr></tr>|
38 | | <code>calc</code>                                           | comença una demostració per càlcul (i.e. una successió de proposicions que, al combinar-se fent servir transitivitat, demostraran l'objectiu)                                                                                       <tr></tr>|
39 | | <code>gcongr</code>                                         | TODO                                                                                                                                                                                                                               <tr></tr>|
40 | | <code>by_cases *nom_nou* : *proposició*</code>            | trenca la demostració en dues branques segons <code>*proposició*</code> sigui cert o fals, fent servir <code>*nom_nou*</code> com el nom de la hipòtesi respecriva en cada branca                                          <tr></tr>|
41 | | <code>exfalso</code>                                        | aplica la regla "Fals implica qualsevol cosa", també coneguda com "ex falso quodlibet" (canvia l'objectiu a  <code>False</code>)                                                                                                              <tr></tr>|
42 | | <code>by_contra *nom_nou*</code>                           | comença una demostració per reducció a l'absurd, fent servir <code>*nom_nou*</code> per la hipòtesi que és la negació de l'objectiu                                                     <tr></tr>|
43 | | <code>push_neg</code>&ensp;(<code>at *hyp*</code>)          | simplifica les negacions a l'objectiu (o a la hipòtesi <code>*hyp*</code>),<br>e.g. canvia <code>¬ ∀ x, *proposició*</code> to <code>∃ x, ¬ *proposició*</code>                                                                        <tr></tr>|
44 | | <code>linarith</code>                                       | demostra l'objectiu fent servir una combinació lineal de les hipòtesis (inclosos arguments basats en la transitivitat)                                                                                                                                    <tr></tr>|
45 | | <code>ring</code>                                           | demostra l'objectiu combinant els axiomes d'un (semi)anell commutatiu                                                                                                                                                                 <tr></tr>|
46 | | <code>simp</code>&ensp;(<code>at *hyp*</code>)              | simplifica l'objectiu (o la hipòtesi <code>*hyp*</code>) combinant algunes igualtats i equivalències ja apreses                                                                                                                    <tr></tr>|
47 | | <code>simp?</code>&ensp;(<code>at *hyp*</code>)             | mostra quines igualtats i equivalències es farien servir per simplificar l'objectiu (o la hipòtesi <code>*hyp*</code>); dona una llista d'expressions que poden utilitzar-se dins de <code>simp only [...]</code>&ensp;(<code>at *hyp*</code>)     <tr></tr>|
48 | | <code>exact?</code>                                         | busca un lema que demostri l'objectiu fent servir hipòtesis del context                                                                                                                                              <tr></tr>|
49 | | <code>apply?</code>                                         | busca lemes la conclusió dels quals coincideixi amb l'objectiu; suggereix aquells que es poden fer servir amb  <code>apply</code> o <code>refine</code>                                                                                         <tr></tr>|
50 | | <code>rw?</code>                                            | TODO                                                                                                                                                                                                                               <tr></tr>|
51 | | <code>aesop</code>                                          | TODO                                                                                                                                                                                                                                        |
52 | 


--------------------------------------------------------------------------------
/README-CZE.md:
--------------------------------------------------------------------------------
 1 | # Lean 4 — přehled taktik pro začátečníky
 2 | 
 3 | V následujících tabulkách vždy <code>*jmeno*</code> označuje jméno, které už Lean zná,
 4 | zatímco <code>*pojmenovani*</code> je nové jméno (právě poskytnuté);
 5 | <code>*term*</code> je libovolný výraz,
 6 | například jméno známého termu,
 7 | funkce aplikovaná na term,
 8 | aritmetický výraz,
 9 | předpoklad z lokálního kontextu,
10 | nebo nějaké lemma aplikované na cokoliv z toho;
11 | <code>*tvrzeni*</code> je term typu <code>Prop</code> (například <code>0 < x</code>). 
12 | Když se některé z těchto slov objeví v jedné buňce vícekrát,
13 | jednotlivé výskyty označují odlišná jména nebo výrazy.
14 | 
15 | ## Taktiky pro logické symboly
16 | 
17 | Následující tabulka ukazuje, jak typicky reagujeme na který logický symbol v závislosti
18 | na jeho umístění (v čele cíle nebo v čele předpokladu).
19 | 
20 | | Logický symbol                          | V cíli                                    | V předpokladu                                                                                                                     |
21 | |-----------------------------------------|-------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|
22 | | <code>∀</code>&ensp; (pro každé)        | <code>intro *pojmenovani*</code>          | <code>apply *term*</code> nebo <code>specialize *jmeno* *term*</code>                                                    <tr></tr>|
23 | | <code>∃</code>&ensp; (existuje)         | <code>use *term*</code>                   | <code>obtain ⟨*pojmenovani*, *pojmenovani*⟩ := *term*</code>                                                             <tr></tr>|
24 | | <code>→</code>&ensp; (implikuje)        | <code>intro *pojmenovani*</code>          | <code>apply *term*</code> nebo <code>specialize *jmeno* *term*</code>                                                    <tr></tr>|
25 | | <code>↔</code>&ensp; (právě tehdy když) | <code>constructor</code>                  | <code>rw [*term*]</code> nebo <code>rw [←*term*]</code>                                                                  <tr></tr>|
26 | | <code>∧</code>&ensp; (AND)              | <code>constructor</code>                  | <code>obtain ⟨*pojmenovani*, *pojmenovani*⟩ := *term*</code>                                                             <tr></tr>|
27 | | <code>∨</code>&ensp; (OR)               | <code>left</code> nebo <code>right</code> | <code>cases *term* with</code> <br><code>\| inl *pojmenovani* => ...</code> <br><code>\| inr *pojmenovani* => ...</code> <tr></tr>|
28 | | <code>¬</code>&ensp; (NOT)              | <code>intro *pojmenovani*</code>          | <code>apply *term*</code> nebo <code>specialize *jmeno* *term*</code>                                                             |
29 | 
30 | ## Obecně užitečné taktiky
31 | 
32 | Závorky v levém sloupci označují volitelné části.
33 | Účinek těchto částí je v pravém sloupci také napsán v závorkách.
34 | 
35 | | Taktika                                                     | Co dělá                                                                                                                                                                                                                                     |
36 | |-------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
37 | | <code>exact *term*</code>                                   | cíl je splněn pomocí <code>*term*</code>                                                                                                                                                                                           <tr></tr>|
38 | | <code>convert *term*</code>                                 | dokaž cíl tím, že ho převedeš na již známý fakt <code>*term*</code>, a vytvoř pomocné cíle pro ty transformace použité k převodu, které nebyly dokázány automaticky                                                                <tr></tr>|
39 | | <code>convert_to *tvrzeni*</code>                           | dokaž cíl tím, že ho převedeš na jiný cíl <code>*tvrzeni*</code>, a vytvoř dodatečné cíle pro ty transformace použité k převodu, které nebyly dokázány automaticky                                                                 <tr></tr>|
40 | | <code>have *pojmenovani* : *tvrzeni*</code>                 | přidej do kontextu předpoklad <code>*pojmenovani*</code>, který tvrdí <code>*tvrzeni*</code>, a zároveň vytvoř a zaměř nový cíl dokázat <code>*tvrzeni*</code>                                                                     <tr></tr>|
41 | | <code>unfold *jmeno*</code>&ensp;(<code>at *hyp*</code>)    | rozbal definici <code>*jmeno*</code> v cíli (nebo v předpokladu <code>*hyp*</code>)                                                                                                                                                <tr></tr>|
42 | | <code>rw [*term*]</code>&ensp;(<code>at *hyp*</code>)       | v cíli (nebo v předpokladu <code>*hyp*</code>) nahraď všechny výskyty levé strany rovnosti nebo ekvivalence <code>*term*</code> za její pravou stranu                                                                              <tr></tr>|
43 | | <code>rw [←*term*]</code>&ensp;(<code>at *hyp*</code>)      | v cíli (nebo v předpokladu <code>*hyp*</code>) nahraď všechny výskyty pravé strany rovnosti nebo ekvivalence <code>*term*</code> za její levou stranu                                                                              <tr></tr>|
44 | | <code>rw [*term*, *term*, ←*term*, ←*term*, *term*]</code>  | proveď několik přepisů v řadě za sebou (opět může být použito v cíli i v předpokladu; libovolná podmnožina <code>*term*</code> může být provedena zprava doleva)                                                                   <tr></tr>|
45 | | <code>by_cases *pojmenovani* : *tvrzeni*</code>             | rozlož důkaz na dvě větve podle toho, jestli <code>*tvrzeni*</code> je splněn nebo ne, kde <code>*pojmenovani*</code> označuje kýženou hypotézu v obou větvích                                                                     <tr></tr>|
46 | | <code>exfalso</code>                                        | použij pravidlo "ze sporu plyne cokoliv" neboli "ex falso quodlibet" (nahradí současný cíl za <code>False</code>)                                                                                                                  <tr></tr>|
47 | | <code>by_contra *pojmenovani*</code>                        | zahaj důkaz sporem, kde <code>*pojmenovani*</code> bude jméno pro předpoklad, který je negací cíle                                                                                                                                 <tr></tr>|
48 | | <code>push_neg</code>&ensp;(<code>at *hyp*</code>)          | posuň negace směrem „dovnitř“ v cíli (nebo v předpokladu <code>*hyp*</code>),<br>například změň <code>¬ ∀ x, *tvrzeni*</code> na <code>∃ x, ¬ *tvrzeni*</code>                                                                     <tr></tr>|
49 | | <code>linarith</code>                                       | dokaž cíl pomocí lineární kombinace předpokladů (zahrnuje argumenty z tranzitivity (ne)rovností)                                                                                                                                   <tr></tr>|
50 | | <code>ring</code>                                           | dokaž cíl pomocí vlastností sčítání, odčítání, násobení a mocnin                                                                                                                                                                   <tr></tr>|
51 | | <code>simp</code>&ensp;(<code>at *hyp*</code>)              | zjednoduš cíl (nebo předpoklad <code>*hyp*</code>) pomocí nějaké kombinace známých rovností a ekvivalencí                                                                                                                          <tr></tr>|
52 | | <code>simp?</code>&ensp;(<code>at *hyp*</code>)             | ukaž, které rovnosti a ekvivalence by mohly být použity ke zjednodušení cíle (nebo předpokladu <code>*hyp*</code>); dej seznam výrazů, které mohou být použity uvnitř <code>simp only [...]</code>&ensp;(<code>at *hyp*</code>)    <tr></tr>|
53 | | <code>exact?</code>                                         | najdi v knihovně (navíc s využitím lokálního kontextu) lemma, které uzavře cíl                                                                                                                                                     <tr></tr>|
54 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Lean 4 spellbook — tactics overview for beginners
 2 | 
 3 | In the following tables, <code>*name*</code> always refers to a name already known to Lean
 4 | while <code>*new_name*</code> is a new name provided by the user;
 5 | <code>*expr*</code> means an expression,
 6 | for example the name of an object in the context,
 7 | an arithmetic expression that is a function of such objects,
 8 | a hypothesis in the context,
 9 | or a lemma applied to any of these;
10 | <code>*proposition*</code> is an expression of the type <code>Prop</code> (e.g. <code>0 < x</code>). 
11 | When one of these words appears twice in the same cell,
12 | the appearances do not designate the same name or the same expression.
13 | 
14 | ## Tactics for logical symbols
15 | 
16 | The following table shows usual responses to logical symbols based on their placement.
17 | 
18 | | Logical symbol                        | Appears in goal                         | Appears in hypothesis                                                                                                       |
19 | |---------------------------------------|-----------------------------------------|-----------------------------------------------------------------------------------------------------------------------------|
20 | | <code>∃</code>&ensp; (there exists)   | <code>use *expr*</code>                 | <code>obtain ⟨*new_name*, *new_name*⟩ := *expr*</code>                                                             <tr></tr>|
21 | | <code>∀</code>&ensp; (for all)        | <code>intro *new_name*</code>           | <code>apply *expr*</code> or <code>specialize *name* *expr*</code>                                                 <tr></tr>|
22 | | <code>¬</code>&ensp; (not)            | <code>intro *new_name*</code>           | <code>apply *expr*</code> or <code>specialize *name* *expr*</code>                                                 <tr></tr>|
23 | | <code>→</code>&ensp; (implies)        | <code>intro *new_name*</code>           | <code>apply *expr*</code> or <code>specialize *name* *expr*</code>                                                 <tr></tr>|
24 | | <code>↔</code>&ensp; (if and only if) | <code>constructor</code>                | <code>rw [*expr*]</code> or <code>rw [←*expr*]</code>                                                             <tr></tr>|
25 | | <code>∧</code>&ensp; (and)            | <code>constructor</code>                | <code>obtain ⟨*new_name*, *new_name*⟩ := *expr*</code>                                                             <tr></tr>|
26 | | <code>∨</code>&ensp; (or)             | <code>left</code> or <code>right</code> | <code>cases *expr* with</code> <br><code>\| inl *new_name* => ...</code> <br><code>\| inr *new_name* => ...</code>         |
27 | 
28 | ## Generally useful tactics
29 | 
30 | In the left-hand column, the parts in parentheses are optional.
31 | The effect of these parts in the right-hand column is also written in parentheses.
32 | 
33 | | Tactic                                                      | Effect                                                                                                                                                                                                                                      |
34 | |-------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
35 | | <code>exact *expr*</code>                                   | the goal is satisfied by <code>*expr*</code>                                                                                                                                                                                       <tr></tr>|
36 | | <code>refine *expr*</code>                                  | similar to <code>exact</code> but allows to leave any number of <code>?_</code> in the <code>*expr*</code> to denote holes that will be filled later                                                                               <tr></tr>|
37 | | <code>convert *expr*</code>                                 | prove the goal by transforming it to an existing fact <code>*expr*</code> and create goals for propositions used in the transformation that were not proved automatically                                                          <tr></tr>|
38 | | <code>convert_to *proposition*</code>                       | transform the goal into the goal <code>*proposition*</code> and create additional goals for propositions used in the transformation that were not proved automatically                                                             <tr></tr>|
39 | | <code>have *new_name* : *proposition*</code>                | introduce a name <code>*new_name*</code> asserting that <code>*proposition*</code> is true; at the same time, create and focus a goal for <code>*proposition*</code>                                                               <tr></tr>|
40 | | <code>unfold *name*</code>&ensp;(<code>at *hyp*</code>)     | unfold the definition of <code>*name*</code> in the goal (or in the hypothesis <code>*hyp*</code>)                                                                                                                                 <tr></tr>|
41 | | <code>rw [*expr*]</code>&ensp;(<code>at *hyp*</code>)       | in the goal (or in the hypothesis <code>*hyp*</code>), replace (all occurrences of) the left-hand side of the equality or equivalence <code>*expr*</code> by its right-hand side                                                   <tr></tr>|
42 | | <code>rw [←*expr*]</code>&ensp;(<code>at *hyp*</code>)      | in the goal (or in the hypothesis <code>*hyp*</code>), replace (all occurrences of) the right-hand side of the equality or equivalence <code>*expr*</code> by its left-hand side                                                   <tr></tr>|
43 | | <code>rw [*expr*, *expr*, ←*expr*, ←*expr*, *expr*]</code>  | perform several rewritings in a sequence (can again be used in the goal or in given hypothesis; any subset of <code>*expr*</code> can again be applied from right to left)                                                         <tr></tr>|
44 | | <code>calc</code>                                           | start a proof by calculation (i.e., a sequence of propositions that, when combined together using transitivity, will prove the goal)                                                                                               <tr></tr>|
45 | | <code>by_cases *new_name* : *proposition*</code>            | split the proof into two branches depending on whether <code>*proposition*</code> is true or false, using <code>*new_name*</code> as name for the respective hypothesis in both branches                                           <tr></tr>|
46 | | <code>exfalso</code>                                        | apply the rule "False implies anything" a.k.a. "ex falso quodlibet" (replaces the goal by <code>False</code>)                                                                                                                      <tr></tr>|
47 | | <code>by_contra *new_name*</code>                           | start a proof by contradiction, using <code>*new_name*</code> as name for the hypothesis that is the negation of the goal                                                                                                          <tr></tr>|
48 | | <code>push_neg</code>&ensp;(<code>at *hyp*</code>)          | push negations in the goal (or in the hypothesis <code>*hyp*</code>),<br>e.g. change <code>¬ ∀ x, *proposition*</code> to <code>∃ x, ¬ *proposition*</code>                                                                        <tr></tr>|
49 | | <code>linarith</code>                                       | prove the goal by a linear combination of hypotheses (includes arguments based on transitivity)                                                                                                                                    <tr></tr>|
50 | | <code>ring</code>                                           | prove the goal by combining the axioms of a commutative (semi)ring                                                                                                                                                                 <tr></tr>|
51 | | <code>simp</code>&ensp;(<code>at *hyp*</code>)              | simplify the goal (or the hypothesis <code>*hyp*</code>) by combining some standard equalities and equivalences                                                                                                                    <tr></tr>|
52 | | <code>simp?</code>&ensp;(<code>at *hyp*</code>)             | show which equalities and equivalences would be used to simplify the goal (or the hypothesis <code>*hyp*</code>); give a list of expressions that can be used inside <code>simp only [...]</code>&ensp;(<code>at *hyp*</code>)     <tr></tr>|
53 | | <code>exact?</code>                                         | search for a single existing lemma which closes the goal, also using local hypotheses                                                                                                                                              <tr></tr>|
54 | | <code>apply?</code>                                         | search for lemmas whose conclusion matches the goal; suggest those that may be used with <code>apply</code> or <code>refine</code>                                                                                                 <tr></tr>|
55 | | <code>rw?</code>&ensp;(<code>at *hyp*</code>)               | search for lemmas that can rewrite the goal (or the hypothesis <code>*hyp*</code>), irrespective of their practicality                                                                                                             <tr></tr>|
56 | | <code>aesop</code>                                          | try to solve the goal using magic                                                                                                                                                                                                  <tr></tr>|
57 | | <code>aesop?</code>                                         | try to solve the goal using magic and show what kind of magic was used (usually produces unreadable output but the names of relevant lemmas are there)                                                                                      |
58 | 


--------------------------------------------------------------------------------