ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Equiv.traverse_eq_map_id
File: Mathlib/Control/Traversable/Equiv.lean

Proof steps:
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → β
x : t' α
⊢ Equiv.traverse eqv (pure ∘ f) x = pure (Equiv.map eqv f x)
state_after: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → β
x : t' α
⊢ (eqv β) (id.mk (f <$> (eqv α).symm x)) = Equiv.map eqv f x
tactic: simp only [Equiv.traverse, traverse_eq_map_id, Id.map_eq, Id.pure_eq]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → β
x : t' α
⊢ (eqv β) (id.mk (f <$> (eqv α).symm x)) = Equiv.map eqv f x
state_after: no goals
tactic: rfl
Theorem: Matrix.det_mul_comm
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M N : Matrix m m R
⊢ (M * N).det = (N * M).det
state_after: no goals
tactic: rw [det_mul, det_mul, mul_comm]
Theorem: List.mem_cyclicPermutations_self
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l✝ l' l : List α
⊢ l ∈ l.cyclicPermutations
state_after: no goals
tactic: simpa using head_mem (cyclicPermutations_ne_nil l)
Theorem: CategoryTheory.Grothendieck.id_fiber'
File: Mathlib/CategoryTheory/Grothendieck.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.17959, u_1} C
inst✝ : Category.{?u.17963, u_2} D
F : C ⥤ Cat
X : Grothendieck F
⊢ (F.map (𝟙 X).base).obj X.fiber = X.fiber
state_after: no goals
tactic: erw [CategoryTheory.Functor.map_id, Functor.id_obj X.fiber]
Theorem: Nat.sum_divisors_prime_pow
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
inst✝ : CommMonoid α
k p : ℕ
f : ℕ → α
h : Prime p
⊢ ∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ range (k + 1), f (p ^ x)
state_after: no goals
tactic: simp [h, divisors_prime_pow]
Theorem: contDiff_zero
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
⊢ ContDiff 𝕜 0 f ↔ Continuous f
state_after: 𝕜 : 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
⊢ ContDiffOn 𝕜 0 f univ ↔ ContinuousOn f univ
tactic: rw [← contDiffOn_univ, continuous_iff_continuousOn_univ]
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
⊢ ContDiffOn 𝕜 0 f univ ↔ ContinuousOn f univ
state_after: no goals
tactic: exact contDiffOn_zero
Theorem: Multiset.prod_X_add_C_eq_sum_esymm
File: Mathlib/RingTheory/Polynomial/Vieta.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
s : Multiset R
⊢ (map (fun r => X + C r) s).prod = ∑ j ∈ Finset.range (card s + 1), C (s.esymm j) * X ^ (card s - j)
state_after: no goals
tactic: classical
    rw [prod_map_add, antidiagonal_eq_map_powerset, map_map, ← bind_powerset_len,
      map_bind, sum_bind, Finset.sum_eq_multiset_sum, Finset.range_val, map_congr (Eq.refl _)]
    intro _ _
    rw [esymm, ← sum_hom', ← sum_map_mul_right, map_congr (Eq.refl _)]
    intro s ht
    rw [mem_powersetCard] at ht
    dsimp
    rw [prod_hom' s (Polynomial.C : R →+* R[X])]
    simp [ht, map_const, prod_replicate, prod_hom', map_id', card_sub]
Theorem: Set.pairwise_insert
File: Mathlib/Data/Set/Pairwise/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
⊢ (insert a s).Pairwise r ↔ s.Pairwise r ∧ ∀ b ∈ s, a ≠ b → r a b ∧ r b a
state_after: no goals
tactic: simp only [insert_eq, pairwise_union, pairwise_singleton, true_and_iff, mem_singleton_iff,
    forall_eq]
Theorem: MeasureTheory.SignedMeasure.totalVariation_absolutelyContinuous_iff
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : Measure α
⊢ s.totalVariation ≪ μ ↔ s.toJordanDecomposition.posPart ≪ μ ∧ s.toJordanDecomposition.negPart ≪ μ
state_after: case mp
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : Measure α
h : s.totalVariation ≪ μ
⊢ s.toJordanDecomposition.posPart ≪ μ ∧ s.toJordanDecomposition.negPart ≪ μ

case mpr
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
s : SignedMeasure α
μ : Measure α
h : s.toJordanDecomposition.posPart ≪ μ ∧ s.toJordanDecomposition.negPart ≪ μ
⊢ s.totalVariation ≪ μ
tactic: constructor <;> intro h
Theorem: MeasureTheory.eLpNorm'_const'
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : F
hc_ne_zero : c ≠ 0
hq_ne_zero : q ≠ 0
⊢ eLpNorm' (fun x => c) q μ = ↑‖c‖₊ * μ Set.univ ^ (1 / q)
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : F
hc_ne_zero : c ≠ 0
hq_ne_zero : q ≠ 0
⊢ (↑‖c‖₊ ^ q) ^ (1 / q) * μ Set.univ ^ (1 / q) = ↑‖c‖₊ * μ Set.univ ^ (1 / q)

α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : F
hc_ne_zero : c ≠ 0
hq_ne_zero : q ≠ 0
⊢ ↑‖c‖₊ ^ q ≠ ⊤
tactic: rw [eLpNorm', lintegral_const, ENNReal.mul_rpow_of_ne_top _ (measure_ne_top μ Set.univ)]
Theorem: AlgebraicTopology.normalizedMooreComplex_obj
File: Mathlib/AlgebraicTopology/MooreComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.55203, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
⊢ { obj := obj, map := fun {X Y} f => map f }.map (𝟙 X) = 𝟙 ({ obj := obj, map := fun {X Y} f => map f }.obj X)
state_after: no goals
tactic: ext (_ | _) <;> dsimp <;> aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.55203, u_1} C
inst✝ : Abelian C
X✝ Y✝ Z✝ : SimplicialObject C
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := obj, map := fun {X Y} f => map f }.map (f ≫ g) =
    { obj := obj, map := fun {X Y} f => map f }.map f ≫ { obj := obj, map := fun {X Y} f => map f }.map g
state_after: no goals
tactic: ext (_ | _) <;> apply Subobject.eq_of_comp_arrow_eq <;> dsimp <;> aesop_cat
Theorem: tprod_range
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g✝ : β → α
a a₁ a₂ : α
g : γ → β
f : β → α
hg : Injective g
⊢ ∏' (x : ↑(Set.range g)), f ↑x = ∏' (x : γ), f (g x)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g✝ : β → α
a a₁ a₂ : α
g : γ → β
f : β → α
hg : Injective g
⊢ ∏' (x : ↑Set.univ), f (g ↑x) = ∏' (x : γ), f (g x)
tactic: rw [← Set.image_univ, tprod_image f hg.injOn]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g✝ : β → α
a a₁ a₂ : α
g : γ → β
f : β → α
hg : Injective g
⊢ ∏' (x : ↑Set.univ), f (g ↑x) = ∏' (x : γ), f (g x)
state_after: no goals
tactic: simp_rw [← comp_apply (g := g), tprod_univ (f ∘ g)]
Theorem: Cubic.map_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝² : CommRing R
inst✝¹ : CommRing S
φ : R →+* S
inst✝ : IsDomain S
⊢ (map φ P).roots = (Polynomial.map φ P.toPoly).roots
state_after: no goals
tactic: rw [roots, map_toPoly]
Theorem: List.norm_prod_le
File: Mathlib/Analysis/Normed/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝¹ : SeminormedRing α
inst✝ : NormOneClass α
⊢ ‖[].prod‖ ≤ (map norm []).prod
state_after: no goals
tactic: simp
Theorem: Int.card_fintype_Icc
File: Mathlib/Data/Int/Interval.lean

Proof steps:
state_before: a b : ℤ
⊢ Fintype.card ↑(Set.Icc a b) = (b + 1 - a).toNat
state_after: no goals
tactic: rw [← card_Icc, Fintype.card_ofFinset]
Theorem: _private.Mathlib.SetTheory.Ordinal.Basic.0.Ordinal.succ_le_iff'
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
a b : Ordinal.{u_3}
α : Type u_3
r : α → α → Prop
hr : IsWellOrder α r
β : Type u_3
s : β → β → Prop
hs : IsWellOrder β s
x✝ : type r < type s
f : r ↪r s
t : β
hf : ∀ (b : β), s b t ↔ ∃ a, f a = b
⊢ type r + 1 ≤ type s
state_after: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
a b : Ordinal.{u_3}
α : Type u_3
r : α → α → Prop
hr : IsWellOrder α r
β : Type u_3
s : β → β → Prop
hs : IsWellOrder β s
x✝ : type r < type s
f : r ↪r s
t : β
hf : ∀ (b : β), s b t ↔ ∃ a, f a = b
this : IsWellOrder β s
⊢ type r + 1 ≤ type s
tactic: haveI := hs
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
a b : Ordinal.{u_3}
α : Type u_3
r : α → α → Prop
hr : IsWellOrder α r
β : Type u_3
s : β → β → Prop
hs : IsWellOrder β s
x✝ : type r < type s
f : r ↪r s
t : β
hf : ∀ (b : β), s b t ↔ ∃ a, f a = b
this : IsWellOrder β s
⊢ type r + 1 ≤ type s
state_after: case refine_1
α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
a✝ b✝ : Ordinal.{u_3}
α : Type u_3
r : α → α → Prop
hr : IsWellOrder α r
β : Type u_3
s : β → β → Prop
hs : IsWellOrder β s
x✝ : type r < type s
f : r ↪r s
t : β
hf : ∀ (b : β), s b t ↔ ∃ a, f a = b
this : IsWellOrder β s
a b : α ⊕ PUnit.{u_3 + 1}
⊢ Sum.Lex r EmptyRelation a b →
    s ((fun t_1 => Sum.rec (⇑f) (fun x => t) t_1) a) ((fun t_1 => Sum.rec (⇑f) (fun x => t) t_1) b)

case refine_2
α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s✝ : β✝ → β✝ → Prop
t✝ : γ → γ → Prop
a✝ b✝ : Ordinal.{u_3}
α : Type u_3
r : α → α → Prop
hr : IsWellOrder α r
β : Type u_3
s : β → β → Prop
hs : IsWellOrder β s
x✝ : type r < type s
f : r ↪r s
t : β
hf : ∀ (b : β), s b t ↔ ∃ a, f a = b
this : IsWellOrder β s
a : α ⊕ PUnit.{u_3 + 1}
b : β
⊢ s b ((RelEmbedding.ofMonotone (fun t_1 => Sum.rec (⇑f) (fun x => t) t_1) ⋯) a) →
    ∃ a', (RelEmbedding.ofMonotone (fun t_1 => Sum.rec (⇑f) (fun x => t) t_1) ⋯) a' = b
tactic: refine ⟨⟨RelEmbedding.ofMonotone (Sum.rec f fun _ => t) (fun a b ↦ ?_), fun a b ↦ ?_⟩⟩
Theorem: MonovaryOn.sum_comp_perm_smul_le_sum_smul
File: Mathlib/Algebra/Order/Rearrangement.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
hfg : MonovaryOn f g ↑s
hσ : {x | σ x ≠ x} ⊆ ↑s
⊢ ∑ i ∈ s, f (σ i) • g i ≤ ∑ i ∈ s, f i • g i
state_after: case h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
hfg : MonovaryOn f g ↑s
hσ : {x | σ x ≠ x} ⊆ ↑s
⊢ ∑ i ∈ s, f (σ i) • g i = ∑ i ∈ s, f i • g (σ⁻¹ i)
tactic: convert hfg.sum_smul_comp_perm_le_sum_smul
    (show { x | σ⁻¹ x ≠ x } ⊆ s by simp only [set_support_inv_eq, hσ]) using 1
state_before: case h.e'_3
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : LinearOrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
hfg : MonovaryOn f g ↑s
hσ : {x | σ x ≠ x} ⊆ ↑s
⊢ ∑ i ∈ s, f (σ i) • g i = ∑ i ∈ s, f i • g (σ⁻¹ i)
state_after: no goals
tactic: exact σ.sum_comp' s (fun i j ↦ f i • g j) hσ
Theorem: Filter.tendsto_nhds
File: Mathlib/Topology/Filter.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
X : Type u_4
Y : Type u_5
la : Filter α
lb : Filter β
f : α → Filter β
⊢ Tendsto f la (𝓝 lb) ↔ ∀ s ∈ lb, ∀ᶠ (a : α) in la, s ∈ f a
state_after: no goals
tactic: simp only [nhds_eq', tendsto_lift', mem_setOf_eq]
Theorem: CategoryTheory.CosimplicialObject.δ_comp_δ''
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ j.castSucc
⊢ X.δ (i.castLT ⋯) ≫ X.δ j.succ = X.δ j ≫ X.δ i
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ j.castSucc
⊢ X.map (SimplexCategory.δ (i.castLT ⋯)) ≫ X.map (SimplexCategory.δ j.succ) =
    X.map (SimplexCategory.δ j) ≫ X.map (SimplexCategory.δ i)
tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ j.castSucc
⊢ X.map (SimplexCategory.δ (i.castLT ⋯)) ≫ X.map (SimplexCategory.δ j.succ) =
    X.map (SimplexCategory.δ j) ≫ X.map (SimplexCategory.δ i)
state_after: no goals
tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ'' H]
Theorem: edist_smul₀
File: Mathlib/Analysis/Normed/MulAction.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : NormedDivisionRing α
inst✝² : SeminormedAddCommGroup β
inst✝¹ : Module α β
inst✝ : BoundedSMul α β
s : α
x y : β
⊢ edist (s • x) (s • y) = ‖s‖₊ • edist x y
state_after: no goals
tactic: simp only [edist_nndist, nndist_smul₀, ENNReal.coe_mul, ENNReal.smul_def, smul_eq_mul]
Theorem: MeasureTheory.mul_meas_ge_le_lintegral₀
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
ε : ℝ≥0∞
⊢ ε * μ {x | ε ≤ f x} ≤ ∫⁻ (a : α), f a ∂μ
state_after: no goals
tactic: simpa only [lintegral_zero, zero_add] using
    lintegral_add_mul_meas_add_le_le_lintegral (ae_of_all _ fun x => zero_le (f x)) hf ε
Theorem: MeasureTheory.eLpNorm'_trim
File: Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ eLpNorm' f q (μ.trim hm) = eLpNorm' f q μ
state_after: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm) ^ (1 / q) = (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q)
tactic: simp_rw [eLpNorm']
state_before: α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm) ^ (1 / q) = (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q)
state_after: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm = ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ
tactic: congr 1
state_before: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm = ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ
state_after: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ↑‖f a‖₊ ^ q
tactic: refine lintegral_trim hm ?_
state_before: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ↑‖f a‖₊ ^ q
state_after: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ‖f a‖₊
tactic: refine @Measurable.pow_const _ _ _ _ _ _ _ m _ (@Measurable.coe_nnreal_ennreal _ m _ ?_) q
state_before: case e_a
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ Measurable fun a => ‖f a‖₊
state_after: case e_a.hf
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun a => ‖f a‖₊
tactic: apply @StronglyMeasurable.measurable
state_before: case e_a.hf
α : Type u_1
E : Type u_2
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ : Measure α
inst✝ : NormedAddCommGroup E
hm : m ≤ m0
f : α → E
hf : StronglyMeasurable f
⊢ StronglyMeasurable fun a => ‖f a‖₊
state_after: no goals
tactic: exact @StronglyMeasurable.nnnorm α m _ _ _ hf
Theorem: Sym.forall
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n n' m : ℕ
s : Sym α n
a b : α
p : Sym α n → Prop
⊢ (∀ (s : Sym α n), p s) ↔ ∀ (s : Multiset α) (hs : Multiset.card s = n), p (mk s hs)
state_after: no goals
tactic: simp [Sym]
Theorem: Matroid.insert_indep_iff
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
⊢ M.Indep (insert e I) ↔ M.Indep I ∧ (e ∉ I → e ∈ M.E \ M.closure I)
state_after: case pos
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
⊢ M.Indep (insert e I) ↔ M.Indep I ∧ (e ∉ I → e ∈ M.E \ M.closure I)

case neg
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : ¬M.Indep I
⊢ M.Indep (insert e I) ↔ M.Indep I ∧ (e ∉ I → e ∈ M.E \ M.closure I)
tactic: by_cases hI : M.Indep I
state_before: case neg
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : ¬M.Indep I
⊢ M.Indep (insert e I) ↔ M.Indep I ∧ (e ∉ I → e ∈ M.E \ M.closure I)
state_after: no goals
tactic: simp [hI, show ¬ M.Indep (insert e I) from fun h ↦ hI <| h.subset <| subset_insert _ _]
Theorem: Function.Semiconj.iterate_left
File: Mathlib/Logic/Function/Iterate.lean

Proof steps:
state_before: α : Type u
β : Type v
f : α → α
g : ℕ → α → α
H : ∀ (n : ℕ), Semiconj f (g n) (g (n + 1))
n k : ℕ
⊢ Semiconj f^[n] (g k) (g (n + k))
state_after: no goals
tactic: induction n generalizing k with
  | zero =>
    rw [Nat.zero_add]
    exact id_left
  | succ n ihn =>
    rw [Nat.add_right_comm, Nat.add_assoc]
    exact (H k).trans (ihn (k + 1))
Theorem: MeasureTheory.smul_ae_eq_self_of_mem_zpowers
File: Mathlib/MeasureTheory/Group/AEStabilizer.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
x y : G
s : Set α
hs : x • s =ᶠ[ae μ] s
hy : y ∈ Subgroup.zpowers x
⊢ y • s =ᶠ[ae μ] s
state_after: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
x y : G
s : Set α
hs : Subgroup.zpowers x ≤ MulAction.aestabilizer G μ s
hy : y ∈ Subgroup.zpowers x
⊢ y • s =ᶠ[ae μ] s
tactic: rw [← MulAction.mem_aestabilizer, ← Subgroup.zpowers_le] at hs
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
x y : G
s : Set α
hs : Subgroup.zpowers x ≤ MulAction.aestabilizer G μ s
hy : y ∈ Subgroup.zpowers x
⊢ y • s =ᶠ[ae μ] s
state_after: no goals
tactic: exact hs hy
Theorem: AddSubgroup.mem_iInf
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
ι : Sort u_5
S : ι → Subgroup G
x : G
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
Theorem: WeierstrassCurve.Jacobian.negY_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.negY P / P z ^ 3 = W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3)
state_after: no goals
tactic: linear_combination (norm := (rw [negY, Affine.negY]; ring1))
    -W.a₁ * P x / P z ^ 2 * div_self hPz - W.a₃ * div_self (pow_ne_zero 3 hPz)
Theorem: Associates.reducible_not_mem_factorSet
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p : Associates α
hp : ¬Irreducible p
s : FactorSet α
h : p ∈ s
⊢ False
state_after: no goals
tactic: rwa [← factorSetMem_eq_mem, FactorSetMem, dif_neg hp] at h
Theorem: PowerSeries.coeff_succ_mul_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (coeff R (n + 1)) (φ * X) = (coeff R n) φ
state_after: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () n + single () 1)) (φ * X) = (MvPowerSeries.coeff R (single () n)) φ
tactic: simp only [coeff, Finsupp.single_add]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () n + single () 1)) (φ * X) = (MvPowerSeries.coeff R (single () n)) φ
state_after: case h.e'_3
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () n)) φ = (MvPowerSeries.coeff R (single () n)) φ * 1
tactic: convert φ.coeff_add_mul_monomial (single () n) (single () 1) _
state_before: case h.e'_3
R : Type u_1
inst✝ : Semiring R
n : ℕ
φ : R⟦X⟧
⊢ (MvPowerSeries.coeff R (single () n)) φ = (MvPowerSeries.coeff R (single () n)) φ * 1
state_after: no goals
tactic: rw [mul_one]