tasksource/leandojo huggingface dataset:
Theorem: fderiv_zero_of_not_differentiableAt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: have : ¬∃ f', HasFDerivAt f f' x := h
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.41308
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.41403
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 : ¬DifferentiableAt 𝕜 f x
⊢ fderiv 𝕜 f x = 0

tactic: simp [fderiv, this]
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.41308
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.41403
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 : ¬DifferentiableAt 𝕜 f x
this : ¬∃ f', HasFDerivAt f f' x
⊢ fderiv 𝕜 f x = 0
Theorem: Nat.coprime_self_add_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [coprime, coprime, gcd_self_add_left]
state_before: m n : ℕ
⊢ coprime (m + n) m ↔ coprime n m
Theorem: Filter.prod_iInf_left
File: Mathlib/Order/Filter/Prod.lean

tactic: dsimp only [SProd.sprod]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.11121
δ : Type ?u.11124
ι : Sort u_1
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ (⨅ (i : ι), f i) ×ˢ g = ⨅ (i : ι), f i ×ˢ g

tactic: rw [Filter.prod, comap_iInf, iInf_inf]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.11121
δ : Type ?u.11124
ι : Sort u_1
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ Filter.prod (⨅ (i : ι), f i) g = ⨅ (i : ι), Filter.prod (f i) g

tactic: simp only [Filter.prod, eq_self_iff_true]
state_before: α : Type u_2
β : Type u_3
γ : Type ?u.11121
δ : Type ?u.11124
ι : Sort u_1
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Filter β
⊢ (⨅ (x : ι), comap Prod.fst (f x) ⊓ comap Prod.snd g) = ⨅ (i : ι), Filter.prod (f i) g
Theorem: Dfinsupp.mapRange.linearMap_id
File: Mathlib/LinearAlgebra/Dfinsupp.lean

tactic: ext
state_before: ι : Type u_1
R : Type u_3
S : Type ?u.140242
M : ι → Type ?u.140247
N : Type ?u.140250
dec_ι : DecidableEq ι
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : ι) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → Module R (M i)
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
β : ι → Type ?u.140337
β₁ : ι → Type ?u.140342
β₂ : ι → Type u_2
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
inst✝⁴ : (i : ι) → AddCommMonoid (β₁ i)
inst✝³ : (i : ι) → AddCommMonoid (β₂ i)
inst✝² : (i : ι) → Module R (β i)
inst✝¹ : (i : ι) → Module R (β₁ i)
inst✝ : (i : ι) → Module R (β₂ i)
⊢ (linearMap fun i => LinearMap.id) = LinearMap.id

tactic: simp [linearMap]
state_before: case h.h.h
ι : Type u_1
R : Type u_3
S : Type ?u.140242
M : ι → Type ?u.140247
N : Type ?u.140250
dec_ι : DecidableEq ι
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : ι) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → Module R (M i)
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R N
β : ι → Type ?u.140337
β₁ : ι → Type ?u.140342
β₂ : ι → Type u_2
inst✝⁵ : (i : ι) → AddCommMonoid (β i)
inst✝⁴ : (i : ι) → AddCommMonoid (β₁ i)
inst✝³ : (i : ι) → AddCommMonoid (β₂ i)
inst✝² : (i : ι) → Module R (β i)
inst✝¹ : (i : ι) → Module R (β₁ i)
inst✝ : (i : ι) → Module R (β₂ i)
i✝¹ : ι
x✝ : β₂ i✝¹
i✝ : ι
⊢ ↑(↑(LinearMap.comp (linearMap fun i => LinearMap.id) (lsingle i✝¹)) x✝) i✝ =
    ↑(↑(LinearMap.comp LinearMap.id (lsingle i✝¹)) x✝) i✝
Theorem: String.utf8PrevAux_lt_of_pos
File: src/lean/Init/Data/String/Basic.lean

tactic: simp [utf8PrevAux]
state_before: c : Char
cs : List Char
i p : Pos
h : p ≠ 0
⊢ (utf8PrevAux (c :: cs) i p).byteIdx < p.byteIdx

tactic: next => exact h' ▸ Nat.add_lt_add_left (one_le_csize _) _
state_before: case hpos
c : Char
cs : List Char
i p : Pos
h : p ≠ 0
h' : i + c = p
⊢ i.byteIdx < p.byteIdx

case hneg
c : Char
cs : List Char
i p : Pos
h : p ≠ 0
h' : ¬i + c = p
⊢ (utf8PrevAux cs (i + c) p).byteIdx < p.byteIdx

tactic: next => exact utf8PrevAux_lt_of_pos _ _ _ h
state_before: case hneg
c : Char
cs : List Char
i p : Pos
h : p ≠ 0
h' : ¬i + c = p
⊢ (utf8PrevAux cs (i + c) p).byteIdx < p.byteIdx

tactic: exact h' ▸ Nat.add_lt_add_left (one_le_csize _) _
state_before: c : Char
cs : List Char
i p : Pos
h : p ≠ 0
h' : i + c = p
⊢ i.byteIdx < p.byteIdx

tactic: exact utf8PrevAux_lt_of_pos _ _ _ h
state_before: c : Char
cs : List Char
i p : Pos
h : p ≠ 0
h' : ¬i + c = p
⊢ (utf8PrevAux cs (i + c) p).byteIdx < p.byteIdx
Theorem: ContinuousLinearMap.sum_apply
File: Mathlib/Topology/Algebra/Module/Basic.lean

tactic: simp only [coe_sum', Finset.sum_apply]
state_before: R₁ : Type u_2
R₂ : Type u_3
R₃ : Type ?u.493091
inst✝¹⁷ : Semiring R₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁴ : TopologicalSpace M₁
inst✝¹³ : AddCommMonoid M₁
M'₁ : Type ?u.493178
inst✝¹² : TopologicalSpace M'₁
inst✝¹¹ : AddCommMonoid M'₁
M₂ : Type u_5
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommMonoid M₂
M₃ : Type ?u.493196
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommMonoid M₃
M₄ : Type ?u.493205
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommMonoid M₄
inst✝⁴ : Module R₁ M₁
inst✝³ : Module R₁ M'₁
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
inst✝ : ContinuousAdd M₂
ι : Type u_1
t : Finset ι
f : ι → M₁ →SL[σ₁₂] M₂
b : M₁
⊢ ↑(∑ d in t, f d) b = ∑ d in t, ↑(f d) b
Theorem: Nat.factors_sublist_of_dvd
File: Mathlib/Data/Nat/Factors.lean

tactic: obtain ⟨a, rfl⟩ := h
state_before: n k : ℕ
h : n ∣ k
h' : k ≠ 0
⊢ factors n <+ factors k

tactic: exact factors_sublist_right (right_ne_zero_of_mul h')
state_before: case intro
n a : ℕ
h' : n * a ≠ 0
⊢ factors n <+ factors (n * a)
Theorem: Int.card_Ioo
File: Mathlib/Data/Int/Interval.lean

tactic: change (Finset.map _ _).card = _
state_before: a b : ℤ
⊢ card (Ioo a b) = toNat (b - a - 1)

tactic: rw [Finset.card_map, Finset.card_range]
state_before: a b : ℤ
⊢ card (map (Function.Embedding.trans Nat.castEmbedding (addLeftEmbedding (a + 1))) (range (toNat (b - a - 1)))) =
    toNat (b - a - 1)
Theorem: Ideal.ramificationIdx_spec
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: let Q : ℕ → Prop := fun m =>  ∀ k : ℕ, map f p ≤ P ^ k → k ≤ m
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
⊢ ramificationIdx f p P = n

tactic: have : Q n := by
  intro k hk
  refine le_of_not_lt fun hnk => ?_
  exact hgt (hk.trans (Ideal.pow_le_pow hnk))
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
⊢ ramificationIdx f p P = n

tactic: rw [ramificationIdx_eq_find ⟨n, this⟩]
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
this : Q n
⊢ ramificationIdx f p P = n

tactic: refine le_antisymm (Nat.find_min' _ this) (le_of_not_gt fun h : Nat.find _ < n => ?_)
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
this : Q n
⊢ Nat.find (_ : ∃ n, ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ n) = n

tactic: obtain this' := Nat.find_spec ⟨n, this⟩
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
this : Q n
h : Nat.find (_ : ∃ n, ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ n) < n
⊢ False

tactic: exact h.not_le (this' _ hle)
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
this : Q n
h : Nat.find (_ : ∃ n, ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ n) < n
this' : Q (Nat.find (_ : ∃ n, Q n))
⊢ False

tactic: intro k hk
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
⊢ Q n

tactic: refine le_of_not_lt fun hnk => ?_
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
k : ℕ
hk : map f p ≤ P ^ k
⊢ k ≤ n

tactic: exact hgt (hk.trans (Ideal.pow_le_pow hnk))
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
n : ℕ
hle : map f p ≤ P ^ n
hgt : ¬map f p ≤ P ^ (n + 1)
Q : ℕ → Prop := fun m => ∀ (k : ℕ), map f p ≤ P ^ k → k ≤ m
k : ℕ
hk : map f p ≤ P ^ k
hnk : n < k
⊢ False
Theorem: Polynomial.bernoulli_zero
File: Mathlib/NumberTheory/BernoulliPolynomials.lean

tactic: simp [bernoulli]
state_before: ⊢ bernoulli 0 = 1
Theorem: Cardinal.aleph_add_aleph
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [Cardinal.add_eq_max (aleph0_le_aleph o₁), max_aleph_eq]
state_before: o₁ o₂ : Ordinal
⊢ aleph o₁ + aleph o₂ = aleph (max o₁ o₂)
Theorem: ENNReal.le_rpow_one_div_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: nth_rw 1 [← rpow_one x]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ≤ y ^ (1 / z) ↔ x ^ z ≤ y

tactic: nth_rw 1 [← @_root_.mul_inv_cancel _ _ z hz.ne']
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ 1 ≤ y ^ (1 / z) ↔ x ^ z ≤ y

tactic: rw [rpow_mul, ← one_div, @rpow_le_rpow_iff _ _ (1 / z) (by simp [hz])]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ x ^ (z * z⁻¹) ≤ y ^ (1 / z) ↔ x ^ z ≤ y

tactic: simp [hz]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 < z
⊢ 0 < 1 / z
Theorem: NNReal.tendsto_cofinite_zero_of_summable
File: Mathlib/Topology/Instances/NNReal.lean

tactic: simp only [← summable_coe, ← tendsto_coe] at hf ⊢
state_before: α : Type u_1
f : α → ℝ≥0
hf : Summable f
⊢ Tendsto f cofinite (𝓝 0)

tactic: exact hf.tendsto_cofinite_zero
state_before: α : Type u_1
f : α → ℝ≥0
hf : Summable fun a => ↑(f a)
⊢ Tendsto (fun a => ↑(f a)) cofinite (𝓝 ↑0)
Theorem: fderiv_const
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: ext m
state_before: 𝕜 : Type u_3
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1385368
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1385463
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
c : F
⊢ (fderiv 𝕜 fun x => c) = 0

tactic: rw [fderiv_const_apply]
state_before: case h.h
𝕜 : Type u_3
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1385368
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1385463
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
c : F
m x✝ : E
⊢ ↑(fderiv 𝕜 (fun x => c) m) x✝ = ↑(OfNat.ofNat 0 m) x✝

tactic: rfl
state_before: case h.h
𝕜 : Type u_3
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.1385368
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.1385463
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
c : F
m x✝ : E
⊢ ↑0 x✝ = ↑(OfNat.ofNat 0 m) x✝
Theorem: MeasureTheory.Memℒp.neg
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [hf.right]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.3183332
G : Type ?u.3183335
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hf : Memℒp f p
⊢ snorm (-f) p μ < ⊤
Theorem: Pmf.mem_support_seq_iff
File: Mathlib/Probability/ProbabilityMassFunction/Constructions.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.73172
q : Pmf (α → β)
p : Pmf α
b : β
⊢ b ∈ support (seq q p) ↔ ∃ f, f ∈ support q ∧ b ∈ f '' support p
Theorem: StrictConcaveOn.slope_anti_adjacent
File: Mathlib/Analysis/Convex/Slope.lean

tactic: have := neg_lt_neg (StrictConvexOn.slope_strict_mono_adjacent hf.neg hx hz hxy hyz)
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)

tactic: simp only [Pi.neg_apply, ← neg_div, neg_sub', neg_neg] at this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : -(((-f) z - (-f) y) / (z - y)) < -(((-f) y - (-f) x) / (y - x))
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)

tactic: exact this
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
s : Set 𝕜
f : 𝕜 → 𝕜
hf : StrictConcaveOn 𝕜 s f
x y z : 𝕜
hx : x ∈ s
hz : z ∈ s
hxy : x < y
hyz : y < z
this : (f z - f y) / (z - y) < (f y - f x) / (y - x)
⊢ (f z - f y) / (z - y) < (f y - f x) / (y - x)
Theorem: CategoryTheory.Limits.coequalizerComparison_map_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

tactic: simp only [← G.map_comp, w]
state_before: C : Type u
inst✝³ : Category C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category D
G : C ⥤ D
inst✝¹ : HasCoequalizer f g
inst✝ : HasCoequalizer (G.map f) (G.map g)
Z : C
h : Y ⟶ Z
w : f ≫ h = g ≫ h
⊢ G.map f ≫ G.map h = G.map g ≫ G.map h

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝³ : Category C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category D
G : C ⥤ D
inst✝¹ : HasCoequalizer f g
inst✝ : HasCoequalizer (G.map f) (G.map g)
Z : C
h : Y ⟶ Z
w : f ≫ h = g ≫ h
⊢ coequalizerComparison f g G ≫ G.map (coequalizer.desc h w) =
    coequalizer.desc (G.map h) (_ : G.map f ≫ G.map h = G.map g ≫ G.map h)

tactic: simp [← G.map_comp]
state_before: case h
C : Type u
inst✝³ : Category C
X Y : C
f g : X ⟶ Y
D : Type u₂
inst✝² : Category D
G : C ⥤ D
inst✝¹ : HasCoequalizer f g
inst✝ : HasCoequalizer (G.map f) (G.map g)
Z : C
h : Y ⟶ Z
w : f ≫ h = g ≫ h
⊢ coequalizer.π (G.map f) (G.map g) ≫ coequalizerComparison f g G ≫ G.map (coequalizer.desc h w) =
    coequalizer.π (G.map f) (G.map g) ≫ coequalizer.desc (G.map h) (_ : G.map f ≫ G.map h = G.map g ≫ G.map h)
Theorem: MeasureTheory.Measure.iSup_restrict_spanningSets
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [iUnion_spanningSets, restrict_univ]
state_before: α : Type u_1
β : Type ?u.731158
γ : Type ?u.731161
δ : Type ?u.731164
ι : Type ?u.731167
R : Type ?u.731170
R' : Type ?u.731173
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : SigmaFinite μ
hs : MeasurableSet s
⊢ ↑↑(restrict μ (⋃ (i : ℕ), spanningSets μ i)) s = ↑↑μ s
Theorem: Multiset.map_comp_coe
File: Mathlib/Data/Multiset/Functor.lean

tactic: funext
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α β : Type u_1
h : α → β
⊢ Functor.map h ∘ Coe.coe = Coe.coe ∘ Functor.map h

tactic: simp only [Function.comp_apply, Coe.coe, fmap_def, coe_map, List.map_eq_map]
state_before: case h
F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α β : Type u_1
h : α → β
x✝ : List α
⊢ (Functor.map h ∘ Coe.coe) x✝ = (Coe.coe ∘ Functor.map h) x✝
Theorem: Stream'.WSeq.flatten_equiv
File: Mathlib/Data/Seq/WSeq.lean

tactic: apply Computation.memRecOn h
state_before: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
⊢ flatten c ~ʷ s

tactic: simp [Equiv.refl]
state_before: case h1
α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
⊢ flatten (Computation.pure s) ~ʷ s

tactic: intro s'
state_before: case h2
α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
⊢ ∀ (s_1 : Computation (WSeq α)), flatten s_1 ~ʷ s → flatten (Computation.think s_1) ~ʷ s

tactic: apply Equiv.trans
state_before: case h2
α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
s' : Computation (WSeq α)
⊢ flatten s' ~ʷ s → flatten (Computation.think s') ~ʷ s

tactic: simp [think_equiv]
state_before: case h2.a
α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
s' : Computation (WSeq α)
⊢ flatten (Computation.think s') ~ʷ flatten s'
Theorem: CategoryTheory.Arrow.AugmentedCechNerve.ExtraDegeneracy.s_comp_base
File: Mathlib/AlgebraicTopology/ExtraDegeneracy.lean

tactic: apply WidePullback.lift_base
state_before: C : Type u_2
inst✝¹ : Category C
f : Arrow C
inst✝ : ∀ (n : ℕ), HasWidePullback f.right (fun x => f.left) fun x => f.hom
S : SplitEpi f.hom
n : ℕ
⊢ (s f S n ≫ WidePullback.base fun x => f.hom) = WidePullback.base fun x => f.hom
Theorem: RegularExpression.one_rmatch_iff
File: Mathlib/Computability/RegularExpressions.lean

tactic: induction x <;> simp [rmatch, matchEpsilon, *]
state_before: α : Type u_1
β : Type ?u.33505
γ : Type ?u.33508
dec : DecidableEq α
a b : α
x : List α
⊢ rmatch 1 x = true ↔ x = []
Theorem: Real.sqrt_div
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [division_def, sqrt_mul hx, sqrt_inv, division_def]
state_before: x : ℝ
hx : 0 ≤ x
y : ℝ
⊢ sqrt (x / y) = sqrt x / sqrt y
Theorem: quotient_norm_neg
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: simp only [AddSubgroup.quotient_norm_eq]
state_before: M : Type u_1
N : Type ?u.81421
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
⊢ ‖-x‖ = ‖x‖

tactic: congr 1 with r
state_before: M : Type u_1
N : Type ?u.81421
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
⊢ sInf (norm '' {m | ↑m = -x}) = sInf (norm '' {m | ↑m = x})

tactic: constructor <;> { rintro ⟨m, hm, rfl⟩; use -m; simpa [neg_eq_iff_eq_neg] using hm }
state_before: case e_a.h
M : Type u_1
N : Type ?u.81421
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ r ∈ norm '' {m | ↑m = -x} ↔ r ∈ norm '' {m | ↑m = x}
Theorem: Odd.zpow_pos_iff
File: Mathlib/Algebra/Order/Field/Power.lean

tactic: cases' hn with k hk
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hn : Odd n
⊢ 0 < a ^ n ↔ 0 < a

tactic: simpa only [hk, two_mul] using zpow_bit1_pos_iff
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n k : ℤ
hk : n = 2 * k + 1
⊢ 0 < a ^ n ↔ 0 < a
Theorem: MeasureTheory.Measure.singularPart_add
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: refine'
  (eq_singularPart ((measurable_rnDeriv μ₁ ν).add (measurable_rnDeriv μ₂ ν))
      ((haveLebesgueDecomposition_spec _ _).2.1.add_left
        (haveLebesgueDecomposition_spec _ _).2.1)
      _).symm
state_before: α : Type u_1
β : Type ?u.53774
m : MeasurableSpace α
μ ν✝ μ₁ μ₂ ν : Measure α
inst✝¹ : HaveLebesgueDecomposition μ₁ ν
inst✝ : HaveLebesgueDecomposition μ₂ ν
⊢ singularPart (μ₁ + μ₂) ν = singularPart μ₁ ν + singularPart μ₂ ν

tactic: erw [withDensity_add_left (measurable_rnDeriv μ₁ ν)]
state_before: α : Type u_1
β : Type ?u.53774
m : MeasurableSpace α
μ ν✝ μ₁ μ₂ ν : Measure α
inst✝¹ : HaveLebesgueDecomposition μ₁ ν
inst✝ : HaveLebesgueDecomposition μ₂ ν
⊢ μ₁ + μ₂ = singularPart μ₁ ν + singularPart μ₂ ν + withDensity ν fun a => rnDeriv μ₁ ν a + rnDeriv μ₂ ν a

tactic: conv_rhs => rw [add_assoc, add_comm (μ₂.singularPart ν), ← add_assoc, ← add_assoc]
state_before: α : Type u_1
β : Type ?u.53774
m : MeasurableSpace α
μ ν✝ μ₁ μ₂ ν : Measure α
inst✝¹ : HaveLebesgueDecomposition μ₁ ν
inst✝ : HaveLebesgueDecomposition μ₂ ν
⊢ μ₁ + μ₂ =
    singularPart μ₁ ν + singularPart μ₂ ν + (withDensity ν (rnDeriv μ₁ ν) + withDensity ν fun a => rnDeriv μ₂ ν a)

tactic: rw [← haveLebesgueDecomposition_add μ₁ ν, add_assoc, add_comm (ν.withDensity (μ₂.rnDeriv ν)),
  ← haveLebesgueDecomposition_add μ₂ ν]
state_before: α : Type u_1
β : Type ?u.53774
m : MeasurableSpace α
μ ν✝ μ₁ μ₂ ν : Measure α
inst✝¹ : HaveLebesgueDecomposition μ₁ ν
inst✝ : HaveLebesgueDecomposition μ₂ ν
⊢ μ₁ + μ₂ =
    (singularPart μ₁ ν + withDensity ν (rnDeriv μ₁ ν) + withDensity ν fun a => rnDeriv μ₂ ν a) + singularPart μ₂ ν
Theorem: LocalHomeomorph.extend_source_mem_nhds
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [f.extend_source I]
state_before: 𝕜 : Type u_4
E : Type u_3
M : Type u_1
H : Type u_2
E' : Type ?u.134059
M' : Type ?u.134062
H' : Type ?u.134065
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x✝ : M
s t : Set M
x : M
h : x ∈ f.source
⊢ x ∈ (extend f I).source
Theorem: integral_one_div_of_neg
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [one_div, integral_inv_of_neg ha hb]
state_before: a b : ℝ
n : ℕ
ha : a < 0
hb : b < 0
⊢ (∫ (x : ℝ) in a..b, 1 / x) = Real.log (b / a)
Theorem: OnePoint.continuousAt_coe
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [ContinuousAt, nhds_coe_eq, tendsto_map'_iff, ContinuousAt]
state_before: X : Type u_2
inst✝¹ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
Y : Type u_1
inst✝ : TopologicalSpace Y
f : OnePoint X → Y
x : X
⊢ ContinuousAt f ↑x ↔ ContinuousAt (f ∘ some) x

tactic: rfl
state_before: X : Type u_2
inst✝¹ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
Y : Type u_1
inst✝ : TopologicalSpace Y
f : OnePoint X → Y
x : X
⊢ Tendsto (f ∘ some) (𝓝 x) (𝓝 (f ↑x)) ↔ Tendsto (f ∘ some) (𝓝 x) (𝓝 ((f ∘ some) x))
Theorem: Matrix.fromBlocks_conjTranspose
File: Mathlib/Data/Matrix/Block.lean

tactic: simp only [conjTranspose, fromBlocks_transpose, fromBlocks_map]
state_before: l : Type u_3
m : Type u_4
n : Type u_2
o : Type u_5
p : Type ?u.17851
q : Type ?u.17854
m' : o → Type ?u.17859
n' : o → Type ?u.17864
p' : o → Type ?u.17869
R : Type ?u.17872
S : Type ?u.17875
α : Type u_1
β : Type ?u.17881
inst✝ : Star α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
⊢ (fromBlocks A B C D)ᴴ = fromBlocks Aᴴ Cᴴ Bᴴ Dᴴ
Theorem: OrderIso.symm_injective
File: Mathlib/Order/Hom/Basic.lean

tactic: rw [← e.symm_symm, h, e'.symm_symm]
state_before: F : Type ?u.81630
α : Type u_1
β : Type u_2
γ : Type ?u.81639
δ : Type ?u.81642
inst✝² : LE α
inst✝¹ : LE β
inst✝ : LE γ
e e' : α ≃o β
h : symm e = symm e'
⊢ e = e'
Theorem: MeasureTheory.snorm_sub_le
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simpa [LpAddConst_of_one_le hp] using snorm_sub_le' hf hg p
state_before: α : Type u_1
E : Type u_2
F : Type ?u.3047771
G : Type ?u.3047774
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : α → E
hf : AEStronglyMeasurable f μ
hg : AEStronglyMeasurable g μ
hp : 1 ≤ p
⊢ snorm (f - g) p μ ≤ snorm f p μ + snorm g p μ