ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Metric.cthickening_eq_iInter_cthickening'
File: Mathlib/Topology/MetricSpace/Thickening.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
δ : ℝ
s : Set ℝ
hsδ : s ⊆ Ioi δ
hs : ∀ (ε : ℝ), δ < ε → (s ∩ Ioc δ ε).Nonempty
E : Set α
⊢ cthickening δ E = ⋂ ε ∈ s, cthickening ε E
state_after: case h₁
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
δ : ℝ
s : Set ℝ
hsδ : s ⊆ Ioi δ
hs : ∀ (ε : ℝ), δ < ε → (s ∩ Ioc δ ε).Nonempty
E : Set α
⊢ cthickening δ E ⊆ ⋂ ε ∈ s, cthickening ε E

case h₂
ι : Sort u_1
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s✝ t : Set α
x : α
δ : ℝ
s : Set ℝ
hsδ : s ⊆ Ioi δ
hs : ∀ (ε : ℝ), δ < ε → (s ∩ Ioc δ ε).Nonempty
E : Set α
⊢ ⋂ ε ∈ s, cthickening ε E ⊆ cthickening δ E
tactic: apply Subset.antisymm
Theorem: rel_iSup_tprod
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s : β → α
⊢ R (m (⨆ b, s b)) (∏' (b : β), m (s b))
state_after: case intro
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s : β → α
val✝ : Encodable β
⊢ R (m (⨆ b, s b)) (∏' (b : β), m (s b))
tactic: cases nonempty_encodable β
state_before: case intro
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s : β → α
val✝ : Encodable β
⊢ R (m (⨆ b, s b)) (∏' (b : β), m (s b))
state_after: case intro
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s : β → α
val✝ : Encodable β
⊢ R (m (⨆ i, ⨆ b ∈ decode₂ β i, s b)) (∏' (i : ℕ), m (⨆ b ∈ decode₂ β i, s b))
tactic: rw [← iSup_decode₂, ← tprod_iSup_decode₂ _ m0 s]
state_before: case intro
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m✝ m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : T2Space M
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Countable β
inst✝ : CompleteLattice α
m : α → M
m0 : m ⊥ = 1
R : M → M → Prop
m_iSup : ∀ (s : ℕ → α), R (m (⨆ i, s i)) (∏' (i : ℕ), m (s i))
s : β → α
val✝ : Encodable β
⊢ R (m (⨆ i, ⨆ b ∈ decode₂ β i, s b)) (∏' (i : ℕ), m (⨆ b ∈ decode₂ β i, s b))
state_after: no goals
tactic: exact m_iSup _
Theorem: HurwitzZeta.differentiable_hurwitzZetaEven_sub_hurwitzZetaEven
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a b : UnitAddCircle
⊢ Differentiable ℂ fun s => hurwitzZetaEven a s - hurwitzZetaEven b s
state_after: a b : UnitAddCircle
z : ℂ
⊢ DifferentiableAt ℂ (fun s => hurwitzZetaEven a s - hurwitzZetaEven b s) z
tactic: intro z
state_before: a b : UnitAddCircle
z : ℂ
⊢ DifferentiableAt ℂ (fun s => hurwitzZetaEven a s - hurwitzZetaEven b s) z
state_after: case inl
a b : UnitAddCircle
z : ℂ
hz : z ≠ 1
⊢ DifferentiableAt ℂ (fun s => hurwitzZetaEven a s - hurwitzZetaEven b s) z

case inr
a b : UnitAddCircle
⊢ DifferentiableAt ℂ (fun s => hurwitzZetaEven a s - hurwitzZetaEven b s) 1
tactic: rcases ne_or_eq z 1 with hz | rfl
Theorem: CategoryTheory.ShortComplex.leftHomologyMap'_comp
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ₁ : S₁ ⟶ S₂
φ₂ : S₂ ⟶ S₃
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
h₃ : S₃.LeftHomologyData
⊢ leftHomologyMap' (φ₁ ≫ φ₂) h₁ h₃ = leftHomologyMap' φ₁ h₁ h₂ ≫ leftHomologyMap' φ₂ h₂ h₃
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ₁ : S₁ ⟶ S₂
φ₂ : S₂ ⟶ S₃
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
h₃ : S₃.LeftHomologyData
γ₁ : LeftHomologyMapData φ₁ h₁ h₂ := leftHomologyMapData φ₁ h₁ h₂
⊢ leftHomologyMap' (φ₁ ≫ φ₂) h₁ h₃ = leftHomologyMap' φ₁ h₁ h₂ ≫ leftHomologyMap' φ₂ h₂ h₃
tactic: let γ₁ := leftHomologyMapData φ₁ h₁ h₂
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ₁ : S₁ ⟶ S₂
φ₂ : S₂ ⟶ S₃
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
h₃ : S₃.LeftHomologyData
γ₁ : LeftHomologyMapData φ₁ h₁ h₂ := leftHomologyMapData φ₁ h₁ h₂
⊢ leftHomologyMap' (φ₁ ≫ φ₂) h₁ h₃ = leftHomologyMap' φ₁ h₁ h₂ ≫ leftHomologyMap' φ₂ h₂ h₃
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ₁ : S₁ ⟶ S₂
φ₂ : S₂ ⟶ S₃
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
h₃ : S₃.LeftHomologyData
γ₁ : LeftHomologyMapData φ₁ h₁ h₂ := leftHomologyMapData φ₁ h₁ h₂
γ₂ : LeftHomologyMapData φ₂ h₂ h₃ := leftHomologyMapData φ₂ h₂ h₃
⊢ leftHomologyMap' (φ₁ ≫ φ₂) h₁ h₃ = leftHomologyMap' φ₁ h₁ h₂ ≫ leftHomologyMap' φ₂ h₂ h₃
tactic: let γ₂ := leftHomologyMapData φ₂ h₂ h₃
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
φ₁ : S₁ ⟶ S₂
φ₂ : S₂ ⟶ S₃
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
h₃ : S₃.LeftHomologyData
γ₁ : LeftHomologyMapData φ₁ h₁ h₂ := leftHomologyMapData φ₁ h₁ h₂
γ₂ : LeftHomologyMapData φ₂ h₂ h₃ := leftHomologyMapData φ₂ h₂ h₃
⊢ leftHomologyMap' (φ₁ ≫ φ₂) h₁ h₃ = leftHomologyMap' φ₁ h₁ h₂ ≫ leftHomologyMap' φ₂ h₂ h₃
state_after: no goals
tactic: rw [γ₁.leftHomologyMap'_eq, γ₂.leftHomologyMap'_eq, (γ₁.comp γ₂).leftHomologyMap'_eq,
    LeftHomologyMapData.comp_φH]
Theorem: MeasureTheory.lintegral_le_of_forall_fin_meas_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m m0 : MeasurableSpace α
E : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : MeasurableSpace E
inst✝² : OpensMeasurableSpace E
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
C : ℝ≥0∞
f : α → ℝ≥0∞
hf : ∀ (s : Set α), MeasurableSet s → μ s ≠ ⊤ → ∫⁻ (x : α) in s, f x ∂μ ≤ C
⊢ SigmaFinite (μ.trim ?m.540668)
state_after: no goals
tactic: rwa [trim_eq_self]
Theorem: IsAddRightRegular.of_add
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
⊢ IsRightRegular b
state_after: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
x y : R
xy : (fun x => x * b) x = (fun x => x * b) y
⊢ x * (b * a) = y * (b * a)
tactic: refine fun x y xy => ab (?_ : x * (b * a) = y * (b * a))
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
x y : R
xy : (fun x => x * b) x = (fun x => x * b) y
⊢ x * (b * a) = y * (b * a)
state_after: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsRightRegular (b * a)
x y : R
xy : (fun x => x * b) x = (fun x => x * b) y
⊢ x * b * a = y * b * a
tactic: rw [← mul_assoc, ← mul_assoc]
Theorem: Finset.mem_dfinsupp_iff_of_support_subset
File: Mathlib/Data/DFinsupp/Interval.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : t.support ⊆ s
⊢ f ∈ s.dfinsupp ⇑t ↔ ∀ (i : ι), f i ∈ t i
state_after: case refine_1
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : t.support ⊆ s
i : ι
h : (i ∈ f.support → i ∈ s) ∧ (i ∈ s → f i ∈ t i)
⊢ f i ∈ t i

case refine_2
ι : Type u_1
α : ι → Type u_2
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (α i)
s : Finset ι
f : Π₀ (i : ι), α i
t✝ : (i : ι) → Finset (α i)
inst✝ : (i : ι) → DecidableEq (α i)
t : Π₀ (i : ι), Finset (α i)
ht : t.support ⊆ s
i : ι
h : f i ∈ t i
hi : i ∈ f.support
H : t i = 0
⊢ f i = 0
tactic: refine mem_dfinsupp_iff.trans (forall_and.symm.trans <| forall_congr' fun i =>
      ⟨ fun h => ?_,
        fun h => ⟨fun hi => ht <| mem_support_iff.2 fun H => mem_support_iff.1 hi ?_, fun _ => h⟩⟩)
Theorem: CliffordAlgebra.contractLeft_ι_mul
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

Proof steps:
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
a : M
b : CliffordAlgebra Q
⊢ (contractLeft d) ((ι Q) a * b) = d a • b - (ι Q) a * (contractLeft d) b
state_after: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
a : M
b : CliffordAlgebra Q
⊢ ∀ (m : M) (x fx : CliffordAlgebra Q),
    ((contractLeftAux Q d) m) ((ι Q) m * x, ((contractLeftAux Q d) m) (x, fx)) = Q m • fx
tactic: refine foldr'_ι_mul _ _ ?_ _ _ _
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
a : M
b : CliffordAlgebra Q
⊢ ∀ (m : M) (x fx : CliffordAlgebra Q),
    ((contractLeftAux Q d) m) ((ι Q) m * x, ((contractLeftAux Q d) m) (x, fx)) = Q m • fx
state_after: no goals
tactic: exact fun m x fx ↦ contractLeftAux_contractLeftAux Q d m x fx
Theorem: Sym.map_id
File: Mathlib/Data/Sym/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
n✝ n' m : ℕ
s✝ : Sym α✝ n✝
a b : α✝
α : Type u_3
n : ℕ
s : Sym α n
⊢ map id s = s
state_after: case h
α✝ : Type u_1
β : Type u_2
n✝ n' m : ℕ
s✝ : Sym α✝ n✝
a b : α✝
α : Type u_3
n : ℕ
s : Sym α n
⊢ ↑(map id s) = ↑s
tactic: ext
state_before: case h
α✝ : Type u_1
β : Type u_2
n✝ n' m : ℕ
s✝ : Sym α✝ n✝
a b : α✝
α : Type u_3
n : ℕ
s : Sym α n
⊢ ↑(map id s) = ↑s
state_after: no goals
tactic: simp only [map, id_eq, Multiset.map_id', ← val_eq_coe]
Theorem: AffineIndependent.finrank_vectorSpan_image_finset
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : DecidableEq P
p : ι → P
hi : AffineIndependent k p
s : Finset ι
n : ℕ
hc : s.card = n + 1
⊢ finrank k ↥(vectorSpan k ↑(Finset.image p s)) = n
state_after: no goals
tactic: classical
  have hi' := hi.range.mono (Set.image_subset_range p ↑s)
  have hc' : (s.image p).card = n + 1 := by rwa [s.card_image_of_injective hi.injective]
  have hn : (s.image p).Nonempty := by simp [hc', ← Finset.card_pos]
  rcases hn with ⟨p₁, hp₁⟩
  have hp₁' : p₁ ∈ p '' s := by simpa using hp₁
  rw [affineIndependent_set_iff_linearIndependent_vsub k hp₁', ← Finset.coe_singleton,
    ← Finset.coe_image, ← Finset.coe_sdiff, Finset.sdiff_singleton_eq_erase, ← Finset.coe_image]
    at hi'
  have hc : (Finset.image (fun p : P => p -ᵥ p₁) ((Finset.image p s).erase p₁)).card = n := by
    rw [Finset.card_image_of_injective _ (vsub_left_injective _), Finset.card_erase_of_mem hp₁]
    exact Nat.pred_eq_of_eq_succ hc'
  rwa [vectorSpan_eq_span_vsub_finset_right_ne k hp₁, finrank_span_finset_eq_card, hc]
Theorem: midpoint_eq_smul_add
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z : P
x y : V
⊢ midpoint R x y = ⅟2 • (x + y)
state_after: no goals
tactic: rw [midpoint_eq_iff, pointReflection_apply, vsub_eq_sub, vadd_eq_add, sub_add_eq_add_sub, ←
    two_smul R, smul_smul, mul_invOf_self, one_smul, add_sub_cancel_left]
Theorem: Finset.compl_erase
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a : α
⊢ (s.erase a)ᶜ = insert a sᶜ
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a a✝ : α
⊢ a✝ ∈ (s.erase a)ᶜ ↔ a✝ ∈ insert a sᶜ
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Fintype α
s t : Finset α
inst✝ : DecidableEq α
a a✝ : α
⊢ a✝ ∈ (s.erase a)ᶜ ↔ a✝ ∈ insert a sᶜ
state_after: no goals
tactic: simp only [or_iff_not_imp_left, mem_insert, not_and, mem_compl, mem_erase]
Theorem: PNat.Coprime.factor_eq_gcd_right_right
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = m.gcd (b * a)
state_after: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (b * a).gcd m
tactic: rw [gcd_comm]
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (b * a).gcd m
state_after: no goals
tactic: apply Coprime.factor_eq_gcd_right cop am bn
Theorem: Polynomial.natTrailingDegree_monomial
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ ((monomial n) a).natTrailingDegree = n
state_after: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ (↑n).toNat = n
tactic: rw [natTrailingDegree, trailingDegree_monomial ha]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
ha : a ≠ 0
⊢ (↑n).toNat = n
state_after: no goals
tactic: rfl
Theorem: inner_sum_smul_sum_smul_of_sum_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
ι₁ : Type u_4
s₁ : Finset ι₁
w₁ : ι₁ → ℝ
v₁ : ι₁ → F
h₁ : ∑ i ∈ s₁, w₁ i = 0
ι₂ : Type u_5
s₂ : Finset ι₂
w₂ : ι₂ → ℝ
v₂ : ι₂ → F
h₂ : ∑ i ∈ s₂, w₂ i = 0
⊢ ⟪∑ i₁ ∈ s₁, w₁ i₁ • v₁ i₁, ∑ i₂ ∈ s₂, w₂ i₂ • v₂ i₂⟫_ℝ =
    (-∑ i₁ ∈ s₁, ∑ i₂ ∈ s₂, w₁ i₁ * w₂ i₂ * (‖v₁ i₁ - v₂ i₂‖ * ‖v₁ i₁ - v₂ i₂‖)) / 2
state_after: no goals
tactic: simp_rw [sum_inner, inner_sum, real_inner_smul_left, real_inner_smul_right,
    real_inner_eq_norm_mul_self_add_norm_mul_self_sub_norm_sub_mul_self_div_two, ← div_sub_div_same,
    ← div_add_div_same, mul_sub_left_distrib, left_distrib, Finset.sum_sub_distrib,
    Finset.sum_add_distrib, ← Finset.mul_sum, ← Finset.sum_mul, h₁, h₂, zero_mul,
    mul_zero, Finset.sum_const_zero, zero_add, zero_sub, Finset.mul_sum, neg_div,
    Finset.sum_div, mul_div_assoc, mul_assoc]
Theorem: Real.continuousAt_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: p : ℝ × ℝ
hp : 0 < p.2
⊢ ContinuousAt (fun p => p.1 ^ p.2) p
state_after: case mk
x y : ℝ
hp : 0 < (x, y).2
⊢ ContinuousAt (fun p => p.1 ^ p.2) (x, y)
tactic: cases' p with x y
state_before: case mk
x y : ℝ
hp : 0 < (x, y).2
⊢ ContinuousAt (fun p => p.1 ^ p.2) (x, y)
state_after: case mk
x y : ℝ
hp : 0 < y
⊢ ContinuousAt (fun p => p.1 ^ p.2) (x, y)
tactic: dsimp only at hp
state_before: case mk
x y : ℝ
hp : 0 < y
⊢ ContinuousAt (fun p => p.1 ^ p.2) (x, y)
state_after: case mk.inl
x y : ℝ
hp : 0 < y
hx : x ≠ 0
⊢ ContinuousAt (fun p => p.1 ^ p.2) (x, y)

case mk.inr
y : ℝ
hp : 0 < y
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
tactic: obtain hx | rfl := ne_or_eq x 0
state_before: case mk.inr
y : ℝ
hp : 0 < y
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
state_after: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => rexp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
tactic: have A : Tendsto (fun p : ℝ × ℝ => exp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0) :=
    tendsto_exp_atBot.comp
      ((tendsto_log_nhdsWithin_zero.comp tendsto_fst).atBot_mul hp tendsto_snd)
state_before: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => rexp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
state_after: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => rexp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.1 ^ p.2) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
tactic: have B : Tendsto (fun p : ℝ × ℝ => p.1 ^ p.2) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0) :=
    squeeze_zero_norm (fun p => abs_rpow_le_exp_log_mul p.1 p.2) A
state_before: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => rexp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.1 ^ p.2) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
state_after: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => rexp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.1 ^ p.2) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
C : Tendsto (fun p => p.1 ^ p.2) (𝓝[{0}] 0 ×ˢ 𝓝 y) (pure 0)
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
tactic: have C : Tendsto (fun p : ℝ × ℝ => p.1 ^ p.2) (𝓝[{0}] 0 ×ˢ 𝓝 y) (pure 0) := by
    rw [nhdsWithin_singleton, tendsto_pure, pure_prod, eventually_map]
    exact (lt_mem_nhds hp).mono fun y hy => zero_rpow hy.ne'
state_before: case mk.inr
y : ℝ
hp : 0 < y
A : Tendsto (fun p => rexp (log p.1 * p.2)) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
B : Tendsto (fun p => p.1 ^ p.2) (𝓝[≠] 0 ×ˢ 𝓝 y) (𝓝 0)
C : Tendsto (fun p => p.1 ^ p.2) (𝓝[{0}] 0 ×ˢ 𝓝 y) (pure 0)
⊢ ContinuousAt (fun p => p.1 ^ p.2) (0, y)
state_after: no goals
tactic: simpa only [← sup_prod, ← nhdsWithin_union, compl_union_self, nhdsWithin_univ, nhds_prod_eq,
    ContinuousAt, zero_rpow hp.ne'] using B.sup (C.mono_right (pure_le_nhds _))
Theorem: sub_nsmul_nsmul_add
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Monoid M
a✝ b c : M
m n : ℕ
a : M
h : m ≤ n
⊢ a ^ (n - m) * a ^ m = a ^ n
state_after: no goals
tactic: rw [← pow_add, Nat.sub_add_cancel h]
Theorem: CategoryTheory.OverPresheafAux.YonedaCollection.map₂_comp
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
⊢ map₂ F (f ≫ g) = map₂ F f ∘ map₂ F g
state_after: case h.h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝¹ : YonedaCollection F Z
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ F (f ≫ g) x✝¹).fst.app x✝ a✝ = ((map₂ F f ∘ map₂ F g) x✝¹).fst.app x✝ a✝

case h.h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝ : YonedaCollection F Z
⊢ F.map (eqToHom ⋯) ((map₂ F f ∘ map₂ F g) x✝).snd = (map₂ F (f ≫ g) x✝).snd
tactic: ext
state_before: case h.h.w.h.h
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝¹ : YonedaCollection F Z
x✝ : Cᵒᵖ
a✝ : (yoneda.obj X).obj x✝
⊢ (map₂ F (f ≫ g) x✝¹).fst.app x✝ a✝ = ((map₂ F f ∘ map₂ F g) x✝¹).fst.app x✝ a✝

case h.h'
C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
x✝ : YonedaCollection F Z
⊢ F.map (eqToHom ⋯) ((map₂ F f ∘ map₂ F g) x✝).snd = (map₂ F (f ≫ g) x✝).snd
state_after: no goals
tactic: all_goals simp
Theorem: toIcoDiv_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b + m • p - (toIcoDiv hp a b + m) • p ∈ Set.Ico a (a + p)
state_after: no goals
tactic: simpa only [add_smul, add_sub_add_right_eq_sub] using sub_toIcoDiv_zsmul_mem_Ico hp a b
Theorem: MeasureTheory.sFiniteSeq_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
n : ℕ
⊢ sFiniteSeq 0 n = 0
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
⊢ (sFiniteSeq 0 n) s = 0 s
tactic: ext s hs
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
⊢ (sFiniteSeq 0 n) s = 0 s
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∑' (n : ℕ), (sFiniteSeq 0 n) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s
tactic: have h : ∑' n, sFiniteSeq (0 : Measure α) n s = 0 := by
    simp [← Measure.sum_apply _ hs, sum_sFiniteSeq]
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∑' (n : ℕ), (sFiniteSeq 0 n) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∀ (i : ℕ), (sFiniteSeq 0 i) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s
tactic: simp only [ENNReal.tsum_eq_zero] at h
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
n : ℕ
s : Set α
hs : MeasurableSet s
h : ∀ (i : ℕ), (sFiniteSeq 0 i) s = 0
⊢ (sFiniteSeq 0 n) s = 0 s
state_after: no goals
tactic: exact h n
Theorem: Stream'.Seq.map_id
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Stream' (Option α)
al : s.IsSeq
⊢ map id ⟨s, al⟩ = ⟨s, al⟩
state_after: case a
α : Type u
β : Type v
γ : Type w
s : Stream' (Option α)
al : s.IsSeq
⊢ ↑(map id ⟨s, al⟩) = ↑⟨s, al⟩
tactic: apply Subtype.eq
state_before: case a
α : Type u
β : Type v
γ : Type w
s : Stream' (Option α)
al : s.IsSeq
⊢ ↑(map id ⟨s, al⟩) = ↑⟨s, al⟩
state_after: case a
α : Type u
β : Type v
γ : Type w
s : Stream' (Option α)
al : s.IsSeq
⊢ Stream'.map (Option.map id) s = s
tactic: dsimp [map]
state_before: case a
α : Type u
β : Type v
γ : Type w
s : Stream' (Option α)
al : s.IsSeq
⊢ Stream'.map (Option.map id) s = s
state_after: no goals
tactic: rw [Option.map_id, Stream'.map_id]
Theorem: AlgebraicGeometry.Scheme.iso_inv_val_base_hom_val_base_apply
File: Mathlib/AlgebraicGeometry/Scheme.lean

Proof steps:
state_before: X Y : Scheme
e : X ≅ Y
y : ↑↑Y.toPresheafedSpace
⊢ e.hom.val.base (e.inv.val.base y) = y
state_after: X Y : Scheme
e : X ≅ Y
y : ↑↑Y.toPresheafedSpace
⊢ (e.inv.val.base ≫ e.hom.val.base) y = (𝟙 Y.toPresheafedSpace).base y
tactic: show (e.inv.val.base ≫ e.hom.val.base) y = 𝟙 Y.toPresheafedSpace y
state_before: X Y : Scheme
e : X ≅ Y
y : ↑↑Y.toPresheafedSpace
⊢ (e.inv.val.base ≫ e.hom.val.base) y = (𝟙 Y.toPresheafedSpace).base y
state_after: no goals
tactic: simp
Theorem: IsSelfAdjoint.star_mul_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝¹ : Mul R
inst✝ : StarMul R
x : R
⊢ IsSelfAdjoint (star x * x)
state_after: no goals
tactic: simp only [IsSelfAdjoint, star_mul, star_star]