ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.sum_erase
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : f a = 1
⊢ ∏ x ∈ s.erase a, f x = ∏ x ∈ s, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : f a = 1
⊢ ∏ x ∈ s \ {a}, f x = ∏ x ∈ s, f x
tactic: rw [← sdiff_singleton_eq_erase]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : f a = 1
⊢ ∏ x ∈ s \ {a}, f x = ∏ x ∈ s, f x
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : f a = 1
x : α
hx : x ∈ s
hnx : x ∉ s \ {a}
⊢ f x = 1
tactic: refine prod_subset sdiff_subset fun x hx hnx => ?_
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : f a = 1
x : α
hx : x ∈ s
hnx : x ∉ s \ {a}
⊢ f x = 1
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : f a = 1
x : α
hx : x ∈ s
hnx : x ∉ s.erase a
⊢ f x = 1
tactic: rw [sdiff_singleton_eq_erase] at hnx
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : f a = 1
x : α
hx : x ∈ s
hnx : x ∉ s.erase a
⊢ f x = 1
state_after: no goals
tactic: rwa [eq_of_mem_of_not_mem_erase hx hnx]
Theorem: isOpen_setOf_eventually_nhdsWithin
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
p : X → Prop
⊢ IsOpen {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
p : X → Prop
a : X
ha : a ∈ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}
⊢ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y} ∈ 𝓝 a
tactic: refine isOpen_iff_mem_nhds.mpr fun a ha => ?_
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
p : X → Prop
a : X
ha : a ∈ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}
⊢ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y} ∈ 𝓝 a
state_after: case h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
p : X → Prop
a : X
ha : a ∈ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}
b : X
hb : ∀ᶠ (x : X) in 𝓝[{a}ᶜ] b, p x
⊢ ∀ᶠ (y : X) in 𝓝[≠] b, p y
tactic: filter_upwards [eventually_nhds_nhdsWithin.mpr ha] with b hb
state_before: case h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
p : X → Prop
a : X
ha : a ∈ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}
b : X
hb : ∀ᶠ (x : X) in 𝓝[{a}ᶜ] b, p x
⊢ ∀ᶠ (y : X) in 𝓝[≠] b, p y
state_after: case h.inl
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
p : X → Prop
a : X
ha : a ∈ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}
hb : ∀ᶠ (x : X) in 𝓝[≠] a, p x
⊢ ∀ᶠ (y : X) in 𝓝[≠] a, p y

case h.inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
p : X → Prop
a : X
ha : a ∈ {x | ∀ᶠ (y : X) in 𝓝[≠] x, p y}
b : X
hb : ∀ᶠ (x : X) in 𝓝[{a}ᶜ] b, p x
h : a ≠ b
⊢ ∀ᶠ (y : X) in 𝓝[≠] b, p y
tactic: rcases eq_or_ne a b with rfl | h
Theorem: CategoryTheory.Limits.limitUncurryIsoLimitCompLim_hom_π_π
File: Mathlib/CategoryTheory/Limits/Fubini.lean

Proof steps:
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ (limitUncurryIsoLimitCompLim F).hom ≫ limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k = limit.π (uncurry.obj F) (j, k)
state_after: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ limit.lift (F ⋙ lim) (coneOfConeUncurry (fun j => limit.isLimit (F.obj j)) (limit.cone (uncurry.obj F))) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (uncurry.obj F) (j, k)
tactic: dsimp [limitUncurryIsoLimitCompLim, IsLimit.conePointUniqueUpToIso, IsLimit.uniqueUpToIso]
state_before: J K : Type v
inst✝⁵ : SmallCategory J
inst✝⁴ : SmallCategory K
C : Type u
inst✝³ : Category.{v, u} C
F : J ⥤ K ⥤ C
inst✝² : HasLimitsOfShape K C
inst✝¹ : HasLimit (uncurry.obj F)
inst✝ : HasLimit (F ⋙ lim)
j : J
k : K
⊢ limit.lift (F ⋙ lim) (coneOfConeUncurry (fun j => limit.isLimit (F.obj j)) (limit.cone (uncurry.obj F))) ≫
      limit.π (F ⋙ lim) j ≫ limit.π (F.obj j) k =
    limit.π (uncurry.obj F) (j, k)
state_after: no goals
tactic: simp
Theorem: HurwitzKernelBounds.f_le_g_nat
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

Proof steps:
state_before: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
⊢ ‖f_nat k a t n‖ ≤ g_nat k a t n
state_after: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
⊢ (↑n + a) ^ k * rexp (-π * (↑n + a) ^ 2 * t) ≤ g_nat k a t n
tactic: rw [f_nat, norm_of_nonneg (by positivity)]
state_before: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
⊢ (↑n + a) ^ k * rexp (-π * (↑n + a) ^ 2 * t) ≤ g_nat k a t n
state_after: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
⊢ rexp (-π * (↑n + a) ^ 2 * t) ≤ rexp (-π * (↑n + a ^ 2) * t)
tactic: refine mul_le_mul_of_nonneg_left ?_ (by positivity)
state_before: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
⊢ rexp (-π * (↑n + a) ^ 2 * t) ≤ rexp (-π * (↑n + a ^ 2) * t)
state_after: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
⊢ 0 ≤ (↑n + a) ^ 2 - (↑n + a ^ 2)
tactic: rw [Real.exp_le_exp, mul_le_mul_right ht,
    mul_le_mul_left_of_neg (neg_lt_zero.mpr pi_pos), ← sub_nonneg]
state_before: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
⊢ 0 ≤ (↑n + a) ^ 2 - (↑n + a ^ 2)
state_after: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
u : ↑n ≤ ↑n ^ 2
⊢ 0 ≤ (↑n + a) ^ 2 - (↑n + a ^ 2)
tactic: have u : (n : ℝ) ≤ (n : ℝ) ^ 2 := by
    simpa only [← Nat.cast_pow, Nat.cast_le] using Nat.le_self_pow two_ne_zero _
state_before: k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
u : ↑n ≤ ↑n ^ 2
⊢ 0 ≤ (↑n + a) ^ 2 - (↑n + a ^ 2)
state_after: case h.e'_4
k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
u : ↑n ≤ ↑n ^ 2
⊢ (↑n + a) ^ 2 - (↑n + a ^ 2) = ↑n ^ 2 - ↑n + 2 * ↑n * a
tactic: convert add_nonneg (sub_nonneg.mpr u) (by positivity : 0 ≤ 2 * n * a) using 1
state_before: case h.e'_4
k : ℕ
a t : ℝ
ha : 0 ≤ a
ht : 0 < t
n : ℕ
u : ↑n ≤ ↑n ^ 2
⊢ (↑n + a) ^ 2 - (↑n + a ^ 2) = ↑n ^ 2 - ↑n + 2 * ↑n * a
state_after: no goals
tactic: ring
Theorem: Turing.PartrecToTM2.ret_supports
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: S : Finset Λ'
k : Cont'
H₁ : contSupp k ⊆ S
⊢ TM2.SupportsStmt S (tr (Λ'.ret k))
state_after: S : Finset Λ'
k : Cont'
H₁ : contSupp k ⊆ S
W : ∀ {q : Λ'}, q ∈ trStmts₁ q
⊢ TM2.SupportsStmt S (tr (Λ'.ret k))
tactic: have W := fun {q} => trStmts₁_self q
Theorem: SameRay.norm_sub
File: Mathlib/Analysis/Normed/Module/Ray.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
x y : E
h : SameRay ℝ x y
⊢ ‖x - y‖ = |‖x‖ - ‖y‖|
state_after: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|
tactic: rcases h.exists_eq_smul with ⟨u, a, b, ha, hb, -, rfl, rfl⟩
state_before: case intro.intro.intro.intro.intro.intro.intro
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
⊢ ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|
state_after: case intro.intro.intro.intro.intro.intro.intro.inr
E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
H : ∀ (a b : ℝ), 0 ≤ a → 0 ≤ b → SameRay ℝ (a • u) (b • u) → b ≤ a → ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|
hab : ¬b ≤ a
⊢ ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|

E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
hab : b ≤ a
⊢ ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|
tactic: wlog hab : b ≤ a generalizing a b with H
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
hab : b ≤ a
⊢ ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|
state_after: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
hab : 0 ≤ a - b
⊢ ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|
tactic: rw [← sub_nonneg] at hab
state_before: E : Type u_1
inst✝³ : SeminormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
u : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
h : SameRay ℝ (a • u) (b • u)
hab : 0 ≤ a - b
⊢ ‖a • u - b • u‖ = |‖a • u‖ - ‖b • u‖|
state_after: no goals
tactic: rw [← sub_smul, norm_smul_of_nonneg hab, norm_smul_of_nonneg ha, norm_smul_of_nonneg hb, ←
    sub_mul, abs_of_nonneg (mul_nonneg hab (norm_nonneg _))]
Theorem: Nat.digits_two_eq_bits
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n : ℕ
⊢ digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
state_after: case z₀
n : ℕ
⊢ digits 2 0 = List.map (fun b => bif b then 1 else 0) (bits 0)

case z₁
n : ℕ
⊢ digits 2 1 = List.map (fun b => bif b then 1 else 0) (bits 1)

case f
n✝ : ℕ
b : Bool
n : ℕ
h : n ≠ 0
ih : digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
⊢ digits 2 (bit b n) = List.map (fun b => bif b then 1 else 0) (bit b n).bits
tactic: induction' n using Nat.binaryRecFromOne with b n h ih
state_before: case f
n✝ : ℕ
b : Bool
n : ℕ
h : n ≠ 0
ih : digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
⊢ digits 2 (bit b n) = List.map (fun b => bif b then 1 else 0) (bit b n).bits
state_after: case f
n✝ : ℕ
b : Bool
n : ℕ
h : n ≠ 0
ih : digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
⊢ digits 2 (bit b n) = List.map (fun b => bif b then 1 else 0) (b :: n.bits)
tactic: rw [bits_append_bit _ _ fun hn => absurd hn h]
state_before: case f
n✝ : ℕ
b : Bool
n : ℕ
h : n ≠ 0
ih : digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
⊢ digits 2 (bit b n) = List.map (fun b => bif b then 1 else 0) (b :: n.bits)
state_after: case f.false
n✝ n : ℕ
h : n ≠ 0
ih : digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
⊢ digits 2 (bit false n) = List.map (fun b => bif b then 1 else 0) (false :: n.bits)

case f.true
n✝ n : ℕ
h : n ≠ 0
ih : digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
⊢ digits 2 (bit true n) = List.map (fun b => bif b then 1 else 0) (true :: n.bits)
tactic: cases b
Theorem: Polynomial.map_smul
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r✝ : R[X]
inst✝ : Semiring S
f : R →+* S
r : R
⊢ map f (r • p) = f r • map f p
state_after: no goals
tactic: rw [map, eval₂_smul, RingHom.comp_apply, C_mul']
Theorem: IsClosed.Icc_subset_of_forall_exists_gt
File: Mathlib/Topology/Order/IntermediateValue.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ x ∈ s ∩ Ico a b, ∀ y ∈ Ioi x, (s ∩ Ioc x y).Nonempty
⊢ Icc a b ⊆ s
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ x ∈ s ∩ Ico a b, ∀ y ∈ Ioi x, (s ∩ Ioc x y).Nonempty
y : α
hy : y ∈ Icc a b
⊢ y ∈ s
tactic: intro y hy
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ x ∈ s ∩ Ico a b, ∀ y ∈ Ioi x, (s ∩ Ioc x y).Nonempty
y : α
hy : y ∈ Icc a b
⊢ y ∈ s
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ x ∈ s ∩ Ico a b, ∀ y ∈ Ioi x, (s ∩ Ioc x y).Nonempty
y : α
hy : y ∈ Icc a b
this : IsClosed (s ∩ Icc a y)
⊢ y ∈ s
tactic: have : IsClosed (s ∩ Icc a y) := by
    suffices s ∩ Icc a y = s ∩ Icc a b ∩ Icc a y by
      rw [this]
      exact IsClosed.inter hs isClosed_Icc
    rw [inter_assoc]
    congr
    exact (inter_eq_self_of_subset_right <| Icc_subset_Icc_right hy.2).symm
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : ConditionallyCompleteLinearOrder α
inst✝⁵ : TopologicalSpace α
inst✝⁴ : OrderTopology α
inst✝³ : ConditionallyCompleteLinearOrder β
inst✝² : TopologicalSpace β
inst✝¹ : OrderTopology β
inst✝ : Nonempty γ
a b : α
s : Set α
hs : IsClosed (s ∩ Icc a b)
ha : a ∈ s
hgt : ∀ x ∈ s ∩ Ico a b, ∀ y ∈ Ioi x, (s ∩ Ioc x y).Nonempty
y : α
hy : y ∈ Icc a b
this : IsClosed (s ∩ Icc a y)
⊢ y ∈ s
state_after: no goals
tactic: exact
    IsClosed.mem_of_ge_of_forall_exists_gt this ha hy.1 fun x hx =>
      hgt x ⟨hx.1, Ico_subset_Ico_right hy.2 hx.2⟩ y hx.2.2
Theorem: List.support_sum_subset
File: Mathlib/Data/Finsupp/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
l : List (ι →₀ M)
⊢ l.sum.support ⊆ foldr (fun x x_1 => x.support ⊔ x_1) ∅ l
state_after: case nil
ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
⊢ [].sum.support ⊆ foldr (fun x x_1 => x.support ⊔ x_1) ∅ []

case cons
ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : AddMonoid M
hd : ι →₀ M
tl : List (ι →₀ M)
IH : tl.sum.support ⊆ foldr (fun x x_1 => x.support ⊔ x_1) ∅ tl
⊢ (hd :: tl).sum.support ⊆ foldr (fun x x_1 => x.support ⊔ x_1) ∅ (hd :: tl)
tactic: induction' l with hd tl IH
Theorem: Unitization.norm_eq_sup
File: Mathlib/Analysis/Normed/Algebra/Unitization.lean

Proof steps:
state_before: 𝕜 : Type u_1
A : Type u_2
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NonUnitalNormedRing A
inst✝³ : NormedSpace 𝕜 A
inst✝² : IsScalarTower 𝕜 A A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : RegularNormedAlgebra 𝕜 A
x : Unitization 𝕜 A
⊢ ‖x‖ = ‖x.fst‖ ⊔ ‖(algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (mul 𝕜 A) x.snd‖
state_after: no goals
tactic: rw [norm_def, splitMul_apply, Prod.norm_def, sup_eq_max]
Theorem: SetTheory.PGame.quot_neg_mul_neg
File: Mathlib/SetTheory/Game/Basic.lean

Proof steps:
state_before: x y : PGame
⊢ ⟦-x * -y⟧ = ⟦x * y⟧
state_after: no goals
tactic: simp
Theorem: himp_left_comm
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ a ⇨ b ⇨ c = b ⇨ a ⇨ c
state_after: no goals
tactic: simp_rw [himp_himp, inf_comm]
Theorem: tendsto_measure_cthickening_of_isClosed
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s✝ t u : Set α
inst✝³ : PseudoEMetricSpace α
inst✝² : MeasurableSpace α
inst✝¹ : OpensMeasurableSpace α
inst✝ : MeasurableSpace β
x : α
ε : ℝ≥0∞
μ : Measure α
s : Set α
hs : ∃ R > 0, μ (cthickening R s) ≠ ⊤
h's : IsClosed s
⊢ Tendsto (fun r => μ (cthickening r s)) (𝓝 0) (𝓝 (μ s))
state_after: case h.e'_5.h.e'_3.h.e'_6
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s✝ t u : Set α
inst✝³ : PseudoEMetricSpace α
inst✝² : MeasurableSpace α
inst✝¹ : OpensMeasurableSpace α
inst✝ : MeasurableSpace β
x : α
ε : ℝ≥0∞
μ : Measure α
s : Set α
hs : ∃ R > 0, μ (cthickening R s) ≠ ⊤
h's : IsClosed s
⊢ s = closure s
tactic: convert tendsto_measure_cthickening hs
state_before: case h.e'_5.h.e'_3.h.e'_6
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort y
s✝ t u : Set α
inst✝³ : PseudoEMetricSpace α
inst✝² : MeasurableSpace α
inst✝¹ : OpensMeasurableSpace α
inst✝ : MeasurableSpace β
x : α
ε : ℝ≥0∞
μ : Measure α
s : Set α
hs : ∃ R > 0, μ (cthickening R s) ≠ ⊤
h's : IsClosed s
⊢ s = closure s
state_after: no goals
tactic: exact h's.closure_eq.symm
Theorem: AlgebraicIndependent.algebraMap_injective
File: Mathlib/RingTheory/AlgebraicIndependent.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
hx : AlgebraicIndependent R x
⊢ Injective ⇑(algebraMap R A)
state_after: no goals
tactic: simpa [Function.comp] using
    (Injective.of_comp_iff (algebraicIndependent_iff_injective_aeval.1 hx) MvPolynomial.C).2
      (MvPolynomial.C_injective _ _)
Theorem: List.Perm.sizeOf_eq_sizeOf
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : SizeOf α
l₁ l₂ : List α
h : l₁ ~ l₂
⊢ sizeOf l₁ = sizeOf l₂
state_after: no goals
tactic: induction h with
  | nil => rfl
  | cons _ _ h_sz₁₂ => simp [h_sz₁₂]
  | swap => simp [Nat.add_left_comm]
  | trans _ _ h_sz₁₂ h_sz₂₃ => simp [h_sz₁₂, h_sz₂₃]
Theorem: GaussianInt.toComplex_def₂
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x : ℤ[i]
⊢ toComplex x = { re := ↑x.re, im := ↑x.im }
state_after: no goals
tactic: apply Complex.ext <;> simp [toComplex_def]
Theorem: HomologicalComplex.ι_mapBifunctorMap
File: Mathlib/Algebra/Homology/Bifunctor.lean

Proof steps:
state_before: C₁ : Type u_1
C₂ : Type u_2
D : Type u_3
inst✝¹¹ : Category.{u_9, u_1} C₁
inst✝¹⁰ : Category.{u_8, u_2} C₂
inst✝⁹ : Category.{u_7, u_3} D
I₁ : Type u_4
I₂ : Type u_5
J : Type u_6
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
inst✝⁸ : HasZeroMorphisms C₁
inst✝⁷ : HasZeroMorphisms C₂
inst✝⁶ : Preadditive D
K₁ L₁ : HomologicalComplex C₁ c₁
K₂ L₂ : HomologicalComplex C₂ c₂
f₁ : K₁ ⟶ L₁
f₂ : K₂ ⟶ L₂
F : C₁ ⥤ C₂ ⥤ D
inst✝⁵ : F.PreservesZeroMorphisms
inst✝⁴ : ∀ (X₁ : C₁), (F.obj X₁).PreservesZeroMorphisms
c : ComplexShape J
inst✝³ : TotalComplexShape c₁ c₂ c
inst✝² : K₁.HasMapBifunctor K₂ F c
inst✝¹ : L₁.HasMapBifunctor L₂ F c
inst✝ : DecidableEq J
i₁ : I₁
i₂ : I₂
j : J
h : c₁.π c₂ c (i₁, i₂) = j
⊢ K₁.ιMapBifunctor K₂ F c i₁ i₂ j h ≫ (mapBifunctorMap f₁ f₂ F c).f j =
    (F.map (f₁.f i₁)).app (K₂.X i₂) ≫ (F.obj (L₁.X i₁)).map (f₂.f i₂) ≫ L₁.ιMapBifunctor L₂ F c i₁ i₂ j h
state_after: no goals
tactic: simp [mapBifunctorMap]
Theorem: Real.one_le_toNNReal
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r : ℝ
⊢ 1 ≤ r.toNNReal ↔ 1 ≤ r
state_after: no goals
tactic: simpa using toNNReal_le_toNNReal_iff_of_pos one_pos
Theorem: Polynomial.rootMultiplicity_mul_X_sub_C_pow
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) = rootMultiplicity a p + n
state_after: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) = rootMultiplicity a p + n
tactic: have h2 := monic_X_sub_C a |>.pow n |>.mul_left_ne_zero h
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) = rootMultiplicity a p + n
state_after: case refine_1
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a (p * (X - C a) ^ n) ≤ rootMultiplicity a p + n

case refine_2
R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝ : CommRing R
p : R[X]
a : R
n : ℕ
h : p ≠ 0
h2 : p * (X - C a) ^ n ≠ 0
⊢ rootMultiplicity a p + n ≤ rootMultiplicity a (p * (X - C a) ^ n)
tactic: refine le_antisymm ?_ ?_
Theorem: CategoryTheory.ShortComplex.FunctorEquivalence.inverse_obj_X₂
File: Mathlib/Algebra/Homology/ShortComplex/FunctorEquivalence.lean

Proof steps:
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.17393, u_1} J
inst✝¹ : Category.{?u.17397, u_2} C
inst✝ : HasZeroMorphisms C
F : J ⥤ ShortComplex C
⊢ whiskerLeft F π₁Toπ₂ ≫ whiskerLeft F π₂Toπ₃ = 0
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.17393, u_1} J
inst✝¹ : Category.{?u.17397, u_2} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : J ⥤ ShortComplex C
φ : X✝ ⟶ Y✝
⊢ whiskerRight φ π₁ ≫ ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) Y✝).f =
    ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) X✝).f ≫ whiskerRight φ π₂
state_after: no goals
tactic: aesop_cat
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{?u.17393, u_1} J
inst✝¹ : Category.{?u.17397, u_2} C
inst✝ : HasZeroMorphisms C
X✝ Y✝ : J ⥤ ShortComplex C
φ : X✝ ⟶ Y✝
⊢ whiskerRight φ π₂ ≫ ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) Y✝).g =
    ((fun F => mk (whiskerLeft F π₁Toπ₂) (whiskerLeft F π₂Toπ₃) ⋯) X✝).g ≫ whiskerRight φ π₃
state_after: no goals
tactic: aesop_cat
Theorem: jacobiSym.pow_right
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

Proof steps:
state_before: a : ℤ
b e : ℕ
⊢ J(a | b ^ e) = J(a | b) ^ e
state_after: case zero
a : ℤ
b : ℕ
⊢ J(a | b ^ 0) = J(a | b) ^ 0

case succ
a : ℤ
b e : ℕ
ih : J(a | b ^ e) = J(a | b) ^ e
⊢ J(a | b ^ (e + 1)) = J(a | b) ^ (e + 1)
tactic: induction' e with e ih
Theorem: Cubic.natDegree_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.natDegree = 1
state_after: no goals
tactic: rw [of_b_eq_zero ha hb, natDegree_linear hc]
Theorem: UniformFun.tendsto_iff_tendstoUniformly
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
F : ι → α →ᵤ β
f : α →ᵤ β
⊢ Tendsto F p (𝓝 f) ↔ TendstoUniformly (⇑toFun ∘ F) (toFun f) p
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
F : ι → α →ᵤ β
f : α →ᵤ β
⊢ (∀ i ∈ 𝓤 β, ∀ᶠ (x : ι) in p, F x ∈ {g | (f, g) ∈ UniformFun.gen α β i}) ↔
    ∀ u ∈ 𝓤 β, ∀ᶠ (n : ι) in p, ∀ (x : α), (toFun f x, (⇑toFun ∘ F) n x) ∈ u
tactic: rw [(UniformFun.hasBasis_nhds α β f).tendsto_right_iff, TendstoUniformly]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
F : ι → α →ᵤ β
f : α →ᵤ β
⊢ (∀ i ∈ 𝓤 β, ∀ᶠ (x : ι) in p, F x ∈ {g | (f, g) ∈ UniformFun.gen α β i}) ↔
    ∀ u ∈ 𝓤 β, ∀ᶠ (n : ι) in p, ∀ (x : α), (toFun f x, (⇑toFun ∘ F) n x) ∈ u
state_after: no goals
tactic: simp only [mem_setOf, UniformFun.gen, Function.comp_def]