ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SimpleGraph.not_isUniform_iff
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ ¬G.IsUniform ε s t ↔
    ∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity s t|
state_after: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ (¬∀ ⦃s' : Finset α⦄,
        s' ⊆ s →
          ∀ ⦃t' : Finset α⦄,
            t' ⊆ t →
              ↑s.card * ε ≤ ↑s'.card → ↑t.card * ε ≤ ↑t'.card → |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < ε) ↔
    ∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity s t|
tactic: unfold IsUniform
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ (¬∀ ⦃s' : Finset α⦄,
        s' ⊆ s →
          ∀ ⦃t' : Finset α⦄,
            t' ⊆ t →
              ↑s.card * ε ≤ ↑s'.card → ↑t.card * ε ≤ ↑t'.card → |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < ε) ↔
    ∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity s t|
state_after: no goals
tactic: simp only [not_forall, not_lt, exists_prop, exists_and_left, Rat.cast_abs, Rat.cast_sub]
Theorem: Set.sigma_eq_empty_iff
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
⊢ (¬∃ i ∈ s, (t i).Nonempty) ↔ ∀ i ∈ s, t i = ∅
state_after: no goals
tactic: simp only [not_nonempty_iff_eq_empty, not_and, not_exists]
Theorem: PowerSeries.exp_mul_exp_neg_eq_one
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ exp A * evalNegHom (exp A) = 1
state_after: no goals
tactic: convert exp_mul_exp_eq_exp_add (1 : A) (-1) <;> simp
Theorem: Real.Angle.cos_antiperiodic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: ⊢ Function.Antiperiodic cos ↑π
state_after: θ : Angle
⊢ (θ + ↑π).cos = -θ.cos
tactic: intro θ
state_before: θ : Angle
⊢ (θ + ↑π).cos = -θ.cos
state_after: case h
x✝ : ℝ
⊢ (↑x✝ + ↑π).cos = -(↑x✝).cos
tactic: induction θ using Real.Angle.induction_on
state_before: case h
x✝ : ℝ
⊢ (↑x✝ + ↑π).cos = -(↑x✝).cos
state_after: no goals
tactic: exact Real.cos_antiperiodic _
Theorem: CategoryTheory.Limits.Bicone.whisker_π
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (fun k => c.ι (g k)) k ≫ (fun k => c.π (g k)) k' = if h : k = k' then eqToHom ⋯ else 0
state_after: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (if h : g k = g k' then eqToHom ⋯ else 0) = if h : k = k' then eqToHom ⋯ else 0
tactic: simp only [c.ι_π]
state_before: J : Type w
C : Type uC
inst✝³ : Category.{uC', uC} C
inst✝² : HasZeroMorphisms C
D : Type uD
inst✝¹ : Category.{uD', uD} D
inst✝ : HasZeroMorphisms D
F : J → C
K : Type w'
f : J → C
c : Bicone f
g : K ≃ J
k k' : K
⊢ (if h : g k = g k' then eqToHom ⋯ else 0) = if h : k = k' then eqToHom ⋯ else 0
state_after: no goals
tactic: split_ifs with h h' h' <;> simp [Equiv.apply_eq_iff_eq g] at h h' <;> tauto
Theorem: Equiv.piCongrLeft_preimage_pi
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
f : ι' ≃ ι
s : Set ι'
t : (i : ι) → Set (α i)
⊢ ⇑(piCongrLeft α f) ⁻¹' (⇑f '' s).pi t = s.pi fun i => t (f i)
state_after: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
f : ι' ≃ ι
s : Set ι'
t : (i : ι) → Set (α i)
⊢ ∀ (x : (a : ι') → α (f a)), x ∈ ⇑(piCongrLeft α f) ⁻¹' (⇑f '' s).pi t ↔ x ∈ s.pi fun i => t (f i)
tactic: apply Set.ext
state_before: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
f : ι' ≃ ι
s : Set ι'
t : (i : ι) → Set (α i)
⊢ ∀ (x : (a : ι') → α (f a)), x ∈ ⇑(piCongrLeft α f) ⁻¹' (⇑f '' s).pi t ↔ x ∈ s.pi fun i => t (f i)
state_after: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
f : ι' ≃ ι
s : Set ι'
t : (i : ι) → Set (α i)
⊢ ∀ (a : (b : ι) → α b),
    (piCongrLeft α f).symm a ∈ ⇑(piCongrLeft α f) ⁻¹' (⇑f '' s).pi t ↔ (piCongrLeft α f).symm a ∈ s.pi fun i => t (f i)
tactic: rw [← (f.piCongrLeft α).symm.forall_congr_right]
state_before: case h
ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
f : ι' ≃ ι
s : Set ι'
t : (i : ι) → Set (α i)
⊢ ∀ (a : (b : ι) → α b),
    (piCongrLeft α f).symm a ∈ ⇑(piCongrLeft α f) ⁻¹' (⇑f '' s).pi t ↔ (piCongrLeft α f).symm a ∈ s.pi fun i => t (f i)
state_after: no goals
tactic: simp
Theorem: ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: s : ℂ
hs : 1 < s.re
⊢ L (fun n => ↑(Λ n)) s = -deriv riemannZeta s / riemannZeta s
state_after: s : ℂ
hs : 1 < s.re
⊢ deriv (L 1) s = deriv riemannZeta s
tactic: suffices deriv (L 1) s = deriv riemannZeta s by
    rw [LSeries_vonMangoldt_eq hs, ← LSeries_one_eq_riemannZeta hs, this]
state_before: s : ℂ
hs : 1 < s.re
⊢ deriv (L 1) s = deriv riemannZeta s
state_after: s : ℂ
hs : 1 < s.re
⊢ ∃ s_1 ∈ nhds s, Set.EqOn (L 1) riemannZeta s_1
tactic: refine Filter.EventuallyEq.deriv_eq <| Filter.eventuallyEq_iff_exists_mem.mpr ?_
state_before: s : ℂ
hs : 1 < s.re
⊢ ∃ s_1 ∈ nhds s, Set.EqOn (L 1) riemannZeta s_1
state_after: no goals
tactic: exact ⟨{z | 1 < z.re}, (isOpen_lt continuous_const continuous_re).mem_nhds hs,
    fun _ ↦ LSeries_one_eq_riemannZeta⟩
Theorem: Cardinal.mul_eq_left_iff
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
⊢ a * b = a ↔ max ℵ₀ b ≤ a ∧ b ≠ 0 ∨ b = 1 ∨ a = 0
state_after: a b : Cardinal.{u_1}
⊢ a * b = a ↔ (ℵ₀ ≤ a ∧ b ≤ a) ∧ b ≠ 0 ∨ b = 1 ∨ a = 0
tactic: rw [max_le_iff]
state_before: a b : Cardinal.{u_1}
⊢ a * b = a ↔ (ℵ₀ ≤ a ∧ b ≤ a) ∧ b ≠ 0 ∨ b = 1 ∨ a = 0
state_after: case refine_1
a b : Cardinal.{u_1}
h : a * b = a
⊢ (ℵ₀ ≤ a ∧ b ≤ a) ∧ b ≠ 0 ∨ b = 1 ∨ a = 0

case refine_2
a b : Cardinal.{u_1}
⊢ (ℵ₀ ≤ a ∧ b ≤ a) ∧ b ≠ 0 ∨ b = 1 ∨ a = 0 → a * b = a
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: GenContFract.fib_le_of_contsAux_b
File: Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean

Proof steps:
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
⊢ ∀ (n : ℕ),
    (∀ m < n, m ≤ 1 ∨ ¬(of v).TerminatedAt (m - 2) → ↑(fib m) ≤ ((of v).contsAux m).b) →
      n ≤ 1 ∨ ¬(of v).TerminatedAt (n - 2) → ↑(fib n) ≤ ((of v).contsAux n).b
state_after: K : Type u_1
v : K
n✝ : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
n : ℕ
IH : ∀ m < n, m ≤ 1 ∨ ¬(of v).TerminatedAt (m - 2) → ↑(fib m) ≤ ((of v).contsAux m).b
hyp : n ≤ 1 ∨ ¬(of v).TerminatedAt (n - 2)
⊢ ↑(fib n) ≤ ((of v).contsAux n).b
tactic: intro n IH hyp
state_before: K : Type u_1
v : K
n✝ : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
n : ℕ
IH : ∀ m < n, m ≤ 1 ∨ ¬(of v).TerminatedAt (m - 2) → ↑(fib m) ≤ ((of v).contsAux m).b
hyp : n ≤ 1 ∨ ¬(of v).TerminatedAt (n - 2)
⊢ ↑(fib n) ≤ ((of v).contsAux n).b
state_after: case zero
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
IH : ∀ m < 0, m ≤ 1 ∨ ¬(of v).TerminatedAt (m - 2) → ↑(fib m) ≤ ((of v).contsAux m).b
hyp : 0 ≤ 1 ∨ ¬(of v).TerminatedAt (0 - 2)
⊢ ↑(fib 0) ≤ ((of v).contsAux 0).b

case succ.zero
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
IH : ∀ m < 0 + 1, m ≤ 1 ∨ ¬(of v).TerminatedAt (m - 2) → ↑(fib m) ≤ ((of v).contsAux m).b
hyp : 0 + 1 ≤ 1 ∨ ¬(of v).TerminatedAt (0 + 1 - 2)
⊢ ↑(fib (0 + 1)) ≤ ((of v).contsAux (0 + 1)).b

case succ.succ
K : Type u_1
v : K
n✝ : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
n : ℕ
IH : ∀ m < n + 1 + 1, m ≤ 1 ∨ ¬(of v).TerminatedAt (m - 2) → ↑(fib m) ≤ ((of v).contsAux m).b
hyp : n + 1 + 1 ≤ 1 ∨ ¬(of v).TerminatedAt (n + 1 + 1 - 2)
⊢ ↑(fib (n + 1 + 1)) ≤ ((of v).contsAux (n + 1 + 1)).b
tactic: rcases n with (_ | _ | n)
Theorem: AlgebraicGeometry.StructureSheaf.to_global_factors
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫ toBasicOpen R 1 ≫ (structureSheaf R).val.map (eqToHom ⋯).op
state_after: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    (CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫ toBasicOpen R 1) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op
tactic: rw [← Category.assoc]
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    (CommRingCat.ofHom (algebraMap R (Localization.Away 1)) ≫ toBasicOpen R 1) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op
state_after: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom ((toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op
tactic: change toOpen R ⊤ =
    (CommRingCat.ofHom <| (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
    (structureSheaf R).1.map (eqToHom _).op
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ =
    CommRingCat.ofHom ((toBasicOpen R 1).comp (algebraMap R (Localization.Away 1))) ≫
      (structureSheaf R).val.map (eqToHom ⋯).op
state_after: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ = (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1)) ≫ (structureSheaf R).val.map (eqToHom ⋯).op
tactic: unfold CommRingCat.ofHom
state_before: R : Type u
inst✝ : CommRing R
⊢ toOpen R ⊤ = (toBasicOpen R 1).comp (algebraMap R (Localization.Away 1)) ≫ (structureSheaf R).val.map (eqToHom ⋯).op
state_after: no goals
tactic: rw [localization_toBasicOpen R, toOpen_res]
Theorem: Mathlib.Tactic.Ring.mul_add
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ d : R
x✝² : a * b₁ = c₁
x✝¹ : a * b₂ = c₂
x✝ : c₁ + 0 + c₂ = d
⊢ a * (b₁ + b₂) = d
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c : R
⊢ a * (b₁ + b₂) = a * b₁ + 0 + a * b₂
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R : Type u_1
inst✝ : CommSemiring R
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c : R
⊢ a * (b₁ + b₂) = a * b₁ + 0 + a * b₂
state_after: no goals
tactic: simp [_root_.mul_add]
Theorem: MeasureTheory.VectorMeasure.MutuallySingular.smul_right
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁸ : AddCommMonoid L
inst✝⁷ : TopologicalSpace L
inst✝⁶ : AddCommMonoid M
inst✝⁵ : TopologicalSpace M
inst✝⁴ : AddCommMonoid N
inst✝³ : TopologicalSpace N
v v₁ v₂ : VectorMeasure α M
w w₁ w₂ : VectorMeasure α N
R : Type u_6
inst✝² : Semiring R
inst✝¹ : DistribMulAction R N
inst✝ : ContinuousConstSMul R N
r : R
h : v ⟂ᵥ w
s : Set α
hmeas : MeasurableSet s
hs₁ : ∀ t ⊆ s, ↑v t = 0
hs₂ : ∀ t ⊆ sᶜ, ↑w t = 0
t : Set α
ht : t ⊆ sᶜ
⊢ ↑(r • w) t = 0
state_after: no goals
tactic: simp only [coe_smul, Pi.smul_apply, hs₂ t ht, smul_zero]
Theorem: CategoryTheory.FunctorToTypes.coprod.desc_app
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F₁ ⟶ F
τ₂ : F₂ ⟶ F
a : C
x : (coprod F₁ F₂).obj a
⊢ F.obj a
state_after: no goals
tactic: cases x with
     | inl x => exact τ₁.app a x
     | inr x => exact τ₂.app a x
state_before: C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F₁ ⟶ F
τ₂ : F₂ ⟶ F
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
⊢ (coprod F₁ F₂).map x✝ ≫
      (fun a x =>
          Sum.casesOn (motive := fun t => x = t → F.obj a) x (fun x_1 h => τ₁.app a x_1) (fun x_1 h => τ₂.app a x_1) ⋯)
        x✝¹ =
    (fun a x =>
          Sum.casesOn (motive := fun t => x = t → F.obj a) x (fun x_1 h => τ₁.app a x_1) (fun x_1 h => τ₂.app a x_1) ⋯)
        x✝² ≫
      F.map x✝
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F₁ ⟶ F
τ₂ : F₂ ⟶ F
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
x : (coprod F₁ F₂).obj x✝²
⊢ ((coprod F₁ F₂).map x✝ ≫
        (fun a x =>
            Sum.casesOn (motive := fun t => x = t → F.obj a) x (fun x_1 h => τ₁.app a x_1) (fun x_1 h => τ₂.app a x_1)
              ⋯)
          x✝¹)
      x =
    ((fun a x =>
            Sum.casesOn (motive := fun t => x = t → F.obj a) x (fun x_1 h => τ₁.app a x_1) (fun x_1 h => τ₂.app a x_1)
              ⋯)
          x✝² ≫
        F.map x✝)
      x
tactic: ext x
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
F G F₁ F₂ : C ⥤ Type w
τ₁ : F₁ ⟶ F
τ₂ : F₂ ⟶ F
x✝² x✝¹ : C
x✝ : x✝² ⟶ x✝¹
x : (coprod F₁ F₂).obj x✝²
⊢ ((coprod F₁ F₂).map x✝ ≫
        (fun a x =>
            Sum.casesOn (motive := fun t => x = t → F.obj a) x (fun x_1 h => τ₁.app a x_1) (fun x_1 h => τ₂.app a x_1)
              ⋯)
          x✝¹)
      x =
    ((fun a x =>
            Sum.casesOn (motive := fun t => x = t → F.obj a) x (fun x_1 h => τ₁.app a x_1) (fun x_1 h => τ₂.app a x_1)
              ⋯)
          x✝² ≫
        F.map x✝)
      x
state_after: no goals
tactic: cases x with | _ => simp only [coprod, types_comp_apply, FunctorToTypes.naturality]
Theorem: Nat.twoPowSum_bitIndices
File: Mathlib/Data/Nat/BitIndices.lean

Proof steps:
state_before: a n✝ n : ℕ
⊢ (map (fun i => 2 ^ i) n.bitIndices).sum = n
state_after: case z
a n : ℕ
⊢ (map (fun i => 2 ^ i) (bitIndices 0)).sum = 0

case f
a n✝ : ℕ
b : Bool
n : ℕ
hs : (map (fun i => 2 ^ i) n.bitIndices).sum = n
⊢ (map (fun i => 2 ^ i) (bit b n).bitIndices).sum = bit b n
tactic: induction' n using binaryRec with b n hs
state_before: case f
a n✝ : ℕ
b : Bool
n : ℕ
hs : (map (fun i => 2 ^ i) n.bitIndices).sum = n
⊢ (map (fun i => 2 ^ i) (bit b n).bitIndices).sum = bit b n
state_after: case f
a n✝ : ℕ
b : Bool
n : ℕ
hs : (map (fun i => 2 ^ i) n.bitIndices).sum = n
hrw : ((fun i => 2 ^ i) ∘ fun x => x + 1) = fun i => 2 * 2 ^ i
⊢ (map (fun i => 2 ^ i) (bit b n).bitIndices).sum = bit b n
tactic: have hrw : (fun i ↦ 2^i) ∘ (fun x ↦ x+1) = fun i ↦ 2 * 2 ^ i := by
    ext i; simp [pow_add, mul_comm]
state_before: case f
a n✝ : ℕ
b : Bool
n : ℕ
hs : (map (fun i => 2 ^ i) n.bitIndices).sum = n
hrw : ((fun i => 2 ^ i) ∘ fun x => x + 1) = fun i => 2 * 2 ^ i
⊢ (map (fun i => 2 ^ i) (bit b n).bitIndices).sum = bit b n
state_after: case f.false
a n✝ n : ℕ
hs : (map (fun i => 2 ^ i) n.bitIndices).sum = n
hrw : ((fun i => 2 ^ i) ∘ fun x => x + 1) = fun i => 2 * 2 ^ i
⊢ (map (fun i => 2 ^ i) (bit false n).bitIndices).sum = bit false n

case f.true
a n✝ n : ℕ
hs : (map (fun i => 2 ^ i) n.bitIndices).sum = n
hrw : ((fun i => 2 ^ i) ∘ fun x => x + 1) = fun i => 2 * 2 ^ i
⊢ (map (fun i => 2 ^ i) (bit true n).bitIndices).sum = bit true n
tactic: cases b
state_before: case f.true
a n✝ n : ℕ
hs : (map (fun i => 2 ^ i) n.bitIndices).sum = n
hrw : ((fun i => 2 ^ i) ∘ fun x => x + 1) = fun i => 2 * 2 ^ i
⊢ (map (fun i => 2 ^ i) (bit true n).bitIndices).sum = bit true n
state_after: no goals
tactic: simp [hrw, List.sum_map_mul_left, hs, add_comm (a := 1)]
Theorem: Cubic.eq_sum_three_roots
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ map φ P = { a := φ P.a, b := φ P.a * -(x + y + z), c := φ P.a * (x * y + x * z + y * z), d := φ P.a * -(x * y * z) }
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ (map φ P).toPoly =
    { a := φ P.a, b := φ P.a * -(x + y + z), c := φ P.a * (x * y + x * z + y * z), d := φ P.a * -(x * y * z) }.toPoly

case inj
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic F
inst✝¹ : Field F
inst✝ : Field K
φ : F →+* K
x y z : K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
⊢ Function.Injective toPoly
tactic: apply_fun @toPoly _ _
Theorem: dvd_sub
File: Mathlib/Algebra/Ring/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NonUnitalRing α
a b c : α
h₁ : a ∣ b
h₂ : a ∣ c
⊢ a ∣ b - c
state_after: no goals
tactic: simpa only [← sub_eq_add_neg] using h₁.add h₂.neg_right
Theorem: Ideal.quotientToQuotientRangePowQuotSuccAux_mk
File: Mathlib/NumberTheory/RamificationInertia.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
a : S
a_mem : a ∈ P ^ i
x : S
⊢ quotientToQuotientRangePowQuotSuccAux f p P a_mem (Submodule.Quotient.mk x) =
    Submodule.Quotient.mk ⟨(Quotient.mk (P ^ e)) (a * x), ⋯⟩
state_after: no goals
tactic: apply Quotient.map'_mk''
Theorem: _private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.add_le_add'
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
⊢ ∀ {a b c d : Cardinal.{u_1}}, a ≤ b → c ≤ d → a + c ≤ b + d
state_after: case mk.mk.mk.mk.intro.intro
α✝ β✝ : Type u
a✝ : Cardinal.{u_1}
α : Type u_1
b✝ : Cardinal.{u_1}
β : Type u_1
c✝ : Cardinal.{u_1}
γ : Type u_1
d✝ : Cardinal.{u_1}
δ : Type u_1
e₁ : α ↪ β
e₂ : γ ↪ δ
⊢ Quot.mk Setoid.r α + Quot.mk Setoid.r γ ≤ Quot.mk Setoid.r β + Quot.mk Setoid.r δ
tactic: rintro ⟨α⟩ ⟨β⟩ ⟨γ⟩ ⟨δ⟩ ⟨e₁⟩ ⟨e₂⟩
state_before: case mk.mk.mk.mk.intro.intro
α✝ β✝ : Type u
a✝ : Cardinal.{u_1}
α : Type u_1
b✝ : Cardinal.{u_1}
β : Type u_1
c✝ : Cardinal.{u_1}
γ : Type u_1
d✝ : Cardinal.{u_1}
δ : Type u_1
e₁ : α ↪ β
e₂ : γ ↪ δ
⊢ Quot.mk Setoid.r α + Quot.mk Setoid.r γ ≤ Quot.mk Setoid.r β + Quot.mk Setoid.r δ
state_after: no goals
tactic: exact ⟨e₁.sumMap e₂⟩
Theorem: MeasurableSpace.generateFrom_singleton_univ
File: Mathlib/MeasureTheory/MeasurableSpace/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s t u : Set α
⊢ ∀ t ∈ {univ}, MeasurableSet t
state_after: no goals
tactic: simp
Theorem: finsum_mem_sUnion
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : t.PairwiseDisjoint id
ht₀ : t.Finite
ht₁ : ∀ x ∈ t, x.Finite
⊢ ∏ᶠ (a : α) (_ : a ∈ ⋃₀ t), f a = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : t.PairwiseDisjoint id
ht₀ : t.Finite
ht₁ : ∀ x ∈ t, x.Finite
⊢ ∏ᶠ (a : α) (_ : a ∈ ⋃ i ∈ t, i), f a = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a
tactic: rw [Set.sUnion_eq_biUnion]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t✝ : Set α
t : Set (Set α)
h : t.PairwiseDisjoint id
ht₀ : t.Finite
ht₁ : ∀ x ∈ t, x.Finite
⊢ ∏ᶠ (a : α) (_ : a ∈ ⋃ i ∈ t, i), f a = ∏ᶠ (s : Set α) (_ : s ∈ t) (a : α) (_ : a ∈ s), f a
state_after: no goals
tactic: exact finprod_mem_biUnion h ht₀ ht₁
Theorem: PNat.gcd_eq_left
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: m n : ℕ+
⊢ m ∣ n → m.gcd n = m
state_after: m n : ℕ+
⊢ ↑m ∣ ↑n → m.gcd n = m
tactic: rw [dvd_iff]
state_before: m n : ℕ+
⊢ ↑m ∣ ↑n → m.gcd n = m
state_after: m n : ℕ+
h : ↑m ∣ ↑n
⊢ m.gcd n = m
tactic: intro h
state_before: m n : ℕ+
h : ↑m ∣ ↑n
⊢ m.gcd n = m
state_after: case a
m n : ℕ+
h : ↑m ∣ ↑n
⊢ ↑(m.gcd n) = ↑m
tactic: apply eq
state_before: case a
m n : ℕ+
h : ↑m ∣ ↑n
⊢ ↑(m.gcd n) = ↑m
state_after: case a
m n : ℕ+
h : ↑m ∣ ↑n
⊢ (↑m).gcd ↑n = ↑m
tactic: simp only [gcd_coe]
state_before: case a
m n : ℕ+
h : ↑m ∣ ↑n
⊢ (↑m).gcd ↑n = ↑m
state_after: no goals
tactic: apply Nat.gcd_eq_left h
Theorem: Stream'.Seq.ge_stable
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
aₙ : α
n m : ℕ
m_le_n : m ≤ n
s_nth_eq_some : s.get? n = some aₙ
⊢ s.get? n ≠ none
state_after: no goals
tactic: simp [s_nth_eq_some]
Theorem: WithBot.le_coe_iff
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b✝ : α
inst✝ : LE α
b : α
⊢ ↑b ≤ ↑b✝ ↔ ∀ (a : α), ↑b = ↑a → a ≤ b✝
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
⊢ ⊥ ≤ ↑b ↔ ∀ (a : α), ⊥ = ↑a → a ≤ b
state_after: no goals
tactic: simp
Theorem: HomologicalComplex.unopFunctor_map_f
File: Mathlib/Algebra/Homology/Opposite.lean

Proof steps:
state_before: ι : Type u_1
V : Type u_2
inst✝¹ : Category.{?u.46156, u_2} V
c : ComplexShape ι
inst✝ : HasZeroMorphisms V
X✝ Y✝ : (HomologicalComplex Vᵒᵖ c)ᵒᵖ
f : X✝ ⟶ Y✝
i j : ι
x✝ : c.symm.Rel i j
⊢ (fun i => (f.unop.f i).unop) i ≫ ((fun X => (unop X).unop) Y✝).d i j =
    ((fun X => (unop X).unop) X✝).d i j ≫ (fun i => (f.unop.f i).unop) j
state_after: no goals
tactic: simp only [unop_d, ← unop_comp, f.unop.comm]
Theorem: bernoulliFun_eval_one
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: k : ℕ
⊢ bernoulliFun k 1 = bernoulliFun k 0 + if k = 1 then 1 else 0
state_after: k : ℕ
⊢ (algebraMap ℚ ℝ) (bernoulli' k) = ↑(bernoulli k) + if k = 1 then 1 else 0
tactic: rw [bernoulliFun, bernoulliFun_eval_zero, Polynomial.eval_one_map, Polynomial.bernoulli_eval_one]
state_before: k : ℕ
⊢ (algebraMap ℚ ℝ) (bernoulli' k) = ↑(bernoulli k) + if k = 1 then 1 else 0
state_after: case pos
k : ℕ
h : k = 1
⊢ (algebraMap ℚ ℝ) (bernoulli' k) = ↑(bernoulli k) + 1

case neg
k : ℕ
h : ¬k = 1
⊢ (algebraMap ℚ ℝ) (bernoulli' k) = ↑(bernoulli k) + 0
tactic: split_ifs with h