ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Basis.coe_mkFinCons
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R ↥N
hli : ∀ (c : R), ∀ x ∈ N, c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ⇑(mkFinCons y b hli hsp) = Fin.cons y (Subtype.val ∘ ⇑b)
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R ↥N
hli : ∀ (c : R), ∀ x ∈ N, c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ⇑(let_fun span_b := ⋯;
      Basis.mk ⋯ ⋯) =
    Fin.cons y (Subtype.val ∘ ⇑b)
tactic: unfold mkFinCons
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R ↥N
hli : ∀ (c : R), ∀ x ∈ N, c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ⇑(let_fun span_b := ⋯;
      Basis.mk ⋯ ⋯) =
    Fin.cons y (Subtype.val ∘ ⇑b)
state_after: no goals
tactic: exact coe_mk (v := Fin.cons y (N.subtype ∘ b)) _ _
Theorem: Function.extend_div
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Div γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ / g₂) (e₁ / e₂) = extend f g₁ e₁ / extend f g₂ e₂
state_after: no goals
tactic: classical
  funext x
  simp [Function.extend_def, apply_dite₂]
Theorem: Multiset.sum_eq_sum_coe
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
inst✝ : CommMonoid α
m : Multiset α
⊢ m.prod = ∏ x : m.ToType, x.fst
state_after: case e_a
α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
inst✝ : CommMonoid α
m : Multiset α
⊢ m = map (fun x => x.fst) Finset.univ.val
tactic: congr
state_before: case e_a
α : Type u_1
inst✝¹ : DecidableEq α
m✝ : Multiset α
inst✝ : CommMonoid α
m : Multiset α
⊢ m = map (fun x => x.fst) Finset.univ.val
state_after: no goals
tactic: erw [map_univ_coe]
Theorem: singleton_div_closedBall_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} / closedBall 1 δ = closedBall x δ
state_after: no goals
tactic: rw [singleton_div_closedBall, div_one]
Theorem: LSeries_delta
File: Mathlib/NumberTheory/LSeries/Basic.lean

Proof steps:
state_before: ⊢ L δ = 1
state_after: case h
x✝ : ℂ
⊢ L δ x✝ = 1 x✝
tactic: ext
state_before: case h
x✝ : ℂ
⊢ L δ x✝ = 1 x✝
state_after: no goals
tactic: simp only [LSeries, LSeries.term_delta, tsum_ite_eq, Pi.one_apply]
Theorem: Acc.TransGen
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : Acc r a
⊢ Acc (Relation.TransGen r) a
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
⊢ Acc (Relation.TransGen r) x
tactic: induction' h with x _ H
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
⊢ Acc (Relation.TransGen r) x
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
y : α
hy : Relation.TransGen r y x
⊢ Acc (Relation.TransGen r) y
tactic: refine Acc.intro x fun y hy ↦ ?_
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
y : α
hy : Relation.TransGen r y x
⊢ Acc (Relation.TransGen r) y
state_after: case intro.single
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
y : α
hyx : r y x
⊢ Acc (Relation.TransGen r) y

case intro.tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
y z : α
hyz : Relation.TransGen r y z
hzx : r z x
⊢ Acc (Relation.TransGen r) y
tactic: cases' hy with _ hyx z _ hyz hzx
state_before: case intro.single
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
y : α
hyx : r y x
⊢ Acc (Relation.TransGen r) y

case intro.tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d x : α
h✝ : ∀ (y : α), r y x → Acc r y
H : ∀ (y : α), r y x → Acc (Relation.TransGen r) y
y z : α
hyz : Relation.TransGen r y z
hzx : r z x
⊢ Acc (Relation.TransGen r) y
state_after: no goals
tactic: exacts [H y hyx, (H z hzx).inv hyz]
Theorem: Subbimodule.mk_carrier
File: Mathlib/Algebra/Module/Bimodule.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : AddSubmonoid M
hA : ∀ (a : A) {m : M}, m ∈ p → a • m ∈ p
hB : ∀ (b : B) {m : M}, m ∈ p → b • m ∈ p
ab : A ⊗[R] B
m : M
x✝ : m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
⊢ 0 • m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
state_after: no goals
tactic: simpa only [zero_smul] using p.zero_mem
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : AddSubmonoid M
hA : ∀ (a : A) {m : M}, m ∈ p → a • m ∈ p
hB : ∀ (b : B) {m : M}, m ∈ p → b • m ∈ p
ab : A ⊗[R] B
m : M
a : A
b : B
hm : m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
⊢ a ⊗ₜ[R] b • m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
state_after: no goals
tactic: simpa only [TensorProduct.Algebra.smul_def] using hA a (hB b hm)
state_before: R : Type u_1
A : Type u_2
B : Type u_3
M : Type u_4
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : Module R M
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Module A M
inst✝⁵ : Module B M
inst✝⁴ : Algebra R A
inst✝³ : Algebra R B
inst✝² : IsScalarTower R A M
inst✝¹ : IsScalarTower R B M
inst✝ : SMulCommClass A B M
p : AddSubmonoid M
hA : ∀ (a : A) {m : M}, m ∈ p → a • m ∈ p
hB : ∀ (b : B) {m : M}, m ∈ p → b • m ∈ p
ab : A ⊗[R] B
m : M
z w : A ⊗[R] B
hz :
  m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier →
    z • m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
hw :
  m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier →
    w • m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
hm : m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
⊢ (z + w) • m ∈ { carrier := ↑p, add_mem' := ⋯, zero_mem' := ⋯ }.carrier
state_after: no goals
tactic: simpa only [add_smul] using p.add_mem (hz hm) (hw hm)
Theorem: Finset.card_eq_sum_card_fiberwise
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✝ : DecidableEq β
f : α → β
s : Finset α
t : Finset β
H : ∀ x ∈ s, f x ∈ t
⊢ s.card = ∑ a ∈ t, (filter (fun x => f x = a) s).card
state_after: no goals
tactic: simp only [card_eq_sum_ones, sum_fiberwise_of_maps_to H]
Theorem: MeasureTheory.eLpNorm'_measure_zero_of_neg
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : MeasurableSpace α
f : α → F
hq_neg : q < 0
⊢ eLpNorm' f q 0 = ⊤
state_after: no goals
tactic: simp [eLpNorm', hq_neg]
Theorem: Set.encard_union_add_encard_inter
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ s t : Set α
⊢ (s ∪ t).encard + (s ∩ t).encard = s.encard + t.encard
state_after: no goals
tactic: rw [← diff_union_self, encard_union_eq disjoint_sdiff_left, add_right_comm,
    encard_diff_add_encard_inter]
Theorem: DifferentiableWithinAt.hasGradientWithinAt
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
h : DifferentiableWithinAt 𝕜 f s x
⊢ HasGradientWithinAt f (gradientWithin f s x) s x
state_after: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
h : DifferentiableWithinAt 𝕜 f s x
⊢ HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x
tactic: rw [hasGradientWithinAt_iff_hasFDerivWithinAt, gradientWithin,
    (toDual 𝕜 F).apply_symm_apply (fderivWithin 𝕜 f s x)]
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
h : DifferentiableWithinAt 𝕜 f s x
⊢ HasFDerivWithinAt f (fderivWithin 𝕜 f s x) s x
state_after: no goals
tactic: exact h.hasFDerivWithinAt
Theorem: MeasurableEmbedding.sigmaFinite_map
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 α
f : α → β
hf : MeasurableEmbedding f
inst✝ : SigmaFinite μ
⊢ SigmaFinite (Measure.map f μ)
state_after: case refine_1
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
f : α → β
hf : MeasurableEmbedding f
inst✝ : SigmaFinite μ
n : ℕ
⊢ (Measure.map f μ) ((fun n => f '' spanningSets μ n ∪ (range f)ᶜ) n) < ⊤

case refine_2
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
f : α → β
hf : MeasurableEmbedding f
inst✝ : SigmaFinite μ
⊢ ⋃ i, (fun n => f '' spanningSets μ n ∪ (range f)ᶜ) i = univ
tactic: refine ⟨fun n ↦ f '' (spanningSets μ n) ∪ (Set.range f)ᶜ, by simp, fun n ↦ ?_, ?_⟩
Theorem: Batteries.AssocList.any_eq
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
p : α → β → Bool
l : AssocList α β
⊢ any p l =
    l.toList.any fun x =>
      match x with
      | (a, b) => p a b
state_after: no goals
tactic: induction l <;> simp [any, *]
Theorem: Multiset.toFinset_filter
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
s✝ t s : Multiset α
p : α → Prop
inst✝ : DecidablePred p
⊢ (filter p s).toFinset = Finset.filter p s.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
s✝ t s : Multiset α
p : α → Prop
inst✝ : DecidablePred p
a✝ : α
⊢ a✝ ∈ (filter p s).toFinset ↔ a✝ ∈ Finset.filter p s.toFinset
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
s✝ t s : Multiset α
p : α → Prop
inst✝ : DecidablePred p
a✝ : α
⊢ a✝ ∈ (filter p s).toFinset ↔ a✝ ∈ Finset.filter p s.toFinset
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.isColimitCoconeOfConeRightOp_desc
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ C
c : Cone F.rightOp
hc : IsLimit c
s : Cocone F
j : Jᵒᵖ
⊢ ((coconeOfConeRightOp c).ι.app j ≫ (fun s => (hc.lift (coneRightOpOfCocone s)).unop) s).op = (s.ι.app j).op
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ C
c : Cone F.rightOp
hc : IsLimit c
s : Cocone F
m : (coconeOfConeRightOp c).pt ⟶ s.pt
w : ∀ (j : Jᵒᵖ), (coconeOfConeRightOp c).ι.app j ≫ m = s.ι.app j
⊢ m = (fun s => (hc.lift (coneRightOpOfCocone s)).unop) s
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ C
c : Cone F.rightOp
hc : IsLimit c
s : Cocone F
m : (coconeOfConeRightOp c).pt ⟶ s.pt
w : ∀ (j : Jᵒᵖ), (coconeOfConeRightOp c).ι.app j ≫ m = s.ι.app j
j : J
⊢ (m.op ≫ c.π.app j).unop = (((fun s => (hc.lift (coneRightOpOfCocone s)).unop) s).op ≫ c.π.app j).unop
tactic: refine Quiver.Hom.op_inj (hc.hom_ext fun j => Quiver.Hom.unop_inj ?_)
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
F : Jᵒᵖ ⥤ C
c : Cone F.rightOp
hc : IsLimit c
s : Cocone F
m : (coconeOfConeRightOp c).pt ⟶ s.pt
w : ∀ (j : Jᵒᵖ), (coconeOfConeRightOp c).ι.app j ≫ m = s.ι.app j
j : J
⊢ (m.op ≫ c.π.app j).unop = (((fun s => (hc.lift (coneRightOpOfCocone s)).unop) s).op ≫ c.π.app j).unop
state_after: no goals
tactic: simpa only [Quiver.Hom.op_unop, IsLimit.fac] using w (op j)
Theorem: cfc_apply_of_not_predicate
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f✝ g : R → R
a✝ : A
ha✝ : autoParam (p a✝) _auto✝
hf : autoParam (ContinuousOn f✝ (spectrum R a✝)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a✝)) _auto✝
f : R → R
a : A
ha : ¬p a
⊢ cfc f a = 0
state_after: no goals
tactic: rw [cfc_def, dif_neg (not_and_of_not_left _ ha)]
Theorem: Sum.elim_eq_iff
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
γ : Sort u_2
β : Type u_3
u u' : α → γ
v v' : β → γ
⊢ Sum.elim u v = Sum.elim u' v' ↔ u = u' ∧ v = v'
state_after: no goals
tactic: simp [funext_iff]
Theorem: DirectSum.fromAddMonoid_of_apply
File: Mathlib/Algebra/DirectSum/Basic.lean

Proof steps:
state_before: ι : Type v
β : ι → Type w
inst✝² : (i : ι) → AddCommMonoid (β i)
inst✝¹ : DecidableEq ι
γ : Type u₁
inst✝ : AddCommMonoid γ
i : ι
f : γ →+ β i
x : γ
⊢ (fromAddMonoid ((of (fun i => γ →+ β i) i) f)) x = (of β i) (f x)
state_after: no goals
tactic: rw [fromAddMonoid_of, AddMonoidHom.coe_comp, Function.comp]
Theorem: CategoryTheory.ShortComplex.RightHomologyData.ofIsColimitCokernelCofork_Q
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.24747, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ Cofork.π c ≫ (Iso.refl c.pt).hom = Cofork.π (CokernelCofork.ofπ (Cofork.π c) ⋯)
state_after: no goals
tactic: aesop_cat
state_before: C : Type u_1
inst✝¹ : Category.{?u.24747, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ Cofork.π c ≫ 𝟙 c.pt ≫ (hc.ofIsoColimit (Cofork.ext (Iso.refl c.pt) ⋯)).desc (CokernelCofork.ofπ S.g ⋯) =
    Cofork.π c ≫ 0
state_after: no goals
tactic: simp [hg]
state_before: C : Type u_1
inst✝¹ : Category.{?u.24747, u_1} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
A : C
hg : S.g = 0
c : CokernelCofork S.f
hc : IsColimit c
⊢ Cofork.π c ≫ (hc.ofIsoColimit (Cofork.ext (Iso.refl c.pt) ⋯)).desc (CokernelCofork.ofπ S.g ⋯) = Cofork.π c ≫ 0
state_after: no goals
tactic: simp [hg]
Theorem: Multiset.toFinsupp_union
File: Mathlib/Data/Finsupp/Multiset.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
⊢ toFinsupp (s ∪ t) = toFinsupp s ⊔ toFinsupp t
state_after: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
a✝ : α
⊢ (toFinsupp (s ∪ t)) a✝ = (toFinsupp s ⊔ toFinsupp t) a✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
a✝ : α
⊢ (toFinsupp (s ∪ t)) a✝ = (toFinsupp s ⊔ toFinsupp t) a✝
state_after: no goals
tactic: simp [sup_eq_max]
Theorem: SetTheory.PGame.add_lf_add_right
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
y z : PGame
h : y ⧏ z
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ y + x ⧏ z + x
state_after: xl xr : Type u
y z : PGame
h : ¬z ≤ y
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ ¬z + x ≤ y + x
tactic: rw [← PGame.not_le] at h ⊢
state_before: xl xr : Type u
y z : PGame
h : ¬z ≤ y
x : PGame
this : z + x ≤ y + x → z ≤ y
⊢ ¬z + x ≤ y + x
state_after: no goals
tactic: exact mt this h
Theorem: Set.mapsTo_empty_iff
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
⊢ MapsTo f s ∅ ↔ s = ∅
state_after: no goals
tactic: simp [mapsTo', subset_empty_iff]
Theorem: ContinuousMap.image_coev
File: Mathlib/Topology/CompactOpen.lean

Proof steps:
state_before: α : Type u_1
X : Type u_2
Y : Type u_3
Z : Type u_4
T : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace T
K : Set X
U : Set Y
y : Y
s : Set X
⊢ ⇑(coev X Y y) '' s = {y} ×ˢ s
state_after: no goals
tactic: simp
Theorem: AdicCompletion.val_sum
File: Mathlib/RingTheory/AdicCompletion/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
I : Ideal R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
N : Type u_3
inst✝¹ : AddCommGroup N
inst✝ : Module R N
α : Type u_4
s : Finset α
f : α → AdicCompletion I M
n : ℕ
⊢ ↑(s.sum f) n = ∑ a ∈ s, ↑(f a) n
state_after: no goals
tactic: simp_rw [← incl_apply, map_sum, Finset.sum_apply]
Theorem: ValuationSubring.coe_mem_principalUnitGroup_iff
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
⊢ ↑x ∈ A.principalUnitGroup ↔ A.unitGroupMulEquiv x ∈ (Units.map ↑(LocalRing.residue ↥A)).ker
state_after: K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
⊢ ↑x ∈ A.principalUnitGroup ↔ ↑((Units.map ↑(LocalRing.residue ↥A)) (A.unitGroupMulEquiv x)) = ↑1
tactic: rw [MonoidHom.mem_ker, Units.ext_iff]
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
⊢ ↑x ∈ A.principalUnitGroup ↔ ↑((Units.map ↑(LocalRing.residue ↥A)) (A.unitGroupMulEquiv x)) = ↑1
state_after: K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
π : ↥A →+* ↥A ⧸ LocalRing.maximalIdeal ↥A := Ideal.Quotient.mk (LocalRing.maximalIdeal ↥A)
⊢ ↑x ∈ A.principalUnitGroup ↔ ↑((Units.map ↑(LocalRing.residue ↥A)) (A.unitGroupMulEquiv x)) = ↑1
tactic: let π := Ideal.Quotient.mk (LocalRing.maximalIdeal A)
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
π : ↥A →+* ↥A ⧸ LocalRing.maximalIdeal ↥A := Ideal.Quotient.mk (LocalRing.maximalIdeal ↥A)
⊢ ↑x ∈ A.principalUnitGroup ↔ ↑((Units.map ↑(LocalRing.residue ↥A)) (A.unitGroupMulEquiv x)) = ↑1
state_after: case convert_3
K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
π : ↥A →+* ↥A ⧸ LocalRing.maximalIdeal ↥A := Ideal.Quotient.mk (LocalRing.maximalIdeal ↥A)
⊢ ↑x ∈ A.principalUnitGroup ↔ π ↑(A.unitGroupMulEquiv x) = 1
tactic: convert_to _ ↔ π _ = 1
state_before: case convert_3
K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
π : ↥A →+* ↥A ⧸ LocalRing.maximalIdeal ↥A := Ideal.Quotient.mk (LocalRing.maximalIdeal ↥A)
⊢ ↑x ∈ A.principalUnitGroup ↔ π ↑(A.unitGroupMulEquiv x) = 1
state_after: case convert_3
K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
π : ↥A →+* ↥A ⧸ LocalRing.maximalIdeal ↥A := Ideal.Quotient.mk (LocalRing.maximalIdeal ↥A)
⊢ ↑x ∈ A.principalUnitGroup ↔ A.valuation ↑(↑(A.unitGroupMulEquiv x) - 1) < 1
tactic: rw [← π.map_one, ← sub_eq_zero, ← π.map_sub, Ideal.Quotient.eq_zero_iff_mem, valuation_lt_one_iff]
state_before: case convert_3
K : Type u
inst✝ : Field K
A : ValuationSubring K
x : ↥A.unitGroup
π : ↥A →+* ↥A ⧸ LocalRing.maximalIdeal ↥A := Ideal.Quotient.mk (LocalRing.maximalIdeal ↥A)
⊢ ↑x ∈ A.principalUnitGroup ↔ A.valuation ↑(↑(A.unitGroupMulEquiv x) - 1) < 1
state_after: no goals
tactic: simp [mem_principalUnitGroup_iff]
Theorem: upperBounds_closure
File: Mathlib/Topology/Order/OrderClosed.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : ClosedIicTopology α
f : β → α
a✝ b : α
s✝ s : Set α
a : α
⊢ a ∈ upperBounds (closure s) ↔ a ∈ upperBounds s
state_after: no goals
tactic: simp_rw [mem_upperBounds_iff_subset_Iic, isClosed_Iic.closure_subset_iff]
Theorem: tendsto_fract_left'
File: Mathlib/Topology/Algebra/Order/Floor.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto fract (𝓝[<] ↑n) (𝓝 1)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto fract (𝓝[<] ↑n) (𝓝 (↑n - (↑n - 1)))
tactic: rw [← sub_sub_cancel (n : α) 1]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto fract (𝓝[<] ↑n) (𝓝 (↑n - (↑n - 1)))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto (fun x => ↑⌊x⌋) (𝓝[<] ↑n) (𝓝 (↑n - 1))
tactic: refine (tendsto_id.mono_left nhdsWithin_le_nhds).sub ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : FloorRing α
inst✝² : TopologicalSpace α
inst✝¹ : OrderClosedTopology α
inst✝ : TopologicalAddGroup α
n : ℤ
⊢ Tendsto (fun x => ↑⌊x⌋) (𝓝[<] ↑n) (𝓝 (↑n - 1))
state_after: no goals
tactic: exact tendsto_floor_left' n
Theorem: IsAdjoinRoot.map_eq_zero_iff
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRoot S f
p : R[X]
⊢ h.map p = 0 ↔ f ∣ p
state_after: no goals
tactic: rw [← h.mem_ker_map, RingHom.mem_ker]