ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ordinal.mul_sub
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
a0 : a = 0
⊢ a * (b - c) = a * b - a * c
state_after: no goals
tactic: simp only [a0, zero_mul, sub_self]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
a0 : ¬a = 0
d : Ordinal.{u_4}
⊢ a * (b - c) ≤ d ↔ a * b - a * c ≤ d
state_after: no goals
tactic: rw [sub_le, ← le_div a0, sub_le, ← le_div a0, mul_add_div _ a0]
Theorem: Fin.init_update_castSucc
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
⊢ init (update q i.castSucc y) = update (init q) i y
state_after: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin n
⊢ init (update q i.castSucc y) j = update (init q) i y j
tactic: ext j
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin n
⊢ init (update q i.castSucc y) j = update (init q) i y j
state_after: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin n
h : j = i
⊢ init (update q i.castSucc y) j = update (init q) i y j

case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α (last n)
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.castSucc
i : Fin n
y : α i.castSucc
z : α (last n)
j : Fin n
h : ¬j = i
⊢ init (update q i.castSucc y) j = update (init q) i y j
tactic: by_cases h : j = i
Theorem: MeasureTheory.tendsto_measure_iUnion'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
⊢ Tendsto (fun i => μ (Accumulate f i)) atTop (𝓝 (μ (⋃ i, f i)))
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
⊢ Tendsto (fun i => μ (Accumulate f i)) atTop (𝓝 (⨆ i, μ (Accumulate f i)))
tactic: rw [measure_iUnion_eq_iSup']
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι✝ : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α✝
μ✝ μ₁ μ₂ : Measure α✝
s s₁ s₂ t : Set α✝
α : Type u_8
ι : Type u_9
inst✝³ : MeasurableSpace α
μ : Measure α
inst✝² : Countable ι
inst✝¹ : Preorder ι
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
f : ι → Set α
⊢ Tendsto (fun i => μ (Accumulate f i)) atTop (𝓝 (⨆ i, μ (Accumulate f i)))
state_after: no goals
tactic: exact tendsto_atTop_iSup fun i j hij ↦ by gcongr
Theorem: tprod_comm'
File: Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousMul α
inst✝ : T3Space α
f : β → γ → α
h : Multipliable (uncurry f)
h₁ : ∀ (b : β), Multipliable (f b)
h₂ : ∀ (c : γ), Multipliable fun b => f b c
⊢ ∏' (c : γ) (b : β), f b c = ∏' (b : β) (c : γ), f b c
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousMul α
inst✝ : T3Space α
f : β → γ → α
h : Multipliable (uncurry f)
h₁ : ∀ (b : β), Multipliable (f b)
h₂ : ∀ (c : γ), Multipliable fun b => f b c
⊢ ∏' (p : γ × β), uncurry f p.swap = ∏' (c : γ × β), uncurry f ((Equiv.prodComm γ β) c)
tactic: erw [← tprod_prod' h h₁, ← tprod_prod' h.prod_symm h₂,
      ← (Equiv.prodComm γ β).tprod_eq (uncurry f)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommMonoid α
inst✝² : TopologicalSpace α
inst✝¹ : ContinuousMul α
inst✝ : T3Space α
f : β → γ → α
h : Multipliable (uncurry f)
h₁ : ∀ (b : β), Multipliable (f b)
h₂ : ∀ (c : γ), Multipliable fun b => f b c
⊢ ∏' (p : γ × β), uncurry f p.swap = ∏' (c : γ × β), uncurry f ((Equiv.prodComm γ β) c)
state_after: no goals
tactic: rfl
Theorem: SimpleGraph.Subgraph.verts_spanningCoe_injective
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
⊢ Function.Injective fun G' => (G'.verts, G'.spanningCoe)
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h : (fun G' => (G'.verts, G'.spanningCoe)) G₁ = (fun G' => (G'.verts, G'.spanningCoe)) G₂
⊢ G₁ = G₂
tactic: intro G₁ G₂ h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h : (fun G' => (G'.verts, G'.spanningCoe)) G₁ = (fun G' => (G'.verts, G'.spanningCoe)) G₂
⊢ G₁ = G₂
state_after: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h :
  ((fun G' => (G'.verts, G'.spanningCoe)) G₁).1 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).1 ∧
    ((fun G' => (G'.verts, G'.spanningCoe)) G₁).2 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).2
⊢ G₁ = G₂
tactic: rw [Prod.ext_iff] at h
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁✝ G₂✝ : G.Subgraph
a b : V
G₁ G₂ : G.Subgraph
h :
  ((fun G' => (G'.verts, G'.spanningCoe)) G₁).1 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).1 ∧
    ((fun G' => (G'.verts, G'.spanningCoe)) G₁).2 = ((fun G' => (G'.verts, G'.spanningCoe)) G₂).2
⊢ G₁ = G₂
state_after: no goals
tactic: exact Subgraph.ext _ _ h.1 (spanningCoe_inj.1 h.2)
Theorem: Nat.eq_iff_prime_padicValNat_eq
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a✝ b✝ m n p a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a = b ↔ ∀ (p : ℕ), Prime p → padicValNat p a = padicValNat p b
state_after: case mp
a✝ b✝ m n p a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ a = b → ∀ (p : ℕ), Prime p → padicValNat p a = padicValNat p b

case mpr
a✝ b✝ m n p a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ (∀ (p : ℕ), Prime p → padicValNat p a = padicValNat p b) → a = b
tactic: constructor
Theorem: NumberField.InfinitePlace.mult_pos
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
w : InfinitePlace K
⊢ 0 < w.mult
state_after: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
w : InfinitePlace K
⊢ 0 < if w.IsReal then 1 else 2
tactic: rw [mult]
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
w : InfinitePlace K
⊢ 0 < if w.IsReal then 1 else 2
state_after: no goals
tactic: split_ifs <;> norm_num
Theorem: Ordinal.nfpBFamily_le_apply
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (∃ i, ∃ (hi : i < o), o.nfpBFamily f a ≤ f i hi b) ↔ o.nfpBFamily f a ≤ b
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (¬∃ i, ∃ (hi : i < o), o.nfpBFamily f a ≤ f i hi b) ↔ ¬o.nfpBFamily f a ≤ b
tactic: rw [← not_iff_not]
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (¬∃ i, ∃ (hi : i < o), o.nfpBFamily f a ≤ f i hi b) ↔ ¬o.nfpBFamily f a ≤ b
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi b < o.nfpBFamily f a) ↔ b < o.nfpBFamily f a
tactic: push_neg
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi b < o.nfpBFamily f a) ↔ b < o.nfpBFamily f a
state_after: no goals
tactic: exact apply_lt_nfpBFamily_iff.{u, v} ho H
Theorem: CategoryTheory.Endofunctor.Algebra.isoMk_hom_f
File: Mathlib/CategoryTheory/Endofunctor/Algebra.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : A₀.a ≅ A₁.a
w : autoParam (F.map h.hom ≫ A₁.str = A₀.str ≫ h.hom) _auto✝
⊢ F.map h.inv ≫ A₀.str = A₁.str ≫ h.inv
state_after: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : A₀.a ≅ A₁.a
w : autoParam (F.map h.hom ≫ A₁.str = A₀.str ≫ h.hom) _auto✝
⊢ F.map (h.inv ≫ h.hom) ≫ A₁.str = A₁.str
tactic: rw [h.eq_comp_inv, Category.assoc, ← w, ← Functor.map_comp_assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ C
A A₀ A₁ A₂ : Algebra F
f : A₀ ⟶ A₁
g : A₁ ⟶ A₂
h : A₀.a ≅ A₁.a
w : autoParam (F.map h.hom ≫ A₁.str = A₀.str ≫ h.hom) _auto✝
⊢ F.map (h.inv ≫ h.hom) ≫ A₁.str = A₁.str
state_after: no goals
tactic: simp
Theorem: Set.Icc_diff_pi_univ_Ioc_subset
File: Mathlib/Order/Interval/Set/Pi.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y z : (i : ι) → α i
⊢ (Icc x z \ univ.pi fun i => Ioc (y i) (z i)) ⊆ ⋃ i, Icc x (update z i (y i))
state_after: case intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y z a : (i : ι) → α i
hay : a ∉ univ.pi fun i => Ioc (y i) (z i)
hax : x ≤ a
haz : a ≤ z
⊢ a ∈ ⋃ i, Icc x (update z i (y i))
tactic: rintro a ⟨⟨hax, haz⟩, hay⟩
state_before: case intro.intro
ι : Type u_1
α : ι → Type u_2
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → LinearOrder (α i)
x y z a : (i : ι) → α i
hay : a ∉ univ.pi fun i => Ioc (y i) (z i)
hax : x ≤ a
haz : a ≤ z
⊢ a ∈ ⋃ i, Icc x (update z i (y i))
state_after: no goals
tactic: simpa [not_and_or, hax, le_update_iff, haz _] using hay
Theorem: CategoryTheory.GrothendieckTopology.diagramNatTrans_app
File: Mathlib/CategoryTheory/Sites/Plus.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : C
W : (J.Cover X)ᵒᵖ
i : ((unop W).index Q).R
⊢ (fun i => Multiequalizer.ι ((unop W).index P) i ≫ η.app (op i.Y)) (((unop W).index Q).fstTo i) ≫
      ((unop W).index Q).fst i =
    (fun i => Multiequalizer.ι ((unop W).index P) i ≫ η.app (op i.Y)) (((unop W).index Q).sndTo i) ≫
      ((unop W).index Q).snd i
state_after: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : C
W : (J.Cover X)ᵒᵖ
i : ((unop W).index Q).R
⊢ (Multiequalizer.ι ((unop W).index P) (((unop W).index Q).fstTo i) ≫ η.app (op (((unop W).index Q).fstTo i).Y)) ≫
      ((unop W).index Q).fst i =
    (Multiequalizer.ι ((unop W).index P) (((unop W).index Q).sndTo i) ≫ η.app (op (((unop W).index Q).sndTo i).Y)) ≫
      ((unop W).index Q).snd i
tactic: dsimp only
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : C
W : (J.Cover X)ᵒᵖ
i : ((unop W).index Q).R
⊢ (Multiequalizer.ι ((unop W).index P) (((unop W).index Q).fstTo i) ≫ η.app (op (((unop W).index Q).fstTo i).Y)) ≫
      ((unop W).index Q).fst i =
    (Multiequalizer.ι ((unop W).index P) (((unop W).index Q).sndTo i) ≫ η.app (op (((unop W).index Q).sndTo i).Y)) ≫
      ((unop W).index Q).snd i
state_after: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : C
W : (J.Cover X)ᵒᵖ
i : ((unop W).index Q).R
⊢ Multiequalizer.ι ((unop W).index P) (((unop W).index P).sndTo i) ≫ ((unop W).index P).snd i ≫ η.app (op i.r.Z) =
    Multiequalizer.ι ((unop W).index P) (((unop W).index Q).sndTo i) ≫ P.map i.r.g₂.op ≫ η.app (op i.r.Z)
tactic: erw [Category.assoc, Category.assoc, ← η.naturality, ← η.naturality,
        Multiequalizer.condition_assoc]
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝¹ : Category.{max v u, w} D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
P✝ P Q : Cᵒᵖ ⥤ D
η : P ⟶ Q
X : C
W : (J.Cover X)ᵒᵖ
i : ((unop W).index Q).R
⊢ Multiequalizer.ι ((unop W).index P) (((unop W).index P).sndTo i) ≫ ((unop W).index P).snd i ≫ η.app (op i.r.Z) =
    Multiequalizer.ι ((unop W).index P) (((unop W).index Q).sndTo i) ≫ P.map i.r.g₂.op ≫ η.app (op i.r.Z)
state_after: no goals
tactic: rfl
Theorem: WeierstrassCurve.Affine.map_polynomialY
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ (map W f).toAffine.polynomialY = Polynomial.map (mapRingHom f) W.polynomialY
state_after: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ C (C 2) * Y + C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) =
    Polynomial.map (mapRingHom f) (C (C 2) * Y + C (C W.a₁ * X + C W.a₃))
tactic: simp only [polynomialY]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ C (C 2) * Y + C (C (map W f).toAffine.a₁ * X + C (map W f).toAffine.a₃) =
    Polynomial.map (mapRingHom f) (C (C 2) * Y + C (C W.a₁ * X + C W.a₃))
state_after: no goals
tactic: map_simp
Theorem: WeierstrassCurve.Affine.map_polynomialX
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ (map W f).toAffine.polynomialX = Polynomial.map (mapRingHom f) W.polynomialX
state_after: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ C (C (map W f).toAffine.a₁) * Y - C (C 3 * X ^ 2 + C (2 * (map W f).toAffine.a₂) * X + C (map W f).toAffine.a₄) =
    Polynomial.map (mapRingHom f) (C (C W.a₁) * Y - C (C 3 * X ^ 2 + C (2 * W.a₂) * X + C W.a₄))
tactic: simp only [polynomialX]
state_before: R : Type u
inst✝¹ : CommRing R
W : Affine R
S : Type v
inst✝ : CommRing S
f : R →+* S
⊢ C (C (map W f).toAffine.a₁) * Y - C (C 3 * X ^ 2 + C (2 * (map W f).toAffine.a₂) * X + C (map W f).toAffine.a₄) =
    Polynomial.map (mapRingHom f) (C (C W.a₁) * Y - C (C 3 * X ^ 2 + C (2 * W.a₂) * X + C W.a₄))
state_after: no goals
tactic: map_simp
Theorem: continuousWithinAt_of_not_mem_closure
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : x ∉ closure s
⊢ ContinuousWithinAt f s x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : 𝓝[s] x = ⊥
⊢ ContinuousWithinAt f s x
tactic: rw [mem_closure_iff_nhdsWithin_neBot, not_neBot] at hx
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : 𝓝[s] x = ⊥
⊢ ContinuousWithinAt f s x
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : 𝓝[s] x = ⊥
⊢ Tendsto f ⊥ (𝓝 (f x))
tactic: rw [ContinuousWithinAt, hx]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : 𝓝[s] x = ⊥
⊢ Tendsto f ⊥ (𝓝 (f x))
state_after: no goals
tactic: exact tendsto_bot
Theorem: Real.exp_neg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ ↑(rexp (-x)) = ↑(rexp x)⁻¹
state_after: no goals
tactic: simp [exp_neg]
Theorem: iSup_iInf_ge_nat_add
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
hf : Monotone fun n => ⨅ i, ⨅ (_ : i ≥ n), f i
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i
tactic: have hf : Monotone fun n => ⨅ i ≥ n, f i := fun n m h => biInf_mono fun i => h.trans
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
hf : Monotone fun n => ⨅ i, ⨅ (_ : i ≥ n), f i
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f i
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ℕ → α
k : ℕ
hf : Monotone fun n => ⨅ i, ⨅ (_ : i ≥ n), f i
⊢ ⨆ n, ⨅ i, ⨅ (_ : i ≥ n), f (i + k) = ⨆ n, ⨅ i, ⨅ (_ : i ≥ n + k), f i
tactic: rw [← Monotone.iSup_nat_add hf k]
Theorem: IsLocalization.AtPrime.Nontrivial
File: Mathlib/RingTheory/Localization/AtPrime.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P✝ : Type u_3
inst✝¹ : CommSemiring P✝
P : Ideal R
hp : P.IsPrime
inst✝ : IsLocalization.AtPrime S P
hze : 0 = 1
⊢ False
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P✝ : Type u_3
inst✝¹ : CommSemiring P✝
P : Ideal R
hp : P.IsPrime
inst✝ : IsLocalization.AtPrime S P
hze : (algebraMap R S) 0 = (algebraMap R S) 1
⊢ False
tactic: rw [← (algebraMap R S).map_one, ← (algebraMap R S).map_zero] at hze
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P✝ : Type u_3
inst✝¹ : CommSemiring P✝
P : Ideal R
hp : P.IsPrime
inst✝ : IsLocalization.AtPrime S P
hze : (algebraMap R S) 0 = (algebraMap R S) 1
⊢ False
state_after: case intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P✝ : Type u_3
inst✝¹ : CommSemiring P✝
P : Ideal R
hp : P.IsPrime
inst✝ : IsLocalization.AtPrime S P
hze : (algebraMap R S) 0 = (algebraMap R S) 1
t : ↥P.primeCompl
ht : ↑t * 0 = ↑t * 1
⊢ False
tactic: obtain ⟨t, ht⟩ := (eq_iff_exists P.primeCompl S).1 hze
state_before: case intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P✝ : Type u_3
inst✝¹ : CommSemiring P✝
P : Ideal R
hp : P.IsPrime
inst✝ : IsLocalization.AtPrime S P
hze : (algebraMap R S) 0 = (algebraMap R S) 1
t : ↥P.primeCompl
ht : ↑t * 0 = ↑t * 1
⊢ False
state_after: case intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P✝ : Type u_3
inst✝¹ : CommSemiring P✝
P : Ideal R
hp : P.IsPrime
inst✝ : IsLocalization.AtPrime S P
hze : (algebraMap R S) 0 = (algebraMap R S) 1
t : ↥P.primeCompl
ht : ↑t * 0 = ↑t * 1
htz : ↑t = 0
⊢ False
tactic: have htz : (t : R) = 0 := by simpa using ht.symm
state_before: case intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P✝ : Type u_3
inst✝¹ : CommSemiring P✝
P : Ideal R
hp : P.IsPrime
inst✝ : IsLocalization.AtPrime S P
hze : (algebraMap R S) 0 = (algebraMap R S) 1
t : ↥P.primeCompl
ht : ↑t * 0 = ↑t * 1
htz : ↑t = 0
⊢ False
state_after: no goals
tactic: exact t.2 (htz.symm ▸ P.zero_mem : ↑t ∈ P)
Theorem: Finsupp.some_zero
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
⊢ some 0 = 0
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a✝ : α
⊢ (some 0) a✝ = 0 a✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a✝ : α
⊢ (some 0) a✝ = 0 a✝
state_after: no goals
tactic: simp
Theorem: UniqueFactorizationMonoid.normalizedFactors_prod_eq
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
s : Multiset α
hs : ∀ a ∈ s, Irreducible a
⊢ normalizedFactors s.prod = Multiset.map (⇑normalize) s
state_after: case empty
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
hs : ∀ a ∈ 0, Irreducible a
⊢ normalizedFactors (Multiset.prod 0) = Multiset.map (⇑normalize) 0

case cons
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
a : α
s : Multiset α
ih : (∀ a ∈ s, Irreducible a) → normalizedFactors s.prod = Multiset.map (⇑normalize) s
hs : ∀ a_1 ∈ a ::ₘ s, Irreducible a_1
⊢ normalizedFactors (a ::ₘ s).prod = Multiset.map (⇑normalize) (a ::ₘ s)
tactic: induction' s using Multiset.induction with a s ih