tasksource/leandojo huggingface dataset:
Theorem: Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv_apply
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: simp
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_3
inst✝² : CommMonoid N
P : Type u_2
inst✝¹ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
Q : Type ?u.2863324
inst✝ : CommMonoid Q
k : LocalizationMap S P
x : M
⊢ ↑(toMap (ofMulEquivOfLocalizations f (mulEquivOfLocalizations f k))) x = ↑(toMap k) x
Theorem: Filter.Tendsto.prod_map_prod_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← prod_atTop_atTop_eq]
state_before: ι : Type ?u.284969
ι' : Type ?u.284972
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) atTop

tactic: exact hf.prod_map hg
state_before: ι : Type ?u.284969
ι' : Type ?u.284972
α : Type u_2
β : Type u_3
γ : Type u_1
inst✝ : SemilatticeSup γ
F : Filter α
G : Filter β
f : α → γ
g : β → γ
hf : Tendsto f F atTop
hg : Tendsto g G atTop
⊢ Tendsto (Prod.map f g) (F ×ˢ G) (atTop ×ˢ atTop)
Theorem: dist_triangle4_left
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [add_left_comm, dist_comm x₁, ← add_assoc]
state_before: α : Type u
β : Type v
X : Type ?u.10546
ι : Type ?u.10549
inst✝ : PseudoMetricSpace α
x₁ y₁ x₂ y₂ : α
⊢ dist x₂ y₂ ≤ dist x₁ y₁ + (dist x₁ x₂ + dist y₁ y₂)

tactic: apply dist_triangle4
state_before: α : Type u
β : Type v
X : Type ?u.10546
ι : Type ?u.10549
inst✝ : PseudoMetricSpace α
x₁ y₁ x₂ y₂ : α
⊢ dist x₂ y₂ ≤ dist x₂ x₁ + dist x₁ y₁ + dist y₁ y₂
Theorem: CategoryTheory.congrArg_cast_hom_left
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: cases p
state_before: C : Type u₁
inst✝ : Category C
X Y Z : C
p : X = Y
q : Y ⟶ Z
⊢ cast (_ : (Y ⟶ Z) = (X ⟶ Z)) q = eqToHom p ≫ q

tactic: simp
state_before: case refl
C : Type u₁
inst✝ : Category C
X Z : C
q : X ⟶ Z
⊢ cast (_ : (X ⟶ Z) = (X ⟶ Z)) q = eqToHom (_ : X = X) ≫ q
Theorem: Sym2.map_id
File: Mathlib/Data/Sym/Sym2.lean

tactic: ext ⟨⟨x, y⟩⟩
state_before: α : Type u_1
β : Type ?u.16100
γ : Type ?u.16103
⊢ map id = id

tactic: rfl
state_before: case h.mk.mk
α : Type u_1
β : Type ?u.16100
γ : Type ?u.16103
x✝ : Sym2 α
x y : α
⊢ map id (Quot.mk Setoid.r (x, y)) = id (Quot.mk Setoid.r (x, y))
Theorem: CauSeq.not_limZero_of_not_congr_zero
File: Mathlib/Data/Real/CauSeq.lean

tactic: intro h
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
hf : ¬f ≈ 0
⊢ ¬LimZero f

tactic: have : LimZero (f - 0) := by simp [h]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
hf : ¬f ≈ 0
h : LimZero f
⊢ False

tactic: exact hf this
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
hf : ¬f ≈ 0
h : LimZero f
this : LimZero (f - 0)
⊢ False

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
hf : ¬f ≈ 0
h : LimZero f
⊢ LimZero (f - 0)
Theorem: Order.le_succ_bot_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [le_succ_iff_eq_or_le, le_bot_iff, or_comm]
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b : α
inst✝ : OrderBot α
⊢ a ≤ succ ⊥ ↔ a = ⊥ ∨ a = succ ⊥
Theorem: Substring.Valid.extract
File: Std/Data/String/Lemmas.lean

tactic: let ⟨l, m, r, h₁⟩ := h₁.validFor
state_before: b e : Pos
x✝ : Substring
h₁ : Valid x✝
h₂ : Valid { str := toString x✝, startPos := b, stopPos := e }
⊢ Valid (Substring.extract x✝ b e)

tactic: rw [h₁.toString] at h₂
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
h₂ : Valid { str := toString x✝, startPos := b, stopPos := e }
l m r : List Char
h₁ : ValidFor l m r x✝
⊢ Valid (Substring.extract x✝ b e)

tactic: let ⟨ml, mm, mr, h₂⟩ := h₂.validFor
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
l m : List Char
h₂ : Valid { str := { data := m }, startPos := b, stopPos := e }
r : List Char
h₁ : ValidFor l m r x✝
⊢ Valid (Substring.extract x✝ b e)

tactic: have ⟨l', r', h₃⟩ := h₁.extract h₂
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
l m : List Char
h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e }
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
⊢ Valid (Substring.extract x✝ b e)

tactic: exact h₃.valid
state_before: b e : Pos
x✝ : Substring
h₁✝ : Valid x✝
l m : List Char
h₂✝ : Valid { str := { data := m }, startPos := b, stopPos := e }
r : List Char
h₁ : ValidFor l m r x✝
ml mm mr : List Char
h₂ : ValidFor ml mm mr { str := { data := m }, startPos := b, stopPos := e }
l' r' : List Char
h₃ : ValidFor l' mm r' (Substring.extract x✝ b e)
⊢ Valid (Substring.extract x✝ b e)
Theorem: Nat.gcd_add_mul_self
File: Std/Data/Nat/Gcd.lean

tactic: simp [gcd_rec m (n + k * m), gcd_rec m n]
state_before: m n k : Nat
⊢ gcd m (n + k * m) = gcd m n
Theorem: Complex.sin_eq_zero_iff_cos_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← mul_self_eq_one_iff, ← sin_sq_add_cos_sq, sq, sq, ← sub_eq_iff_eq_add, sub_self]
state_before: z : ℂ
⊢ sin z = 0 ↔ cos z = 1 ∨ cos z = -1

tactic: exact ⟨fun h => by rw [h, MulZeroClass.mul_zero], eq_zero_of_mul_self_eq_zero ∘ Eq.symm⟩
state_before: z : ℂ
⊢ sin z = 0 ↔ 0 = sin z * sin z

tactic: rw [h, MulZeroClass.mul_zero]
state_before: z : ℂ
h : sin z = 0
⊢ 0 = sin z * sin z
Theorem: IsIdempotentElem.pow_succ_eq
File: Mathlib/Algebra/Ring/Idempotents.lean

tactic: rw [pow_succ, ih, h.eq]
state_before: M : Type ?u.8183
N : Type u_1
S : Type ?u.8189
M₀ : Type ?u.8192
M₁ : Type ?u.8195
R : Type ?u.8198
G : Type ?u.8201
G₀ : Type ?u.8204
inst✝⁷ : Mul M
inst✝⁶ : Monoid N
inst✝⁵ : Semigroup S
inst✝⁴ : MulZeroClass M₀
inst✝³ : MulOneClass M₁
inst✝² : NonAssocRing R
inst✝¹ : Group G
inst✝ : CancelMonoidWithZero G₀
p : N
n✝ : ℕ
h : IsIdempotentElem p
n : ℕ
ih : p ^ (n + 1) = p
⊢ p ^ (Nat.succ n + 1) = p
Theorem: AddMonoidAlgebra.mem_closure_of_mem_span_closure
File: Mathlib/RingTheory/FiniteType.lean

tactic: suffices Multiplicative.ofAdd m ∈ Submonoid.closure (Multiplicative.toAdd ⁻¹' S) by
  simpa [← toSubmonoid_closure]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : of' R M m ∈ span R ↑(Submonoid.closure (of' R M '' S))
⊢ m ∈ closure S

tactic: let S' := @Submonoid.closure (Multiplicative M) Multiplicative.mulOneClass S
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : of' R M m ∈ span R ↑(Submonoid.closure (of' R M '' S))
⊢ ↑Multiplicative.ofAdd m ∈ Submonoid.closure (↑Multiplicative.toAdd ⁻¹' S)

tactic: have h' : Submonoid.map (of R M) S' = Submonoid.closure ((fun x : M => (of R M) x) '' S) :=
  MonoidHom.map_mclosure _ _
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : of' R M m ∈ span R ↑(Submonoid.closure (of' R M '' S))
S' : Submonoid (Multiplicative M) := Submonoid.closure S
⊢ ↑Multiplicative.ofAdd m ∈ Submonoid.closure (↑Multiplicative.toAdd ⁻¹' S)

tactic: rw [Set.image_congr' (show ∀ x, of' R M x = of R M x from fun x => of'_eq_of x), ← h'] at h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : of' R M m ∈ span R ↑(Submonoid.closure (of' R M '' S))
S' : Submonoid (Multiplicative M) := Submonoid.closure S
h' : Submonoid.map (of R M) S' = Submonoid.closure ((fun x => ↑(of R M) x) '' S)
⊢ ↑Multiplicative.ofAdd m ∈ Submonoid.closure (↑Multiplicative.toAdd ⁻¹' S)

tactic: simpa using of'_mem_span.1 h
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
S' : Submonoid (Multiplicative M) := Submonoid.closure S
h : of' R M m ∈ span R ↑(Submonoid.map (of R M) S')
h' : Submonoid.map (of R M) S' = Submonoid.closure ((fun x => ↑(of R M) x) '' S)
⊢ ↑Multiplicative.ofAdd m ∈ Submonoid.closure (↑Multiplicative.toAdd ⁻¹' S)

tactic: simpa [← toSubmonoid_closure]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommMonoid M
inst✝ : Nontrivial R
m : M
S : Set M
h : of' R M m ∈ span R ↑(Submonoid.closure (of' R M '' S))
this : ↑Multiplicative.ofAdd m ∈ Submonoid.closure (↑Multiplicative.toAdd ⁻¹' S)
⊢ m ∈ closure S
Theorem: List.unzip_enumFrom_eq_prod
File: Mathlib/Data/List/Range.lean

tactic: simp only [enumFrom_eq_zip_range', unzip_zip, length_range']
state_before: α : Type u
l : List α
n : ℕ
⊢ unzip (enumFrom n l) = (range' n (length l), l)
Theorem: Set.bijective_iff_bijective_of_iUnion_eq_univ
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [Bijective, injective_iff_injective_of_iUnion_eq_univ hU,
  surjective_iff_surjective_of_iUnion_eq_univ hU]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.186792
ι : Sort ?u.186795
ι' : Sort ?u.186798
ι₂ : Sort ?u.186801
κ : ι → Sort ?u.186806
κ₁ : ι → Sort ?u.186811
κ₂ : ι → Sort ?u.186816
κ' : ι' → Sort ?u.186821
s : Set β
f : α → β
U : ι → Set β
hU : iUnion U = univ
⊢ Bijective f ↔ ∀ (i : ι), Bijective (restrictPreimage (U i) f)

tactic: simp [Bijective, forall_and]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.186792
ι : Sort ?u.186795
ι' : Sort ?u.186798
ι₂ : Sort ?u.186801
κ : ι → Sort ?u.186806
κ₁ : ι → Sort ?u.186811
κ₂ : ι → Sort ?u.186816
κ' : ι' → Sort ?u.186821
s : Set β
f : α → β
U : ι → Set β
hU : iUnion U = univ
⊢ ((∀ (i : ι), Injective (restrictPreimage (U i) f)) ∧ ∀ (i : ι), Surjective (restrictPreimage (U i) f)) ↔
    ∀ (i : ι), Bijective (restrictPreimage (U i) f)
Theorem: Nat.pred_iterate
File: Mathlib/Data/Nat/SuccPred.lean

tactic: rw [Function.iterate_succ', sub_succ]
state_before: a n : ℕ
⊢ (pred^[n + 1]) a = a - (n + 1)

tactic: exact congr_arg _ (pred_iterate a n)
state_before: a n : ℕ
⊢ (pred ∘ pred^[n]) a = pred (a - n)
Theorem: OmegaCompletePartialOrder.ContinuousHom.comp_assoc
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: ext
state_before: α : Type u
α' : Type ?u.65959
β : Type v
β' : Type ?u.65964
γ : Type u_1
φ : Type u_2
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
f : γ →𝒄 φ
g : β →𝒄 γ
h : α →𝒄 β
⊢ comp f (comp g h) = comp (comp f g) h

tactic: rfl
state_before: case h
α : Type u
α' : Type ?u.65959
β : Type v
β' : Type ?u.65964
γ : Type u_1
φ : Type u_2
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
f : γ →𝒄 φ
g : β →𝒄 γ
h : α →𝒄 β
x✝ : α
⊢ ↑(comp f (comp g h)).toOrderHom x✝ = ↑(comp (comp f g) h).toOrderHom x✝
Theorem: Equiv.Perm.set_support_mul_subset
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: intro x
state_before: α : Type u_1
p q : Perm α
⊢ {x | ↑(p * q) x ≠ x} ⊆ {x | ↑p x ≠ x} ∪ {x | ↑q x ≠ x}

tactic: simp only [Perm.coe_mul, Function.comp_apply, Ne.def, Set.mem_union, Set.mem_setOf_eq]
state_before: α : Type u_1
p q : Perm α
x : α
⊢ x ∈ {x | ↑(p * q) x ≠ x} → x ∈ {x | ↑p x ≠ x} ∪ {x | ↑q x ≠ x}

tactic: by_cases hq : q x = x <;> simp [hq]
state_before: α : Type u_1
p q : Perm α
x : α
⊢ ¬↑p (↑q x) = x → ¬↑p x = x ∨ ¬↑q x = x
Theorem: Complex.IsExpCmpFilter.of_isBigO_im_re_rpow
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: norm_cast
state_before: l : Filter ℂ
hre : Tendsto re l atTop
r : ℝ
hr : im =O[l] fun z => z.re ^ r
n : ℕ
⊢ (fun z => z.im ^ ↑n) =O[l] fun z => (z.re ^ r) ^ ↑n

tactic: exact hr.pow n
state_before: l : Filter ℂ
hre : Tendsto re l atTop
r : ℝ
hr : im =O[l] fun z => z.re ^ r
n : ℕ
⊢ (fun z => z.im ^ n) =O[l] fun z => (z.re ^ r) ^ n

tactic: simp only [Real.rpow_mul hz r n, Real.rpow_nat_cast]
state_before: l : Filter ℂ
hre : Tendsto re l atTop
r : ℝ
hr : im =O[l] fun z => z.re ^ r
n : ℕ
z : ℂ
hz : 0 ≤ z.re
⊢ (fun z => (z.re ^ r) ^ ↑n) z = (fun z => z.re ^ (r * ↑n)) z
Theorem: RingTopology.toTopologicalSpace_injective
File: Mathlib/Topology/Algebra/Ring/Basic.lean

tactic: intro f g _
state_before: α : Type u_1
inst✝ : Ring α
⊢ Injective toTopologicalSpace

tactic: cases f
state_before: α : Type u_1
inst✝ : Ring α
f g : RingTopology α
a✝ : f.toTopologicalSpace = g.toTopologicalSpace
⊢ f = g

tactic: cases g
state_before: case mk
α : Type u_1
inst✝ : Ring α
g : RingTopology α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalRing✝ : TopologicalRing α
a✝ :
  { toTopologicalSpace := toTopologicalSpace✝, toTopologicalRing := toTopologicalRing✝ }.toTopologicalSpace =
    g.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝, toTopologicalRing := toTopologicalRing✝ } = g

tactic: congr
state_before: case mk.mk
α : Type u_1
inst✝ : Ring α
toTopologicalSpace✝¹ : TopologicalSpace α
toTopologicalRing✝¹ : TopologicalRing α
toTopologicalSpace✝ : TopologicalSpace α
toTopologicalRing✝ : TopologicalRing α
a✝ :
  { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalRing := toTopologicalRing✝¹ }.toTopologicalSpace =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalRing := toTopologicalRing✝ }.toTopologicalSpace
⊢ { toTopologicalSpace := toTopologicalSpace✝¹, toTopologicalRing := toTopologicalRing✝¹ } =
    { toTopologicalSpace := toTopologicalSpace✝, toTopologicalRing := toTopologicalRing✝ }
Theorem: Associates.prod_le_prod
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: haveI := Classical.decEq (Associates α)
state_before: α : Type u_1
β : Type ?u.42748
γ : Type ?u.42751
δ : Type ?u.42754
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
⊢ Multiset.prod p ≤ Multiset.prod q

tactic: haveI := Classical.decEq α
state_before: α : Type u_1
β : Type ?u.42748
γ : Type ?u.42751
δ : Type ?u.42754
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this : DecidableEq (Associates α)
⊢ Multiset.prod p ≤ Multiset.prod q

tactic: suffices p.prod ≤ (p + (q - p)).prod by rwa [add_tsub_cancel_of_le h] at this
state_before: α : Type u_1
β : Type ?u.42748
γ : Type ?u.42751
δ : Type ?u.42754
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ Multiset.prod p ≤ Multiset.prod q

tactic: suffices p.prod * 1 ≤ p.prod * (q - p).prod by simpa
state_before: α : Type u_1
β : Type ?u.42748
γ : Type ?u.42751
δ : Type ?u.42754
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ Multiset.prod p ≤ Multiset.prod (p + (q - p))

tactic: exact mul_mono (le_refl p.prod) one_le
state_before: α : Type u_1
β : Type ?u.42748
γ : Type ?u.42751
δ : Type ?u.42754
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝ : DecidableEq (Associates α)
this : DecidableEq α
⊢ Multiset.prod p * 1 ≤ Multiset.prod p * Multiset.prod (q - p)

tactic: rwa [add_tsub_cancel_of_le h] at this
state_before: α : Type u_1
β : Type ?u.42748
γ : Type ?u.42751
δ : Type ?u.42754
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝¹ : DecidableEq (Associates α)
this✝ : DecidableEq α
this : Multiset.prod p ≤ Multiset.prod (p + (q - p))
⊢ Multiset.prod p ≤ Multiset.prod q

tactic: simpa
state_before: α : Type u_1
β : Type ?u.42748
γ : Type ?u.42751
δ : Type ?u.42754
inst✝ : CommMonoid α
p q : Multiset (Associates α)
h : p ≤ q
this✝¹ : DecidableEq (Associates α)
this✝ : DecidableEq α
this : Multiset.prod p * 1 ≤ Multiset.prod p * Multiset.prod (q - p)
⊢ Multiset.prod p ≤ Multiset.prod (p + (q - p))
Theorem: measurable_find
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: refine' measurable_to_nat fun x => _
state_before: α : Type u_1
β : Type ?u.56687
γ : Type ?u.56690
δ : Type ?u.56693
δ' : Type ?u.56696
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
⊢ Measurable fun x => Nat.find (_ : ∃ N, p x N)

tactic: rw [preimage_find_eq_disjointed (fun k => {x | p x k})]
state_before: α : Type u_1
β : Type ?u.56687
γ : Type ?u.56690
δ : Type ?u.56693
δ' : Type ?u.56696
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
x : α
⊢ MeasurableSet ((fun x => Nat.find (_ : ∃ N, p x N)) ⁻¹' {Nat.find (_ : ∃ N, p x N)})

tactic: exact MeasurableSet.disjointed hm _
state_before: α : Type u_1
β : Type ?u.56687
γ : Type ?u.56690
δ : Type ?u.56693
δ' : Type ?u.56696
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
hp : ∀ (x : α), ∃ N, p x N
hm : ∀ (k : ℕ), MeasurableSet {x | p x k}
x : α
⊢ MeasurableSet (disjointed (fun k => {x | p x k}) (Nat.find (_ : ∃ N, p x N)))
Theorem: aeSeq.aeSeq_eq_mk_ae
File: Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean

tactic: simp only [aeSeq, hx, if_true]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type ?u.571614
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
f : ι → α → β
μ : MeasureTheory.Measure α
p : α → (ι → β) → Prop
inst✝ : Countable ι
hf : ∀ (i : ι), AEMeasurable (f i)
hp : ∀ᵐ (x : α) ∂μ, p x fun n => f n x
x : α
hx : x ∈ aeSeqSet hf p
i : ι
⊢ aeSeq hf p i x = AEMeasurable.mk (f i) (_ : AEMeasurable (f i)) x
Theorem: Real.tendsto_mul_exp_add_div_pow_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: α : Type ?u.33412
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 < b
⊢ Tendsto (fun x => (b * exp x + c) / x ^ n) atTop atTop

tactic: simp only [add_div, mul_div_assoc]
state_before: case inr
α : Type ?u.33412
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 < b
hn : n ≠ 0
⊢ Tendsto (fun x => (b * exp x + c) / x ^ n) atTop atTop

tactic: exact
  ((tendsto_exp_div_pow_atTop n).const_mul_atTop hb).atTop_add
    (tendsto_const_nhds.div_atTop (tendsto_pow_atTop hn))
state_before: case inr
α : Type ?u.33412
x y z : ℝ
l : Filter α
b c : ℝ
n : ℕ
hb : 0 < b
hn : n ≠ 0
⊢ Tendsto (fun x => b * (exp x / x ^ n) + c / x ^ n) atTop atTop

tactic: simp only [pow_zero, div_one]
state_before: case inl
α : Type ?u.33412
x y z : ℝ
l : Filter α
b c : ℝ
hb : 0 < b
⊢ Tendsto (fun x => (b * exp x + c) / x ^ 0) atTop atTop

tactic: exact (tendsto_exp_atTop.const_mul_atTop hb).atTop_add tendsto_const_nhds
state_before: case inl
α : Type ?u.33412
x y z : ℝ
l : Filter α
b c : ℝ
hb : 0 < b
⊢ Tendsto (fun x => b * exp x + c) atTop atTop
Theorem: Set.range_eq_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [@eq_comm α a]
state_before: α : Type u_2
β : Type ?u.199050
γ : Type ?u.199053
ι✝ : Sort ?u.199056
ι' : Sort ?u.199059
ι₂ : Sort ?u.199062
κ : ι✝ → Sort ?u.199067
κ₁ : ι✝ → Sort ?u.199072
κ₂ : ι✝ → Sort ?u.199077
κ' : ι' → Sort ?u.199082
ι : Sort u_1
f : ι → α
a : α
⊢ a ∈ range f ↔ a ∈ ⋃ (i : ι), {f i}
Theorem: factorization_zero
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: simp [factorization]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : UniqueFactorizationMonoid α
inst✝¹ : NormalizationMonoid α
inst✝ : DecidableEq α
⊢ factorization 0 = 0
Theorem: PNat.find_comp_succ
File: Mathlib/Data/PNat/Find.lean

tactic: refine' (find_eq_iff _).2 ⟨PNat.find_spec h₂, fun n => PNat.recOn n _ _⟩
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
⊢ PNat.find h = PNat.find h₂ + 1

tactic: intro m _ hm
state_before: case refine'_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ ∀ (n : ℕ+), (n < PNat.find h₂ + 1 → ¬p n) → n + 1 < PNat.find h₂ + 1 → ¬p (n + 1)

tactic: simp only [add_lt_add_iff_right, lt_find_iff] at hm
state_before: case refine'_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : m + 1 < PNat.find h₂ + 1
⊢ ¬p (m + 1)

tactic: exact hm _ le_rfl
state_before: case refine'_2
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m✝ : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n m : ℕ+
a✝ : m < PNat.find h₂ + 1 → ¬p m
hm : ∀ (m_1 : ℕ+), m_1 ≤ m → ¬p (m_1 + 1)
⊢ ¬p (m + 1)

tactic: simp [h1]
state_before: case refine'_1
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h✝ : ∃ n, p n
n✝ m : ℕ+
h : ∃ n, p n
h₂ : ∃ n, p (n + 1)
h1 : ¬p 1
n : ℕ+
⊢ 1 < PNat.find h₂ + 1 → ¬p 1
Theorem: pochhammer_succ_comp_X_add_one
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

tactic: suffices (pochhammer ℕ (n + 1)).comp (X + 1) =
    pochhammer ℕ (n + 1) + (n + 1) * (pochhammer ℕ n).comp (X + 1)
  by simpa [map_comp] using congr_arg (Polynomial.map (Nat.castRingHom S)) this
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
⊢ comp (pochhammer S (n + 1)) (X + 1) = pochhammer S (n + 1) + (n + 1) • comp (pochhammer S n) (X + 1)

tactic: nth_rw 2 [pochhammer_succ_left]
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
⊢ comp (pochhammer ℕ (n + 1)) (X + 1) = pochhammer ℕ (n + 1) + (↑n + 1) * comp (pochhammer ℕ n) (X + 1)

tactic: simp only
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
⊢ comp (pochhammer ℕ (n + 1)) (X + 1) = X * comp (pochhammer ℕ n) (X + 1) + (↑n + 1) * comp (pochhammer ℕ n) (X + 1)

tactic: rw [← add_mul, pochhammer_succ_right ℕ n, mul_comp, mul_comm, add_comp, X_comp, nat_cast_comp,
  add_comm, ← add_assoc]
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
⊢ comp (pochhammer ℕ (n + 1)) (X + 1) = X * comp (pochhammer ℕ n) (X + 1) + (↑n + 1) * comp (pochhammer ℕ n) (X + 1)

tactic: ring
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
⊢ (↑n + X + 1) * comp (pochhammer ℕ n) (X + 1) = (X + (↑n + 1)) * comp (pochhammer ℕ n) (X + 1)

tactic: simpa [map_comp] using congr_arg (Polynomial.map (Nat.castRingHom S)) this
state_before: S : Type u
inst✝ : Semiring S
n : ℕ
this : comp (pochhammer ℕ (n + 1)) (X + 1) = pochhammer ℕ (n + 1) + (↑n + 1) * comp (pochhammer ℕ n) (X + 1)
⊢ comp (pochhammer S (n + 1)) (X + 1) = pochhammer S (n + 1) + (n + 1) • comp (pochhammer S n) (X + 1)
Theorem: Multiset.cons_inj_right
File: Mathlib/Data/Multiset/Basic.lean

tactic: rintro ⟨l₁⟩ ⟨l₂⟩
state_before: α : Type u_1
β : Type ?u.12536
γ : Type ?u.12539
a : α
⊢ ∀ {s t : Multiset α}, a ::ₘ s = a ::ₘ t ↔ s = t

tactic: simp
state_before: case mk.mk
α : Type u_1
β : Type ?u.12536
γ : Type ?u.12539
a : α
s✝ : Multiset α
l₁ : List α
t✝ : Multiset α
l₂ : List α
⊢ a ::ₘ Quot.mk Setoid.r l₁ = a ::ₘ Quot.mk Setoid.r l₂ ↔ Quot.mk Setoid.r l₁ = Quot.mk Setoid.r l₂
Theorem: Finset.supIndep_univ_bool
File: Mathlib/Order/SupIndep.lean

tactic: simp only [Ne.def, not_false_iff]
state_before: α : Type u_1
β : Type ?u.13543
ι : Type ?u.13546
ι' : Type ?u.13549
inst✝¹ : Lattice α
inst✝ : OrderBot α
s t : Finset ι
f✝ : ι → α
i : ι
f : Bool → α
⊢ true ≠ false
Theorem: OrderRingIso.toOrderRingHom_injective
File: Mathlib/Algebra/Order/Hom/Ring.lean

tactic: convert FunLike.ext'_iff.1 h using 0
state_before: F : Type ?u.78843
α : Type u_1
β : Type u_2
γ : Type ?u.78852
δ : Type ?u.78855
inst✝⁵ : NonAssocSemiring α
inst✝⁴ : Preorder α
inst✝³ : NonAssocSemiring β
inst✝² : Preorder β
inst✝¹ : NonAssocSemiring γ
inst✝ : Preorder γ
f g : α ≃+*o β
h : toOrderRingHom f = toOrderRingHom g
⊢ (fun f => ↑f) f = (fun f => ↑f) g