phc
/
lean4game
6
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

set theory levels

Browse Source
pull/43/head
Jon Eugster 3 years ago
parent 73a44bd057
commit 404f346920
52 changed files with 1602 additions and 37 deletions
Show Stats Download Patch File Download Diff File

21
server/testgame/TestGame.lean
Unescape Escape View File

@ -17,10 +17,25 @@ import TestGame.Levels.SetFunction
Game "TestGame" Game "TestGame"
Title "Lean 4 game" Title "Lean 4 game"
Introduction Introduction
"Work in progress. "
Durch eine unvorhergesehene und nicht-kanonische Singularität in der Raumzeit
bist Du ausversehen in ein Paralleluniversum gestolpert. Wie es aussieht, gibt es kein zurück.
Richte Dich besser darauf ein, hier bleiben und Dich zurechtzufinden zu müssen.
Wie es aussieht, gibt es hier viele nette kleine Planeten. Alle bewohnbar, und bis zu
sieben Sonnenuntergänge täglich inklusive. Nur werden sie allesamt von Formalosophen bewohnt,
seltsamen Wesen mit ausgefallenen mathematischen Obsessionen. Und dummerweise hat sich
herumgesprochen, dass Du in Deinem früheren Universum Mathematiker warst. Du wirst hier
keine Ruhe finden, solange Du nicht lernst, ihren unablässigen Wissensdurst zu stillen.
Es gibt nur zwei Schwierigkeiten: Erstens haben die Formalosophen allem Anschein nach
überhaupt kein tieferes mathematisches Verständnis, und zweitens kommunizieren Sie
exklusiv in einem Dir fremden Dialekt. Zum Glück hat Robo mit Dir das Universum gewechselt.
Robo, das ist Dein kleiner SmartElf. Robo kann zwar auch keine Mathematik, aber es scheint,
er kann irgendetwas mit dem Formalosophendialekt anfangen.
" "
Conclusion Conclusion
"There is nothing else so far. Thanks for rescuing natural numbers!" "Fertig!"
Path Proposition → Implication → Predicate → Contradiction → LeanStuff Path Proposition → Implication → Predicate → Contradiction → LeanStuff
@ -28,3 +43,5 @@ Path Proposition → Implication → Predicate → Contradiction → LeanStuff
Path Predicate → Induction → LeanStuff → Function → SetFunction Path Predicate → Induction → LeanStuff → Function → SetFunction
Path LeanStuff → SetTheory → SetFunction Path LeanStuff → SetTheory → SetFunction
Path SetTheory → SetTheory2

20
server/testgame/TestGame/LemmaDocs.lean
Unescape Escape View File

@ -77,6 +77,26 @@ LemmaDoc even_square as even_square in "Nat"
"`∀ (n : ℕ), even n → even (n ^ 2)`" "`∀ (n : ℕ), even n → even (n ^ 2)`"
LemmaDoc mem_univ as mem_univ in "Set"
"x ∈ @univ α"
LemmaDoc not_mem_empty as not_mem_empty
""
LemmaDoc empty_subset as empty_subset in "Set"
""
LemmaDoc Subset.antisymm_iff as Subset.antisymm_iff in "Set"
""
LemmaSet natural : "Natürliche Zahlen" := LemmaSet natural : "Natürliche Zahlen" :=
Even Odd not_odd not_even Even Odd not_odd not_even

4
server/testgame/TestGame/Levels/Contradiction/L03_ByContra.lean
Unescape Escape View File

@ -31,11 +31,11 @@ steht:
Statement Statement
"Angenommen $B$ ist falsch und es gilt $A \\Rightarrow B$. Zeige, dass $A$ falsch sein "Angenommen $B$ ist falsch und es gilt $A \\Rightarrow B$. Zeige, dass $A$ falsch sein
muss." muss."
(A B : Prop) (h : A → B) (b : ¬ B) : ¬ A := by (A B : Prop) (g : A → B) (b : ¬ B) : ¬ A := by
by_contra a by_contra a
suffices b : B suffices b : B
contradiction contradiction
apply h apply g
assumption assumption

3
server/testgame/TestGame/Levels/Induction/L10_Bernoulli.lean
Unescape Escape View File

@ -28,8 +28,7 @@ example (n : ℕ) : (∑ i : Fin (n + 1), ↑(2 * i - 1)) = n ^ 2 := by
induction' n with n hn induction' n with n hn
simp simp
#check Finset.sum_comm
Statement Statement
"Zeige $\\sum_{i = 0}^n i = \\frac{n ⬝ (n + 1)}{2}$." "Zeige $\\sum_{i = 0}^n i = \\frac{n ⬝ (n + 1)}{2}$."

25
server/testgame/TestGame/Levels/Induction/T00_Sum.lean
Unescape Escape View File

@ -0,0 +1,25 @@
import TestGame.Metadata
import Mathlib.Tactic.Ring
import Mathlib
import TestGame.ToBePorted
Game "TestGame"
World "Induction"
Level 3
Title "Induktion"
Introduction
"
"
Statement
"Zeige $\\sum_{i = 0}^n i^3 = (\\sum_{i = 0}^n i^3)^2$."
(n : ℕ) : (∑ i : Fin (n + 1), (i : ℕ)^3) = (∑ i : Fin (n + 1), (i : ℕ))^2 := by
induction n
simp
sorry
Tactics ring

24
server/testgame/TestGame/Levels/Induction/T01_Induction.lean
Unescape Escape View File

@ -0,0 +1,24 @@
import Mathlib.Algebra.BigOperators.Basic
import Mathlib
import TestGame.Metadata
set_option tactic.hygienic false
Game "TestGame"
World "Induction"
Level 2
Title "endliche Summe"
Introduction
"
2^n > n^2 für n ≥ 5
"
Statement
"2^n > n^2 für n ≥ 5"
(n : ℕ) : True := by
sorry
Tactics rw simp ring

24
server/testgame/TestGame/Levels/Induction/T02_Induction.lean
Unescape Escape View File

@ -0,0 +1,24 @@
import Mathlib.Algebra.BigOperators.Basic
import Mathlib
import TestGame.Metadata
set_option tactic.hygienic false
Game "TestGame"
World "Induction"
Level 2
Title "endliche Summe"
Introduction
"
n^3 + 2n ist durch 3 teilbar für alle ganzen Zahlen n
"
Statement
"n^3 + 2n ist durch 3 teilbar für alle ganzen Zahlen n"
(n : ℤ) : True := by
sorry
Tactics rw simp ring

34
server/testgame/TestGame/Levels/Induction/T03_SumComm.lean
Unescape Escape View File

@ -0,0 +1,34 @@
import Mathlib.Algebra.BigOperators.Basic
import Mathlib
import TestGame.Metadata
set_option tactic.hygienic false
Game "TestGame"
World "Induction"
Level 1
Title "Simp"
Introduction
"
"
Statement
""
(n : ℕ) : True := by
trivial
Tactics simp
-- Σ_i Σ_j ... = Σ_j Σ_i ...
-- rw [sum_comm]
example : ¬ ∀ (x : ℕ), x ≥ 10 := by
push_neg
use 5
simp
¬ ∀ (...) ↔ ∃ (¬ ...)

1
server/testgame/TestGame/Levels/Proposition.lean
Unescape Escape View File

@ -1,3 +1,4 @@
import TestGame.Levels.Proposition.L00_Tauto
import TestGame.Levels.Proposition.L01_Rfl import TestGame.Levels.Proposition.L01_Rfl
import TestGame.Levels.Proposition.L02_Assumption import TestGame.Levels.Proposition.L02_Assumption
import TestGame.Levels.Proposition.L03_Assumption import TestGame.Levels.Proposition.L03_Assumption

51
server/testgame/TestGame/Levels/Proposition/L00_Tauto.lean
Unescape Escape View File

@ -0,0 +1,51 @@
import TestGame.Metadata
import Mathlib.Tactic.Tauto
Game "TestGame"
World "Proposition"
Level 1
Title "Atomatisierung"
Introduction
"
Willkommen zum Lean-Crashkurs wo du lernst wie man mathematische Beweise vom Computer
unterstützt und verifiziert schreiben kann.
*Rechts* siehst den Status des Beweis. Unter **Main Goal** steht, was du im Moment am beweisen
bist. Falls es mehrere Subgoals gibt, werden alle weiteren darunter unter **Further Goals**
aufgelistet, diese musst du dann später auch noch zeigen.
Ein Beweis besteht aus mehreren **Taktiken**. Das sind einzelne Beweisschritte, ähnlich wie
man auf Papier argumentieren würde. Manche Taktiken können ganz konkret etwas kleines machen,
andere sind stark und lösen ganze Probleme automatisiert. Du findest die Taktiken *Links* an der
Seite.
Wenn der Beweis komplett ist, erscheint \"Level completed! 🎉\".
Als erstes ein kleiner Preview, dass Lean auch vieles automatisch kann. So gibt es eine
Taktik `tauto`, die alle wahren Aussagen der Prädikaten-Logik beweisen kann.
Dieses Beispiel würde von Hand etwas Zeit in Anspruch nehmen. Lean ist da viel schneller.
Gib also `tauto` gefolgt von Enter ⏎ ein um deinen ersten automatisierten Beweis zu führen!
"
Statement
"Zeige dass folgende Aussage wahr ist:
$$
\\neg ((\\neg B\\textrm{ oder }\\neg C) \\textrm{ oder } (A \\Rightarrow B)) \\Rightarrow
(\\neg A \\textrm{ oder } B) \\textrm{ und } \\neg (B \\textrm{ und } C)
$$
"
(A B C : Prop) :
¬((¬B ∨ ¬ C) ∨ (A → B)) → (¬A ∨ B) ∧ ¬ (B ∧ C) := by
tauto
HiddenHint (A : Prop) (B : Prop) (C : Prop): ¬((¬B ∨ ¬ C) ∨ (A → B)) → (¬A ∨ B) ∧ ¬ (B ∧ C) =>
"Man schreibt eine Taktik pro Zeile, also gib `tauto` ein und geh mit Enter ⏎ auf eine neue Zeile."
Conclusion ""
Tactics tauto

20
server/testgame/TestGame/Levels/Proposition/L01_Rfl.lean
Unescape Escape View File

@ -2,29 +2,17 @@ import TestGame.Metadata
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 1 Level 2
Title "Aller Anfang ist... ein Einzeiler?" Title "Aller Anfang ist... ein Einzeiler?"
Introduction Introduction
" "
Willkommen zum Lean-Crashkurs wo du lernst wie man mathematische Beweise vom Computer Jetzt gehen wir aber einen Schritt zurück und lernen, wie man konkret mit Lean arbeitet,
unterstützt und verifiziert schreiben kann. damit du verstehst, was `tauto` hinter der Kulisse macht.
*Rechts* siehst den Status des Beweis. Unter **Main Goal** steht, was du im Moment am beweisen
bist. Falls es mehrere Subgoals gibt, werden alle weiteren darunter unter **Further Goals**
aufgelistet, diese musst du dann später auch noch zeigen.
Ein Beweis besteht aus mehreren **Taktiken**. Das sind einzelne Beweisschritte, ähnlich wie
man auf Papier argumentieren würde. Manche Taktiken können ganz konkret etwas kleines machen,
andere sind stark und lösen ganze Probleme automatisiert. Du findest die Taktiken *Links* an der
Seite.
Wenn der Beweis komplett ist, erscheint \"Level completed! 🎉\".
Deine erste Taktik ist `rfl` (für \"reflexivity\"), welche dazu da ist, Deine erste Taktik ist `rfl` (für \"reflexivity\"), welche dazu da ist,
ein Goal der Form $X = X$ zu schliessen. ein Goal der Form $X = X$ zu schließen.
Gib die Taktik ein gefolgt von Enter ⏎.
" "
Statement Statement

2
server/testgame/TestGame/Levels/Proposition/L02_Assumption.lean
Unescape Escape View File

@ -2,7 +2,7 @@ import TestGame.Metadata
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 2 Level 3
Title "Annahmen" Title "Annahmen"

2
server/testgame/TestGame/Levels/Proposition/L03_Assumption.lean
Unescape Escape View File

@ -3,7 +3,7 @@ import Mathlib.Data.Nat.Basic -- TODO
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 3 Level 4
Title "Logische Aussagen" Title "Logische Aussagen"

2
server/testgame/TestGame/Levels/Proposition/L04_True.lean
Unescape Escape View File

@ -2,7 +2,7 @@ import TestGame.Metadata
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 4 Level 5
Title "True/False" Title "True/False"

2
server/testgame/TestGame/Levels/Proposition/L05_Not.lean
Unescape Escape View File

@ -2,7 +2,7 @@ import TestGame.Metadata
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 5 Level 6
Title "Not" Title "Not"

2
server/testgame/TestGame/Levels/Proposition/L06_False.lean
Unescape Escape View File

@ -4,7 +4,7 @@ import Mathlib.Tactic.LeftRight
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 6 Level 7
Title "Widerspruch beweist alles." Title "Widerspruch beweist alles."

2
server/testgame/TestGame/Levels/Proposition/L07_ContraNotEq.lean
Unescape Escape View File

@ -6,7 +6,7 @@ import TestGame.ToBePorted
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 7 Level 8
Title "Widerspruch" Title "Widerspruch"

2
server/testgame/TestGame/Levels/Proposition/L08_Contra.lean
Unescape Escape View File

@ -6,7 +6,7 @@ import TestGame.ToBePorted
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 8 Level 9
Title "Widerspruch" Title "Widerspruch"

2
server/testgame/TestGame/Levels/Proposition/L09_And.lean
Unescape Escape View File

@ -5,7 +5,7 @@ set_option tactic.hygienic false
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 9 Level 10
Title "Und" Title "Und"

2
server/testgame/TestGame/Levels/Proposition/L10_And.lean
Unescape Escape View File

@ -5,7 +5,7 @@ set_option tactic.hygienic false
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 10 Level 11
Title "Und" Title "Und"

2
server/testgame/TestGame/Levels/Proposition/L11_Or.lean
Unescape Escape View File

@ -6,7 +6,7 @@ import Mathlib.Tactic.LeftRight
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 11 Level 12
Title "Oder" Title "Oder"

2
server/testgame/TestGame/Levels/Proposition/L12_Or.lean
Unescape Escape View File

@ -9,7 +9,7 @@ import Mathlib.Tactic.LeftRight
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 12 Level 13
Title "Oder" Title "Oder"

2
server/testgame/TestGame/Levels/Proposition/L13_Summary.lean
Unescape Escape View File

@ -6,7 +6,7 @@ set_option tactic.hygienic false
Game "TestGame" Game "TestGame"
World "Proposition" World "Proposition"
Level 13 Level 14
Title "Zusammenfassung" Title "Zusammenfassung"

25
server/testgame/TestGame/Levels/SetTheory.lean
Unescape Escape View File

@ -1,5 +1,28 @@
import TestGame.Levels.SetTheory.T01_Set import TestGame.Levels.SetTheory.L01_Univ
import TestGame.Levels.SetTheory.L02_Empty
import TestGame.Levels.SetTheory.L03_Subset
import TestGame.Levels.SetTheory.L04_SubsetEmpty
import TestGame.Levels.SetTheory.L05_Empty
import TestGame.Levels.SetTheory.L06_Nonempty
import TestGame.Levels.SetTheory.L07_UnionInter
import TestGame.Levels.SetTheory.L08_UnionInter
import TestGame.Levels.SetTheory.L09_Complement
import TestGame.Levels.SetTheory.L10_Morgan
import TestGame.Levels.SetTheory.L11_SSubset
import TestGame.Levels.SetTheory.L12_Insert
import TestGame.Levels.SetTheory.L13_Insert
import TestGame.Levels.SetTheory.L14_SetOf
import TestGame.Levels.SetTheory.L15_Powerset
import TestGame.Levels.SetTheory.L16_Disjoint
import TestGame.Levels.SetTheory.L17_SetOf
import TestGame.Levels.SetTheory.L18_SetOf
import TestGame.Levels.SetTheory.L19_Subtype
Game "TestGame" Game "TestGame"
World "SetTheory" World "SetTheory"
Title "Mengenlehre" Title "Mengenlehre"
Game "TestGame"
World "SetTheory2"
Title "Mehr Mengenlehre"

42
server/testgame/TestGame/Levels/SetTheory/L01_Univ.lean
Unescape Escape View File

@ -0,0 +1,42 @@
import TestGame.Metadata
import Mathlib.Init.Set
import Mathlib.Tactic.Tauto
set_option tactic.hygienic false
set_option autoImplicit false
Game "TestGame"
World "SetTheory"
Level 1
Title "Mengen"
Introduction
"
In diesem Kapitel schauen wir uns Mengen an.
Zuerst ein ganz wichtiger Punkt: Alle Mengen in Lean sind homogen. Das heisst,
alle Elemente in einer Menge haben den gleichen Typ.
Zum Beispiel `{1, 4, 6}` ist eine Menge von natürlichen Zahlen. Aber man kann keine
Menge `{(2 : ℕ), {3, 1}, \"e\", (1 : ℂ)}` definieren, da die Elemente unterschiedliche Typen haben.
Für einen Typen `{X : Type*}` definiert damit also `set X` der Type aller Mengen mit Elementen aus
`X`. `set.univ` ist dann ganz `X` also Menge betrachtet, und es ist wichtig den Unterschied
zu kennen: `(univ : set X)` und `(X : Typ*)` haben nicht den gleichen Typ und sind damit auch nicht
austauschbar!
Um zu beweisen, dass etwas in `univ` ist, kannst du verschiedenste deiner Taktiken anwenden,
zum Beispiel `tauto`.
"
open Set
Statement mem_univ
"4 ist ein Element der Menge aller natürlichen Zahlen." {A : Type _} (x : A) :
x ∈ (univ : Set A) := by
trivial
-- tauto
Tactics tauto trivial

29
server/testgame/TestGame/Levels/SetTheory/L02_Empty.lean
Unescape Escape View File

@ -0,0 +1,29 @@
import TestGame.Metadata
import Mathlib.Init.Set
import Mathlib.Tactic.Tauto
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 2
Title "leere Menge"
Introduction
"
Gleich wie bei `univ` gibt es leere Mengen `∅` von verschiedenen Typen.
So ist `(∅ : Set ℕ)` in Lean nicht das gleiche wie `(∅ : Set ℤ)`. (`\\empty`)
Zudem hat die Verneinung `¬ (x ∈ A)` die Notation `x ∉ A` (`\\nin`), gleich wie bei `=` and `≠`.
Um zu zeigen, dass etwas nicht in der leeren Menge ist, kannst du wieder `tauto` verwenden.
"
open Set
Statement not_mem_empty
"Kein Element ist in der leeren Menge enthalten." {A : Type _} (x : A) :
x ∉ (∅ : Set A) := by
tauto

45
server/testgame/TestGame/Levels/SetTheory/L03_Subset.lean
Unescape Escape View File

@ -0,0 +1,45 @@
import TestGame.Metadata
import Mathlib.Init.Set
import Mathlib.Tactic.Tauto
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 3
Title "Teilmengen"
Introduction
"
Hat man zwei Mengen `(A B : Set ℕ)` kann man fragen, ob diese Teilmengen
voneinander sind: `A ⊆ B` (`\\sub`/`\\ss`) ist die Notation für Teilmengen, die auch gleich
sein können.
`A ⊆ B` ist als `∀ x, x ∈ A → x ∈ B` definiert, das heisst, ein `⊆` kann immer auch mit `intro x hx`
angegangen werden.
Die Taktik `tauto` macht das automatisch, aber um dies zu lernen ist `tauto` hier deaktiviert.
Benutze also `intro`:
"
namespace MySet
open Set
theorem mem_univ {A : Type _} (x : A) : x ∈ (univ : Set A) := by
trivial
theorem not_mem_empty {A : Type _} (x : A) : x ∉ (∅ : Set A) := by
tauto
Statement subset_empty_iff
"." (A : Set ℕ) : A ⊆ univ := by
intro h hA
apply mem_univ -- or `trivial`.
Tactics intro trivial apply
-- blocked: tauto simp
end MySet

61
server/testgame/TestGame/Levels/SetTheory/L04_SubsetEmpty.lean
Unescape Escape View File

@ -0,0 +1,61 @@
import TestGame.Metadata
import TestGame.Levels.SetTheory.L03_Subset
import Mathlib.Init.Set
import Mathlib.Tactic.Tauto
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 4
Title "Teilmengen"
Introduction
"
Ein zentrales Lemma ist `Subset.antisymm_iff` welches folgendes sagt:
```
A = B ↔ A ⊆ B ∧ B ⊆ A
```
Fast immer wenn man Gleichheiten von Mengen zeigen muss, will man diese in zwei Ungleichungen
aufteilen.
"
namespace MySet
open Set
-- Copied some lemmas from `Matlib.Data.Set.Basic` in order to not import the entire file.
theorem tmp {α : Type _} {s t : Set α} : s = t → s ⊆ t :=
fun h₁ _ h₂ => by rw [← h₁] ; exact h₂
theorem Subset.antisymm_iff {α : Type _} {a b : Set α} : a = b ↔ a ⊆ b ∧ b ⊆ a :=
⟨fun e => ⟨tmp e, tmp e.symm⟩, fun ⟨h₁, h₂⟩ => Set.ext fun _ => ⟨@h₁ _, @h₂ _⟩⟩
@[simp]
theorem empty_subset {α : Type _} (s : Set α) : ∅ ⊆ s :=
fun.
Statement subset_empty_iff
"Die einzige Teilmenge der leeren Menge ist die leere Menge."
{A : Type _} (s : Set A) :
s ⊆ ∅ ↔ s = ∅ := by
constructor
intro h
rw [Subset.antisymm_iff]
constructor
assumption
simp only [empty_subset]
intro a
rw [Subset.antisymm_iff] at a
rcases a with ⟨h₁, h₂⟩
assumption
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset
end MySet

52
server/testgame/TestGame/Levels/SetTheory/L05_Empty.lean
Unescape Escape View File

@ -0,0 +1,52 @@
import TestGame.Metadata
import TestGame.Levels.SetTheory.L04_SubsetEmpty
--import Mathlib.Data.Set.Basic
import Mathlib.Init.Set
import Mathlib.Tactic.Tauto
import Mathlib.Tactic.PushNeg
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 5
Title "Nonempty"
Introduction
"
Das Gegenteil von `A = ∅` ist `A ≠ ∅`, aber in Lean wird der Ausdruck `A.Nonempty` bevorzugt.
Dieser ist dadurch existiert, dass in `A` ein Element existiert: `∃x, x ∈ A`.
Zeige dass die beiden Ausdrücke äquivalent sind:
"
namespace MySet
open Set
theorem subset_empty_iff {A : Type _} (s : Set A) : s ⊆ ∅ ↔ s = ∅ := by
constructor
intro h
rw [Subset.antisymm_iff]
constructor
assumption
simp only [empty_subset]
intro a
rw [Subset.antisymm_iff] at a
rcases a with ⟨h₁, h₂⟩
assumption
Statement eq_empty_iff_forall_not_mem
""
{A : Type _} (s : Set A) :
s = ∅ ↔ ∀ x, x ∉ s := by
rw [←subset_empty_iff]
rfl -- This is quite a miracle :)
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset
end MySet

35
server/testgame/TestGame/Levels/SetTheory/L06_Nonempty.lean
Unescape Escape View File

@ -0,0 +1,35 @@
import TestGame.Metadata
import TestGame.Levels.SetTheory.L05_Empty
import Mathlib.Data.Set.Basic
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 6
Title "Nonempty"
Introduction
"
Das Gegenteil von `A = ∅` ist `A ≠ ∅`, aber in Lean wird der Ausdruck `A.Nonempty` bevorzugt.
Dieser ist dadurch existiert, dass in `A` ein Element existiert: `∃x, x ∈ A`.
Zeige dass die beiden Ausdrücke äquivalent sind:
"
open Set
Statement nonempty_iff_ne_empty
""
{A : Type _} (s : Set A) :
s.Nonempty ↔ s ≠ ∅ := by
rw [Set.Nonempty]
rw [ne_eq, eq_empty_iff_forall_not_mem]
push_neg
rfl
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

31
server/testgame/TestGame/Levels/SetTheory/L07_UnionInter.lean
Unescape Escape View File

@ -0,0 +1,31 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 7
Title "Schnittmenge und Vereinigung"
Introduction
"
Die klassischen Mengenoperationen sind
Schnittmenge `∩` (`\\inter`), Vereinigung `∪` (`\\union`) und
Differenz `\\` (`\\\\`).
Die Taktik `simp` kann triviale Aussagen with Vereinigung mit der
leeren Menge vereinfachen.
"
open Set
Statement
"" (A B : Set ℕ) : (A ∪ ∅) ∩ B = A ∩ (univ ∩ B) := by
simp
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

35
server/testgame/TestGame/Levels/SetTheory/L08_UnionInter.lean
Unescape Escape View File

@ -0,0 +1,35 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 8
Title "Schnittmenge und Vereinigung"
Introduction
"
Ansonsten gibt es jegliche Lemmas in
`import Mathlib.Data.Set.Basic`
die beim Umgang mit diesen Operationen weiterhelfen. Schaue in der Bibliothek auf
der Seite nach Lemmas, die dir hier weiterhelfen!
"
open Set
Statement
""
(A B : Set ℕ) : univ \ (A ∩ B) = (univ \ A) ∪ (univ \ B) ∪ (A \ B) := by
rw [diff_inter]
rw [union_assoc]
rw [←union_diff_distrib]
rw [univ_union]
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

35
server/testgame/TestGame/Levels/SetTheory/L09_Complement.lean
Unescape Escape View File

@ -0,0 +1,35 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
Game "TestGame"
World "SetTheory"
Level 9
Title "Komplement"
Introduction
"
Das Komplement einer Menge wird als `Aᶜ` (`\\^c`) geschrieben. Wichtige Lemmas
sind `not_mem_compl_iff` und `compl_eq_univ_diff`.
"
open Set
#check not_mem_compl_iff
#check compl_eq_univ_diff
Statement
""
(A : Set ℕ) (h : Aᶜ ⊆ A) : A = univ := by
apply Subset.antisymm
simp only [subset_univ]
intros x hx
by_cases h4 : x ∈ Aᶜ
exact mem_of_subset_of_mem h h4
rw [←not_mem_compl_iff]
exact h4
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

58
server/testgame/TestGame/Levels/SetTheory/L10_Morgan.lean
Unescape Escape View File

@ -0,0 +1,58 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
Game "TestGame"
World "SetTheory"
Level 10
Title "Morgansche Regeln"
Introduction
"
Die De-Morgan'schen Regeln sagen `(A ∪ B)ᶜ = Aᶜ ∩ Bᶜ`
und `(A ∩ B)ᶜ = Aᶜ ∪ Bᶜ` sind in Lean als
`compl_union` und `compl_inter`.
Zudem gibt es die Lemmas `mem_compl_iff : x ∈ Aᶜ ↔ x ∉ A` und
`not_mem_compl_iff`, mit welchen
man die de-Morganschen Regeln einfach selber beweisen könnten.
Die meisten Aufgaben über Mengen sind eine Kombination von `rw` und `simp_rw` verschiedenster
Lemmas in `import Mathlib.Data.Set`.
Die Taktik `simp_rw` funktioniert ähnlich wie `rw`, aber sie versucht jedes Lemma so oft
wie möglich anzuwenden. Wir kennen also 4 etwas verwandte Optionen um Lemmas und Theoreme zu
brauchen:
- `rw [lemma_A, lemma_B]`: führt jedes Lemma genau einmal aus in der Reihenfolge.
- `simp_rw [lemma_A, lemma_B]` : führt jedes Lemma in Reihenfolge so oft aus wie möglich.
- `simp only [lemma_A, lemma_B]` : sucht eine Kombination der beiden Lemmas, ohne bestimmte
Reihenfolge.
- `simp [lemma_A, lemma_B]` : Braucht die beiden Lemmas und alle simp-Lemmas.
"
open Set
#check compl_union
#check compl_inter
#check mem_compl_iff
Statement
""
(A B C : Set ℕ) : (A \ B)ᶜ ∩ (C \ B)ᶜ = ((univ \ A) \ C) ∪ (univ \ Bᶜ) := by
rw [←compl_union]
rw [←union_diff_distrib]
rw [diff_diff]
simp_rw [←compl_eq_univ_diff]
rw [←compl_inter]
rw [diff_eq_compl_inter]
rw [inter_comm]
Tactics constructor intro rw assumption rcases simp tauto trivial
-- TODOs
-- Lemmas compl_union compl_inter mem_compl_iff

38
server/testgame/TestGame/Levels/SetTheory/L11_SSubset.lean
Unescape Escape View File

@ -0,0 +1,38 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
Game "TestGame"
World "SetTheory"
Level 11
Title "Strikte Teilmenge"
Introduction
"
Strikte Teilmengen sind in Lean eher selten, aber wir schauen sie hier
trotzdem kurz an : `A ⊂ B` (`\\ssub`) bedeutet `(A ⊆ B) ∧ (¬B ⊆ A)`.
Entsprechend, kann man die gleichen Methoden wie beim UND benützen
(`rcases`/`constructor`).
Zudem kann man mit `rw [ssubset_def]` explizit die Definition einsetzen.
Note: `rw [subset_def]` macht das gleiche für `⊆`.
"
--open Set
Statement
""
(A B : Set ℕ) (h : A ⊂ B) : ∃ x, x ∈ B \ A := by
cases' h with h₁ h₂
rw [Set.subset_def] at h₂
rw [not_forall] at h₂
cases' h₂ with x hx
use x
rw [not_imp] at hx
rw [Set.mem_diff]
exact hx
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

37
server/testgame/TestGame/Levels/SetTheory/L12_Insert.lean
Unescape Escape View File

@ -0,0 +1,37 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
Game "TestGame"
World "SetTheory"
Level 12
Title "Konkrete Mengen"
Introduction
"
Nun schauen wir uns konkrete Mengen an. Man schreibt diese mit
geschweiften Klammern: `{0, 4, 117, 3}`. Meistens muss man
den Typ explizit angeben, weil lein nicht weiss, ob man mit `Set` (Mengen)
oder `Finset` (endliche Mengen) arbeiten möchte: `({4, 9} : Set ℕ)`.
`Finset` schauen wir uns später an.
Um mit expliziten Mengen zu arbeiten, ist die Implementationsweise wichtig.
Intern ist eine Menge `{0, 9, 5, 2}` iterativ als Vereinigung von
Singletons definiert: `{0} ∪ ( {9} ∪ ( {5} ∪ {2} ))`.
Die folgende Aufgabe ist entsprechend mit `rfl` lösbar.
"
open Set
Statement
"Die Menge $\\{4, 9\\}}$ ist per Definition \\{4}\\cup\\{9\\}." :
({4, 9} : Set ℕ) = Set.insert 4 {9} := by
rfl
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

39
server/testgame/TestGame/Levels/SetTheory/L13_Insert.lean
Unescape Escape View File

@ -0,0 +1,39 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
Game "TestGame"
World "SetTheory"
Level 13
Title "Konkrete Mengen"
Introduction
"
Um zu überprüfen, dass gewisse Elemente in
konkreten Mengen enthalten sind, gibt es nicht direkt eine Taktik, aber ein
einfaches Rezept:
```
simp_rw [mem_insert_iff, mem_singleton_iff] at *
```
vereinfacht Aussagen der Form `6 ∈ { 0, 6, 1}` zu `(6 = 0) ∨ (6 = 6) ∨ (6 = 1)`,
und dann kann `tauto` diese Aussage beweisen.
Bei `⊆` kann man wie schon vorher zuerst mit `intro x hx` die Definition
auseinandernehmen und dann gleich vorgehen.
"
open Set
Statement
"" :
({2, 3, 5} : Set ℕ) ⊆ {4, 2, 5, 7, 3} := by
intro x hx
simp_rw [mem_insert_iff, mem_singleton_iff] at *
tauto
Tactics simp_rw intro tauto rw
--Lemmas Subset.antisymm_iff empty_subset

37
server/testgame/TestGame/Levels/SetTheory/L14_SetOf.lean
Unescape Escape View File

@ -0,0 +1,37 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.Parity
import Mathlib.Tactic.Ring
Game "TestGame"
World "SetTheory2"
Level 1
Title "Mengen mit Konditionen"
Introduction
"
Eine wichtige mathematische Notation ist Teilmengen zu erstellen,
die gewissen Bedingungen unterliegen.
`{n : ℕ | Odd n}` ist die Menge aller natürlichen Zahlen, die ungerade sind.
Diese Konstruktion hat in Lean den Namen `setOf`
Um zu beweisen, dass ein Element in einer Teilmenge mit Bedingungen ist, braucht
man `rw [mem_setOf]`. Danach muss man zeigen, dass die Bedinung für
dieses Element erfüllt ist.
"
open Set
Statement
"" :
3 ∈ {n : ℕ | Odd n} := by
rw [mem_setOf]
use 1
ring
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

42
server/testgame/TestGame/Levels/SetTheory/L15_Powerset.lean
Unescape Escape View File

@ -0,0 +1,42 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.Parity
import Mathlib.Tactic.Ring
import TestGame.ToBePorted
Game "TestGame"
World "SetTheory2"
Level 2
Title "Potenzmenge"
Introduction
"
Eine andere wichtige Menge ist die Potenzmenge einer Menge, welche als
`𝒫 A` geschrieben wird (`\\powerset`). Diese ist als `{S | S ⊆ A}` definiert, also
alle Mengen, die in $A$ enthalten sind.
Eines der wichtigsten Lemmas ist `mem_powerset_iff: x ∈ 𝒫 s ↔ x ⊆ s` welches
im Grunde die Definition einsetzt.
"
open Set
Statement
"" (X Y : Set ℕ):
𝒫 X ∪ 𝒫 Y ⊆ 𝒫 (X ∪ Y) := by
intro A hA
rw [mem_union] at hA
simp_rw [mem_powerset_iff] at *
rcases hA with hA | hA
apply subset_union_of_subset_left
assumption
apply subset_union_of_subset_right
assumption
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

41
server/testgame/TestGame/Levels/SetTheory/L16_Disjoint.lean
Unescape Escape View File

@ -0,0 +1,41 @@
import TestGame.Metadata
import Mathlib
import Mathlib.Algebra.Parity
import Mathlib.Tactic.Ring
Game "TestGame"
World "SetTheory2"
Level 3
Title ""
Introduction
"
Um anzunehmen, dass zwei Mengen disjunkt sind schreibt man
`Disjoint S T`, welches dadurch definiert ist das die
einzige gemeinsame Teilmenge die leere Menge ist,
also etwa `A ⊆ S → A ⊆ T → A ⊆ ∅`.
Beachte, dass `Disjoint` in Lean genereller definiert ist als
für Mengen, deshalb siehst du die Symbole
`≤` anstatt `⊆` und `⊥` anstatt `∅`, aber diese bedeuten genau
das gleiche.
"
open Set
Statement
"" :
¬Disjoint ({n : ℤ | ∃ k, n = 2 * k} : Set ℤ) ({3, 5, 6, 9, 11} : Set ℤ) := by
unfold Disjoint
rw [not_forall] -- why not `push_neg`?
use {6}
simp
use 3
ring
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

39
server/testgame/TestGame/Levels/SetTheory/L17_SetOf.lean
Unescape Escape View File

@ -0,0 +1,39 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.Parity
import Mathlib
Game "TestGame"
World "SetTheory2"
Level 4
Title ""
Introduction
"
"
open Set
Statement
"" :
{2, 7} ⊆ {n : ℕ | n = 2 ∨ (n ≤ 10 ∧ Odd n)} := by
rw [setOf_or, setOf_and]
intro x hx
rw [mem_union, mem_inter_iff]
simp_rw [mem_setOf, mem_insert_iff, mem_singleton_iff] at *
rcases hx with hx | hx
left
assumption
right
constructor
linarith
use 3
rw [hx]
ring
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

33
server/testgame/TestGame/Levels/SetTheory/L18_SetOf.lean
Unescape Escape View File

@ -0,0 +1,33 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.Parity
import Mathlib
Game "TestGame"
World "SetTheory2"
Level 5
Title ""
Introduction
"
Zu der Teilmengen-Schreibweise (`SetOf`) gibt es noch zwei spezielle
Syntax, die abundzu auftreten.
Der erste ist `{ x ∈ S | 0 ≤ x}` ( für z.B `(S : Set ℤ)`),
welcher eine Abkürzung für `{ x : ℤ | x ∈ S ∧ 0 ≤ x}` ist.
Entsprechend hilft auch hier `setOf_and`.
"
open Set
Statement
"" (S : Set ℤ) :
{ x ∈ (S : Set ℤ) | 0 ≤ x} ⊆ S := by
library_search
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

28
server/testgame/TestGame/Levels/SetTheory/L19_Subtype.lean
Unescape Escape View File

@ -0,0 +1,28 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.Parity
import Mathlib.Tactic.Ring
Game "TestGame"
World "SetTheory2"
Level 6
Title ""
Introduction
"
"
open Set
Statement
"" :
3 ∈ {n : ℕ | Odd n} := by
rw [mem_setOf]
use 1
ring
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

27
server/testgame/TestGame/Levels/SetTheory/L20_UnionInter.lean
Unescape Escape View File

@ -0,0 +1,27 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.Parity
import Mathlib
Game "TestGame"
World "SetTheory2"
Level 7
Title ""
Introduction
"
Wir haben bereits `∪` und `∩` kennengelernt. Von beiden gibt es auch eine Version für Familien
von Mengen: $\\bigcup_i A_ i$ und $\\bigcap_j B_ j$.
"
open Set
Statement
"" : True := sorry
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

28
server/testgame/TestGame/Levels/SetTheory/L21_Summary.lean
Unescape Escape View File

@ -0,0 +1,28 @@
import TestGame.Metadata
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.Parity
import Mathlib.Tactic.Ring
Game "TestGame"
World "SetTheory"
Level 21
Title ""
Introduction
"
"
open Set
Statement
"" :
3 ∈ {n : ℕ | Odd n} := by
rw [mem_setOf]
use 1
ring
Tactics constructor intro rw assumption rcases simp tauto trivial
Lemmas Subset.antisymm_iff empty_subset

109
server/testgame/TestGame/Levels/SetTheory/PowersetPlayground.lean
Unescape Escape View File

@ -0,0 +1,109 @@
import Mathlib
open Set
namespace Finset
theorem powerset_singleton {U : Type _} [DecidableEq U] (x : U) :
Finset.powerset {x} = {∅, {x}} := by
ext y
rw [mem_powerset, subset_singleton_iff, mem_insert, mem_singleton]
end Finset
/- The powerset of a singleton contains only `∅` and the singleton. -/
theorem powerset_singleton {U : Type _} (x : U) :
𝒫 ({x} : Set U) = {∅, {x}} := by
ext y
rw [mem_powerset_iff, subset_singleton_iff_eq, mem_insert_iff, mem_singleton_iff]
theorem subset_insert_iff_of_not_mem {U : Type _ } {s t : Set U} {a : U} (h : a ∉ s)
: s ⊆ insert a t ↔ s ⊆ t := by
constructor
· intro g y hy
specialize g hy
rw [mem_insert_iff] at g
rcases g with g | g
· rw [g] at hy
contradiction
· assumption
· intro g y hy
specialize g hy
exact mem_insert_of_mem _ g
theorem subset_insert_iff_of_not_mem' {U : Type _ } {s t : Set U} {a : U} (h : a ∉ s)
(g : s ⊆ t) : s ⊆ insert a t := by
intro y hy
specialize g hy
exact mem_insert_of_mem _ g
lemma mem_powerset_insert_iff {U : Type _} (A S : Set U) (x : U) :
S ∈ 𝒫 (insert x A) ↔ S ∈ 𝒫 A ∨ ∃ B ∈ 𝒫 A , insert x B = S := by
simp_rw [mem_powerset_iff]
constructor
· intro h
by_cases hs : x ∈ S
· right
use S \ {x}
rw [insert_diff_singleton, insert_eq_of_mem hs, diff_singleton_subset_iff]
exact ⟨h, rfl⟩
· left
exact (subset_insert_iff_of_not_mem hs).mp h
· intro h
rcases h with h | ⟨B, h₁, h₂⟩
· exact le_trans h (subset_insert x A)
· rw [←h₂]
exact insert_subset_insert h₁
lemma mem_powerset_insert_iff' {U : Type _} (A S : Set U) (x : U) :
S ∈ 𝒫 (insert x A) ↔ S \ {x} ∈ 𝒫 A := by
rw [mem_powerset_iff, mem_powerset_iff, diff_singleton_subset_iff]
lemma powerset_insert {U : Type _} (A : Set U) (x : U) :
𝒫 (insert x A) = A.powerset ∪ A.powerset.image (insert x) := by
ext y
rw [mem_powerset_insert_iff, mem_union, mem_image]
example : ({0} : Set ℕ) ∪ {1, 2} = {0, 2, 1} := by
rw [union_insert, singleton_union]
simp only [insert_comm, ←insert_emptyc_eq]
example : powerset {0, 1} = {∅, {0}, {1}, {0, 1}} := by
simp_rw [powerset_insert, powerset_singleton]
simp only [image_insert_eq, union_insert, image_singleton, union_singleton]
simp only [insert_comm, ←insert_emptyc_eq]
-- This one is much slower, but it still works
example : powerset {0, 1, 2, 4} =
{∅, {0}, {1}, {0, 1}, {2}, {1, 2}, {0, 2}, {0, 1, 2},
{4}, {0, 4}, {1, 4}, {0, 1, 4}, {2, 4}, {1, 2, 4}, {0, 2, 4}, {0, 1, 2, 4}} := by
simp_rw [powerset_insert, powerset_singleton]
simp only [image_insert_eq, union_insert, image_singleton, union_singleton]
simp only [insert_comm, ←insert_emptyc_eq]
example : ({∅, {0}, {1}, {0, 1}} : Finset (Finset ℕ)) = {∅, {1}, {0}, {0, 1}} := by
simp only []
example : ({{0, 2}, {3, 5, 6}} : Set (Set ℕ)) = {{2, 0}, {5, 3, 6}} := by
rw [Subset.antisymm_iff]
constructor <;>
intro A hA <;>
simp_rw [mem_insert_iff, mem_singleton_iff] at *
· rw [pair_comm 2 0, insert_comm 5 3]
tauto
· rw [pair_comm 0 2, insert_comm 3 5]
tauto
-- A trick to compare two concrete sets.
example (A : Set ℕ) : ({{0, 2}, A, {3, 5, 6}} : Set (Set ℕ)) = {{2, 0}, {5, 3, 6}, A} := by
simp only [insert_comm, ←insert_emptyc_eq]
example : ({{0, 2}, {3, 5, 6}} : Finset (Finset ℕ)) = {{2, 0}, {5, 3, 6}} := by
simp only
-- Trick:
-- attribute [default_instance] Set.instSingletonSet

250
server/testgame/TestGame/Levels/SetTheory/T01_Set.lean
Unescape Escape View File

@ -1,5 +1,15 @@
import TestGame.Metadata import TestGame.Metadata
import Mathlib.Order.SymmDiff
import Mathlib.Logic.Function.Iterate
import Mathlib.Tactic.Use
import Mathlib.Tactic.SolveByElim
import Mathlib.Tactic.Tauto
import Mathlib.Tactic.ByContra
import Mathlib.Tactic.Lift
import Mathlib.Data.Set.Basic
import Mathlib.Data.Finset.Powerset
import Mathlib.Tactic.LibrarySearch
import Mathlib import Mathlib
set_option tactic.hygienic false set_option tactic.hygienic false
@ -45,3 +55,243 @@ Statement
rw [Set.univ_union] rw [Set.univ_union]
Tactics rw Tactics rw
example : 4 ∈ (univ : Set ℕ) := by
trivial
example (A : Set ℕ) : 4 ∉ (∅ : Set ℕ) := by
trivial
example (A : Set ℕ) : A ⊆ univ := by
intro x h
trivial
-- -- subset_empty_iff
-- example {s : Set α} : s ⊆ ∅ ↔ s = ∅ := by
-- constructor
-- intro h
-- rw [Subset.antisymm_iff]
-- constructor
-- assumption
-- simp only [empty_subset]
-- intro a
-- rw [Subset.antisymm_iff] at a
-- rcases a with ⟨h₁, h₂⟩
-- assumption
-- -- eq_empty_iff_forall_not_mem
-- example {s : Set α} : s = ∅ ↔ ∀ x, x ∉ s := by
-- rw [←subset_empty_iff]
-- rfl
-- -- nonempty_iff_ne_empty
-- example (X : Type _) (s : Set X) : Set.Nonempty s ↔ s ≠ ∅ := by
-- rw [Set.Nonempty]
-- rw [ne_eq, eq_empty_iff_forall_not_mem]
-- push_neg
-- rfl
-- example (A B : ℝ): A = B ↔ A ≤ B ∧ B ≤ A := by library_search
namespace Finset
theorem powerset_singleton {U : Type _} [DecidableEq U] (x : U) :
Finset.powerset {x} = {∅, {x}} := by
ext y
rw [mem_powerset, subset_singleton_iff, mem_insert, mem_singleton]
end Finset
/- The powerset of a singleton contains only `∅` and the singleton. -/
theorem powerset_singleton {U : Type _} (x : U) :
𝒫 ({x} : Set U) = {∅, {x}} := by
ext y
rw [mem_powerset_iff, subset_singleton_iff_eq]
rw [mem_insert_iff, mem_singleton_iff]
lemma mem_powerset_insert_iff {U : Type _} (A S : Set U) (x : U) :
S ∈ 𝒫 (insert x A) ↔ S \ {x} ∈ 𝒫 A := by
rw [mem_powerset_iff, mem_powerset_iff, diff_singleton_subset_iff]
-- lemma powerset_insert {U : Type _} (A : Set U) (x : U) :
-- 𝒫 (insert x A) = 𝒫 A ∪ ({B : Set U | B \ {x} ∈ 𝒫 A}) := by
-- sorry
theorem subset_insert_iff_of_not_mem {U : Type _ }{s t : Set U} (h : a ∉ s) : s ⊆ insert a t ↔ s ⊆ t := by
rw [subset_insert_iff, erase_eq_of_not_mem h]
lemma mem_powerset_insert_iff₂ {U : Type _} (A S : Set U) (x : U) :
S ∈ 𝒫 (insert x A) ↔ S ∈ 𝒫 A ∨ ∃ B ∈ 𝒫 A , insert x B = S := by
simp_rw [mem_powerset_iff]
constructor
· intro h
by_cases hs : x ∈ S
· sorry
· left
rw [Finset.subset_insert_iff_of_not_mem]
· intro h
rcases h with h | ⟨B, h₁, h₂⟩
· exact le_trans h (subset_insert x A)
· rw [←h₂]
exact insert_subset_insert h₁
lemma powerset_insert {U : Type _} (A : Set U) (x : U) :
𝒫 (insert x A) = A.powerset ∪ A.powerset.image (insert x) := by
rw [Subset.antisymm_iff]
constructor <;>
intro B hB <;>
simp_rw [mem_powerset_insert_iff₂, mem_union, mem_image] at hB ⊢ <;>
assumption
example : powerset {0, 1} = {∅, {0}, {1}, {0, 1}} := by
simp_rw [powerset_insert, powerset_singleton, Finset.powerset_insert, Finset.powerset_singleton]
simp only [image_insert_eq, union_insert, image_singleton, union_singleton]
simp only [insert_comm, ←insert_emptyc_eq]
example [DecidableEq ℕ] : Finset.powerset {0, 1} = {∅, {0}, {1}, {0, 1}} := by
repeat' rw [@ Finset.powerset_insert ℕ]
repeat' rw [@Finset.powerset_singleton ℕ]
--simp only [image_insert_eq, union_insert, image_singleton, union_singleton]
example : powerset {0, 1, 2, 4} =
{∅, {0}, {1}, {0, 1}, {2}, {1, 2}, {0, 2}, {0, 1, 2},
{4}, {0, 4}, {1, 4}, {0, 1, 4}, {2, 4}, {1, 2, 4}, {0, 2, 4}, {0, 1, 2, 4}} := by
simp_rw [powerset_insert, powerset_singleton]
simp_rw [image_insert_eq, image_singleton]
example : Finset.powerset ({0, 1} : Finset ℕ) = {{0, 1}, ∅, {1}, {0}} := by
have h : Finset.powerset ({0, 1} : Finset ℕ) = {∅, {0}, {1}, {0, 1}}
rfl
rw [h]
simp only []
example : ({∅, {0}, {1}, {0, 1}} : Finset (Finset ℕ)) = {∅, {1}, {0}, {0, 1}} := by
simp only []
lemma subset_of_subset_diff {U : Type _} (A B C : Set U) (h : A ⊆ B \ C) : A ⊆ B :=
fun _ hx => mem_of_mem_diff (h hx)
lemma subset_of_subset_diff' {U : Type _} (A B C : Set U) (h : A ⊆ B) : A \ C ⊆ B :=
sorry
lemma mem_powerset' {U : Type _} {A B C : Set U}
(h' : B ∈ 𝒫 C) (h : A ⊆ B) :
A ∈ 𝒫 C := by
rw [mem_powerset_iff] at h' ⊢
exact le_trans h h'
example (A B : Set ℕ) : A = B ↔ ∀ x, x ∈ A ↔ x ∈ B := by
exact ext_iff
lemma NO.powerset_insert {U : Type _} (A : Set U) (x : U) :
𝒫 (insert x A) = 𝒫 A ∪ ({insert x B | B ∈ 𝒫 A}) := by
ext y
rw [mem_powerset_insert_iff]
constructor
· intro h
rw [mem_union, mem_setOf]
by_cases hx : x ∈ y
· right
use y \ {x}
constructor
· assumption
· rw [insert_diff_singleton, insert_eq_of_mem hx]
· left
rw [diff_singleton_eq_self hx] at h
assumption
· intro h
rw [mem_union, mem_setOf] at h
rcases h with h | h
· apply mem_powerset' h
simp
· rcases h with ⟨B, hB⟩
rw [←hB.2]
apply mem_powerset' hB.1
simp
-- lemma xxx {U : Type _} (x y : U):
-- ({insert x B | B ∈ {∅, }}) = {({x} : Set U), {x, y}} := by
-- sorry
-- lemma hh {U : Type _} (A : Set U) (x : U) :
-- A \ {x} ∈
lemma diff_singleton_eq_iff {U : Type _} {A B : Set U} {x : U} :
A \ {x} = B ↔ A = B ∨ A = insert x B := by sorry
lemma x1 {U : Type _} (x : U) : insert x (∅ : Set U) = {x} := by sorry
--set_option maxHeartbeats 20000
example {U : Type _} {x y : U} : ({x, y} : Set U) = {y, x} := by
exact pair_comm x y
example {U : Type _} {A : Set U} {x y : U} : insert x (insert y A) = insert y (insert x A) := by
exact insert_comm x y A
open Classical
#check decide
example : ({{0, 2}, {3, 5, 6}} : Set (Set ℕ)) = {{2, 0}, {5, 3, 6}} := by
rw [Subset.antisymm_iff]
constructor <;>
intro A hA <;>
simp_rw [mem_insert_iff, mem_singleton_iff] at *
· rw [pair_comm 2 0, insert_comm 5 3]
tauto
· rw [pair_comm 0 2, insert_comm 3 5]
tauto
example (A : Set ℕ) : ({{0, 2}, A, {3, 5, 6}} : Set (Set ℕ)) = {{2, 0}, {5, 3, 6}, A} := by
simp only [insert_comm, ←insert_emptyc_eq]
example : ({{0, 2}, {3, 5, 6}} : Finset (Finset ℕ)) = {{2, 0}, {5, 3, 6}} := by
simp only
-- -- This works but does not scale well
-- ext x
-- simp_rw [powerset_insert, powerset_singleton]
-- simp_rw [mem_union, mem_setOf, mem_insert_iff, mem_singleton_iff]
-- simp_rw [diff_singleton_eq_iff, x1]
-- tauto
-- rw [Subset.antisymm_iff]
-- constructor
-- intro A hA
-- rw [mem_powerset_iff] at hA
-- simp_rw [mem_insert_iff, mem_singleton_iff] at *
example : ({2, 3, 5} : Set ℕ) ⊆ {4, 2, 5, 7, 3} := by
intro a ha
simp_rw [Set.mem_insert_iff, Set.mem_singleton_iff] at *
tauto
example : ({0} : Set ℕ) ∪ {1, 2} = {0, 2, 1} := by
rw [Subset.antisymm_iff]
intro A hA
--rw [Set.mem_insert_iff]
-- Trick:
-- attribute [default_instance] Set.instSingletonSet

96
server/testgame/TestGame/Levels/SetTheory/T04_xx.lean
Unescape Escape View File

@ -0,0 +1,96 @@
import TestGame.Metadata
import Mathlib
import Duper.Tactic
import Mathlib.Order.Disjoint
set_option tactic.hygienic false
Game "TestGame"
World "SetTheory"
Level 4
Title "Mengen"
Introduction
"
`∈ ∉ ⊆ ⊂ ⋃ ⋂`
"
open Set
-- open_locale cardinal
variables {X : Type _} (x : X) (A B : Set X)
#check A.Nonempty
#check Nonempty A
#check insert x A -- {x} ∪ A
-- #check disjoint A B -- needs Mathlib.Order.Disjoint
#check A ∆ B
#check Nontrivial A
#check ({2} : Set ℕ)
example : ({2} : Set ℕ) ⊆ {4, 2, 3} := by
simp only [mem_singleton_iff, mem_insert_iff, or_self, singleton_subset_iff, or_false, or_true]
example : ({2, 3, 5} : Set ℕ) ⊆ {4, 2, 5, 7, 3} := by
intro n hn
simp only [mem_insert_iff, mem_singleton_iff] at *
tauto
example : {2, 3, 5} ⊆ (univ : Set ℕ) := by
tauto
example : 3 ∈ ({4, 2, 5, 7, 3} : Set ℕ) := by
tauto
example : ({4, 9} : Set ℕ) = Set.insert 4 {9} := by
rfl
#check Finset.card
variable (A : Finset ℕ)
#check A.card
-- card_union_eq
example (A B : Finset ℕ) (h : Disjoint A B) : (A ∪ B).card = A.card + B.card := by
-- Not a suitable proof for the course.
rw [← Finset.disjUnion_eq_union A B h, Finset.card_disjUnion _ _ _]
example : ¬Disjoint {n : ℤ | ∃ k, n = 2 * k} {3, 5, 6, 9, 11} := by
rw [not_disjoint_iff]
use 6
constructor
rw [mem_setOf_eq]
use 3
tauto
example : {n : ℕ | Even n ∨ Odd n} = univ := by
rw [setOf_or]
#check Set.eq_of_mem_singleton
#check {n : ℤ | ∃ k, n = 2 * k}
#check {n : ℤ // ∃ k, n = 2 * k}
#check ℤ
variables (C : Set ℤ)
#check {n ∈ C | ∃ (k : ℤ), n = 2 * k}
#check {n : ℤ | n ∈ C ∧ ∃ (k : ℤ), n = 2 * k}
#check {x ∈ A | x = x}
#check {y | y ∈ A}
#check setOf_and
#check setOf_or
#check Disjoint C univ
example : {n ∈ C | ∃ (k : ℤ), n = 2 * k} = {n : ℤ | n ∈ C ∧ ∃ (k : ℤ), n = 2 * k} := by
rfl

13
server/testgame/TestGame/TacticDocs.lean
Unescape Escape View File

@ -81,6 +81,12 @@ mit Theoremen/Lemmas der Form `X = Y`
TODO TODO
" "
TacticDoc simp_rw
"
## Beschreibung
TODO
"
TacticDoc apply TacticDoc apply
" "
@ -96,6 +102,13 @@ TacticDoc constructor
TODO TODO
" "
TacticDoc tauto
"
## Beschreibung
TODO
"
TacticDoc rcases TacticDoc rcases
" "
## Beschreibung ## Beschreibung

70
server/testgame/TestGame/ToBePorted.lean
Unescape Escape View File

@ -14,3 +14,73 @@ lemma even_square (n : ℕ) : Even n → Even (n ^ 2) := by
ring ring
theorem nat_succ (n : ℕ) : Nat.succ n = n + 1 := rfl theorem nat_succ (n : ℕ) : Nat.succ n = n + 1 := rfl
section powerset
open Set
namespace Finset
theorem powerset_singleton {U : Type _} [DecidableEq U] (x : U) :
Finset.powerset {x} = {∅, {x}} := by
ext y
rw [mem_powerset, subset_singleton_iff, mem_insert, mem_singleton]
end Finset
/- The powerset of a singleton contains only `∅` and the singleton. -/
theorem powerset_singleton {U : Type _} (x : U) :
𝒫 ({x} : Set U) = {∅, {x}} := by
ext y
rw [mem_powerset_iff, subset_singleton_iff_eq, mem_insert_iff, mem_singleton_iff]
theorem subset_insert_iff_of_not_mem {U : Type _ } {s t : Set U} {a : U} (h : a ∉ s)
: s ⊆ insert a t ↔ s ⊆ t := by
constructor
· intro g y hy
specialize g hy
rw [mem_insert_iff] at g
rcases g with g | g
· rw [g] at hy
contradiction
· assumption
· intro g y hy
specialize g hy
exact mem_insert_of_mem _ g
theorem subset_insert_iff_of_not_mem' {U : Type _ } {s t : Set U} {a : U} (h : a ∉ s)
(g : s ⊆ t) : s ⊆ insert a t := by
intro y hy
specialize g hy
exact mem_insert_of_mem _ g
lemma mem_powerset_insert_iff {U : Type _} (A S : Set U) (x : U) :
S ∈ 𝒫 (insert x A) ↔ S ∈ 𝒫 A ∨ ∃ B ∈ 𝒫 A , insert x B = S := by
simp_rw [mem_powerset_iff]
constructor
· intro h
by_cases hs : x ∈ S
· right
use S \ {x}
rw [insert_diff_singleton, insert_eq_of_mem hs, diff_singleton_subset_iff]
exact ⟨h, rfl⟩
· left
exact (subset_insert_iff_of_not_mem hs).mp h
· intro h
rcases h with h | ⟨B, h₁, h₂⟩
· exact le_trans h (subset_insert x A)
· rw [←h₂]
exact insert_subset_insert h₁
lemma mem_powerset_insert_iff' {U : Type _} (A S : Set U) (x : U) :
S ∈ 𝒫 (insert x A) ↔ S \ {x} ∈ 𝒫 A := by
rw [mem_powerset_iff, mem_powerset_iff, diff_singleton_subset_iff]
lemma powerset_insert {U : Type _} (A : Set U) (x : U) :
𝒫 (insert x A) = A.powerset ∪ A.powerset.image (insert x) := by
ext y
rw [mem_powerset_insert_iff, mem_union, mem_image]
end powerset

10
server/testgame/lake-manifest.json
Unescape Escape View File

@ -28,7 +28,7 @@
{"git": {"git":
{"url": "https://github.com/leanprover-community/mathlib4.git", {"url": "https://github.com/leanprover-community/mathlib4.git",
"subDir?": null, "subDir?": null,
"rev": "8176e5d663db861cccf6fed6db2f9e5669fe6c5b", "rev": "98bc5f26ea463d9583f601c84518c95643c0ea14",
"name": "mathlib", "name": "mathlib",
"inputRev?": "master"}}, "inputRev?": "master"}},
{"git": {"git":
@ -59,6 +59,12 @@
{"git": {"git":
{"url": "https://github.com/leanprover/std4", {"url": "https://github.com/leanprover/std4",
"subDir?": null, "subDir?": null,
"rev": "5770b609aeae209cb80ac74655ee8c750c12aabd", "rev": "04b3c9831e0c141713a70e68af7e40973ec9a1ff",
"name": "std", "name": "std",
"inputRev?": "main"}},
{"git":
{"url": "/home/jeugster/Documents/Lean/duper",
"subDir?": null,
"rev": "d0fb397d96483c90969c725ad5ea307cc02bdf7d",
"name": "duper",
"inputRev?": "main"}}]} "inputRev?": "main"}}]}

3
server/testgame/lakefile.lean
Unescape Escape View File

@ -6,6 +6,9 @@ require GameServer from ".."/"leanserver"
require mathlib from git require mathlib from git
"https://github.com/leanprover-community/mathlib4.git"@"master" "https://github.com/leanprover-community/mathlib4.git"@"master"
require duper from git
"/home/jeugster/Documents/Lean/duper"@"main"
--set_option tactic.hygienic false --set_option tactic.hygienic false
--set_option autoImplicit false --set_option autoImplicit false

Write Preview
Loading…
Cancel
Save