ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Equiv.Perm.cycleFactorsFinset_eq_singleton_iff
File: Mathlib/GroupTheory/Perm/Cycle/Factors.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
⊢ f.cycleFactorsFinset = {g} ↔ f.IsCycle ∧ f = g
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
⊢ f = g → (g.IsCycle ↔ f.IsCycle)
tactic: suffices f = g → (g.IsCycle ↔ f.IsCycle) by
    rw [cycleFactorsFinset_eq_finset]
    simpa [eq_comm]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f g : Perm α
⊢ f = g → (g.IsCycle ↔ f.IsCycle)
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f : Perm α
⊢ f.IsCycle ↔ f.IsCycle
tactic: rintro rfl
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f : Perm α
⊢ f.IsCycle ↔ f.IsCycle
state_after: no goals
tactic: exact Iff.rfl
Theorem: CategoryTheory.Functor.isTriangulated_of_precomp_iso
File: Mathlib/CategoryTheory/Triangulated/Functor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝²⁴ : Category.{u_4, u_1} C
inst✝²³ : Category.{u_6, u_2} D
inst✝²² : Category.{u_5, u_3} E
inst✝²¹ : HasShift C ℤ
inst✝²⁰ : HasShift D ℤ
inst✝¹⁹ : HasShift E ℤ
F : C ⥤ D
inst✝¹⁸ : F.CommShift ℤ
G : D ⥤ E
inst✝¹⁷ : G.CommShift ℤ
inst✝¹⁶ : HasZeroObject C
inst✝¹⁵ : HasZeroObject D
inst✝¹⁴ : HasZeroObject E
inst✝¹³ : Preadditive C
inst✝¹² : Preadditive D
inst✝¹¹ : Preadditive E
inst✝¹⁰ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝⁹ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁸ : ∀ (n : ℤ), (shiftFunctor E n).Additive
inst✝⁷ : Pretriangulated C
inst✝⁶ : Pretriangulated D
inst✝⁵ : Pretriangulated E
H : C ⥤ E
e : F ⋙ G ≅ H
inst✝⁴ : H.CommShift ℤ
inst✝³ : H.IsTriangulated
inst✝² : F.IsTriangulated
inst✝¹ : F.mapArrow.EssSurj
inst✝ : NatTrans.CommShift e.hom ℤ
⊢ G.IsTriangulated
state_after: C : Type u_1
D : Type u_2
E : Type u_3
inst✝²⁴ : Category.{u_4, u_1} C
inst✝²³ : Category.{u_6, u_2} D
inst✝²² : Category.{u_5, u_3} E
inst✝²¹ : HasShift C ℤ
inst✝²⁰ : HasShift D ℤ
inst✝¹⁹ : HasShift E ℤ
F : C ⥤ D
inst✝¹⁸ : F.CommShift ℤ
G : D ⥤ E
inst✝¹⁷ : G.CommShift ℤ
inst✝¹⁶ : HasZeroObject C
inst✝¹⁵ : HasZeroObject D
inst✝¹⁴ : HasZeroObject E
inst✝¹³ : Preadditive C
inst✝¹² : Preadditive D
inst✝¹¹ : Preadditive E
inst✝¹⁰ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝⁹ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁸ : ∀ (n : ℤ), (shiftFunctor E n).Additive
inst✝⁷ : Pretriangulated C
inst✝⁶ : Pretriangulated D
inst✝⁵ : Pretriangulated E
H : C ⥤ E
e : F ⋙ G ≅ H
inst✝⁴ : H.CommShift ℤ
inst✝³ : H.IsTriangulated
inst✝² : F.IsTriangulated
inst✝¹ : F.mapArrow.EssSurj
inst✝ : NatTrans.CommShift e.hom ℤ
this : (F ⋙ G).IsTriangulated
⊢ G.IsTriangulated
tactic: have := (isTriangulated_iff_of_iso e).2 inferInstance
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝²⁴ : Category.{u_4, u_1} C
inst✝²³ : Category.{u_6, u_2} D
inst✝²² : Category.{u_5, u_3} E
inst✝²¹ : HasShift C ℤ
inst✝²⁰ : HasShift D ℤ
inst✝¹⁹ : HasShift E ℤ
F : C ⥤ D
inst✝¹⁸ : F.CommShift ℤ
G : D ⥤ E
inst✝¹⁷ : G.CommShift ℤ
inst✝¹⁶ : HasZeroObject C
inst✝¹⁵ : HasZeroObject D
inst✝¹⁴ : HasZeroObject E
inst✝¹³ : Preadditive C
inst✝¹² : Preadditive D
inst✝¹¹ : Preadditive E
inst✝¹⁰ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝⁹ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁸ : ∀ (n : ℤ), (shiftFunctor E n).Additive
inst✝⁷ : Pretriangulated C
inst✝⁶ : Pretriangulated D
inst✝⁵ : Pretriangulated E
H : C ⥤ E
e : F ⋙ G ≅ H
inst✝⁴ : H.CommShift ℤ
inst✝³ : H.IsTriangulated
inst✝² : F.IsTriangulated
inst✝¹ : F.mapArrow.EssSurj
inst✝ : NatTrans.CommShift e.hom ℤ
this : (F ⋙ G).IsTriangulated
⊢ G.IsTriangulated
state_after: no goals
tactic: exact isTriangulated_of_precomp F G
Theorem: unique_iff_subsingleton_and_nonempty
File: Mathlib/Logic/Unique.lean

Proof steps:
state_before: α : Sort u
x✝ : Nonempty (Unique α)
u : Unique α
⊢ Subsingleton α ∧ Nonempty α
state_after: no goals
tactic: constructor <;> exact inferInstance
state_before: α : Sort u
x✝ : Subsingleton α ∧ Nonempty α
hs : Subsingleton α
hn : Nonempty α
⊢ Unique α
state_after: α : Sort u
x✝ : Subsingleton α ∧ Nonempty α
hs : Subsingleton α
hn : Nonempty α
inhabited_h : Inhabited α
⊢ Unique α
tactic: inhabit α
state_before: α : Sort u
x✝ : Subsingleton α ∧ Nonempty α
hs : Subsingleton α
hn : Nonempty α
inhabited_h : Inhabited α
⊢ Unique α
state_after: no goals
tactic: exact Unique.mk' α
Theorem: SetTheory.PGame.Impartial.impartial_congr
File: Mathlib/SetTheory/Game/Impartial.lean

Proof steps:
state_before: G H : PGame
e : G ≡r H
⊢ ∀ [inst : G.Impartial], H.Impartial
state_after: G H : PGame
e : G ≡r H
h : G.Impartial
⊢ H.Impartial
tactic: intro h
state_before: G H : PGame
e : G ≡r H
h : G.Impartial
⊢ H.Impartial
state_after: no goals
tactic: exact impartial_def.2
      ⟨Equiv.trans e.symm.equiv (Equiv.trans (neg_equiv_self G) (neg_equiv_neg_iff.2 e.equiv)),
        fun i => impartial_congr (e.moveLeftSymm i), fun j => impartial_congr (e.moveRightSymm j)⟩
Theorem: IsPrimitiveRoot.adjoinEquivRingOfIntegers'_symm_apply
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ IsCyclotomicExtension {p ^ 1} ℚ K
state_after: case h.e'_1.h.e'_4
p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ p ^ 1 = p
tactic: convert hcycl
state_before: case h.e'_1.h.e'_4
p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ p ^ 1 = p
state_after: no goals
tactic: rw [pow_one]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
⊢ IsPrimitiveRoot ζ ↑(p ^ 1)
state_after: no goals
tactic: rwa [pow_one]
Theorem: Finset.mem_eraseNone
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Finset (Option α)
x : α
⊢ x ∈ eraseNone s ↔ some x ∈ s
state_after: no goals
tactic: simp [eraseNone]
Theorem: CategoryTheory.ShortComplex.Homotopy.compRight_h₂
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.158486, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
h : Homotopy φ₁ φ₂
ψ : S₂ ⟶ S₃
⊢ (φ₁ ≫ ψ).τ₁ = S₁.f ≫ h.h₁ ≫ ψ.τ₁ + h.h₀ ≫ ψ.τ₁ + (φ₂ ≫ ψ).τ₁
state_after: no goals
tactic: rw [comp_τ₁, comp_τ₁, h.comm₁, add_comp, add_comp, assoc]
state_before: C : Type u_1
inst✝¹ : Category.{?u.158486, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
h : Homotopy φ₁ φ₂
ψ : S₂ ⟶ S₃
⊢ (φ₁ ≫ ψ).τ₂ = S₁.g ≫ h.h₂ ≫ ψ.τ₂ + (h.h₁ ≫ ψ.τ₁) ≫ S₃.f + (φ₂ ≫ ψ).τ₂
state_after: no goals
tactic: rw [comp_τ₂, comp_τ₂, h.comm₂, add_comp, add_comp, assoc, assoc, assoc, ψ.comm₁₂]
state_before: C : Type u_1
inst✝¹ : Category.{?u.158486, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂
h : Homotopy φ₁ φ₂
ψ : S₂ ⟶ S₃
⊢ (φ₁ ≫ ψ).τ₃ = h.h₃ ≫ ψ.τ₃ + (h.h₂ ≫ ψ.τ₂) ≫ S₃.g + (φ₂ ≫ ψ).τ₃
state_after: no goals
tactic: rw [comp_τ₃, comp_τ₃, h.comm₃, add_comp, add_comp, assoc, assoc, ψ.comm₂₃]
Theorem: WeierstrassCurve.Jacobian.negDblY_of_Z_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
hPz : P z = 0
⊢ W'.negDblY P = -(P x ^ 2) ^ 3
state_after: no goals
tactic: linear_combination (norm :=
      (rw [negDblY, dblU_of_Z_eq_zero hPz, dblX_of_Z_eq_zero hP hPz, negY_of_Z_eq_zero hPz]; ring1))
    (8 * (equation_of_Z_eq_zero hPz).mp hP - 12 * P x ^ 3) * (equation_of_Z_eq_zero hPz).mp hP
Theorem: CategoryTheory.IsCodetecting.isCoseparating
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : HasCoequalizers C
𝒢 : Set C
⊢ IsCodetecting 𝒢 → IsCoseparating 𝒢
state_after: no goals
tactic: simpa only [← isSeparating_op_iff, ← isDetecting_op_iff] using IsDetecting.isSeparating
Theorem: AdjoinRoot.Polynomial.quotQuotEquivComm_symm_mk_mk
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝ : CommRing R
I : Ideal R
f p : R[X]
⊢ (quotQuotEquivComm I f).symm
      ((Ideal.Quotient.mk (span {(Ideal.Quotient.mk (Ideal.map C I)) f})) ((Ideal.Quotient.mk (Ideal.map C I)) p)) =
    (Ideal.Quotient.mk (span {Polynomial.map (Ideal.Quotient.mk I) f})) (Polynomial.map (Ideal.Quotient.mk I) p)
state_after: no goals
tactic: simp only [Polynomial.quotQuotEquivComm, quotientEquiv_symm_mk,
    polynomialQuotientEquivQuotientPolynomial_symm_mk]
Theorem: MeasureTheory.eLpNorm_smul_measure_of_ne_zero
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
p : ℝ≥0∞
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
⊢ eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ
state_after: case pos
α : 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
p : ℝ≥0∞
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
hp0 : p = 0
⊢ eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ

case neg
α : 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
p : ℝ≥0∞
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
hp0 : ¬p = 0
⊢ eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ
tactic: by_cases hp0 : p = 0
state_before: case neg
α : 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
p : ℝ≥0∞
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
hp0 : ¬p = 0
⊢ eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ
state_after: case pos
α : 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
p : ℝ≥0∞
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
hp0 : ¬p = 0
hp_top : p = ⊤
⊢ eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ

case neg
α : 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
p : ℝ≥0∞
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
hp0 : ¬p = 0
hp_top : ¬p = ⊤
⊢ eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ
tactic: by_cases hp_top : p = ∞
state_before: case neg
α : 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
p : ℝ≥0∞
f : α → F
c : ℝ≥0∞
hc : c ≠ 0
hp0 : ¬p = 0
hp_top : ¬p = ⊤
⊢ eLpNorm f p (c • μ) = c ^ (1 / p).toReal • eLpNorm f p μ
state_after: no goals
tactic: exact eLpNorm_smul_measure_of_ne_zero_of_ne_top hp0 hp_top c
Theorem: Ordinal.add_le_nadd
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c : Ordinal.{u}
⊢ a + b ≤ a ♯ b
state_after: no goals
tactic: induction b using limitRecOn with
  | H₁ => simp
  | H₂ c h =>
    rwa [add_succ, nadd_succ, succ_le_succ_iff]
  | H₃ c hc H =>
    simp_rw [← IsNormal.blsub_eq.{u, u} (add_isNormal a) hc, blsub_le_iff]
    exact fun i hi => (H i hi).trans_lt (nadd_lt_nadd_left hi a)
Theorem: not_uncountable_iff
File: Mathlib/Data/Countable/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
⊢ ¬Uncountable α ↔ Countable α
state_after: no goals
tactic: rw [uncountable_iff_not_countable, not_not]
Theorem: Mathlib.Meta.NormNum.isRat_inv_neg_one
File: Mathlib/Tactic/NormNum/Inv.lean

Proof steps:
state_before: u : Lean.Level
α : Type u_1
inst✝ : DivisionRing α
⊢ (↑(Int.negOfNat 1))⁻¹ = ↑(Int.negOfNat 1)
state_after: no goals
tactic: simp [inv_neg_one]
Theorem: IsDedekindDomain.HeightOneSpectrum.intValuation.map_one'
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
⊢ v.intValuationDef 1 = 1
state_after: no goals
tactic: rw [v.intValuationDef_if_neg (zero_ne_one.symm : (1 : R) ≠ 0), Ideal.span_singleton_one, ←
    Ideal.one_eq_top, Associates.mk_one, Associates.factors_one,
    Associates.count_zero (by apply v.associates_irreducible), Int.ofNat_zero, neg_zero, ofAdd_zero,
    WithZero.coe_one]
Theorem: Primrec.fin_curry
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n → σ
h : Primrec₂ f
a : α
⊢ (Vector.ofFn fun i => f a i).get = f a
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n → σ
h : Primrec₂ f
a : α
i : Fin n
⊢ (Vector.ofFn fun i => f a i).get i = f a i
tactic: funext i
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : α → Fin n → σ
h : Primrec₂ f
a : α
i : Fin n
⊢ (Vector.ofFn fun i => f a i).get i = f a i
state_after: no goals
tactic: simp
Theorem: _private.Mathlib.Algebra.Module.LocalizedModule.0.LocalizedModule.add_comm'
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
x y : LocalizedModule S M
m m' : M
s s' : ↥S
⊢ mk m s + mk m' s' = mk m' s' + mk m s
state_after: no goals
tactic: rw [mk_add_mk, mk_add_mk, add_comm, mul_comm]
Theorem: id_nullhomotopic
File: Mathlib/Topology/Homotopy/Contractible.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : ContractibleSpace X
⊢ (ContinuousMap.id X).Nullhomotopic
state_after: case intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : ContractibleSpace X
hv : X ≃ₕ Unit
⊢ (ContinuousMap.id X).Nullhomotopic
tactic: obtain ⟨hv⟩ := ContractibleSpace.hequiv_unit X
state_before: case intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : ContractibleSpace X
hv : X ≃ₕ Unit
⊢ (ContinuousMap.id X).Nullhomotopic
state_after: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : ContractibleSpace X
hv : X ≃ₕ Unit
⊢ (ContinuousMap.id X).Homotopic (const X (hv.invFun ()))
tactic: use hv.invFun ()
state_before: case h
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : ContractibleSpace X
hv : X ≃ₕ Unit
⊢ (ContinuousMap.id X).Homotopic (const X (hv.invFun ()))
state_after: no goals
tactic: convert hv.left_inv.symm
Theorem: VectorFourier.fourierPowSMulRight_apply
File: Mathlib/Analysis/Fourier/FourierTransformDeriv.lean

Proof steps:
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℂ E
V : Type u_2
W : Type u_3
inst✝³ : NormedAddCommGroup V
inst✝² : NormedSpace ℝ V
inst✝¹ : NormedAddCommGroup W
inst✝ : NormedSpace ℝ W
L : V →L[ℝ] W →L[ℝ] ℝ
f✝ f : V → E
v : V
n : ℕ
m : Fin n → W
⊢ (fourierPowSMulRight L f v n) m = (-(2 * ↑π * I)) ^ n • (∏ i : Fin n, (L v) (m i)) • f v
state_after: no goals
tactic: simp [fourierPowSMulRight]
Theorem: GaussianInt.toComplex_star
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x : ℤ[i]
⊢ toComplex (star x) = (starRingEnd ℂ) (toComplex x)
state_after: x : ℤ[i]
⊢ { re := ↑(star x).re, im := ↑(star x).im } = (starRingEnd ℂ) { re := ↑x.re, im := ↑x.im }
tactic: rw [toComplex_def₂, toComplex_def₂]
state_before: x : ℤ[i]
⊢ { re := ↑(star x).re, im := ↑(star x).im } = (starRingEnd ℂ) { re := ↑x.re, im := ↑x.im }
state_after: no goals
tactic: exact congr_arg₂ _ rfl (Int.cast_neg _)
Theorem: CategoryTheory.Monad.toMon_one
File: Mathlib/CategoryTheory/Monad/EquivMon.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
M : Monad C
⊢ MonoidalCategory.whiskerRight M.μ M.toFunctor ≫ M.μ =
    (MonoidalCategory.associator M.toFunctor M.toFunctor M.toFunctor).hom ≫
      MonoidalCategory.whiskerLeft M.toFunctor M.μ ≫ M.μ
state_after: case w.h
C : Type u
inst✝ : Category.{v, u} C
M : Monad C
x✝ : C
⊢ (MonoidalCategory.whiskerRight M.μ M.toFunctor ≫ M.μ).app x✝ =
    ((MonoidalCategory.associator M.toFunctor M.toFunctor M.toFunctor).hom ≫
          MonoidalCategory.whiskerLeft M.toFunctor M.μ ≫ M.μ).app
      x✝
tactic: ext
state_before: case w.h
C : Type u
inst✝ : Category.{v, u} C
M : Monad C
x✝ : C
⊢ (MonoidalCategory.whiskerRight M.μ M.toFunctor ≫ M.μ).app x✝ =
    ((MonoidalCategory.associator M.toFunctor M.toFunctor M.toFunctor).hom ≫
          MonoidalCategory.whiskerLeft M.toFunctor M.μ ≫ M.μ).app
      x✝
state_after: no goals
tactic: simp [M.assoc]
Theorem: Filter.ZeroAtFilter.add
File: Mathlib/Order/Filter/ZeroAndBoundedAtFilter.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝² : TopologicalSpace β
inst✝¹ : AddZeroClass β
inst✝ : ContinuousAdd β
l : Filter α
f g : α → β
hf : l.ZeroAtFilter f
hg : l.ZeroAtFilter g
⊢ l.ZeroAtFilter (f + g)
state_after: no goals
tactic: simpa using hf.add hg
Theorem: CategoryTheory.MonoOver.mapIso_functor
File: Mathlib/CategoryTheory/Subobject/MonoOver.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A B : C
e : A ≅ B
⊢ map (e.hom ≫ e.inv) = map (𝟙 A)
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
A B : C
e : A ≅ B
⊢ map (e.inv ≫ e.hom) = map (𝟙 B)
state_after: no goals
tactic: simp
Theorem: HomogeneousLocalization.val_intCast
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
n : ℤ
⊢ n.castDef.val = ↑n
state_after: no goals
tactic: cases n <;> simp [Int.castDef, *]
Theorem: MvPowerSeries.isUnit_iff_constantCoeff
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
⊢ IsUnit φ ↔ IsUnit ((constantCoeff σ R) φ)
state_after: case mp
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
⊢ IsUnit φ → IsUnit ((constantCoeff σ R) φ)

case mpr
σ : Type u_1
R : Type u_2
inst✝ : Ring R
φ : MvPowerSeries σ R
⊢ IsUnit ((constantCoeff σ R) φ) → IsUnit φ
tactic: constructor
Theorem: Finsupp.subtypeDomain_eq_zero_iff
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
p : α → Prop
f : α →₀ M
hf : ∀ x ∈ f.support, p x
H : ∀ (x : α), p x → f x = 0
x : α
⊢ f x = 0 x
state_after: no goals
tactic: classical exact if hx : p x then H x hx else not_mem_support_iff.1 <| mt (hf x) hx
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
p : α → Prop
f : α →₀ M
hf : ∀ x ∈ f.support, p x
H : f = 0
x : α
x✝ : p x
⊢ f x = 0
state_after: no goals
tactic: simp [H]
Theorem: sub_eq_zero
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✝ : Group G
a b c d : G
n : ℤ
h : a = b
⊢ a / b = 1
state_after: no goals
tactic: rw [h, div_self']
Theorem: Pell.Solution₁.eq_one_of_x_eq_one
File: Mathlib/NumberTheory/Pell.lean

Proof steps:
state_before: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
⊢ a = 1
state_after: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : d * a.y ^ 2 = a.x ^ 2 - 1
⊢ a = 1
tactic: have prop := a.prop_y
state_before: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : d * a.y ^ 2 = a.x ^ 2 - 1
⊢ a = 1
state_after: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : a.y = 0
⊢ a = 1
tactic: rw [ha, one_pow, sub_self, mul_eq_zero, or_iff_right h₀, sq_eq_zero_iff] at prop
state_before: d : ℤ
h₀ : d ≠ 0
a : Solution₁ d
ha : a.x = 1
prop : a.y = 0
⊢ a = 1
state_after: no goals
tactic: exact ext ha prop
Theorem: CategoryTheory.Monad.adj_counit
File: Mathlib/CategoryTheory/Monad/Algebra.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ T.map (T.map f ≫ Y.a) ≫ Y.a = (T.free.obj X).a ≫ T.map f ≫ Y.a
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ T.map (T.map f ≫ Y.a) ≫ Y.a = T.μ.app X ≫ T.map f ≫ Y.a
tactic: dsimp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ T.map (T.map f ≫ Y.a) ≫ Y.a = T.μ.app X ≫ T.map f ≫ Y.a
state_after: no goals
tactic: simp [← Y.assoc, ← T.μ.naturality_assoc]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : T.free.obj X ⟶ Y
⊢ (fun f => { f := T.map f ≫ Y.a, h := ⋯ }) ((fun f => T.η.app X ≫ f.f) f) = f
state_after: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : T.free.obj X ⟶ Y
⊢ ((fun f => { f := T.map f ≫ Y.a, h := ⋯ }) ((fun f => T.η.app X ≫ f.f) f)).f = f.f
tactic: ext
state_before: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : T.free.obj X ⟶ Y
⊢ ((fun f => { f := T.map f ≫ Y.a, h := ⋯ }) ((fun f => T.η.app X ≫ f.f) f)).f = f.f
state_after: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : T.free.obj X ⟶ Y
⊢ T.map (T.η.app X ≫ f.f) ≫ Y.a = f.f
tactic: dsimp
state_before: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : T.free.obj X ⟶ Y
⊢ T.map (T.η.app X ≫ f.f) ≫ Y.a = f.f
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ (fun f => T.η.app X ≫ f.f) ((fun f => { f := T.map f ≫ Y.a, h := ⋯ }) f) = f
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ T.η.app X ≫ T.map f ≫ Y.a = f
tactic: dsimp only [forget_obj]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ T.η.app X ≫ T.map f ≫ Y.a = f
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ (𝟭 C).map f ≫ 𝟙 Y.A = f
tactic: rw [← T.η.naturality_assoc, Y.unit]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
X : C
Y : T.Algebra
f : X ⟶ T.forget.obj Y
⊢ (𝟭 C).map f ≫ 𝟙 Y.A = f
state_after: no goals
tactic: apply Category.comp_id