ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Group.mem_closure_union_iff
File: Mathlib/Deprecated/Subgroup.lean

Proof steps:
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G✝
inst✝¹ : Group G✝
s✝ : Set G✝
G : Type u_4
inst✝ : CommGroup G
s t : Set G
x : G
⊢ x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x
state_after: G✝ : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G✝
inst✝¹ : Group G✝
s✝ : Set G✝
G : Type u_4
inst✝ : CommGroup G
s t : Set G
x : G
⊢ (∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure t, y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure (Inv.inv ⁻¹' s), ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x) ↔
    ∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure (Inv.inv ⁻¹' s), y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure t, ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x
tactic: simp only [closure_eq_mclosure, Monoid.mem_closure_union_iff, exists_prop, preimage_union]
state_before: G✝ : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G✝
inst✝¹ : Group G✝
s✝ : Set G✝
G : Type u_4
inst✝ : CommGroup G
s t : Set G
x : G
⊢ (∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure t, y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure (Inv.inv ⁻¹' s), ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x) ↔
    ∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure (Inv.inv ⁻¹' s), y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure t, ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x
state_after: case mp
G✝ : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G✝
inst✝¹ : Group G✝
s✝ : Set G✝
G : Type u_4
inst✝ : CommGroup G
s t : Set G
x : G
⊢ (∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure t, y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure (Inv.inv ⁻¹' s), ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x) →
    ∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure (Inv.inv ⁻¹' s), y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure t, ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x

case mpr
G✝ : Type u_1
H : Type u_2
A : Type u_3
a a₁ a₂ b c : G✝
inst✝¹ : Group G✝
s✝ : Set G✝
G : Type u_4
inst✝ : CommGroup G
s t : Set G
x : G
⊢ (∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure (Inv.inv ⁻¹' s), y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure t, ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x) →
    ∃ y,
      (∃ y_1 ∈ Monoid.Closure s, ∃ z ∈ Monoid.Closure t, y_1 * z = y) ∧
        ∃ z, (∃ y ∈ Monoid.Closure (Inv.inv ⁻¹' s), ∃ z_1 ∈ Monoid.Closure (Inv.inv ⁻¹' t), y * z_1 = z) ∧ y * z = x
tactic: constructor
Theorem: Ordering.swap_swap
File: .lake/packages/batteries/Batteries/Classes/Order.lean

Proof steps:
state_before: o : Ordering
⊢ o.swap.swap = o
state_after: no goals
tactic: cases o <;> rfl
Theorem: CategoryTheory.Limits.spanExt_inv_app_left
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).inv.app WalkingSpan.left = iY.inv
state_after: no goals
tactic: dsimp [spanExt]
Theorem: Real.cos_lt_cos_of_nonneg_of_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x y : ℝ
hx₁ : 0 ≤ x
hy₂ : y ≤ π / 2
hxy : x < y
⊢ π / 2 ≤ π
state_after: no goals
tactic: linarith
Theorem: MeromorphicAt.inv_iff
File: Mathlib/Analysis/Analytic/Meromorphic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → 𝕜
x : 𝕜
h : MeromorphicAt f⁻¹ x
⊢ MeromorphicAt f x
state_after: no goals
tactic: simpa only [inv_inv] using h.inv
Theorem: Monotone.piecewise_eventually_eq_iUnion
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
β : α → Type u_6
inst✝² : Preorder ι
s : ι → Set α
inst✝¹ : (i : ι) → DecidablePred fun x => x ∈ s i
inst✝ : DecidablePred fun x => x ∈ ⋃ i, s i
hs : Monotone s
f g : (a : α) → β a
a : α
⊢ ∀ᶠ (i : ι) in atTop, (s i).piecewise f g a = (⋃ i, s i).piecewise f g a
state_after: case inl.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
β : α → Type u_6
inst✝² : Preorder ι
s : ι → Set α
inst✝¹ : (i : ι) → DecidablePred fun x => x ∈ s i
inst✝ : DecidablePred fun x => x ∈ ⋃ i, s i
hs : Monotone s
f g : (a : α) → β a
a : α
i : ι
hi : a ∈ s i
⊢ ∀ᶠ (i : ι) in atTop, (s i).piecewise f g a = (⋃ i, s i).piecewise f g a

case inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β✝ : Type u_4
γ : Type u_5
β : α → Type u_6
inst✝² : Preorder ι
s : ι → Set α
inst✝¹ : (i : ι) → DecidablePred fun x => x ∈ s i
inst✝ : DecidablePred fun x => x ∈ ⋃ i, s i
hs : Monotone s
f g : (a : α) → β a
a : α
ha : ¬∃ i, a ∈ s i
⊢ ∀ᶠ (i : ι) in atTop, (s i).piecewise f g a = (⋃ i, s i).piecewise f g a
tactic: rcases em (∃ i, a ∈ s i) with ⟨i, hi⟩ | ha
Theorem: Turing.ListBlank.map_modifyNth
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
F : PointedMap Γ Γ'
f : Γ → Γ
f' : Γ' → Γ'
H : ∀ (x : Γ), F.f (f x) = f' (F.f x)
n : ℕ
L : ListBlank Γ
⊢ map F (modifyNth f n L) = modifyNth f' n (map F L)
state_after: no goals
tactic: induction' n with n IH generalizing L <;>
    simp only [*, ListBlank.head_map, ListBlank.modifyNth, ListBlank.map_cons, ListBlank.tail_map]
Theorem: ZeroHom.withTopMap_apply
File: Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean

Proof steps:
state_before: α : Type u
β : Type v
M : Type u_1
N : Type u_2
inst✝¹ : One M
inst✝ : One N
f : OneHom M N
⊢ map (⇑f) 1 = 1
state_after: no goals
tactic: rw [WithTop.map_one, map_one, coe_one]
Theorem: List.pmap_append
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁✝ l₂✝ : List α
p : ι → Prop
f : (a : ι) → p a → α
l₁ l₂ : List ι
h : ∀ (a : ι), a ∈ l₁ ++ l₂ → p a
⊢ pmap f (l₁ ++ l₂) h = pmap f l₁ ⋯ ++ pmap f l₂ ⋯
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂✝ : List α
p : ι → Prop
f : (a : ι) → p a → α
l₂ : List ι
h : ∀ (a : ι), a ∈ [] ++ l₂ → p a
⊢ pmap f ([] ++ l₂) h = pmap f [] ⋯ ++ pmap f l₂ ⋯

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂✝ : List α
p : ι → Prop
f : (a : ι) → p a → α
l₂ : List ι
head✝ : ι
tail✝ : List ι
ih : ∀ (h : ∀ (a : ι), a ∈ tail✝ ++ l₂ → p a), pmap f (tail✝ ++ l₂) h = pmap f tail✝ ⋯ ++ pmap f l₂ ⋯
h : ∀ (a : ι), a ∈ head✝ :: tail✝ ++ l₂ → p a
⊢ pmap f (head✝ :: tail✝ ++ l₂) h = pmap f (head✝ :: tail✝) ⋯ ++ pmap f l₂ ⋯
tactic: induction' l₁ with _ _ ih
Theorem: WittVector.zmodEquivTrunc_compat
File: Mathlib/RingTheory/WittVector/Compare.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k₁ k₂ : ℕ
hk : k₁ ≤ k₂
⊢ (TruncatedWittVector.truncate hk).comp ((zmodEquivTrunc p k₂).toRingHom.comp (PadicInt.toZModPow k₂)) =
    (zmodEquivTrunc p k₁).toRingHom.comp (PadicInt.toZModPow k₁)
state_after: no goals
tactic: rw [← RingHom.comp_assoc, commutes, RingHom.comp_assoc,
    PadicInt.zmod_cast_comp_toZModPow _ _ hk]
Theorem: PartialEquiv.EqOnSource.trans'
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
f f' : PartialEquiv β γ
he : e ≈ e'
hf : f ≈ f'
⊢ e.trans f ≈ e'.trans f'
state_after: case left
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
f f' : PartialEquiv β γ
he : e ≈ e'
hf : f ≈ f'
⊢ (e.trans f).source = (e'.trans f').source

case right
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e✝ : PartialEquiv α β
e'✝ : PartialEquiv β γ
e e' : PartialEquiv α β
f f' : PartialEquiv β γ
he : e ≈ e'
hf : f ≈ f'
⊢ EqOn (↑(e.trans f)) (↑(e'.trans f')) (e.trans f).source
tactic: constructor
Theorem: LSeries.mul_delta_eq_smul_delta
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: f : ℕ → ℂ
⊢ f * δ = f 1 • δ
state_after: case h
f : ℕ → ℂ
n : ℕ
⊢ (f * δ) n = (f 1 • δ) n
tactic: ext n
state_before: case h
f : ℕ → ℂ
n : ℕ
⊢ (f * δ) n = (f 1 • δ) n
state_after: case h
f : ℕ → ℂ
n : ℕ
⊢ (if n = 1 then f n else 0) = if n = 1 then f 1 else 0
tactic: simp only [Pi.mul_apply, delta, mul_ite, mul_one, mul_zero, Pi.smul_apply, smul_eq_mul]
state_before: case h
f : ℕ → ℂ
n : ℕ
⊢ (if n = 1 then f n else 0) = if n = 1 then f 1 else 0
state_after: no goals
tactic: split_ifs with hn <;> simp only [hn]
Theorem: ExteriorAlgebra.ι_mul_prod_list
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean

Proof steps:
state_before: R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
n : ℕ
f : Fin n → M
i : Fin n
⊢ (ι R) (f i) * (List.ofFn fun i => (ι R) (f i)).prod = 0
state_after: case zero
R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : Fin 0 → M
i : Fin 0
⊢ (ι R) (f i) * (List.ofFn fun i => (ι R) (f i)).prod = 0

case succ
R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
n : ℕ
hn : ∀ (f : Fin n → M) (i : Fin n), (ι R) (f i) * (List.ofFn fun i => (ι R) (f i)).prod = 0
f : Fin (n + 1) → M
i : Fin (n + 1)
⊢ (ι R) (f i) * (List.ofFn fun i => (ι R) (f i)).prod = 0
tactic: induction' n with n hn
Theorem: ONote.nf_repr_split'
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: o' : ONote
m : ℕ
x✝ : NF 0
p : split' 0 = (o', m)
⊢ o'.NF ∧ repr 0 = ω * o'.repr + ↑m
state_after: o' : ONote
m : ℕ
x✝ : NF 0
fst_eq✝ : 0 = o'
snd_eq✝ : 0 = m
⊢ o'.NF ∧ repr 0 = ω * o'.repr + ↑m
tactic: injection p
state_before: o' : ONote
m : ℕ
x✝ : NF 0
fst_eq✝ : 0 = o'
snd_eq✝ : 0 = m
⊢ o'.NF ∧ repr 0 = ω * o'.repr + ↑m
state_after: x✝ : NF 0
⊢ NF 0 ∧ repr 0 = ω * repr 0 + ↑0
tactic: substs o' m
state_before: x✝ : NF 0
⊢ NF 0 ∧ repr 0 = ω * repr 0 + ↑0
state_after: no goals
tactic: simp [NF.zero]
state_before: e : ONote
n : ℕ+
a o' : ONote
m : ℕ
h : (e.oadd n a).NF
p : (e.oadd n a).split' = (o', m)
⊢ o'.NF ∧ (e.oadd n a).repr = ω * o'.repr + ↑m
state_after: case pos
e : ONote
n : ℕ+
a o' : ONote
m : ℕ
h : (e.oadd n a).NF
e0 : e = 0
p : 0 = o' ∧ ↑n = m
⊢ o'.NF ∧ ↑↑n + a.repr = ω * o'.repr + ↑m

case neg
e : ONote
n : ℕ+
a o' : ONote
m : ℕ
h : (e.oadd n a).NF
e0 : ¬e = 0
p : (e - 1).oadd n a.split'.1 = o' ∧ a.split'.2 = m
⊢ o'.NF ∧ ω ^ e.repr * ↑↑n + a.repr = ω * o'.repr + ↑m
tactic: by_cases e0 : e = 0 <;> simp [e0, split, split'] at p ⊢
Theorem: List.length_toAssocList
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l : List (α × β)
⊢ l.toAssocList.length = l.length
state_after: no goals
tactic: induction l <;> simp [*]
Theorem: FirstOrder.Language.Ultraproduct.term_realize_cast
File: Mathlib/ModelTheory/Ultraproducts.lean

Proof steps:
state_before: α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝ : (a : α) → L.Structure (M a)
β : Type u_3
x : β → (a : α) → M a
t : L.Term β
⊢ Term.realize (fun i => Quotient.mk' (x i)) t = Quotient.mk' fun a => Term.realize (fun i => x i a) t
state_after: case h.e'_3.h.e'_3
α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝ : (a : α) → L.Structure (M a)
β : Type u_3
x : β → (a : α) → M a
t : L.Term β
⊢ (fun a => Term.realize (fun i => x i a) t) = Term.realize x t
tactic: convert @Term.realize_quotient_mk' L _ ((u : Filter α).productSetoid M)
      (Ultraproduct.setoidPrestructure M u) _ t x using 2
state_before: case h.e'_3.h.e'_3
α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝ : (a : α) → L.Structure (M a)
β : Type u_3
x : β → (a : α) → M a
t : L.Term β
⊢ (fun a => Term.realize (fun i => x i a) t) = Term.realize x t
state_after: case h.e'_3.h.e'_3.h
α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝ : (a : α) → L.Structure (M a)
β : Type u_3
x : β → (a : α) → M a
t : L.Term β
a : α
⊢ Term.realize (fun i => x i a) t = Term.realize x t a
tactic: ext a
state_before: case h.e'_3.h.e'_3.h
α : Type u_1
M : α → Type u_2
u : Ultrafilter α
L : Language
inst✝ : (a : α) → L.Structure (M a)
β : Type u_3
x : β → (a : α) → M a
t : L.Term β
a : α
⊢ Term.realize (fun i => x i a) t = Term.realize x t a
state_after: no goals
tactic: induction t with
  | var => rfl
  | func _ _ t_ih => simp only [Term.realize, t_ih]; rfl
Theorem: Complex.isOpen_setOf_mem_nhds_and_isMaxOn_norm
File: Mathlib/Analysis/Complex/AbsMax.lean

Proof steps:
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
hd : DifferentiableOn ℂ f s
⊢ IsOpen {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
state_after: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
hd : DifferentiableOn ℂ f s
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
⊢ Filter.Eventually (IsMaxOn (norm ∘ f) s) (𝓝 z)
tactic: refine isOpen_iff_mem_nhds.2 fun z hz => (eventually_eventually_nhds.2 hz.1).and ?_
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
hd : DifferentiableOn ℂ f s
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
⊢ Filter.Eventually (IsMaxOn (norm ∘ f) s) (𝓝 z)
state_after: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
hd : ∀ᶠ (w : E) in 𝓝 z, DifferentiableAt ℂ f w
⊢ Filter.Eventually (IsMaxOn (norm ∘ f) s) (𝓝 z)
tactic: replace hd : ∀ᶠ w in 𝓝 z, DifferentiableAt ℂ f w := hd.eventually_differentiableAt hz.1
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
s : Set E
z : E
hz : z ∈ {z | s ∈ 𝓝 z ∧ IsMaxOn (norm ∘ f) s z}
hd : ∀ᶠ (w : E) in 𝓝 z, DifferentiableAt ℂ f w
⊢ Filter.Eventually (IsMaxOn (norm ∘ f) s) (𝓝 z)
state_after: no goals
tactic: exact (norm_eventually_eq_of_isLocalMax hd <| hz.2.isLocalMax hz.1).mono fun x hx y hy =>
    le_trans (hz.2 hy).out hx.ge
Theorem: mem_vadd_const_affineSegment
File: Mathlib/Analysis/Convex/Between.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✝⁶ : OrderedRing R
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 : V
p : P
⊢ z +ᵥ p ∈ affineSegment R (x +ᵥ p) (y +ᵥ p) ↔ z ∈ affineSegment R x y
state_after: no goals
tactic: rw [← affineSegment_vadd_const_image, (vadd_right_injective p).mem_set_image]
Theorem: finsum_mem_eq_sum_filter
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hf : (mulSupport f).Finite
⊢ s ∩ mulSupport f = ↑(Finset.filter (fun x => x ∈ s) hf.toFinset) ∩ mulSupport f
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hf : (mulSupport f).Finite
x : α
⊢ x ∈ s ∩ mulSupport f ↔ x ∈ ↑(Finset.filter (fun x => x ∈ s) hf.toFinset) ∩ mulSupport f
tactic: ext x
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝² : CommMonoid M
inst✝¹ : CommMonoid N
f : α → M
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hf : (mulSupport f).Finite
x : α
⊢ x ∈ s ∩ mulSupport f ↔ x ∈ ↑(Finset.filter (fun x => x ∈ s) hf.toFinset) ∩ mulSupport f
state_after: no goals
tactic: simp [and_comm]
Theorem: Ideal.map_isPrime_of_surjective
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
hf : Function.Surjective ⇑f
I : Ideal R
H : I.IsPrime
hk : RingHom.ker f ≤ I
⊢ (map f I).IsPrime
state_after: case refine_1
R : Type u_1
S : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
hf : Function.Surjective ⇑f
I : Ideal R
H : I.IsPrime
hk : RingHom.ker f ≤ I
h : map f I = ⊤
⊢ ⊤ ≤ I

case refine_2
R : Type u_1
S : Type u_2
F : Type u_3
inst✝² : Ring R
inst✝¹ : Ring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
hf : Function.Surjective ⇑f
I : Ideal R
H : I.IsPrime
hk : RingHom.ker f ≤ I
x y : S
⊢ x * y ∈ map f I → x ∈ map f I ∨ y ∈ map f I
tactic: refine ⟨fun h => H.ne_top (eq_top_iff.2 ?_), fun {x y} => ?_⟩
Theorem: SeparationQuotient.map_comp
File: Mathlib/Topology/UniformSpace/Separation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hf : UniformContinuous f
hg : UniformContinuous g
⊢ mk ∘ g ∘ f = (map g ∘ map f) ∘ mk
state_after: no goals
tactic: simp only [Function.comp, map_mk, hf, hg]
Theorem: CategoryTheory.ShortComplex.Exact.isIso_g'
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.132496, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
⊢ IsIso h.g'
state_after: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.132496, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this : Mono h.g'
⊢ IsIso h.g'
tactic: have := hS.mono_g' h
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.132496, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this : Mono h.g'
⊢ IsIso h.g'
state_after: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.132496, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this✝ : Mono h.g'
this : Epi h.g'
⊢ IsIso h.g'
tactic: have := epi_of_epi_fac h.p_g'
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Category.{?u.132496, u_2} D
inst✝³ : Preadditive C
inst✝² : Preadditive D
S : ShortComplex C
inst✝¹ : Balanced C
hS : S.Exact
h : S.RightHomologyData
inst✝ : Epi S.g
this✝ : Mono h.g'
this : Epi h.g'
⊢ IsIso h.g'
state_after: no goals
tactic: exact isIso_of_mono_of_epi h.g'
Theorem: NormedCommGroup.tendsto_nhds_one
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✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
f : α → E
l : Filter α
⊢ (∀ ε > 0, ∀ᶠ (x : α) in l, dist (f x) 1 < ε) ↔ ∀ ε > 0, ∀ᶠ (x : α) in l, ‖f x‖ < ε
state_after: no goals
tactic: simp only [dist_one_right]
Theorem: PEquiv.isSome_symm_get
File: Mathlib/Data/PEquiv.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
a : α
h : (f a).isSome = true
⊢ f.symm ((f a).get h) = some a
state_after: no goals
tactic: rw [f.eq_some_iff, some_get]
Theorem: List.Nodup.union
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l l₁✝ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
l₁ : List α
h : l₂.Nodup
⊢ (l₁ ∪ l₂).Nodup
state_after: case nil
α : Type u
β : Type v
l l₁ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
l₂ : List α
h : l₂.Nodup
⊢ ([] ∪ l₂).Nodup

case cons
α : Type u
β : Type v
l l₁✝ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l₁ : List α
ih : ∀ {l₂ : List α}, l₂.Nodup → (l₁ ∪ l₂).Nodup
l₂ : List α
h : l₂.Nodup
⊢ (a :: l₁ ∪ l₂).Nodup
tactic: induction' l₁ with a l₁ ih generalizing l₂
Theorem: sub_eq_sub_iff_comm
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✝ : DivisionMonoid α
a b c d : α
⊢ (a / b)⁻¹ = (c / d)⁻¹ ↔ b / a = d / c
state_after: no goals
tactic: simp only [inv_div]
Theorem: HomologicalComplex.pOpcycles_opcyclesIsoSc'_inv
File: Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.sc' i j k).pOpcycles ≫ (K.opcyclesIsoSc' i j k hi hk).inv = K.pOpcycles j
state_after: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.sc' i j k).pOpcycles ≫ ShortComplex.opcyclesMap ((natIsoSc' C c i j k hi hk).inv.app K) = K.pOpcycles j
tactic: dsimp [opcyclesIsoSc']
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.sc' i j k).pOpcycles ≫ ShortComplex.opcyclesMap ((natIsoSc' C c i j k hi hk).inv.app K) = K.pOpcycles j
state_after: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.sc j).pOpcycles = K.pOpcycles j
tactic: simp only [ShortComplex.p_opcyclesMap, shortComplexFunctor'_obj_X₂, shortComplexFunctor_obj_X₂,
    natIsoSc'_inv_app_τ₂, id_comp]
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
inst✝² : HasZeroMorphisms C
ι : Type u_2
c : ComplexShape ι
K : HomologicalComplex C c
i j k : ι
hi : c.prev j = i
hk : c.next j = k
inst✝¹ : K.HasHomology j
inst✝ : (K.sc' i j k).HasHomology
⊢ (K.sc j).pOpcycles = K.pOpcycles j
state_after: no goals
tactic: rfl
Theorem: Matrix.dotProduct_comp_equiv_symm
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
e : n ≃ m
⊢ u ⬝ᵥ x ∘ ⇑e.symm = u ∘ ⇑e ⬝ᵥ x
state_after: no goals
tactic: simpa only [Equiv.symm_symm] using (comp_equiv_symm_dotProduct u x e.symm).symm
Theorem: Cardinal.sum_nat_eq_add_sum_succ
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
f : ℕ → Cardinal.{u}
⊢ sum f = f 0 + sum fun i => f (i + 1)
state_after: α β : Type u
f : ℕ → Cardinal.{u}
⊢ #(Quotient.out (f 0) ⊕ (n : ℕ) × Quotient.out (f (n + 1))) = f 0 + sum fun i => f (i + 1)
tactic: refine (Equiv.sigmaNatSucc fun i => Quotient.out (f i)).cardinal_eq.trans ?_
state_before: α β : Type u
f : ℕ → Cardinal.{u}
⊢ #(Quotient.out (f 0) ⊕ (n : ℕ) × Quotient.out (f (n + 1))) = f 0 + sum fun i => f (i + 1)
state_after: no goals
tactic: simp only [mk_sum, mk_out, lift_id, mk_sigma]