url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
|
|---|---|---|---|---|---|---|---|---|
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex1.lean | inter_rectangles | [168, 1] | [193, 18] | exact hlei1 | case mpr.left
x : ℝ × ℝ
mem : x ∈ Set.singleton (1, 0)
i : ℝ
hle0i : 0 ≤ i
hlei1 : i ≤ 1
mem' : x = (1, 0)
⊢ i ≤ 1 | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex1.lean | inter_rectangles | [168, 1] | [193, 18] | rw [mem'] | case mpr.right
x : ℝ × ℝ
mem : x ∈ Set.singleton (1, 0)
i : ℝ
hle0i : 0 ≤ i
hlei1 : i ≤ 1
mem' : x = (1, 0)
⊢ x ≤ (1, i) | case mpr.right
x : ℝ × ℝ
mem : x ∈ Set.singleton (1, 0)
i : ℝ
hle0i : 0 ≤ i
hlei1 : i ≤ 1
mem' : x = (1, 0)
⊢ (1, 0) ≤ (1, i) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex1.lean | inter_rectangles | [168, 1] | [193, 18] | simp | case mpr.right
x : ℝ × ℝ
mem : x ∈ Set.singleton (1, 0)
i : ℝ
hle0i : 0 ≤ i
hlei1 : i ≤ 1
mem' : x = (1, 0)
⊢ (1, 0) ≤ (1, i) | case mpr.right
x : ℝ × ℝ
mem : x ∈ Set.singleton (1, 0)
i : ℝ
hle0i : 0 ≤ i
hlei1 : i ≤ 1
mem' : x = (1, 0)
⊢ 0 ≤ i |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex1.lean | inter_rectangles | [168, 1] | [193, 18] | exact hle0i | case mpr.right
x : ℝ × ℝ
mem : x ∈ Set.singleton (1, 0)
i : ℝ
hle0i : 0 ≤ i
hlei1 : i ≤ 1
mem' : x = (1, 0)
⊢ 0 ≤ i | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | have hucnt
: ¬(Set.Countable (({0, 1} : Set ℕ) ×ˢ (Set.univ : Set ℝ))) := by
intro hcnt
have hun : ({0, 1} : Set ℕ) = {0} ∪ {1} := by
rw [Set.union_comm, Set.union_singleton]
rw [hun] at hcnt
simp_rw
[Set.union_prod,
Set.countable_union,
Set.countable_iff_exists_injective] at hcnt
rcases hcnt with ⟨⟨f, finj⟩⟩
let g : ↑(Set.univ : Set ℝ) → ({0} ×ˢ (Set.univ : Set ℝ))
:= λ r => ⟨((0 : ℕ), r), by simp⟩
have ginj : Function.Injective g := by
intro a b heq
simp only [Subtype.mk.injEq, Prod.mk.injEq, true_and] at heq
exact SetCoe.ext heq
let fg : ↑(Set.univ : Set ℝ) → ℕ := f ∘ g
have fginj := Function.Injective.comp finj ginj
exact Cardinal.not_countable_real (Set.countable_iff_exists_injective.mpr ⟨fg, fginj⟩) | ⊢ Uncountable ({0, 1} ×ˢ Set.univ) | hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ Uncountable ({0, 1} ×ˢ Set.univ) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | constructor | hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ Uncountable ({0, 1} ×ˢ Set.univ) | case left
hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ ¬Set.Countable ({0, 1} ×ˢ Set.univ)
case right
hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ Set.Infinite ({0, 1} ×ˢ Set.univ) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | intro hcnt | ⊢ ¬Set.Countable ({0, 1} ×ˢ Set.univ) | hcnt : Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | have hun : ({0, 1} : Set ℕ) = {0} ∪ {1} := by
rw [Set.union_comm, Set.union_singleton] | hcnt : Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ False | hcnt : Set.Countable ({0, 1} ×ˢ Set.univ)
hun : {0, 1} = {0} ∪ {1}
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | rw [hun] at hcnt | hcnt : Set.Countable ({0, 1} ×ˢ Set.univ)
hun : {0, 1} = {0} ∪ {1}
⊢ False | hcnt : Set.Countable (({0} ∪ {1}) ×ˢ Set.univ)
hun : {0, 1} = {0} ∪ {1}
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | simp_rw
[Set.union_prod,
Set.countable_union,
Set.countable_iff_exists_injective] at hcnt | hcnt : Set.Countable (({0} ∪ {1}) ×ˢ Set.univ)
hun : {0, 1} = {0} ∪ {1}
⊢ False | hun : {0, 1} = {0} ∪ {1}
hcnt : (∃ f, Function.Injective f) ∧ ∃ f, Function.Injective f
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | rcases hcnt with ⟨⟨f, finj⟩⟩ | hun : {0, 1} = {0} ∪ {1}
hcnt : (∃ f, Function.Injective f) ∧ ∃ f, Function.Injective f
⊢ False | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | let g : ↑(Set.univ : Set ℝ) → ({0} ×ˢ (Set.univ : Set ℝ))
:= λ r => ⟨((0 : ℕ), r), by simp⟩ | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
⊢ False | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | have ginj : Function.Injective g := by
intro a b heq
simp only [Subtype.mk.injEq, Prod.mk.injEq, true_and] at heq
exact SetCoe.ext heq | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
⊢ False | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
ginj : Function.Injective g
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | let fg : ↑(Set.univ : Set ℝ) → ℕ := f ∘ g | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
ginj : Function.Injective g
⊢ False | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
ginj : Function.Injective g
fg : ↑Set.univ → ℕ := f ∘ g
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | have fginj := Function.Injective.comp finj ginj | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
ginj : Function.Injective g
fg : ↑Set.univ → ℕ := f ∘ g
⊢ False | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
ginj : Function.Injective g
fg : ↑Set.univ → ℕ := f ∘ g
fginj : Function.Injective (f ∘ g)
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | exact Cardinal.not_countable_real (Set.countable_iff_exists_injective.mpr ⟨fg, fginj⟩) | case intro.intro
hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
ginj : Function.Injective g
fg : ↑Set.univ → ℕ := f ∘ g
fginj : Function.Injective (f ∘ g)
⊢ False | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | rw [Set.union_comm, Set.union_singleton] | hcnt : Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ {0, 1} = {0} ∪ {1} | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | simp | hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
r : ↑Set.univ
⊢ (0, ↑r) ∈ {0} ×ˢ Set.univ | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | intro a b heq | hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
⊢ Function.Injective g | hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
a b : ↑Set.univ
heq : g a = g b
⊢ a = b |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | simp only [Subtype.mk.injEq, Prod.mk.injEq, true_and] at heq | hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
a b : ↑Set.univ
heq : g a = g b
⊢ a = b | hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
a b : ↑Set.univ
heq : ↑a = ↑b
⊢ a = b |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | exact SetCoe.ext heq | hun : {0, 1} = {0} ∪ {1}
right✝ : ∃ f, Function.Injective f
f : ↑({0} ×ˢ Set.univ) → ℕ
finj : Function.Injective f
g : ↑Set.univ → ↑({0} ×ˢ Set.univ) := fun r => { val := (0, ↑r), property := (_ : (0, ↑r) ∈ {0} ×ˢ Set.univ) }
a b : ↑Set.univ
heq : ↑a = ↑b
⊢ a = b | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | exact hucnt | case left
hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ ¬Set.Countable ({0, 1} ×ˢ Set.univ) | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | have hncnt {α : Type} {s : Set α}
: ¬Set.Countable s → Set.Infinite s := by
contrapose
simp only [Set.mem_singleton_iff, Set.not_infinite, not_not, Set.Finite.countable]
exact Set.Finite.countable | case right
hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
⊢ Set.Infinite ({0, 1} ×ˢ Set.univ) | case right
hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
hncnt : ∀ {α : Type} {s : Set α}, ¬Set.Countable s → Set.Infinite s
⊢ Set.Infinite ({0, 1} ×ˢ Set.univ) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | exact hncnt hucnt | case right
hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
hncnt : ∀ {α : Type} {s : Set α}, ¬Set.Countable s → Set.Infinite s
⊢ Set.Infinite ({0, 1} ×ˢ Set.univ) | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | contrapose | hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
α : Type
s : Set α
⊢ ¬Set.Countable s → Set.Infinite s | hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
α : Type
s : Set α
⊢ ¬Set.Infinite s → ¬¬Set.Countable s |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | simp only [Set.mem_singleton_iff, Set.not_infinite, not_not, Set.Finite.countable] | hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
α : Type
s : Set α
⊢ ¬Set.Infinite s → ¬¬Set.Countable s | hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
α : Type
s : Set α
⊢ Set.Finite s → Set.Countable s |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | prod_bin_real_uncountable | [8, 1] | [41, 22] | exact Set.Finite.countable | hucnt : ¬Set.Countable ({0, 1} ×ˢ Set.univ)
α : Type
s : Set α
⊢ Set.Finite s → Set.Countable s | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | rcases hcntiA with ⟨hcntA, _⟩ | α : Type
A B : Set α
hsub : A ⊆ B
hcntiA : Countably_Infinite A
hucnt : Uncountable B
⊢ Uncountable (B \ A) | case intro
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
⊢ Uncountable (B \ A) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | constructor | case intro
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
⊢ Uncountable (B \ A) | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
⊢ ¬Set.Countable (B \ A)
case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
⊢ Set.Infinite (B \ A) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | intro hcntmin | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
⊢ ¬Set.Countable (B \ A) | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hcntmin : Set.Countable (B \ A)
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | have hcntB := Set.Countable.union hcntA hcntmin | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hcntmin : Set.Countable (B \ A)
⊢ False | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hcntmin : Set.Countable (B \ A)
hcntB : Set.Countable (A ∪ B \ A)
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | rw [Set.union_diff_cancel hsub] at hcntB | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hcntmin : Set.Countable (B \ A)
hcntB : Set.Countable (A ∪ B \ A)
⊢ False | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hcntmin : Set.Countable (B \ A)
hcntB : Set.Countable B
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | exact hucnt.1 hcntB | case intro.left
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hcntmin : Set.Countable (B \ A)
hcntB : Set.Countable B
⊢ False | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | intro hfin | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
⊢ Set.Infinite (B \ A) | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | have hcnt := Set.Finite.countable hfin | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
⊢ False | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
hcnt : Set.Countable (B \ A)
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | have hcntB := Set.Countable.union hcntA hcnt | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
hcnt : Set.Countable (B \ A)
⊢ False | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
hcnt : Set.Countable (B \ A)
hcntB : Set.Countable (A ∪ B \ A)
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | rw [Set.union_diff_cancel hsub] at hcntB | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
hcnt : Set.Countable (B \ A)
hcntB : Set.Countable (A ∪ B \ A)
⊢ False | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
hcnt : Set.Countable (B \ A)
hcntB : Set.Countable B
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | uncountable_minus_countably_infinite_uncountable | [44, 1] | [62, 24] | exact hucnt.1 hcntB | case intro.right
α : Type
A B : Set α
hsub : A ⊆ B
hucnt : Uncountable B
hcntA : Set.Countable A
right✝ : Set.Infinite A
hfin : Set.Finite (B \ A)
hcnt : Set.Countable (B \ A)
hcntB : Set.Countable B
⊢ False | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_gt_real_card | [69, 1] | [75, 40] | simp only [Cardinal.mk_univ, indicator] | ⊢ Cardinal.mk ↑indicator > Cardinal.mk ↑Set.univ | ⊢ Cardinal.mk (ℝ → ↑binary') > Cardinal.mk ℝ |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_gt_real_card | [69, 1] | [75, 40] | rw [binary', ←Cardinal.power_def, Cardinal.mk_insert (by simp), Cardinal.mk_singleton] | ⊢ Cardinal.mk (ℝ → ↑binary') > Cardinal.mk ℝ | ⊢ (1 + 1) ^ Cardinal.mk ℝ > Cardinal.mk ℝ |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_gt_real_card | [69, 1] | [75, 40] | ring_nf | ⊢ (1 + 1) ^ Cardinal.mk ℝ > Cardinal.mk ℝ | ⊢ 2 ^ Cardinal.mk ℝ > Cardinal.mk ℝ |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_gt_real_card | [69, 1] | [75, 40] | exact Cardinal.cantor (Cardinal.mk ℝ) | ⊢ 2 ^ Cardinal.mk ℝ > Cardinal.mk ℝ | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_gt_real_card | [69, 1] | [75, 40] | simp | ⊢ 0 ∉ {1} | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | rcases b with ⟨hv, hp⟩ | b : ↑binary'
hb : ¬↑b = 1
⊢ ↑b = 0 | case mk
hv : ℕ
hp : hv ∈ binary'
hb : ¬↑{ val := hv, property := hp } = 1
⊢ ↑{ val := hv, property := hp } = 0 |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | dsimp only at * | case mk
hv : ℕ
hp : hv ∈ binary'
hb : ¬↑{ val := hv, property := hp } = 1
⊢ ↑{ val := hv, property := hp } = 0 | case mk
hv : ℕ
hp : hv ∈ binary'
hb : ¬hv = 1
⊢ hv = 0 |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | rw [binary'] at hp | case mk
hv : ℕ
hp : hv ∈ binary'
hb : ¬hv = 1
⊢ hv = 0 | case mk
hv : ℕ
hp : hv ∈ {0, 1}
hb : ¬hv = 1
⊢ hv = 0 |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | simp only [Set.mem_singleton_iff, Set.mem_insert_iff] at hp | case mk
hv : ℕ
hp : hv ∈ {0, 1}
hb : ¬hv = 1
⊢ hv = 0 | case mk
hv : ℕ
hb : ¬hv = 1
hp : hv = 0 ∨ hv = 1
⊢ hv = 0 |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | rcases hp with (h0 | h1) | case mk
hv : ℕ
hb : ¬hv = 1
hp : hv = 0 ∨ hv = 1
⊢ hv = 0 | case mk.inl
hv : ℕ
hb : ¬hv = 1
h0 : hv = 0
⊢ hv = 0
case mk.inr
hv : ℕ
hb : ¬hv = 1
h1 : hv = 1
⊢ hv = 0 |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | exact h0 | case mk.inl
hv : ℕ
hb : ¬hv = 1
h0 : hv = 0
⊢ hv = 0 | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | exfalso | case mk.inr
hv : ℕ
hb : ¬hv = 1
h1 : hv = 1
⊢ hv = 0 | case mk.inr.h
hv : ℕ
hb : ¬hv = 1
h1 : hv = 1
⊢ False |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary'_zero_eq_iff_one_eq | [77, 1] | [89, 16] | exact hb h1 | case mk.inr.h
hv : ℕ
hb : ¬hv = 1
h1 : hv = 1
⊢ False | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | cases b | a b : binary
hb : b = binary.one ↔ a = binary.one
⊢ b = binary.zero ↔ a = binary.zero | case zero
a : binary
hb : binary.zero = binary.one ↔ a = binary.one
⊢ binary.zero = binary.zero ↔ a = binary.zero
case one
a : binary
hb : binary.one = binary.one ↔ a = binary.one
⊢ binary.one = binary.zero ↔ a = binary.zero |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | simp only [false_iff, forall_true_left] at * | case zero
a : binary
hb : binary.zero = binary.one ↔ a = binary.one
⊢ binary.zero = binary.zero ↔ a = binary.zero | case zero
a : binary
hb : ¬a = binary.one
⊢ True ↔ a = binary.zero |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | cases a | case zero
a : binary
hb : ¬a = binary.one
⊢ True ↔ a = binary.zero | case zero.zero
hb : ¬binary.zero = binary.one
⊢ True ↔ binary.zero = binary.zero
case zero.one
hb : ¬binary.one = binary.one
⊢ True ↔ binary.one = binary.zero |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | simp only | case zero.zero
hb : ¬binary.zero = binary.one
⊢ True ↔ binary.zero = binary.zero | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | simp only [not_true_eq_false] at * | case zero.one
hb : ¬binary.one = binary.one
⊢ True ↔ binary.one = binary.zero | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | simp only [true_iff, false_iff] at * | case one
a : binary
hb : binary.one = binary.one ↔ a = binary.one
⊢ binary.one = binary.zero ↔ a = binary.zero | case one
a : binary
hb : a = binary.one
⊢ ¬a = binary.zero |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | cases a | case one
a : binary
hb : a = binary.one
⊢ ¬a = binary.zero | case one.zero
hb : binary.zero = binary.one
⊢ ¬binary.zero = binary.zero
case one.one
hb : binary.one = binary.one
⊢ ¬binary.one = binary.zero |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | simp only at * | case one.zero
hb : binary.zero = binary.one
⊢ ¬binary.zero = binary.zero | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_zero_eq_iff_one_eq | [97, 1] | [110, 36] | simp only [not_false_eq_true] | case one.one
hb : binary.one = binary.one
⊢ ¬binary.one = binary.zero | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_ne_one_eq_zero | [112, 1] | [119, 39] | cases b | b : binary
hb : ¬b = binary.one
⊢ b = binary.zero | case zero
hb : ¬binary.zero = binary.one
⊢ binary.zero = binary.zero
case one
hb : ¬binary.one = binary.one
⊢ binary.one = binary.zero |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_ne_one_eq_zero | [112, 1] | [119, 39] | simp only | case zero
hb : ¬binary.zero = binary.one
⊢ binary.zero = binary.zero | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | binary_ne_one_eq_zero | [112, 1] | [119, 39] | simp only [not_true_eq_false] at * | case one
hb : ¬binary.one = binary.one
⊢ binary.one = binary.zero | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | let f : indicator' → (𝒫 (Set.univ : Set ℝ)) := by
rw [indicator']
rintro ⟨fn, _⟩
exact {
val := Set.preimage fn {binary.one}
property := by simp only [Set.powerset_univ, Set.mem_univ]
} | ⊢ ∃ f, Function.Bijective f | f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ ∃ f, Function.Bijective f |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | use f | f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ ∃ f, Function.Bijective f | case h
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ Function.Bijective f |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | constructor | case h
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ Function.Bijective f | case h.left
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ Function.Injective f
case h.right
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ Function.Surjective f |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | rw [indicator'] | ⊢ ↑indicator' → ↑(𝒫 Set.univ) | ⊢ ↑Set.univ → ↑(𝒫 Set.univ) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | rintro ⟨fn, _⟩ | ⊢ ↑Set.univ → ↑(𝒫 Set.univ) | case mk
fn : ℝ → binary
property✝ : fn ∈ Set.univ
⊢ ↑(𝒫 Set.univ) |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | exact {
val := Set.preimage fn {binary.one}
property := by simp only [Set.powerset_univ, Set.mem_univ]
} | case mk
fn : ℝ → binary
property✝ : fn ∈ Set.univ
⊢ ↑(𝒫 Set.univ) | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [Set.powerset_univ, Set.mem_univ] | fn : ℝ → binary
property✝ : fn ∈ Set.univ
⊢ fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | rintro ⟨fa, _⟩ ⟨fb, _⟩ heq | case h.left
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ Function.Injective f | case h.left.mk.mk
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
heq : f { val := fa, property := property✝¹ } = f { val := fb, property := property✝ }
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [Set.powerset_univ] at f | case h.left.mk.mk
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
heq : f { val := fa, property := property✝¹ } = f { val := fb, property := property✝ }
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
heq : f✝ { val := fa, property := property✝¹ } = f✝ { val := fb, property := property✝ }
f : ↑indicator' → ↑Set.univ
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [eq_mpr_eq_cast, cast_eq, Subtype.mk.injEq] at heq | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
heq : f✝ { val := fa, property := property✝¹ } = f✝ { val := fb, property := property✝ }
f : ↑indicator' → ↑Set.univ
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : fa ⁻¹' {binary.one} = fb ⁻¹' {binary.one}
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | rw [Set.ext_iff] at heq | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : fa ⁻¹' {binary.one} = fb ⁻¹' {binary.one}
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : ∀ (x : ℝ), x ∈ fa ⁻¹' {binary.one} ↔ x ∈ fb ⁻¹' {binary.one}
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [Set.mem_preimage, Set.mem_singleton_iff] at heq | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : ∀ (x : ℝ), x ∈ fa ⁻¹' {binary.one} ↔ x ∈ fb ⁻¹' {binary.one}
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : ∀ (x : ℝ), fa x = binary.one ↔ fb x = binary.one
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | exact SetCoe.ext heqv | case h.left.mk.mk
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : ∀ (x : ℝ), fa x = binary.one ↔ fb x = binary.one
heqv : fa = fb
⊢ { val := fa, property := property✝¹ } = { val := fb, property := property✝ } | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | ext x | f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : ∀ (x : ℝ), fa x = binary.one ↔ fb x = binary.one
⊢ fa = fb | case h
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : ∀ (x : ℝ), fa x = binary.one ↔ fb x = binary.one
x : ℝ
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | specialize heq x | case h
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
heq : ∀ (x : ℝ), fa x = binary.one ↔ fb x = binary.one
x : ℝ
⊢ fa x = fb x | case h
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | have hzero_iff := binary_zero_eq_iff_one_eq heq | case h
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
⊢ fa x = fb x | case h
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | by_cases heqfa : fa x = binary.one | case h
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
⊢ fa x = fb x | case pos
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : fa x = binary.one
⊢ fa x = fb x
case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | have heqfbzero := heq.mp heqfa | case pos
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : fa x = binary.one
⊢ fa x = fb x | case pos
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : fa x = binary.one
heqfbzero : fb x = binary.one
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | rw [←heqfbzero] at heqfa | case pos
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : fa x = binary.one
heqfbzero : fb x = binary.one
⊢ fa x = fb x | case pos
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : fa x = fb x
heqfbzero : fb x = binary.one
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | exact heqfa | case pos
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : fa x = fb x
heqfbzero : fb x = binary.one
⊢ fa x = fb x | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | have heqfazero := binary_ne_one_eq_zero heqfa | case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
⊢ fa x = fb x | case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
heqfazero : fa x = binary.zero
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | have heqfbone := hzero_iff.mp heqfazero | case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
heqfazero : fa x = binary.zero
⊢ fa x = fb x | case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
heqfazero : fa x = binary.zero
heqfbone : fb x = binary.zero
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | rw [←heqfbone] at heqfazero | case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
heqfazero : fa x = binary.zero
heqfbone : fb x = binary.zero
⊢ fa x = fb x | case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
heqfazero : fa x = fb x
heqfbone : fb x = binary.zero
⊢ fa x = fb x |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | exact heqfazero | case neg
f✝ : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
fa : ℝ → binary
property✝¹ : fa ∈ indicator'
fb : ℝ → binary
property✝ : fb ∈ indicator'
f : ↑indicator' → ↑Set.univ
x : ℝ
heq : fa x = binary.one ↔ fb x = binary.one
hzero_iff : fa x = binary.zero ↔ fb x = binary.zero
heqfa : ¬fa x = binary.one
heqfazero : fa x = fb x
heqfbone : fb x = binary.zero
⊢ fa x = fb x | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | intro pw | case h.right
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
⊢ Function.Surjective f | case h.right
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ∃ a, f a = pw |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | use a | case h.right
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ ∃ a, f a = pw | case h
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ f a = pw |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [eq_mpr_eq_cast, cast_eq, eq_mp_eq_cast, Set.powerset_univ, set_coe_cast] | case h
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ f a = pw | case h
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ {
val :=
(fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹' {binary.one},
property :=
(_ :
↑{ val := fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero,
property :=
(_ :
(fun x => x ∈ Set.univ) fun x =>
if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) } ⁻¹'
{binary.one} ∈
𝒫 Set.univ) } =
pw |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | apply Subtype.eq | case h
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ {
val :=
(fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹' {binary.one},
property :=
(_ :
↑{ val := fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero,
property :=
(_ :
(fun x => x ∈ Set.univ) fun x =>
if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) } ⁻¹'
{binary.one} ∈
𝒫 Set.univ) } =
pw | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ ↑{
val :=
(fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹'
{binary.one},
property :=
(_ :
↑{ val := fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero,
property :=
(_ :
(fun x => x ∈ Set.univ) fun x =>
if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) } ⁻¹'
{binary.one} ∈
𝒫 Set.univ) } =
↑pw |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [Set.powerset_univ, set_coe_cast, Set.ext_iff] | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ ↑{
val :=
(fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹'
{binary.one},
property :=
(_ :
↑{ val := fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero,
property :=
(_ :
(fun x => x ∈ Set.univ) fun x =>
if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) } ⁻¹'
{binary.one} ∈
𝒫 Set.univ) } =
↑pw | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ ∀ (x : ℝ),
x ∈ (fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹' {binary.one} ↔
x ∈ ↑pw |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | intro x | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
⊢ ∀ (x : ℝ),
x ∈ (fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹' {binary.one} ↔
x ∈ ↑pw | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
x : ℝ
⊢ x ∈ (fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹' {binary.one} ↔
x ∈ ↑pw |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [Set.powerset_univ, set_coe_cast, Set.mem_preimage, Set.mem_singleton_iff] | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
x : ℝ
⊢ x ∈ (fun x => if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) ⁻¹' {binary.one} ↔
x ∈ ↑pw | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
x : ℝ
⊢ (if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) = binary.one ↔ x ∈ ↑pw |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | constructor | case h.a
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
x : ℝ
⊢ (if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) = binary.one ↔ x ∈ ↑pw | case h.a.mp
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
x : ℝ
⊢ (if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) = binary.one → x ∈ ↑pw
case h.a.mpr
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
a : ↑indicator' :=
Eq.mpr (_ : ↑indicator' = ↑Set.univ)
{
val := fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero,
property :=
(_ :
(fun x =>
let_fun real_set := ↑(Eq.mp (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw);
if x ∈ real_set then binary.one else binary.zero) ∈
Set.univ) }
x : ℝ
⊢ x ∈ ↑pw → (if x ∈ ↑(cast (_ : ↑(𝒫 Set.univ) = ↑Set.univ) pw) then binary.one else binary.zero) = binary.one |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | rw [indicator'] | f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ↑indicator' | f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ↑Set.univ |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | constructor | f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ↑Set.univ | case property
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ?val ∈ Set.univ
case val
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ℝ → binary |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [Set.mem_univ] | case property
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ?val ∈ Set.univ | no goals |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | intro x | case val
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
⊢ ℝ → binary | case val
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
x : ℝ
⊢ binary |
https://github.com/aronerben/lean4-playground.git | 5efced915ecee24cd723d28d00aa63f9c7ea0a9c | meetings/ex5.lean | indicator_card_eq_powerset_card_bij | [123, 1] | [178, 20] | simp only [Set.powerset_univ] at pw | case val
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
pw : ↑(𝒫 Set.univ)
x : ℝ
⊢ binary | case val
f : ↑indicator' → ↑(𝒫 Set.univ) :=
Eq.mpr (_ : (↑indicator' → ↑(𝒫 Set.univ)) = (↑Set.univ → ↑(𝒫 Set.univ))) fun a =>
Subtype.casesOn a fun fn property =>
{ val := fn ⁻¹' {binary.one}, property := (_ : fn ⁻¹' {binary.one} ∈ 𝒫 Set.univ) }
x : ℝ
pw : ↑Set.univ
⊢ binary |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.