ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WittVector.ghostComponent_verschiebungFun
File: Mathlib/RingTheory/WittVector/Verschiebung.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n : ℕ
⊢ (ghostComponent (n + 1)) x.verschiebungFun = ↑p * (ghostComponent n) x
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n : ℕ
⊢ ∑ i ∈ Finset.range (n + 1 + 1), ↑p ^ i * x.verschiebungFun.coeff i ^ p ^ (n + 1 - i) =
    ↑p * ∑ i ∈ Finset.range (n + 1), ↑p ^ i * x.coeff i ^ p ^ (n - i)
tactic: simp only [ghostComponent_apply, aeval_wittPolynomial]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n : ℕ
⊢ ∑ i ∈ Finset.range (n + 1 + 1), ↑p ^ i * x.verschiebungFun.coeff i ^ p ^ (n + 1 - i) =
    ↑p * ∑ i ∈ Finset.range (n + 1), ↑p ^ i * x.coeff i ^ p ^ (n - i)
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n : ℕ
⊢ ∀ x_1 ∈ Finset.range (n + 1),
    ↑p ^ (x_1 + 1) * x.verschiebungFun.coeff (x_1 + 1) ^ p ^ (n + 1 - (x_1 + 1)) =
      ↑p * (↑p ^ x_1 * x.coeff x_1 ^ p ^ (n - x_1))
tactic: rw [Finset.sum_range_succ', verschiebungFun_coeff, if_pos rfl,
    zero_pow (pow_ne_zero _ hp.1.ne_zero), mul_zero, add_zero, Finset.mul_sum, Finset.sum_congr rfl]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n : ℕ
⊢ ∀ x_1 ∈ Finset.range (n + 1),
    ↑p ^ (x_1 + 1) * x.verschiebungFun.coeff (x_1 + 1) ^ p ^ (n + 1 - (x_1 + 1)) =
      ↑p * (↑p ^ x_1 * x.coeff x_1 ^ p ^ (n - x_1))
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n i : ℕ
⊢ ↑p ^ (i + 1) * x.verschiebungFun.coeff (i + 1) ^ p ^ (n + 1 - (i + 1)) = ↑p * (↑p ^ i * x.coeff i ^ p ^ (n - i))
tactic: rintro i -
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
x : 𝕎 R
n i : ℕ
⊢ ↑p ^ (i + 1) * x.verschiebungFun.coeff (i + 1) ^ p ^ (n + 1 - (i + 1)) = ↑p * (↑p ^ i * x.coeff i ^ p ^ (n - i))
state_after: no goals
tactic: simp only [pow_succ', verschiebungFun_coeff_succ, Nat.succ_sub_succ_eq_sub, mul_assoc]
Theorem: Filter.HasBasis.biInter_biUnion_ball
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
U : ι → Set (α × α)
h : (𝓤 α).HasBasis p U
s : Set α
⊢ ⋂ i, ⋂ (_ : p i), ⋃ x ∈ s, ball x (U i) = closure s
state_after: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
U : ι → Set (α × α)
h : (𝓤 α).HasBasis p U
s : Set α
x : α
⊢ x ∈ ⋂ i, ⋂ (_ : p i), ⋃ x ∈ s, ball x (U i) ↔ x ∈ closure s
tactic: ext x
state_before: case h
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
p : ι → Prop
U : ι → Set (α × α)
h : (𝓤 α).HasBasis p U
s : Set α
x : α
⊢ x ∈ ⋂ i, ⋂ (_ : p i), ⋃ x ∈ s, ball x (U i) ↔ x ∈ closure s
state_after: no goals
tactic: simp [mem_closure_iff_nhds_basis (nhds_basis_uniformity h), ball]
Theorem: AdjoinRoot.Minpoly.toAdjoin_apply'
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
x : S
a : AdjoinRoot (minpoly R x)
⊢ (aeval ⟨x, ⋯⟩) (minpoly R x) = 0
state_after: no goals
tactic: simp [← Subalgebra.coe_eq_zero, aeval_subalgebra_coe]
Theorem: IsAddGroupHom.sub
File: Mathlib/Deprecated/Group.lean

Proof steps:
state_before: α✝ : Type u
β✝ : Type v
α : Type u_1
β : Type u_2
inst✝¹ : AddGroup α
inst✝ : AddCommGroup β
f g : α → β
hf : IsAddGroupHom f
hg : IsAddGroupHom g
⊢ IsAddGroupHom fun a => f a - g a
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
Theorem: SatisfiesM_Except_eq
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

Proof steps:
state_before: ε : Type u_1
α✝ : Type u_2
p : α✝ → Prop
x : Except ε α✝
⊢ SatisfiesM p x → ∀ (a : α✝), x = Except.ok a → p a
state_after: ε : Type u_1
α✝ : Type u_2
p : α✝ → Prop
⊢ ∀ {x : Except ε α✝}, SatisfiesM p x → ∀ (a : α✝), x = Except.ok a → p a
tactic: revert x
state_before: ε : Type u_1
α✝ : Type u_2
p : α✝ → Prop
⊢ ∀ {x : Except ε α✝}, SatisfiesM p x → ∀ (a : α✝), x = Except.ok a → p a
state_after: no goals
tactic: intro | .ok _, ⟨.ok ⟨_, h⟩, rfl⟩, _, rfl => exact h
Theorem: ENNReal.tsum_toReal_eq
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → ℝ≥0∞
hf : ∀ (a : α), f a ≠ ⊤
⊢ (∑' (a : α), f a).toReal = ∑' (a : α), (f a).toReal
state_after: no goals
tactic: simp only [ENNReal.toReal, tsum_toNNReal_eq hf, NNReal.coe_tsum]
Theorem: Mathlib.Vector.mapAccumr₂_bisim_tail
File: Mathlib/Data/Vector/MapLemmas.lean

Proof steps:
state_before: α : Type
n : ℕ
xs : Vector α n
β σ₁ γ σ₂ : Type
ys : Vector β n
f₁ : α → β → σ₁ → σ₁ × γ
f₂ : α → β → σ₂ → σ₂ × γ
s₁ : σ₁
s₂ : σ₂
h :
  ∃ R, R s₁ s₂ ∧ ∀ {s : σ₁} {q : σ₂} (a : α) (b : β), R s q → R (f₁ a b s).1 (f₂ a b q).1 ∧ (f₁ a b s).2 = (f₂ a b q).2
⊢ (mapAccumr₂ f₁ xs ys s₁).2 = (mapAccumr₂ f₂ xs ys s₂).2
state_after: case intro.intro
α : Type
n : ℕ
xs : Vector α n
β σ₁ γ σ₂ : Type
ys : Vector β n
f₁ : α → β → σ₁ → σ₁ × γ
f₂ : α → β → σ₂ → σ₂ × γ
s₁ : σ₁
s₂ : σ₂
R : σ₁ → σ₂ → Prop
h₀ : R s₁ s₂
hR : ∀ {s : σ₁} {q : σ₂} (a : α) (b : β), R s q → R (f₁ a b s).1 (f₂ a b q).1 ∧ (f₁ a b s).2 = (f₂ a b q).2
⊢ (mapAccumr₂ f₁ xs ys s₁).2 = (mapAccumr₂ f₂ xs ys s₂).2
tactic: rcases h with ⟨R, h₀, hR⟩
state_before: case intro.intro
α : Type
n : ℕ
xs : Vector α n
β σ₁ γ σ₂ : Type
ys : Vector β n
f₁ : α → β → σ₁ → σ₁ × γ
f₂ : α → β → σ₂ → σ₂ × γ
s₁ : σ₁
s₂ : σ₂
R : σ₁ → σ₂ → Prop
h₀ : R s₁ s₂
hR : ∀ {s : σ₁} {q : σ₂} (a : α) (b : β), R s q → R (f₁ a b s).1 (f₂ a b q).1 ∧ (f₁ a b s).2 = (f₂ a b q).2
⊢ (mapAccumr₂ f₁ xs ys s₁).2 = (mapAccumr₂ f₂ xs ys s₂).2
state_after: no goals
tactic: exact (mapAccumr₂_bisim R h₀ hR).2
Theorem: ContinuousLinearMap.comp_zero
File: Mathlib/Topology/Algebra/Module/Basic.lean

Proof steps:
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁷ : Semiring R₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁴ : TopologicalSpace M₁
inst✝¹³ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹² : TopologicalSpace M'₁
inst✝¹¹ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommMonoid M₄
inst✝⁴ : Module R₁ M₁
inst✝³ : Module R₁ M'₁
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
g : M₂ →SL[σ₂₃] M₃
⊢ g.comp 0 = 0
state_after: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁷ : Semiring R₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁴ : TopologicalSpace M₁
inst✝¹³ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹² : TopologicalSpace M'₁
inst✝¹¹ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommMonoid M₄
inst✝⁴ : Module R₁ M₁
inst✝³ : Module R₁ M'₁
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
g : M₂ →SL[σ₂₃] M₃
x✝ : M₁
⊢ (g.comp 0) x✝ = 0 x✝
tactic: ext
state_before: case h
R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁷ : Semiring R₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁴ : TopologicalSpace M₁
inst✝¹³ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹² : TopologicalSpace M'₁
inst✝¹¹ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommMonoid M₄
inst✝⁴ : Module R₁ M₁
inst✝³ : Module R₁ M'₁
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
g : M₂ →SL[σ₂₃] M₃
x✝ : M₁
⊢ (g.comp 0) x✝ = 0 x✝
state_after: no goals
tactic: simp
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.pi
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

Proof steps:
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
⊢ (MorphismProperty.pi W).IsInvertedBy (Functor.pi F)
state_after: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ IsIso ((Functor.pi F).map f)
tactic: intro _ _ f hf
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ IsIso ((Functor.pi F).map f)
state_after: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ ∀ (i : J), IsIso ((Functor.pi F).map f i)
tactic: rw [isIso_pi_iff]
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
⊢ ∀ (i : J), IsIso ((Functor.pi F).map f i)
state_after: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
j : J
⊢ IsIso ((Functor.pi F).map f j)
tactic: intro j
state_before: C✝ : Type u
inst✝³ : Category.{v, u} C✝
D✝ : Type u'
inst✝² : Category.{v', u'} D✝
J : Type w
C : J → Type u
D : J → Type u'
inst✝¹ : (j : J) → Category.{v, u} (C j)
inst✝ : (j : J) → Category.{v', u'} (D j)
W : (j : J) → MorphismProperty (C j)
F : (j : J) → C j ⥤ D j
hF : ∀ (j : J), (W j).IsInvertedBy (F j)
X✝ Y✝ : (j : J) → C j
f : X✝ ⟶ Y✝
hf : MorphismProperty.pi W f
j : J
⊢ IsIso ((Functor.pi F).map f j)
state_after: no goals
tactic: exact hF j _ (hf j)
Theorem: PNat.XgcdType.isSpecial_iff
File: Mathlib/Data/PNat/Xgcd.lean

Proof steps:
state_before: u : XgcdType
⊢ u.IsSpecial ↔ u.IsSpecial'
state_after: u : XgcdType
⊢ u.wp + u.zp + u.wp * u.zp = u.x * u.y ↔ u.w * u.z = (u.x * u.y).succPNat
tactic: dsimp [IsSpecial, IsSpecial']
state_before: u : XgcdType
⊢ u.wp + u.zp + u.wp * u.zp = u.x * u.y ↔ u.w * u.z = (u.x * u.y).succPNat
state_after: u : XgcdType
wp x y zp ap bp : ℕ
⊢ { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.wp +
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.zp +
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.wp *
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.zp =
      { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.x *
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.y ↔
    { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.w *
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.z =
      ({ wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.x *
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.y).succPNat
tactic: let ⟨wp, x, y, zp, ap, bp⟩ := u
state_before: u : XgcdType
wp x y zp ap bp : ℕ
⊢ { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.wp +
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.zp +
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.wp *
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.zp =
      { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.x *
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.y ↔
    { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.w *
        { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.z =
      ({ wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.x *
          { wp := wp, x := x, y := y, zp := zp, ap := ap, bp := bp }.y).succPNat
state_after: case mp
u : XgcdType
wp x y zp ap bp : ℕ
h : wp + zp + wp * zp = x * y
⊢ (wp + 1) * (zp + 1) = x * y + 1

case mpr
u : XgcdType
wp x y zp ap bp : ℕ
h : (wp + 1) * (zp + 1) = x * y + 1
⊢ wp + zp + wp * zp = x * y
tactic: constructor <;> intro h <;> simp [w, z, succPNat] at * <;>
    simp only [← coe_inj, mul_coe, mk_coe] at *
Theorem: Finset.prod_map
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✝ : CommMonoid β
s : Finset α
e : α ↪ γ
f : γ → β
⊢ ∏ x ∈ map e s, f x = ∏ x ∈ s, f (e x)
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
e : α ↪ γ
f : γ → β
⊢ (Multiset.map ((fun x => f x) ∘ ⇑e) s.val).prod = ∏ x ∈ s, f (e x)
tactic: rw [Finset.prod, Finset.map_val, Multiset.map_map]
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✝ : CommMonoid β
s : Finset α
e : α ↪ γ
f : γ → β
⊢ (Multiset.map ((fun x => f x) ∘ ⇑e) s.val).prod = ∏ x ∈ s, f (e x)
state_after: no goals
tactic: rfl
Theorem: Fin.append_left_nil
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
⊢ m + n = n
state_after: no goals
tactic: rw [hu, Nat.zero_add]
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
⊢ append u v = v ∘ cast ⋯
state_after: case refine_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
l : Fin m
⊢ append u v (castAdd n l) = (v ∘ cast ⋯) (castAdd n l)

case refine_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Type u_1
u : Fin m → α
v : Fin n → α
hu : m = 0
r : Fin n
⊢ append u v (natAdd m r) = (v ∘ cast ⋯) (natAdd m r)
tactic: refine funext (Fin.addCases (fun l => ?_) fun r => ?_)
Theorem: CategoryTheory.ShortComplex.quasiIso_iff_isIso_descOpcycles
File: Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean

Proof steps:
state_before: C : Type ?u.31337
inst✝⁵ : Category.{?u.31341, ?u.31337} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
hg₁ : S₁.g = 0
hf₂ : S₂.f = 0
hg₂ : S₂.g = 0
⊢ S₁.f ≫ φ.τ₂ = 0
state_after: no goals
tactic: rw [← φ.comm₁₂, hf₂, comp_zero]
state_before: C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
hg₁ : S₁.g = 0
hf₂ : S₂.f = 0
hg₂ : S₂.g = 0
⊢ QuasiIso φ ↔ IsIso (S₁.descOpcycles φ.τ₂ ⋯)
state_after: C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
hg₁ : S₁.g = 0
hf₂ : S₂.f = 0
hg₂ : S₂.g = 0
H : RightHomologyMapData φ
  (RightHomologyData.ofIsColimitCokernelCofork S₁ hg₁ (CokernelCofork.ofπ S₁.pOpcycles ⋯) S₁.opcyclesIsCokernel)
  (RightHomologyData.ofZeros S₂ hf₂ hg₂) :=
  { φQ := S₁.descOpcycles φ.τ₂ ⋯, φH := S₁.descOpcycles φ.τ₂ ⋯, commp := ⋯, commg' := ⋯, commι := ⋯ }
⊢ QuasiIso φ ↔ IsIso (S₁.descOpcycles φ.τ₂ ⋯)
tactic: let H : RightHomologyMapData φ
      (RightHomologyData.ofIsColimitCokernelCofork S₁ hg₁ _ S₁.opcyclesIsCokernel)
        (RightHomologyData.ofZeros S₂ hf₂ hg₂) :=
    { φQ := S₁.descOpcycles φ.τ₂ (by rw [← φ.comm₁₂, hf₂, comp_zero])
      φH := S₁.descOpcycles φ.τ₂ (by rw [← φ.comm₁₂, hf₂, comp_zero]) }
state_before: C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
hg₁ : S₁.g = 0
hf₂ : S₂.f = 0
hg₂ : S₂.g = 0
H : RightHomologyMapData φ
  (RightHomologyData.ofIsColimitCokernelCofork S₁ hg₁ (CokernelCofork.ofπ S₁.pOpcycles ⋯) S₁.opcyclesIsCokernel)
  (RightHomologyData.ofZeros S₂ hf₂ hg₂) :=
  { φQ := S₁.descOpcycles φ.τ₂ ⋯, φH := S₁.descOpcycles φ.τ₂ ⋯, commp := ⋯, commg' := ⋯, commι := ⋯ }
⊢ QuasiIso φ ↔ IsIso (S₁.descOpcycles φ.τ₂ ⋯)
state_after: no goals
tactic: exact H.quasiIso_iff
Theorem: Set.einfsep_ne_top
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
⊢ s.einfsep ≠ ⊤ ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ edist x y ≠ ⊤
state_after: no goals
tactic: simp_rw [← lt_top_iff_ne_top, einfsep_lt_top]
Theorem: IsCompactlyGenerated.BooleanGenerators.sSup_le_sSup_iff_of_atoms
File: Mathlib/Order/BooleanGenerators.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
X Y : Set α
hX : X ⊆ S
hY : Y ⊆ S
⊢ sSup X ≤ sSup Y ↔ X ⊆ Y
state_after: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
X Y : Set α
hX : X ⊆ S
hY : Y ⊆ S
⊢ sSup X ≤ sSup Y → X ⊆ Y
tactic: refine ⟨?_, sSup_le_sSup⟩
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
X Y : Set α
hX : X ⊆ S
hY : Y ⊆ S
⊢ sSup X ≤ sSup Y → X ⊆ Y
state_after: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
X Y : Set α
hX : X ⊆ S
hY : Y ⊆ S
h : sSup X ≤ sSup Y
a : α
ha : a ∈ X
⊢ a ∈ Y
tactic: intro h a ha
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
X Y : Set α
hX : X ⊆ S
hY : Y ⊆ S
h : sSup X ≤ sSup Y
a : α
ha : a ∈ X
⊢ a ∈ Y
state_after: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
X Y : Set α
hX : X ⊆ S
hY : Y ⊆ S
h : sSup X ≤ sSup Y
a : α
ha : a ∈ X
⊢ IsAtom a
tactic: apply (hS.mono hY).mem_of_isAtom_of_le_sSup_atoms _ _ ((le_sSup ha).trans h)
state_before: α : Type u_1
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
S : Set α
hS : BooleanGenerators S
X Y : Set α
hX : X ⊆ S
hY : Y ⊆ S
h : sSup X ≤ sSup Y
a : α
ha : a ∈ X
⊢ IsAtom a
state_after: no goals
tactic: exact (hS.mono hX).isAtom a ha
Theorem: CategoryTheory.GradedObject.comapEq_hom_app
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
f g : β → γ
h : f = g
X : GradedObject γ C
b : β
⊢ (comap C f).obj X b = (comap C g).obj X b
state_after: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
f g : β → γ
h : f = g
X : GradedObject γ C
b : β
⊢ X (f b) = X (g b)
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
f g : β → γ
h : f = g
X : GradedObject γ C
b : β
⊢ X (f b) = X (g b)
state_after: no goals
tactic: simp only [h]
state_before: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
f g : β → γ
h : f = g
X : GradedObject γ C
b : β
⊢ (comap C g).obj X b = (comap C f).obj X b
state_after: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
f g : β → γ
h : f = g
X : GradedObject γ C
b : β
⊢ X (g b) = X (f b)
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
β γ : Type w
f g : β → γ
h : f = g
X : GradedObject γ C
b : β
⊢ X (g b) = X (f b)
state_after: no goals
tactic: simp only [h]
Theorem: subset_sSup_of_within
File: Mathlib/Order/CompleteLatticeIntervals.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝² : Preorder α
inst✝¹ : SupSet α
inst✝ : Inhabited ↑s
t : Set ↑s
h' : t.Nonempty
h'' : BddAbove t
h : sSup (Subtype.val '' t) ∈ s
⊢ sSup (Subtype.val '' t) = ↑(sSup t)
state_after: no goals
tactic: simp [dif_pos, h, h', h'']
Theorem: List.mem_sublistsLen_self
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l l' : List α
h : l' <+ l
⊢ l' ∈ sublistsLen l'.length l
state_after: case slnil
α : Type u
β : Type v
γ : Type w
l l' : List α
⊢ [] ∈ sublistsLen [].length []

case cons
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ l₁ ∈ sublistsLen l₁.length (a :: l₂)

case cons₂
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ a :: l₁ ∈ sublistsLen (a :: l₁).length (a :: l₂)
tactic: induction' h with l₁ l₂ a s IH l₁ l₂ a s IH
Theorem: Set.IsPWO.mul
File: Mathlib/Data/Finset/MulAntidiagonal.lean

Proof steps:
state_before: α : Type u_1
s t : Set α
inst✝ : OrderedCancelCommMonoid α
hs : s.IsPWO
ht : t.IsPWO
⊢ (s * t).IsPWO
state_after: α : Type u_1
s t : Set α
inst✝ : OrderedCancelCommMonoid α
hs : s.IsPWO
ht : t.IsPWO
⊢ ((fun x => x.1 * x.2) '' s ×ˢ t).IsPWO
tactic: rw [← image_mul_prod]
state_before: α : Type u_1
s t : Set α
inst✝ : OrderedCancelCommMonoid α
hs : s.IsPWO
ht : t.IsPWO
⊢ ((fun x => x.1 * x.2) '' s ×ˢ t).IsPWO
state_after: no goals
tactic: exact (hs.prod ht).image_of_monotone (monotone_fst.mul' monotone_snd)
Theorem: Localization.AtPrime.nilpotent_iff_not_unit_of_minimal
File: Mathlib/RingTheory/Ideal/MinimalPrime.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
I : Ideal R
hI : I.IsPrime
hMin : I ∈ minimalPrimes R
x : Localization I.primeCompl
⊢ IsNilpotent x ↔ x ∈ nonunits (Localization I.primeCompl)
state_after: no goals
tactic: simpa only [← LocalRing.mem_maximalIdeal] using nilpotent_iff_mem_maximal_of_minimal hMin
Theorem: AddMonoid.le_minOrder
File: Mathlib/GroupTheory/Order/Min.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a : α
n : ℕ∞
⊢ n ≤ minOrder α ↔ ∀ ⦃a : α⦄, a ≠ 1 → IsOfFinOrder a → n ≤ ↑(orderOf a)
state_after: no goals
tactic: simp [minOrder]
Theorem: Finsupp.sum_antidiagonal_swap
File: Mathlib/Data/Finsupp/Antidiagonal.lean

Proof steps:
state_before: α : Type u
inst✝¹ : DecidableEq α
M : Type u_1
inst✝ : CommMonoid M
n : α →₀ ℕ
f : (α →₀ ℕ) → (α →₀ ℕ) → M
⊢ ∀ (i : (α →₀ ℕ) × (α →₀ ℕ)), i ∈ antidiagonal n ↔ (Equiv.prodComm (α →₀ ℕ) (α →₀ ℕ)) i ∈ antidiagonal n
state_after: no goals
tactic: simp [add_comm]
state_before: α : Type u
inst✝¹ : DecidableEq α
M : Type u_1
inst✝ : CommMonoid M
n : α →₀ ℕ
f : (α →₀ ℕ) → (α →₀ ℕ) → M
⊢ ∀ i ∈ antidiagonal n, f i.1 i.2 = f ((Equiv.prodComm (α →₀ ℕ) (α →₀ ℕ)) i).2 ((Equiv.prodComm (α →₀ ℕ) (α →₀ ℕ)) i).1
state_after: no goals
tactic: simp