ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finsupp.update_erase_eq_update
File: Mathlib/Data/Finsupp/Defs.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
f : α →₀ M
a : α
b : M
⊢ (erase a f).update a b = f.update a b
state_after: no goals
tactic: rw [erase_eq_update_zero, update_idem]
Theorem: MeasureTheory.stoppedValue_piecewise_const
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
⊢ stoppedValue f (s.piecewise (fun x => i) fun x => j) = s.piecewise (f i) (f j)
state_after: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ stoppedValue f (s.piecewise (fun x => i) fun x => j) ω = s.piecewise (f i) (f j) ω
tactic: ext ω
state_before: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ stoppedValue f (s.piecewise (fun x => i) fun x => j) ω = s.piecewise (f i) (f j) ω
state_after: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ f (s.piecewise (fun x => i) (fun x => j) ω) ω = s.piecewise (f i) (f j) ω
tactic: rw [stoppedValue]
state_before: case h
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝¹ : Preorder ι
𝒢 : Filtration ι m
τ η : Ω → ι
i✝ j✝ : ι
s : Set Ω
inst✝ : DecidablePred fun x => x ∈ s
ι' : Type u_4
i j : ι'
f : ι' → Ω → ℝ
ω : Ω
⊢ f (s.piecewise (fun x => i) (fun x => j) ω) ω = s.piecewise (f i) (f j) ω
state_after: no goals
tactic: by_cases hx : ω ∈ s <;> simp [hx]
Theorem: Ordinal.nadd_le_iff
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c : Ordinal.{u}
⊢ b ♯ c ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a
state_after: a b c : Ordinal.{u}
⊢ max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a
tactic: rw [nadd_def]
state_before: a b c : Ordinal.{u}
⊢ max (b.blsub fun a' x => a' ♯ c) (c.blsub fun b' x => b ♯ b') ≤ a ↔ (∀ b' < b, b' ♯ c < a) ∧ ∀ c' < c, b ♯ c' < a
state_after: no goals
tactic: simp [blsub_le_iff]
Theorem: LinearMap.disjoint_ker
File: Mathlib/Algebra/Module/Submodule/Ker.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
K : Type u_5
M : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₃ : Type u_9
V : Type u_10
V₂ : Type u_11
inst✝¹² : Semiring R
inst✝¹¹ : Semiring R₂
inst✝¹⁰ : Semiring R₃
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁶ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁵ : Module R M
inst✝⁴ : Module R₂ M₂
inst✝³ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_12
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : F
p : Submodule R M
⊢ Disjoint p (ker f) ↔ ∀ x ∈ p, f x = 0 → x = 0
state_after: no goals
tactic: simp [disjoint_def]
Theorem: Set.mulIndicator_apply_ne_one
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a✝ a : α
⊢ s.mulIndicator f a ≠ 1 ↔ a ∈ s ∩ mulSupport f
state_after: no goals
tactic: simp only [Ne, mulIndicator_apply_eq_one, Classical.not_imp, mem_inter_iff, mem_mulSupport]
Theorem: measurable_findGreatest
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ k ≤ N, MeasurableSet {x | p x k}
⊢ Measurable fun x => Nat.findGreatest (p x) N
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ k ≤ N, MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
⊢ MeasurableSet {x | Nat.findGreatest (p x) N = k}
tactic: refine measurable_findGreatest' fun k hk => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ k ≤ N, MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
⊢ MeasurableSet {x | Nat.findGreatest (p x) N = k}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ k ≤ N, MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
⊢ MeasurableSet ({a | k ≤ N} ∩ ((⋂ (_ : k ≠ 0), {x | p x k}) ∩ ⋂ i, ⋂ (_ : k < i), ⋂ (_ : i ≤ N), {a | p a i}ᶜ))
tactic: simp only [Nat.findGreatest_eq_iff, setOf_and, setOf_forall, ← compl_setOf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α
inst✝¹ : MeasurableSpace α
p : α → ℕ → Prop
inst✝ : (x : α) → DecidablePred (p x)
N : ℕ
hN : ∀ k ≤ N, MeasurableSet {x | p x k}
k : ℕ
hk : k ≤ N
⊢ MeasurableSet ({a | k ≤ N} ∩ ((⋂ (_ : k ≠ 0), {x | p x k}) ∩ ⋂ i, ⋂ (_ : k < i), ⋂ (_ : i ≤ N), {a | p a i}ᶜ))
state_after: no goals
tactic: repeat' apply_rules [MeasurableSet.inter, MeasurableSet.const, MeasurableSet.iInter,
    MeasurableSet.compl, hN] <;> try intros
Theorem: Fin.cycleRange_of_gt
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
i j : Fin n.succ
h : i < j
⊢ i.cycleRange j = j
state_after: case h
n : ℕ
i j : Fin n.succ
h : i < j
⊢ j ∉ Set.range ⇑(castLEEmb ⋯)
tactic: rw [cycleRange, ofLeftInverse'_eq_ofInjective,
    ← Function.Embedding.toEquivRange_eq_ofInjective, ← viaFintypeEmbedding,
    viaFintypeEmbedding_apply_not_mem_range]
state_before: case h
n : ℕ
i j : Fin n.succ
h : i < j
⊢ j ∉ Set.range ⇑(castLEEmb ⋯)
state_after: no goals
tactic: simpa
Theorem: Mathlib.Tactic.ComputeDegree.coeff_sub_of_eq
File: Mathlib/Tactic/ComputeDegree.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
n : ℕ
a b : R
f g : R[X]
hf : f.coeff n = a
hg : g.coeff n = b
⊢ (f - g).coeff n = a - b
state_after: R : Type u_1
inst✝ : Ring R
n : ℕ
f g : R[X]
⊢ (f - g).coeff n = f.coeff n - g.coeff n
tactic: subst hf hg
state_before: R : Type u_1
inst✝ : Ring R
n : ℕ
f g : R[X]
⊢ (f - g).coeff n = f.coeff n - g.coeff n
state_after: no goals
tactic: apply coeff_sub
Theorem: FreeMagma.lift_symm_apply
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Mul β
f : α → β
F : FreeMagma α →ₙ* β
⊢ (fun f => { toFun := liftAux f, map_mul' := ⋯ }) ((fun F => ⇑F ∘ of) F) = F
state_after: case h.h
α : Type u
β : Type v
inst✝ : Mul β
f : α → β
F : FreeMagma α →ₙ* β
x✝ : α
⊢ (⇑((fun f => { toFun := liftAux f, map_mul' := ⋯ }) ((fun F => ⇑F ∘ of) F)) ∘ of) x✝ = (⇑F ∘ of) x✝
tactic: ext
state_before: case h.h
α : Type u
β : Type v
inst✝ : Mul β
f : α → β
F : FreeMagma α →ₙ* β
x✝ : α
⊢ (⇑((fun f => { toFun := liftAux f, map_mul' := ⋯ }) ((fun F => ⇑F ∘ of) F)) ∘ of) x✝ = (⇑F ∘ of) x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Subgroupoid.generated_le_generatedNormal
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
X : (c d : C) → Set (c ⟶ d)
⊢ generated X ≤ generatedNormal X
state_after: case h
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
X : (c d : C) → Set (c ⟶ d)
⊢ {S | (∀ (c d : C), X c d ⊆ S.arrows c d) ∧ S.IsNormal} ⊆ {S | ∀ (c d : C), X c d ⊆ S.arrows c d}
tactic: apply @sInf_le_sInf (Subgroupoid C) _
state_before: case h
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
X : (c d : C) → Set (c ⟶ d)
⊢ {S | (∀ (c d : C), X c d ⊆ S.arrows c d) ∧ S.IsNormal} ⊆ {S | ∀ (c d : C), X c d ⊆ S.arrows c d}
state_after: no goals
tactic: exact fun S ⟨h, _⟩ => h
Theorem: CategoryTheory.sheafifyMap_id
File: Mathlib/CategoryTheory/Sites/Sheafification.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : GrothendieckTopology C
A : Type u₂
inst✝² : Category.{v₂, u₂} A
D : Type u_1
inst✝¹ : Category.{u_2, u_1} D
inst✝ : HasWeakSheafify J D
P : Cᵒᵖ ⥤ D
⊢ sheafifyMap J (𝟙 P) = 𝟙 (sheafify J P)
state_after: no goals
tactic: simp [sheafifyMap, sheafify]
Theorem: one_div_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ 1 / a < b ↔ 1 / b < a
state_after: no goals
tactic: simpa using inv_lt ha hb
Theorem: Dual.apply_one_mul_eq
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : Dual R R
r : R
⊢ f 1 * r = f r
state_after: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : Dual R R
r : R
⊢ f 1 * r = f (r • 1)
tactic: conv_rhs => rw [← mul_one r, ← smul_eq_mul]
state_before: R : Type u
inst✝⁴ : CommSemiring R
M₁ : Type v
M₂ : Type v'
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : Dual R R
r : R
⊢ f 1 * r = f (r • 1)
state_after: no goals
tactic: rw [map_smul, smul_eq_mul, mul_comm]
Theorem: Equiv.piCongrLeft_sum_inr
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: β : Sort ?u.114339
α : Sort ?u.114344
P : β → Sort w
e✝ : α ≃ β
ι'' : Sort u_2
ι : Type u_3
ι' : Type u_4
π : ι'' → Type u_1
e : ι ⊕ ι' ≃ ι''
f : (i : ι) → π (e (inl i))
g : (i : ι') → π (e (inr i))
j : ι'
⊢ (piCongrLeft π e) ((sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (inr j)) = g j
state_after: no goals
tactic: simp_rw [piCongrLeft_apply_eq_cast, sumPiEquivProdPi_symm_apply,
    sum_rec_congr _ _ _ (e.symm_apply_apply (inr j)), cast_cast, cast_eq]
Theorem: FinBoolAlg.Iso.mk_hom_toLatticeHom_toSupHom_toFun
File: Mathlib/Order/Category/FinBoolAlg.lean

Proof steps:
state_before: α β : FinBoolAlg
e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
      let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) =
    𝟙 α
state_after: case w
α β : FinBoolAlg
e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg
x✝ : (forget FinBoolAlg).obj α
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 α) x✝
tactic: ext
state_before: case w
α β : FinBoolAlg
e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg
x✝ : (forget FinBoolAlg).obj α
⊢ ((let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : FinBoolAlg
e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
      let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
      { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) =
    𝟙 β
state_after: case w
α β : FinBoolAlg
e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg
x✝ : (forget FinBoolAlg).obj β
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 β) x✝
tactic: ext
state_before: case w
α β : FinBoolAlg
e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg
x✝ : (forget FinBoolAlg).obj β
⊢ ((let __src := { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }) ≫
        let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
        { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
      x✝ =
    (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: LieHom.quotKerEquivRange_invFun
File: Mathlib/Algebra/Lie/Quotient.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
⊢ ∀ {x y : L ⧸ f.ker},
    { toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅x, y⁆ =
      ⁅{ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun x,
        { toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun y⁆
state_after: case mk.mk
R : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
x✝ : L ⧸ f.ker
x : L
y✝ : L ⧸ f.ker
y : L
⊢ { toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅Quot.mk Setoid.r x, Quot.mk Setoid.r y⁆ =
    ⁅{ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r x),
      { toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r y)⁆
tactic: rintro ⟨x⟩ ⟨y⟩
state_before: case mk.mk
R : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
x✝ : L ⧸ f.ker
x : L
y✝ : L ⧸ f.ker
y : L
⊢ { toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun ⁅Quot.mk Setoid.r x, Quot.mk Setoid.r y⁆ =
    ⁅{ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r x),
      { toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r y)⁆
state_after: case mk.mk
R : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
x✝ : L ⧸ f.ker
x : L
y✝ : L ⧸ f.ker
y : L
⊢ ↑({ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun
        ⁅Quot.mk Setoid.r x, Quot.mk Setoid.r y⁆) =
    ⁅↑({ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r x)),
      ↑({ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r y))⁆
tactic: rw [← SetLike.coe_eq_coe, LieSubalgebra.coe_bracket]
state_before: case mk.mk
R : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
x✝ : L ⧸ f.ker
x : L
y✝ : L ⧸ f.ker
y : L
⊢ ↑({ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun
        ⁅Quot.mk Setoid.r x, Quot.mk Setoid.r y⁆) =
    ⁅↑({ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r x)),
      ↑({ toFun := ⇑(↑f).quotKerEquivRange, map_add' := ⋯, map_smul' := ⋯ }.toFun (Quot.mk Setoid.r y))⁆
state_after: no goals
tactic: simp only [Submodule.Quotient.quot_mk_eq_mk, LinearMap.quotKerEquivRange_apply_mk, ←
        LieSubmodule.Quotient.mk_bracket, coe_toLinearMap, map_lie]
Theorem: Subalgebra.rank_top
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝¹⁰ : Ring R
inst✝⁹ : CommRing S
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M'
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R M₁
F : Type u_2
E : Type u_3
inst✝² : CommRing F
inst✝¹ : Ring E
inst✝ : Algebra F E
⊢ Module.rank F ↥⊤ = Module.rank F E
state_after: no goals
tactic: exact _root_.rank_top F E
Theorem: BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J✝ : Box ι
i : ι
x : ℝ
I J Js : Box ι
s : Finset (ι × ℝ)
H : ∀ (i : ι), {(i, J.lower i), (i, J.upper i)} ⊆ s
HJs : Js ∈ splitMany I s
Hn : ¬Disjoint ↑J ↑Js
⊢ Js ≤ J
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J✝ : Box ι
i : ι
x : ℝ
I J Js : Box ι
s : Finset (ι × ℝ)
HJs : Js ∈ splitMany I s
Hn : ¬Disjoint ↑J ↑Js
H : ∀ (i : ι), (i, J.lower i) ∈ s ∧ (i, J.upper i) ∈ s
⊢ Js ≤ J
tactic: simp only [Finset.insert_subset_iff, Finset.singleton_subset_iff] at H
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J✝ : Box ι
i : ι
x : ℝ
I J Js : Box ι
s : Finset (ι × ℝ)
HJs : Js ∈ splitMany I s
Hn : ¬Disjoint ↑J ↑Js
H : ∀ (i : ι), (i, J.lower i) ∈ s ∧ (i, J.upper i) ∈ s
⊢ Js ≤ J
state_after: case intro.intro
ι : Type u_1
M : Type u_2
n : ℕ
I✝ J✝ : Box ι
i : ι
x✝ : ℝ
I J Js : Box ι
s : Finset (ι × ℝ)
HJs : Js ∈ splitMany I s
Hn : ¬Disjoint ↑J ↑Js
H : ∀ (i : ι), (i, J.lower i) ∈ s ∧ (i, J.upper i) ∈ s
x : ι → ℝ
hx : x ∈ ↑J
hxs : x ∈ ↑Js
⊢ Js ≤ J
tactic: rcases Box.not_disjoint_coe_iff_nonempty_inter.mp Hn with ⟨x, hx, hxs⟩
state_before: case intro.intro
ι : Type u_1
M : Type u_2
n : ℕ
I✝ J✝ : Box ι
i : ι
x✝ : ℝ
I J Js : Box ι
s : Finset (ι × ℝ)
HJs : Js ∈ splitMany I s
Hn : ¬Disjoint ↑J ↑Js
H : ∀ (i : ι), (i, J.lower i) ∈ s ∧ (i, J.upper i) ∈ s
x : ι → ℝ
hx : x ∈ ↑J
hxs : x ∈ ↑Js
⊢ Js ≤ J
state_after: case intro.intro.refine_1
ι : Type u_1
M : Type u_2
n : ℕ
I✝ J✝ : Box ι
i✝ : ι
x✝ : ℝ
I J Js : Box ι
s : Finset (ι × ℝ)
HJs : Js ∈ splitMany I s
Hn : ¬Disjoint ↑J ↑Js
H : ∀ (i : ι), (i, J.lower i) ∈ s ∧ (i, J.upper i) ∈ s
x : ι → ℝ
hx : x ∈ ↑J
hxs : x ∈ ↑Js
y : ι → ℝ
hy : y ∈ Js
i : ι
⊢ J.lower i < y i

case intro.intro.refine_2
ι : Type u_1
M : Type u_2
n : ℕ
I✝ J✝ : Box ι
i✝ : ι
x✝ : ℝ
I J Js : Box ι
s : Finset (ι × ℝ)
HJs : Js ∈ splitMany I s
Hn : ¬Disjoint ↑J ↑Js
H : ∀ (i : ι), (i, J.lower i) ∈ s ∧ (i, J.upper i) ∈ s
x : ι → ℝ
hx : x ∈ ↑J
hxs : x ∈ ↑Js
y : ι → ℝ
hy : y ∈ Js
i : ι
⊢ y i ≤ J.upper i
tactic: refine fun y hy i => ⟨?_, ?_⟩
Theorem: Polynomial.coeff_monomial_mul
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q r✝ p : R[X]
n d : ℕ
r : R
⊢ ((monomial n) r * p).coeff (d + n) = r * p.coeff d
state_after: no goals
tactic: rw [← C_mul_X_pow_eq_monomial, mul_assoc, coeff_C_mul, X_pow_mul, coeff_mul_X_pow]
Theorem: Mathlib.Meta.NormNum.IsRat.to_isInt
File: Mathlib/Tactic/NormNum/Result.lean

Proof steps:
state_before: α✝ : Type u
u : Level
α : Type u_1
inst✝ : Ring α
num✝ : ℤ
inv : Invertible ↑1
this : Invertible 1
⊢ ↑num✝ * ⅟↑1 = ↑num✝
state_after: no goals
tactic: simp
Theorem: MeasureTheory.extend_union
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

Proof steps:
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)
mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
hd : Disjoint s₁ s₂
h₁ : P s₁
h₂ : P s₂
⊢ extend m (s₁ ∪ s₂) = extend m s₁ + extend m s₂
state_after: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)
mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
hd : Disjoint s₁ s₂
h₁ : P s₁
h₂ : P s₂
⊢ ∑ b : Bool, extend m (bif b then s₁ else s₂) = extend m s₁ + extend m s₂
tactic: rw [union_eq_iUnion,
    extend_iUnion P0 m0 PU mU (pairwise_disjoint_on_bool.2 hd) (Bool.forall_bool.2 ⟨h₂, h₁⟩),
    tsum_fintype]
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ i, f i)
mU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), Pairwise (Disjoint on f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯
msU : ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)), m (⋃ i, f i) ⋯ ≤ ∑' (i : ℕ), m (f i) ⋯
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
hd : Disjoint s₁ s₂
h₁ : P s₁
h₂ : P s₂
⊢ ∑ b : Bool, extend m (bif b then s₁ else s₂) = extend m s₁ + extend m s₂
state_after: no goals
tactic: simp
Theorem: mul_boole
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
γ : Type w
R : Type x
α : Type u_1
inst✝¹ : MulZeroOneClass α
P : Prop
inst✝ : Decidable P
a : α
⊢ (a * if P then 1 else 0) = if P then a else 0
state_after: no goals
tactic: simp
Theorem: Real.logb_lt_logb_iff
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ logb b x < logb b y ↔ x < y
state_after: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ log x < log y ↔ x < y
tactic: rw [logb, logb, div_lt_div_right (log_pos hb)]
state_before: b x y : ℝ
hb : 1 < b
hx : 0 < x
hy : 0 < y
⊢ log x < log y ↔ x < y
state_after: no goals
tactic: exact log_lt_log_iff hx hy
Theorem: Complex.mul_inv_cancel
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
h : z ≠ 0
⊢ z * z⁻¹ = 1
state_after: no goals
tactic: rw [inv_def, ← mul_assoc, mul_conj, ← ofReal_mul, mul_inv_cancel (mt normSq_eq_zero.1 h),
    ofReal_one]
Theorem: Submodule.subsingleton_quotient_iff_eq_top
File: Mathlib/LinearAlgebra/Quotient.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ Subsingleton (M ⧸ p) ↔ p = ⊤
state_after: case mp
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ Subsingleton (M ⧸ p) → p = ⊤

case mpr
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ p = ⊤ → Subsingleton (M ⧸ p)
tactic: constructor
Theorem: ZMod.div_eq_filter_card
File: Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean

Proof steps:
state_before: a b c : ℕ
hb0 : 0 < b
hc : a / b ≤ c
⊢ a / b = (Ico 1 (a / b).succ).card
state_after: no goals
tactic: simp
state_before: a b c : ℕ
hb0 : 0 < b
hc : a / b ≤ c
x : ℕ
⊢ x ∈ Ico 1 (a / b).succ ↔ x ∈ filter (fun x => x * b ≤ a) (Ico 1 c.succ)
state_after: a b c : ℕ
hb0 : 0 < b
hc : a / b ≤ c
x : ℕ
this : x * b ≤ a → x ≤ c
⊢ x ∈ Ico 1 (a / b).succ ↔ x ∈ filter (fun x => x * b ≤ a) (Ico 1 c.succ)
tactic: have : x * b ≤ a → x ≤ c := fun h => le_trans (by rwa [le_div_iff_mul_le hb0]) hc
state_before: a b c : ℕ
hb0 : 0 < b
hc : a / b ≤ c
x : ℕ
this : x * b ≤ a → x ≤ c
⊢ x ∈ Ico 1 (a / b).succ ↔ x ∈ filter (fun x => x * b ≤ a) (Ico 1 c.succ)
state_after: a b c : ℕ
hb0 : 0 < b
hc : a / b ≤ c
x : ℕ
this : x * b ≤ a → x ≤ c
⊢ x * b ≤ a → 1 ≤ x → x ≤ c
tactic: simp [Nat.lt_succ_iff, le_div_iff_mul_le hb0]
state_before: a b c : ℕ
hb0 : 0 < b
hc : a / b ≤ c
x : ℕ
this : x * b ≤ a → x ≤ c
⊢ x * b ≤ a → 1 ≤ x → x ≤ c
state_after: no goals
tactic: tauto