ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Basis.toMatrix_smul
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
R₁ : Type u_9
S : Type u_10
inst✝⁴ : CommRing R₁
inst✝³ : Ring S
inst✝² : Algebra R₁ S
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
x : S
b : Basis ι R₁ S
w : ι → S
⊢ b.toMatrix (x • w) = (Algebra.leftMulMatrix b) x * b.toMatrix w
state_after: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
R₁ : Type u_9
S : Type u_10
inst✝⁴ : CommRing R₁
inst✝³ : Ring S
inst✝² : Algebra R₁ S
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
x : S
b : Basis ι R₁ S
w : ι → S
i✝ j✝ : ι
⊢ b.toMatrix (x • w) i✝ j✝ = ((Algebra.leftMulMatrix b) x * b.toMatrix w) i✝ j✝
tactic: ext
state_before: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
R₁ : Type u_9
S : Type u_10
inst✝⁴ : CommRing R₁
inst✝³ : Ring S
inst✝² : Algebra R₁ S
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
x : S
b : Basis ι R₁ S
w : ι → S
i✝ j✝ : ι
⊢ b.toMatrix (x • w) i✝ j✝ = ((Algebra.leftMulMatrix b) x * b.toMatrix w) i✝ j✝
state_after: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
R₁ : Type u_9
S : Type u_10
inst✝⁴ : CommRing R₁
inst✝³ : Ring S
inst✝² : Algebra R₁ S
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
x : S
b : Basis ι R₁ S
w : ι → S
i✝ j✝ : ι
⊢ ((Algebra.leftMulMatrix b) x *ᵥ ⇑(b.repr (w j✝))) i✝ = ((Algebra.leftMulMatrix b) x * b.toMatrix w) i✝ j✝
tactic: rw [Basis.toMatrix_apply, Pi.smul_apply, smul_eq_mul, ← Algebra.leftMulMatrix_mulVec_repr]
state_before: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝¹⁰ : CommSemiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M₂
inst✝⁵ : Module R₂ M₂
e : Basis ι R M
v : ι' → M
i : ι
j : ι'
R₁ : Type u_9
S : Type u_10
inst✝⁴ : CommRing R₁
inst✝³ : Ring S
inst✝² : Algebra R₁ S
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
x : S
b : Basis ι R₁ S
w : ι → S
i✝ j✝ : ι
⊢ ((Algebra.leftMulMatrix b) x *ᵥ ⇑(b.repr (w j✝))) i✝ = ((Algebra.leftMulMatrix b) x * b.toMatrix w) i✝ j✝
state_after: no goals
tactic: rfl
Theorem: AlgebraicGeometry.PresheafedSpace.GlueData.snd_invApp_t_app'
File: Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
⊢ ∃ (eq :
    (Opens.map (D.t k i).base).op.obj (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
      op
        ((opensFunctor (pullback.fst (D.f k i) (D.f k j))).obj
          (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ })))),
    invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
        (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
          (D.V (k, i)).presheaf.map (eqToHom eq) =
      (D.t' k i j).c.app (op U) ≫
        invApp (pullback.fst (D.f k i) (D.f k j))
          (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ }))
state_after: case w
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
⊢ (Opens.map (D.t k i).base).op.obj (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    op
      ((opensFunctor (pullback.fst (D.f k i) (D.f k j))).obj
        (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ })))

case h
C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
⊢ invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
        (D.V (k, i)).presheaf.map (eqToHom ?w) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
        (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ }))
tactic: fconstructor
Theorem: LinearMap.ker_comp_eq_of_commute_of_disjoint_ker
File: Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
h : Commute f g
h' : Disjoint (ker f) (ker g)
⊢ ker (f ∘ₗ g) = ker f ⊔ ker g
state_after: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
h : Commute f g
h' : Disjoint (ker f) (ker g)
⊢ ∀ (x : V), f x = 0 → f (g x) = 0
tactic: suffices ∀ x, f x = 0 → f (g x) = 0 by rw [ker_comp, comap_eq_sup_ker_of_disjoint _ h']; simpa
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
h : Commute f g
h' : Disjoint (ker f) (ker g)
⊢ ∀ (x : V), f x = 0 → f (g x) = 0
state_after: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
h : Commute f g
h' : Disjoint (ker f) (ker g)
x : V
hx : f x = 0
⊢ f (g x) = 0
tactic: intro x hx
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f g : V →ₗ[K] V
h : Commute f g
h' : Disjoint (ker f) (ker g)
x : V
hx : f x = 0
⊢ f (g x) = 0
state_after: no goals
tactic: rw [← comp_apply, ← mul_eq_comp, h.eq, mul_apply, hx, _root_.map_zero]
Theorem: MeasureTheory.UnifIntegrable.sub
File: Mathlib/MeasureTheory/Function/UniformIntegrable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hg : UnifIntegrable g p μ
hp : 1 ≤ p
hf_meas : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hg_meas : ∀ (i : ι), AEStronglyMeasurable (g i) μ
⊢ UnifIntegrable (f - g) p μ
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hg : UnifIntegrable g p μ
hp : 1 ≤ p
hf_meas : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hg_meas : ∀ (i : ι), AEStronglyMeasurable (g i) μ
⊢ UnifIntegrable (f + -g) p μ
tactic: rw [sub_eq_add_neg]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝ : NormedAddCommGroup β
f g : ι → α → β
p : ℝ≥0∞
hf : UnifIntegrable f p μ
hg : UnifIntegrable g p μ
hp : 1 ≤ p
hf_meas : ∀ (i : ι), AEStronglyMeasurable (f i) μ
hg_meas : ∀ (i : ι), AEStronglyMeasurable (g i) μ
⊢ UnifIntegrable (f + -g) p μ
state_after: no goals
tactic: exact hf.add hg.neg hp hf_meas fun i => (hg_meas i).neg
Theorem: BoxIntegral.Box.splitLower_ne_splitUpper
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
⊢ I.splitLower i x ≠ I.splitUpper i x
state_after: case inl
ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
h : x ≤ I.lower i
⊢ I.splitLower i x ≠ I.splitUpper i x

case inr
ι : Type u_1
M : Type u_2
n : ℕ
I✝ : Box ι
i✝ : ι
x✝ : ℝ
y : ι → ℝ
I : Box ι
i : ι
x : ℝ
h✝ : I.lower i < x
⊢ I.splitLower i x ≠ I.splitUpper i x
tactic: cases' le_or_lt x (I.lower i) with h
Theorem: Subspace.dualRestrict_leftInverse
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
x : Module.Dual K ↥W
⊢ (dualRestrict W ∘ₗ W.dualLift) x = x
state_after: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
x : Module.Dual K ↥W
⊢ 1 x = x
tactic: rw [dualRestrict_comp_dualLift]
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W✝ W : Subspace K V
x : Module.Dual K ↥W
⊢ 1 x = x
state_after: no goals
tactic: rfl
Theorem: IsKleinFour.inv_eq_self
File: Mathlib/GroupTheory/SpecificGroups/KleinFour.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
inst✝ : IsKleinFour G
x : G
⊢ Monoid.exponent G = 2
state_after: no goals
tactic: simp
Theorem: DirectedOn.insert
File: Mathlib/Order/Directed.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
a : α
s : Set α
hd : DirectedOn r s
ha : ∀ b ∈ s, ∃ c ∈ s, r a c ∧ r b c
⊢ DirectedOn r (insert a s)
state_after: case inl.inl
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
y : α
ha : ∀ b ∈ s, ∃ c ∈ s, r y c ∧ r b c
⊢ ∃ z ∈ insert y s, r y z ∧ r y z

case inl.inr
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
x : α
ha : ∀ b ∈ s, ∃ c ∈ s, r x c ∧ r b c
y : α
hy : y ∈ s
⊢ ∃ z ∈ insert x s, r x z ∧ r y z

case inr.inl
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
s : Set α
hd : DirectedOn r s
x : α
hx : x ∈ s
y : α
ha : ∀ b ∈ s, ∃ c ∈ s, r y c ∧ r b c
⊢ ∃ z ∈ insert y s, r x z ∧ r y z

case inr.inr
α : Type u
β : Type v
ι : Sort w
r r' s✝ : α → α → Prop
h : Reflexive r
a : α
s : Set α
hd : DirectedOn r s
ha : ∀ b ∈ s, ∃ c ∈ s, r a c ∧ r b c
x : α
hx : x ∈ s
y : α
hy : y ∈ s
⊢ ∃ z ∈ insert a s, r x z ∧ r y z
tactic: rintro x (rfl | hx) y (rfl | hy)
Theorem: contDiff_clm_apply_iff
File: Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
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
inst✝¹ : CompleteSpace 𝕜
n : ℕ∞
f : E → F →L[𝕜] G
inst✝ : FiniteDimensional 𝕜 F
⊢ ContDiff 𝕜 n f ↔ ∀ (y : F), ContDiff 𝕜 n fun x => (f x) y
state_after: no goals
tactic: simp_rw [← contDiffOn_univ, contDiffOn_clm_apply]
Theorem: Matrix.dotProduct_self_star_eq_zero
File: Mathlib/LinearAlgebra/Matrix/DotProduct.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
p : Type u_3
R : Type u_4
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : Fintype p
inst✝⁴ : PartialOrder R
inst✝³ : NonUnitalRing R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : NoZeroDivisors R
v : n → R
⊢ (∀ i ∈ Finset.univ, v i * star (v i) = 0) ↔ v = 0
state_after: no goals
tactic: simp [Function.funext_iff, mul_eq_zero]
Theorem: LipschitzWith.ae_differentiableAt
File: Mathlib/Analysis/Calculus/Rademacher.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f✝ g : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
f : E → F
h : LipschitzWith C f
⊢ ∀ᵐ (x : E) ∂μ, DifferentiableAt ℝ f x
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f✝ g : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
f : E → F
h : LipschitzOnWith C f univ
⊢ ∀ᵐ (x : E) ∂μ, DifferentiableAt ℝ f x
tactic: rw [← lipschitzOnWith_univ] at h
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : FiniteDimensional ℝ E
inst✝⁵ : MeasurableSpace E
inst✝⁴ : BorelSpace E
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
C D : ℝ≥0
f✝ g : E → ℝ
s : Set E
μ : Measure E
inst✝¹ : μ.IsAddHaarMeasure
inst✝ : FiniteDimensional ℝ F
f : E → F
h : LipschitzOnWith C f univ
⊢ ∀ᵐ (x : E) ∂μ, DifferentiableAt ℝ f x
state_after: no goals
tactic: simpa [differentiableWithinAt_univ] using h.ae_differentiableWithinAt_of_mem
Theorem: AddConstMapClass.map_const_add
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddCommSemigroup G
inst✝¹ : Add H
inst✝ : AddConstMapClass F G H a b
f : F
x : G
⊢ f (a + x) = f x + b
state_after: no goals
tactic: rw [add_comm, map_add_const]
Theorem: Finset.lcm_congr
File: Mathlib/Algebra/GCDMonoid/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f✝ f g : β → α
hs : s₁ = s₂
hfg : ∀ a ∈ s₂, f a = g a
⊢ s₁.lcm f = s₂.lcm g
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ : Finset β
f✝ f g : β → α
hfg : ∀ a ∈ s₁, f a = g a
⊢ s₁.lcm f = s₁.lcm g
tactic: subst hs
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ : Finset β
f✝ f g : β → α
hfg : ∀ a ∈ s₁, f a = g a
⊢ s₁.lcm f = s₁.lcm g
state_after: no goals
tactic: exact Finset.fold_congr hfg
Theorem: WeierstrassCurve.φ_three
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.φ 3 = C X * C W.Ψ₃ ^ 2 - C W.preΨ₄ * W.ψ₂ ^ 2
state_after: no goals
tactic: erw [φ, ψ_three, ψ_four, mul_assoc, ψ_two, ← sq]
Theorem: MeasureTheory.Lp.ext
File: Mathlib/MeasureTheory/Function/LpSpace.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 g : ↥(Lp E p μ)
h : ↑↑f =ᶠ[ae μ] ↑↑g
⊢ f = g
state_after: case mk
α : 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
g : ↥(Lp E p μ)
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
h : ↑↑⟨val✝, property✝⟩ =ᶠ[ae μ] ↑↑g
⊢ ⟨val✝, property✝⟩ = g
tactic: cases f
state_before: case mk
α : 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
g : ↥(Lp E p μ)
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
h : ↑↑⟨val✝, property✝⟩ =ᶠ[ae μ] ↑↑g
⊢ ⟨val✝, property✝⟩ = g
state_after: case mk.mk
α : 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
val✝¹ : α →ₘ[μ] E
property✝¹ : val✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
h : ↑↑⟨val✝¹, property✝¹⟩ =ᶠ[ae μ] ↑↑⟨val✝, property✝⟩
⊢ ⟨val✝¹, property✝¹⟩ = ⟨val✝, property✝⟩
tactic: cases g
state_before: case mk.mk
α : 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
val✝¹ : α →ₘ[μ] E
property✝¹ : val✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
h : ↑↑⟨val✝¹, property✝¹⟩ =ᶠ[ae μ] ↑↑⟨val✝, property✝⟩
⊢ ⟨val✝¹, property✝¹⟩ = ⟨val✝, property✝⟩
state_after: case mk.mk
α : 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
val✝¹ : α →ₘ[μ] E
property✝¹ : val✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
h : ↑↑⟨val✝¹, property✝¹⟩ =ᶠ[ae μ] ↑↑⟨val✝, property✝⟩
⊢ val✝¹ = val✝
tactic: simp only [Subtype.mk_eq_mk]
state_before: case mk.mk
α : 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
val✝¹ : α →ₘ[μ] E
property✝¹ : val✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
property✝ : val✝ ∈ Lp E p μ
h : ↑↑⟨val✝¹, property✝¹⟩ =ᶠ[ae μ] ↑↑⟨val✝, property✝⟩
⊢ val✝¹ = val✝
state_after: no goals
tactic: exact AEEqFun.ext h
Theorem: Matrix.trace_eq_neg_charpoly_coeff
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M✝ : Matrix n n R
inst✝ : Nonempty n
M : Matrix n n R
⊢ M.trace = -M.charpoly.coeff (Fintype.card n - 1)
state_after: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M✝ : Matrix n n R
inst✝ : Nonempty n
M : Matrix n n R
⊢ ∑ i : n, M.diag i = ∑ i : n, M i i
tactic: rw [charpoly_coeff_eq_prod_coeff_of_le _ le_rfl, Fintype.card,
    prod_X_sub_C_coeff_card_pred univ (fun i : n => M i i) Fintype.card_pos, neg_neg, trace]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M✝ : Matrix n n R
inst✝ : Nonempty n
M : Matrix n n R
⊢ ∑ i : n, M.diag i = ∑ i : n, M i i
state_after: no goals
tactic: simp_rw [diag_apply]
Theorem: WithTop.sInf_empty
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : Preorder α
inst✝ : InfSet α
⊢ ∅ ⊆ {⊤} ∨ ¬BddBelow ∅
state_after: no goals
tactic: simp
Theorem: Set.preimage_const_mul_Ioc_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => c * x) ⁻¹' Ioc a b = Ico (b / c) (a / c)
state_after: no goals
tactic: simpa only [mul_comm] using preimage_mul_const_Ioc_of_neg a b h
Theorem: CategoryTheory.Limits.imageSubobjectIso_comp_image_map
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
inst✝³ : HasImage f✝
W X Y Z : C
f : W ⟶ X
inst✝² : HasImage f
g : Y ⟶ Z
inst✝¹ : HasImage g
sq : Arrow.mk f ⟶ Arrow.mk g
inst✝ : HasImageMap sq
⊢ (imageSubobjectIso (Arrow.mk f).hom).hom ≫ image.map sq = imageSubobjectMap sq ≫ (imageSubobjectIso g).hom
state_after: no goals
tactic: erw [← Iso.comp_inv_eq, Category.assoc, ← (imageSubobjectIso f).eq_inv_comp,
    image_map_comp_imageSubobjectIso_inv sq]
Theorem: Part.some_add_some
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mul α
a b : α
⊢ some a * some b = some (a * b)
state_after: no goals
tactic: simp [mul_def]
Theorem: Cardinal.toPartENat_natCast
File: Mathlib/SetTheory/Cardinal/PartENat.lean

Proof steps:
state_before: α : Type u
n : ℕ
⊢ toPartENat ↑n = ↑n
state_after: no goals
tactic: simp only [← partENatOfENat_toENat, toENat_nat, PartENat.ofENat_coe]
Theorem: Orientation.kahler_rotation_left'
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
θ : Real.Angle
⊢ (o.kahler ((o.rotation θ) x)) y = ↑(-θ).expMapCircle * (o.kahler x) y
state_after: no goals
tactic: simp only [Real.Angle.expMapCircle_neg, coe_inv_circle_eq_conj, kahler_rotation_left]
Theorem: Nat.factorization_choose_le_one
File: Mathlib/Data/Nat/Choose/Factorization.lean

Proof steps:
state_before: p n k : ℕ
p_large : n < p ^ 2
⊢ (n.choose k).factorization p ≤ 1
state_after: p n k : ℕ
p_large : n < p ^ 2
⊢ log p n ≤ 1
tactic: apply factorization_choose_le_log.trans
state_before: p n k : ℕ
p_large : n < p ^ 2
⊢ log p n ≤ 1
state_after: case inl
p k : ℕ
p_large : 0 < p ^ 2
⊢ log p 0 ≤ 1

case inr
p n k : ℕ
p_large : n < p ^ 2
hn0 : n ≠ 0
⊢ log p n ≤ 1
tactic: rcases eq_or_ne n 0 with (rfl | hn0)
state_before: case inr
p n k : ℕ
p_large : n < p ^ 2
hn0 : n ≠ 0
⊢ log p n ≤ 1
state_after: no goals
tactic: exact Nat.lt_succ_iff.1 (log_lt_of_lt_pow hn0 p_large)
Theorem: CategoryTheory.GrothendieckTopology.W_whiskerLeft_iff
File: Mathlib/CategoryTheory/Sites/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝⁹ : Category.{v₂, u₂} D
K : GrothendieckTopology D
e : C ≌ D
G : D ⥤ C
A : Type u₃
inst✝⁸ : Category.{v₃, u₃} A
inst✝⁷ : EssentiallySmall.{w, v₁, u₁} C
B : Type u_1
inst✝⁶ : Category.{?u.110647, u_1} B
F : A ⥤ B
inst✝⁵ : HasSheafify ((equivSmallModel C).inverse.inducedTopology J) A
inst✝⁴ : ((equivSmallModel C).inverse.inducedTopology J).HasSheafCompose F
inst✝³ : G.IsCoverDense J
inst✝² : G.IsContinuous K J
inst✝¹ : G.Full
inst✝ : (G.sheafPushforwardContinuous A K J).EssSurj
P Q : Cᵒᵖ ⥤ A
f : P ⟶ Q
⊢ K.W (whiskerLeft G.op f) ↔ J.W f
state_after: C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝⁹ : Category.{v₂, u₂} D
K : GrothendieckTopology D
e : C ≌ D
G : D ⥤ C
A : Type u₃
inst✝⁸ : Category.{v₃, u₃} A
inst✝⁷ : EssentiallySmall.{w, v₁, u₁} C
B : Type u_1
inst✝⁶ : Category.{?u.110647, u_1} B
F : A ⥤ B
inst✝⁵ : HasSheafify ((equivSmallModel C).inverse.inducedTopology J) A
inst✝⁴ : ((equivSmallModel C).inverse.inducedTopology J).HasSheafCompose F
inst✝³ : G.IsCoverDense J
inst✝² : G.IsContinuous K J
inst✝¹ : G.Full
inst✝ : (G.sheafPushforwardContinuous A K J).EssSurj
P Q : Cᵒᵖ ⥤ A
f : P ⟶ Q
⊢ K.W (whiskerLeft G.op f) ↔ K.W.inverseImage ((whiskeringLeft Dᵒᵖ Cᵒᵖ A).obj G.op) f
tactic: rw [← W_inverseImage_whiskeringLeft J K G]
state_before: C : Type u₁
inst✝¹⁰ : Category.{v₁, u₁} C
J : GrothendieckTopology C
D : Type u₂
inst✝⁹ : Category.{v₂, u₂} D
K : GrothendieckTopology D
e : C ≌ D
G : D ⥤ C
A : Type u₃
inst✝⁸ : Category.{v₃, u₃} A
inst✝⁷ : EssentiallySmall.{w, v₁, u₁} C
B : Type u_1
inst✝⁶ : Category.{?u.110647, u_1} B
F : A ⥤ B
inst✝⁵ : HasSheafify ((equivSmallModel C).inverse.inducedTopology J) A
inst✝⁴ : ((equivSmallModel C).inverse.inducedTopology J).HasSheafCompose F
inst✝³ : G.IsCoverDense J
inst✝² : G.IsContinuous K J
inst✝¹ : G.Full
inst✝ : (G.sheafPushforwardContinuous A K J).EssSurj
P Q : Cᵒᵖ ⥤ A
f : P ⟶ Q
⊢ K.W (whiskerLeft G.op f) ↔ K.W.inverseImage ((whiskeringLeft Dᵒᵖ Cᵒᵖ A).obj G.op) f
state_after: no goals
tactic: rfl
Theorem: Relation.comp_iff
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r✝ : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
r : α → Prop → Prop
this : (fun x x_1 => x ↔ x_1) = fun x x_1 => x = x_1
⊢ (r ∘r fun x x_1 => x ↔ x_1) = r
state_after: no goals
tactic: rw [this, comp_eq]