tasksource/leandojo huggingface dataset:
Theorem: Asymptotics.isLittleO_norm_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def]
state_before: α : Type u_1
β : Type ?u.125138
E : Type ?u.125141
F : Type u_2
G : Type ?u.125147
E' : Type u_3
F' : Type ?u.125153
G' : Type ?u.125156
E'' : Type ?u.125159
F'' : Type ?u.125162
G'' : Type ?u.125165
R : Type ?u.125168
R' : Type ?u.125171
𝕜 : Type ?u.125174
𝕜' : Type ?u.125177
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (fun x => ‖f' x‖) =o[l] g ↔ f' =o[l] g

tactic: exact forall₂_congr fun _ _ => isBigOWith_norm_left
state_before: α : Type u_1
β : Type ?u.125138
E : Type ?u.125141
F : Type u_2
G : Type ?u.125147
E' : Type u_3
F' : Type ?u.125153
G' : Type ?u.125156
E'' : Type ?u.125159
F'' : Type ?u.125162
G'' : Type ?u.125165
R : Type ?u.125168
R' : Type ?u.125171
𝕜 : Type ?u.125174
𝕜' : Type ?u.125177
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l (fun x => ‖f' x‖) g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f' g
Theorem: nhdsWithin_prod_eq
File: Mathlib/Topology/Constructions.lean

tactic: simp only [nhdsWithin, nhds_prod_eq, ← prod_inf_prod, prod_principal_principal]
state_before: α : Type u
β : Type v
γ : Type ?u.33531
δ : Type ?u.33534
ε : Type ?u.33537
ζ : Type ?u.33540
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
a : α
b : β
s : Set α
t : Set β
⊢ 𝓝[s ×ˢ t] (a, b) = 𝓝[s] a ×ˢ 𝓝[t] b
Theorem: MeasureTheory.integral_mul_right
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [mul_comm]
state_before: α : Type u_2
E : Type ?u.936450
F : Type ?u.936453
𝕜 : Type ?u.936456
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : SMulCommClass ℝ 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
L : Type u_1
inst✝ : IsROrC L
r : L
f : α → L
⊢ (∫ (a : α), f a * r ∂μ) = (∫ (a : α), f a ∂μ) * r

tactic: exact integral_mul_left r f
state_before: α : Type u_2
E : Type ?u.936450
F : Type ?u.936453
𝕜 : Type ?u.936456
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace ℝ E
inst✝⁷ : CompleteSpace E
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : SMulCommClass ℝ 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
L : Type u_1
inst✝ : IsROrC L
r : L
f : α → L
⊢ (∫ (a : α), r * f a ∂μ) = r * ∫ (a : α), f a ∂μ
Theorem: Fin.succ_castSucc
File: Mathlib/Data/Fin/Basic.lean

tactic: simp
state_before: n✝ m n : ℕ
i : Fin n
⊢ ↑(succ (↑castSucc i)) = ↑(↑castSucc (succ i))
Theorem: IsGLB.biUnion_Ici_eq_Ici
File: Mathlib/Data/Set/Intervals/Disjoint.lean

tactic: refine' (iUnion₂_subset fun x hx => _).antisymm fun x hx => _
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
⊢ (⋃ (x : α) (_ : x ∈ s), Ici x) = Ici a

tactic: exact Ici_subset_Ici.mpr (mem_lowerBounds.mp a_glb.1 x hx)
state_before: case refine'_1
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
x : α
hx : x ∈ s
⊢ Ici x ⊆ Ici a

tactic: apply mem_iUnion₂.mpr
state_before: case refine'_2
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
x : α
hx : x ∈ Ici a
⊢ x ∈ ⋃ (i : α) (_ : i ∈ s), Ici i

tactic: refine' ⟨a, a_mem, hx⟩
state_before: case refine'_2
ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
a_glb : IsGLB s a
a_mem : a ∈ s
x : α
hx : x ∈ Ici a
⊢ ∃ i j, x ∈ Ici i
Theorem: CategoryTheory.Functor.id_comp
File: Mathlib/CategoryTheory/Functor/Basic.lean

tactic: cases F
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
F : C ⥤ D
⊢ 𝟭 C ⋙ F = F

tactic: rfl
state_before: case mk
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
E : Type u₃
inst✝ : Category E
toPrefunctor✝ : C ⥤q D
map_id✝ : ∀ (X : C), toPrefunctor✝.map (𝟙 X) = 𝟙 (toPrefunctor✝.obj X)
map_comp✝ : ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), toPrefunctor✝.map (f ≫ g) = toPrefunctor✝.map f ≫ toPrefunctor✝.map g
⊢ 𝟭 C ⋙ mk toPrefunctor✝ = mk toPrefunctor✝
Theorem: LocalEquiv.trans_self_symm
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: have A : (e.trans e.symm).source = e.source := by mfld_set_tac
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58218
δ : Type ?u.58221
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ LocalEquiv.trans e (LocalEquiv.symm e) ≈ ofSet e.source

tactic: refine' ⟨by rw [A, ofSet_source], fun x hx => _⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58218
δ : Type ?u.58221
e : LocalEquiv α β
e' : LocalEquiv β γ
A : (LocalEquiv.trans e (LocalEquiv.symm e)).source = e.source
⊢ LocalEquiv.trans e (LocalEquiv.symm e) ≈ ofSet e.source

tactic: rw [A] at hx
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58218
δ : Type ?u.58221
e : LocalEquiv α β
e' : LocalEquiv β γ
A : (LocalEquiv.trans e (LocalEquiv.symm e)).source = e.source
x : α
hx : x ∈ (LocalEquiv.trans e (LocalEquiv.symm e)).source
⊢ ↑(LocalEquiv.trans e (LocalEquiv.symm e)) x = ↑(ofSet e.source) x

tactic: simp only [hx, mfld_simps]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58218
δ : Type ?u.58221
e : LocalEquiv α β
e' : LocalEquiv β γ
A : (LocalEquiv.trans e (LocalEquiv.symm e)).source = e.source
x : α
hx : x ∈ e.source
⊢ ↑(LocalEquiv.trans e (LocalEquiv.symm e)) x = ↑(ofSet e.source) x

tactic: mfld_set_tac
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58218
δ : Type ?u.58221
e : LocalEquiv α β
e' : LocalEquiv β γ
⊢ (LocalEquiv.trans e (LocalEquiv.symm e)).source = e.source

tactic: rw [A, ofSet_source]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.58218
δ : Type ?u.58221
e : LocalEquiv α β
e' : LocalEquiv β γ
A : (LocalEquiv.trans e (LocalEquiv.symm e)).source = e.source
⊢ (LocalEquiv.trans e (LocalEquiv.symm e)).source = (ofSet e.source).source
Theorem: Computation.destruct_map
File: Mathlib/Data/Seq/Computation.lean

tactic: apply s.recOn <;> intro <;> simp
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s : Computation α
⊢ destruct (map f s) = lmap f (rmap (map f) (destruct s))
Theorem: lp.single_apply_self
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rw [lp.single_apply, dif_pos rfl]
state_before: α : Type u_2
E : α → Type u_1
p✝ q : ℝ≥0∞
inst✝⁴ : (i : α) → NormedAddCommGroup (E i)
𝕜 : Type ?u.858705
inst✝³ : NormedRing 𝕜
inst✝² : (i : α) → Module 𝕜 (E i)
inst✝¹ : ∀ (i : α), BoundedSMul 𝕜 (E i)
inst✝ : DecidableEq α
p : ℝ≥0∞
i : α
a : E i
⊢ ↑(lp.single p i a) i = a
Theorem: Mathlib.Tactic.Ring.mul_pf_right
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₃ c b₁ : R
b₂ : ℕ
x✝ : a * b₃ = c
⊢ a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * c

tactic: rw [mul_left_comm]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b₃ b₁ : R
b₂ : ℕ
⊢ a * (b₁ ^ b₂ * b₃) = b₁ ^ b₂ * (a * b₃)
Theorem: finprod_congr_Prop
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: subst q
state_before: G : Type ?u.40546
M : Type u_1
N : Type ?u.40552
α : Sort ?u.40555
β : Sort ?u.40558
ι : Sort ?u.40561
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
p q : Prop
f : p → M
g : q → M
hpq : p = q
hfg : ∀ (h : q), f (_ : p) = g h
⊢ finprod f = finprod g

tactic: exact finprod_congr hfg
state_before: G : Type ?u.40546
M : Type u_1
N : Type ?u.40552
α : Sort ?u.40555
β : Sort ?u.40558
ι : Sort ?u.40561
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
p : Prop
f g : p → M
hfg : ∀ (h : p), f (_ : p) = g h
⊢ finprod f = finprod g
Theorem: Submodule.range_mkQ
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: rintro ⟨x⟩
state_before: R : Type u_2
M : Type u_1
r : R
x y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type ?u.216815
M₂ : Type ?u.216818
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
⊢ ∀ (x : M ⧸ p), x ∈ range (mkQ p)

tactic: exact ⟨x, rfl⟩
state_before: case mk
R : Type u_2
M : Type u_1
r : R
x✝¹ y : M
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
p p' : Submodule R M
R₂ : Type ?u.216815
M₂ : Type ?u.216818
inst✝² : Ring R₂
inst✝¹ : AddCommGroup M₂
inst✝ : Module R₂ M₂
τ₁₂ : R →+* R₂
x✝ : M ⧸ p
x : M
⊢ Quot.mk Setoid.r x ∈ range (mkQ p)
Theorem: Rat.le_total
File: Mathlib/Data/Rat/Order.lean

tactic: have := Rat.nonneg_total (b - a)
state_before: a b c : ℚ
⊢ a ≤ b ∨ b ≤ a

tactic: rw [Rat.le_iff_Nonneg, Rat.le_iff_Nonneg]
state_before: a b c : ℚ
this : Rat.Nonneg (b - a) ∨ Rat.Nonneg (-(b - a))
⊢ a ≤ b ∨ b ≤ a

tactic: rwa [neg_sub] at this
state_before: a b c : ℚ
this : Rat.Nonneg (b - a) ∨ Rat.Nonneg (-(b - a))
⊢ Rat.Nonneg (b - a) ∨ Rat.Nonneg (a - b)
Theorem: List.get?_set_of_lt'
File: Std/Data/List/Lemmas.lean

tactic: simp [get?_set]
state_before: α : Type u_1
a : α
m n : Nat
l : List α
h : m < length l
⊢ get? (set l m a) n = if m = n then some a else get? l n

tactic: split <;> subst_vars <;> simp [*, get?_eq_get h]
state_before: α : Type u_1
a : α
m n : Nat
l : List α
h : m < length l
⊢ (if m = n then Option.map (fun x => a) (get? l n) else get? l n) = if m = n then some a else get? l n
Theorem: ENNReal.exists_nat_pos_inv_mul_lt
File: Mathlib/Data/Real/ENNReal.lean

tactic: rcases exists_nat_pos_mul_gt hb ha with ⟨n, npos, hn⟩
state_before: α : Type ?u.341859
β : Type ?u.341862
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
⊢ ∃ n, n > 0 ∧ (↑n)⁻¹ * a < b

tactic: use n, npos
state_before: case intro.intro
α : Type ?u.341859
β : Type ?u.341862
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : n > 0
hn : a < ↑n * b
⊢ ∃ n, n > 0 ∧ (↑n)⁻¹ * a < b

tactic: rw [← ENNReal.div_eq_inv_mul]
state_before: case intro.intro
α : Type ?u.341859
β : Type ?u.341862
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : n > 0
hn : a < ↑n * b
⊢ (↑n)⁻¹ * a < b

tactic: exact div_lt_of_lt_mul' hn
state_before: case intro.intro
α : Type ?u.341859
β : Type ?u.341862
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : n > 0
hn : a < ↑n * b
⊢ a / ↑n < b
Theorem: Finset.image₂_image₂_image₂_comm
File: Mathlib/Data/Finset/NAry.lean

tactic: push_cast
state_before: α : Type u_7
α' : Type ?u.76425
β : Type u_8
β' : Type ?u.76431
γ✝ : Type ?u.76434
γ' : Type ?u.76437
δ✝ : Type ?u.76440
δ' : Type ?u.76443
ε : Type u_6
ε' : Type u_9
ζ : Type u_3
ζ' : Type u_4
ν : Type u_5
inst✝¹⁰ : DecidableEq α'
inst✝⁹ : DecidableEq β'
inst✝⁸ : DecidableEq γ✝
inst✝⁷ : DecidableEq γ'
inst✝⁶ : DecidableEq δ✝
inst✝⁵ : DecidableEq δ'
inst✝⁴ : DecidableEq ε
inst✝³ : DecidableEq ε'
f✝ f'✝ : α → β → γ✝
g✝ g'✝ : α → β → γ✝ → δ✝
s s' : Finset α
t t' : Finset β
u✝ u' : Finset γ✝
a a' : α
b b' : β
c : γ✝
γ : Type u_1
δ : Type u_2
u : Finset γ
v : Finset δ
inst✝² : DecidableEq ζ
inst✝¹ : DecidableEq ζ'
inst✝ : DecidableEq ν
f : ε → ζ → ν
g : α → β → ε
h : γ → δ → ζ
f' : ε' → ζ' → ν
g' : α → γ → ε'
h' : β → δ → ζ'
h_comm : ∀ (a : α) (b : β) (c : γ) (d : δ), f (g a b) (h c d) = f' (g' a c) (h' b d)
⊢ ↑(image₂ f (image₂ g s t) (image₂ h u v)) = ↑(image₂ f' (image₂ g' s u) (image₂ h' t v))

tactic: exact image2_image2_image2_comm h_comm
state_before: α : Type u_7
α' : Type ?u.76425
β : Type u_8
β' : Type ?u.76431
γ✝ : Type ?u.76434
γ' : Type ?u.76437
δ✝ : Type ?u.76440
δ' : Type ?u.76443
ε : Type u_6
ε' : Type u_9
ζ : Type u_3
ζ' : Type u_4
ν : Type u_5
inst✝¹⁰ : DecidableEq α'
inst✝⁹ : DecidableEq β'
inst✝⁸ : DecidableEq γ✝
inst✝⁷ : DecidableEq γ'
inst✝⁶ : DecidableEq δ✝
inst✝⁵ : DecidableEq δ'
inst✝⁴ : DecidableEq ε
inst✝³ : DecidableEq ε'
f✝ f'✝ : α → β → γ✝
g✝ g'✝ : α → β → γ✝ → δ✝
s s' : Finset α
t t' : Finset β
u✝ u' : Finset γ✝
a a' : α
b b' : β
c : γ✝
γ : Type u_1
δ : Type u_2
u : Finset γ
v : Finset δ
inst✝² : DecidableEq ζ
inst✝¹ : DecidableEq ζ'
inst✝ : DecidableEq ν
f : ε → ζ → ν
g : α → β → ε
h : γ → δ → ζ
f' : ε' → ζ' → ν
g' : α → γ → ε'
h' : β → δ → ζ'
h_comm : ∀ (a : α) (b : β) (c : γ) (d : δ), f (g a b) (h c d) = f' (g' a c) (h' b d)
⊢ image2 f (image2 g ↑s ↑t) (image2 h ↑u ↑v) = image2 f' (image2 g' ↑s ↑u) (image2 h' ↑t ↑v)
Theorem: CategoryTheory.Limits.HasZeroObject.zeroIsoTerminal_hom
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: ext
state_before: C : Type u
inst✝⁴ : Category C
D : Type u'
inst✝³ : Category D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasTerminal C
⊢ zeroIsoTerminal.hom = 0
Theorem: Basis.tensorProduct_apply
File: Mathlib/LinearAlgebra/TensorProductBasis.lean

tactic: simp [Basis.tensorProduct]
state_before: R : Type u_2
M : Type u_3
N : Type u_5
ι : Type u_1
κ : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
b : Basis ι R M
c : Basis κ R N
i : ι
j : κ
⊢ ↑(tensorProduct b c) (i, j) = ↑b i ⊗ₜ[R] ↑c j
Theorem: Set.univ_pi_piecewise
File: Mathlib/Data/Set/Function.lean

tactic: simp [compl_eq_univ_diff]
state_before: α✝ : Type ?u.98315
β : Type ?u.98318
γ : Type ?u.98321
ι✝ : Sort ?u.98324
π : α✝ → Type ?u.98329
δ : α✝ → Sort ?u.98334
s✝ : Set α✝
f g : (i : α✝) → δ i
inst✝¹ : (j : α✝) → Decidable (j ∈ s✝)
ι : Type u_1
α : ι → Type u_2
s : Set ι
t t' : (i : ι) → Set (α i)
inst✝ : (x : ι) → Decidable (x ∈ s)
⊢ pi univ (piecewise s t t') = pi s t ∩ pi (sᶜ) t'
Theorem: List.one_lt_prod_of_one_lt
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simpa using h
state_before: ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
b : M
h : ∀ (x : M), x ∈ [b] → 1 < x
x✝ : [b] ≠ []
⊢ 1 < prod [b]

tactic: simp only [forall_eq_or_imp, List.mem_cons] at hl₁
state_before: ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
hl₁ : ∀ (x : M), x ∈ a :: b :: l → 1 < x
x✝ : a :: b :: l ≠ []
⊢ 1 < prod (a :: b :: l)

tactic: rw [List.prod_cons]
state_before: ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ (a : M), a ∈ l → 1 < a
⊢ 1 < prod (a :: b :: l)

tactic: apply one_lt_mul_of_lt_of_le' hl₁.1
state_before: ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ (a : M), a ∈ l → 1 < a
⊢ 1 < a * prod (b :: l)

tactic: apply le_of_lt ((b :: l).one_lt_prod_of_one_lt _ (l.cons_ne_nil b))
state_before: ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ (a : M), a ∈ l → 1 < a
⊢ 1 ≤ prod (b :: l)

tactic: intro x hx
state_before: ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ (a : M), a ∈ l → 1 < a
⊢ ∀ (x : M), x ∈ b :: l → 1 < x

tactic: cases hx
state_before: ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ (a : M), a ∈ l → 1 < a
x : M
hx : x ∈ b :: l
⊢ 1 < x

tactic: exact hl₁.2.1
state_before: case head
ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ (a : M), a ∈ l → 1 < a
⊢ 1 < b

tactic: exact hl₁.2.2 _ ‹_›
state_before: case tail
ι : Type ?u.131727
α : Type ?u.131730
M : Type u_1
N : Type ?u.131736
P : Type ?u.131739
M₀ : Type ?u.131742
G : Type ?u.131745
R : Type ?u.131748
inst✝ : OrderedCommMonoid M
a b : M
l : List M
x✝ : a :: b :: l ≠ []
hl₁ : 1 < a ∧ 1 < b ∧ ∀ (a : M), a ∈ l → 1 < a
x : M
a✝ : Mem x l
⊢ 1 < x
Theorem: LocalHomeomorph.prod_eq_prod_of_nonempty'
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: rw [eq_comm, prod_eq_prod_of_nonempty h, eq_comm, @eq_comm _ e₂']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e : LocalHomeomorph α β
e' : LocalHomeomorph β γ
e₁ e₁' : LocalHomeomorph α β
e₂ e₂' : LocalHomeomorph γ δ
h : Set.Nonempty (prod e₁' e₂').toLocalEquiv.source
⊢ prod e₁ e₂ = prod e₁' e₂' ↔ e₁ = e₁' ∧ e₂ = e₂'
Theorem: fibRec_charPoly_eq
File: Mathlib/Data/Real/GoldenRatio.lean

tactic: rw [fibRec, LinearRecurrence.charPoly]
state_before: α : Type ?u.41184
inst✝¹ : CommSemiring α
β : Type u_1
inst✝ : CommRing β
⊢ LinearRecurrence.charPoly fibRec = X ^ 2 - (X + 1)

tactic: simp [Finset.sum_fin_eq_sum_range, Finset.sum_range_succ', ← smul_X_eq_monomial]
state_before: α : Type ?u.41184
inst✝¹ : CommSemiring α
β : Type u_1
inst✝ : CommRing β
⊢ (↑(monomial { order := 2, coeffs := ![1, 1] }.order) 1 -
      Finset.sum Finset.univ fun i => ↑(monomial ↑i) (LinearRecurrence.coeffs { order := 2, coeffs := ![1, 1] } i)) =
    X ^ 2 - (X + 1)
Theorem: differentiableOn_neg_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simpa only [neg_neg] using h.neg
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.421118
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.421213
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : DifferentiableOn 𝕜 (fun y => -f y) s
⊢ DifferentiableOn 𝕜 f s
Theorem: EReal.continuousAt_add_bot_bot
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [ContinuousAt, tendsto_nhds_bot_iff_real, bot_add]
state_before: α : Type ?u.27248
inst✝ : TopologicalSpace α
⊢ ContinuousAt (fun p => p.fst + p.snd) (⊥, ⊥)

tactic: refine fun r ↦ ((gt_mem_nhds (bot_lt_coe 0)).prod_nhds
  (gt_mem_nhds <| bot_lt_coe r)).mono fun _ h ↦ ?_
state_before: α : Type ?u.27248
inst✝ : TopologicalSpace α
⊢ ∀ (x : ℝ), ∀ᶠ (a : EReal × EReal) in 𝓝 (⊥, ⊥), a.fst + a.snd < ↑x

tactic: simpa only [coe_zero, zero_add] using add_lt_add h.1 h.2
state_before: α : Type ?u.27248
inst✝ : TopologicalSpace α
r : ℝ
x✝ : EReal × EReal
h : x✝.fst < ↑0 ∧ x✝.snd < ↑r
⊢ x✝.fst + x✝.snd < ↑r
Theorem: Nat.le_three_of_sqrt_eq_one
File: Mathlib/Data/Nat/Sqrt.lean

tactic: rw [h]
state_before: n : ℕ
h : sqrt n = 1
⊢ sqrt n < 2

tactic: decide
state_before: n : ℕ
h : sqrt n = 1
⊢ 1 < 2
Theorem: multiplicity.geom_sum₂_eq_one
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: rw [← Nat.cast_one]
state_before: R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
⊢ multiplicity (↑p) (∑ i in range p, x ^ i * y ^ (p - 1 - i)) = 1

tactic: refine' multiplicity.eq_coe_iff.2 ⟨_, _⟩
state_before: R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
⊢ multiplicity (↑p) (∑ i in range p, x ^ i * y ^ (p - ↑1 - i)) = 1

tactic: rw [dvd_iff_dvd_of_dvd_sub hxy] at hx
state_before: case refine'_2
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
⊢ ¬↑p ^ (1 + 1) ∣ ∑ i in range p, x ^ i * y ^ (p - ↑1 - i)

tactic: cases' hxy with k hk
state_before: case refine'_2
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ y
⊢ ¬↑p ^ (1 + 1) ∣ ∑ i in range p, x ^ i * y ^ (p - ↑1 - i)

tactic: rw [one_add_one_eq_two, eq_add_of_sub_eq' hk]
state_before: case refine'_2.intro
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hx : ¬↑p ∣ y
k : R
hk : x - y = ↑p * k
⊢ ¬↑p ^ (1 + 1) ∣ ∑ i in range p, x ^ i * y ^ (p - ↑1 - i)

tactic: refine' mt (dvd_iff_dvd_of_dvd_sub (@odd_sq_dvd_geom_sum₂_sub _ _ y k _ hp1)).mp _
state_before: case refine'_2.intro
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hx : ¬↑p ∣ y
k : R
hk : x - y = ↑p * k
⊢ ¬↑p ^ 2 ∣ ∑ i in range p, (y + ↑p * k) ^ i * y ^ (p - ↑1 - i)

tactic: rw [pow_two, mul_dvd_mul_iff_left hp.ne_zero]
state_before: case refine'_2.intro
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hx : ¬↑p ∣ y
k : R
hk : x - y = ↑p * k
⊢ ¬↑p ^ 2 ∣ ↑p * y ^ (p - 1)

tactic: exact mt hp.dvd_of_dvd_pow hx
state_before: case refine'_2.intro
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hx : ¬↑p ∣ y
k : R
hk : x - y = ↑p * k
⊢ ¬↑p ∣ y ^ (p - 1)

tactic: rw [pow_one]
state_before: case refine'_1
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
⊢ ↑p ^ 1 ∣ ∑ i in range p, x ^ i * y ^ (p - ↑1 - i)

tactic: exact dvd_geom_sum₂_self hxy
state_before: case refine'_1
R : Type u_1
n : ℕ
inst✝² : CommRing R
a b x y : R
p : ℕ
inst✝¹ : IsDomain R
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
hp : Prime ↑p
hp1 : Odd p
hxy : ↑p ∣ x - y
hx : ¬↑p ∣ x
⊢ ↑p ∣ ∑ i in range p, x ^ i * y ^ (p - ↑1 - i)
Theorem: UFModel.Agrees.get_eq
File: Mathlib/Data/UnionFind.lean

tactic: cases H
state_before: α : Type u_1
β : Sort u_2
f : α → β
arr : Array α
n : ℕ
m : Fin n → β
H : Agrees arr f m
⊢ ∀ (i : ℕ) (h₁ : i < Array.size arr) (h₂ : i < n),
    f (Array.get arr { val := i, isLt := h₁ }) = m { val := i, isLt := h₂ }

tactic: exact fun i h _ ↦ rfl
state_before: case mk
α : Type u_1
β : Sort u_2
f : α → β
arr : Array α
⊢ ∀ (i : ℕ) (h₁ h₂ : i < Array.size arr),
    f (Array.get arr { val := i, isLt := h₁ }) = (fun i => f (Array.get arr i)) { val := i, isLt := h₂ }
Theorem: Tuple.antitone_pair_of_not_sorted'
File: Mathlib/Data/Fin/Tuple/Sort.lean

tactic: contrapose! h
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : f ∘ ↑σ ≠ f ∘ ↑(sort f)
⊢ ∃ i j, i < j ∧ (f ∘ ↑σ) j < (f ∘ ↑σ) i

tactic: exact comp_sort_eq_comp_iff_monotone.mpr (monotone_iff_forall_lt.mpr h)
state_before: n : ℕ
α : Type u_1
inst✝ : LinearOrder α
f : Fin n → α
σ : Equiv.Perm (Fin n)
h : ∀ (i j : Fin n), i < j → (f ∘ ↑σ) i ≤ (f ∘ ↑σ) j
⊢ f ∘ ↑σ = f ∘ ↑(sort f)