tasksource/leandojo huggingface dataset:
Theorem: Part.fix_le
File: Mathlib/Control/LawfulFix.lean

tactic: rw [fix_eq_ωSup f]
state_before: α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
⊢ Part.fix ↑f ≤ X

tactic: apply ωSup_le _ _ _
state_before: α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
⊢ ωSup (approxChain f) ≤ X

tactic: simp only [Fix.approxChain, OrderHom.coe_fun_mk]
state_before: α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
⊢ ∀ (i : ℕ), ↑(approxChain f) i ≤ X

tactic: intro i
state_before: α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
⊢ ∀ (i : ℕ), approx (↑f) i ≤ X

tactic: induction i with
| zero => dsimp [Fix.approx]; apply bot_le
| succ _ i_ih => trans f X; apply f.monotone i_ih ; apply hX
state_before: α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
i : ℕ
⊢ approx (↑f) i ≤ X

tactic: dsimp [Fix.approx]
state_before: case zero
α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
⊢ approx (↑f) Nat.zero ≤ X

tactic: apply bot_le
state_before: case zero
α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
⊢ ⊥ ≤ X

tactic: trans f X
state_before: case succ
α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
n✝ : ℕ
i_ih : approx (↑f) n✝ ≤ X
⊢ approx (↑f) (Nat.succ n✝) ≤ X

tactic: apply f.monotone i_ih
state_before: α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
n✝ : ℕ
i_ih : approx (↑f) n✝ ≤ X
⊢ approx (↑f) (Nat.succ n✝) ≤ ↑f X

α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
n✝ : ℕ
i_ih : approx (↑f) n✝ ≤ X
⊢ ↑f X ≤ X

tactic: apply hX
state_before: α✝ : Type u_2
β : α✝ → Type u_1
α : Type ?u.12565
f : ((a : α✝) → Part (β a)) →o (a : α✝) → Part (β a)
X : (a : α✝) → Part (β a)
hX : ↑f X ≤ X
n✝ : ℕ
i_ih : approx (↑f) n✝ ≤ X
⊢ ↑f X ≤ X
Theorem: Finset.empty_pow
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← tsub_add_cancel_of_le (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero hn), pow_succ, empty_mul]
state_before: F : Type ?u.440630
α : Type u_1
β : Type ?u.440636
γ : Type ?u.440639
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : Monoid α
s t : Finset α
a : α
m n : ℕ
hn : n ≠ 0
⊢ ∅ ^ n = ∅
Theorem: cauchySeq_of_edist_le_geometric
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: refine' cauchySeq_of_edist_le_of_tsum_ne_top _ hu _
state_before: α : Type u_1
β : Type ?u.430769
ι : Type ?u.430772
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ CauchySeq f

tactic: rw [ENNReal.tsum_mul_left, ENNReal.tsum_geometric]
state_before: α : Type u_1
β : Type ?u.430769
ι : Type ?u.430772
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ (∑' (n : ℕ), C * r ^ n) ≠ ⊤

tactic: refine' ENNReal.mul_ne_top hC (ENNReal.inv_ne_top.2 _)
state_before: α : Type u_1
β : Type ?u.430769
ι : Type ?u.430772
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ C * (1 - r)⁻¹ ≠ ⊤

tactic: exact (tsub_pos_iff_lt.2 hr).ne'
state_before: α : Type u_1
β : Type ?u.430769
ι : Type ?u.430772
inst✝ : PseudoEMetricSpace α
r C : ℝ≥0∞
hr : r < 1
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * r ^ n
⊢ 1 - r ≠ 0
Theorem: Polynomial.coeff_update_same
File: Mathlib/Data/Polynomial/Basic.lean

tactic: rw [p.coeff_update_apply, if_pos rfl]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n : ℕ
a : R
⊢ coeff (update p n a) n = a
Theorem: Set.Ico_union_Ico'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
⊢ Ico a b ∪ Ico c d = Ico (min a c) (max b d)

tactic: simp_rw [mem_union, mem_Ico, min_le_iff, lt_max_iff]
state_before: case h
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ x ∈ Ico a b ∪ Ico c d ↔ x ∈ Ico (min a c) (max b d)

tactic: by_cases hc : c ≤ x <;> by_cases hd : x < d
state_before: case h
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

tactic: simp only [hc, hd, and_self, or_true]
state_before: case pos
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c ≤ x
hd : x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

tactic: have hax : a ≤ x := h₂.trans (le_of_not_gt hd)
state_before: case neg
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c ≤ x
hd : ¬x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

tactic: simp only [hax, true_and, hc, or_self]
state_before: case neg
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c ≤ x
hd : ¬x < d
hax : a ≤ x
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

tactic: have hxb : x < b := (lt_of_not_ge hc).trans_le h₁
state_before: case pos
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c ≤ x
hd : x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

tactic: simp only [hxb, and_true, hc, false_and, or_false, true_or]
state_before: case pos
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c ≤ x
hd : x < d
hxb : x < b
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)

tactic: simp only [hc, hd, and_self, or_false]
state_before: case neg
α : Type u_1
β : Type ?u.114474
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c ≤ x
hd : ¬x < d
⊢ a ≤ x ∧ x < b ∨ c ≤ x ∧ x < d ↔ (a ≤ x ∨ c ≤ x) ∧ (x < b ∨ x < d)
Theorem: smul_inv_lt_iff_of_neg
File: Mathlib/Algebra/Order/Module.lean

tactic: rw [← smul_lt_smul_iff_of_neg h, smul_inv_smul₀ h.ne]
state_before: k : Type u_1
M : Type u_2
N : Type ?u.102476
inst✝³ : LinearOrderedField k
inst✝² : OrderedAddCommGroup M
inst✝¹ : Module k M
inst✝ : OrderedSMul k M
a b : M
c : k
h : c < 0
⊢ a < c⁻¹ • b ↔ b < c • a
Theorem: CategoryTheory.Subobject.factorThru_self
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category C
X✝ Y Z : C
D : Type u₂
inst✝ : Category D
X : C
P : Subobject X
h : Factors P (arrow P)
⊢ factorThru P (arrow P) h = 𝟙 (underlying.obj P)

tactic: simp
state_before: case h
C : Type u₁
inst✝¹ : Category C
X✝ Y Z : C
D : Type u₂
inst✝ : Category D
X : C
P : Subobject X
h : Factors P (arrow P)
⊢ factorThru P (arrow P) h ≫ arrow P = 𝟙 (underlying.obj P) ≫ arrow P
Theorem: Set.subset_image_diff
File: Mathlib/Data/Set/Image.lean

tactic: rw [diff_subset_iff, ← image_union, union_diff_self]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.47510
ι : Sort ?u.47513
ι' : Sort ?u.47516
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
⊢ f '' s \ f '' t ⊆ f '' (s \ t)

tactic: exact image_subset f (subset_union_right t s)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.47510
ι : Sort ?u.47513
ι' : Sort ?u.47516
f✝ : α → β
s✝ t✝ : Set α
f : α → β
s t : Set α
⊢ f '' s ⊆ f '' (t ∪ s)
Theorem: SimpleGraph.Walk.map_fst_darts
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simpa! using congr_arg List.dropLast (map_fst_darts_append p)
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ List.map (fun x => x.fst) (darts p) = List.dropLast (support p)
Theorem: Array.eq_of_isEqv
File: src/lean/Init/Data/Array/DecidableEq.lean

tactic: simp [Array.isEqv]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : Array α
⊢ (isEqv a b fun x y => decide (x = y)) = true → a = b

tactic: split
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : Array α
⊢ (if h : size a = size b then isEqvAux a b h (fun x y => decide (x = y)) 0 else false) = true → a = b

tactic: case inr => intro; contradiction
state_before: case inl
α : Type u_1
inst✝ : DecidableEq α
a b : Array α
h✝ : size a = size b
⊢ isEqvAux a b h✝ (fun x y => decide (x = y)) 0 = true → a = b

case inr
α : Type u_1
inst✝ : DecidableEq α
a b : Array α
h✝ : ¬size a = size b
⊢ False → a = b

tactic: case inl hsz =>
 intro h
 have aux := eq_of_isEqvAux a b hsz 0 (Nat.zero_le ..) h
 exact ext a b hsz fun i h _ => aux i (Nat.zero_le ..) _
state_before: case inl
α : Type u_1
inst✝ : DecidableEq α
a b : Array α
h✝ : size a = size b
⊢ isEqvAux a b h✝ (fun x y => decide (x = y)) 0 = true → a = b

tactic: intro
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : Array α
h✝ : ¬size a = size b
⊢ False → a = b

tactic: contradiction
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : Array α
h✝ : ¬size a = size b
a✝ : False
⊢ a = b

tactic: intro h
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : Array α
hsz : size a = size b
⊢ isEqvAux a b hsz (fun x y => decide (x = y)) 0 = true → a = b

tactic: have aux := eq_of_isEqvAux a b hsz 0 (Nat.zero_le ..) h
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : Array α
hsz : size a = size b
h : isEqvAux a b hsz (fun x y => decide (x = y)) 0 = true
⊢ a = b

tactic: exact ext a b hsz fun i h _ => aux i (Nat.zero_le ..) _
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : Array α
hsz : size a = size b
h : isEqvAux a b hsz (fun x y => decide (x = y)) 0 = true
aux : ∀ (j : Nat), 0 ≤ j → ∀ (high : j < size a), a[j] = b[j]
⊢ a = b
Theorem: AffineBasis.coord_apply_ne
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: rw [coord, AffineMap.coe_mk, ← @Subtype.coe_mk _ (fun j => j ≠ i) j h.symm, ← b.basisOf_apply,
  Basis.sumCoords_self_apply, sub_self]
state_before: ι : Type u_1
ι' : Type ?u.94243
k : Type u_2
V : Type u_4
P : Type u_3
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
h : i ≠ j
⊢ ↑(coord b i) (↑b j) = 0
Theorem: SimpleGraph.Walk.append_reverseAux
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons h _ ih => exact ih q (cons (G.symm h) r)
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x : V
p : Walk G u v
q : Walk G v w
r : Walk G u x
⊢ Walk.reverseAux (append p q) r = Walk.reverseAux q (Walk.reverseAux p r)

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x u✝ : V
q : Walk G u✝ w
r : Walk G u✝ x
⊢ Walk.reverseAux (append nil q) r = Walk.reverseAux q (Walk.reverseAux nil r)

tactic: exact ih q (cons (G.symm h) r)
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x u✝ v✝ w✝ : V
h : Adj G u✝ v✝
p✝ : Walk G v✝ w✝
ih : ∀ (q : Walk G w✝ w) (r : Walk G v✝ x), Walk.reverseAux (append p✝ q) r = Walk.reverseAux q (Walk.reverseAux p✝ r)
q : Walk G w✝ w
r : Walk G u✝ x
⊢ Walk.reverseAux (append (cons h p✝) q) r = Walk.reverseAux q (Walk.reverseAux (cons h p✝) r)
Theorem: ENNReal.iSup_add_iSup
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: cases isEmpty_or_nonempty ι
state_before: α : Type ?u.143268
β : Type ?u.143271
γ : Type ?u.143274
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f g : ι → ℝ≥0∞
h : ∀ (i j : ι), ∃ k, f i + g j ≤ f k + g k
⊢ iSup f + iSup g = ⨆ (a : ι), f a + g a

tactic: simp only [iSup_of_empty, bot_eq_zero, zero_add]
state_before: case inl
α : Type ?u.143268
β : Type ?u.143271
γ : Type ?u.143274
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f g : ι → ℝ≥0∞
h : ∀ (i j : ι), ∃ k, f i + g j ≤ f k + g k
h✝ : IsEmpty ι
⊢ iSup f + iSup g = ⨆ (a : ι), f a + g a

tactic: refine' le_antisymm _ (iSup_le fun a => add_le_add (le_iSup _ _) (le_iSup _ _))
state_before: case inr
α : Type ?u.143268
β : Type ?u.143271
γ : Type ?u.143274
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f g : ι → ℝ≥0∞
h : ∀ (i j : ι), ∃ k, f i + g j ≤ f k + g k
h✝ : Nonempty ι
⊢ iSup f + iSup g = ⨆ (a : ι), f a + g a

tactic: refine' iSup_add_iSup_le fun i j => _
state_before: case inr
α : Type ?u.143268
β : Type ?u.143271
γ : Type ?u.143274
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f g : ι → ℝ≥0∞
h : ∀ (i j : ι), ∃ k, f i + g j ≤ f k + g k
h✝ : Nonempty ι
⊢ iSup f + iSup g ≤ ⨆ (a : ι), f a + g a

tactic: rcases h i j with ⟨k, hk⟩
state_before: case inr
α : Type ?u.143268
β : Type ?u.143271
γ : Type ?u.143274
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f g : ι → ℝ≥0∞
h : ∀ (i j : ι), ∃ k, f i + g j ≤ f k + g k
h✝ : Nonempty ι
i j : ι
⊢ f i + g j ≤ ⨆ (a : ι), f a + g a

tactic: exact le_iSup_of_le k hk
state_before: case inr.intro
α : Type ?u.143268
β : Type ?u.143271
γ : Type ?u.143274
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f g : ι → ℝ≥0∞
h : ∀ (i j : ι), ∃ k, f i + g j ≤ f k + g k
h✝ : Nonempty ι
i j k : ι
hk : f i + g j ≤ f k + g k
⊢ f i + g j ≤ ⨆ (a : ι), f a + g a
Theorem: Real.logb_lt_logb
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb, logb, div_lt_div_right (log_pos hb)]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hxy : x < y
⊢ logb b x < logb b y

tactic: exact log_lt_log hx hxy
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hxy : x < y
⊢ log x < log y
Theorem: Subsemigroup.mem_sSup_of_directed_on
File: Mathlib/GroupTheory/Subsemigroup/Membership.lean

tactic: simp only [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk,
  exists_prop]
state_before: ι : Sort ?u.3746
M : Type u_1
A : Type ?u.3752
B : Type ?u.3755
inst✝ : Mul M
S : Set (Subsemigroup M)
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ sSup S ↔ ∃ s, s ∈ S ∧ x ∈ s
Theorem: TopologicalSpace.NoetherianSpace.exists_finite_set_isClosed_irreducible
File: Mathlib/Topology/NoetherianSpace.lean

tactic: lift s to Closeds α using hs
state_before: α : Type u_1
β : Type ?u.13042
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Set α
hs : IsClosed s
⊢ ∃ S, Set.Finite S ∧ (∀ (t : Set α), t ∈ S → IsClosed t) ∧ (∀ (t : Set α), t ∈ S → IsIrreducible t) ∧ s = ⋃₀ S

tactic: rcases NoetherianSpace.exists_finite_set_closeds_irreducible s with ⟨S, hSf, hS, rfl⟩
state_before: case intro
α : Type u_1
β : Type ?u.13042
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
s : Closeds α
⊢ ∃ S, Set.Finite S ∧ (∀ (t : Set α), t ∈ S → IsClosed t) ∧ (∀ (t : Set α), t ∈ S → IsIrreducible t) ∧ ↑s = ⋃₀ S

tactic: refine ⟨(↑) '' S, hSf.image _, Set.ball_image_iff.2 fun S _ => S.2, Set.ball_image_iff.2 hS, ?_⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type ?u.13042
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
S : Set (Closeds α)
hSf : Set.Finite S
hS : ∀ (t : Closeds α), t ∈ S → IsIrreducible ↑t
⊢ ∃ S_1,
    Set.Finite S_1 ∧
      (∀ (t : Set α), t ∈ S_1 → IsClosed t) ∧ (∀ (t : Set α), t ∈ S_1 → IsIrreducible t) ∧ ↑(sSup S) = ⋃₀ S_1

tactic: lift S to Finset (Closeds α) using hSf
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type ?u.13042
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
S : Set (Closeds α)
hSf : Set.Finite S
hS : ∀ (t : Closeds α), t ∈ S → IsIrreducible ↑t
⊢ ↑(sSup S) = ⋃₀ (SetLike.coe '' S)

tactic: simp [← Finset.sup_id_eq_sSup, Closeds.coe_finset_sup]
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.13042
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : NoetherianSpace α
S : Finset (Closeds α)
hS : ∀ (t : Closeds α), t ∈ ↑S → IsIrreducible ↑t
⊢ ↑(sSup ↑S) = ⋃₀ (SetLike.coe '' ↑S)
Theorem: Finset.fold_const
File: Mathlib/Data/Finset/Fold.lean

tactic: induction' s using Finset.induction_on with x s hx IH generalizing hd
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12073
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
hd : Decidable (s = ∅)
c : β
h : op c (op b c) = op b c
⊢ fold op b (fun x => c) s = if s = ∅ then b else op b c

tactic: simp
state_before: case empty
α : Type u_1
β : Type u_2
γ : Type ?u.12073
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s : Finset α
a : α
hd✝ : Decidable (s = ∅)
c : β
h : op c (op b c) = op b c
hd : Decidable (∅ = ∅)
⊢ fold op b (fun x => c) ∅ = if ∅ = ∅ then b else op b c

tactic: simp only [Finset.fold_insert hx, IH, if_false, Finset.insert_ne_empty]
state_before: case insert
α : Type u_1
β : Type u_2
γ : Type ?u.12073
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s✝ : Finset α
a : α
hd✝ : Decidable (s✝ = ∅)
c : β
h : op c (op b c) = op b c
x : α
s : Finset α
hx : ¬x ∈ s
IH : ∀ [hd : Decidable (s = ∅)], fold op b (fun x => c) s = if s = ∅ then b else op b c
hd : Decidable (insert x s = ∅)
⊢ fold op b (fun x => c) (insert x s) = if insert x s = ∅ then b else op b c

tactic: split_ifs
state_before: case insert
α : Type u_1
β : Type u_2
γ : Type ?u.12073
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s✝ : Finset α
a : α
hd✝ : Decidable (s✝ = ∅)
c : β
h : op c (op b c) = op b c
x : α
s : Finset α
hx : ¬x ∈ s
IH : ∀ [hd : Decidable (s = ∅)], fold op b (fun x => c) s = if s = ∅ then b else op b c
hd : Decidable (insert x s = ∅)
⊢ op c (if s = ∅ then b else op b c) = op b c

tactic: rw [hc.comm]
state_before: case insert.inl
α : Type u_1
β : Type u_2
γ : Type ?u.12073
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s✝ : Finset α
a : α
hd✝ : Decidable (s✝ = ∅)
c : β
h : op c (op b c) = op b c
x : α
s : Finset α
hx : ¬x ∈ s
IH : ∀ [hd : Decidable (s = ∅)], fold op b (fun x => c) s = if s = ∅ then b else op b c
hd : Decidable (insert x s = ∅)
h✝ : s = ∅
⊢ op c b = op b c

tactic: exact h
state_before: case insert.inr
α : Type u_1
β : Type u_2
γ : Type ?u.12073
op : β → β → β
hc : IsCommutative β op
ha : IsAssociative β op
f : α → β
b : β
s✝ : Finset α
a : α
hd✝ : Decidable (s✝ = ∅)
c : β
h : op c (op b c) = op b c
x : α
s : Finset α
hx : ¬x ∈ s
IH : ∀ [hd : Decidable (s = ∅)], fold op b (fun x => c) s = if s = ∅ then b else op b c
hd : Decidable (insert x s = ∅)
h✝ : ¬s = ∅
⊢ op c (op b c) = op b c
Theorem: Fin.succRecOn_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n <;> rfl
state_before: n✝ m : ℕ
C : (n : ℕ) → Fin n → Sort u_1
H0 : (n : ℕ) → C (n + 1) 0
Hs : (n : ℕ) → (i : Fin n) → C n i → C (Nat.succ n) (succ i)
n : ℕ
⊢ succRecOn 0 H0 Hs = H0 n
Theorem: GroupCat.SurjectiveOfEpiAuxs.h_apply_infinity
File: Mathlib/Algebra/Category/GroupCat/EpiMono.lean

tactic: change ((τ).symm.trans (g x)).trans τ _ = _
state_before: A B : GroupCat
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ ↑(↑h x) ∞ = ∞

tactic: simp only [MonoidHom.coe_mk, Equiv.toFun_as_coe, Equiv.coe_trans, Function.comp_apply]
state_before: A B : GroupCat
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ ↑((τ.symm.trans (↑g x)).trans τ) ∞ = ∞

tactic: rw [τ_symm_apply_infinity, g_apply_fromCoset]
state_before: A B : GroupCat
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ ↑τ (↑(↑g x) (↑τ.symm ∞)) = ∞

tactic: simpa only using τ_apply_fromCoset' f x hx
state_before: A B : GroupCat
f : A ⟶ B
x : ↑B
hx : x ∈ MonoidHom.range f
⊢ ↑τ
      (fromCoset
        {
          val :=
            x *l
              ↑{ val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
                  property :=
                    (_ :
                      ∃ y,
                        Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                          (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) },
          property :=
            (_ :
              x *l
                  ↑{ val := (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier,
                      property :=
                        (_ :
                          ∃ y,
                            Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier y =
                              (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier) } ∈
                Set.range (Function.swap leftCoset (MonoidHom.range f).toSubmonoid.toSubsemigroup.carrier)) }) =
    ∞
Theorem: Set.Icc.one_sub_nonneg
File: Mathlib/Data/Set/Intervals/Instances.lean

tactic: simpa using x.2.2
state_before: α : Type ?u.26831
inst✝¹ : OrderedSemiring α
β : Type u_1
inst✝ : OrderedRing β
x : ↑(Icc 0 1)
⊢ 0 ≤ 1 - ↑x
Theorem: GeneralizedContinuedFraction.first_continuant_eq
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [nth_cont_eq_succ_nth_cont_aux]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
zeroth_s_eq : Stream'.Seq.get? g.s 0 = some gp
⊢ continuants g 1 = { a := gp.b * g.h + gp.a, b := gp.b }

tactic: convert second_continuant_aux_eq zeroth_s_eq
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
zeroth_s_eq : Stream'.Seq.get? g.s 0 = some gp
⊢ continuantsAux g (1 + 1) = { a := gp.b * g.h + gp.a, b := gp.b }
Theorem: Filter.map₂_assoc
File: Mathlib/Order/Filter/NAry.lean

tactic: simp only [map₂_map₂_left, map₂_map₂_right, h_assoc]
state_before: α : Type u_4
α' : Type ?u.37656
β : Type u_5
β' : Type ?u.37662
γ : Type u_1
γ' : Type ?u.37668
δ : Type u_3
δ' : Type ?u.37674
ε : Type u_2
ε' : Type u_6
m✝ : α → β → γ
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : δ → γ → ε
n : α → β → δ
m' : α → ε' → ε
n' : β → γ → ε'
h : Filter γ
h_assoc : ∀ (a : α) (b : β) (c : γ), m (n a b) c = m' a (n' b c)
⊢ map₂ m (map₂ n f g) h = map₂ m' f (map₂ n' g h)
Theorem: Subtype.forall_set_subtype
File: Mathlib/Data/Set/Image.lean

tactic: rw [← forall_subset_range_iff, range_coe]
state_before: α : Type u_1
t : Set α
p : Set α → Prop
⊢ (∀ (s : Set ↑t), p (val '' s)) ↔ ∀ (s : Set α), s ⊆ t → p s
Theorem: FractionalIdeal.coeIdeal_eq_one
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simpa only [Ideal.one_eq_top] using coeIdeal_inj
state_before: R : Type u_1
inst✝⁸ : CommRing R
S : Submonoid R
P : Type ?u.1120670
inst✝⁷ : CommRing P
inst✝⁶ : Algebra R P
loc : IsLocalization S P
K : Type u_2
K' : Type ?u.1121134
inst✝⁵ : Field K
inst✝⁴ : Field K'
inst✝³ : Algebra R K
inst✝² : IsFractionRing R K
inst✝¹ : Algebra R K'
inst✝ : IsFractionRing R K'
I✝ J : FractionalIdeal R⁰ K
h : K →ₐ[R] K'
I : Ideal R
⊢ ↑I = 1 ↔ I = 1