ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.SimpleFunc.tendsto_approxOn_L1_nnnorm
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace E
inst✝² : NormedAddCommGroup E
inst✝¹ : OpensMeasurableSpace E
f : β → E
hf : Measurable f
s : Set E
y₀ : E
h₀ : y₀ ∈ s
inst✝ : SeparableSpace ↑s
μ : Measure β
hμ : ∀ᵐ (x : β) ∂μ, f x ∈ closure s
hi : HasFiniteIntegral (fun x => f x - y₀) μ
⊢ Tendsto (fun n => ∫⁻ (x : β), ↑‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ∂μ) atTop (𝓝 0)
state_after: no goals
tactic: simpa [eLpNorm_one_eq_lintegral_nnnorm] using
    tendsto_approxOn_Lp_eLpNorm hf h₀ one_ne_top hμ
      (by simpa [eLpNorm_one_eq_lintegral_nnnorm] using hi)
Theorem: GaloisInsertion.l_biSup_u
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι✝ : Sort x
κ : ι✝ → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
ι : Sort x
p : ι → Prop
f : (i : ι) → p i → β
⊢ l (⨆ i, ⨆ (hi : p i), u (f i hi)) = ⨆ i, ⨆ (hi : p i), f i hi
state_after: no goals
tactic: simp only [iSup_subtype', gi.l_iSup_u]
Theorem: AnalyticAt.order_eq_nat_iff
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n✝ : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
n : ℕ
⊢ hf.order = ↑n ↔ ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ n • g z
state_after: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n✝ : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
n : ℕ
⊢ (if h : ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0 then ⊤ else ↑⋯.choose) = ↑n ↔
    ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ n • g z
tactic: unfold order
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n✝ : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
n : ℕ
⊢ (if h : ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0 then ⊤ else ↑⋯.choose) = ↑n ↔
    ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ n • g z
state_after: case pos
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n✝ : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
n : ℕ
h : ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
⊢ ⊤ = ↑n ↔ ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ n • g z

case neg
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n✝ : ℕ
z z₀ : 𝕜
hf : AnalyticAt 𝕜 f z₀
n : ℕ
h : ¬∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = 0
⊢ ↑⋯.choose = ↑n ↔ ∃ g, AnalyticAt 𝕜 g z₀ ∧ g z₀ ≠ 0 ∧ ∀ᶠ (z : 𝕜) in 𝓝 z₀, f z = (z - z₀) ^ n • g z
tactic: split_ifs with h
Theorem: MeasureTheory.Measure.haarMeasure_self
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
⊢ (haarMeasure K₀) ↑K₀ = 1
state_after: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarMeasure K₀) ↑K₀ = 1
tactic: haveI : LocallyCompactSpace G := K₀.locallyCompactSpace_of_group
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarMeasure K₀) ↑K₀ = 1
state_after: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ ((haarContent K₀).measure ↑K₀)⁻¹ * (haarContent K₀).measure ↑K₀ = 1
tactic: simp only [haarMeasure, coe_smul, Pi.smul_apply, smul_eq_mul]
state_before: G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ ((haarContent K₀).measure ↑K₀)⁻¹ * (haarContent K₀).measure ↑K₀ = 1
state_after: case h0
G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarContent K₀).outerMeasure (closure ↑K₀) ≠ 0

case ht
G : Type u_1
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
inst✝² : TopologicalGroup G
inst✝¹ : MeasurableSpace G
inst✝ : BorelSpace G
K₀ : PositiveCompacts G
this : LocallyCompactSpace G
⊢ (haarContent K₀).outerMeasure (closure ↑K₀) ≠ ⊤
tactic: rw [← K₀.isCompact.measure_closure,
    Content.measure_apply _ isClosed_closure.measurableSet, ENNReal.inv_mul_cancel]
Theorem: strictMono_iff_map_pos
File: Mathlib/Algebra/Order/Hom/Monoid.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝² : OrderedAddCommGroup α
inst✝¹ : OrderedAddCommMonoid β
i : FunLike F α β
f : F
iamhc✝ : AddMonoidHomClass F α β
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
iamhc : AddMonoidHomClass F α β
⊢ StrictMono ⇑f ↔ ∀ (a : α), 0 < a → 0 < f a
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝² : OrderedAddCommGroup α
inst✝¹ : OrderedAddCommMonoid β
i : FunLike F α β
f : F
iamhc✝ : AddMonoidHomClass F α β
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
iamhc : AddMonoidHomClass F α β
h : StrictMono ⇑f
a : α
⊢ 0 < a → 0 < f a

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝² : OrderedAddCommGroup α
inst✝¹ : OrderedAddCommMonoid β
i : FunLike F α β
f : F
iamhc✝ : AddMonoidHomClass F α β
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x < x_1
iamhc : AddMonoidHomClass F α β
h : ∀ (a : α), 0 < a → 0 < f a
a b : α
hl : a < b
⊢ f a < f b
tactic: refine ⟨fun h a => ?_, fun h a b hl => ?_⟩
Theorem: MeasureTheory.Lp.coeFn_nonneg
File: Mathlib/MeasureTheory/Function/LpOrder.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p μ)
⊢ 0 ≤ᶠ[ae μ] ↑↑f ↔ 0 ≤ f
state_after: α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p μ)
⊢ 0 ≤ᶠ[ae μ] ↑↑f ↔ ↑↑0 ≤ᶠ[ae μ] ↑↑f
tactic: rw [← coeFn_le]
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p μ)
⊢ 0 ≤ᶠ[ae μ] ↑↑f ↔ ↑↑0 ≤ᶠ[ae μ] ↑↑f
state_after: α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p μ)
h0 : ↑↑0 =ᶠ[ae μ] 0
⊢ 0 ≤ᶠ[ae μ] ↑↑f ↔ ↑↑0 ≤ᶠ[ae μ] ↑↑f
tactic: have h0 := Lp.coeFn_zero E p μ
state_before: α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p μ)
h0 : ↑↑0 =ᶠ[ae μ] 0
⊢ 0 ≤ᶠ[ae μ] ↑↑f ↔ ↑↑0 ≤ᶠ[ae μ] ↑↑f
state_after: case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p μ)
h0 : ↑↑0 =ᶠ[ae μ] 0
h : 0 ≤ᶠ[ae μ] ↑↑f
a✝¹ : α
a✝ : 0 a✝¹ ≤ ↑↑f a✝¹
h2 : ↑↑0 a✝¹ = 0 a✝¹
⊢ ↑↑0 a✝¹ ≤ ↑↑f a✝¹

case h
α : Type u_1
E : Type u_2
m : MeasurableSpace α
μ : Measure α
p : ℝ≥0∞
inst✝ : NormedLatticeAddCommGroup E
f : ↥(Lp E p μ)
h0 : ↑↑0 =ᶠ[ae μ] 0
h : ↑↑0 ≤ᶠ[ae μ] ↑↑f
a✝¹ : α
a✝ : ↑↑0 a✝¹ ≤ ↑↑f a✝¹
h2 : ↑↑0 a✝¹ = 0 a✝¹
⊢ 0 a✝¹ ≤ ↑↑f a✝¹
tactic: constructor <;> intro h <;> filter_upwards [h, h0] with _ _ h2
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ X.δ j.succ ≫ X.δ i = X.δ i.castSucc ≫ X.δ j
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ X.map (SimplexCategory.δ j.succ).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ j).op
tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ X.map (SimplexCategory.δ j.succ).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ j).op
state_after: no goals
tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ H]
Theorem: SimpleGraph.Walk.start_mem_support
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ u ∈ p.support
state_after: no goals
tactic: cases p <;> simp
Theorem: Polynomial.nodup_roots_iff_of_splits
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
⊢ f.roots.Nodup ↔ f.Separable
state_after: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬f.Separable
⊢ ¬f.roots.Nodup
tactic: refine ⟨(fun hnsep ↦ ?_).mtr, nodup_roots⟩
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬f.Separable
⊢ ¬f.roots.Nodup
state_after: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬(GCDMonoid.gcd f (derivative f)).degree = 0
⊢ ¬f.roots.Nodup
tactic: rw [Separable, ← gcd_isUnit_iff, isUnit_iff_degree_eq_zero] at hnsep
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬(GCDMonoid.gcd f (derivative f)).degree = 0
⊢ ¬f.roots.Nodup
state_after: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬(GCDMonoid.gcd f (derivative f)).degree = 0
x : F
hx : eval₂ (RingHom.id F) x (GCDMonoid.gcd f (derivative f)) = 0
⊢ ¬f.roots.Nodup
tactic: obtain ⟨x, hx⟩ := exists_root_of_splits _
    (splits_of_splits_of_dvd _ hf h (gcd_dvd_left f _)) hnsep
state_before: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬(GCDMonoid.gcd f (derivative f)).degree = 0
x : F
hx : eval₂ (RingHom.id F) x (GCDMonoid.gcd f (derivative f)) = 0
⊢ ¬f.roots.Nodup
state_after: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬(GCDMonoid.gcd f (derivative f)).degree = 0
x : F
hx : eval₂ (RingHom.id F) x (GCDMonoid.gcd f (derivative f)) = 0
⊢ ∃ x, 1 < Multiset.count x f.roots
tactic: simp_rw [Multiset.nodup_iff_count_le_one, not_forall, not_le]
state_before: case intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
f : F[X]
hf : f ≠ 0
h : Splits (RingHom.id F) f
hnsep : ¬(GCDMonoid.gcd f (derivative f)).degree = 0
x : F
hx : eval₂ (RingHom.id F) x (GCDMonoid.gcd f (derivative f)) = 0
⊢ ∃ x, 1 < Multiset.count x f.roots
state_after: no goals
tactic: exact ⟨x, ((one_lt_rootMultiplicity_iff_isRoot_gcd hf).2 hx).trans_eq f.count_roots.symm⟩
Theorem: CategoryTheory.Injective.injective_of_adjoint
File: Mathlib/CategoryTheory/Preadditive/Injective.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
inst✝¹ : L.PreservesMonomorphisms
adj : L ⊣ R
J : D
inst✝ : Injective J
A x✝ : C
g : A ⟶ R.obj J
f : A ⟶ x✝
im : Mono f
⊢ (adj.homEquiv A J).symm (f ≫ (adj.homEquiv x✝ J) (factorThru ((adj.homEquiv A J).symm g) (L.map f))) =
    (adj.homEquiv A J).symm g
state_after: no goals
tactic: simp
Theorem: TensorProduct.dualDistribEquivOfBasis_symm_apply
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : DecidableEq ι
inst✝⁷ : DecidableEq κ
inst✝⁶ : Fintype ι
inst✝⁵ : Fintype κ
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
b : Basis ι R M
c : Basis κ R N
⊢ Dual R M ⊗[R] Dual R N ≃ₗ[R] Dual R (M ⊗[R] N)
state_after: case refine_1
R : Type u_1
A : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : DecidableEq ι
inst✝⁷ : DecidableEq κ
inst✝⁶ : Fintype ι
inst✝⁵ : Fintype κ
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
b : Basis ι R M
c : Basis κ R N
⊢ dualDistrib R M N ∘ₗ dualDistribInvOfBasis b c = LinearMap.id

case refine_2
R : Type u_1
A : Type u_2
M : Type u_3
N : Type u_4
ι : Type u_5
κ : Type u_6
inst✝⁸ : DecidableEq ι
inst✝⁷ : DecidableEq κ
inst✝⁶ : Fintype ι
inst✝⁵ : Fintype κ
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
b : Basis ι R M
c : Basis κ R N
⊢ dualDistribInvOfBasis b c ∘ₗ dualDistrib R M N = LinearMap.id
tactic: refine LinearEquiv.ofLinear (dualDistrib R M N) (dualDistribInvOfBasis b c) ?_ ?_
Theorem: MeasureTheory.OuterMeasure.map_iInf
File: Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean

Proof steps:
state_before: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
hf : Injective f
m : ι → OuterMeasure α
⊢ (map f) (⨅ i, m i) = (restrict (range f)) (⨅ i, (map f) (m i))
state_after: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
hf : Injective f
m : ι → OuterMeasure α
⊢ (map f) (⨅ i, m i) = (map f) ((comap f) (⨅ i, (map f) (m i)))
tactic: refine Eq.trans ?_ (map_comap _ _)
state_before: α : Type u_1
ι : Sort u_2
β : Type u_3
f : α → β
hf : Injective f
m : ι → OuterMeasure α
⊢ (map f) (⨅ i, m i) = (map f) ((comap f) (⨅ i, (map f) (m i)))
state_after: no goals
tactic: simp only [comap_iInf, comap_map hf]
Theorem: Nat.factorization_eq_of_coprime_right
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a✝ b✝ m n p✝ p a b : ℕ
hab : a.Coprime b
hpb : p ∈ b.primeFactorsList
⊢ (a * b).factorization p = b.factorization p
state_after: a✝ b✝ m n p✝ p a b : ℕ
hab : a.Coprime b
hpb : p ∈ b.primeFactorsList
⊢ (b * a).factorization p = b.factorization p
tactic: rw [mul_comm]
state_before: a✝ b✝ m n p✝ p a b : ℕ
hab : a.Coprime b
hpb : p ∈ b.primeFactorsList
⊢ (b * a).factorization p = b.factorization p
state_after: no goals
tactic: exact factorization_eq_of_coprime_left (coprime_comm.mp hab) hpb
Theorem: Cardinal.mk_univ_quaternionAlgebra
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: R : Type u_1
c₁ c₂ : R
⊢ #↑Set.univ = #R ^ 4
state_after: no goals
tactic: rw [mk_univ, mk_quaternionAlgebra]
Theorem: AddCommGrp.asHom_injective
File: Mathlib/Algebra/Category/Grp/Basic.lean

Proof steps:
state_before: G : AddCommGrp
h k : ↑G
w : asHom h = asHom k
⊢ h = k
state_after: no goals
tactic: convert congr_arg (fun k : AddCommGrp.of ℤ ⟶ G => (k : ℤ → G) (1 : ℤ)) w <;> simp
Theorem: PiTensorProduct.liftAux.smul
File: Mathlib/LinearAlgebra/PiTensorProduct.lean

Proof steps:
state_before: ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
r : R
x : ⨂[R] (i : ι), s i
⊢ (liftAux φ) (r • x) = r • (liftAux φ) x
state_after: case refine_1
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
r : R
x : ⨂[R] (i : ι), s i
⊢ ∀ (r_1 : R) (f : (i : ι) → s i), (liftAux φ) (r • tprodCoeff R r_1 f) = r • (liftAux φ) (tprodCoeff R r_1 f)

case refine_2
ι : Type u_1
ι₂ : Type u_2
ι₃ : Type u_3
R : Type u_4
inst✝⁷ : CommSemiring R
R₁ : Type u_5
R₂ : Type u_6
s : ι → Type u_7
inst✝⁶ : (i : ι) → AddCommMonoid (s i)
inst✝⁵ : (i : ι) → Module R (s i)
M : Type u_8
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
E : Type u_9
inst✝² : AddCommMonoid E
inst✝¹ : Module R E
F : Type u_10
inst✝ : AddCommMonoid F
φ : MultilinearMap R s E
r : R
x : ⨂[R] (i : ι), s i
⊢ ∀ (x y : ⨂[R] (i : ι), s i),
    (liftAux φ) (r • x) = r • (liftAux φ) x →
      (liftAux φ) (r • y) = r • (liftAux φ) y → (liftAux φ) (r • (x + y)) = r • (liftAux φ) (x + y)
tactic: refine PiTensorProduct.induction_on' x ?_ ?_
Theorem: CategoryTheory.Iso.cancel_iso_hom_right
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ Z✝ X Y Z : C
f f' : X ⟶ Y
g : Y ≅ Z
⊢ f ≫ g.hom = f' ≫ g.hom ↔ f = f'
state_after: no goals
tactic: simp only [cancel_mono]
Theorem: ENNReal.mul_lt_of_lt_div
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a < b / c
⊢ a * c < b
state_after: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : b ≤ a * c
⊢ b / c ≤ a
tactic: contrapose! h
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : b ≤ a * c
⊢ b / c ≤ a
state_after: no goals
tactic: exact ENNReal.div_le_of_le_mul h
Theorem: DiscreteValuationRing.associated_of_irreducible
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha : Irreducible a
hb : Irreducible b
⊢ Associated a b
state_after: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha : maximalIdeal R = span {a}
hb : maximalIdeal R = span {b}
⊢ Associated a b
tactic: rw [irreducible_iff_uniformizer] at ha hb
state_before: R : Type u
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : DiscreteValuationRing R
a b : R
ha : maximalIdeal R = span {a}
hb : maximalIdeal R = span {b}
⊢ Associated a b
state_after: no goals
tactic: rw [← span_singleton_eq_span_singleton, ← ha, hb]
Theorem: contDiffWithinAt_insert_self
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ ContDiffWithinAt 𝕜 n f (insert x s) x ↔ ContDiffWithinAt 𝕜 n f s x
state_after: no goals
tactic: simp_rw [ContDiffWithinAt, insert_idem]
Theorem: FirstOrder.Language.BoundedFormula.relabel_all
File: Mathlib/ModelTheory/Syntax.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
g : α → β ⊕ Fin n
k : ℕ
φ : L.BoundedFormula α (k + 1)
⊢ relabel g φ.all = (relabel g φ).all
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
g : α → β ⊕ Fin n
k : ℕ
φ : L.BoundedFormula α (k + 1)
⊢ (castLE ⋯ (mapTermRel (fun x t => Term.relabel (relabelAux g x) t) (fun x => id) (fun x => castLE ⋯) φ)).all =
    (mapTermRel (fun x t => Term.relabel (relabelAux g x) t) (fun x => id) (fun x => castLE ⋯) φ).all
tactic: rw [relabel, mapTermRel, relabel]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
g : α → β ⊕ Fin n
k : ℕ
φ : L.BoundedFormula α (k + 1)
⊢ (castLE ⋯ (mapTermRel (fun x t => Term.relabel (relabelAux g x) t) (fun x => id) (fun x => castLE ⋯) φ)).all =
    (mapTermRel (fun x t => Term.relabel (relabelAux g x) t) (fun x => id) (fun x => castLE ⋯) φ).all
state_after: no goals
tactic: simp
Theorem: Finsupp.erase_single
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a : α
b : M
⊢ erase a (single a b) = 0
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a : α
b : M
s : α
⊢ (erase a (single a b)) s = 0 s
tactic: ext s
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a : α
b : M
s : α
⊢ (erase a (single a b)) s = 0 s
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a : α
b : M
s : α
hs : s = a
⊢ (erase a (single a b)) s = 0 s

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a : α
b : M
s : α
hs : ¬s = a
⊢ (erase a (single a b)) s = 0 s
tactic: by_cases hs : s = a