tasksource/leandojo huggingface dataset:
Theorem: lintegral_comp_eq_lintegral_meas_lt_mul
File: Mathlib/MeasureTheory/Integral/Layercake.lean

tactic: rw [lintegral_comp_eq_lintegral_meas_le_mul μ f_nn f_mble g_intble g_nn]
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.997875
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t
g_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t
⊢ (∫⁻ (ω : α), ENNReal.ofReal (∫ (t : ℝ) in 0 ..f ω, g t) ∂μ) =
    ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t < f a} * ENNReal.ofReal (g t)

tactic: apply lintegral_congr_ae
state_before: α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.997875
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t
g_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t
⊢ (∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t)) =
    ∫⁻ (t : ℝ) in Ioi 0, ↑↑μ {a | t < f a} * ENNReal.ofReal (g t)

tactic: filter_upwards [Measure.meas_le_ae_eq_meas_lt μ (volume.restrict (Ioi 0)) f_mble] with t ht
state_before: case h
α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.997875
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t
g_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t
⊢ (fun a => ↑↑μ {a_1 | a ≤ f a_1} * ENNReal.ofReal (g a)) =ᵐ[Measure.restrict volume (Ioi 0)] fun a =>
    ↑↑μ {a_1 | a < f a_1} * ENNReal.ofReal (g a)

tactic: rw [ht]
state_before: case h
α : Type u_1
inst✝³ : MeasurableSpace α
μ✝ : MeasureTheory.Measure α
β : Type ?u.997875
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSingletonClass β
f : α → ℝ
g : ℝ → ℝ
s : Set α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f_nn : 0 ≤ f
f_mble : Measurable f
g_intble : ∀ (t : ℝ), t > 0 → IntervalIntegrable g volume 0 t
g_nn : ∀ᵐ (t : ℝ) ∂Measure.restrict volume (Ioi 0), 0 ≤ g t
t : ℝ
ht : ↑↑μ {a | t ≤ f a} = ↑↑μ {a | t < f a}
⊢ ↑↑μ {a | t ≤ f a} * ENNReal.ofReal (g t) = ↑↑μ {a | t < f a} * ENNReal.ofReal (g t)
Theorem: Submodule.fg_iff_addSubmonoid_fg
File: Mathlib/RingTheory/Finiteness.lean

tactic: simpa [← span_nat_eq_addSubmonoid_closure] using hS
state_before: R : Type ?u.1240
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
P : Submodule ℕ M
x✝ : FG P
S : Finset M
hS : span ℕ ↑S = P
⊢ AddSubmonoid.closure ↑S = P.toAddSubmonoid

tactic: simpa [← span_nat_eq_addSubmonoid_closure] using hS
state_before: R : Type ?u.1240
M : Type u_1
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
P : Submodule ℕ M
x✝ : AddSubmonoid.FG P.toAddSubmonoid
S : Finset M
hS : AddSubmonoid.closure ↑S = P.toAddSubmonoid
⊢ span ℕ ↑S = P
Theorem: MeasurableSpace.measurableSet_bot_iff
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: simp (config := { contextual := true }) [or_imp]
state_before: α : Type u_1
β : Type ?u.23072
γ : Type ?u.23075
δ : Type ?u.23078
δ' : Type ?u.23081
ι : Sort ?u.23084
s✝ t u s : Set α
⊢ ∀ (s : Set α), (fun s => s = ∅ ∨ s = univ) s → (fun s => s = ∅ ∨ s = univ) (sᶜ)
Theorem: Matrix.inv_inv_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: by_cases h : IsUnit A.det
state_before: l : Type ?u.348186
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
⊢ A⁻¹⁻¹⁻¹ = A⁻¹

tactic: rw [nonsing_inv_nonsing_inv _ h]
state_before: case pos
l : Type ?u.348186
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
h : IsUnit (det A)
⊢ A⁻¹⁻¹⁻¹ = A⁻¹

tactic: simp [nonsing_inv_apply_not_isUnit _ h]
state_before: case neg
l : Type ?u.348186
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
h : ¬IsUnit (det A)
⊢ A⁻¹⁻¹⁻¹ = A⁻¹
Theorem: List.foldrIdx_eq_foldr_enum
File: Mathlib/Data/List/Indexes.lean

tactic: simp only [foldrIdx, foldrIdxSpec, foldrIdx_eq_foldrIdxSpec, enum]
state_before: α : Type u
β : Type v
f : ℕ → α → β → β
b : β
as : List α
⊢ foldrIdx f b as = foldr (uncurry f) b (enum as)
Theorem: MeasureTheory.snorm'_measure_zero_of_pos
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm', hq_pos]
state_before: α : Type u_1
E : Type ?u.946710
F : Type u_2
G : Type ?u.946716
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
hq_pos : 0 < q
⊢ snorm' f q 0 = 0
Theorem: IsPreconnected.infinite_of_nontrivial
File: Mathlib/Topology/Separation.lean

tactic: refine' mt (fun hf => (subsingleton_coe s).mp _) (not_subsingleton_iff.mpr hs)
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
h : IsPreconnected s
hs : Set.Nontrivial s
⊢ Set.Infinite s

tactic: haveI := @discrete_of_t1_of_finite s _ _ hf.to_subtype
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
h : IsPreconnected s
hs : Set.Nontrivial s
hf : Set.Finite s
⊢ Subsingleton ↑s

tactic: exact @PreconnectedSpace.trivial_of_discrete _ _ (Subtype.preconnectedSpace h) _
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : T1Space α
s : Set α
h : IsPreconnected s
hs : Set.Nontrivial s
hf : Set.Finite s
this : DiscreteTopology ↑s
⊢ Subsingleton ↑s
Theorem: WithTop.sub_eq_top_iff
File: Mathlib/Algebra/Order/Sub/WithTop.lean

tactic: induction a using recTopCoe <;> induction b using recTopCoe <;>
  simp only [← coe_sub, coe_ne_top, sub_top, zero_ne_top, coe_ne_top, top_sub_coe, false_and,
    Ne.def]
state_before: α : Type u_1
β : Type ?u.2076
inst✝¹ : Sub α
inst✝ : Zero α
a b : WithTop α
⊢ a - b = ⊤ ↔ a = ⊤ ∧ b ≠ ⊤
Theorem: JordanHolderModule.second_iso
File: Mathlib/RingTheory/SimpleModule.lean

tactic: constructor
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.102423
inst✝¹ : AddCommGroup N
inst✝ : Module R N
X Y : Submodule R M
x✝ : X ⋖ X ⊔ Y
⊢ Iso (X, X ⊔ Y) (X ⊓ Y, Y)

tactic: rw [sup_comm, inf_comm]
state_before: case val
R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.102423
inst✝¹ : AddCommGroup N
inst✝ : Module R N
X Y : Submodule R M
x✝ : X ⋖ X ⊔ Y
⊢ ({ x // x ∈ (X, X ⊔ Y).snd } ⧸ Submodule.comap (Submodule.subtype (X, X ⊔ Y).snd) (X, X ⊔ Y).fst) ≃ₗ[R]
    { x // x ∈ (X ⊓ Y, Y).snd } ⧸ Submodule.comap (Submodule.subtype (X ⊓ Y, Y).snd) (X ⊓ Y, Y).fst

tactic: dsimp
state_before: case val
R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.102423
inst✝¹ : AddCommGroup N
inst✝ : Module R N
X Y : Submodule R M
x✝ : X ⋖ X ⊔ Y
⊢ ({ x // x ∈ (X, Y ⊔ X).snd } ⧸ Submodule.comap (Submodule.subtype (X, Y ⊔ X).snd) (X, Y ⊔ X).fst) ≃ₗ[R]
    { x // x ∈ (Y ⊓ X, Y).snd } ⧸ Submodule.comap (Submodule.subtype (Y ⊓ X, Y).snd) (Y ⊓ X, Y).fst

tactic: exact (LinearMap.quotientInfEquivSupQuotient Y X).symm
state_before: case val
R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
m : Submodule R M
N : Type ?u.102423
inst✝¹ : AddCommGroup N
inst✝ : Module R N
X Y : Submodule R M
x✝ : X ⋖ X ⊔ Y
⊢ ({ x // x ∈ Y ⊔ X } ⧸ Submodule.comap (Submodule.subtype (Y ⊔ X)) X) ≃ₗ[R]
    { x // x ∈ Y } ⧸ Submodule.comap (Submodule.subtype Y) Y ⊓ Submodule.comap (Submodule.subtype Y) X
Theorem: MeasureTheory.lintegral_singleton'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [restrict_singleton, lintegral_smul_measure, lintegral_dirac' _ hf, mul_comm]
state_before: α : Type u_1
β : Type ?u.1728971
γ : Type ?u.1728974
δ : Type ?u.1728977
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
a : α
⊢ (∫⁻ (x : α) in {a}, f x ∂μ) = f a * ↑↑μ {a}
Theorem: Set.image_prod_mk_subset_prod_left
File: Mathlib/Data/Set/Prod.lean

tactic: rintro _ ⟨a, ha, rfl⟩
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.83787
δ : Type ?u.83790
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
hb : b ∈ t
⊢ (fun a => (a, b)) '' s ⊆ s ×ˢ t

tactic: exact ⟨ha, hb⟩
state_before: case intro.intro
α : Type u_2
β : Type u_1
γ : Type ?u.83787
δ : Type ?u.83790
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a✝ : α
b : β
hb : b ∈ t
a : α
ha : a ∈ s
⊢ (fun a => (a, b)) a ∈ s ×ˢ t
Theorem: MeasurableEmbedding.measurable_extend
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: refine' measurable_of_restrict_of_restrict_compl hf.measurableSet_range _ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.381496
δ' : Type ?u.381499
ι : Sort uι
s t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g✝ : β → γ
hf : MeasurableEmbedding f
g : α → γ
g' : β → γ
hg : Measurable g
hg' : Measurable g'
⊢ Measurable (extend f g g')

tactic: rw [restrict_extend_range]
state_before: case refine'_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.381496
δ' : Type ?u.381499
ι : Sort uι
s t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g✝ : β → γ
hf : MeasurableEmbedding f
g : α → γ
g' : β → γ
hg : Measurable g
hg' : Measurable g'
⊢ Measurable (restrict (range f) (extend f g g'))

tactic: simpa only [rangeSplitting] using hg.comp hf.measurable_rangeSplitting
state_before: case refine'_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.381496
δ' : Type ?u.381499
ι : Sort uι
s t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g✝ : β → γ
hf : MeasurableEmbedding f
g : α → γ
g' : β → γ
hg : Measurable g
hg' : Measurable g'
⊢ Measurable fun x => g (Exists.choose (_ : ↑x ∈ range f))

tactic: rw [restrict_extend_compl_range]
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.381496
δ' : Type ?u.381499
ι : Sort uι
s t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g✝ : β → γ
hf : MeasurableEmbedding f
g : α → γ
g' : β → γ
hg : Measurable g
hg' : Measurable g'
⊢ Measurable (restrict (range fᶜ) (extend f g g'))

tactic: exact hg'.comp measurable_subtype_coe
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.381496
δ' : Type ?u.381499
ι : Sort uι
s t u : Set α
mα : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
f : α → β
g✝ : β → γ
hf : MeasurableEmbedding f
g : α → γ
g' : β → γ
hg : Measurable g
hg' : Measurable g'
⊢ Measurable (g' ∘ Subtype.val)
Theorem: ConvexOn.translate_right
File: Mathlib/Analysis/Convex/Function.lean

tactic: rw [smul_add, smul_add, add_add_add_comm, Convex.combo_self hab]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.117268
α : Type ?u.117271
β : Type u_3
ι : Type ?u.117277
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : OrderedAddCommMonoid α
inst✝² : OrderedAddCommMonoid β
inst✝¹ : Module 𝕜 E
inst✝ : SMul 𝕜 β
s : Set E
f : E → β
hf : ConvexOn 𝕜 s f
c x : E
hx : x ∈ (fun z => c + z) ⁻¹' s
y : E
hy : y ∈ (fun z => c + z) ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ f (c + (a • x + b • y)) = f (a • (c + x) + b • (c + y))
Theorem: Complex.norm_cderiv_lt
File: Mathlib/Analysis/Complex/LocallyUniformLimit.lean

tactic: obtain ⟨L, hL1, hL2⟩ : ∃ L < M, ∀ w ∈ sphere z r, ‖f w‖ ≤ L := by
  have e1 : (sphere z r).Nonempty := NormedSpace.sphere_nonempty.mpr hr.le
  have e2 : ContinuousOn (fun w => ‖f w‖) (sphere z r) := continuous_norm.comp_continuousOn hf
  obtain ⟨x, hx, hx'⟩ := (isCompact_sphere z r).exists_forall_ge e1 e2
  exact ⟨‖f x‖, hfM x hx, hx'⟩
state_before: E : Type u_1
ι : Type ?u.28951
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hfM : ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ < M
hf : ContinuousOn f (sphere z r)
⊢ ‖cderiv r f z‖ < M / r

tactic: exact (norm_cderiv_le hr hL2).trans_lt ((div_lt_div_right hr).mpr hL1)
state_before: case intro.intro
E : Type u_1
ι : Type ?u.28951
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hfM : ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ < M
hf : ContinuousOn f (sphere z r)
L : ℝ
hL1 : L < M
hL2 : ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ ≤ L
⊢ ‖cderiv r f z‖ < M / r

tactic: have e1 : (sphere z r).Nonempty := NormedSpace.sphere_nonempty.mpr hr.le
state_before: E : Type u_1
ι : Type ?u.28951
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hfM : ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ < M
hf : ContinuousOn f (sphere z r)
⊢ ∃ L, L < M ∧ ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ ≤ L

tactic: have e2 : ContinuousOn (fun w => ‖f w‖) (sphere z r) := continuous_norm.comp_continuousOn hf
state_before: E : Type u_1
ι : Type ?u.28951
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hfM : ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ < M
hf : ContinuousOn f (sphere z r)
e1 : Set.Nonempty (sphere z r)
⊢ ∃ L, L < M ∧ ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ ≤ L

tactic: obtain ⟨x, hx, hx'⟩ := (isCompact_sphere z r).exists_forall_ge e1 e2
state_before: E : Type u_1
ι : Type ?u.28951
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hfM : ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ < M
hf : ContinuousOn f (sphere z r)
e1 : Set.Nonempty (sphere z r)
e2 : ContinuousOn (fun w => ‖f w‖) (sphere z r)
⊢ ∃ L, L < M ∧ ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ ≤ L

tactic: exact ⟨‖f x‖, hfM x hx, hx'⟩
state_before: case intro.intro
E : Type u_1
ι : Type ?u.28951
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
U K : Set ℂ
z : ℂ
M r δ : ℝ
φ : Filter ι
F : ι → ℂ → E
f g : ℂ → E
hr : 0 < r
hfM : ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ < M
hf : ContinuousOn f (sphere z r)
e1 : Set.Nonempty (sphere z r)
e2 : ContinuousOn (fun w => ‖f w‖) (sphere z r)
x : ℂ
hx : x ∈ sphere z r
hx' : ∀ (y : ℂ), y ∈ sphere z r → ‖f y‖ ≤ ‖f x‖
⊢ ∃ L, L < M ∧ ∀ (w : ℂ), w ∈ sphere z r → ‖f w‖ ≤ L
Theorem: LocalHomeomorph.prod_eq_prod_of_nonempty
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: obtain ⟨⟨x, y⟩, -⟩ := id h
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₂'

tactic: haveI : Nonempty α := ⟨x⟩
state_before: case intro.mk
α : 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
x : α
y : γ
⊢ prod e₁ e₂ = prod e₁' e₂' ↔ e₁ = e₁' ∧ e₂ = e₂'

tactic: haveI : Nonempty β := ⟨e₁ x⟩
state_before: case intro.mk
α : 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
x : α
y : γ
this : Nonempty α
⊢ prod e₁ e₂ = prod e₁' e₂' ↔ e₁ = e₁' ∧ e₂ = e₂'

tactic: haveI : Nonempty γ := ⟨y⟩
state_before: case intro.mk
α : 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
x : α
y : γ
this✝ : Nonempty α
this : Nonempty β
⊢ prod e₁ e₂ = prod e₁' e₂' ↔ e₁ = e₁' ∧ e₂ = e₂'

tactic: haveI : Nonempty δ := ⟨e₂ y⟩
state_before: case intro.mk
α : 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
x : α
y : γ
this✝¹ : Nonempty α
this✝ : Nonempty β
this : Nonempty γ
⊢ prod e₁ e₂ = prod e₁' e₂' ↔ e₁ = e₁' ∧ e₂ = e₂'

tactic: simp_rw [LocalHomeomorph.ext_iff, prod_apply, prod_symm_apply, prod_source, Prod.ext_iff,
  Set.prod_eq_prod_iff_of_nonempty h, forall_and, Prod.forall, forall_const,
  and_assoc, and_left_comm]
state_before: case intro.mk
α : 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
x : α
y : γ
this✝² : Nonempty α
this✝¹ : Nonempty β
this✝ : Nonempty γ
this : Nonempty δ
⊢ prod e₁ e₂ = prod e₁' e₂' ↔ e₁ = e₁' ∧ e₂ = e₂'
Theorem: Nat.dvd_zero
File: Std/Data/Nat/Lemmas.lean

tactic: simp
state_before: a : Nat
⊢ 0 = a * 0
Theorem: CategoryTheory.GrothendieckTopology.covering_iff_covers_id
File: Mathlib/CategoryTheory/Sites/Grothendieck.lean

tactic: simp [covers_iff]
state_before: C : Type u
inst✝ : Category C
X Y : C
S✝ R : Sieve X
J : GrothendieckTopology C
S : Sieve X
⊢ S ∈ sieves J X ↔ Covers J S (𝟙 X)
Theorem: Sum.elim_div_div
File: Mathlib/Data/Pi/Algebra.lean

tactic: ext x
state_before: I : Type u
α : Type u_2
β : Type u_3
γ : Type u_1
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f i
i : I
a a' : α → γ
b b' : β → γ
inst✝ : Div γ
⊢ Sum.elim (a / a') (b / b') = Sum.elim a b / Sum.elim a' b'

tactic: cases x <;> rfl
state_before: case h
I : Type u
α : Type u_2
β : Type u_3
γ : Type u_1
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i : I
a a' : α → γ
b b' : β → γ
inst✝ : Div γ
x : α ⊕ β
⊢ Sum.elim (a / a') (b / b') x = (Sum.elim a b / Sum.elim a' b') x
Theorem: dist_homothety_center
File: Mathlib/Analysis/NormedSpace/AddTorsor.lean

tactic: rw [dist_comm, dist_center_homothety]
state_before: α : Type ?u.14890
V : Type u_2
P : Type u_1
W : Type ?u.14899
Q : Type ?u.14902
inst✝⁸ : SeminormedAddCommGroup V
inst✝⁷ : PseudoMetricSpace P
inst✝⁶ : NormedAddTorsor V P
inst✝⁵ : NormedAddCommGroup W
inst✝⁴ : MetricSpace Q
inst✝³ : NormedAddTorsor W Q
𝕜 : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 V
inst✝ : NormedSpace 𝕜 W
p₁ p₂ : P
c : 𝕜
⊢ dist (↑(homothety p₁ c) p₂) p₁ = ‖c‖ * dist p₁ p₂
Theorem: PadicInt.ker_toZModPow
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: ext x
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
n : ℕ
⊢ RingHom.ker (toZModPow n) = Ideal.span {↑p ^ n}

tactic: rw [RingHom.mem_ker]
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ x ∈ RingHom.ker (toZModPow n) ↔ x ∈ Ideal.span {↑p ^ n}

tactic: constructor
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ ↑(toZModPow n) x = 0 ↔ x ∈ Ideal.span {↑p ^ n}

tactic: intro h
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ ↑(toZModPow n) x = 0 → x ∈ Ideal.span {↑p ^ n}

tactic: suffices x.appr n = 0 by
  convert appr_spec n x
  simp only [this, sub_zero, cast_zero]
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : ↑(toZModPow n) x = 0
⊢ x ∈ Ideal.span {↑p ^ n}

tactic: dsimp [toZModPow, toZModHom] at h
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : ↑(toZModPow n) x = 0
⊢ appr x n = 0

tactic: rw [ZMod.nat_cast_zmod_eq_zero_iff_dvd] at h
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : ↑(appr x n) = 0
⊢ appr x n = 0

tactic: apply eq_zero_of_dvd_of_lt h (appr_lt _ _)
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : p ^ n ∣ appr x n
⊢ appr x n = 0

tactic: convert appr_spec n x
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : ↑(toZModPow n) x = 0
this : appr x n = 0
⊢ x ∈ Ideal.span {↑p ^ n}

tactic: simp only [this, sub_zero, cast_zero]
state_before: case h.e'_4
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : ↑(toZModPow n) x = 0
this : appr x n = 0
⊢ x = x - ↑(appr x n)

tactic: intro h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
⊢ x ∈ Ideal.span {↑p ^ n} → ↑(toZModPow n) x = 0

tactic: rw [← sub_zero x] at h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : x ∈ Ideal.span {↑p ^ n}
⊢ ↑(toZModPow n) x = 0

tactic: dsimp [toZModPow, toZModHom]
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : x - 0 ∈ Ideal.span {↑p ^ n}
⊢ ↑(toZModPow n) x = 0

tactic: rw [zmod_congr_of_sub_mem_span n x _ 0 _ h, cast_zero]
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : x - 0 ∈ Ideal.span {↑p ^ n}
⊢ ↑(appr x n) = 0

tactic: apply appr_spec
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ : ℤ_[p]
n : ℕ
x : ℤ_[p]
h : x - 0 ∈ Ideal.span {↑p ^ n}
⊢ x - ↑(appr x n) ∈ Ideal.span {↑p ^ n}
Theorem: Basis.equivFun_symm_apply
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [Basis.equivFun, Finsupp.total_apply, Finsupp.sum_fintype, Finsupp.equivFunOnFinite]
state_before: ι : Type u_2
ι' : Type ?u.642672
R : Type u_3
R₂ : Type ?u.642678
K : Type ?u.642681
M : Type u_1
M' : Type ?u.642687
M'' : Type ?u.642690
V : Type u
V' : Type ?u.642695
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : AddCommMonoid M'
inst✝¹ : Module R M'
inst✝ : Fintype ι
b : Basis ι R M
x : ι → R
⊢ ↑(LinearEquiv.symm (equivFun b)) x = ∑ i : ι, x i • ↑b i
Theorem: Polynomial.degree_list_prod_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: induction' l with hd tl IH
state_before: R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
l : List S[X]
⊢ degree (List.prod l) ≤ List.sum (List.map degree l)

tactic: simp
state_before: case nil
R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
⊢ degree (List.prod []) ≤ List.sum (List.map degree [])

tactic: simpa using (degree_mul_le _ _).trans (add_le_add_left IH _)
state_before: case cons
R : Type u
ι : Type w
s : Finset ι
S : Type u_1
inst✝ : Semiring S
hd : S[X]
tl : List S[X]
IH : degree (List.prod tl) ≤ List.sum (List.map degree tl)
⊢ degree (List.prod (hd :: tl)) ≤ List.sum (List.map degree (hd :: tl))
Theorem: mul_le_of_one_le_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [mul_one] using mul_le_mul_of_nonpos_left h ha
state_before: α : Type u
β : Type ?u.42351
inst✝ : OrderedRing α
a b c d : α
ha : a ≤ 0
h : 1 ≤ b
⊢ a * b ≤ a
Theorem: Polynomial.nthRootsFinset_zero
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simp [nthRootsFinset]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
⊢ nthRootsFinset 0 R = ∅
Theorem: FreeGroup.equivalence_join_red
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Red.Step a b
⊢ ReflGen Red.Step b b

tactic: rfl
state_before: α : Type u
L L₁ L₂ L₃ L₄ a b✝ c b : List (α × Bool)
hab hac : Red.Step a b
⊢ ReflTransGen Red.Step b b