tasksource/leandojo huggingface dataset:
Theorem: Finset.powerset_insert
File: Mathlib/Data/Finset/Powerset.lean

tactic: ext t
state_before: α : Type u_1
s✝ t : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
⊢ powerset (insert a s) = powerset s ∪ image (insert a) (powerset s)

tactic: simp only [exists_prop, mem_powerset, mem_image, mem_union, subset_insert_iff]
state_before: case a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
⊢ t ∈ powerset (insert a s) ↔ t ∈ powerset s ∪ image (insert a) (powerset s)

tactic: by_cases h : a ∈ t
state_before: case a
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
⊢ erase t a ⊆ s ↔ t ⊆ s ∨ ∃ a_1, a_1 ⊆ s ∧ insert a a_1 = t

tactic: constructor
state_before: case pos
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
⊢ erase t a ⊆ s ↔ t ⊆ s ∨ ∃ a_1, a_1 ⊆ s ∧ insert a a_1 = t

tactic: exact fun H => Or.inr ⟨_, H, insert_erase h⟩
state_before: case pos.mp
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
⊢ erase t a ⊆ s → t ⊆ s ∨ ∃ a_2, a_2 ⊆ s ∧ insert a a_2 = t

tactic: intro H
state_before: case pos.mpr
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
⊢ (t ⊆ s ∨ ∃ a_1, a_1 ⊆ s ∧ insert a a_1 = t) → erase t a ⊆ s

tactic: cases' H with H H
state_before: case pos.mpr
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
H : t ⊆ s ∨ ∃ a_1, a_1 ⊆ s ∧ insert a a_1 = t
⊢ erase t a ⊆ s

tactic: exact Subset.trans (erase_subset a t) H
state_before: case pos.mpr.inl
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
H : t ⊆ s
⊢ erase t a ⊆ s

tactic: rcases H with ⟨u, hu⟩
state_before: case pos.mpr.inr
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
H : ∃ a_1, a_1 ⊆ s ∧ insert a a_1 = t
⊢ erase t a ⊆ s

tactic: rw [← hu.2]
state_before: case pos.mpr.inr.intro
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
u : Finset α
hu : u ⊆ s ∧ insert a u = t
⊢ erase t a ⊆ s

tactic: exact Subset.trans (erase_insert_subset a u) hu.1
state_before: case pos.mpr.inr.intro
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : a ∈ t
u : Finset α
hu : u ⊆ s ∧ insert a u = t
⊢ erase (insert a u) a ⊆ s

tactic: have : ¬∃ u : Finset α, u ⊆ s ∧ insert a u = t := by simp [Ne.symm (ne_insert_of_not_mem _ _ h)]
state_before: case neg
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : ¬a ∈ t
⊢ erase t a ⊆ s ↔ t ⊆ s ∨ ∃ a_1, a_1 ⊆ s ∧ insert a a_1 = t

tactic: simp [Finset.erase_eq_of_not_mem h, this]
state_before: case neg
α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : ¬a ∈ t
this : ¬∃ u, u ⊆ s ∧ insert a u = t
⊢ erase t a ⊆ s ↔ t ⊆ s ∨ ∃ a_1, a_1 ⊆ s ∧ insert a a_1 = t

tactic: simp [Ne.symm (ne_insert_of_not_mem _ _ h)]
state_before: α : Type u_1
s✝ t✝ : Finset α
inst✝ : DecidableEq α
s : Finset α
a : α
t : Finset α
h : ¬a ∈ t
⊢ ¬∃ u, u ⊆ s ∧ insert a u = t
Theorem: Nat.dist_tri_right
File: Mathlib/Data/Nat/Dist.lean

tactic: rw [add_comm]
state_before: n m : ℕ
⊢ m ≤ n + dist n m

tactic: apply dist_tri_left
state_before: n m : ℕ
⊢ m ≤ dist n m + n
Theorem: Real.sInf_le_sSup
File: Mathlib/Data/Real/Basic.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | hne)
state_before: x y : ℝ
s : Set ℝ
h₁ : BddBelow s
h₂ : BddAbove s
⊢ sInf s ≤ sSup s

tactic: rw [sInf_empty, sSup_empty]
state_before: case inl
x y : ℝ
h₁ : BddBelow ∅
h₂ : BddAbove ∅
⊢ sInf ∅ ≤ sSup ∅

tactic: exact csInf_le_csSup h₁ h₂ hne
state_before: case inr
x y : ℝ
s : Set ℝ
h₁ : BddBelow s
h₂ : BddAbove s
hne : Set.Nonempty s
⊢ sInf s ≤ sSup s
Theorem: CauSeq.sup_eq_right
File: Mathlib/Data/Real/CauSeq.lean

tactic: obtain ⟨ε, ε0 : _ < _, i, h⟩ | h := h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : a ≤ b
⊢ a ⊔ b ≈ b

tactic: intro _ _
state_before: case inl.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ (j : ℕ), j ≥ i → ε ≤ ↑(b - a) j
⊢ a ⊔ b ≈ b

tactic: refine' ⟨i, fun j hj => _⟩
state_before: case inl.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ (j : ℕ), j ≥ i → ε ≤ ↑(b - a) j
ε✝ : α
a✝ : ε✝ > 0
⊢ ∃ i, ∀ (j : ℕ), j ≥ i → abs (↑(a ⊔ b - b) j) < ε✝

tactic: dsimp
state_before: case inl.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ (j : ℕ), j ≥ i → ε ≤ ↑(b - a) j
ε✝ : α
a✝ : ε✝ > 0
j : ℕ
hj : j ≥ i
⊢ abs (↑(a ⊔ b - b) j) < ε✝

tactic: erw [← max_sub_sub_right]
state_before: case inl.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ (j : ℕ), j ≥ i → ε ≤ ↑(b - a) j
ε✝ : α
a✝ : ε✝ > 0
j : ℕ
hj : j ≥ i
⊢ abs (↑a j ⊔ ↑b j - ↑b j) < ε✝

tactic: rwa [sub_self, max_eq_right, abs_zero]
state_before: case inl.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ (j : ℕ), j ≥ i → ε ≤ ↑(b - a) j
ε✝ : α
a✝ : ε✝ > 0
j : ℕ
hj : j ≥ i
⊢ abs (max (↑a j - ↑b j) (↑b j - ↑b j)) < ε✝

tactic: rw [sub_nonpos, ← sub_nonneg]
state_before: case inl.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ (j : ℕ), j ≥ i → ε ≤ ↑(b - a) j
ε✝ : α
a✝ : ε✝ > 0
j : ℕ
hj : j ≥ i
⊢ ↑a j - ↑b j ≤ 0

tactic: exact ε0.le.trans (h _ hj)
state_before: case inl.intro.intro.intro
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
ε : α
ε0 : 0 < ε
i : ℕ
h : ∀ (j : ℕ), j ≥ i → ε ≤ ↑(b - a) j
ε✝ : α
a✝ : ε✝ > 0
j : ℕ
hj : j ≥ i
⊢ 0 ≤ ↑b j - ↑a j

tactic: refine' Setoid.trans (sup_equiv_sup h (Setoid.refl _)) _
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : a ≈ b
⊢ a ⊔ b ≈ b

tactic: rw [CauSeq.sup_idem]
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : a ≈ b
⊢ b ⊔ b ≈ b
Theorem: OmegaCompletePartialOrder.continuous_const
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: rw [ωSup_le_iff, Chain.map_coe, OrderHom.const_coe_coe]
state_before: α : Type u
β : Type v
γ : Type ?u.12251
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
x : β
c : Chain α
z : β
⊢ ↑(↑(OrderHom.const α) x) (ωSup c) ≤ z ↔ ωSup (map c (↑(OrderHom.const α) x)) ≤ z

tactic: simp
state_before: α : Type u
β : Type v
γ : Type ?u.12251
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
x : β
c : Chain α
z : β
⊢ Function.const α x (ωSup c) ≤ z ↔ ∀ (i : ℕ), (Function.const α x ∘ ↑c) i ≤ z
Theorem: Sym2.out_snd_mem
File: Mathlib/Data/Sym/Sym2.lean

tactic: rw [eq_swap, Prod.mk.eta, e.out_eq]
state_before: α : Type u_1
β : Type ?u.34479
γ : Type ?u.34482
e : Sym2 α
⊢ e = Quotient.mk (Rel.setoid α) ((Quotient.out e).snd, (Quotient.out e).fst)
Theorem: MeasureTheory.coe_toNNReal_ae_eq
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: filter_upwards [hf]
state_before: α : Type u_1
β : Type ?u.1005622
γ : Type ?u.1005625
δ : Type ?u.1005628
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
⊢ (fun x => ↑(ENNReal.toNNReal (f x))) =ᵐ[μ] f

tactic: intro x hx
state_before: case h
α : Type u_1
β : Type ?u.1005622
γ : Type ?u.1005625
δ : Type ?u.1005628
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
⊢ ∀ (a : α), f a < ⊤ → ↑(ENNReal.toNNReal (f a)) = f a

tactic: simp only [hx.ne, Ne.def, not_false_iff, coe_toNNReal]
state_before: case h
α : Type u_1
β : Type ?u.1005622
γ : Type ?u.1005625
δ : Type ?u.1005628
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → ℝ≥0∞
hf : ∀ᵐ (x : α) ∂μ, f x < ⊤
x : α
hx : f x < ⊤
⊢ ↑(ENNReal.toNNReal (f x)) = f x
Theorem: Set.elim_preimage_pi
File: Mathlib/Data/Prod/TProd.lean

tactic: have h2 : { i | i ∈ l } = univ := by
  ext i
  simp [h]
state_before: ι : Type u
α : ι → Type v
i j : ι
l✝ : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
l : List ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
t : (i : ι) → Set (α i)
⊢ TProd.elim' h ⁻¹' pi univ t = Set.tprod l t

tactic: rw [← h2, ← mk_preimage_tprod, preimage_preimage]
state_before: ι : Type u
α : ι → Type v
i j : ι
l✝ : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
l : List ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
t : (i : ι) → Set (α i)
h2 : {i | i ∈ l} = univ
⊢ TProd.elim' h ⁻¹' pi univ t = Set.tprod l t

tactic: simp only [TProd.mk_elim hnd h]
state_before: ι : Type u
α : ι → Type v
i j : ι
l✝ : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
l : List ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
t : (i : ι) → Set (α i)
h2 : {i | i ∈ l} = univ
⊢ (fun x => TProd.mk l (TProd.elim' h x)) ⁻¹' Set.tprod l t = Set.tprod l t

tactic: dsimp
state_before: ι : Type u
α : ι → Type v
i j : ι
l✝ : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
l : List ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
t : (i : ι) → Set (α i)
h2 : {i | i ∈ l} = univ
⊢ (fun x => x) ⁻¹' Set.tprod l t = Set.tprod l t

tactic: rfl
state_before: ι : Type u
α : ι → Type v
i j : ι
l✝ : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
l : List ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
t : (i : ι) → Set (α i)
h2 : {i | i ∈ l} = univ
⊢ Set.tprod l t = Set.tprod l t

tactic: ext i
state_before: ι : Type u
α : ι → Type v
i j : ι
l✝ : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
l : List ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
t : (i : ι) → Set (α i)
⊢ {i | i ∈ l} = univ

tactic: simp [h]
state_before: case h
ι : Type u
α : ι → Type v
i✝ j : ι
l✝ : List ι
f : (i : ι) → α i
inst✝ : DecidableEq ι
l : List ι
hnd : Nodup l
h : ∀ (i : ι), i ∈ l
t : (i : ι) → Set (α i)
i : ι
⊢ i ∈ {i | i ∈ l} ↔ i ∈ univ
Theorem: continuousOn_iff
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [ContinuousOn, ContinuousWithinAt, tendsto_nhds, mem_nhdsWithin]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.311983
δ : Type ?u.311986
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
⊢ ContinuousOn f s ↔ ∀ (x : α), x ∈ s → ∀ (t : Set β), IsOpen t → f x ∈ t → ∃ u, IsOpen u ∧ x ∈ u ∧ u ∩ s ⊆ f ⁻¹' t
Theorem: Equiv.Perm.support_eq_empty_iff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: simp_rw [Finset.ext_iff, mem_support, Finset.not_mem_empty, iff_false_iff, not_not,
  Equiv.Perm.ext_iff, one_apply]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g σ : Perm α
⊢ support σ = ∅ ↔ σ = 1
Theorem: Cardinal.lsub_lt_ord_lift_of_isRegular
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rwa [hc.cof_eq]
state_before: α : Type ?u.157402
r : α → α → Prop
ι : Type u
f : ι → Ordinal
c : Cardinal
hc : IsRegular c
hι : lift (#ι) < c
⊢ lift (#ι) < Ordinal.cof (ord c)
Theorem: dfinsupp_sumAddHom_mem
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: rw [Dfinsupp.sumAddHom_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝³ : (i : ι) → AddZeroClass (β i)
inst✝² : AddCommMonoid γ
S : Type u_1
inst✝¹ : SetLike S γ
inst✝ : AddSubmonoidClass S γ
s : S
f : Π₀ (i : ι), β i
g : (i : ι) → β i →+ γ
h : ∀ (c : ι), ↑f c ≠ 0 → ↑(g c) (↑f c) ∈ s
⊢ ↑(sumAddHom g) f ∈ s
Theorem: Matrix.hadamard_one
File: Mathlib/Data/Matrix/Hadamard.lean

tactic: ext i j
state_before: α : Type u_1
β : Type ?u.17082
γ : Type ?u.17085
m : Type ?u.17088
n : Type u_2
R : Type ?u.17094
A B C : Matrix m n α
inst✝¹ : DecidableEq n
inst✝ : MulZeroOneClass α
M : Matrix n n α
⊢ M ⊙ 1 = diagonal fun i => M i i

tactic: by_cases h: i = j <;> simp [h]
state_before: case a.h
α : Type u_1
β : Type ?u.17082
γ : Type ?u.17085
m : Type ?u.17088
n : Type u_2
R : Type ?u.17094
A B C : Matrix m n α
inst✝¹ : DecidableEq n
inst✝ : MulZeroOneClass α
M : Matrix n n α
i j : n
⊢ (M ⊙ 1) i j = diagonal (fun i => M i i) i j
Theorem: Multiset.card_pi
File: Mathlib/Data/Multiset/Pi.lean

tactic: simp
state_before: α : Type u_1
inst✝ : DecidableEq α
β : α → Type u
δ : α → Sort v
m : Multiset α
t : (a : α) → Multiset (β a)
⊢ ↑card (pi 0 t) = prod (map (fun a => ↑card (t a)) 0)

tactic: simp (config := { contextual := true }) [mul_comm]
state_before: α : Type u_1
inst✝ : DecidableEq α
β : α → Type u
δ : α → Sort v
m : Multiset α
t : (a : α) → Multiset (β a)
⊢ ∀ ⦃a : α⦄ {s : Multiset α},
    ↑card (pi s t) = prod (map (fun a => ↑card (t a)) s) →
      ↑card (pi (a ::ₘ s) t) = prod (map (fun a => ↑card (t a)) (a ::ₘ s))
Theorem: ZFSet.pair_mem_prod
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp
state_before: x y a b : ZFSet
⊢ pair a b ∈ prod x y ↔ a ∈ x ∧ b ∈ y
Theorem: Rel.interedges_disjoint_right
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: rw [Finset.disjoint_left] at ht⊢
state_before: 𝕜 : Type ?u.7027
ι : Type ?u.7030
κ : Type ?u.7033
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : Disjoint t t'
⊢ Disjoint (interedges r s t) (interedges r s t')

tactic: intro _ hx hy
state_before: 𝕜 : Type ?u.7027
ι : Type ?u.7030
κ : Type ?u.7033
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → ¬a ∈ t'
⊢ ∀ ⦃a : α × β⦄, a ∈ interedges r s t → ¬a ∈ interedges r s t'

tactic: rw [mem_interedges_iff] at hx hy
state_before: 𝕜 : Type ?u.7027
ι : Type ?u.7030
κ : Type ?u.7033
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → ¬a ∈ t'
a✝ : α × β
hx : a✝ ∈ interedges r s t
hy : a✝ ∈ interedges r s t'
⊢ False

tactic: exact ht hx.2.1 hy.2.1
state_before: 𝕜 : Type ?u.7027
ι : Type ?u.7030
κ : Type ?u.7033
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s✝ s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
s : Finset α
t t' : Finset β
ht : ∀ ⦃a : β⦄, a ∈ t → ¬a ∈ t'
a✝ : α × β
hx : a✝.fst ∈ s ∧ a✝.snd ∈ t ∧ r a✝.fst a✝.snd
hy : a✝.fst ∈ s ∧ a✝.snd ∈ t' ∧ r a✝.fst a✝.snd
⊢ False
Theorem: Cardinal.cantorFunction_succ
File: Mathlib/Data/Real/Cardinality.lean

tactic: rw [cantorFunction, tsum_eq_zero_add (summable_cantor_function f h1 h2)]
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ cantorFunction c f = (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)

tactic: rw [cantorFunctionAux_succ, tsum_mul_left, cantorFunctionAux, _root_.pow_zero]
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ (cantorFunctionAux c f 0 + ∑' (b : ℕ), cantorFunctionAux c f (b + 1)) =
    (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)

tactic: rfl
state_before: c : ℝ
f✝ g : ℕ → Bool
n : ℕ
f : ℕ → Bool
h1 : 0 ≤ c
h2 : c < 1
⊢ ((bif f 0 then 1 else 0) + c * ∑' (x : ℕ), cantorFunctionAux c (fun n => f (n + 1)) x) =
    (bif f 0 then 1 else 0) + c * cantorFunction c fun n => f (n + 1)
Theorem: isGenericPoint_iff_specializes
File: Mathlib/Topology/Sober.lean

tactic: simp only [specializes_iff_mem_closure, IsGenericPoint, Set.ext_iff]
state_before: α : Type u_1
β : Type ?u.467
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
⊢ IsGenericPoint x S ↔ ∀ (y : α), x ⤳ y ↔ y ∈ S
Theorem: Filter.eventually_all
File: Mathlib/Order/Filter/Basic.lean

tactic: cases nonempty_fintype ι
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.142440
ι✝ : Sort x
ι : Type u_1
inst✝ : Finite ι
l : Filter α
p : ι → α → Prop
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι), p i x) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p i x

tactic: simpa only [Filter.Eventually, setOf_forall] using iInter_mem
state_before: case intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.142440
ι✝ : Sort x
ι : Type u_1
inst✝ : Finite ι
l : Filter α
p : ι → α → Prop
val✝ : Fintype ι
⊢ (∀ᶠ (x : α) in l, ∀ (i : ι), p i x) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p i x
Theorem: PLift.down_inj
File: Mathlib/Logic/Basic.lean

tactic: rw [h]
state_before: α : Sort u_1
a b : PLift α
h : a = b
⊢ a.down = b.down
Theorem: map_eq_top_iff
File: Mathlib/Order/Hom/Bounded.lean

tactic: letI : TopHomClass F α β := OrderIsoClass.toTopHomClass
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.6610
δ : Type ?u.6613
inst✝⁴ : LE α
inst✝³ : OrderTop α
inst✝² : PartialOrder β
inst✝¹ : OrderTop β
inst✝ : OrderIsoClass F α β
f : F
a : α
⊢ ↑f a = ⊤ ↔ a = ⊤

tactic: rw [← map_top f, (EquivLike.injective f).eq_iff]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.6610
δ : Type ?u.6613
inst✝⁴ : LE α
inst✝³ : OrderTop α
inst✝² : PartialOrder β
inst✝¹ : OrderTop β
inst✝ : OrderIsoClass F α β
f : F
a : α
this : TopHomClass F α β := OrderIsoClass.toTopHomClass
⊢ ↑f a = ⊤ ↔ a = ⊤
Theorem: MeasureTheory.SimpleFunc.range_const
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp [Function.const]
state_before: α✝ : Type ?u.14969
β : Type u_2
γ : Type ?u.14975
δ : Type ?u.14978
inst✝² : MeasurableSpace α✝
α : Type u_1
inst✝¹ : MeasurableSpace α
inst✝ : Nonempty α
b : β
⊢ ↑(SimpleFunc.range (const α b)) = ↑{b}
Theorem: Option.map_map₂_antidistrib
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp [h_antidistrib]
state_before: α : Type u_5
β : Type u_6
γ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
δ : Type u_1
β' : Type u_2
α' : Type u_3
g : γ → δ
f' : β' → α' → δ
g₁ : β → β'
g₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g₁ b) (Option.map g₂ a)
Theorem: Cardinal.univ_inaccessible
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simpa using lift_lt_univ' ℵ₀
state_before: α : Type ?u.170585
r : α → α → Prop
⊢ ℵ₀ < univ

tactic: simp
state_before: α : Type ?u.170585
r : α → α → Prop
⊢ univ ≤ Ordinal.cof (ord univ)

tactic: rcases lt_univ'.1 h with ⟨c, rfl⟩
state_before: α : Type ?u.170585
r : α → α → Prop
c : Cardinal
h : c < univ
⊢ 2 ^ c < univ

tactic: rw [← lift_two_power.{u, max (u + 1) v}]
state_before: case intro
α : Type ?u.170585
r : α → α → Prop
c : Cardinal
h : lift c < univ
⊢ 2 ^ lift c < univ

tactic: apply lift_lt_univ'
state_before: case intro
α : Type ?u.170585
r : α → α → Prop
c : Cardinal
h : lift c < univ
⊢ lift (2 ^ c) < univ
Theorem: DirectSum.coe_decompose_mul_of_left_mem_of_not_le
File: Mathlib/RingTheory/GradedAlgebra/Basic.lean

tactic: lift a to 𝒜 i using a_mem
state_before: ι : Type u_3
R : Type ?u.341327
A : Type u_1
σ : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
a b : A
n i : ι
a_mem : a ∈ 𝒜 i
h : ¬i ≤ n
⊢ ↑(↑(↑(decompose 𝒜) (a * b)) n) = 0

tactic: rwa [decompose_mul, decompose_coe, coe_of_mul_apply_of_not_le]
state_before: case intro
ι : Type u_3
R : Type ?u.341327
A : Type u_1
σ : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : CanonicallyOrderedAddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
b : A
n i : ι
h : ¬i ≤ n
a : { x // x ∈ 𝒜 i }
⊢ ↑(↑(↑(decompose 𝒜) (↑a * b)) n) = 0
Theorem: RingHom.rangeS_top_iff_surjective
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: rw [coe_rangeS, coe_top]
state_before: R : Type u
S : Type v
T : Type w
inst✝⁷ : NonAssocSemiring R
M : Submonoid R
inst✝⁶ : NonAssocSemiring S
inst✝⁵ inst✝⁴ : NonAssocSemiring T
s : Subsemiring R
σR : Type ?u.432297
σS : Type ?u.432300
inst✝³ : SetLike σR R
inst✝² : SetLike σS S
inst✝¹ : SubsemiringClass σR R
inst✝ : SubsemiringClass σS S
f : R →+* S
⊢ ↑(rangeS f) = ↑⊤ ↔ Set.range ↑f = Set.univ
Theorem: HasCompactSupport.smul_right
File: Mathlib/Topology/Support.lean

tactic: rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
state_before: X : Type ?u.26610
α : Type u_1
α' : Type ?u.26616
β : Type ?u.26619
γ : Type ?u.26622
δ : Type ?u.26625
M : Type u_3
E : Type ?u.26631
R : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
f : α → R
f' : α → M
x : α
hf : HasCompactSupport f
⊢ HasCompactSupport (f • f')

tactic: exact hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, zero_smul]
state_before: X : Type ?u.26610
α : Type u_1
α' : Type ?u.26616
β : Type ?u.26619
γ : Type ?u.26622
δ : Type ?u.26625
M : Type u_3
E : Type ?u.26631
R : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
f : α → R
f' : α → M
x : α
hf : f =ᶠ[coclosedCompact α] 0
⊢ f • f' =ᶠ[coclosedCompact α] 0

tactic: simp_rw [Pi.smul_apply', hx, Pi.zero_apply, zero_smul]
state_before: X : Type ?u.26610
α : Type u_1
α' : Type ?u.26616
β : Type ?u.26619
γ : Type ?u.26622
δ : Type ?u.26625
M : Type u_3
E : Type ?u.26631
R : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
f : α → R
f' : α → M
x✝ : α
hf : f =ᶠ[coclosedCompact α] 0
x : α
hx : f x = OfNat.ofNat 0 x
⊢ (f • f') x = OfNat.ofNat 0 x
Theorem: Ideal.quotientMap_surjective
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: simp [hx, hy]
state_before: R : Type u
S : Type v
F : Type w
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
R₁ : Type ?u.1436024
R₂ : Type ?u.1436027
A : Type ?u.1436030
B : Type ?u.1436033
inst✝⁶ : CommSemiring R₁
inst✝⁵ : CommSemiring R₂
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R₁ A
inst✝¹ : Algebra R₂ A
inst✝ : Algebra R₁ B
J : Ideal R
I : Ideal S
f : R →+* S
H : J ≤ comap f I
hf : Function.Surjective ↑f
x✝ : S ⧸ I
x : S
hx : ↑(Quotient.mk I) x = x✝
y : R
hy : ↑f y = x
⊢ ↑(quotientMap I f H) (↑(Quotient.mk J) y) = x✝
Theorem: T_def
File: Mathlib/NumberTheory/Padics/Hensel.lean

tactic: simp [T_gen, ← PadicInt.norm_def]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
F : Polynomial ℤ_[p]
a : ℤ_[p]
hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
hnsol : Polynomial.eval a F ≠ 0
⊢ T_gen p F a = ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (↑Polynomial.derivative F)‖ ^ 2
Theorem: le_iSup_iff
File: Mathlib/Order/CompleteLattice.lean

tactic: simp [iSup, le_sSup_iff, upperBounds]
state_before: α : Type u_1
β : Type ?u.27403
β₂ : Type ?u.27406
γ : Type ?u.27409
ι : Sort u_2
ι' : Sort ?u.27415
κ : ι → Sort ?u.27420
κ' : ι' → Sort ?u.27425
inst✝ : CompleteSemilatticeSup α
s✝ t : Set α
a b : α
s : ι → α
⊢ a ≤ iSup s ↔ ∀ (b : α), (∀ (i : ι), s i ≤ b) → a ≤ b
Theorem: Polynomial.card_roots_le_map_of_injective
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_cases hp0 : p = 0
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
⊢ ↑Multiset.card (roots p) ≤ ↑Multiset.card (roots (map f p))

tactic: exact card_roots_le_map ((Polynomial.map_ne_zero_iff hf).mpr hp0)
state_before: case neg
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hp0 : ¬p = 0
⊢ ↑Multiset.card (roots p) ≤ ↑Multiset.card (roots (map f p))

tactic: simp only [hp0, roots_zero, Polynomial.map_zero, Multiset.card_zero]
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hp0 : p = 0
⊢ ↑Multiset.card (roots p) ≤ ↑Multiset.card (roots (map f p))

tactic: rfl
state_before: case pos
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
hf : Function.Injective ↑f
hp0 : p = 0
⊢ 0 ≤ 0