ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.PreGaloisCategory.autGaloisSystem_obj
File: Mathlib/CategoryTheory/Galois/Prorepresentability.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A : PointedGaloisObject F
⊢ { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (𝟙 A) =
    𝟙 ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.obj A)
state_after: case w
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A : PointedGaloisObject F
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (𝟙 A)) σ =
    (𝟙 ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.obj A)) σ
tactic: ext (σ : Aut A.obj)
state_before: case w
C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : GaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
A : PointedGaloisObject F
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (𝟙 A)) σ =
    (𝟙 ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.obj A)) σ
state_after: no goals
tactic: simp
state_before: C✝ : Type u₁
inst✝² : Category.{u₂, u₁} C✝
inst✝¹ : GaloisCategory C✝
F : C✝ ⥤ FintypeCat
inst✝ : FiberFunctor F
A B C : PointedGaloisObject F
f : A ⟶ B
g : B ⟶ C
⊢ { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (f ≫ g) =
    { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map f ≫
      { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map g
state_after: case w
C✝ : Type u₁
inst✝² : Category.{u₂, u₁} C✝
inst✝¹ : GaloisCategory C✝
F : C✝ ⥤ FintypeCat
inst✝ : FiberFunctor F
A B C : PointedGaloisObject F
f : A ⟶ B
g : B ⟶ C
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (f ≫ g)) σ =
    ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map f ≫
        { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map g)
      σ
tactic: ext (σ : Aut A.obj)
state_before: case w
C✝ : Type u₁
inst✝² : Category.{u₂, u₁} C✝
inst✝¹ : GaloisCategory C✝
F : C✝ ⥤ FintypeCat
inst✝ : FiberFunctor F
A B C : PointedGaloisObject F
f : A ⟶ B
g : B ⟶ C
σ : Aut A.obj
⊢ ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map (f ≫ g)) σ =
    ({ obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map f ≫
        { obj := fun A => Grp.of (Aut A.obj), map := fun {A B} f => autMapHom f.val }.map g)
      σ
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Monad.monToMonad_map_toNatTrans
File: Mathlib/CategoryTheory/Monad/EquivMon.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
⊢ ∀ (X_1 : C), (ofMon X).η.app X_1 ≫ __src✝.app X_1 = (ofMon Y).η.app X_1
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : Mon_ (C ⥤ C)
f : X✝ ⟶ Y
X : C
⊢ (ofMon X✝).η.app X ≫ __src✝.app X = (ofMon Y).η.app X
tactic: intro X
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : Mon_ (C ⥤ C)
f : X✝ ⟶ Y
X : C
⊢ (ofMon X✝).η.app X ≫ __src✝.app X = (ofMon Y).η.app X
state_after: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : Mon_ (C ⥤ C)
f : X✝ ⟶ Y
X : C
⊢ Y.one.app X = (ofMon Y).η.app X
tactic: erw [← NatTrans.comp_app, f.one_hom]
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : Mon_ (C ⥤ C)
f : X✝ ⟶ Y
X : C
⊢ Y.one.app X = (ofMon Y).η.app X
state_after: no goals
tactic: simp only [Functor.id_obj, ofMon_obj, ofMon_η]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
⊢ ∀ (X_1 : C),
    (ofMon X).μ.app X_1 ≫ __src✝.app X_1 =
      ((ofMon X).map (__src✝.app X_1) ≫ __src✝.app ((ofMon Y).obj X_1)) ≫ (ofMon Y).μ.app X_1
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
Z : C
⊢ (ofMon X).μ.app Z ≫ __src✝.app Z = ((ofMon X).map (__src✝.app Z) ≫ __src✝.app ((ofMon Y).obj Z)) ≫ (ofMon Y).μ.app Z
tactic: intro Z
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
Z : C
⊢ (ofMon X).μ.app Z ≫ __src✝.app Z = ((ofMon X).map (__src✝.app Z) ≫ __src✝.app ((ofMon Y).obj Z)) ≫ (ofMon Y).μ.app Z
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
Z : C
⊢ (MonoidalCategory.tensorHom f.hom f.hom ≫ Y.mul).app Z =
    ((ofMon X).map (__src✝.app Z) ≫ __src✝.app ((ofMon Y).obj Z)) ≫ (ofMon Y).μ.app Z
tactic: erw [← NatTrans.comp_app, f.mul_hom]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
Z : C
⊢ (MonoidalCategory.tensorHom f.hom f.hom ≫ Y.mul).app Z =
    ((ofMon X).map (__src✝.app Z) ≫ __src✝.app ((ofMon Y).obj Z)) ≫ (ofMon Y).μ.app Z
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
Z : C
⊢ (f.hom.app (X.X.obj Z) ≫ Y.X.map (f.hom.app Z)) ≫ Y.mul.app Z =
    ((ofMon X).map (f.hom.app Z) ≫ f.hom.app (Y.X.obj Z)) ≫ Y.mul.app Z
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Mon_ (C ⥤ C)
f : X ⟶ Y
Z : C
⊢ (f.hom.app (X.X.obj Z) ≫ Y.X.map (f.hom.app Z)) ≫ Y.mul.app Z =
    ((ofMon X).map (f.hom.app Z) ≫ f.hom.app (Y.X.obj Z)) ≫ Y.mul.app Z
state_after: no goals
tactic: simp only [Category.assoc, NatTrans.naturality, ofMon_obj, ofMon]
Theorem: MeasurableSpace.measurableSet_sSup
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ MeasurableSet s ↔ GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ GenerateMeasurable (⋃₀ ((fun m => {t | MeasurableSet t}) '' ms)) s ↔
    GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s
tactic: change GenerateMeasurable (⋃₀ _) _ ↔ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
ms : Set (MeasurableSpace α)
s : Set α
⊢ GenerateMeasurable (⋃₀ ((fun m => {t | MeasurableSet t}) '' ms)) s ↔
    GenerateMeasurable {s | ∃ m ∈ ms, MeasurableSet s} s
state_after: no goals
tactic: simp [← setOf_exists]
Theorem: Multiset.Ioo_self
File: Mathlib/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ Ioo a a = 0
state_after: no goals
tactic: rw [Ioo, Finset.Ioo_self, Finset.empty_val]
Theorem: Trivialization.nhds_eq_inf_comap
File: Mathlib/Topology/FiberBundle/Trivialization.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x z : Z
hz : z ∈ e.source
⊢ 𝓝 z = comap proj (𝓝 (proj z)) ⊓ comap (Prod.snd ∘ ↑e) (𝓝 (↑e z).2)
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x z : Z
hz : z ∈ e.source
l : Filter Z
⊢ l ≤ 𝓝 z ↔ l ≤ comap proj (𝓝 (proj z)) ⊓ comap (Prod.snd ∘ ↑e) (𝓝 (↑e z).2)
tactic: refine eq_of_forall_le_iff fun l ↦ ?_
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x z : Z
hz : z ∈ e.source
l : Filter Z
⊢ l ≤ 𝓝 z ↔ l ≤ comap proj (𝓝 (proj z)) ⊓ comap (Prod.snd ∘ ↑e) (𝓝 (↑e z).2)
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x z : Z
hz : z ∈ e.source
l : Filter Z
⊢ l ≤ 𝓝 z ↔ Tendsto proj l (𝓝 (proj z)) ∧ Tendsto (Prod.snd ∘ ↑e) l (𝓝 (↑e z).2)
tactic: rw [le_inf_iff, ← tendsto_iff_comap, ← tendsto_iff_comap]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x z : Z
hz : z ∈ e.source
l : Filter Z
⊢ l ≤ 𝓝 z ↔ Tendsto proj l (𝓝 (proj z)) ∧ Tendsto (Prod.snd ∘ ↑e) l (𝓝 (↑e z).2)
state_after: no goals
tactic: exact e.tendsto_nhds_iff hz
Theorem: Real.sin_pos_of_pos_of_lt_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
h0x : 0 < x
hxp : x < π
hx2 : ¬x ≤ 2
⊢ 2 + 2 = 4
state_after: no goals
tactic: norm_num
Theorem: Cubic.leadingCoeff_of_c_ne_zero
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 Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c ≠ 0
⊢ P.toPoly.leadingCoeff = P.c
state_after: no goals
tactic: rw [of_b_eq_zero ha hb, leadingCoeff_linear hc]
Theorem: Multiset.noncommProd_commute
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
s : Multiset α
comm : {x | x ∈ s}.Pairwise Commute
y : α
h : ∀ x ∈ s, Commute y x
⊢ Commute y (s.noncommProd comm)
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
y : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, Commute y x
⊢ Commute y (noncommProd ⟦a✝⟧ comm)
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
y : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, Commute y x
⊢ Commute y (noncommProd ⟦a✝⟧ comm)
state_after: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
y : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, Commute y x
⊢ Commute y a✝.prod
tactic: simp only [quot_mk_to_coe, noncommProd_coe]
state_before: case h
F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : α → β → β
op : α → α → α
inst✝² : Monoid α
inst✝¹ : Monoid β
inst✝ : FunLike F α β
y : α
a✝ : List α
comm : {x | x ∈ ⟦a✝⟧}.Pairwise Commute
h : ∀ x ∈ ⟦a✝⟧, Commute y x
⊢ Commute y a✝.prod
state_after: no goals
tactic: exact Commute.list_prod_right _ _ h
Theorem: Basis.det_comp
File: Mathlib/LinearAlgebra/Determinant.lean

Proof steps:
state_before: R : Type u_1
inst✝⁸ : CommRing R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
M' : Type u_3
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
ι : Type u_4
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
e✝ : Basis ι R M
A : Type u_5
inst✝¹ : CommRing A
inst✝ : Module A M
e : Basis ι A M
f : M →ₗ[A] M
v : ι → M
⊢ e.det (⇑f ∘ v) = LinearMap.det f * e.det v
state_after: no goals
tactic: rw [Basis.det_apply, Basis.det_apply, ← f.det_toMatrix e, ← Matrix.det_mul,
    e.toMatrix_eq_toMatrix_constr (f ∘ v), e.toMatrix_eq_toMatrix_constr v, ← toMatrix_comp,
    e.constr_comp]
Theorem: Nat.Ico_zero_eq_range
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
⊢ Ico 0 = range
state_after: no goals
tactic: rw [← Nat.bot_eq_zero, ← Iio_eq_Ico, Iio_eq_range]
Theorem: AList.perm_union
File: Mathlib/Data/List/AList.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
s₁ s₂ s₃ s₄ : AList β
p₁₂ : s₁.entries ~ s₂.entries
p₃₄ : s₃.entries ~ s₄.entries
⊢ (s₁ ∪ s₃).entries ~ (s₂ ∪ s₄).entries
state_after: no goals
tactic: simp [p₁₂.kunion s₃.nodupKeys p₃₄]
Theorem: ENNReal.exists_countable_dense_no_zero_top
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ ∃ s, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ⊤ ∉ s
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
s_count : s.Countable
s_dense : Dense s
hs : (∀ (x : ℝ≥0∞), IsBot x → x ∉ s) ∧ ∀ (x : ℝ≥0∞), IsTop x → x ∉ s
⊢ ∃ s, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ⊤ ∉ s
tactic: obtain ⟨s, s_count, s_dense, hs⟩ :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∉ s) ∧ ∀ x, IsTop x → x ∉ s :=
    exists_countable_dense_no_bot_top ℝ≥0∞
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
s_count : s.Countable
s_dense : Dense s
hs : (∀ (x : ℝ≥0∞), IsBot x → x ∉ s) ∧ ∀ (x : ℝ≥0∞), IsTop x → x ∉ s
⊢ ∃ s, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ⊤ ∉ s
state_after: no goals
tactic: exact ⟨s, s_count, s_dense, fun h => hs.1 0 (by simp) h, fun h => hs.2 ∞ (by simp) h⟩
Theorem: Polynomial.update_eq_add_sub_coeff
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
a✝ b : R✝
n✝ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
⊢ p.update n a = p + C (a - p.coeff n) * X ^ n
state_after: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (p.update n a).coeff n✝ = (p + C (a - p.coeff n) * X ^ n).coeff n✝
tactic: ext
state_before: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (p.update n a).coeff n✝ = (p + C (a - p.coeff n) * X ^ n).coeff n✝
state_after: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (if n✝ = n then a else p.coeff n✝) = p.coeff n✝ + if n✝ = n then a - p.coeff n else 0
tactic: rw [coeff_update_apply, coeff_add, coeff_C_mul_X_pow]
state_before: case a
R✝ : Type u
S : Type v
a✝ b : R✝
n✝¹ m : ℕ
inst✝¹ : Semiring R✝
p✝ q r : R✝[X]
R : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
a : R
n✝ : ℕ
⊢ (if n✝ = n then a else p.coeff n✝) = p.coeff n✝ + if n✝ = n then a - p.coeff n else 0
state_after: no goals
tactic: split_ifs with h <;> simp [h]
Theorem: QuadraticMap.polar_smul_left_of_tower
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R M
inst✝⁶ : Module R N
Q : QuadraticMap R M N
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : Module S M
inst✝² : IsScalarTower S R M
inst✝¹ : Module S N
inst✝ : IsScalarTower S R N
a : S
x y : M
⊢ polar (⇑Q) (a • x) y = a • polar (⇑Q) x y
state_after: no goals
tactic: rw [← IsScalarTower.algebraMap_smul R a x, polar_smul_left, algebraMap_smul]
Theorem: Path.extend_one
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ : Path x y
⊢ γ.extend 1 = y
state_after: no goals
tactic: simp
Theorem: Mathlib.Meta.NormNum.isNat_neg_of_isNegNat
File: Mathlib/Tactic/NormNum/DivMod.lean

Proof steps:
state_before: a : ℤ
b : ℕ
h : IsInt a (Int.negOfNat b)
⊢ -a = ↑b
state_after: no goals
tactic: simp [h.out]
Theorem: MeasureTheory.SimpleFunc.const_lintegral_restrict
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
c : ℝ≥0∞
s : Set α
⊢ (const α c).lintegral (μ.restrict s) = c * μ s
state_after: no goals
tactic: rw [const_lintegral, Measure.restrict_apply MeasurableSet.univ, univ_inter]
Theorem: Subgroup.IsComplement.coe_equiv_snd_eq_one_iff_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ T
⊢ ↑(hST.equiv g).2 = 1 ↔ g ∈ S
state_after: no goals
tactic: rw [equiv_snd_eq_inv_mul, inv_mul_eq_one, equiv_fst_eq_self_iff_mem _ h1]
Theorem: ProbabilityTheory.Kernel.iIndepFun.indepFun_finset_prod_of_not_mem
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
β✝ : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
f✝ : Ω → β✝
g : Ω → β'
β : Type u_8
m : MeasurableSpace β
inst✝² : CommMonoid β
inst✝¹ : MeasurableMul₂ β
f : ι → Ω → β
inst✝ : IsMarkovKernel κ
hf_Indep : iIndepFun (fun x => m) f κ μ
hf_meas : ∀ (i : ι), Measurable (f i)
s : Finset ι
i : ι
hi : i ∉ s
⊢ IndepFun (∏ j ∈ s, f j) (f i) κ μ
state_after: no goals
tactic: classical
  have h_right : f i =
    (fun p : ({i} : Finset ι) → β => p ⟨i, Finset.mem_singleton_self i⟩) ∘
    fun a (j : ({i} : Finset ι)) => f j a := rfl
  have h_meas_right : Measurable fun p : ({i} : Finset ι) → β
    => p ⟨i, Finset.mem_singleton_self i⟩ := measurable_pi_apply ⟨i, Finset.mem_singleton_self i⟩
  have h_left : ∏ j ∈ s, f j = (fun p : s → β => ∏ j, p j) ∘ fun a (j : s) => f j a := by
    ext1 a
    simp only [Function.comp_apply]
    have : (∏ j : ↥s, f (↑j) a) = (∏ j : ↥s, f ↑j) a := by rw [Finset.prod_apply]
    rw [this, Finset.prod_coe_sort]
  have h_meas_left : Measurable fun p : s → β => ∏ j, p j :=
    Finset.univ.measurable_prod fun (j : ↥s) (_H : j ∈ Finset.univ) => measurable_pi_apply j
  rw [h_left, h_right]
  exact
    (hf_Indep.indepFun_finset s {i} (Finset.disjoint_singleton_left.mpr hi).symm hf_meas).comp
      h_meas_left h_meas_right
Theorem: Set.bounded_le_inter_le
File: Mathlib/Order/Bounded.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) → Bounded (fun x x_1 => x ≤ x_1) s
tactic: refine ⟨?_, Bounded.mono Set.inter_subset_left⟩
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) → Bounded (fun x x_1 => x ≤ x_1) s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) → Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b})
tactic: rw [← @bounded_le_inter_lt _ s _ a]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) → Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b})
state_after: no goals
tactic: exact Bounded.mono fun x ⟨hx, hx'⟩ => ⟨hx, le_of_lt hx'⟩
Theorem: tprod_pi_single
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ ∏' (b' : β), Pi.mulSingle b a b' = a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ Pi.mulSingle b a b = a

α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : DecidableEq β
b : β
a : α
⊢ ∀ (b' : β), b' ≠ b → Pi.mulSingle b a b' = 1
tactic: rw [tprod_eq_mulSingle b]
Theorem: CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁_app
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
⊢ ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
    (yonedaCollectionPresheaf A F).map f ≫ (fun X => YonedaCollection.map₁ η) Y =
      (fun X => YonedaCollection.map₁ η) X ≫ (yonedaCollectionPresheaf A G).map f
state_after: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
X✝ Y✝ : Cᵒᵖ
f✝ : X✝ ⟶ Y✝
⊢ (yonedaCollectionPresheaf A F).map f✝ ≫ (fun X => YonedaCollection.map₁ η) Y✝ =
    (fun X => YonedaCollection.map₁ η) X✝ ≫ (yonedaCollectionPresheaf A G).map f✝
tactic: intros
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
X✝ Y✝ : Cᵒᵖ
f✝ : X✝ ⟶ Y✝
⊢ (yonedaCollectionPresheaf A F).map f✝ ≫ (fun X => YonedaCollection.map₁ η) Y✝ =
    (fun X => YonedaCollection.map₁ η) X✝ ≫ (yonedaCollectionPresheaf A G).map f✝
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
X✝ Y✝ : Cᵒᵖ
f✝ : X✝ ⟶ Y✝
a✝ : (yonedaCollectionPresheaf A F).obj X✝
⊢ ((yonedaCollectionPresheaf A F).map f✝ ≫ (fun X => YonedaCollection.map₁ η) Y✝) a✝ =
    ((fun X => YonedaCollection.map₁ η) X✝ ≫ (yonedaCollectionPresheaf A G).map f✝) a✝
tactic: ext
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F G : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
η : F ⟶ G
X✝ Y✝ : Cᵒᵖ
f✝ : X✝ ⟶ Y✝
a✝ : (yonedaCollectionPresheaf A F).obj X✝
⊢ ((yonedaCollectionPresheaf A F).map f✝ ≫ (fun X => YonedaCollection.map₁ η) Y✝) a✝ =
    ((fun X => YonedaCollection.map₁ η) X✝ ≫ (yonedaCollectionPresheaf A G).map f✝) a✝
state_after: no goals
tactic: simp
Theorem: Cardinal.continuum_power_aleph0
File: Mathlib/SetTheory/Cardinal/Continuum.lean

Proof steps:
state_before: ⊢ 𝔠 ^ ℵ₀ = 𝔠
state_after: no goals
tactic: rw [← two_power_aleph0, ← power_mul, mul_eq_left le_rfl le_rfl aleph0_ne_zero]
Theorem: Filter.unbounded_of_tendsto_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
⊢ ¬BddAbove (range f)
state_after: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
⊢ False
tactic: rintro ⟨M, hM⟩
state_before: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
⊢ False
state_after: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ False
tactic: cases' mem_atTop_sets.mp (h <| Ioi_mem_atTop M) with a ha
state_before: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ False
state_after: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ M < M
tactic: apply lt_irrefl M
state_before: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ M < M
state_after: no goals
tactic: calc
    M < f a := ha a le_rfl
    _ ≤ M := hM (Set.mem_range_self a)