ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Pretriangulated.isoTriangleOfIso₁₂_inv_hom₁
File: Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
⊢ T₁ ≅ T₂
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
h : ∃ e', e'.hom.hom₁ = (Arrow.isoMk e₁ e₂ ⋯).hom.left ∧ e'.hom.hom₂ = (Arrow.isoMk e₁ e₂ ⋯).hom.right
⊢ T₁ ≅ T₂
tactic: have h := exists_iso_of_arrow_iso T₁ T₂ hT₁ hT₂ (Arrow.isoMk e₁ e₂ comm.symm)
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : Preadditive C
inst✝ : ∀ (n : ℤ), (shiftFunctor C n).Additive
hC : Pretriangulated C
T₁ T₂ : Triangle C
hT₁ : T₁ ∈ distinguishedTriangles
hT₂ : T₂ ∈ distinguishedTriangles
e₁ : T₁.obj₁ ≅ T₂.obj₁
e₂ : T₁.obj₂ ≅ T₂.obj₂
comm : T₁.mor₁ ≫ e₂.hom = e₁.hom ≫ T₂.mor₁
h : ∃ e', e'.hom.hom₁ = (Arrow.isoMk e₁ e₂ ⋯).hom.left ∧ e'.hom.hom₂ = (Arrow.isoMk e₁ e₂ ⋯).hom.right
⊢ T₁ ≅ T₂
state_after: no goals
tactic: exact Triangle.isoMk _ _ e₁ e₂ (Triangle.π₃.mapIso h.choose) comm (by
    have eq := h.choose_spec.2
    dsimp at eq ⊢
    conv_rhs => rw [← eq, ← TriangleMorphism.comm₂]) (by
    have eq := h.choose_spec.1
    dsimp at eq ⊢
    conv_lhs => rw [← eq, TriangleMorphism.comm₃])
Theorem: Monoid.Coprod.range_inl_sup_range_inr
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Group G
inst✝ : Group H
⊢ inl.range ⊔ inr.range = ⊤
state_after: no goals
tactic: rw [← closure_range_inl_union_inr, Subgroup.closure_union, ← MonoidHom.coe_range,
    ← MonoidHom.coe_range, Subgroup.closure_eq, Subgroup.closure_eq]
Theorem: ContinuousMultilinearMap.norm_compContinuousLinearMapL_le
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f : (i : ι) → E i →L[𝕜] E₁ i
⊢ 0 ≤ ∏ i : ι, ‖f i‖
state_after: no goals
tactic: positivity
Theorem: Polynomial.Chebyshev.U_neg_sub_one
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ U R (-n - 1) = -U R (n - 1)
state_after: no goals
tactic: induction n using Polynomial.Chebyshev.induct with
  | zero => simp
  | one => simp
  | add_two n ih1 ih2 =>
    have h₁ := U_add_one R n
    have h₂ := U_sub_two R (-n - 1)
    linear_combination (norm := ring_nf) 2 * (X : R[X]) * ih1 - ih2 + h₁ + h₂
  | neg_add_one n ih1 ih2 =>
    have h₁ := U_eq R n
    have h₂ := U_sub_two R (-n)
    linear_combination (norm := ring_nf) 2 * (X : R[X]) * ih1 - ih2 + h₁ + h₂
Theorem: CochainComplex.HomComplex.Cochain.leftShiftAddEquiv_symm_apply
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n a n' : ℤ
hn' : n + a = n'
γ : Cochain K L n
⊢ (fun γ => γ.leftUnshift n hn') ((fun γ => γ.leftShift a n' hn') γ) = γ
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n a n' : ℤ
hn' : n + a = n'
γ : Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'
⊢ (fun γ => γ.leftShift a n' hn') ((fun γ => γ.leftUnshift n hn') γ) = γ
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ✝ γ₁ γ₂ : Cochain K L n✝
n a n' : ℤ
hn' : n + a = n'
γ γ' : Cochain K L n
⊢ { toFun := fun γ => γ.leftShift a n' hn', invFun := fun γ => γ.leftUnshift n hn', left_inv := ⋯,
          right_inv := ⋯ }.toFun
      (γ + γ') =
    { toFun := fun γ => γ.leftShift a n' hn', invFun := fun γ => γ.leftUnshift n hn', left_inv := ⋯,
            right_inv := ⋯ }.toFun
        γ +
      { toFun := fun γ => γ.leftShift a n' hn', invFun := fun γ => γ.leftUnshift n hn', left_inv := ⋯,
            right_inv := ⋯ }.toFun
        γ'
state_after: no goals
tactic: simp
Theorem: Finset.uIcc_subset_uIcc_union_uIcc
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ ↑[[a, c]] ⊆ ↑([[a, b]] ∪ [[b, c]])
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.uIcc a c ⊆ Set.uIcc a b ∪ Set.uIcc b c
tactic: push_cast
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Set.uIcc a c ⊆ Set.uIcc a b ∪ Set.uIcc b c
state_after: no goals
tactic: exact Set.uIcc_subset_uIcc_union_uIcc
Theorem: Ideal.isJacobson_of_isIntegral
File: Mathlib/RingTheory/Jacobson.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
hR : IsJacobson R
⊢ IsJacobson S
state_after: R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
hR : IsJacobson R
⊢ ∀ (P : Ideal S), P.IsPrime → P.jacobson = P
tactic: rw [isJacobson_iff_prime_eq]
state_before: R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
hR : IsJacobson R
⊢ ∀ (P : Ideal S), P.IsPrime → P.jacobson = P
state_after: R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : P.IsPrime
⊢ P.jacobson = P
tactic: intro P hP
state_before: R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : P.IsPrime
⊢ P.jacobson = P
state_after: case pos
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : P.IsPrime
hP_top : comap (algebraMap R S) P = ⊤
⊢ P.jacobson = P

case neg
R : Type u_1
S : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing S
I : Ideal R
inst✝¹ : Algebra R S
inst✝ : Algebra.IsIntegral R S
hR : IsJacobson R
P : Ideal S
hP : P.IsPrime
hP_top : ¬comap (algebraMap R S) P = ⊤
⊢ P.jacobson = P
tactic: by_cases hP_top : comap (algebraMap R S) P = ⊤
Theorem: MeasureTheory.setIntegral_prod_mul
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν
inst✝⁴ : NormedSpace ℝ E
inst✝³ : SFinite μ
E' : Type u_7
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace ℝ E'
L : Type u_8
inst✝ : _root_.RCLike L
f : α → L
g : β → L
s : Set α
t : Set β
⊢ ∫ (z : α × β) in s ×ˢ t, f z.1 * g z.2 ∂μ.prod ν = (∫ (x : α) in s, f x ∂μ) * ∫ (y : β) in t, g y ∂ν
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν
inst✝⁴ : NormedSpace ℝ E
inst✝³ : SFinite μ
E' : Type u_7
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace ℝ E'
L : Type u_8
inst✝ : _root_.RCLike L
f : α → L
g : β → L
s : Set α
t : Set β
⊢ ∫ (z : α × β), f z.1 * g z.2 ∂(μ.restrict s).prod (ν.restrict t) = (∫ (x : α) in s, f x ∂μ) * ∫ (y : β) in t, g y ∂ν
tactic: rw [← Measure.prod_restrict s t]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : MeasurableSpace α'
inst✝⁹ : MeasurableSpace β
inst✝⁸ : MeasurableSpace β'
inst✝⁷ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : SFinite ν
inst✝⁴ : NormedSpace ℝ E
inst✝³ : SFinite μ
E' : Type u_7
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace ℝ E'
L : Type u_8
inst✝ : _root_.RCLike L
f : α → L
g : β → L
s : Set α
t : Set β
⊢ ∫ (z : α × β), f z.1 * g z.2 ∂(μ.restrict s).prod (ν.restrict t) = (∫ (x : α) in s, f x ∂μ) * ∫ (y : β) in t, g y ∂ν
state_after: no goals
tactic: apply integral_prod_mul
Theorem: rTensor_mkQ
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ ker (rTensor Q N.mkQ) = range (rTensor Q N.subtype)
state_after: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ Exact ⇑(rTensor Q N.subtype) ⇑(rTensor Q N.mkQ)
tactic: rw [← exact_iff]
state_before: R : Type u_1
M : Type u_2
N✝ : Type u_3
P : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup N✝
inst✝⁵ : AddCommGroup P
inst✝⁴ : Module R M
inst✝³ : Module R N✝
inst✝² : Module R P
f : M →ₗ[R] N✝
g : N✝ →ₗ[R] P
Q : Type u_5
inst✝¹ : AddCommGroup Q
inst✝ : Module R Q
hfg : Exact ⇑f ⇑g
hg : Surjective ⇑g
N : Submodule R M
⊢ Exact ⇑(rTensor Q N.subtype) ⇑(rTensor Q N.mkQ)
state_after: no goals
tactic: exact rTensor_exact Q (LinearMap.exact_subtype_mkQ N) (Submodule.mkQ_surjective N)
Theorem: Fin.natCast_eq_last
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
⊢ ↑n = last n
state_after: case h
n✝ m n : ℕ
⊢ ↑↑n = ↑(last n)
tactic: ext
state_before: case h
n✝ m n : ℕ
⊢ ↑↑n = ↑(last n)
state_after: no goals
tactic: simp
Theorem: AddLECancellable.le_add_iff_nonneg_right
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LE α
inst✝¹ : MulOneClass α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
ha : MulLECancellable a
⊢ a ≤ a * b ↔ a * 1 ≤ a * b
state_after: no goals
tactic: rw [mul_one]
Theorem: FirstOrder.Language.Theory.models_iff_not_satisfiable
File: Mathlib/ModelTheory/Satisfiability.lean

Proof steps:
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ T ⊨ᵇ φ ↔ ¬(T ∪ {Formula.not φ}).IsSatisfiable
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ (∀ (M : T.ModelType), ↑M ⊨ φ) ↔ ¬Nonempty (T ∪ {Formula.not φ}).ModelType
tactic: rw [models_sentence_iff, IsSatisfiable]
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
⊢ (∀ (M : T.ModelType), ↑M ⊨ φ) ↔ ¬Nonempty (T ∪ {Formula.not φ}).ModelType
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
h : ¬Nonempty (T ∪ {Formula.not φ}).ModelType
M : T.ModelType
⊢ ↑M ⊨ φ
tactic: refine
    ⟨fun h1 h2 =>
      (Sentence.realize_not _).1
        (realize_sentence_of_mem (T ∪ {Formula.not φ})
          (Set.subset_union_right (Set.mem_singleton _)))
        (h1 (h2.some.subtheoryModel Set.subset_union_left)),
      fun h M => ?_⟩
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
h : ¬Nonempty (T ∪ {Formula.not φ}).ModelType
M : T.ModelType
⊢ ↑M ⊨ φ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ¬↑M ⊨ φ
⊢ Nonempty (T ∪ {Formula.not φ}).ModelType
tactic: contrapose! h
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ¬↑M ⊨ φ
⊢ Nonempty (T ∪ {Formula.not φ}).ModelType
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ↑M ⊨ Formula.not φ
⊢ Nonempty (T ∪ {Formula.not φ}).ModelType
tactic: rw [← Sentence.realize_not] at h
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ↑M ⊨ Formula.not φ
⊢ Nonempty (T ∪ {Formula.not φ}).ModelType
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ↑M ⊨ Formula.not φ
ψ : L.Sentence
hψ : ψ ∈ T ∪ {Formula.not φ}
h' : ψ ∈ {Formula.not φ}
⊢ ↑M ⊨ ψ
tactic: refine
    ⟨{  Carrier := M
        is_model := ⟨fun ψ hψ => hψ.elim (realize_sentence_of_mem _) fun h' => ?_⟩ }⟩
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ↑M ⊨ Formula.not φ
ψ : L.Sentence
hψ : ψ ∈ T ∪ {Formula.not φ}
h' : ψ ∈ {Formula.not φ}
⊢ ↑M ⊨ ψ
state_after: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ↑M ⊨ Formula.not φ
ψ : L.Sentence
hψ : ψ ∈ T ∪ {Formula.not φ}
h' : ψ ∈ {Formula.not φ}
⊢ ↑M ⊨ Formula.not φ
tactic: rw [Set.mem_singleton_iff.1 h']
state_before: L : Language
T : L.Theory
α : Type w
n : ℕ
φ : L.Sentence
M : T.ModelType
h : ↑M ⊨ Formula.not φ
ψ : L.Sentence
hψ : ψ ∈ T ∪ {Formula.not φ}
h' : ψ ∈ {Formula.not φ}
⊢ ↑M ⊨ Formula.not φ
state_after: no goals
tactic: exact h
Theorem: multiplicity.lt_top_iff_finite
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Monoid α
inst✝² : Monoid β
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a b : α
⊢ multiplicity a b < ⊤ ↔ Finite a b
state_after: no goals
tactic: rw [lt_top_iff_ne_top, ne_top_iff_finite]
Theorem: Set.toFinset_ssubset_toFinset
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑t
⊢ s.toFinset ⊂ t.toFinset ↔ s ⊂ t
state_after: no goals
tactic: simp only [Finset.ssubset_def, toFinset_subset_toFinset, ssubset_def]
Theorem: norm_of_subsingleton'
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₂ : ℝ
inst✝ : Subsingleton E
a : E
⊢ ‖a‖ = 0
state_after: no goals
tactic: rw [Subsingleton.elim a 1, norm_one']
Theorem: discreteTopology_of_isOpen_singleton_zero
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsOpen {1}
⊢ DiscreteTopology G
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsOpen {1}
⊢ ∀ (a : G), IsOpen {a}
tactic: rw [← singletons_open_iff_discrete]
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsOpen {1}
⊢ ∀ (a : G), IsOpen {a}
state_after: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsOpen {1}
g : G
⊢ IsOpen {g}
tactic: intro g
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsOpen {1}
g : G
⊢ {g} = (fun x => g⁻¹ * x) ⁻¹' {1}
state_after: no goals
tactic: simp only [mul_one, Set.preimage_mul_left_singleton, eq_self_iff_true, inv_inv,
    Set.singleton_eq_singleton_iff]
Theorem: Sym2.map_map
File: Mathlib/Data/Sym/Sym2.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
g : β → γ
f : α → β
x : Sym2 α
⊢ map g (map f x) = map (g ∘ f) x
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
g : β → γ
f : α → β
x✝ y✝ : α
⊢ map g (map f s(x✝, y✝)) = map (g ∘ f) s(x✝, y✝)
tactic: induction x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
g : β → γ
f : α → β
x✝ y✝ : α
⊢ map g (map f s(x✝, y✝)) = map (g ∘ f) s(x✝, y✝)
state_after: no goals
tactic: aesop
Theorem: Basis.toMatrix_reindex
File: Mathlib/LinearAlgebra/Matrix/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
⊢ (b.reindex e).toMatrix v = (b.toMatrix v).submatrix (⇑e.symm) _root_.id
state_after: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
i✝ j✝ : ι'
⊢ (b.reindex e).toMatrix v i✝ j✝ = (b.toMatrix v).submatrix (⇑e.symm) _root_.id i✝ j✝
tactic: ext
state_before: case a
ι : Type u_1
ι' : Type u_2
κ : Type u_3
κ' : Type u_4
R : Type u_5
M : Type u_6
inst✝⁷ : CommSemiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
R₂ : Type u_7
M₂ : Type u_8
inst✝⁴ : CommRing R₂
inst✝³ : AddCommGroup M₂
inst✝² : Module R₂ M₂
e✝ : Basis ι R M
v✝ : ι' → M
i : ι
j : ι'
N : Type u_9
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
b✝ : Basis ι R M
b' : Basis ι' R M
c : Basis κ R N
c' : Basis κ' R N
f : M →ₗ[R] N
b : Basis ι R M
v : ι' → M
e : ι ≃ ι'
i✝ j✝ : ι'
⊢ (b.reindex e).toMatrix v i✝ j✝ = (b.toMatrix v).submatrix (⇑e.symm) _root_.id i✝ j✝
state_after: no goals
tactic: simp only [Basis.toMatrix_apply, Basis.repr_reindex, Matrix.submatrix_apply, _root_.id,
    Finsupp.mapDomain_equiv_apply]
Theorem: CategoryTheory.Limits.map_π_preserves_coequalizer_inv_desc
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = g ≫ h
inst✝² : HasCoequalizer f g
inst✝¹ : HasCoequalizer (G.map f) (G.map g)
inst✝ : PreservesColimit (parallelPair f g) G
W : D
k : G.obj Y ⟶ W
wk : G.map f ≫ k = G.map g ≫ k
⊢ G.map (coequalizer.π f g) ≫ (PreservesCoequalizer.iso G f g).inv ≫ coequalizer.desc k wk = k
state_after: no goals
tactic: rw [← Category.assoc, map_π_preserves_coequalizer_inv, coequalizer.π_desc]
Theorem: Ring.inverse_mul_cancel_left
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ inverse x * (x * y) = y
state_after: no goals
tactic: rw [← mul_assoc, inverse_mul_cancel x h, one_mul]
Theorem: toIocMod_add_zsmul
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocMod hp a (b + m • p) = toIocMod hp a b
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b + m • p - (toIocDiv hp a b • p + m • p) = b - toIocDiv hp a b • p
tactic: rw [toIocMod, toIocDiv_add_zsmul, toIocMod, add_smul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ b + m • p - (toIocDiv hp a b • p + m • p) = b - toIocDiv hp a b • p
state_after: no goals
tactic: abel
Theorem: Polynomial.leadingCoeff_linear
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
ha : a ≠ 0
⊢ (C a * X + C b).leadingCoeff = a
state_after: no goals
tactic: rw [add_comm, leadingCoeff_add_of_degree_lt (degree_C_lt_degree_C_mul_X ha),
    leadingCoeff_C_mul_X]
Theorem: Polynomial.rootMultiplicity_C
File: Mathlib/Algebra/Polynomial/Div.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
r a : R
⊢ rootMultiplicity a (C r) = 0
state_after: case inl
R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
r a : R
h✝ : Subsingleton R
⊢ rootMultiplicity a (C r) = 0

case inr
R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
r a : R
h✝ : Nontrivial R
⊢ rootMultiplicity a (C r) = 0
tactic: cases subsingleton_or_nontrivial R
Theorem: List.drop_take_succ_join_eq_getElem'
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
h : i < L.length
⊢ drop (Nat.sum (take i (map length L))) (take (Nat.sum (take (i + 1) (map length L))) L.join) = L[i]
state_after: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
h : i < L.length
this : take i (map length L) = take i (map length (take (i + 1) L))
⊢ drop (Nat.sum (take i (map length L))) (take (Nat.sum (take (i + 1) (map length L))) L.join) = L[i]
tactic: have : (L.map length).take i = ((L.take (i + 1)).map length).take i := by
    simp [map_take, take_take, Nat.min_eq_left]
state_before: α : Type u_1
β : Type u_2
L : List (List α)
i : ℕ
h : i < L.length
this : take i (map length L) = take i (map length (take (i + 1) L))
⊢ drop (Nat.sum (take i (map length L))) (take (Nat.sum (take (i + 1) (map length L))) L.join) = L[i]
state_after: no goals
tactic: simp only [this, length_map, take_sum_join', drop_sum_join', drop_take_succ_eq_cons_getElem, h,
    join, append_nil]