ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submodule.ideal_span_singleton_smul
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
⊢ Ideal.span {r} • N = r • N
state_after: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
this : span R (⋃ t ∈ N, {r • t}) = r • N
⊢ Ideal.span {r} • N = r • N
tactic: have : span R (⋃ (t : M) (_ : t ∈ N), {r • t}) = r • N := by
    convert span_eq (r • N)
    exact (Set.image_eq_iUnion _ (N : Set M)).symm
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
this : span R (⋃ t ∈ N, {r • t}) = r • N
⊢ Ideal.span {r} • N = r • N
state_after: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
this : span R (⋃ t ∈ N, {r • t}) = r • N
⊢ span R (⋃ s ∈ {r}, ⋃ t ∈ ↑N, {s • t}) = r • N
tactic: conv_lhs => rw [← span_eq N, span_smul_span]
state_before: R : Type u
M : Type v
M' : Type u_1
F : Type u_2
G : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
I J : Ideal R
N✝ P : Submodule R M
S : Set R
T : Set M
r : R
N : Submodule R M
this : span R (⋃ t ∈ N, {r • t}) = r • N
⊢ span R (⋃ s ∈ {r}, ⋃ t ∈ ↑N, {s • t}) = r • N
state_after: no goals
tactic: simpa
Theorem: Order.succ_eq_iInf
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
⊢ succ a = ⨅ b, ⨅ (_ : a < b), b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
⊢ ⨅ b, ⨅ (_ : a < b), b ≤ succ a
tactic: refine le_antisymm (le_iInf fun b => le_iInf succ_le_of_lt) ?_
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
⊢ ⨅ b, ⨅ (_ : a < b), b ≤ succ a
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
⊢ ⨅ b, ⨅ (_ : ⊤ < b), b ≤ succ ⊤

case inr
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
ha : a ≠ ⊤
⊢ ⨅ b, ⨅ (_ : a < b), b ≤ succ a
tactic: obtain rfl | ha := eq_or_ne a ⊤
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : SuccOrder α
a : α
ha : a ≠ ⊤
⊢ ⨅ b, ⨅ (_ : a < b), b ≤ succ a
state_after: no goals
tactic: exact iInf₂_le _ (lt_succ_iff_ne_top.2 ha)
Theorem: Ordnode.eraseMax.valid
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : t.Valid
⊢ t.eraseMax.Valid
state_after: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : t.Valid
⊢ t.dual.eraseMin.Valid
tactic: rw [Valid.dual_iff, dual_eraseMax]
state_before: α : Type u_1
inst✝ : Preorder α
t : Ordnode α
h : t.Valid
⊢ t.dual.eraseMin.Valid
state_after: no goals
tactic: exact eraseMin.valid h.dual
Theorem: UniformFun.iInf_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ uniformSpace α γ = ⨅ i, uniformSpace α γ
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ 𝓤 (α →ᵤ γ) = 𝓤 (α →ᵤ γ)
tactic: ext : 1
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ 𝓤 (α →ᵤ γ) = 𝓤 (α →ᵤ γ)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (𝓤 γ) = 𝓤 (α →ᵤ γ)
tactic: change UniformFun.filter α γ 𝓤[⨅ i, u i] = 𝓤[⨅ i, 𝒰(α, γ, u i)]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (𝓤 γ) = 𝓤 (α →ᵤ γ)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (⨅ i, 𝓤 γ) = ⨅ i, 𝓤 (α →ᵤ γ)
tactic: rw [iInf_uniformity, iInf_uniformity]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u : ι → UniformSpace γ
⊢ UniformFun.filter α γ (⨅ i, 𝓤 γ) = ⨅ i, 𝓤 (α →ᵤ γ)
state_after: no goals
tactic: exact (UniformFun.gc α γ).u_iInf
Theorem: one_div_mul_one_div_rev
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ 1 / a * (1 / b) = 1 / (b * a)
state_after: no goals
tactic: simp
Theorem: IsUnramifiedAtInfinitePlaces.bot
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Algebra k K
inst✝³ : Algebra k F
inst✝² : Algebra K F
inst✝¹ : IsScalarTower k K F
h₁ : IsUnramifiedAtInfinitePlaces k F
inst✝ : Algebra.IsAlgebraic K F
w : InfinitePlace K
⊢ InfinitePlace.IsUnramified k w
state_after: case intro
k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Algebra k K
inst✝³ : Algebra k F
inst✝² : Algebra K F
inst✝¹ : IsScalarTower k K F
h₁ : IsUnramifiedAtInfinitePlaces k F
inst✝ : Algebra.IsAlgebraic K F
w : InfinitePlace F
⊢ InfinitePlace.IsUnramified k ((fun x => x.comap (algebraMap K F)) w)
tactic: obtain ⟨w, rfl⟩ := InfinitePlace.comap_surjective (K := F) w
state_before: case intro
k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Algebra k K
inst✝³ : Algebra k F
inst✝² : Algebra K F
inst✝¹ : IsScalarTower k K F
h₁ : IsUnramifiedAtInfinitePlaces k F
inst✝ : Algebra.IsAlgebraic K F
w : InfinitePlace F
⊢ InfinitePlace.IsUnramified k ((fun x => x.comap (algebraMap K F)) w)
state_after: no goals
tactic: exact (h₁.1 w).comap K
Theorem: Int.bodd_add
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: m n : ℤ
⊢ (m + n).bodd = xor m.bodd n.bodd
state_after: case negSucc.negSucc
m n : ℕ
⊢ ((m + n).succ + 1).bodd = (m + 1 + (n + 1)).bodd
tactic: cases' m with m m <;>
  cases' n with n n <;>
  simp only [ofNat_eq_coe, ofNat_add_negSucc, negSucc_add_ofNat,
             negSucc_add_negSucc, bodd_subNatNat] <;>
  simp only [negSucc_coe, bodd_neg, bodd_coe, ← Nat.bodd_add, Bool.xor_comm, ← Nat.cast_add]
state_before: case negSucc.negSucc
m n : ℕ
⊢ ((m + n).succ + 1).bodd = (m + 1 + (n + 1)).bodd
state_after: no goals
tactic: rw [← Nat.succ_add, add_assoc]
Theorem: CategoryTheory.coyonedaEquiv_coyoneda_map
File: Mathlib/CategoryTheory/Yoneda.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
⊢ coyonedaEquiv (coyoneda.map f.op) = f
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
⊢ (coyoneda.map f.op).app Y (𝟙 Y) = f
tactic: rw [coyonedaEquiv_apply]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
⊢ (coyoneda.map f.op).app Y (𝟙 Y) = f
state_after: no goals
tactic: simp
Theorem: CategoryTheory.algebraEquivUnder_functor
File: Mathlib/CategoryTheory/Monad/Products.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryCoproducts C
A : (coprodMonad X).Algebra
⊢ coprod.inl ≫
      (coprodMonad X).map (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom ≫
        ((algebraToUnder X ⋙ underToAlgebra X).obj A).a =
    coprod.inl ≫ ((𝟭 (coprodMonad X).Algebra).obj A).a ≫ (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryCoproducts C
A : (coprodMonad X).Algebra
⊢ coprod.inr ≫
      (coprodMonad X).map (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom ≫
        ((algebraToUnder X ⋙ underToAlgebra X).obj A).a =
    coprod.inr ≫ ((𝟭 (coprodMonad X).Algebra).obj A).a ≫ (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom
state_after: no goals
tactic: simpa using A.unit.symm
Theorem: Hyperreal.gt_of_tendsto_zero_of_neg
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ ↑r < ofSeq f
state_after: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ -↑(-r) < ofSeq f
tactic: rw [← neg_neg r, coe_neg]
state_before: f : ℕ → ℝ
hf : Tendsto f atTop (𝓝 0)
r : ℝ
hr : r < 0
⊢ -↑(-r) < ofSeq f
state_after: no goals
tactic: exact neg_lt_of_tendsto_zero_of_pos hf (neg_pos.mpr hr)
Theorem: Finset.product_sdiff_offDiag
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
⊢ s ×ˢ s \ s.offDiag = s.diag
state_after: no goals
tactic: rw [← diag_union_offDiag, union_sdiff_self, sdiff_eq_self_of_disjoint (disjoint_diag_offDiag _)]
Theorem: RingQuot.Rel.smul
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝³ : Semiring R
S : Type uS
inst✝² : CommSemiring S
T : Type uT
A : Type uA
inst✝¹ : Semiring A
inst✝ : Algebra S A
r : A → A → Prop
k : S
a b : A
h : Rel r a b
⊢ Rel r (k • a) (k • b)
state_after: no goals
tactic: simp only [Algebra.smul_def, Rel.mul_right h]
Theorem: mul_sub_right_distrib
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonUnitalNonAssocRing α
a b c : α
⊢ (a - b) * c = a * c - b * c
state_after: no goals
tactic: simpa only [sub_eq_add_neg, neg_mul_eq_neg_mul] using add_mul a (-b) c
Theorem: Multiset.disjoint_ndinsert_left
File: Mathlib/Data/Multiset/FinsetOps.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
⊢ (ndinsert a s).Disjoint t ↔ (a ::ₘ s).Disjoint t
state_after: no goals
tactic: simp [Disjoint]
Theorem: Complex.eqOn_of_isPreconnected_of_isMaxOn_norm
File: Mathlib/Analysis/Complex/AbsMax.lean

Proof steps:
state_before: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : StrictConvexSpace ℝ F
f : E → F
U : Set E
c : E
hc : IsPreconnected U
ho : IsOpen U
hd : DifferentiableOn ℂ f U
hcU : c ∈ U
hm : IsMaxOn (norm ∘ f) U c
x : E
hx : x ∈ U
H₁ : ‖f x‖ = ‖f c‖
H₂ : ‖f x + f c‖ = ‖f c + f c‖
⊢ ‖f x + Function.const E (f c) x‖ = ‖f x‖ + ‖Function.const E (f c) x‖
state_after: no goals
tactic: simp only [H₂, SameRay.rfl.norm_add, H₁, Function.const]
Theorem: tendsto_sum_nat_add
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
f : ℕ → G
⊢ Tendsto (fun i => ∏' (k : ℕ), f (k + i)) atTop (𝓝 1)
state_after: case pos
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
f : ℕ → G
hf : Multipliable f
⊢ Tendsto (fun i => ∏' (k : ℕ), f (k + i)) atTop (𝓝 1)

case neg
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalGroup G
inst✝ : T2Space G
f : ℕ → G
hf : ¬Multipliable f
⊢ Tendsto (fun i => ∏' (k : ℕ), f (k + i)) atTop (𝓝 1)
tactic: by_cases hf : Multipliable f
Theorem: TangentBundle.symmL_model_space
File: Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
b b' : F
⊢ Trivialization.symmL 𝕜 (trivializationAt F (TangentSpace 𝓘(𝕜, F)) b) b' = 1
state_after: case hb
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
b b' : F
⊢ b' ∈ (trivializationAt F (TangentSpace 𝓘(𝕜, F)) b).baseSet
tactic: rw [TangentBundle.trivializationAt_symmL, coordChange_model_space]
state_before: case hb
𝕜 : Type u_1
inst✝¹⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹³ : NormedAddCommGroup E
inst✝¹² : NormedSpace 𝕜 E
E' : Type u_3
inst✝¹¹ : NormedAddCommGroup E'
inst✝¹⁰ : NormedSpace 𝕜 E'
H : Type u_4
inst✝⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
H' : Type u_5
inst✝⁸ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M : Type u_6
inst✝⁷ : TopologicalSpace M
inst✝⁶ : ChartedSpace H M
inst✝⁵ : SmoothManifoldWithCorners I M
M' : Type u_7
inst✝⁴ : TopologicalSpace M'
inst✝³ : ChartedSpace H' M'
inst✝² : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
b b' : F
⊢ b' ∈ (trivializationAt F (TangentSpace 𝓘(𝕜, F)) b).baseSet
state_after: no goals
tactic: apply mem_univ
Theorem: NNRat.cast_commute
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionSemiring α
q✝ r q : ℚ≥0
a : α
⊢ Commute (↑q) a
state_after: no goals
tactic: simpa only [cast_def] using (q.num.cast_commute a).div_left (q.den.cast_commute a)
Theorem: MeasureTheory.eLpNorm_one_smul_measure
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
c : ℝ≥0∞
⊢ eLpNorm f 1 (c • μ) = c * eLpNorm f 1 μ
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
c : ℝ≥0∞
⊢ c ^ (1 / 1).toReal • eLpNorm f 1 μ = c * eLpNorm f 1 μ
tactic: rw [@eLpNorm_smul_measure_of_ne_top _ _ _ μ _ 1 (@ENNReal.coe_ne_top 1) f c]
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
c : ℝ≥0∞
⊢ c ^ (1 / 1).toReal • eLpNorm f 1 μ = c * eLpNorm f 1 μ
state_after: no goals
tactic: simp
Theorem: PadicInt.mem_span_pow_iff_le_valuation
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ x ∈ Ideal.span {↑p ^ n} ↔ ↑n ≤ x.valuation
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ n ∣ x ↔ ↑n ≤ x.valuation
tactic: rw [Ideal.mem_span_singleton]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ n ∣ x ↔ ↑n ≤ x.valuation
state_after: case mp
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑p ^ n ∣ x → ↑n ≤ x.valuation

case mpr
p : ℕ
hp : Fact (Nat.Prime p)
x : ℤ_[p]
hx : x ≠ 0
n : ℕ
⊢ ↑n ≤ x.valuation → ↑p ^ n ∣ x
tactic: constructor
Theorem: Matrix.isUnit_transpose
File: Mathlib/Data/Matrix/Invertible.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
α : Type u_3
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommSemiring α
A : Matrix n n α
⊢ IsUnit Aᵀ ↔ IsUnit A
state_after: no goals
tactic: simp only [← nonempty_invertible_iff_isUnit,
    (transposeInvertibleEquivInvertible A).nonempty_congr]
Theorem: Finset.prod_equiv
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι✝ : Type u_1
κ✝ : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α✝
a : α✝
f✝ g✝ : α✝ → β
inst✝¹ : CommMonoid β
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝ : CommMonoid α
s : Finset ι
t : Finset κ
f : ι → α
g : κ → α
e : ι ≃ κ
hst : ∀ (i : ι), i ∈ s ↔ e i ∈ t
hfg : ∀ i ∈ s, f i = g (e i)
⊢ ∏ i ∈ s, f i = ∏ i ∈ t, g i
state_after: no goals
tactic: refine prod_nbij' e e.symm ?_ ?_ ?_ ?_ hfg <;> simp [hst]
Theorem: Nat.floor_le_ceil
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
⊢ ⌊a⌋₊ ≤ ⌈a⌉₊
state_after: case inl
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : a ≤ 0
⊢ ⌊a⌋₊ ≤ ⌈a⌉₊

case inr
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a : α
ha : 0 ≤ a
⊢ ⌊a⌋₊ ≤ ⌈a⌉₊
tactic: obtain ha | ha := le_total a 0
Theorem: CategoryTheory.Bicategory.leftUnitor_comp
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (λ_ (f ≫ g)).hom = (α_ (𝟙 a) f g).inv ≫ (λ_ f).hom ▷ g
state_after: no goals
tactic: simp
Theorem: Cardinal.prime_of_aleph0_le
File: Mathlib/SetTheory/Cardinal/Divisibility.lean

Proof steps:
state_before: a b : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
⊢ Prime a
state_after: case refine_1
a b : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
⊢ ¬IsUnit a

case refine_2
a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
⊢ a ∣ b ∨ a ∣ c
tactic: refine ⟨(aleph0_pos.trans_le ha).ne', ?_, fun b c hbc => ?_⟩
state_before: case refine_2
a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
⊢ a ∣ b ∨ a ∣ c
state_after: case refine_2.inl
a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c = 0
⊢ a ∣ b ∨ a ∣ c

case refine_2.inr
a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
⊢ a ∣ b ∨ a ∣ c
tactic: rcases eq_or_ne (b * c) 0 with hz | hz
state_before: case refine_2.inr
a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
⊢ a ∣ b ∨ a ∣ c
state_after: case refine_2.inr.inr
a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
this :
  ∀ {a : Cardinal.{u}} {b : Cardinal.{u}} {n m : ℕ},
    ℵ₀ ≤ a → ∀ (b c : Cardinal.{u}), a ∣ b * c → b * c ≠ 0 → c ≤ b → a ∣ b ∨ a ∣ c
h : ¬c ≤ b
⊢ a ∣ b ∨ a ∣ c

a✝ a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
h : c ≤ b
⊢ a ∣ b ∨ a ∣ c
tactic: wlog h : c ≤ b
state_before: a✝ a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
h : c ≤ b
⊢ a ∣ b ∨ a ∣ c
state_after: case h
a✝ a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
h : c ≤ b
⊢ a ∣ b
tactic: left
state_before: case h
a✝ a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
h : c ≤ b
⊢ a ∣ b
state_after: case h
a✝ a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
h : c ≤ b
habc : a ≤ b * c
⊢ a ∣ b
tactic: have habc := le_of_dvd hz hbc
state_before: case h
a✝ a b✝ : Cardinal.{u}
n m : ℕ
ha : ℵ₀ ≤ a
b c : Cardinal.{u}
hbc : a ∣ b * c
hz : b * c ≠ 0
h : c ≤ b
habc : a ≤ b * c
⊢ a ∣ b
state_after: no goals
tactic: rwa [mul_eq_max' <| ha.trans <| habc, max_def', if_pos h] at hbc
Theorem: min_lt_min_right_iff
File: Mathlib/Order/MinMax.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
⊢ min a b < min a c ↔ b < c ∧ b < a
state_after: no goals
tactic: simp_rw [min_comm a, min_lt_min_left_iff]
Theorem: Denumerable.lower_raise'
File: Mathlib/Logic/Equiv/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Denumerable α
inst✝ : Denumerable β
m : ℕ
l : List ℕ
n : ℕ
⊢ lower' (raise' (m :: l) n) n = m :: l
state_after: no goals
tactic: simp [raise', lower', add_tsub_cancel_right, lower_raise']
Theorem: Finsupp.support_nonempty_iff
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
f : α →₀ M
⊢ f.support.Nonempty ↔ f ≠ 0
state_after: no goals
tactic: simp only [Finsupp.support_eq_empty, Finset.nonempty_iff_ne_empty, Ne]
Theorem: CategoryTheory.CostructuredArrow.toStructuredArrow_map
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ ((fun X => StructuredArrow.mk (unop X).hom.op) X✝).hom ≫ F.op.map f.unop.left.op =
    ((fun X => StructuredArrow.mk (unop X).hom.op) Y✝).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (unop X✝).hom.op ≫ (F.map f.unop.left).op = (unop Y✝).hom.op
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (unop X✝).hom.op ≫ (F.map f.unop.left).op = (unop Y✝).hom.op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ ((unop Y✝).hom ≫ 𝟙 d).op = (unop Y✝).hom.op
tactic: rw [← op_comp, f.unop.w, Functor.const_obj_map]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ ((unop Y✝).hom ≫ 𝟙 d).op = (unop Y✝).hom.op
state_after: no goals
tactic: erw [Category.comp_id]
Theorem: Fin.one_succAbove_zero
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m : ℕ
p : Fin (n✝ + 1)
i j : Fin n✝
n : ℕ
⊢ succAbove 1 0 = 0
state_after: no goals
tactic: rfl
Theorem: NNRat.den_mul_eq_num
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: p q✝ : ℚ≥0
n₁ n₂ d₁ d₂ d : ℕ
q : ℚ≥0
⊢ ↑q.den * q = ↑q.num
state_after: no goals
tactic: rw [mul_comm, mul_den_eq_num]
Theorem: CategoryTheory.MonoidalCategory.rightUnitor_inv_naturality
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y Z X X' : C
f : X ⟶ X'
⊢ f ≫ (ρ_ X').inv = (ρ_ X).inv ≫ f ▷ 𝟙_ C
state_after: no goals
tactic: simp