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 | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | obtain ⟨t, _, ht, hts⟩ := Set.mem_setOf_eq.mp h | case left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
⊢ False | case left.intro.intro.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
t : Set α
left✝ : t ∈ P
ht : Subtype.val ⁻¹' t = ∅
hts : t ∩ s ≠ ∅
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | apply hts | case left.intro.intro.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
t : Set α
left✝ : t ∈ P
ht : Subtype.val ⁻¹' t = ∅
hts : t ∩ s ≠ ∅
⊢ False | case left.intro.intro.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
t : Set α
left✝ : t ∈ P
ht : Subtype.val ⁻¹' t = ∅
hts : t ∩ s ≠ ∅
⊢ t ∩ s = ∅ | Please generate a tactic in lean4 to solve the state.
STATE:
case left.intro.intro.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
t : Set α
left✝ : t ∈ P
ht : Subtype.val ⁻¹' t = ∅
hts : t ∩ s ≠ ∅
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | rw [Set.inter_comm, ← Subtype.image_preimage_coe, ht, Set.image_empty] | case left.intro.intro.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
t : Set α
left✝ : t ∈ P
ht : Subtype.val ⁻¹' t = ∅
hts : t ∩ s ≠ ∅
⊢ t ∩ s = ∅ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case left.intro.intro.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
h : ∅ ∈ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ s ≠ ∅}
t : Set α
left✝ : t ∈ P
ht : Subtype.val ⁻¹' t = ∅
hts : t ∩ s ≠ ∅
⊢ t ∩ s = ∅
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | intro a | case right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ ∀ (a : ↑s), ∃! b x, a ∈ b | case right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
⊢ ∃! b x, a ∈ b | Please generate a tactic in lean4 to solve the state.
STATE:
case right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
⊢ ∀ (a : ↑s), ∃! b x, a ∈ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | obtain ⟨t, ht⟩ := hP.right ↑a | case right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
⊢ ∃! b x, a ∈ b | case right.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (fun b => ∃! x, ↑a ∈ b) t ∧ ∀ (y : Set α), (fun b => ∃! x, ↑a ∈ b) y → y = t
⊢ ∃! b x, a ∈ b | Please generate a tactic in lean4 to solve the state.
STATE:
case right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
⊢ ∃! b x, a ∈ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | simp only [exists_unique_iff_exists, exists_prop, and_imp] at ht | case right.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (fun b => ∃! x, ↑a ∈ b) t ∧ ∀ (y : Set α), (fun b => ∃! x, ↑a ∈ b) y → y = t
⊢ ∃! b x, a ∈ b | case right.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∃! b x, a ∈ b | Please generate a tactic in lean4 to solve the state.
STATE:
case right.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (fun b => ∃! x, ↑a ∈ b) t ∧ ∀ (y : Set α), (fun b => ∃! x, ↑a ∈ b) y → y = t
⊢ ∃! b x, a ∈ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | use Subtype.val ⁻¹' t | case right.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∃! b x, a ∈ b | case h
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (fun b => ∃! x, a ∈ b) (Subtype.val ⁻¹' t) ∧ ∀ (y : Set ↑s), (fun b => ∃! x, a ∈ b) y → y = Subtype.val ⁻¹' t | Please generate a tactic in lean4 to solve the state.
STATE:
case right.intro
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∃! b x, a ∈ b
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | constructor | case h
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (fun b => ∃! x, a ∈ b) (Subtype.val ⁻¹' t) ∧ ∀ (y : Set ↑s), (fun b => ∃! x, a ∈ b) y → y = Subtype.val ⁻¹' t | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (fun b => ∃! x, a ∈ b) (Subtype.val ⁻¹' t)
case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∀ (y : Set ↑s), (fun b => ∃! x, a ∈ b) y → y = Subtype.val ⁻¹' t | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (fun b => ∃! x, a ∈ b) (Subtype.val ⁻¹' t) ∧ ∀ (y : Set ↑s), (fun b => ∃! x, a ∈ b) y → y = Subtype.val ⁻¹' t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | simp only [Ne.def, Set.mem_setOf_eq, Set.mem_preimage, exists_unique_iff_exists, exists_prop] | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (fun b => ∃! x, a ∈ b) (Subtype.val ⁻¹' t) | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (∃ t_1 ∈ P, Subtype.val ⁻¹' t_1 = Subtype.val ⁻¹' t ∧ ¬t_1 ∩ s = ∅) ∧ ↑a ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (fun b => ∃! x, a ∈ b) (Subtype.val ⁻¹' t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | refine ⟨⟨t, ht.1.1, rfl, ?_⟩, ht.1.2⟩ | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (∃ t_1 ∈ P, Subtype.val ⁻¹' t_1 = Subtype.val ⁻¹' t ∧ ¬t_1 ∩ s = ∅) ∧ ↑a ∈ t | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ¬t ∩ s = ∅ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ (∃ t_1 ∈ P, Subtype.val ⁻¹' t_1 = Subtype.val ⁻¹' t ∧ ¬t_1 ∩ s = ∅) ∧ ↑a ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | intro h | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ¬t ∩ s = ∅ | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
h : t ∩ s = ∅
⊢ False | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ¬t ∩ s = ∅
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | rw [← Set.mem_empty_iff_false (a : α), ← h] | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
h : t ∩ s = ∅
⊢ False | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
h : t ∩ s = ∅
⊢ ↑a ∈ t ∩ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
h : t ∩ s = ∅
⊢ False
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | exact Set.mem_inter ht.left.right (Subtype.mem a) | case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
h : t ∩ s = ∅
⊢ ↑a ∈ t ∩ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.left
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
h : t ∩ s = ∅
⊢ ↑a ∈ t ∩ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | simp only [Ne.def, Set.mem_setOf_eq, exists_unique_iff_exists,
exists_prop, and_imp, forall_exists_index] | case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∀ (y : Set ↑s), (fun b => ∃! x, a ∈ b) y → y = Subtype.val ⁻¹' t | case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∀ (y : Set ↑s), ∀ x ∈ P, Subtype.val ⁻¹' x = y → ¬x ∩ s = ∅ → a ∈ y → y = Subtype.val ⁻¹' t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∀ (y : Set ↑s), (fun b => ∃! x, a ∈ b) y → y = Subtype.val ⁻¹' t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | intro y x hxP hxy _ hay | case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∀ (y : Set ↑s), ∀ x ∈ P, Subtype.val ⁻¹' x = y → ¬x ∩ s = ∅ → a ∈ y → y = Subtype.val ⁻¹' t | case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ y = Subtype.val ⁻¹' t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
⊢ ∀ (y : Set ↑s), ∀ x ∈ P, Subtype.val ⁻¹' x = y → ¬x ∩ s = ∅ → a ∈ y → y = Subtype.val ⁻¹' t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | rw [← hxy, Subtype.preimage_coe_eq_preimage_coe_iff] | case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ y = Subtype.val ⁻¹' t | case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ s ∩ x = s ∩ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ y = Subtype.val ⁻¹' t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | congr | case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ s ∩ x = s ∩ t | case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ x = t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ s ∩ x = s ∩ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | apply ht.right x hxP | case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ x = t | case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ ↑a ∈ x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ x = t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | rw [← Set.mem_preimage, hxy] | case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ ↑a ∈ x | case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ a ∈ y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ ↑a ∈ x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.isPartition_on | [43, 1] | [66, 68] | exact hay | case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ a ∈ y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.right.e_a
α✝ : Type ?u.49
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Set α
a : ↑s
t : Set α
ht : (t ∈ P ∧ ↑a ∈ t) ∧ ∀ y ∈ P, ↑a ∈ y → y = t
y : Set ↑s
x : Set α
hxP : x ∈ P
hxy : Subtype.val ⁻¹' x = y
a✝ : ¬x ∩ s = ∅
hay : a ∈ y
⊢ a ∈ y
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | rw [← mul_one (Fintype.card α), ← Finset.sum_card] | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
⊢ ∑ s in c, s.card = Fintype.card α | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
⊢ ∀ (a : α), (Finset.filter (fun x => a ∈ x) c).card = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
⊢ ∑ s in c, s.card = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | intro a | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
⊢ ∀ (a : α), (Finset.filter (fun x => a ∈ x) c).card = 1 | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
⊢ (Finset.filter (fun x => a ∈ x) c).card = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
⊢ ∀ (a : α), (Finset.filter (fun x => a ∈ x) c).card = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | rw [Finset.card_eq_one] | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
⊢ (Finset.filter (fun x => a ∈ x) c).card = 1 | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
⊢ (Finset.filter (fun x => a ∈ x) c).card = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | obtain ⟨s, hs, hs'⟩ := hc.right a | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : ∃! x, a ∈ s
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | simp only [Set.mem_setOf_eq, exists_unique_iff_exists, exists_eq_left', exists_prop, and_imp] at hs hs' | case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : ∃! x, a ∈ s
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : ∃! x, a ∈ s
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | have hs'2 : ∀ z : Finset α, z ∈ c → a ∈ z → z = s.toFinset := by
intro z hz ha
rw [← Finset.coe_inj, Set.coe_toFinset]
refine hs' z ?_ (Finset.mem_coe.mpr ha)
simp only [Finset.toFinset_coe, hz] | case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | use s.toFinset | case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case h
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
⊢ Finset.filter (fun x => a ∈ x) c = {Set.toFinset s} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | ext t | case h
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
⊢ Finset.filter (fun x => a ∈ x) c = {Set.toFinset s} | case h.a
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ Finset.filter (fun x => a ∈ x) c ↔ t ∈ {Set.toFinset s} | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
⊢ Finset.filter (fun x => a ∈ x) c = {Set.toFinset s}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | simp only [Finset.mem_filter, Finset.mem_singleton] | case h.a
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ Finset.filter (fun x => a ∈ x) c ↔ t ∈ {Set.toFinset s} | case h.a
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ c ∧ a ∈ t ↔ t = Set.toFinset s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ Finset.filter (fun x => a ∈ x) c ↔ t ∈ {Set.toFinset s}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | constructor | case h.a
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ c ∧ a ∈ t ↔ t = Set.toFinset s | case h.a.mp
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ c ∧ a ∈ t → t = Set.toFinset s
case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t = Set.toFinset s → t ∈ c ∧ a ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ c ∧ a ∈ t ↔ t = Set.toFinset s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | intro z hz ha | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
⊢ ∀ z ∈ c, a ∈ z → z = Set.toFinset s | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ z = Set.toFinset s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
⊢ ∀ z ∈ c, a ∈ z → z = Set.toFinset s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | rw [← Finset.coe_inj, Set.coe_toFinset] | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ z = Set.toFinset s | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ ↑z = s | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ z = Set.toFinset s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | refine hs' z ?_ (Finset.mem_coe.mpr ha) | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ ↑z = s | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ Set.toFinset ↑z ∈ c | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ ↑z = s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | simp only [Finset.toFinset_coe, hz] | α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ Set.toFinset ↑z ∈ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
z : Finset α
hz : z ∈ c
ha : a ∈ z
⊢ Set.toFinset ↑z ∈ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | rintro ⟨ht, ha⟩ | case h.a.mp
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ c ∧ a ∈ t → t = Set.toFinset s | case h.a.mp.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t ∈ c
ha : a ∈ t
⊢ t = Set.toFinset s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.mp
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t ∈ c ∧ a ∈ t → t = Set.toFinset s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | exact hs'2 t ht ha | case h.a.mp.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t ∈ c
ha : a ∈ t
⊢ t = Set.toFinset s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.mp.intro
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t ∈ c
ha : a ∈ t
⊢ t = Set.toFinset s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | intro ht | case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t = Set.toFinset s → t ∈ c ∧ a ∈ t | case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t = Set.toFinset s
⊢ t ∈ c ∧ a ∈ t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
⊢ t = Set.toFinset s → t ∈ c ∧ a ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | simp only [ht, Set.mem_toFinset] | case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t = Set.toFinset s
⊢ t ∈ c ∧ a ∈ t | case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t = Set.toFinset s
⊢ Set.toFinset s ∈ c ∧ a ∈ s | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t = Set.toFinset s
⊢ t ∈ c ∧ a ∈ t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition' | [77, 1] | [98, 13] | exact hs | case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t = Set.toFinset s
⊢ Set.toFinset s ∈ c ∧ a ∈ s | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.mpr
α : Type u_1
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c}
a : α
s : Set α
hs : Set.toFinset s ∈ c ∧ a ∈ s
hs' : ∀ (y : Set α), Set.toFinset y ∈ c → a ∈ y → y = s
hs'2 : ∀ z ∈ c, a ∈ z → z = Set.toFinset s
t : Finset α
ht : t = Set.toFinset s
⊢ Set.toFinset s ∈ c ∧ a ∈ s
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | let c' : Finset (Finset α) := {s : Finset α | (s : Set α) ∈ c}.toFinset | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | have hcc' : c = {s : Set α | ∃ t : Finset α, s.toFinset = t ∧ t ∈ c'} := by
simp only [c', Set.toFinset_setOf, Finset.mem_univ, forall_true_left,
Finset.mem_filter, true_and, exists_eq_left', Set.coe_toFinset, Set.setOf_mem_eq] | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | rw [hcc'] at hc | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | rw [← Partition.card_of_partition' hc] | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | have hi : ∀ a ∈ c.toFinset, a.toFinset ∈ c' := by
intro a ha
simp only [c', Set.toFinset_setOf, Finset.mem_univ, forall_true_left,
Finset.mem_filter, Set.coe_toFinset, true_and]
simp only [Set.mem_toFinset] at ha
exact ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | have hj : ∀ a ∈ c', (a : Set α) ∈ c.toFinset := by
intro a ha
simp only [c', Set.toFinset_setOf, Finset.mem_univ, forall_true_left,
Finset.mem_filter, true_and] at ha
simp only [Set.mem_toFinset]
exact ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | rw [Finset.sum_bij' _ _ hi hj _ _] | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ Set.toFinset c, (Set.toFinset a).card = (Set.toFinset a).card
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ Set.toFinset c, ↑(Set.toFinset a) = a
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ c', Set.toFinset ↑a = a | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∑ s in Set.toFinset c, (Set.toFinset s).card = ∑ s in c', s.card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | all_goals { intros; simp only [Set.coe_toFinset, Finset.toFinset_coe] } | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ Set.toFinset c, (Set.toFinset a).card = (Set.toFinset a).card
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ Set.toFinset c, ↑(Set.toFinset a) = a
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ c', Set.toFinset ↑a = a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ Set.toFinset c, (Set.toFinset a).card = (Set.toFinset a).card
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ Set.toFinset c, ↑(Set.toFinset a) = a
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ c', Set.toFinset ↑a = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | simp only [c', Set.toFinset_setOf, Finset.mem_univ, forall_true_left,
Finset.mem_filter, true_and, exists_eq_left', Set.coe_toFinset, Set.setOf_mem_eq] | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
⊢ c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'} | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
hc : Setoid.IsPartition c
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
⊢ c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | intro a ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c' | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ Set.toFinset c
⊢ Set.toFinset a ∈ c' | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
⊢ ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | simp only [c', Set.toFinset_setOf, Finset.mem_univ, forall_true_left,
Finset.mem_filter, Set.coe_toFinset, true_and] | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ Set.toFinset c
⊢ Set.toFinset a ∈ c' | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ Set.toFinset c
⊢ a ∈ c | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ Set.toFinset c
⊢ Set.toFinset a ∈ c'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | simp only [Set.mem_toFinset] at ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ Set.toFinset c
⊢ a ∈ c | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ c
⊢ a ∈ c | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ Set.toFinset c
⊢ a ∈ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | exact ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ c
⊢ a ∈ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
a : Set α
ha : a ∈ c
⊢ a ∈ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | intro a ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
⊢ ∀ a ∈ c', ↑a ∈ Set.toFinset c | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : a ∈ c'
⊢ ↑a ∈ Set.toFinset c | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
⊢ ∀ a ∈ c', ↑a ∈ Set.toFinset c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | simp only [c', Set.toFinset_setOf, Finset.mem_univ, forall_true_left,
Finset.mem_filter, true_and] at ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : a ∈ c'
⊢ ↑a ∈ Set.toFinset c | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : ↑a ∈ c
⊢ ↑a ∈ Set.toFinset c | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : a ∈ c'
⊢ ↑a ∈ Set.toFinset c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | simp only [Set.mem_toFinset] | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : ↑a ∈ c
⊢ ↑a ∈ Set.toFinset c | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : ↑a ∈ c
⊢ ↑a ∈ c | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : ↑a ∈ c
⊢ ↑a ∈ Set.toFinset c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | exact ha | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : ↑a ∈ c
⊢ ↑a ∈ c | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
a : Finset α
ha : ↑a ∈ c
⊢ ↑a ∈ c
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | intros | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ c', Set.toFinset ↑a = a | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
a✝ : Finset α
ha✝ : a✝ ∈ c'
⊢ Set.toFinset ↑a✝ = a✝ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
⊢ ∀ a ∈ c', Set.toFinset ↑a = a
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition | [103, 1] | [124, 74] | simp only [Set.coe_toFinset, Finset.toFinset_coe] | α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
a✝ : Finset α
ha✝ : a✝ ∈ c'
⊢ Set.toFinset ↑a✝ = a✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝ : Fintype α
c : Set (Set α)
c' : Finset (Finset α) := Set.toFinset {s | ↑s ∈ c}
hc : Setoid.IsPartition {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hcc' : c = {s | ∃ t, Set.toFinset s = t ∧ t ∈ c'}
hi : ∀ a ∈ Set.toFinset c, Set.toFinset a ∈ c'
hj : ∀ a ∈ c', ↑a ∈ Set.toFinset c
a✝ : Finset α
ha✝ : a✝ ∈ c'
⊢ Set.toFinset ↑a✝ = a✝
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | rw [← Finset.card_biUnion] | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ (Set.toFinset s).card = ∑ t in Set.toFinset P, (Set.toFinset (s ∩ t)).card | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ (Set.toFinset s).card = (Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t)).card
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ∀ x ∈ Set.toFinset P, ∀ y ∈ Set.toFinset P, x ≠ y → Disjoint (Set.toFinset (s ∩ x)) (Set.toFinset (s ∩ y)) | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ (Set.toFinset s).card = ∑ t in Set.toFinset P, (Set.toFinset (s ∩ t)).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | apply congr_arg | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ (Set.toFinset s).card = (Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t)).card
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ∀ x ∈ Set.toFinset P, ∀ y ∈ Set.toFinset P, x ≠ y → Disjoint (Set.toFinset (s ∩ x)) (Set.toFinset (s ∩ y)) | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ Set.toFinset s = Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t)
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ∀ x ∈ Set.toFinset P, ∀ y ∈ Set.toFinset P, x ≠ y → Disjoint (Set.toFinset (s ∩ x)) (Set.toFinset (s ∩ y)) | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ (Set.toFinset s).card = (Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t)).card
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ∀ x ∈ Set.toFinset P, ∀ y ∈ Set.toFinset P, x ≠ y → Disjoint (Set.toFinset (s ∩ x)) (Set.toFinset (s ∩ y))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | rw [← Finset.coe_inj] | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ Set.toFinset s = Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t) | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ↑(Set.toFinset s) = ↑(Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ Set.toFinset s = Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | simp only [Set.coe_toFinset, Finset.coe_biUnion] | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ↑(Set.toFinset s) = ↑(Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t)) | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = ⋃ x ∈ P, s ∩ x | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ↑(Set.toFinset s) = ↑(Finset.biUnion (Set.toFinset P) fun t => Set.toFinset (s ∩ t))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | rw [Set.biUnion_eq_iUnion, ← Set.inter_iUnion, ← Set.sUnion_eq_iUnion] | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = ⋃ x ∈ P, s ∩ x | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = s ∩ ⋃₀ P | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = ⋃ x ∈ P, s ∩ x
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | rw [Setoid.IsPartition.sUnion_eq_univ hP] | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = s ∩ ⋃₀ P | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = s ∩ Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = s ∩ ⋃₀ P
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | exact (Set.inter_univ s).symm | case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = s ∩ Set.univ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ s = s ∩ Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | intro t ht u hu htu | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ∀ x ∈ Set.toFinset P, ∀ y ∈ Set.toFinset P, x ≠ y → Disjoint (Set.toFinset (s ∩ x)) (Set.toFinset (s ∩ y)) | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t : Set α
ht : t ∈ Set.toFinset P
u : Set α
hu : u ∈ Set.toFinset P
htu : t ≠ u
⊢ Disjoint (Set.toFinset (s ∩ t)) (Set.toFinset (s ∩ u)) | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
⊢ ∀ x ∈ Set.toFinset P, ∀ y ∈ Set.toFinset P, x ≠ y → Disjoint (Set.toFinset (s ∩ x)) (Set.toFinset (s ∩ y))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | simp only [Set.mem_toFinset] at ht hu | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t : Set α
ht : t ∈ Set.toFinset P
u : Set α
hu : u ∈ Set.toFinset P
htu : t ≠ u
⊢ Disjoint (Set.toFinset (s ∩ t)) (Set.toFinset (s ∩ u)) | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t u : Set α
htu : t ≠ u
ht : t ∈ P
hu : u ∈ P
⊢ Disjoint (Set.toFinset (s ∩ t)) (Set.toFinset (s ∩ u)) | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t : Set α
ht : t ∈ Set.toFinset P
u : Set α
hu : u ∈ Set.toFinset P
htu : t ≠ u
⊢ Disjoint (Set.toFinset (s ∩ t)) (Set.toFinset (s ∩ u))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | simp only [← Finset.disjoint_coe, Set.coe_toFinset] | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t u : Set α
htu : t ≠ u
ht : t ∈ P
hu : u ∈ P
⊢ Disjoint (Set.toFinset (s ∩ t)) (Set.toFinset (s ∩ u)) | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t u : Set α
htu : t ≠ u
ht : t ∈ P
hu : u ∈ P
⊢ Disjoint (s ∩ t) (s ∩ u) | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t u : Set α
htu : t ≠ u
ht : t ∈ P
hu : u ∈ P
⊢ Disjoint (Set.toFinset (s ∩ t)) (Set.toFinset (s ∩ u))
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_set_eq_sum_parts | [129, 1] | [144, 59] | exact
Set.disjoint_of_subset (Set.inter_subset_right s t) (Set.inter_subset_right s u)
(Setoid.IsPartition.pairwiseDisjoint hP ht hu htu) | α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t u : Set α
htu : t ≠ u
ht : t ∈ P
hu : u ∈ P
⊢ Disjoint (s ∩ t) (s ∩ u) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.9159
α : Type u_1
inst✝ : Fintype α
s : Set α
P : Set (Set α)
hP : IsPartition P
t u : Set α
htu : t ≠ u
ht : t ∈ P
hu : u ∈ P
⊢ Disjoint (s ∩ t) (s ∩ u)
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_eq_sum_parts | [149, 1] | [158, 24] | rw [← Finset.card_univ] | α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Fintype.card α = ∑ t in Set.toFinset P, (Set.toFinset t).card | α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Finset.univ.card = ∑ t in Set.toFinset P, (Set.toFinset t).card | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Fintype.card α = ∑ t in Set.toFinset P, (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_eq_sum_parts | [149, 1] | [158, 24] | convert Setoid.IsPartition.card_set_eq_sum_parts Set.univ hP | α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Finset.univ.card = ∑ t in Set.toFinset P, (Set.toFinset t).card | case h.e'_2.h.e'_2
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Finset.univ = Set.toFinset Set.univ
case h.e'_3.a.h.e'_2.h
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
x✝ : Set α
a✝ : x✝ ∈ Set.toFinset P
⊢ x✝ = Set.univ ∩ x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Finset.univ.card = ∑ t in Set.toFinset P, (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_eq_sum_parts | [149, 1] | [158, 24] | rw [Set.toFinset_univ.symm] | case h.e'_2.h.e'_2
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Finset.univ = Set.toFinset Set.univ | case h.e'_2.h.e'_2
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Set.toFinset Set.univ = Set.toFinset Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_2
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Finset.univ = Set.toFinset Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_eq_sum_parts | [149, 1] | [158, 24] | congr | case h.e'_2.h.e'_2
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Set.toFinset Set.univ = Set.toFinset Set.univ | case h.e'_2.h.e'_2.h.e_3.h
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Set.fintypeUniv = Subtype.fintype fun x => x ∈ Set.univ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_2
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Set.toFinset Set.univ = Set.toFinset Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_eq_sum_parts | [149, 1] | [158, 24] | simp only [eq_iff_true_of_subsingleton] | case h.e'_2.h.e'_2.h.e_3.h
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Set.fintypeUniv = Subtype.fintype fun x => x ∈ Set.univ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2.h.e'_2.h.e_3.h
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
⊢ Set.fintypeUniv = Subtype.fintype fun x => x ∈ Set.univ
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_eq_sum_parts | [149, 1] | [158, 24] | rw [Set.univ_inter] | case h.e'_3.a.h.e'_2.h
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
x✝ : Set α
a✝ : x✝ ∈ Set.toFinset P
⊢ x✝ = Set.univ ∩ x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_3.a.h.e'_2.h
α✝ : Type ?u.12056
α : Type u_1
inst✝ : Fintype α
P : Set (Set α)
hP : IsPartition P
x✝ : Set α
a✝ : x✝ ∈ Set.toFinset P
⊢ x✝ = Set.univ ∩ x✝
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | intro P' | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
⊢ let P' := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅};
s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
⊢ let P' := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅};
s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | have :=
@Partition.card_of_partition _ (FinsetCoe.fintype s) _ (Setoid.isPartition_on hP (s : Set α)) | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this :
∑ s_1 in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset s_1).card = Fintype.card ↑↑s
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | simp only [Finset.coe_sort_coe, Fintype.card_coe] at this | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this :
∑ s_1 in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset s_1).card = Fintype.card ↑↑s
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this :
∑ s_1 in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset s_1).card = Fintype.card ↑↑s
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | rw [← this] | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card =
∑ t in Set.toFinset P', (Set.toFinset t).card | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ s.card = ∑ t in Set.toFinset P', (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | apply congr_arg₂ | α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card =
∑ t in Set.toFinset P', (Set.toFinset t).card | case hx
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅} = Set.toFinset P'
case hy
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ (fun x => (Set.toFinset x).card) = fun t => (Set.toFinset t).card | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card =
∑ t in Set.toFinset P', (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | apply Finset.coe_injective | case hx
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅} = Set.toFinset P' | case hx.a
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ ↑(Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}) = ↑(Set.toFinset P') | Please generate a tactic in lean4 to solve the state.
STATE:
case hx
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅} = Set.toFinset P'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | simp only [Ne.def, Set.coe_toFinset] | case hx.a
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ ↑(Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}) = ↑(Set.toFinset P') | case hx.a
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ ¬t ∩ ↑s = ∅} = P' | Please generate a tactic in lean4 to solve the state.
STATE:
case hx.a
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ ↑(Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}) = ↑(Set.toFinset P')
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | exact rfl | case hx.a
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ ¬t ∩ ↑s = ∅} = P' | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hx.a
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ ¬t ∩ ↑s = ∅} = P'
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | ext | case hy
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ (fun x => (Set.toFinset x).card) = fun t => (Set.toFinset t).card | case hy.h
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
x✝ : Set { x // x ∈ s }
⊢ (Set.toFinset x✝).card = (Set.toFinset x✝).card | Please generate a tactic in lean4 to solve the state.
STATE:
case hy
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
⊢ (fun x => (Set.toFinset x).card) = fun t => (Set.toFinset t).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | apply congr_arg | case hy.h
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
x✝ : Set { x // x ∈ s }
⊢ (Set.toFinset x✝).card = (Set.toFinset x✝).card | case hy.h.h
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
x✝ : Set { x // x ∈ s }
⊢ Set.toFinset x✝ = Set.toFinset x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case hy.h
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
x✝ : Set { x // x ∈ s }
⊢ (Set.toFinset x✝).card = (Set.toFinset x✝).card
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Setoid.IsPartition.card_finset_eq_sum_parts | [163, 1] | [176, 48] | rw [Set.toFinset_inj] | case hy.h.h
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
x✝ : Set { x // x ∈ s }
⊢ Set.toFinset x✝ = Set.toFinset x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hy.h.h
α✝ : Type ?u.17222
α : Type u_1
P : Set (Set α)
hP : IsPartition P
s : Finset α
P' : Set (Set { x // x ∈ s }) := {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}
this : ∑ x in Set.toFinset {u | ∃ t ∈ P, Subtype.val ⁻¹' t = u ∧ t ∩ ↑s ≠ ∅}, (Set.toFinset x).card = s.card
x✝ : Set { x // x ∈ s }
⊢ Set.toFinset x✝ = Set.toFinset x✝
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | rw [← mul_one (Fintype.card α), ← Finset.sum_card] | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
⊢ ∑ s in c, s.card = Fintype.card α | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
⊢ ∀ (a : α), (Finset.filter (fun x => a ∈ x) c).card = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
⊢ ∑ s in c, s.card = Fintype.card α
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | intro a | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
⊢ ∀ (a : α), (Finset.filter (fun x => a ∈ x) c).card = 1 | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
⊢ (Finset.filter (fun x => a ∈ x) c).card = 1 | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
⊢ ∀ (a : α), (Finset.filter (fun x => a ∈ x) c).card = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | rw [Finset.card_eq_one] | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
⊢ (Finset.filter (fun x => a ∈ x) c).card = 1 | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
⊢ (Finset.filter (fun x => a ∈ x) c).card = 1
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | obtain ⟨s, ⟨hs, has⟩, hs'⟩ := hc.right a | α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}
has : (fun x => a ∈ s) hs ∧ ∀ (y : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}), (fun x => a ∈ s) y → y = hs
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | simp only [Set.mem_setOf_eq] at hs | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}
has : (fun x => a ∈ s) hs ∧ ∀ (y : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}), (fun x => a ∈ s) y → y = hs
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : ∃ t, s = ↑t ∧ t ∈ c
has : (fun x => a ∈ s) hs ∧ ∀ (y : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}), (fun x => a ∈ s) y → y = hs
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}
has : (fun x => a ∈ s) hs ∧ ∀ (y : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}), (fun x => a ∈ s) y → y = hs
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | simp only [Finset.mem_coe, Set.mem_setOf_eq, Finset.coe_inj, exists_eq_left', implies_true, and_true] at has | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : ∃ t, s = ↑t ∧ t ∈ c
has : (fun x => a ∈ s) hs ∧ ∀ (y : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}), (fun x => a ∈ s) y → y = hs
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : ∃ t, s = ↑t ∧ t ∈ c
has : a ∈ s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : ∃ t, s = ↑t ∧ t ∈ c
has : (fun x => a ∈ s) hs ∧ ∀ (y : s ∈ {s | ∃ t, s = ↑t ∧ t ∈ c}), (fun x => a ∈ s) y → y = hs
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | simp only [Set.mem_setOf_eq, exists_unique_iff_exists, exists_prop, and_imp, forall_exists_index] at hs' | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : ∃ t, s = ↑t ∧ t ∈ c
has : a ∈ s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs : ∃ t, s = ↑t ∧ t ∈ c
has : a ∈ s
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs' : ∀ (y : Set α), (fun b => ∃! x, a ∈ b) y → y = s
hs : ∃ t, s = ↑t ∧ t ∈ c
has : a ∈ s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | obtain ⟨t, rfl, ht⟩ := hs | case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs : ∃ t, s = ↑t ∧ t ∈ c
has : a ∈ s
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
s : Set α
hs : ∃ t, s = ↑t ∧ t ∈ c
has : a ∈ s
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = s
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | use t | case intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1} | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
⊢ Finset.filter (fun x => a ∈ x) c = {t} | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
⊢ ∃ a_1, Finset.filter (fun x => a ∈ x) c = {a_1}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | ext u | case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
⊢ Finset.filter (fun x => a ∈ x) c = {t} | case h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ Finset.filter (fun x => a ∈ x) c ↔ u ∈ {t} | Please generate a tactic in lean4 to solve the state.
STATE:
case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
⊢ Finset.filter (fun x => a ∈ x) c = {t}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | simp only [Finset.mem_filter, Finset.mem_singleton] | case h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ Finset.filter (fun x => a ∈ x) c ↔ u ∈ {t} | case h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ c ∧ a ∈ u ↔ u = t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ Finset.filter (fun x => a ∈ x) c ↔ u ∈ {t}
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | constructor | case h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ c ∧ a ∈ u ↔ u = t | case h.a.mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ c ∧ a ∈ u → u = t
case h.a.mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u = t → u ∈ c ∧ a ∈ u | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ c ∧ a ∈ u ↔ u = t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | rintro ⟨huc, hau⟩ | case h.a.mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ c ∧ a ∈ u → u = t | case h.a.mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
huc : u ∈ c
hau : a ∈ u
⊢ u = t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
⊢ u ∈ c ∧ a ∈ u → u = t
TACTIC:
|
https://github.com/AntoineChambert-Loir/Jordan4.git | d49910c127be01229697737a55a2d756e908d3e1 | Jordan/Mathlib/Partitions.lean | Partition.card_of_partition'' | [186, 1] | [207, 20] | rw [← Finset.coe_inj] | case h.a.mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
huc : u ∈ c
hau : a ∈ u
⊢ u = t | case h.a.mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
huc : u ∈ c
hau : a ∈ u
⊢ ↑u = ↑t | Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.mp.intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
c : Finset (Finset α)
hc : Setoid.IsPartition {s | ∃ t, s = ↑t ∧ t ∈ c}
a : α
t : Finset α
ht : t ∈ c
has : a ∈ ↑t
hs' : ∀ (y : Set α) (x : Finset α), y = ↑x → x ∈ c → a ∈ y → y = ↑t
u : Finset α
huc : u ∈ c
hau : a ∈ u
⊢ u = t
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.