ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: BoxIntegral.Prepartition.biUnionIndex_mem
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

Proof steps:
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hJ : J ∈ π.biUnion πi
⊢ π.biUnionIndex πi J ∈ π
state_after: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hJ : J ∈ π.biUnion πi
⊢ ⋯.choose ∈ π
tactic: rw [biUnionIndex, dif_pos hJ]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
hJ : J ∈ π.biUnion πi
⊢ ⋯.choose ∈ π
state_after: no goals
tactic: exact (π.mem_biUnion.1 hJ).choose_spec.1
Theorem: nhds_ne_subtype_eq_bot_iff
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝ : TopologicalSpace X
S : Set X
x : ↑S
⊢ 𝓝[≠] x = ⊥ ↔ 𝓝[≠] ↑x ⊓ 𝓟 S = ⊥
state_after: no goals
tactic: rw [← nhdsWithin_subtype_eq_bot_iff, preimage_compl, ← image_singleton,
    Subtype.coe_injective.preimage_image]
Theorem: PowerSeries.coeff_derivativeFun
File: Mathlib/RingTheory/PowerSeries/Derivative.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
n : ℕ
⊢ (coeff R n) f.derivativeFun = (coeff R (n + 1)) f * (↑n + 1)
state_after: no goals
tactic: rw [derivativeFun, coeff_mk]
Theorem: AlgebraicGeometry.Scheme.Hom.preimage_image_eq
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : X.Opens
⊢ f ⁻¹ᵁ f ''ᵁ U = U
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : X.Opens
⊢ ↑(f ⁻¹ᵁ f ''ᵁ U) = ↑U
tactic: apply Opens.ext
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : X.Opens
⊢ ↑(f ⁻¹ᵁ f ''ᵁ U) = ↑U
state_after: no goals
tactic: simp [Set.preimage_image_eq _ f.openEmbedding.inj]
Theorem: UniformContinuous.zpow_const
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ ↑n
state_after: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ n
tactic: simp_rw [zpow_natCast]
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ n
state_after: no goals
tactic: exact hf.pow_const _
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => f x ^ Int.negSucc n
state_after: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => (f x ^ (n + 1))⁻¹
tactic: simp_rw [zpow_negSucc]
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : UniformSpace β
f : β → α
hf : UniformContinuous f
n : ℕ
⊢ UniformContinuous fun x => (f x ^ (n + 1))⁻¹
state_after: no goals
tactic: exact (hf.pow_const _).inv
Theorem: CategoryTheory.Limits.Bicone.ofColimitCocone_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F f : J → C
t : Cocone (Discrete.functor f)
ht : IsColimit t
j j' : J
⊢ (fun j => t.ι.app { as := j }) j ≫
      (fun j => ht.desc (Cofan.mk (f j) fun j' => if h : j' = j then eqToHom ⋯ else 0)) j' =
    if h : j = j' then eqToHom ⋯ else 0
state_after: no goals
tactic: simp
Theorem: List.getElem?_set_eq'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
n : Nat
l : List α
⊢ (l.set n a)[n]? = (fun x => a) <$> l[n]?
state_after: no goals
tactic: simp only [set_eq_modifyNth, getElem?_modifyNth_eq]
Theorem: MonCat.uliftFunctor_map
File: Mathlib/Algebra/Category/MonCat/Basic.lean

Proof steps:
state_before: X : MonCat
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.obj
        X)
state_after: no goals
tactic: rfl
state_before: X Y Z : MonCat
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (f ≫ g) =
    { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        f ≫
      { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        g
state_after: no goals
tactic: rfl
Theorem: Multiset.Ioo_cons_left
File: Mathlib/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : LocallyFiniteOrder α
a b : α
h : a < b
⊢ a ::ₘ Ioo a b = Ico a b
state_after: no goals
tactic: classical
    rw [Ioo, ← Finset.insert_val_of_not_mem left_not_mem_Ioo, Finset.Ioo_insert_left h]
    rfl
Theorem: Set.InjOn.image_diff_subset
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t✝ t₁ t₂ : Set β
p : Set γ
f✝ f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
f : α → β
t : Set α
h : InjOn f s
hst : t ⊆ s
⊢ f '' (s \ t) = f '' s \ f '' t
state_after: no goals
tactic: rw [h.image_diff, inter_eq_self_of_subset_right hst]
Theorem: CircleDeg1Lift.iterate_pos_eq_iff
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f g : CircleDeg1Lift
x : ℝ
m : ℤ
n : ℕ
hn : 0 < n
⊢ (⇑f)^[n] x = x + ↑n * ↑m ↔ f x = x + ↑m
state_after: no goals
tactic: simpa only [nsmul_eq_mul, add_right_iterate] using
    (f.commute_add_int m).iterate_pos_eq_iff_map_eq f.monotone (strictMono_id.add_const (m : ℝ)) hn
Theorem: Set.right_mem_Iic
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Iic a
state_after: no goals
tactic: simp
Theorem: IsPrimitiveRoot.minpoly_dvd_x_pow_sub_one
File: Mathlib/RingTheory/RootsOfUnity/Minpoly.lean

Proof steps:
state_before: n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
⊢ minpoly ℤ μ ∣ X ^ n - 1
state_after: case inl
K : Type u_1
inst✝² : CommRing K
μ : K
inst✝¹ : IsDomain K
inst✝ : CharZero K
h : IsPrimitiveRoot μ 0
⊢ minpoly ℤ μ ∣ X ^ 0 - 1

case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ minpoly ℤ μ ∣ X ^ n - 1
tactic: rcases n.eq_zero_or_pos with (rfl | h0)
state_before: case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ minpoly ℤ μ ∣ X ^ n - 1
state_after: case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ (Polynomial.aeval μ) (X ^ n - 1) = 0
tactic: apply minpoly.isIntegrallyClosed_dvd (isIntegral h h0)
state_before: case inr
n : ℕ
K : Type u_1
inst✝² : CommRing K
μ : K
h : IsPrimitiveRoot μ n
inst✝¹ : IsDomain K
inst✝ : CharZero K
h0 : n > 0
⊢ (Polynomial.aeval μ) (X ^ n - 1) = 0
state_after: no goals
tactic: simp only [((IsPrimitiveRoot.iff_def μ n).mp h).left, aeval_X_pow, eq_intCast, Int.cast_one,
    aeval_one, map_sub, sub_self]
Theorem: Nat.Prime.properDivisors
File: Mathlib/NumberTheory/Divisors.lean

Proof steps:
state_before: n p : ℕ
pp : Prime p
⊢ p.properDivisors = {1}
state_after: no goals
tactic: rw [← erase_insert properDivisors.not_self_mem, insert_self_properDivisors pp.ne_zero,
    pp.divisors, pair_comm, erase_insert fun con => pp.ne_one (mem_singleton.1 con)]
Theorem: List.Chain.sublist
File: Mathlib/Data/List/Chain.lean

Proof steps:
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Chain R a l₂
h : l₁ <+ l₂
⊢ Chain R a l₁
state_after: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Pairwise R (a :: l₂)
h : l₁ <+ l₂
⊢ Pairwise R (a :: l₁)
tactic: rw [chain_iff_pairwise] at hl ⊢
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁ l₂ : List α
a b : α
inst✝ : IsTrans α R
hl : Pairwise R (a :: l₂)
h : l₁ <+ l₂
⊢ Pairwise R (a :: l₁)
state_after: no goals
tactic: exact hl.sublist (h.cons_cons a)
Theorem: CategoryTheory.MonoidalCategory.associator_inv_naturality_middle
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z✝ X Y Y' : C
f : Y ⟶ Y'
Z : C
⊢ X ◁ f ▷ Z ≫ (α_ X Y' Z).inv = (α_ X Y Z).inv ≫ (X ◁ f) ▷ Z
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Idempotents.Karoubi.eqToHom_f
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : Karoubi C
h : P = Q
⊢ (eqToHom h).f = P.p ≫ eqToHom ⋯
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P : Karoubi C
⊢ (eqToHom ⋯).f = P.p ≫ eqToHom ⋯
tactic: subst h
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P : Karoubi C
⊢ (eqToHom ⋯).f = P.p ≫ eqToHom ⋯
state_after: no goals
tactic: simp only [eqToHom_refl, Karoubi.id_f, comp_id]
Theorem: EuclideanGeometry.affineIndependent_iff_of_two_zsmul_oangle_eq
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ p₅ p₆ : P
h : 2 • ∡ p₁ p₂ p₃ = 2 • ∡ p₄ p₅ p₆
⊢ AffineIndependent ℝ ![p₁, p₂, p₃] ↔ AffineIndependent ℝ ![p₄, p₅, p₆]
state_after: no goals
tactic: simp_rw [← oangle_ne_zero_and_ne_pi_iff_affineIndependent, ← Real.Angle.two_zsmul_ne_zero_iff, h]
Theorem: comap_norm_nhdsWithin_Ioi_zero'
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : NormedGroup E
inst✝ : NormedGroup F
a b : E
⊢ comap norm (𝓝[>] 0) = 𝓝[≠] 1
state_after: no goals
tactic: simp [nhdsWithin, comap_norm_nhds_one, Set.preimage, Set.compl_def]
Theorem: Complex.mul_cpow_ofReal_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
state_after: case inl
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ (↑a * ↑b) ^ 0 = ↑a ^ 0 * ↑b ^ 0

case inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
tactic: rcases eq_or_ne r 0 with (rfl | hr)
state_before: case inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
state_after: case inr.inl
b : ℝ
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha : 0 ≤ 0
⊢ (↑0 * ↑b) ^ r = ↑0 ^ r * ↑b ^ r

case inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
tactic: rcases eq_or_lt_of_le ha with (rfl | ha')
state_before: case inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
state_after: case inr.inr.inl
a : ℝ
ha : 0 ≤ a
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb : 0 ≤ 0
⊢ (↑a * ↑0) ^ r = ↑a ^ r * ↑0 ^ r

case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
tactic: rcases eq_or_lt_of_le hb with (rfl | hb')
state_before: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
state_after: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
ha'' : ↑a ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
tactic: have ha'' : (a : ℂ) ≠ 0 := ofReal_ne_zero.mpr ha'.ne'
state_before: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
ha'' : ↑a ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
state_after: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
ha'' : ↑a ≠ 0
hb'' : ↑b ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
tactic: have hb'' : (b : ℂ) ≠ 0 := ofReal_ne_zero.mpr hb'.ne'
state_before: case inr.inr.inr
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
r : ℂ
hr : r ≠ 0
ha' : 0 < a
hb' : 0 < b
ha'' : ↑a ≠ 0
hb'' : ↑b ≠ 0
⊢ (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r
state_after: no goals
tactic: rw [cpow_def_of_ne_zero (mul_ne_zero ha'' hb''), log_ofReal_mul ha' hb'', ofReal_log ha,
    add_mul, exp_add, ← cpow_def_of_ne_zero ha'', ← cpow_def_of_ne_zero hb'']
Theorem: Nat.pow_sub_le_descFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ (n + 1 - 0) ^ 0 ≤ n.descFactorial 0
state_after: no goals
tactic: rw [descFactorial_zero, Nat.pow_zero]
state_before: n k : ℕ
⊢ (n + 1 - (k + 1)) ^ (k + 1) ≤ n.descFactorial (k + 1)
state_after: n k : ℕ
⊢ (n - k) * (n - k) ^ k ≤ (n - k) * n.descFactorial k
tactic: rw [descFactorial_succ, Nat.pow_succ, succ_sub_succ, Nat.mul_comm]
state_before: n k : ℕ
⊢ (n - k) * (n - k) ^ k ≤ (n - k) * n.descFactorial k
state_after: case h
n k : ℕ
⊢ (n - k) ^ k ≤ n.descFactorial k
tactic: apply Nat.mul_le_mul_left
state_before: case h
n k : ℕ
⊢ (n - k) ^ k ≤ n.descFactorial k
state_after: no goals
tactic: exact (le_trans (Nat.pow_le_pow_left (Nat.sub_le_sub_right n.le_succ _) k)
      (pow_sub_le_descFactorial n k))
Theorem: MvPolynomial.totalDegree_zero_iff_isHomogeneous
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝¹ inst✝ : CommSemiring R
p : MvPolynomial σ R
⊢ p.totalDegree = 0 ↔ p.IsHomogeneous 0
state_after: no goals
tactic: rw [← weightedTotalDegree_one,
    ← isWeightedHomogeneous_zero_iff_weightedTotalDegree_eq_zero, IsHomogeneous]
Theorem: continuousMul_inf
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝¹ : TopologicalSpace X
ι' : Sort u_6
inst✝ : Mul M
t₁ t₂ : TopologicalSpace M
h₁ : ContinuousMul M
h₂ : ContinuousMul M
⊢ ContinuousMul M
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝¹ : TopologicalSpace X
ι' : Sort u_6
inst✝ : Mul M
t₁ t₂ : TopologicalSpace M
h₁ : ContinuousMul M
h₂ : ContinuousMul M
b : Bool
⊢ ContinuousMul M
tactic: refine continuousMul_iInf fun b => ?_
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝¹ : TopologicalSpace X
ι' : Sort u_6
inst✝ : Mul M
t₁ t₂ : TopologicalSpace M
h₁ : ContinuousMul M
h₂ : ContinuousMul M
b : Bool
⊢ ContinuousMul M
state_after: no goals
tactic: cases b <;> assumption
Theorem: CategoryTheory.Comma.post_obj_hom
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁷ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁶ : Category.{v₂, u₂} B
T : Type u₃
inst✝⁵ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝⁴ : Category.{?u.158446, u_1} A'
inst✝³ : Category.{?u.158450, u_2} B'
inst✝² : Category.{?u.158454, u_3} T'
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
L : A ⥤ T
R : B ⥤ T
F : T ⥤ C
X✝ Y✝ : Comma L R
f : X✝ ⟶ Y✝
⊢ (L ⋙ F).map f.left ≫ ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) Y✝).hom =
    ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) X✝).hom ≫ (R ⋙ F).map f.right
state_after: no goals
tactic: simp only [Functor.comp_map, ← F.map_comp, f.w]
Theorem: CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_hom_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : Augmented C
⊢ X.rightOp.leftOp.right = X.right
state_after: no goals
tactic: aesop_cat
Theorem: Zsqrtd.muld_val
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d x y : ℤ
⊢ sqrtd * { re := x, im := y } = { re := d * y, im := x }
state_after: no goals
tactic: ext <;> simp
Theorem: CochainComplex.HomComplex.Cochain.rightShiftAddEquiv_symm_apply
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n a n' : ℤ
hn' : n' + a = n
γ : Cochain K L n
⊢ (fun γ => γ.rightUnshift n hn') ((fun γ => γ.rightShift a n' hn') γ) = γ
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n a n' : ℤ
hn' : n' + a = n
γ : Cochain K ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj L) n'
⊢ (fun γ => γ.rightShift a n' hn') ((fun γ => γ.rightUnshift n hn') γ) = γ
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n a n' : ℤ
hn' : n' + a = n
γ γ' : Cochain K L n
⊢ { toFun := fun γ => γ.rightShift a n' hn', invFun := fun γ => γ.rightUnshift n hn', left_inv := ⋯,
          right_inv := ⋯ }.toFun
      (γ + γ') =
    { toFun := fun γ => γ.rightShift a n' hn', invFun := fun γ => γ.rightUnshift n hn', left_inv := ⋯,
            right_inv := ⋯ }.toFun
        γ +
      { toFun := fun γ => γ.rightShift a n' hn', invFun := fun γ => γ.rightUnshift n hn', left_inv := ⋯,
            right_inv := ⋯ }.toFun
        γ'
state_after: no goals
tactic: simp
Theorem: EMetric.countable_closure_of_compact
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
hs : IsCompact s
⊢ ∃ t ⊆ s, t.Countable ∧ s = closure t
state_after: case intro.intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
hs : IsCompact s
t : Set γ
hts : t ⊆ s
htc : t.Countable
hsub : s ⊆ closure t
⊢ ∃ t ⊆ s, t.Countable ∧ s = closure t
tactic: rcases subset_countable_closure_of_compact hs with ⟨t, hts, htc, hsub⟩
state_before: case intro.intro.intro
α : Type u
β : Type v
X : Type u_1
inst✝¹ : PseudoEMetricSpace α
γ : Type w
inst✝ : EMetricSpace γ
s : Set γ
hs : IsCompact s
t : Set γ
hts : t ⊆ s
htc : t.Countable
hsub : s ⊆ closure t
⊢ ∃ t ⊆ s, t.Countable ∧ s = closure t
state_after: no goals
tactic: exact ⟨t, hts, htc, hsub.antisymm (closure_minimal hts hs.isClosed)⟩
Theorem: CategoryTheory.ShortComplex.Exact.isZero_X₂_iff
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.72498, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ IsZero S.X₂ ↔ S.f = 0 ∧ S.g = 0
state_after: case mp
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.72498, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ IsZero S.X₂ → S.f = 0 ∧ S.g = 0

case mpr
C : Type u_1
D : Type u_2
inst✝³ : Category.{u_3, u_1} C
inst✝² : Category.{?u.72498, u_2} D
inst✝¹ : Preadditive C
inst✝ : Preadditive D
S : ShortComplex C
hS : S.Exact
⊢ S.f = 0 ∧ S.g = 0 → IsZero S.X₂
tactic: constructor
Theorem: PNat.gcd_comm
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: m n : ℕ+
⊢ m.gcd n = n.gcd m
state_after: case a
m n : ℕ+
⊢ ↑(m.gcd n) = ↑(n.gcd m)
tactic: apply eq
state_before: case a
m n : ℕ+
⊢ ↑(m.gcd n) = ↑(n.gcd m)
state_after: case a
m n : ℕ+
⊢ (↑m).gcd ↑n = (↑n).gcd ↑m
tactic: simp only [gcd_coe]
state_before: case a
m n : ℕ+
⊢ (↑m).gcd ↑n = (↑n).gcd ↑m
state_after: no goals
tactic: apply Nat.gcd_comm
Theorem: Polynomial.smeval_zero
File: Mathlib/Algebra/Polynomial/Smeval.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : Semiring R
r : R
p : R[X]
S : Type u_2
inst✝² : AddCommMonoid S
inst✝¹ : Pow S ℕ
inst✝ : MulActionWithZero R S
x : S
⊢ smeval 0 x = 0
state_after: no goals
tactic: simp only [smeval_eq_sum, smul_pow, sum_zero_index]
Theorem: Set.Intersecting.card_le
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : BooleanAlgebra α
inst✝ : Fintype α
s : Finset α
hs : (↑s).Intersecting
⊢ 2 * s.card ≤ Fintype.card α
state_after: no goals
tactic: classical
    refine (s.disjUnion _ hs.disjoint_map_compl).card_le_univ.trans_eq' ?_
    rw [Nat.two_mul, card_disjUnion, card_map]
Theorem: Multiset.pairwise_coe_iff
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
r : α → α → Prop
l : List α
⊢ ∀ (a : List α), ↑l = ↑a ∧ List.Pairwise r a ↔ l ~ a ∧ List.Pairwise r a
state_after: no goals
tactic: simp
Theorem: iteratedDerivWithin_const_mul
File: Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
n : ℕ
x : 𝕜
s : Set 𝕜
hx : x ∈ s
h : UniqueDiffOn 𝕜 s
f✝ g : 𝕜 → F
c : 𝕜
f : 𝕜 → 𝕜
hf : ContDiffOn 𝕜 (↑n) f s
⊢ iteratedDerivWithin n (fun z => c * f z) s x = c * iteratedDerivWithin n f s x
state_after: no goals
tactic: simpa using iteratedDerivWithin_const_smul (F := 𝕜) hx h c hf