tasksource/leandojo huggingface dataset:
Theorem: Real.exp_bound'
File: Mathlib/Data/Complex/Exponential.lean

tactic: have h3 : |x| = x := by simpa
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
⊢ exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑n + 1) / (↑(Nat.factorial n) * ↑n)

tactic: have h4 : |x| ≤ 1 := by rwa [h3]
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
h3 : abs' x = x
⊢ exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑n + 1) / (↑(Nat.factorial n) * ↑n)

tactic: have h' := Real.exp_bound h4 hn
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
h3 : abs' x = x
h4 : abs' x ≤ 1
⊢ exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑n + 1) / (↑(Nat.factorial n) * ↑n)

tactic: rw [h3] at h'
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
h3 : abs' x = x
h4 : abs' x ≤ 1
h' :
  abs' (exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m)) ≤ abs' x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))
⊢ exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑n + 1) / (↑(Nat.factorial n) * ↑n)

tactic: have h'' := (abs_sub_le_iff.1 h').1
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
h3 : abs' x = x
h4 : abs' x ≤ 1
h' : abs' (exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m)) ≤ x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))
⊢ exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑n + 1) / (↑(Nat.factorial n) * ↑n)

tactic: have t := sub_le_iff_le_add'.1 h''
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
h3 : abs' x = x
h4 : abs' x ≤ 1
h' : abs' (exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m)) ≤ x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))
h'' : exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m) ≤ x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))
⊢ exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑n + 1) / (↑(Nat.factorial n) * ↑n)

tactic: simpa [mul_div_assoc] using t
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
h3 : abs' x = x
h4 : abs' x ≤ 1
h' : abs' (exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m)) ≤ x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))
h'' : exp x - ∑ m in range n, x ^ m / ↑(Nat.factorial m) ≤ x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))
t : exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑(Nat.succ n) / (↑(Nat.factorial n) * ↑n))
⊢ exp x ≤ ∑ m in range n, x ^ m / ↑(Nat.factorial m) + x ^ n * (↑n + 1) / (↑(Nat.factorial n) * ↑n)

tactic: simpa
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
⊢ abs' x = x

tactic: rwa [h3]
state_before: x : ℝ
h1 : 0 ≤ x
h2 : x ≤ 1
n : ℕ
hn : 0 < n
h3 : abs' x = x
⊢ abs' x ≤ 1
Theorem: Prod.mk_covby_mk_iff_right
File: Mathlib/Order/Cover.lean

tactic: simp_rw [covby_iff_wcovby_and_lt, mk_wcovby_mk_iff_right, mk_lt_mk_iff_right]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a, b₁) ⋖ (a, b₂) ↔ b₁ ⋖ b₂
Theorem: ENNReal.lintegral_rpow_funMulInvSnorm_eq_one
File: Mathlib/MeasureTheory/Integral/MeanInequalities.lean

tactic: simp_rw [funMulInvSnorm_rpow hp0_lt]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0_lt : 0 < p
f : α → ℝ≥0∞
hf_nonzero : (∫⁻ (a : α), f a ^ p ∂μ) ≠ 0
hf_top : (∫⁻ (a : α), f a ^ p ∂μ) ≠ ⊤
⊢ (∫⁻ (c : α), funMulInvSnorm f p μ c ^ p ∂μ) = 1

tactic: rw [lintegral_mul_const', ENNReal.mul_inv_cancel hf_nonzero hf_top]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0_lt : 0 < p
f : α → ℝ≥0∞
hf_nonzero : (∫⁻ (a : α), f a ^ p ∂μ) ≠ 0
hf_top : (∫⁻ (a : α), f a ^ p ∂μ) ≠ ⊤
⊢ (∫⁻ (c : α), f c ^ p * (∫⁻ (c : α), f c ^ p ∂μ)⁻¹ ∂μ) = 1

tactic: rwa [inv_ne_top]
state_before: case hr
α : Type u_1
inst✝ : MeasurableSpace α
μ : MeasureTheory.Measure α
p : ℝ
hp0_lt : 0 < p
f : α → ℝ≥0∞
hf_nonzero : (∫⁻ (a : α), f a ^ p ∂μ) ≠ 0
hf_top : (∫⁻ (a : α), f a ^ p ∂μ) ≠ ⊤
⊢ (∫⁻ (c : α), f c ^ p ∂μ)⁻¹ ≠ ⊤
Theorem: Lagrange.basisDivisor_add_symm
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: classical rw [
  ← sum_basis (Set.injOn_of_injective Function.injective_id _) ⟨x, mem_insert_self _ {y}⟩,
  sum_insert (not_mem_singleton.mpr hxy), sum_singleton, basis_pair_left hxy,
  basis_pair_right hxy, id, id]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type ?u.84878
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
x y : F
hxy : x ≠ y
⊢ basisDivisor x y + basisDivisor y x = 1

tactic: rw [
← sum_basis (Set.injOn_of_injective Function.injective_id _) ⟨x, mem_insert_self _ {y}⟩,
sum_insert (not_mem_singleton.mpr hxy), sum_singleton, basis_pair_left hxy,
basis_pair_right hxy, id, id]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type ?u.84878
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
x y : F
hxy : x ≠ y
⊢ basisDivisor x y + basisDivisor y x = 1
Theorem: inner_self_ofReal_norm
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_self_re_eq_norm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1684989
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑‖inner x x‖ = inner x x

tactic: exact inner_self_ofReal_re _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1684989
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x : E
⊢ ↑(↑re (inner x x)) = inner x x
Theorem: Ordinal.mul_ne_zero
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [Ordinal.pos_iff_ne_zero] using mul_pos
state_before: α : Type ?u.217228
β : Type ?u.217231
γ : Type ?u.217234
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal
⊢ a ≠ 0 → b ≠ 0 → a * b ≠ 0
Theorem: EReal.coe_abs
File: Mathlib/Data/Real/EReal.lean

tactic: rw [abs_def, ← Real.coe_nnabs, ENNReal.ofReal_coe_nnreal]
state_before: x : ℝ
⊢ ↑(EReal.abs ↑x) = ↑(abs x)

tactic: rfl
state_before: x : ℝ
⊢ ↑↑(↑Real.nnabs x) = ↑↑(↑Real.nnabs x)
Theorem: BoxIntegral.Prepartition.restrict_mono
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: refine' ofWithBot_mono fun J₁ hJ₁ hne => _
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
⊢ restrict π₁ J ≤ restrict π₂ J

tactic: rw [Finset.mem_image] at hJ₁
state_before: ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : WithBot (Box ι)
hJ₁ : J₁ ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₁.boxes
hne : J₁ ≠ ⊥
⊢ ∃ J', J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes ∧ J₁ ≤ J'

tactic: rcases hJ₁ with ⟨J₁, hJ₁, rfl⟩
state_before: ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : WithBot (Box ι)
hJ₁ : ∃ a, a ∈ π₁.boxes ∧ ↑J ⊓ ↑a = J₁
hne : J₁ ≠ ⊥
⊢ ∃ J', J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes ∧ J₁ ≤ J'

tactic: rcases Hle hJ₁ with ⟨J₂, hJ₂, hle⟩
state_before: case intro.intro
ι : Type u_1
I J J₁✝ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : Box ι
hJ₁ : J₁ ∈ π₁.boxes
hne : ↑J ⊓ ↑J₁ ≠ ⊥
⊢ ∃ J', J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes ∧ ↑J ⊓ ↑J₁ ≤ J'

tactic: exact ⟨_, Finset.mem_image_of_mem _ hJ₂, inf_le_inf_left _ <| WithBot.coe_le_coe.2 hle⟩
state_before: case intro.intro.intro.intro
ι : Type u_1
I J J₁✝ J₂✝ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
Hle : π₁ ≤ π₂
J₁ : Box ι
hJ₁ : J₁ ∈ π₁.boxes
hne : ↑J ⊓ ↑J₁ ≠ ⊥
J₂ : Box ι
hJ₂ : J₂ ∈ π₂
hle : J₁ ≤ J₂
⊢ ∃ J', J' ∈ Finset.image (fun J' => ↑J ⊓ ↑J') π₂.boxes ∧ ↑J ⊓ ↑J₁ ≤ J'
Theorem: Module.card_fintype
File: Mathlib/LinearAlgebra/Basis.lean

tactic: classical
  calc
    card M = card (ι → R) := card_congr b.equivFun.toEquiv
    _ = card R ^ card ι := card_fun
state_before: ι : Type u_1
ι' : Type ?u.640840
R : Type u_2
R₂ : Type ?u.640846
K : Type ?u.640849
M : Type u_3
M' : Type ?u.640855
M'' : Type ?u.640858
V : Type u
V' : Type ?u.640863
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : Fintype ι
b✝ b : Basis ι R M
inst✝¹ : Fintype R
inst✝ : Fintype M
⊢ card M = card R ^ card ι

tactic: calc
  card M = card (ι → R) := card_congr b.equivFun.toEquiv
  _ = card R ^ card ι := card_fun
state_before: ι : Type u_1
ι' : Type ?u.640840
R : Type u_2
R₂ : Type ?u.640846
K : Type ?u.640849
M : Type u_3
M' : Type ?u.640855
M'' : Type ?u.640858
V : Type u
V' : Type ?u.640863
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
inst✝⁴ : AddCommMonoid M'
inst✝³ : Module R M'
inst✝² : Fintype ι
b✝ b : Basis ι R M
inst✝¹ : Fintype R
inst✝ : Fintype M
⊢ card M = card R ^ card ι
Theorem: cauchySeq_of_edist_le_geometric_two
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: simp only [div_eq_mul_inv, ENNReal.inv_pow] at hu
state_before: α : Type u_1
β : Type ?u.439361
ι : Type ?u.439364
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C / 2 ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
⊢ CauchySeq f

tactic: refine' cauchySeq_of_edist_le_geometric 2⁻¹ C _ hC hu
state_before: α : Type u_1
β : Type ?u.439361
ι : Type ?u.439364
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ CauchySeq f

tactic: simp [ENNReal.one_lt_two]
state_before: α : Type u_1
β : Type ?u.439361
ι : Type ?u.439364
inst✝ : PseudoEMetricSpace α
C : ℝ≥0∞
hC : C ≠ ⊤
f : ℕ → α
a : α
ha : Tendsto f atTop (𝓝 a)
hu : ∀ (n : ℕ), edist (f n) (f (n + 1)) ≤ C * 2⁻¹ ^ n
⊢ 2⁻¹ < 1
Theorem: Submodule.QuotientTorsion.torsion_eq_bot
File: Mathlib/Algebra/Module/Torsion.lean

tactic: rw [Quotient.mk''_eq_mk, ← Quotient.mk_smul, Quotient.mk_eq_zero] at hax
state_before: R : Type u_2
M : Type u_1
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
z : M ⧸ torsion R M
x : M
x✝ : Quotient.mk'' x ∈ torsion R (M ⧸ torsion R M)
a : { x // x ∈ R⁰ }
hax : a • Quotient.mk'' x = 0
⊢ Quotient.mk'' x ∈ ⊥

tactic: rw [mem_bot, Quotient.mk''_eq_mk, Quotient.mk_eq_zero]
state_before: R : Type u_2
M : Type u_1
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
z : M ⧸ torsion R M
x : M
x✝ : Quotient.mk'' x ∈ torsion R (M ⧸ torsion R M)
a : { x // x ∈ R⁰ }
hax : a • x ∈ torsion R M
⊢ Quotient.mk'' x ∈ ⊥

tactic: cases' hax with b h
state_before: R : Type u_2
M : Type u_1
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
z : M ⧸ torsion R M
x : M
x✝ : Quotient.mk'' x ∈ torsion R (M ⧸ torsion R M)
a : { x // x ∈ R⁰ }
hax : a • x ∈ torsion R M
⊢ x ∈ torsion R M

tactic: exact ⟨b * a, (mul_smul _ _ _).trans h⟩
state_before: case intro
R : Type u_2
M : Type u_1
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
z : M ⧸ torsion R M
x : M
x✝ : Quotient.mk'' x ∈ torsion R (M ⧸ torsion R M)
a b : { x // x ∈ R⁰ }
h : b • a • x = 0
⊢ x ∈ torsion R M
Theorem: CategoryTheory.Presieve.functorPushforward_comp
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: funext x
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X
⊢ functorPushforward (F ⋙ G) R = functorPushforward G (functorPushforward F R)

tactic: ext f
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X
x : E
⊢ functorPushforward (F ⋙ G) R = functorPushforward G (functorPushforward F R)

tactic: constructor
state_before: case h.h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X
x : E
f : x ⟶ (F ⋙ G).obj X
⊢ f ∈ functorPushforward (F ⋙ G) R ↔ f ∈ functorPushforward G (functorPushforward F R)

tactic: rintro ⟨X, f₁, g₁, h₁, rfl⟩
state_before: case h.h.mp
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X
x : E
f : x ⟶ (F ⋙ G).obj X
⊢ f ∈ functorPushforward (F ⋙ G) R → f ∈ functorPushforward G (functorPushforward F R)

tactic: exact ⟨F.obj X, F.map f₁, g₁, ⟨X, f₁, 𝟙 _, h₁, by simp⟩, rfl⟩
state_before: case h.h.mp.intro.intro.intro.intro
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X✝
x : E
X : C
f₁ : X ⟶ X✝
g₁ : x ⟶ (F ⋙ G).obj X
h₁ : R f₁
⊢ g₁ ≫ (F ⋙ G).map f₁ ∈ functorPushforward G (functorPushforward F R)

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X✝
x : E
X : C
f₁ : X ⟶ X✝
g₁ : x ⟶ (F ⋙ G).obj X
h₁ : R f₁
⊢ F.map f₁ = 𝟙 (F.obj X) ≫ F.map f₁

tactic: rintro ⟨X, f₁, g₁, ⟨X', f₂, g₂, h₁, rfl⟩, rfl⟩
state_before: case h.h.mpr
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X
x : E
f : x ⟶ (F ⋙ G).obj X
⊢ f ∈ functorPushforward G (functorPushforward F R) → f ∈ functorPushforward (F ⋙ G) R

tactic: exact ⟨X', f₂, g₁ ≫ G.map g₂, h₁, by simp⟩
state_before: case h.h.mpr.intro.intro.intro.intro.intro.intro.intro.intro
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X✝
x : E
X : D
g₁ : x ⟶ G.obj X
X' : C
f₂ : X' ⟶ X✝
g₂ : X ⟶ F.obj X'
h₁ : R f₂
⊢ g₁ ≫ G.map (g₂ ≫ F.map f₂) ∈ functorPushforward (F ⋙ G) R

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X✝ Y Z : C
f : Y ⟶ X✝
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Presieve X✝
x : E
X : D
g₁ : x ⟶ G.obj X
X' : C
f₂ : X' ⟶ X✝
g₂ : X ⟶ F.obj X'
h₁ : R f₂
⊢ g₁ ≫ G.map (g₂ ≫ F.map f₂) = (g₁ ≫ G.map g₂) ≫ (F ⋙ G).map f₂
Theorem: integral_exp_neg_Ioi
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

tactic: simpa only [integral_comp_neg_Ioi] using integral_exp_Iic (-c)
state_before: c : ℝ
⊢ (∫ (x : ℝ) in Ioi c, exp (-x)) = exp (-c)
Theorem: Option.map₂_eq_none_iff
File: Mathlib/Data/Option/NAry.lean

tactic: cases a <;> cases b <;> simp
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
f : α → β → γ
a : Option α
b : Option β
c : Option γ
⊢ map₂ f a b = none ↔ a = none ∨ b = none
Theorem: Int.fmod_def
File: Std/Data/Int/DivMod.lean

tactic: rw [← Int.add_sub_cancel (a.fmod b), fmod_add_fdiv]
state_before: a b : Int
⊢ fmod a b = a - b * fdiv a b
Theorem: Rat.normalize_eq_zero
File: Std/Data/Rat/Lemmas.lean

tactic: have' := normalize_eq_iff d0 Nat.one_ne_zero
state_before: d : Nat
n : Int
d0 : d ≠ 0
⊢ normalize n d = 0 ↔ n = 0

tactic: rw [normalize_zero (d := 1)] at this
state_before: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize ?refine'_1 d = normalize ?refine'_2 1 ↔ ?refine'_1 * ↑1 = ?refine'_2 * ↑d
⊢ normalize n d = 0 ↔ n = 0

case refine'_1
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

case refine'_2
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

tactic: rw [this]
state_before: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize ?refine'_1 d = 0 ↔ ?refine'_1 * ↑1 = 0 * ↑d
⊢ normalize n d = 0 ↔ n = 0

case refine'_1
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

case refine'_1
d : Nat
n : Int
d0 : d ≠ 0
⊢ Int

tactic: simp
state_before: case refine'_3
d : Nat
n : Int
d0 : d ≠ 0
this : normalize n d = 0 ↔ n * ↑1 = 0 * ↑d
⊢ n * ↑1 = 0 * ↑d ↔ n = 0
Theorem: CategoryTheory.Abelian.kernel.lift.inv
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: have := isIso_kernel_lift_of_exact_of_mono _ _ ex
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono f
ex : Exact f g
⊢ let_fun this := (_ : IsIso (kernel.lift g f (_ : f ≫ g = 0)));
  CategoryTheory.inv (kernel.lift g f (_ : f ≫ g = 0)) ≫ f = kernel.ι g

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono f
ex : Exact f g
this : IsIso (kernel.lift g f (_ : f ≫ g = 0))
⊢ let_fun this := (_ : IsIso (kernel.lift g f (_ : f ≫ g = 0)));
  CategoryTheory.inv (kernel.lift g f (_ : f ≫ g = 0)) ≫ f = kernel.ι g
Theorem: Set.prod_singleton
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.9697
δ : Type ?u.9700
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ {b} = (fun a => (a, b)) '' s

tactic: simp [and_left_comm, eq_comm]
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.9697
δ : Type ?u.9700
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α
y : β
⊢ (x, y) ∈ s ×ˢ {b} ↔ (x, y) ∈ (fun a => (a, b)) '' s
Theorem: PartENat.pos_iff_one_le
File: Mathlib/Data/Nat/PartENat.lean

tactic: simp only [iff_true_iff, le_top, natCast_lt_top, ← @Nat.cast_zero PartENat]
state_before: x : PartENat
⊢ 0 < ⊤ ↔ 1 ≤ ⊤

tactic: rw [← Nat.cast_zero, ← Nat.cast_one, PartENat.coe_lt_coe, PartENat.coe_le_coe]
state_before: x : PartENat
n : ℕ
⊢ 0 < ↑n ↔ 1 ≤ ↑n

tactic: rfl
state_before: x : PartENat
n : ℕ
⊢ 0 < n ↔ 1 ≤ n
Theorem: MeasurableSpace.measurableSet_iInf
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: rw [iInf, measurableSet_sInf, forall_range_iff]
state_before: α : Type u_2
β : Type ?u.30962
γ : Type ?u.30965
δ : Type ?u.30968
δ' : Type ?u.30971
ι✝ : Sort ?u.30974
s✝ t u : Set α
ι : Sort u_1
m : ι → MeasurableSpace α
s : Set α
⊢ MeasurableSet s ↔ ∀ (i : ι), MeasurableSet s
Theorem: symmDiff_self
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff, sup_idem, sdiff_self]
state_before: ι : Type ?u.17889
α : Type u_1
β : Type ?u.17895
π : ι → Type ?u.17900
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ a = ⊥
Theorem: Int.ModEq.mul_left'
File: Mathlib/Data/Int/ModEq.lean

tactic: obtain hc | rfl | hc := lt_trichotomy c 0
state_before: m n a b c d : ℤ
h : a ≡ b [ZMOD n]
⊢ c * a ≡ c * b [ZMOD c * n]

tactic: rw [← neg_modEq_neg, ← modEq_neg, ← neg_mul, ← neg_mul, ← neg_mul]
state_before: case inl
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : c < 0
⊢ c * a ≡ c * b [ZMOD c * n]

tactic: simp only [ModEq, mul_emod_mul_of_pos _ _ (neg_pos.2 hc), h.eq]
state_before: case inl
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : c < 0
⊢ -c * a ≡ -c * b [ZMOD -c * n]

tactic: simp
state_before: case inr.inl
m n a b d : ℤ
h : a ≡ b [ZMOD n]
⊢ 0 * a ≡ 0 * b [ZMOD 0 * n]

tactic: simp only [ModEq, mul_emod_mul_of_pos _ _ hc, h.eq]
state_before: case inr.inr
m n a b c d : ℤ
h : a ≡ b [ZMOD n]
hc : 0 < c
⊢ c * a ≡ c * b [ZMOD c * n]
Theorem: Hyperreal.infinitesimal_pos_iff_infinitePos_inv
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [inv_inv]
state_before: x : ℝ*
⊢ Infinitesimal x⁻¹⁻¹ ∧ 0 < x⁻¹⁻¹ ↔ Infinitesimal x ∧ 0 < x
Theorem: SimpleGraph.Subgraph.deleteEdges_le
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: constructor <;> simp (config := { contextual := true }) [subset_rfl]
state_before: ι : Sort ?u.247819
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ deleteEdges G' s ≤ G'
Theorem: Mathlib.Tactic.Abel.term_add_constg
File: Mathlib/Tactic/Abel.lean

tactic: simp [h.symm, termg, add_assoc]
state_before: α : Type u_1
inst✝ : AddCommGroup α
n : ℤ
x a k a' : α
h : a + k = a'
⊢ termg n x a + k = termg n x a'
Theorem: Cubic.leadingCoeff_of_b_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_a_eq_zero ha, leadingCoeff_quadratic hb]
state_before: R : Type u_1
S : Type ?u.555902
F : Type ?u.555905
K : Type ?u.555908
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b ≠ 0
⊢ leadingCoeff (toPoly P) = P.b
Theorem: Ordinal.sup_iterate_eq_nfp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: refine' funext fun a => le_antisymm _ (sup_le fun l => _)
state_before: f✝ f : Ordinal → Ordinal
⊢ (fun a => sup fun n => (f^[n]) a) = nfp f

tactic: rw [sup_le_iff]
state_before: case refine'_1
f✝ f : Ordinal → Ordinal
a : Ordinal
⊢ (sup fun n => (f^[n]) a) ≤ nfp f a

tactic: intro n
state_before: case refine'_1
f✝ f : Ordinal → Ordinal
a : Ordinal
⊢ ∀ (i : ℕ), (f^[i]) a ≤ nfp f a

tactic: rw [← List.length_replicate n Unit.unit, ← List.foldr_const f a]
state_before: case refine'_1
f✝ f : Ordinal → Ordinal
a : Ordinal
n : ℕ
⊢ (f^[n]) a ≤ nfp f a

tactic: apply le_sup
state_before: case refine'_1
f✝ f : Ordinal → Ordinal
a : Ordinal
n : ℕ
⊢ List.foldr (fun x => f) a (List.replicate n ()) ≤ nfp f a

tactic: rw [List.foldr_const f a l]
state_before: case refine'_2
f✝ f : Ordinal → Ordinal
a : Ordinal
l : List Unit
⊢ List.foldr (fun x => f) a l ≤ sup fun n => (f^[n]) a

tactic: exact le_sup _ _
state_before: case refine'_2
f✝ f : Ordinal → Ordinal
a : Ordinal
l : List Unit
⊢ (f^[List.length l]) a ≤ sup fun n => (f^[n]) a
Theorem: Fin.sum_const
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.62145
inst✝ : AddCommMonoid α
n : ℕ
x : α
⊢ ∑ _i : Fin n, x = n • x
Theorem: Finset.Iic_eq_cons_Iio
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: classical rw [cons_eq_insert, Iio_insert]
state_before: ι : Type ?u.119351
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrderBot α
b : α
⊢ Iic b = cons b (Iio b) (_ : ¬b ∈ Iio b)

tactic: rw [cons_eq_insert, Iio_insert]
state_before: ι : Type ?u.119351
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrderBot α
b : α
⊢ Iic b = cons b (Iio b) (_ : ¬b ∈ Iio b)
Theorem: Nat.gcd_dvd
File: Std/Data/Nat/Gcd.lean

tactic: induction m, n using gcd.induction with
| H0 n => rw [gcd_zero_left]; exact ⟨Nat.dvd_zero n, Nat.dvd_refl n⟩
| H1 m n _ IH => rw [← gcd_rec] at IH; exact ⟨IH.2, (dvd_mod_iff IH.2).1 IH.1⟩
state_before: m n : Nat
⊢ gcd m n ∣ m ∧ gcd m n ∣ n

tactic: rw [gcd_zero_left]
state_before: case H0
n : Nat
⊢ gcd 0 n ∣ 0 ∧ gcd 0 n ∣ n

tactic: exact ⟨Nat.dvd_zero n, Nat.dvd_refl n⟩
state_before: case H0
n : Nat
⊢ n ∣ 0 ∧ n ∣ n

tactic: rw [← gcd_rec] at IH
state_before: case H1
m n : Nat
a✝ : 0 < m
IH : gcd (n % m) m ∣ n % m ∧ gcd (n % m) m ∣ m
⊢ gcd m n ∣ m ∧ gcd m n ∣ n

tactic: exact ⟨IH.2, (dvd_mod_iff IH.2).1 IH.1⟩
state_before: case H1
m n : Nat
a✝ : 0 < m
IH : gcd m n ∣ n % m ∧ gcd m n ∣ m
⊢ gcd m n ∣ m ∧ gcd m n ∣ n
Theorem: Nat.lcm_dvd
File: Std/Data/Nat/Gcd.lean

tactic: match eq_zero_or_pos k with
| .inl h => rw [h]; exact Nat.dvd_zero _
| .inr kpos =>
  apply Nat.dvd_of_mul_dvd_mul_left (gcd_pos_of_pos_left n (pos_of_dvd_of_pos H1 kpos))
  rw [gcd_mul_lcm, ← gcd_mul_right, Nat.mul_comm n k]
  exact dvd_gcd (Nat.mul_dvd_mul_left _ H2) (Nat.mul_dvd_mul_right H1 _)
state_before: m n k : Nat
H1 : m ∣ k
H2 : n ∣ k
⊢ lcm m n ∣ k

tactic: rw [h]
state_before: m n k : Nat
H1 : m ∣ k
H2 : n ∣ k
h : k = 0
⊢ lcm m n ∣ k

tactic: exact Nat.dvd_zero _
state_before: m n k : Nat
H1 : m ∣ k
H2 : n ∣ k
h : k = 0
⊢ lcm m n ∣ 0

tactic: apply Nat.dvd_of_mul_dvd_mul_left (gcd_pos_of_pos_left n (pos_of_dvd_of_pos H1 kpos))
state_before: m n k : Nat
H1 : m ∣ k
H2 : n ∣ k
kpos : k > 0
⊢ lcm m n ∣ k

tactic: rw [gcd_mul_lcm, ← gcd_mul_right, Nat.mul_comm n k]
state_before: m n k : Nat
H1 : m ∣ k
H2 : n ∣ k
kpos : k > 0
⊢ gcd m n * lcm m n ∣ gcd m n * k

tactic: exact dvd_gcd (Nat.mul_dvd_mul_left _ H2) (Nat.mul_dvd_mul_right H1 _)
state_before: m n k : Nat
H1 : m ∣ k
H2 : n ∣ k
kpos : k > 0
⊢ m * n ∣ gcd (m * k) (k * n)
Theorem: Nat.odd_add
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [odd_iff_not_even, even_add, not_iff, odd_iff_not_even]
state_before: m n : ℕ
⊢ Odd (m + n) ↔ (Odd m ↔ Even n)