tasksource/leandojo huggingface dataset:
Theorem: EuclideanGeometry.dist_smul_vadd_eq_dist
File: Mathlib/Geometry/Euclidean/Basic.lean

tactic: conv_lhs =>
  rw [← mul_self_inj_of_nonneg dist_nonneg dist_nonneg, dist_smul_vadd_sq, ← sub_eq_zero,
    add_sub_assoc, dist_eq_norm_vsub V p₁ p₂, ← real_inner_self_eq_norm_mul_norm, sub_self]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
⊢ dist (r • v +ᵥ p₁) p₂ = dist p₁ p₂ ↔ r = 0 ∨ r = -2 * inner v (p₁ -ᵥ p₂) / inner v v

tactic: have hvi : ⟪v, v⟫ ≠ 0 := by simpa using hv
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
⊢ inner v v * r * r + 2 * inner v (p₁ -ᵥ p₂) * r + 0 = 0 ↔ r = 0 ∨ r = -2 * inner v (p₁ -ᵥ p₂) / inner v v

tactic: have hd : discrim ⟪v, v⟫ (2 * ⟪v, p₁ -ᵥ p₂⟫) 0 = 2 * ⟪v, p₁ -ᵥ p₂⟫ * (2 * ⟪v, p₁ -ᵥ p₂⟫) := by
  rw [discrim]
  ring
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
hvi : inner v v ≠ 0
⊢ inner v v * r * r + 2 * inner v (p₁ -ᵥ p₂) * r + 0 = 0 ↔ r = 0 ∨ r = -2 * inner v (p₁ -ᵥ p₂) / inner v v

tactic: rw [quadratic_eq_zero_iff hvi hd, add_left_neg, zero_div, neg_mul_eq_neg_mul, ←
  mul_sub_right_distrib, sub_eq_add_neg, ← mul_two, mul_assoc, mul_div_assoc, mul_div_mul_left,
  mul_div_assoc]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
hvi : inner v v ≠ 0
hd : discrim (inner v v) (2 * inner v (p₁ -ᵥ p₂)) 0 = 2 * inner v (p₁ -ᵥ p₂) * (2 * inner v (p₁ -ᵥ p₂))
⊢ inner v v * r * r + 2 * inner v (p₁ -ᵥ p₂) * r + 0 = 0 ↔ r = 0 ∨ r = -2 * inner v (p₁ -ᵥ p₂) / inner v v

tactic: norm_num
state_before: case hc
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
hvi : inner v v ≠ 0
hd : discrim (inner v v) (2 * inner v (p₁ -ᵥ p₂)) 0 = 2 * inner v (p₁ -ᵥ p₂) * (2 * inner v (p₁ -ᵥ p₂))
⊢ 2 ≠ 0

tactic: simpa using hv
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
⊢ inner v v ≠ 0

tactic: rw [discrim]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
hvi : inner v v ≠ 0
⊢ discrim (inner v v) (2 * inner v (p₁ -ᵥ p₂)) 0 = 2 * inner v (p₁ -ᵥ p₂) * (2 * inner v (p₁ -ᵥ p₂))

tactic: ring
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
v : V
p₁ p₂ : P
hv : v ≠ 0
r : ℝ
hvi : inner v v ≠ 0
⊢ (2 * inner v (p₁ -ᵥ p₂)) ^ 2 - 4 * inner v v * 0 = 2 * inner v (p₁ -ᵥ p₂) * (2 * inner v (p₁ -ᵥ p₂))
Theorem: Seminorm.smul_ball_zero
File: Mathlib/Analysis/Seminorm.lean

tactic: ext
state_before: R : Type ?u.1183264
R' : Type ?u.1183267
𝕜 : Type u_1
𝕜₂ : Type ?u.1183273
𝕜₃ : Type ?u.1183276
𝕝 : Type ?u.1183279
E : Type u_2
E₂ : Type ?u.1183285
E₃ : Type ?u.1183288
F : Type ?u.1183291
G : Type ?u.1183294
ι : Type ?u.1183297
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x : E
p : Seminorm 𝕜 E
k : 𝕜
r : ℝ
hk : k ≠ 0
⊢ k • ball p 0 r = ball p 0 (‖k‖ * r)

tactic: rw [mem_smul_set_iff_inv_smul_mem₀ hk, p.mem_ball_zero, p.mem_ball_zero, map_smul_eq_mul,
  norm_inv, ← div_eq_inv_mul, div_lt_iff (norm_pos_iff.2 hk), mul_comm]
state_before: case h
R : Type ?u.1183264
R' : Type ?u.1183267
𝕜 : Type u_1
𝕜₂ : Type ?u.1183273
𝕜₃ : Type ?u.1183276
𝕝 : Type ?u.1183279
E : Type u_2
E₂ : Type ?u.1183285
E₃ : Type ?u.1183288
F : Type ?u.1183291
G : Type ?u.1183294
ι : Type ?u.1183297
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r✝ : ℝ
x : E
p : Seminorm 𝕜 E
k : 𝕜
r : ℝ
hk : k ≠ 0
x✝ : E
⊢ x✝ ∈ k • ball p 0 r ↔ x✝ ∈ ball p 0 (‖k‖ * r)
Theorem: Finset.disjSups_subset_sups
File: Mathlib/Data/Finset/Sups.lean

tactic: simp_rw [subset_iff, mem_sups, mem_disjSups]
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ s ○ t ⊆ s ⊻ t

tactic: exact fun c ⟨a, b, ha, hb, _, hc⟩ => ⟨a, b, ha, hb, hc⟩
state_before: α : Type u_1
inst✝³ : DecidableEq α
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ ∀ ⦃x : α⦄, (∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ Disjoint a b ∧ a ⊔ b = x) → ∃ a, a ∈ s ∧ ∃ b, b ∈ t ∧ a ⊔ b = x
Theorem: IsPrimitiveRoot.inv
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: simp only [h.pow_eq_one, inv_one, eq_self_iff_true, inv_pow]
state_before: M : Type ?u.2706015
N : Type ?u.2706018
G : Type u_1
R : Type ?u.2706024
S : Type ?u.2706027
F : Type ?u.2706030
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : G
h : IsPrimitiveRoot ζ k
⊢ ζ⁻¹ ^ k = 1

tactic: intro l hl
state_before: M : Type ?u.2706015
N : Type ?u.2706018
G : Type u_1
R : Type ?u.2706024
S : Type ?u.2706027
F : Type ?u.2706030
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l : ℕ
ζ : G
h : IsPrimitiveRoot ζ k
⊢ ∀ (l : ℕ), ζ⁻¹ ^ l = 1 → k ∣ l

tactic: apply h.dvd_of_pow_eq_one l
state_before: M : Type ?u.2706015
N : Type ?u.2706018
G : Type u_1
R : Type ?u.2706024
S : Type ?u.2706027
F : Type ?u.2706030
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l✝ : ℕ
ζ : G
h : IsPrimitiveRoot ζ k
l : ℕ
hl : ζ⁻¹ ^ l = 1
⊢ k ∣ l

tactic: rw [← inv_inj, ← inv_pow, hl, inv_one]
state_before: M : Type ?u.2706015
N : Type ?u.2706018
G : Type u_1
R : Type ?u.2706024
S : Type ?u.2706027
F : Type ?u.2706030
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
inst✝ : DivisionCommMonoid G
k l✝ : ℕ
ζ : G
h : IsPrimitiveRoot ζ k
l : ℕ
hl : ζ⁻¹ ^ l = 1
⊢ ζ ^ l = 1
Theorem: Matrix.add_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type u_2
m : Type u_1
n : Type u_3
o : Type ?u.267360
m' : o → Type ?u.267365
n' : o → Type ?u.267370
R : Type ?u.267373
S : Type ?u.267376
α : Type v
β : Type w
γ : Type ?u.267383
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
L M : Matrix l m α
N : Matrix m n α
⊢ (L + M) ⬝ N = L ⬝ N + M ⬝ N

tactic: apply add_dotProduct
state_before: case a.h
l : Type u_2
m : Type u_1
n : Type u_3
o : Type ?u.267360
m' : o → Type ?u.267365
n' : o → Type ?u.267370
R : Type ?u.267373
S : Type ?u.267376
α : Type v
β : Type w
γ : Type ?u.267383
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : Fintype m
L M : Matrix l m α
N : Matrix m n α
i✝ : l
x✝ : n
⊢ ((L + M) ⬝ N) i✝ x✝ = (L ⬝ N + M ⬝ N) i✝ x✝
Theorem: MvPolynomial.mem_vars
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical simp only [vars_def, Multiset.mem_toFinset, mem_degrees, mem_support_iff, exists_prop]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.152343
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
i : σ
⊢ i ∈ vars p ↔ ∃ d x, i ∈ d.support

tactic: simp only [vars_def, Multiset.mem_toFinset, mem_degrees, mem_support_iff, exists_prop]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.152343
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
i : σ
⊢ i ∈ vars p ↔ ∃ d x, i ∈ d.support
Theorem: Mathlib.Meta.NormNum.Rat.invOf_denom_swap
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [mul_invOf_eq_iff_eq_mul_right, ← Int.commute_cast, mul_assoc,
  ← mul_left_eq_iff_eq_invOf_mul, Int.commute_cast]
state_before: α : Type u_1
inst✝² : Ring α
n₁ n₂ : ℤ
a₁ a₂ : α
inst✝¹ : Invertible a₁
inst✝ : Invertible a₂
⊢ ↑n₁ * ⅟a₁ = ↑n₂ * ⅟a₂ ↔ ↑n₁ * a₂ = ↑n₂ * a₁
Theorem: Ideal.span_singleton_lt_span_singleton
File: Mathlib/RingTheory/Ideal/Basic.lean

tactic: rw [lt_iff_le_not_le, span_singleton_le_span_singleton, span_singleton_le_span_singleton,
  dvd_and_not_dvd_iff]
state_before: α : Type u
β : Type v
a b : α
inst✝² : CommSemiring α
I : Ideal α
inst✝¹ : CommRing β
inst✝ : IsDomain β
x y : β
⊢ span {x} < span {y} ↔ DvdNotUnit y x
Theorem: skewAdjointLieSubalgebraEquiv_symm_apply
File: Mathlib/Algebra/Lie/SkewAdjoint.lean

tactic: simp [skewAdjointLieSubalgebraEquiv]
state_before: R : Type u
M : Type v
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
B : BilinForm R M
N : Type w
inst✝¹ : AddCommGroup N
inst✝ : Module R N
e : N ≃ₗ[R] M
f : { x // x ∈ skewAdjointLieSubalgebra B }
⊢ ↑(↑(LieEquiv.symm (skewAdjointLieSubalgebraEquiv B e)) f) = ↑(LinearEquiv.lieConj (LinearEquiv.symm e)) ↑f
Theorem: Equiv.Perm.IsCycle.conj
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rintro ⟨x, hx, h⟩
state_before: ι : Type ?u.342424
α : Type u_1
β : Type ?u.342430
f g : Perm α
x y : α
⊢ IsCycle f → IsCycle (g * f * g⁻¹)

tactic: refine' ⟨g x, by simp [coe_mul, inv_apply_self, hx], fun y hy => _⟩
state_before: case intro.intro
ι : Type ?u.342424
α : Type u_1
β : Type ?u.342430
f g : Perm α
x✝ y x : α
hx : ↑f x ≠ x
h : ∀ ⦃y : α⦄, ↑f y ≠ y → SameCycle f x y
⊢ IsCycle (g * f * g⁻¹)

tactic: rw [← apply_inv_self g y]
state_before: case intro.intro
ι : Type ?u.342424
α : Type u_1
β : Type ?u.342430
f g : Perm α
x✝ y✝ x : α
hx : ↑f x ≠ x
h : ∀ ⦃y : α⦄, ↑f y ≠ y → SameCycle f x y
y : α
hy : ↑(g * f * g⁻¹) y ≠ y
⊢ SameCycle (g * f * g⁻¹) (↑g x) y

tactic: exact (h <| eq_inv_iff_eq.not.2 hy).conj
state_before: case intro.intro
ι : Type ?u.342424
α : Type u_1
β : Type ?u.342430
f g : Perm α
x✝ y✝ x : α
hx : ↑f x ≠ x
h : ∀ ⦃y : α⦄, ↑f y ≠ y → SameCycle f x y
y : α
hy : ↑(g * f * g⁻¹) y ≠ y
⊢ SameCycle (g * f * g⁻¹) (↑g x) (↑g (↑g⁻¹ y))

tactic: simp [coe_mul, inv_apply_self, hx]
state_before: ι : Type ?u.342424
α : Type u_1
β : Type ?u.342430
f g : Perm α
x✝ y x : α
hx : ↑f x ≠ x
h : ∀ ⦃y : α⦄, ↑f y ≠ y → SameCycle f x y
⊢ ↑(g * f * g⁻¹) (↑g x) ≠ ↑g x
Theorem: Fin.castLT_castAdd
File: Mathlib/Data/Fin/Basic.lean

tactic: ext
state_before: n m✝ m : ℕ
i : Fin n
⊢ castLT (↑(castAdd m) i) (_ : ↑(↑(castAdd m) i) < n) = i

tactic: simp
state_before: case h
n m✝ m : ℕ
i : Fin n
⊢ ↑(castLT (↑(castAdd m) i) (_ : ↑(↑(castAdd m) i) < n)) = ↑i
Theorem: iSup_emptyset
File: Mathlib/Order/CompleteLattice.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
β₂ : Type ?u.111941
γ : Type ?u.111944
ι : Sort ?u.111947
ι' : Sort ?u.111950
κ : ι → Sort ?u.111955
κ' : ι' → Sort ?u.111960
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : β → α
⊢ (⨆ (x : β) (_ : x ∈ ∅), f x) = ⊥
Theorem: Submodule.comap_map_eq_self
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [Submodule.comap_map_eq, sup_of_le_left h]
state_before: R : Type u_1
R₂ : Type u_3
K : Type ?u.300612
M : Type u_2
M₂ : Type u_4
V : Type ?u.300621
S : Type ?u.300624
inst✝⁶ : Semiring R
inst✝⁵ : Semiring R₂
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : AddCommGroup M₂
inst✝¹ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝ : RingHomSurjective τ₁₂
F : Type u_5
sc : SemilinearMapClass F τ₁₂ M M₂
f : F
p : Submodule R M
h : LinearMap.ker f ≤ p
⊢ comap f (map f p) = p
Theorem: Sum.not_isRight
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.7248
δ : Type ?u.7251
x✝ y x : α ⊕ β
⊢ (!decide (isRight x = isLeft x)) = true
Theorem: not_isAssociatedPrime_of_subsingleton
File: Mathlib/RingTheory/Ideal/AssociatedPrime.lean

tactic: rintro ⟨hI, x, hx⟩
state_before: R : Type u_2
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_1
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type ?u.27644
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : Subsingleton M
⊢ ¬IsAssociatedPrime I M

tactic: apply hI.ne_top
state_before: case intro.intro
R : Type u_2
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_1
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type ?u.27644
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : Subsingleton M
hI : Ideal.IsPrime I
x : M
hx : I = Submodule.annihilator (Submodule.span R {x})
⊢ False

tactic: rwa [Subsingleton.elim x 0, Submodule.span_singleton_eq_bot.mpr rfl, Submodule.annihilator_bot]
  at hx
state_before: case intro.intro
R : Type u_2
inst✝⁵ : CommRing R
I J : Ideal R
M : Type u_1
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
M' : Type ?u.27644
inst✝² : AddCommGroup M'
inst✝¹ : Module R M'
f : M →ₗ[R] M'
inst✝ : Subsingleton M
hI : Ideal.IsPrime I
x : M
hx : I = Submodule.annihilator (Submodule.span R {x})
⊢ I = ⊤
Theorem: HasFPowerSeriesAt.hasStrictFDerivAt
File: Mathlib/Analysis/Calculus/FDerivAnalytic.lean

tactic: refine' h.isBigO_image_sub_norm_mul_norm_sub.trans_isLittleO (IsLittleO.of_norm_right _)
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
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
h : HasFPowerSeriesAt f p x
⊢ HasStrictFDerivAt f (↑(continuousMultilinearCurryFin1 𝕜 E F) (p 1)) x

tactic: refine' isLittleO_iff_exists_eq_mul.2 ⟨fun y => ‖y - (x, x)‖, _, EventuallyEq.rfl⟩
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
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
h : HasFPowerSeriesAt f p x
⊢ (fun y => ‖y - (x, x)‖ * ‖y.fst - y.snd‖) =o[nhds (x, x)] fun x => ‖x.fst - x.snd‖

tactic: refine' (continuous_id.sub continuous_const).norm.tendsto' _ _ _
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
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
h : HasFPowerSeriesAt f p x
⊢ Tendsto (fun y => ‖y - (x, x)‖) (nhds (x, x)) (nhds 0)

tactic: rw [_root_.id, sub_self, norm_zero]
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
p : FormalMultilinearSeries 𝕜 E F
r : ℝ≥0∞
f : E → F
x : E
s : Set E
h : HasFPowerSeriesAt f p x
⊢ ‖id (x, x) - (x, x)‖ = 0
Theorem: integral_inv
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: have h' := fun x (hx : x ∈ [[a, b]]) => ne_of_mem_of_not_mem hx h
state_before: a b : ℝ
n : ℕ
h : ¬0 ∈ [[a, b]]
⊢ (∫ (x : ℝ) in a..b, x⁻¹) = Real.log (b / a)

tactic: rw [integral_deriv_eq_sub' _ deriv_log' (fun x hx => differentiableAt_log (h' x hx))
    (continuousOn_inv₀.mono <| subset_compl_singleton_iff.mpr h),
  log_div (h' b right_mem_uIcc) (h' a left_mem_uIcc)]
state_before: a b : ℝ
n : ℕ
h : ¬0 ∈ [[a, b]]
h' : ∀ (x : ℝ), x ∈ [[a, b]] → x ≠ 0
⊢ (∫ (x : ℝ) in a..b, x⁻¹) = Real.log (b / a)
Theorem: MeasureTheory.SimpleFunc.FinMeasSupp.lintegral_lt_top
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: refine' sum_lt_top fun a ha => _
state_before: α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
⊢ lintegral f μ < ⊤

tactic: rcases eq_or_ne a ∞ with (rfl | ha)
state_before: α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
a : ℝ≥0∞
ha : a ∈ SimpleFunc.range f
⊢ a * ↑↑μ (↑f ⁻¹' {a}) ≠ ⊤

tactic: simp only [ae_iff, Ne.def, Classical.not_not] at hf
state_before: case inl
α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
ha : ⊤ ∈ SimpleFunc.range f
⊢ ⊤ * ↑↑μ (↑f ⁻¹' {⊤}) ≠ ⊤

tactic: simp [Set.preimage, hf]
state_before: case inl
α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
ha : ⊤ ∈ SimpleFunc.range f
hf : ↑↑μ {a | ↑f a = ⊤} = 0
⊢ ⊤ * ↑↑μ (↑f ⁻¹' {⊤}) ≠ ⊤

tactic: by_cases ha0 : a = 0
state_before: case inr
α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
a : ℝ≥0∞
ha✝ : a ∈ SimpleFunc.range f
ha : a ≠ ⊤
⊢ a * ↑↑μ (↑f ⁻¹' {a}) ≠ ⊤

tactic: subst a
state_before: case pos
α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
a : ℝ≥0∞
ha✝ : a ∈ SimpleFunc.range f
ha : a ≠ ⊤
ha0 : a = 0
⊢ a * ↑↑μ (↑f ⁻¹' {a}) ≠ ⊤

tactic: rwa [MulZeroClass.zero_mul]
state_before: case pos
α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
ha✝ : 0 ∈ SimpleFunc.range f
ha : 0 ≠ ⊤
⊢ 0 * ↑↑μ (↑f ⁻¹' {0}) ≠ ⊤

tactic: exact mul_ne_top ha (finMeasSupp_iff.1 hm _ ha0).ne
state_before: case neg
α : Type u_1
β : Type ?u.918859
γ : Type ?u.918862
δ : Type ?u.918865
m : MeasurableSpace α
inst✝¹ : Zero β
inst✝ : Zero γ
μ : Measure α
f✝ : α →ₛ β
f : α →ₛ ℝ≥0∞
hm : SimpleFunc.FinMeasSupp f μ
hf : ∀ᵐ (a : α) ∂μ, ↑f a ≠ ⊤
a : ℝ≥0∞
ha✝ : a ∈ SimpleFunc.range f
ha : a ≠ ⊤
ha0 : ¬a = 0
⊢ a * ↑↑μ (↑f ⁻¹' {a}) ≠ ⊤
Theorem: Lean.Data.AC.Context.mergeIdem_head2
File: src/lean/Init/Data/AC.lean

tactic: simp [mergeIdem, mergeIdem.loop, h]
state_before: x y : Nat
ys : List Nat
h : x ≠ y
⊢ mergeIdem (x :: y :: ys) = x :: mergeIdem (y :: ys)
Theorem: Equiv.equivCongr_trans
File: Mathlib/Logic/Equiv/Defs.lean

tactic: ext
state_before: α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
⊢ (equivCongr ab de).trans (equivCongr bc ef) = equivCongr (ab.trans bc) (de.trans ef)

tactic: rfl
state_before: case H.H
α : Sort u
β : Sort v
γ : Sort w
δ : Sort u_1
ε : Sort u_2
ζ : Sort u_3
ab : α ≃ β
de : δ ≃ ε
bc : β ≃ γ
ef : ε ≃ ζ
x✝¹ : α ≃ δ
x✝ : γ
⊢ ↑(↑((equivCongr ab de).trans (equivCongr bc ef)) x✝¹) x✝ = ↑(↑(equivCongr (ab.trans bc) (de.trans ef)) x✝¹) x✝
Theorem: Matrix.circulant_isSymm_iff
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: rw [IsSymm, transpose_circulant, circulant_inj, funext_iff]
state_before: α : Type u_2
β : Type ?u.64028
m : Type ?u.64031
n : Type u_1
R : Type ?u.64037
inst✝ : AddGroup n
v : n → α
⊢ IsSymm (circulant v) ↔ ∀ (i : n), v (-i) = v i
Theorem: FirstOrder.Language.ElementarySubstructure.theory_model_iff
File: Mathlib/ModelTheory/ElementaryMaps.lean

tactic: simp only [Theory.model_iff, realize_sentence]
state_before: L : Language
M : Type u_3
N : Type ?u.401025
P : Type ?u.401028
Q : Type ?u.401031
inst✝³ : Structure L M
inst✝² : Structure L N
inst✝¹ : Structure L P
inst✝ : Structure L Q
S : ElementarySubstructure L M
T : Theory L
⊢ { x // x ∈ S } ⊨ T ↔ M ⊨ T
Theorem: CategoryTheory.Subobject.inf_pullback
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: revert f₁
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
X Y : C
g : X ⟶ Y
f₁ f₂ : Subobject Y
⊢ (pullback g).obj (f₁ ⊓ f₂) = (pullback g).obj f₁ ⊓ (pullback g).obj f₂

tactic: apply Quotient.ind'
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
X Y : C
g : X ⟶ Y
f₂ : Subobject Y
⊢ ∀ (f₁ : Subobject Y), (pullback g).obj (f₁ ⊓ f₂) = (pullback g).obj f₁ ⊓ (pullback g).obj f₂

tactic: intro f₁
state_before: case h
C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
X Y : C
g : X ⟶ Y
f₂ : Subobject Y
⊢ ∀ (a : MonoOver Y), (pullback g).obj (Quotient.mk'' a ⊓ f₂) = (pullback g).obj (Quotient.mk'' a) ⊓ (pullback g).obj f₂

tactic: erw [inf_def, inf_def, inf_eq_map_pullback', inf_eq_map_pullback', ← pullback_comp, ←
  map_pullback pullback.condition (pullbackIsPullback f₁.arrow g), ← pullback_comp,
  pullback.condition]
state_before: case h
C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
X Y : C
g : X ⟶ Y
f₂ : Subobject Y
f₁ : MonoOver Y
⊢ (pullback g).obj (Quotient.mk'' f₁ ⊓ f₂) = (pullback g).obj (Quotient.mk'' f₁) ⊓ (pullback g).obj f₂

tactic: rfl
state_before: case h
C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
X Y : C
g : X ⟶ Y
f₂ : Subobject Y
f₁ : MonoOver Y
⊢ (map pullback.snd).obj ((pullback (pullback.snd ≫ g)).obj f₂) =
    (map (MonoOver.arrow ((MonoOver.pullback g).obj f₁))).obj
      ((pullback (MonoOver.arrow ((MonoOver.pullback g).obj f₁) ≫ g)).obj f₂)
Theorem: Finsupp.single_smul
File: Mathlib/Data/Finsupp/Basic.lean

tactic: by_cases h : a = b <;> simp [h]
state_before: α : Type u_3
β : Type ?u.579469
γ : Type ?u.579472
ι : Type ?u.579475
M : Type u_1
M' : Type ?u.579481
N : Type ?u.579484
P : Type ?u.579487
G : Type ?u.579490
H : Type ?u.579493
R : Type u_2
S : Type ?u.579499
inst✝² : Zero M
inst✝¹ : MonoidWithZero R
inst✝ : MulActionWithZero R M
a b : α
f : α → M
r : R
⊢ ↑(single a r) b • f a = ↑(single a (r • f b)) b
Theorem: IsUnit.mul_right_dvd
File: Mathlib/Algebra/Divisibility/Units.lean

tactic: rcases hu with ⟨u, rfl⟩
state_before: α : Type u_1
inst✝ : Monoid α
a b u : α
hu : IsUnit u
⊢ a * u ∣ b ↔ a ∣ b

tactic: apply Units.mul_right_dvd
state_before: case intro
α : Type u_1
inst✝ : Monoid α
a b : α
u : αˣ
⊢ a * ↑u ∣ b ↔ a ∣ b
Theorem: CategoryTheory.Limits.equalizerSubobject_factors_iff
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: rw [← Subobject.factorThru_arrow _ _ w, Category.assoc, equalizerSubobject_arrow_comp,
  Category.assoc]
state_before: C : Type u
inst✝¹ : Category C
X Y Z : C
f g : X ⟶ Y
inst✝ : HasEqualizer f g
W : C
h : W ⟶ X
w : Factors (equalizerSubobject f g) h
⊢ h ≫ f = h ≫ g
Theorem: Polynomial.degree_cyclotomic'
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: simp only [degree_eq_natDegree (cyclotomic'_ne_zero n R), natDegree_cyclotomic' h]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
ζ : R
n : ℕ
h : IsPrimitiveRoot ζ n
⊢ degree (cyclotomic' n R) = ↑(Nat.totient n)
Theorem: Rat.zero_divInt
File: Std/Data/Rat/Lemmas.lean

tactic: cases n <;> simp [divInt]
state_before: n : Int
⊢ 0 /. n = 0
Theorem: Function.Injective.mem_finset_image
File: Mathlib/Data/Finset/Image.lean

tactic: refine' ⟨fun h => _, Finset.mem_image_of_mem f⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.69600
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
hf : Injective f
⊢ f a ∈ image f s ↔ a ∈ s

tactic: obtain ⟨y, hy, heq⟩ := mem_image.1 h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.69600
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
hf : Injective f
h : f a ∈ image f s
⊢ a ∈ s

tactic: exact hf heq ▸ hy
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.69600
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
hf : Injective f
h : f a ∈ image f s
y : α
hy : y ∈ s
heq : f y = f a
⊢ a ∈ s