1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Limits.ι_colimitLimitToLimitColimit_π
File: Mathlib/CategoryTheory/Limits/ColimitLimit.lean

tactic: dsimp [colimitLimitToLimitColimit]
state_before: J : Type u₁
K : Type u₂
inst✝⁴ : Category.{v₁, u₁} J
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J × K ⥤ C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasColimitsOfShape K C
j : J
k : K
⊢ colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k ≫ colimitLimitToLimitColimit F ≫ limit.π (curry.obj F ⋙ colim) j =
    limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k
state_after: J : Type u₁
K : Type u₂
inst✝⁴ : Category.{v₁, u₁} J
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J × K ⥤ C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasColimitsOfShape K C
j : J
k : K
⊢ colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k ≫
      limit.lift (curry.obj F ⋙ colim)
          { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
            π :=
              {
                app := fun j =>
                  colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                    { pt := colimit ((curry.obj F).obj j),
                      ι :=
                        {
                          app := fun k =>
                            limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                          naturality := ⋯ } },
                naturality := ⋯ } } ≫
        limit.π (curry.obj F ⋙ colim) j =
    limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k

tactic: simp
state_before: J : Type u₁
K : Type u₂
inst✝⁴ : Category.{v₁, u₁} J
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F : J × K ⥤ C
inst✝¹ : HasLimitsOfShape J C
inst✝ : HasColimitsOfShape K C
j : J
k : K
⊢ colimit.ι (curry.obj (Prod.swap K J ⋙ F) ⋙ lim) k ≫
      limit.lift (curry.obj F ⋙ colim)
          { pt := colimit (curry.obj (Prod.swap K J ⋙ F) ⋙ lim),
            π :=
              {
                app := fun j =>
                  colimit.desc (curry.obj (Prod.swap K J ⋙ F) ⋙ lim)
                    { pt := colimit ((curry.obj F).obj j),
                      ι :=
                        {
                          app := fun k =>
                            limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k,
                          naturality := ⋯ } },
                naturality := ⋯ } } ≫
        limit.π (curry.obj F ⋙ colim) j =
    limit.π ((curry.obj (Prod.swap K J ⋙ F)).obj k) j ≫ colimit.ι ((curry.obj F).obj j) k
state_after: no goals
Theorem: Matroid.basis_empty_iff
File: Mathlib/Data/Matroid/Basic.lean

tactic: (rw [h]; exact M.empty_indep.basis_self)
state_before: α : Type u_1
M✝ : Matroid α
I : Set α
M : Matroid α
h : I = ∅
⊢ M.Basis I ∅
state_after: no goals

tactic: rw [h]
state_before: α : Type u_1
M✝ : Matroid α
I : Set α
M : Matroid α
h : I = ∅
⊢ M.Basis I ∅
state_after: α : Type u_1
M✝ : Matroid α
I : Set α
M : Matroid α
h : I = ∅
⊢ M.Basis ∅ ∅

tactic: exact M.empty_indep.basis_self
state_before: α : Type u_1
M✝ : Matroid α
I : Set α
M : Matroid α
h : I = ∅
⊢ M.Basis ∅ ∅
state_after: no goals
Theorem: MonoidAlgebra.mem_adjoin_support
File: Mathlib/RingTheory/FiniteType.lean

tactic: suffices span R (of R M '' f.support) ≤ Subalgebra.toSubmodule (adjoin R (of R M '' f.support)) by
  exact this (mem_span_support f)
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ f ∈ adjoin R (⇑(of R M) '' ↑f.support)
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ span R (⇑(of R M) '' ↑f.support) ≤ Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support))

tactic: rw [Submodule.span_le]
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ span R (⇑(of R M) '' ↑f.support) ≤ Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support))
state_after: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ ⇑(of R M) '' ↑f.support ⊆ ↑(Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support)))

tactic: exact subset_adjoin
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
⊢ ⇑(of R M) '' ↑f.support ⊆ ↑(Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support)))
state_after: no goals

tactic: exact this (mem_span_support f)
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
inst✝ : Monoid M
f : MonoidAlgebra R M
this : span R (⇑(of R M) '' ↑f.support) ≤ Subalgebra.toSubmodule (adjoin R (⇑(of R M) '' ↑f.support))
⊢ f ∈ adjoin R (⇑(of R M) '' ↑f.support)
state_after: no goals
Theorem: Multiset.coe_sections
File: Mathlib/Data/Multiset/Sections.lean

tactic: simp only [List.map_cons, List.sections]
state_before: α : Type u_1
a : List α
l : List (List α)
⊢ (↑(List.map (fun l => ↑l) (a :: l))).Sections = ↑(List.map (fun l => ↑l) (a :: l).sections)
state_after: α : Type u_1
a : List α
l : List (List α)
⊢ (↑(↑a :: List.map (fun l => ↑l) l)).Sections =
    ↑(List.map (fun l => ↑l) (l.sections.bind fun s => List.map (fun a => a :: s) a))

tactic: rw [← cons_coe, sections_cons, bind_map_comm, coe_sections l]
state_before: α : Type u_1
a : List α
l : List (List α)
⊢ (↑(↑a :: List.map (fun l => ↑l) l)).Sections =
    ↑(List.map (fun l => ↑l) (l.sections.bind fun s => List.map (fun a => a :: s) a))
state_after: α : Type u_1
a : List α
l : List (List α)
⊢ ((↑(List.map (fun l => ↑l) l.sections)).bind fun b => map (fun a => a ::ₘ b) ↑a) =
    ↑(List.map (fun l => ↑l) (l.sections.bind fun s => List.map (fun a => a :: s) a))
Theorem: LowerSet.map_map
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
⊢ (map g) ((map f) s) = (map (f.trans g)) s
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
x✝ : γ
⊢ x✝ ∈ ↑((map g) ((map f) s)) ↔ x✝ ∈ ↑((map (f.trans g)) s)

tactic: simp
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
f✝ : α ≃o β
s t : LowerSet α
a : α
b : β
g : β ≃o γ
f : α ≃o β
x✝ : γ
⊢ x✝ ∈ ↑((map g) ((map f) s)) ↔ x✝ ∈ ↑((map (f.trans g)) s)
state_after: no goals
Theorem: MeasureTheory.setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

tactic: rw [restrict_withDensity hs, lintegral_withDensity_eq_lintegral_mul_non_measurable _ f_meas hf]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ✝ μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
s : Set α
hs : MeasurableSet s
hf : ∀ᵐ (x : α) ∂μ.restrict s, f x < ⊤
⊢ ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ
state_after: no goals
Theorem: CoxeterSystem.simple_induction
File: Mathlib/GroupTheory/Coxeter/Basic.lean

tactic: have := cs.submonoid_closure_range_simple.symm ▸ Submonoid.mem_top w
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
p : W → Prop
w : W
simple : ∀ (i : B), p (cs.simple i)
one : p 1
mul : ∀ (w w' : W), p w → p w' → p (w * w')
⊢ p w
state_after: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
p : W → Prop
w : W
simple : ∀ (i : B), p (cs.simple i)
one : p 1
mul : ∀ (w w' : W), p w → p w' → p (w * w')
this : w ∈ Submonoid.closure (Set.range cs.simple)
⊢ p w

tactic: exact Submonoid.closure_induction this (fun x ⟨i, hi⟩ ↦ hi ▸ simple i) one mul
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
p : W → Prop
w : W
simple : ∀ (i : B), p (cs.simple i)
one : p 1
mul : ∀ (w w' : W), p w → p w' → p (w * w')
this : w ∈ Submonoid.closure (Set.range cs.simple)
⊢ p w
state_after: no goals
Theorem: cfc_pow
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: rw [cfc_apply f a, ← map_pow, cfc_apply _ a]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
f : R → R
n : ℕ
a : A
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ cfc (fun x => f x ^ n) a = cfc f a ^ n
state_after: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
f : R → R
n : ℕ
a : A
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ (cfcHom ha) { toFun := (spectrum R a).restrict fun x => f x ^ n, continuous_toFun := ⋯ } =
    (cfcHom ha) ({ toFun := (spectrum R a).restrict f, continuous_toFun := ⋯ } ^ n)

tactic: congr
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf✝ : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
f : R → R
n : ℕ
a : A
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
ha : autoParam (p a) _auto✝
⊢ (cfcHom ha) { toFun := (spectrum R a).restrict fun x => f x ^ n, continuous_toFun := ⋯ } =
    (cfcHom ha) ({ toFun := (spectrum R a).restrict f, continuous_toFun := ⋯ } ^ n)
state_after: no goals
Theorem: intervalIntegral.integral_comp_add_right
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simp [intervalIntegral, A.setIntegral_map]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A✝ : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
d : ℝ
A : MeasurableEmbedding fun x => x + d
⊢ ∫ (x : ℝ) in a..b, f (x + d) = ∫ (x : ℝ) in a + d..b + d, f x ∂Measure.map (fun x => x + d) volume
state_after: no goals

tactic: rw [map_add_right_eq_self]
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A✝ : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c d✝ : ℝ
f : ℝ → E
d : ℝ
A : MeasurableEmbedding fun x => x + d
⊢ ∫ (x : ℝ) in a + d..b + d, f x ∂Measure.map (fun x => x + d) volume = ∫ (x : ℝ) in a + d..b + d, f x
state_after: no goals
Theorem: Int.dvd_natCast
File: Mathlib/Data/Int/Defs.lean

tactic: obtain hn | hn := natAbs_eq m <;> rw [hn] <;> simp [← natCast_dvd_natCast, Int.neg_dvd]
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ m ∣ ↑n ↔ m.natAbs ∣ n
state_after: no goals
Theorem: CategoryTheory.Limits.IsInitial.epi_to
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: haveI := t.isSplitEpi_to f
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsInitial X
f : Y ⟶ X
⊢ Epi f
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsInitial X
f : Y ⟶ X
this : IsSplitEpi f
⊢ Epi f

tactic: infer_instance
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : C
t : IsInitial X
f : Y ⟶ X
this : IsSplitEpi f
⊢ Epi f
state_after: no goals
Theorem: NNReal.mul_le_iff_le_inv
File: Mathlib/Data/NNReal/Basic.lean

tactic: have : 0 < r := lt_of_le_of_ne (zero_le r) hr.symm
state_before: a b r : ℝ≥0
hr : r ≠ 0
⊢ r * a ≤ b ↔ a ≤ r⁻¹ * b
state_after: a b r : ℝ≥0
hr : r ≠ 0
this : 0 < r
⊢ r * a ≤ b ↔ a ≤ r⁻¹ * b

tactic: rw [← mul_le_mul_left (inv_pos.mpr this), ← mul_assoc, inv_mul_cancel hr, one_mul]
state_before: a b r : ℝ≥0
hr : r ≠ 0
this : 0 < r
⊢ r * a ≤ b ↔ a ≤ r⁻¹ * b
state_after: no goals
Theorem: CategoryTheory.Limits.coprod.map_inl_inr_codiag
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ X Y : C
inst✝¹ : HasBinaryCoproduct X Y
inst✝ : HasBinaryCoproduct (X ⨿ Y) (X ⨿ Y)
⊢ map inl inr ≫ codiag (X ⨿ Y) = 𝟙 (X ⨿ Y)
state_after: no goals
Theorem: div_right_injective
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp only [div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ Injective fun a => b / a
state_after: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ Injective fun a => b * a⁻¹

tactic: exact fun a a' h ↦ inv_injective (mul_right_injective b h)
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ Injective fun a => b * a⁻¹
state_after: no goals
Theorem: Polynomial.leadingCoeff_multiset_prod
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: rw [← leadingCoeffHom_apply, MonoidHom.map_multiset_prod]
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
⊢ t.prod.leadingCoeff = (Multiset.map (fun f => f.leadingCoeff) t).prod
state_after: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
⊢ (Multiset.map (⇑leadingCoeffHom) t).prod = (Multiset.map (fun f => f.leadingCoeff) t).prod

tactic: rfl
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
⊢ (Multiset.map (⇑leadingCoeffHom) t).prod = (Multiset.map (fun f => f.leadingCoeff) t).prod
state_after: no goals
Theorem: CategoryTheory.Functor.shiftIso_zero_hom_app
File: Mathlib/CategoryTheory/Shift/ShiftSequence.lean

tactic: simp [F.shiftIso_zero a]
state_before: C : Type u_1
A : Type u_2
inst✝⁶ : Category.{u_6, u_1} C
inst✝⁵ : Category.{u_5, u_2} A
F : C ⥤ A
M : Type u_3
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence M
a : M
X : C
⊢ (F.shiftIso 0 a a ⋯).hom.app X = (F.shift a).map ((shiftFunctorZero C M).hom.app X)
state_after: no goals
Theorem: Fin.univ_image_getElem'
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp only [univ_image_def, List.ofFn_getElem_eq_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
l : List α
f : α → β
⊢ image (fun i => f l[↑i]) univ = (List.map f l).toFinset
state_after: no goals
Theorem: rat_add_continuous_lemma
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

tactic: simpa [add_halves, sub_eq_add_neg, add_comm, add_left_comm, add_assoc] using
  lt_of_le_of_lt (abv_add abv _ _) (add_lt_add h₁ h₂)
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
ε : α
ε0 : 0 < ε
a₁ a₂ b₁ b₂ : β
h₁ : abv (a₁ - b₁) < ε / 2
h₂ : abv (a₂ - b₂) < ε / 2
⊢ abv (a₁ + a₂ - (b₁ + b₂)) < ε
state_after: no goals
Theorem: Rat.nonneg_antisymm
File: Mathlib/Data/Rat/Defs.lean

tactic: simp_rw [← num_eq_zero, Int.le_antisymm_iff, ← num_nonneg, num_neg_eq_neg_num, Int.neg_nonneg]
state_before: q a b c : ℚ
⊢ 0 ≤ q → 0 ≤ -q → q = 0
state_after: q a b c : ℚ
⊢ 0 ≤ q.num → q.num ≤ 0 → q.num ≤ 0 ∧ 0 ≤ q.num

tactic: tauto
state_before: q a b c : ℚ
⊢ 0 ≤ q.num → q.num ≤ 0 → q.num ≤ 0 ∧ 0 ≤ q.num
state_after: no goals
Theorem: TopCat.fst_openEmbedding_of_right_openEmbedding
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: convert (homeoOfIso (asIso (pullback.fst : pullback f (𝟙 S) ⟶ _))).openEmbedding.comp
    (pullback_map_openEmbedding_of_open_embeddings (i₁ := 𝟙 X) f g f (𝟙 _)
      (homeoOfIso (Iso.refl _)).openEmbedding H (𝟙 _) rfl (by simp))
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : OpenEmbedding ⇑g
⊢ OpenEmbedding ⇑pullback.fst
state_after: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : OpenEmbedding ⇑g
⊢ ⇑pullback.fst = ⇑(homeoOfIso (asIso pullback.fst)) ∘ ⇑(pullback.map f g f (𝟙 S) (𝟙 X) g (𝟙 S) ⋯ ⋯)

tactic: erw [← coe_comp]
state_before: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : OpenEmbedding ⇑g
⊢ ⇑pullback.fst = ⇑(homeoOfIso (asIso pullback.fst)) ∘ ⇑(pullback.map f g f (𝟙 S) (𝟙 X) g (𝟙 S) ⋯ ⋯)
state_after: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : OpenEmbedding ⇑g
⊢ ⇑pullback.fst = ⇑(pullback.map f g f (𝟙 S) (𝟙 X) g (𝟙 S) ⋯ ⋯ ≫ (asIso pullback.fst).hom)

tactic: simp
state_before: case h.e'_5
J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : OpenEmbedding ⇑g
⊢ ⇑pullback.fst = ⇑(pullback.map f g f (𝟙 S) (𝟙 X) g (𝟙 S) ⋯ ⋯ ≫ (asIso pullback.fst).hom)
state_after: no goals

tactic: simp
state_before: J : Type v
inst✝ : SmallCategory J
X✝ Y✝ Z : TopCat
X Y S : TopCat
f : X ⟶ S
g : Y ⟶ S
H : OpenEmbedding ⇑g
⊢ g ≫ 𝟙 S = g ≫ 𝟙 S
state_after: no goals
Theorem: WithLp.prod_nnnorm_equiv
File: Mathlib/Analysis/NormedSpace/ProdLp.lean

tactic: rw [prod_nnnorm_eq_sup, Prod.nnnorm_def', _root_.sup_eq_max, equiv_fst, equiv_snd]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
f : WithLp ⊤ (α × β)
⊢ ‖(WithLp.equiv ⊤ (α × β)) f‖₊ = ‖f‖₊
state_after: no goals
Theorem: Sylow.card_quotient_normalizer_modEq_card_quotient
File: Mathlib/GroupTheory/Sylow.lean

tactic: rw [← Fintype.card_congr (fixedPointsMulLeftCosetsEquivQuotient H)]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
H : Subgroup G
hH : Fintype.card ↥H = p ^ n
⊢ Fintype.card (↥H.normalizer ⧸ comap H.normalizer.subtype H) ≡ Fintype.card (G ⧸ H) [MOD p]
state_after: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
H : Subgroup G
hH : Fintype.card ↥H = p ^ n
⊢ Fintype.card ↑(MulAction.fixedPoints (↥H) (G ⧸ H)) ≡ Fintype.card (G ⧸ H) [MOD p]

tactic: exact ((IsPGroup.of_card hH).card_modEq_card_fixedPoints _).symm
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
H : Subgroup G
hH : Fintype.card ↥H = p ^ n
⊢ Fintype.card ↑(MulAction.fixedPoints (↥H) (G ⧸ H)) ≡ Fintype.card (G ⧸ H) [MOD p]
state_after: no goals
Theorem: Cardinal.isStrongLimit_aleph0
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rcases lt_aleph0.1 hx with ⟨n, rfl⟩
state_before: α : Type u_1
r : α → α → Prop
x : Cardinal.{u_2}
hx : x < ℵ₀
⊢ 2 ^ x < ℵ₀
state_after: case intro
α : Type u_1
r : α → α → Prop
n : ℕ
hx : ↑n < ℵ₀
⊢ 2 ^ ↑n < ℵ₀

tactic: exact mod_cast nat_lt_aleph0 (2 ^ n)
state_before: case intro
α : Type u_1
r : α → α → Prop
n : ℕ
hx : ↑n < ℵ₀
⊢ 2 ^ ↑n < ℵ₀
state_after: no goals
Theorem: Multiset.map_comp_cons
File: Mathlib/Data/Multiset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type v
γ : Type u_2
f : α → β
t : α
⊢ map f ∘ cons t = cons (f t) ∘ map f
state_after: case h
α : Type u_1
β : Type v
γ : Type u_2
f : α → β
t : α
x✝ : Multiset α
⊢ (map f ∘ cons t) x✝ = (cons (f t) ∘ map f) x✝

tactic: simp
state_before: case h
α : Type u_1
β : Type v
γ : Type u_2
f : α → β
t : α
x✝ : Multiset α
⊢ (map f ∘ cons t) x✝ = (cons (f t) ∘ map f) x✝
state_after: no goals
Theorem: pairwiseDisjoint_unique
File: Mathlib/Data/Set/Pairwise/Lattice.lean

tactic: refine exists_unique_of_exists_of_unique ?ex ?unique
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∃! i, i ∈ s ∧ y ∈ f i
state_after: case ex
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∃ x ∈ s, y ∈ f x

case unique
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∀ (y₁ y₂ : ι), y₁ ∈ s ∧ y ∈ f y₁ → y₂ ∈ s ∧ y ∈ f y₂ → y₁ = y₂

tactic: simpa only [mem_iUnion, exists_prop] using hy
state_before: case ex
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∃ x ∈ s, y ∈ f x
state_after: no goals

tactic: rintro i j ⟨his, hi⟩ ⟨hjs, hj⟩
state_before: case unique
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
⊢ ∀ (y₁ y₂ : ι), y₁ ∈ s ∧ y ∈ f y₁ → y₂ ∈ s ∧ y ∈ f y₂ → y₁ = y₂
state_after: case unique.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
i j : ι
his : i ∈ s
hi : y ∈ f i
hjs : j ∈ s
hj : y ∈ f j
⊢ i = j

tactic: exact h_disjoint.elim his hjs <| not_disjoint_iff.mpr ⟨y, ⟨hi, hj⟩⟩
state_before: case unique.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
y : α
h_disjoint : s.PairwiseDisjoint f
hy : y ∈ ⋃ i ∈ s, f i
i j : ι
his : i ∈ s
hi : y ∈ f i
hjs : j ∈ s
hj : y ∈ f j
⊢ i = j
state_after: no goals