ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Algebra.fg_trans'
File: Mathlib/RingTheory/Adjoin/Tower.lean

Proof steps:
state_before: R✝ : Type u
S✝ : Type v
A✝ : Type w
B : Type u₁
R : Type u_1
S : Type u_2
A : Type u_3
inst✝⁶ : CommSemiring R
inst✝⁵ : CommSemiring S
inst✝⁴ : Semiring A
inst✝³ : Algebra R S
inst✝² : Algebra S A
inst✝¹ : Algebra R A
inst✝ : IsScalarTower R S A
hRS : ⊤.FG
hSA : ⊤.FG
s : Finset S
hs : adjoin R ↑s = ⊤
t : Finset A
ht : adjoin S ↑t = ⊤
⊢ adjoin R ↑(Finset.image (⇑(algebraMap S A)) s ∪ t) = ⊤
state_after: no goals
tactic: rw [Finset.coe_union, Finset.coe_image, Algebra.adjoin_algebraMap_image_union_eq_adjoin_adjoin,
      hs, Algebra.adjoin_top, ht, Subalgebra.restrictScalars_top, Subalgebra.restrictScalars_top]
Theorem: MeasureTheory.withDensity_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ μ.withDensity f = 0 ↔ f =ᶠ[ae μ] 0
state_after: no goals
tactic: rw [← measure_univ_eq_zero, withDensity_apply _ .univ, restrict_univ, lintegral_eq_zero_iff' hf]
Theorem: HasSum.sub
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
hf : HasProd f a₁
hg : HasProd g a₂
⊢ HasProd (fun b => f b / g b) (a₁ / a₂)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
hf : HasProd f a₁
hg : HasProd g a₂
⊢ HasProd (fun b => f b * (g b)⁻¹) (a₁ * a₂⁻¹)
tactic: simp only [div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalGroup α
f g : β → α
a a₁ a₂ : α
hf : HasProd f a₁
hg : HasProd g a₂
⊢ HasProd (fun b => f b * (g b)⁻¹) (a₁ * a₂⁻¹)
state_after: no goals
tactic: exact hf.mul hg.inv
Theorem: mk_eq
File: Mathlib/Tactic/CategoryTheory/Monoidal.lean

Proof steps:
state_before: α : Type u_1
a b a' b' : α
ha : a = a'
hb : b = b'
h : a' = b'
⊢ a = b
state_after: no goals
tactic: simp [h, ha, hb]
Theorem: Monoid.PushoutI.NormalWord.ext_iff
File: Mathlib/GroupTheory/PushoutI.lean

Proof steps:
state_before: ι : Type u_1
G : ι → Type u_2
H : Type u_3
K : Type u_4
inst✝⁴ : Monoid K
inst✝³ : (i : ι) → Group (G i)
inst✝² : Group H
φ : (i : ι) → H →* G i
d : Transversal φ
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (G i)
w₁ w₂ : NormalWord d
h : w₁ = w₂
⊢ w₁.head = w₂.head ∧ w₁.toList = w₂.toList
state_after: no goals
tactic: simp [h]
Theorem: Monoid.exponent_dvd
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
inst✝ : Monoid G
n : ℕ
⊢ exponent G ∣ n ↔ ∀ (g : G), orderOf g ∣ n
state_after: no goals
tactic: simp_rw [exponent_dvd_iff_forall_pow_eq_one, orderOf_dvd_iff_pow_eq_one]
Theorem: Ioo_mem_nhdsWithin_Iio'
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : ClosedIicTopology α
inst✝ : TopologicalSpace β
a b c : α
f : α → β
H : a < b
⊢ Ioo a b ∈ 𝓝[<] b
state_after: no goals
tactic: simpa only [← Iio_inter_Ioi] using inter_mem_nhdsWithin _ (Ioi_mem_nhds H)
Theorem: AlgebraicTopology.map_alternatingFaceMapComplex
File: Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : F.Additive
⊢ alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex (ComplexShape.down ℕ) =
    (SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D
state_after: case h_map
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : F.Additive
⊢ autoParam
    (∀ (X Y : SimplicialObject C) (f : X ⟶ Y),
      (alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex (ComplexShape.down ℕ)).map f =
        eqToHom ⋯ ≫ ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).map f ≫ eqToHom ⋯)
    _auto✝

case h_obj
C : Type u_1
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Preadditive C
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
F : C ⥤ D
inst✝ : F.Additive
⊢ ∀ (X : SimplicialObject C),
    (alternatingFaceMapComplex C ⋙ F.mapHomologicalComplex (ComplexShape.down ℕ)).obj X =
      ((SimplicialObject.whiskering C D).obj F ⋙ alternatingFaceMapComplex D).obj X
tactic: apply CategoryTheory.Functor.ext
Theorem: MeasureTheory.eLpNormEssSup_indicator_eq_eLpNormEssSup_restrict
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
c : E
f✝ : α → E
hf : AEStronglyMeasurable f✝ μ
s : Set α
f : α → F
hs : MeasurableSet s
⊢ eLpNormEssSup (s.indicator f) μ = eLpNormEssSup f (μ.restrict s)
state_after: no goals
tactic: simp_rw [eLpNormEssSup, nnnorm_indicator_eq_indicator_nnnorm, ENNReal.coe_indicator,
    ENNReal.essSup_indicator_eq_essSup_restrict hs]
Theorem: Array.SatisfiesM_mapIdxM.go
File: .lake/packages/batteries/Batteries/Data/Array/Monadic.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : Fin as.size → α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f i as[i])
⊢ SatisfiesM (fun arr => motive as.size ∧ ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i]) (as.mapIdxM f)
state_after: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : Fin as.size → α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f i as[i])
⊢ SatisfiesM (fun arr => motive as.size ∧ ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i])
    (mapIdxM.map as f as.size 0 ⋯ #[])
tactic: simp [mapIdxM]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
as : Array α
f : Fin as.size → α → m β
motive : Nat → Prop
h0 : motive 0
p : Fin as.size → β → Prop
hs : ∀ (i : Fin as.size), motive ↑i → SatisfiesM (fun x => p i x ∧ motive (↑i + 1)) (f i as[i])
⊢ SatisfiesM (fun arr => motive as.size ∧ ∃ eq, ∀ (i : Nat) (h : i < as.size), p ⟨i, h⟩ arr[i])
    (mapIdxM.map as f as.size 0 ⋯ #[])
state_after: no goals
tactic: exact go rfl nofun h0
Theorem: Subalgebra.topologicalClosure_star_comm
File: Mathlib/Topology/Algebra/StarSubalgebra.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : CommSemiring R
inst✝¹¹ : StarRing R
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : StarRing A
inst✝⁶ : StarModule R A
inst✝⁵ : TopologicalSemiring A
inst✝⁴ : ContinuousStar A
inst✝³ : TopologicalSpace B
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : StarRing B
s : Subalgebra R A
⊢ (star s).topologicalClosure = star s.topologicalClosure
state_after: R : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : CommSemiring R
inst✝¹¹ : StarRing R
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : StarRing A
inst✝⁶ : StarModule R A
inst✝⁵ : TopologicalSemiring A
inst✝⁴ : ContinuousStar A
inst✝³ : TopologicalSpace B
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : StarRing B
s : Subalgebra R A
⊢ ∀ (t : Subalgebra R A), (star t).topologicalClosure ≤ star t.topologicalClosure
tactic: suffices ∀ t : Subalgebra R A, (star t).topologicalClosure ≤ star t.topologicalClosure from
    le_antisymm (this s) (by simpa only [star_star] using Subalgebra.star_mono (this (star s)))
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝¹² : CommSemiring R
inst✝¹¹ : StarRing R
inst✝¹⁰ : TopologicalSpace A
inst✝⁹ : Semiring A
inst✝⁸ : Algebra R A
inst✝⁷ : StarRing A
inst✝⁶ : StarModule R A
inst✝⁵ : TopologicalSemiring A
inst✝⁴ : ContinuousStar A
inst✝³ : TopologicalSpace B
inst✝² : Semiring B
inst✝¹ : Algebra R B
inst✝ : StarRing B
s : Subalgebra R A
⊢ ∀ (t : Subalgebra R A), (star t).topologicalClosure ≤ star t.topologicalClosure
state_after: no goals
tactic: exact fun t => (star t).topologicalClosure_minimal (Subalgebra.star_mono subset_closure)
    (isClosed_closure.preimage continuous_star)
Theorem: List.Ico.filter_lt_of_succ_bot
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m : ℕ
hnm : n < m
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]
state_after: n m : ℕ
hnm : n < m
r : min m (n + 1) = n + 1
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]
tactic: have r : min m (n + 1) = n + 1 := (@inf_eq_right _ _ m (n + 1)).mpr hnm
state_before: n m : ℕ
hnm : n < m
r : min m (n + 1) = n + 1
⊢ filter (fun x => decide (x < n + 1)) (Ico n m) = [n]
state_after: no goals
tactic: simp [filter_lt n m (n + 1), r]
Theorem: Cubic.disc_ne_zero_iff_roots_nodup
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 F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ P.disc ≠ 0 ↔ (map φ P).roots.Nodup
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ {x, y, z}.Nodup
tactic: rw [disc_ne_zero_iff_roots_ne ha h3, h3]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ {x, y, z}.Nodup
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ (x ::ₘ y ::ₘ {z}).Nodup
tactic: change _ ↔ (x ::ₘ y ::ₘ {z}).Nodup
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ (x ::ₘ y ::ₘ {z}).Nodup
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ ¬(x = y ∨ x = z) ∧ ¬y = z ∧ {z}.Nodup
tactic: rw [nodup_cons, nodup_cons, mem_cons, mem_singleton, mem_singleton]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ ¬(x = y ∨ x = z) ∧ ¬y = z ∧ {z}.Nodup
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ ¬(x = y ∨ x = z) ∧ ¬y = z ∧ True
tactic: simp only [nodup_singleton]
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ x ≠ y ∧ x ≠ z ∧ y ≠ z ↔ ¬(x = y ∨ x = z) ∧ ¬y = z ∧ True
state_after: no goals
tactic: tauto
Theorem: CategoryTheory.Abelian.Pseudoelement.pseudo_surjective_of_epi
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
P Q : C
f : P ⟶ Q
inst✝ : Epi f
qbar : Pseudoelement Q
q : Over Q
⊢ 𝟙 (pullback f q.hom) ≫ ((fun g => app f g) (Over.mk (pullback.fst f q.hom))).hom = pullback.snd f q.hom ≫ q.hom
state_after: no goals
tactic: rw [Category.id_comp, ← pullback.condition, app_hom, Over.coe_hom]
Theorem: Orientation.rightAngleRotationAux₁_rightAngleRotationAux₁
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x) = -x
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ ∀ (v : E), ⟪v, o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x)⟫_ℝ = ⟪v, -x⟫_ℝ
tactic: apply ext_inner_left ℝ
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ ∀ (v : E), ⟪v, o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x)⟫_ℝ = ⟪v, -x⟫_ℝ
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ⟪y, o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x)⟫_ℝ = ⟪y, -x⟫_ℝ
tactic: intro y
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ⟪y, o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x)⟫_ℝ = ⟪y, -x⟫_ℝ
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
this : ⟪o.rightAngleRotationAux₁ y, o.rightAngleRotationAux₁ x⟫_ℝ = ⟪y, x⟫_ℝ
⊢ ⟪y, o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x)⟫_ℝ = ⟪y, -x⟫_ℝ
tactic: have : ⟪o.rightAngleRotationAux₁ y, o.rightAngleRotationAux₁ x⟫ = ⟪y, x⟫ :=
    LinearIsometry.inner_map_map o.rightAngleRotationAux₂ y x
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
this : ⟪o.rightAngleRotationAux₁ y, o.rightAngleRotationAux₁ x⟫_ℝ = ⟪y, x⟫_ℝ
⊢ ⟪y, o.rightAngleRotationAux₁ (o.rightAngleRotationAux₁ x)⟫_ℝ = ⟪y, -x⟫_ℝ
state_after: no goals
tactic: rw [o.inner_rightAngleRotationAux₁_right, ← o.inner_rightAngleRotationAux₁_left, this,
    inner_neg_right]
Theorem: Real.exp_one_pow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
⊢ rexp 1 ^ n = rexp ↑n
state_after: no goals
tactic: rw [← rpow_natCast, exp_one_rpow]
Theorem: Polynomial.leadingCoeff_det_X_one_add_C
File: Mathlib/LinearAlgebra/Matrix/Polynomial.lean

Proof steps:
state_before: n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
⊢ (X • 1 + A.map ⇑C).det.leadingCoeff = 1
state_after: case inl
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Subsingleton α
⊢ (X • 1 + A.map ⇑C).det.leadingCoeff = 1

case inr
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
⊢ (X • 1 + A.map ⇑C).det.leadingCoeff = 1
tactic: cases subsingleton_or_nontrivial α
state_before: case inr
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
⊢ (X • 1 + A.map ⇑C).det.leadingCoeff = 1
state_after: case inr
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
⊢ (X • 1 + A.map ⇑C).det.coeff (X • 1 + A.map ⇑C).det.natDegree =
    (X • Matrix.map 1 ⇑C + A.map ⇑C).det.coeff (Fintype.card n)
tactic: rw [← @det_one n, ← coeff_det_X_add_C_card _ A, leadingCoeff]
state_before: case inr
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
⊢ (X • 1 + A.map ⇑C).det.coeff (X • 1 + A.map ⇑C).det.natDegree =
    (X • Matrix.map 1 ⇑C + A.map ⇑C).det.coeff (Fintype.card n)
state_after: case inr
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
⊢ (X • 1 + A.map ⇑C).det.coeff (X • 1 + A.map ⇑C).det.natDegree = (X • 1 + A.map ⇑C).det.coeff (Fintype.card n)
tactic: simp only [Matrix.map_one, C_eq_zero, RingHom.map_one]
state_before: case inr
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
⊢ (X • 1 + A.map ⇑C).det.coeff (X • 1 + A.map ⇑C).det.natDegree = (X • 1 + A.map ⇑C).det.coeff (Fintype.card n)
state_after: case inr.inl
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
h : (X • Matrix.map 1 ⇑C + A.map ⇑C).det.natDegree = Fintype.card n
⊢ (X • 1 + A.map ⇑C).det.coeff (X • 1 + A.map ⇑C).det.natDegree = (X • 1 + A.map ⇑C).det.coeff (Fintype.card n)

case inr.inr
n : Type u_1
α : Type u_2
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : CommRing α
A : Matrix n n α
h✝ : Nontrivial α
h : (X • Matrix.map 1 ⇑C + A.map ⇑C).det.natDegree < Fintype.card n
⊢ (X • 1 + A.map ⇑C).det.coeff (X • 1 + A.map ⇑C).det.natDegree = (X • 1 + A.map ⇑C).det.coeff (Fintype.card n)
tactic: rcases (natDegree_det_X_add_C_le 1 A).eq_or_lt with h | h
Theorem: integral_cos
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, cos x = sin b - sin a
state_after: case hderiv
a b : ℝ
n : ℕ
⊢ deriv sin = cos

case hdiff
a b : ℝ
n : ℕ
⊢ ∀ x ∈ [[a, b]], DifferentiableAt ℝ sin x

case hcont
a b : ℝ
n : ℕ
⊢ ContinuousOn cos [[a, b]]
tactic: rw [integral_deriv_eq_sub']
Theorem: Ring.multichoose_zero_right
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : AddCommMonoid R
inst✝³ : Pow R ℕ
inst✝² : BinomialRing R
inst✝¹ : MulOneClass R
inst✝ : NatPowAssoc R
r : R
⊢ multichoose r 0 = 1
state_after: no goals
tactic: rw [multichoose_zero_right', npow_zero]
Theorem: Matroid.eq_emptyOn_or_nonempty
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
E B I X R J : Set α
M : Matroid α
⊢ M = emptyOn α ∨ M.Nonempty
state_after: α : Type u_1
M✝ : Matroid α
E B I X R J : Set α
M : Matroid α
⊢ M.E = ∅ ∨ M.Nonempty
tactic: rw [← ground_eq_empty_iff]
state_before: α : Type u_1
M✝ : Matroid α
E B I X R J : Set α
M : Matroid α
⊢ M.E = ∅ ∨ M.Nonempty
state_after: no goals
tactic: exact M.E.eq_empty_or_nonempty.elim Or.inl (fun h ↦ Or.inr ⟨h⟩)
Theorem: nhds_basis_Ioo'
File: Mathlib/Topology/Order/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a : α
hl : ∃ l, l < a
hu : ∃ u, a < u
s : Set α
⊢ (∃ l u, a ∈ Ioo l u ∧ Ioo l u ⊆ s) ↔ ∃ i, (i.1 < a ∧ a < i.2) ∧ Ioo i.1 i.2 ⊆ s
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Localization.SmallHom.mk_comp_mk
File: Mathlib/CategoryTheory/Localization/SmallHom.lean

Proof steps:
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
W : MorphismProperty C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
D' : Type u₃
inst✝³ : Category.{v₃, u₃} D'
X Y Z T : C
inst✝² : HasSmallLocalizedHom W X Y
inst✝¹ : HasSmallLocalizedHom W Y Z
inst✝ : HasSmallLocalizedHom W X Z
f : X ⟶ Y
g : Y ⟶ Z
⊢ (equiv W W.Q) ((mk W f).comp (mk W g)) = (equiv W W.Q) (mk W (f ≫ g))
state_after: no goals
tactic: simp [equiv_comp]
Theorem: CategoryTheory.Grothendieck.comp_fiber'
File: Mathlib/CategoryTheory/Grothendieck.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.19181, u_1} C
inst✝ : Category.{?u.19185, u_2} D
F : C ⥤ Cat
X Y Z : Grothendieck F
f : X ⟶ Y
g : Y ⟶ Z
⊢ (F.map (f ≫ g).base).obj X.fiber = (F.map g.base).obj ((F.map f.base).obj X.fiber)
state_after: no goals
tactic: erw [Functor.map_comp, Functor.comp_obj]
Theorem: lift_rank_mul_lift_rank
File: Mathlib/LinearAlgebra/Dimension/Free.lean

Proof steps:
state_before: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
⊢ lift.{w, v} (Module.rank F K) * lift.{v, w} (Module.rank K A) = lift.{v, w} (Module.rank F A)
state_after: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
b : Basis (Module.Free.ChooseBasisIndex F K) F K := Module.Free.chooseBasis F K
⊢ lift.{w, v} (Module.rank F K) * lift.{v, w} (Module.rank K A) = lift.{v, w} (Module.rank F A)
tactic: let b := Module.Free.chooseBasis F K
state_before: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
b : Basis (Module.Free.ChooseBasisIndex F K) F K := Module.Free.chooseBasis F K
⊢ lift.{w, v} (Module.rank F K) * lift.{v, w} (Module.rank K A) = lift.{v, w} (Module.rank F A)
state_after: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
b : Basis (Module.Free.ChooseBasisIndex F K) F K := Module.Free.chooseBasis F K
c : Basis (Module.Free.ChooseBasisIndex K A) K A := Module.Free.chooseBasis K A
⊢ lift.{w, v} (Module.rank F K) * lift.{v, w} (Module.rank K A) = lift.{v, w} (Module.rank F A)
tactic: let c := Module.Free.chooseBasis K A
state_before: F : Type u
K : Type v
A : Type w
inst✝¹⁰ : Ring F
inst✝⁹ : Ring K
inst✝⁸ : AddCommGroup A
inst✝⁷ : Module F K
inst✝⁶ : Module K A
inst✝⁵ : Module F A
inst✝⁴ : IsScalarTower F K A
inst✝³ : StrongRankCondition F
inst✝² : StrongRankCondition K
inst✝¹ : Module.Free F K
inst✝ : Module.Free K A
b : Basis (Module.Free.ChooseBasisIndex F K) F K := Module.Free.chooseBasis F K
c : Basis (Module.Free.ChooseBasisIndex K A) K A := Module.Free.chooseBasis K A
⊢ lift.{w, v} (Module.rank F K) * lift.{v, w} (Module.rank K A) = lift.{v, w} (Module.rank F A)
state_after: no goals
tactic: rw [← (Module.rank F K).lift_id, ← b.mk_eq_rank, ← (Module.rank K A).lift_id, ← c.mk_eq_rank,
    ← lift_umax.{w, v}, ← (b.smulTower c).mk_eq_rank, mk_prod, lift_mul, lift_lift, lift_lift,
    lift_lift, lift_lift, lift_umax.{v, w}]
Theorem: MeasureTheory.integral_inv_eq_self
File: Mathlib/MeasureTheory/Group/Integral.lean

Proof steps:
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ✝ : Measure G
f✝ : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableInv G
f : G → E
μ : Measure G
inst✝ : μ.IsInvInvariant
⊢ ∫ (x : G), f x⁻¹ ∂μ = ∫ (x : G), f x ∂μ
state_after: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ✝ : Measure G
f✝ : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableInv G
f : G → E
μ : Measure G
inst✝ : μ.IsInvInvariant
h : MeasurableEmbedding fun x => x⁻¹
⊢ ∫ (x : G), f x⁻¹ ∂μ = ∫ (x : G), f x ∂μ
tactic: have h : MeasurableEmbedding fun x : G => x⁻¹ := (MeasurableEquiv.inv G).measurableEmbedding
state_before: 𝕜 : Type u_1
M : Type u_2
α : Type u_3
G : Type u_4
E : Type u_5
F : Type u_6
inst✝⁷ : MeasurableSpace G
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
μ✝ : Measure G
f✝ : G → E
g : G
inst✝² : Group G
inst✝¹ : MeasurableInv G
f : G → E
μ : Measure G
inst✝ : μ.IsInvInvariant
h : MeasurableEmbedding fun x => x⁻¹
⊢ ∫ (x : G), f x⁻¹ ∂μ = ∫ (x : G), f x ∂μ
state_after: no goals
tactic: rw [← h.integral_map, map_inv_eq_self]