ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Matrix.Fin.circulant_mul
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
R : Type u_5
inst✝ : Semiring α
⊢ ∀ (v w : Fin 0 → α), circulant v * circulant w = circulant (circulant v *ᵥ w)
state_after: no goals
tactic: simp [Injective, eq_iff_true_of_subsingleton]
Theorem: Polynomial.roots_X_pow_char_pow_sub_C_pow
File: Mathlib/FieldTheory/Perfect.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
inst✝² : IsDomain R
p n : ℕ
inst✝¹ : ExpChar R p
f : R[X]
inst✝ : PerfectRing R p
y : R
m : ℕ
⊢ ((X ^ p ^ n - C y) ^ m).roots = (m * p ^ n) • {(iterateFrobeniusEquiv R p n).symm y}
state_after: no goals
tactic: rw [roots_pow, roots_X_pow_char_pow_sub_C, mul_smul]
Theorem: Finset.smul_univ
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑(s • univ) = ↑univ
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑s • Set.univ = Set.univ
tactic: push_cast
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑s • Set.univ = Set.univ
state_after: no goals
tactic: exact Set.smul_univ hs
Theorem: Nat.pred_sub
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m✝ n✝ k : ℕ
p q : ℕ → Prop
n m : ℕ
⊢ n.pred - m = (n - m).pred
state_after: no goals
tactic: rw [← Nat.sub_one, Nat.sub_sub, one_add, sub_succ]
Theorem: Sum.isSome_getLeft?_iff_isLeft
File: Mathlib/Data/Sum/Basic.lean

Proof steps:
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
⊢ x.getLeft?.isSome = true ↔ x.isLeft = true
state_after: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
⊢ (∃ a, x.getLeft? = some a) ↔ ∃ y, x = inl y
tactic: rw [isLeft_iff, Option.isSome_iff_exists]
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
⊢ (∃ a, x.getLeft? = some a) ↔ ∃ y, x = inl y
state_after: no goals
tactic: simp
Theorem: Nat.add_pos_iff_pos_or_pos
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ 0 < m + n ↔ 0 < m ∨ 0 < n
state_after: no goals
tactic: omega
Theorem: interior_prod_eq
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
x✝ : X × Y
a : X
b : Y
⊢ (a, b) ∈ interior (s ×ˢ t) ↔ (a, b) ∈ interior s ×ˢ interior t
state_after: no goals
tactic: simp only [mem_interior_iff_mem_nhds, mem_prod, prod_mem_nhds_iff]
Theorem: WithLp.prod_norm_sq_eq_of_L2
File: Mathlib/Analysis/Normed/Lp/ProdLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
x : WithLp 2 (α × β)
⊢ ‖x‖ ^ 2 = ‖x.1‖ ^ 2 + ‖x.2‖ ^ 2
state_after: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
x : WithLp 2 (α × β)
⊢ ‖x‖₊ ^ 2 = ‖x.1‖₊ ^ 2 + ‖x.2‖₊ ^ 2
tactic: suffices ‖x‖₊ ^ 2 = ‖x.fst‖₊ ^ 2 + ‖x.snd‖₊ ^ 2 by
    simpa only [NNReal.coe_sum] using congr_arg ((↑) : ℝ≥0 → ℝ) this
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
x : WithLp 2 (α × β)
⊢ ‖x‖₊ ^ 2 = ‖x.1‖₊ ^ 2 + ‖x.2‖₊ ^ 2
state_after: no goals
tactic: rw [prod_nnnorm_eq_of_L2, NNReal.sq_sqrt]
Theorem: WithTop.untop'_zero_mul
File: Mathlib/Algebra/Order/Ring/WithTop.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b
state_after: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
ha : a = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
ha : ¬a = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b
tactic: by_cases ha : a = 0
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
ha : ¬a = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b
state_after: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
ha : ¬a = 0
hb : b = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b

case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
ha : ¬a = 0
hb : ¬b = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b
tactic: by_cases hb : b = 0
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ b✝ a b : WithTop α
ha : ¬a = 0
hb : ¬b = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b
state_after: case neg.top
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b✝ b : WithTop α
hb : ¬b = 0
ha : ¬⊤ = 0
⊢ untop' 0 (⊤ * b) = untop' 0 ⊤ * untop' 0 b

case neg.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b✝ b : WithTop α
hb : ¬b = 0
a✝ : α
ha : ¬↑a✝ = 0
⊢ untop' 0 (↑a✝ * b) = untop' 0 ↑a✝ * untop' 0 b
tactic: induction a
state_before: case neg.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b✝ b : WithTop α
hb : ¬b = 0
a✝ : α
ha : ¬↑a✝ = 0
⊢ untop' 0 (↑a✝ * b) = untop' 0 ↑a✝ * untop' 0 b
state_after: case neg.coe.top
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
a✝ : α
ha : ¬↑a✝ = 0
hb : ¬⊤ = 0
⊢ untop' 0 (↑a✝ * ⊤) = untop' 0 ↑a✝ * untop' 0 ⊤

case neg.coe.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
a✝¹ : α
ha : ¬↑a✝¹ = 0
a✝ : α
hb : ¬↑a✝ = 0
⊢ untop' 0 (↑a✝¹ * ↑a✝) = untop' 0 ↑a✝¹ * untop' 0 ↑a✝
tactic: induction b
state_before: case neg.coe.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
a✝¹ : α
ha : ¬↑a✝¹ = 0
a✝ : α
hb : ¬↑a✝ = 0
⊢ untop' 0 (↑a✝¹ * ↑a✝) = untop' 0 ↑a✝¹ * untop' 0 ↑a✝
state_after: no goals
tactic: rw [← coe_mul, untop'_coe, untop'_coe, untop'_coe]
Theorem: UniqueMDiffWithinAt.preimage_partialHomeomorph
File: Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝⁸ : TopologicalSpace M
inst✝⁷ : ChartedSpace H M
inst✝⁶ : SmoothManifoldWithCorners I M
E' : Type u_5
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝³ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : SmoothManifoldWithCorners I' M'
s : Set M
x : M
hs : UniqueMDiffWithinAt I s x
e : PartialHomeomorph M M'
he : PartialHomeomorph.MDifferentiable I I' e
hx : x ∈ e.source
⊢ UniqueMDiffWithinAt I' (e.target ∩ ↑e.symm ⁻¹' s) (↑e x)
state_after: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝⁸ : TopologicalSpace M
inst✝⁷ : ChartedSpace H M
inst✝⁶ : SmoothManifoldWithCorners I M
E' : Type u_5
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝³ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : SmoothManifoldWithCorners I' M'
s : Set M
x : M
hs : UniqueMDiffWithinAt I s x
e : PartialHomeomorph M M'
he : PartialHomeomorph.MDifferentiable I I' e
hx : x ∈ e.source
⊢ UniqueMDiffWithinAt I' (↑e '' (s ∩ e.source)) (↑e x)
tactic: rw [← e.image_source_inter_eq', inter_comm]
state_before: 𝕜 : Type u_1
inst✝¹² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
H : Type u_3
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝⁸ : TopologicalSpace M
inst✝⁷ : ChartedSpace H M
inst✝⁶ : SmoothManifoldWithCorners I M
E' : Type u_5
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝³ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : SmoothManifoldWithCorners I' M'
s : Set M
x : M
hs : UniqueMDiffWithinAt I s x
e : PartialHomeomorph M M'
he : PartialHomeomorph.MDifferentiable I I' e
hx : x ∈ e.source
⊢ UniqueMDiffWithinAt I' (↑e '' (s ∩ e.source)) (↑e x)
state_after: no goals
tactic: exact (hs.inter (e.open_source.mem_nhds hx)).image_denseRange
    (he.mdifferentiableAt hx).hasMFDerivAt.hasMFDerivWithinAt
    (he.mfderiv_surjective hx).denseRange
Theorem: Ordinal.mod_mod_of_dvd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
h : c ∣ b
⊢ a % b % c = a % c
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
h : c ∣ b
⊢ a % b % c = (b * (a / b) + a % b) % c
tactic: nth_rw 2 [← div_add_mod a b]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
h : c ∣ b
⊢ a % b % c = (b * (a / b) + a % b) % c
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a c d : Ordinal.{u_4}
⊢ a % (c * d) % c = (c * d * (a / (c * d)) + a % (c * d)) % c
tactic: rcases h with ⟨d, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a c d : Ordinal.{u_4}
⊢ a % (c * d) % c = (c * d * (a / (c * d)) + a % (c * d)) % c
state_after: no goals
tactic: rw [mul_assoc, mul_add_mod_self]
Theorem: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_inverse_map
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelFamily (ULift.{w, 0} Bool)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
    ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
          parallelPair (line { down := true }) (line { down := false })).obj
      X
state_after: no goals
tactic: cases X <;> rfl
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelFamily (ULift.{w, 0} Bool)} (f : X ⟶ Y),
    (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
      ((fun X => eqToIso ⋯) X).hom ≫
        ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
              parallelPair (line { down := true }) (line { down := false })).map
          f
state_after: no goals
tactic: rintro _ _ (_|⟨_|_⟩) <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelPair
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
          parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
      X =
    (𝟭 WalkingParallelPair).obj X
state_after: no goals
tactic: cases X <;> rfl
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelPair} (f : X ⟶ Y),
    (parallelPair (line { down := true }) (line { down := false }) ⋙
              parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
          f ≫
        ((fun X => eqToIso ⋯) Y).hom =
      ((fun X => eqToIso ⋯) X).hom ≫ (𝟭 WalkingParallelPair).map f
state_after: no goals
tactic: rintro _ _ (_|_|_) <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ (X : WalkingParallelFamily (ULift.{w, 0} Bool)),
    (parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
          ((NatIso.ofComponents (fun X => eqToIso ⋯) ⋯).hom.app X) ≫
        (NatIso.ofComponents (fun X => eqToIso ⋯) ⋯).hom.app
          ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
            X) =
      𝟙 ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj X)
state_after: no goals
tactic: rintro (_|_) <;> aesop_cat
Theorem: Ordinal.type_preimage_aux
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type u_1
γ : Type u_2
r✝ : α✝ → α✝ → Prop
s : β✝ → β✝ → Prop
t : γ → γ → Prop
α β : Type u
r : α → α → Prop
inst✝ : IsWellOrder α r
f : β ≃ α
⊢ (type fun x y => r (f x) (f y)) = type r
state_after: no goals
tactic: convert (RelIso.preimage f r).ordinal_type_eq
Theorem: MeasureTheory.eLpNorm_lt_top_iff_lintegral_rpow_nnnorm_lt_top
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
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤ → eLpNorm f p μ < ⊤
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
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤
⊢ eLpNorm f p μ < ⊤
tactic: intro h
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
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤
⊢ eLpNorm f p μ < ⊤
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
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤
hp' : 0 < p.toReal
⊢ eLpNorm f p μ < ⊤
tactic: have hp' := ENNReal.toReal_pos hp_ne_zero hp_ne_top
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
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤
hp' : 0 < p.toReal
⊢ eLpNorm f p μ < ⊤
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
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤
hp' : 0 < p.toReal
this : 0 < 1 / p.toReal
⊢ eLpNorm f p μ < ⊤
tactic: have : 0 < 1 / p.toReal := div_pos zero_lt_one hp'
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
f : α → F
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
h : ∫⁻ (a : α), ↑‖f a‖₊ ^ p.toReal ∂μ < ⊤
hp' : 0 < p.toReal
this : 0 < 1 / p.toReal
⊢ eLpNorm f p μ < ⊤
state_after: no goals
tactic: simpa [eLpNorm_eq_lintegral_rpow_nnnorm hp_ne_zero hp_ne_top] using
      ENNReal.rpow_lt_top_of_nonneg (le_of_lt this) (ne_of_lt h)
Theorem: add_mem_cancel_left
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
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H K : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
x y : G
h : x ∈ H
hab : x * y ∈ H
⊢ y ∈ H
state_after: no goals
tactic: simpa using mul_mem (inv_mem h) hab
Theorem: FreeSemigroup.lift_symm_apply
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semigroup β
f✝ f : α → β
x y : FreeSemigroup α
⊢ (fun x => List.foldl (fun a b => a * f b) (f x.head) x.tail) (x * y) =
    (fun x => List.foldl (fun a b => a * f b) (f x.head) x.tail) x *
      (fun x => List.foldl (fun a b => a * f b) (f x.head) x.tail) y
state_after: no goals
tactic: simp [head_mul, tail_mul, ← List.foldl_map, List.foldl_append, List.foldl_cons,
          List.foldl_assoc]
Theorem: List.Nodup.isCycleOn_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
⊢ l.formPerm.IsCycleOn {a | a ∈ l}
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : a ∈ {a | a ∈ l}
b : α
hb : b ∈ {a | a ∈ l}
⊢ l.formPerm.SameCycle a b
tactic: refine ⟨l.formPerm.bijOn fun _ => List.formPerm_mem_iff_mem, fun a ha b hb => ?_⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : a ∈ {a | a ∈ l}
b : α
hb : b ∈ {a | a ∈ l}
⊢ l.formPerm.SameCycle a b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle a b
tactic: rw [Set.mem_setOf, ← List.indexOf_lt_length] at ha hb
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle a b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle (l.get ⟨indexOf a l, ha⟩) (l.get ⟨indexOf b l, hb⟩)
tactic: rw [← List.indexOf_get ha, ← List.indexOf_get hb]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.formPerm.SameCycle (l.get ⟨indexOf a l, ha⟩) (l.get ⟨indexOf b l, hb⟩)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ (l.formPerm ^ (↑(indexOf b l) - ↑(indexOf a l))) (l.get ⟨indexOf a l, ha⟩) = l.get ⟨indexOf b l, hb⟩
tactic: refine ⟨l.indexOf b - l.indexOf a, ?_⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ (l.formPerm ^ (↑(indexOf b l) - ↑(indexOf a l))) (l.get ⟨indexOf a l, ha⟩) = l.get ⟨indexOf b l, hb⟩
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.get ⟨(indexOf a l + indexOf b l) % l.length, ⋯⟩ = l.get ⟨(indexOf b l + indexOf a l) % l.length, ⋯⟩
tactic: simp only [sub_eq_neg_add, zpow_add, zpow_neg, Equiv.Perm.inv_eq_iff_eq, zpow_natCast,
    Equiv.Perm.coe_mul, List.formPerm_pow_apply_get _ h, Function.comp]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : DecidableEq α
l : List α
h : l.Nodup
a : α
ha : indexOf a l < l.length
b : α
hb : indexOf b l < l.length
⊢ l.get ⟨(indexOf a l + indexOf b l) % l.length, ⋯⟩ = l.get ⟨(indexOf b l + indexOf a l) % l.length, ⋯⟩
state_after: no goals
tactic: rw [add_comm]
Theorem: Hyperreal.isSt_trans_real
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: r s t : ℝ
⊢ (↑r).IsSt s → (↑s).IsSt t → (↑r).IsSt t
state_after: r s t : ℝ
⊢ r = s → s = t → r = t
tactic: rw [isSt_real_iff_eq, isSt_real_iff_eq, isSt_real_iff_eq]
state_before: r s t : ℝ
⊢ r = s → s = t → r = t
state_after: no goals
tactic: exact Eq.trans
Theorem: gal_C_isSolvable
File: Mathlib/FieldTheory/AbelRuffini.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
x : F
⊢ IsSolvable (C x).Gal
state_after: no goals
tactic: infer_instance
Theorem: List.zipLeft_nil_right
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
as : List α
b : β
bs : List β
⊢ as.zipLeft [] = map (fun a => (a, none)) as
state_after: no goals
tactic: cases as <;> rfl
Theorem: polynomialFunctions_closure_eq_top'
File: Mathlib/Topology/ContinuousFunction/Weierstrass.lean

Proof steps:
state_before: ⊢ (polynomialFunctions I).topologicalClosure = ⊤
state_after: ⊢ ⊤ ≤ (polynomialFunctions I).topologicalClosure
tactic: rw [eq_top_iff]
state_before: ⊢ ⊤ ≤ (polynomialFunctions I).topologicalClosure
state_after: f : C(↑I, ℝ)
⊢ f ∈ (polynomialFunctions I).topologicalClosure
tactic: rintro f -
state_before: f : C(↑I, ℝ)
⊢ f ∈ (polynomialFunctions I).topologicalClosure
state_after: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : C(↑I, ℝ)) in nhds f, x ∈ ↑(polynomialFunctions I).toSubsemiring
tactic: refine Filter.Frequently.mem_closure ?_
state_before: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : C(↑I, ℝ)) in nhds f, x ∈ ↑(polynomialFunctions I).toSubsemiring
state_after: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : ℕ) in atTop, bernsteinApproximation x f ∈ ↑(polynomialFunctions I).toSubsemiring
tactic: refine Filter.Tendsto.frequently (bernsteinApproximation_uniform f) ?_
state_before: f : C(↑I, ℝ)
⊢ ∃ᶠ (x : ℕ) in atTop, bernsteinApproximation x f ∈ ↑(polynomialFunctions I).toSubsemiring
state_after: case h
f : C(↑I, ℝ)
⊢ ∀ (x : ℕ), bernsteinApproximation x f ∈ ↑(polynomialFunctions I).toSubsemiring
tactic: apply frequently_of_forall
state_before: case h
f : C(↑I, ℝ)
⊢ ∀ (x : ℕ), bernsteinApproximation x f ∈ ↑(polynomialFunctions I).toSubsemiring
state_after: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ ↑(polynomialFunctions I).toSubsemiring
tactic: intro n
state_before: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ ↑(polynomialFunctions I).toSubsemiring
state_after: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ (polynomialFunctions I).toSubsemiring
tactic: simp only [SetLike.mem_coe]
state_before: case h
f : C(↑I, ℝ)
n : ℕ
⊢ bernsteinApproximation n f ∈ (polynomialFunctions I).toSubsemiring
state_after: case h.h
f : C(↑I, ℝ)
n : ℕ
⊢ ∀ x ∈ Finset.univ, f (bernstein.z x) • bernstein n ↑x ∈ polynomialFunctions I
tactic: apply Subalgebra.sum_mem
state_before: case h.h
f : C(↑I, ℝ)
n : ℕ
⊢ ∀ x ∈ Finset.univ, f (bernstein.z x) • bernstein n ↑x ∈ polynomialFunctions I
state_after: case h.h
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ f (bernstein.z n) • bernstein n✝ ↑n ∈ polynomialFunctions I
tactic: rintro n -
state_before: case h.h
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ f (bernstein.z n) • bernstein n✝ ↑n ∈ polynomialFunctions I
state_after: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ bernstein n✝ ↑n ∈ polynomialFunctions I
tactic: apply Subalgebra.smul_mem
state_before: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ bernstein n✝ ↑n ∈ polynomialFunctions I
state_after: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ (bernsteinPolynomial ℝ n✝ ↑n).toContinuousMapOn I ∈ Subalgebra.map (Polynomial.toContinuousMapOnAlgHom I) ⊤
tactic: dsimp [bernstein, polynomialFunctions]
state_before: case h.h.hx
f : C(↑I, ℝ)
n✝ : ℕ
n : Fin (n✝ + 1)
⊢ (bernsteinPolynomial ℝ n✝ ↑n).toContinuousMapOn I ∈ Subalgebra.map (Polynomial.toContinuousMapOnAlgHom I) ⊤
state_after: no goals
tactic: simp