ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LSeries.term_smul_apply
File: Mathlib/NumberTheory/LSeries/Linearity.lean

Proof steps:
state_before: f : ℕ → ℂ
c s : ℂ
n : ℕ
⊢ term (c • f) s n = c * term f s n
state_after: no goals
tactic: rw [term_smul, Pi.smul_apply, smul_eq_mul]
Theorem: toDFinsupp_support
File: Mathlib/Data/Finsupp/ToDFinsupp.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
⊢ f.toDFinsupp.support = f.support
state_after: case a
ι : Type u_1
R : Type u_2
M : Type u_3
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
a✝ : ι
⊢ a✝ ∈ f.toDFinsupp.support ↔ a✝ ∈ f.support
tactic: ext
state_before: case a
ι : Type u_1
R : Type u_2
M : Type u_3
inst✝² : DecidableEq ι
inst✝¹ : Zero M
inst✝ : (m : M) → Decidable (m ≠ 0)
f : ι →₀ M
a✝ : ι
⊢ a✝ ∈ f.toDFinsupp.support ↔ a✝ ∈ f.support
state_after: no goals
tactic: simp
Theorem: AddOreLocalization.vadd_cancel
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type u_2
inst✝ : MulAction R X
r : X
s t : ↥S
⊢ (↑s /ₒ t) • (r /ₒ s) = r /ₒ t
state_after: no goals
tactic: simp [oreDiv_smul_char s.1 r t s 1 1 (by simp)]
Theorem: Matrix.mem_range_scalar_of_commute_transvectionStruct
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

Proof steps:
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
⊢ M ∈ Set.range ⇑(scalar n)
state_after: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
⊢ Pairwise fun i j => Commute (stdBasisMatrix i j 1) M
tactic: refine mem_range_scalar_of_commute_stdBasisMatrix ?_
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
⊢ Pairwise fun i j => Commute (stdBasisMatrix i j 1) M
state_after: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i✝ j✝ : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
i j : n
hij : i ≠ j
⊢ Commute (stdBasisMatrix i j 1) M
tactic: intro i j hij
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i✝ j✝ : n
inst✝ : Fintype n
M : Matrix n n R
hM : ∀ (t : TransvectionStruct n R), Commute t.toMatrix M
i j : n
hij : i ≠ j
⊢ Commute (stdBasisMatrix i j 1) M
state_after: no goals
tactic: simpa [transvection, mul_add, add_mul] using (hM ⟨i, j, hij, 1⟩).eq
Theorem: Equiv.subtypeEquiv_refl
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α : Sort u_1
p : α → Prop
h : optParam (∀ (a : α), p a ↔ p ((Equiv.refl α) a)) ⋯
⊢ (Equiv.refl α).subtypeEquiv h = Equiv.refl { a // p a }
state_after: case H.a
α : Sort u_1
p : α → Prop
h : optParam (∀ (a : α), p a ↔ p ((Equiv.refl α) a)) ⋯
x✝ : { a // p a }
⊢ ↑(((Equiv.refl α).subtypeEquiv h) x✝) = ↑((Equiv.refl { a // p a }) x✝)
tactic: ext
state_before: case H.a
α : Sort u_1
p : α → Prop
h : optParam (∀ (a : α), p a ↔ p ((Equiv.refl α) a)) ⋯
x✝ : { a // p a }
⊢ ↑(((Equiv.refl α).subtypeEquiv h) x✝) = ↑((Equiv.refl { a // p a }) x✝)
state_after: no goals
tactic: rfl
Theorem: singleton_mul_closedBall
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} * closedBall y δ = closedBall (x * y) δ
state_after: no goals
tactic: simp_rw [singleton_mul, ← smul_eq_mul, image_smul, smul_closedBall]
Theorem: NormedAddGroupHom.ker.incl_comp_lift
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
h : g.comp f = 0
⊢ (incl g.ker).comp (lift f g h) = f
state_after: case H
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
h : g.comp f = 0
x✝ : V₁
⊢ ((incl g.ker).comp (lift f g h)) x✝ = f x✝
tactic: ext
state_before: case H
V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
g : NormedAddGroupHom V₂ V₃
h : g.comp f = 0
x✝ : V₁
⊢ ((incl g.ker).comp (lift f g h)) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: Polynomial.roots_normalize
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizationMonoid R
p : R[X]
⊢ (normalize p).roots = p.roots
state_after: no goals
tactic: rw [normalize_apply, mul_comm, coe_normUnit, roots_C_mul _ (normUnit (leadingCoeff p)).ne_zero]
Theorem: Turing.PartrecToTM2.head_supports
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: S : Finset Λ'
k : K'
q : Λ'
H : Λ'.Supports S q
x✝ : Option Γ'
⊢ Λ'.Supports S
    ((fun s => (if s = some Γ'.consₗ then id else Λ'.clear (fun x => decide (x = Γ'.consₗ)) k) (unrev q)) x✝)
state_after: S : Finset Λ'
k : K'
q : Λ'
H : Λ'.Supports S q
x✝ : Option Γ'
⊢ Λ'.Supports S ((if x✝ = some Γ'.consₗ then id else Λ'.clear (fun x => decide (x = Γ'.consₗ)) k) (unrev q))
tactic: dsimp only
state_before: S : Finset Λ'
k : K'
q : Λ'
H : Λ'.Supports S q
x✝ : Option Γ'
⊢ Λ'.Supports S ((if x✝ = some Γ'.consₗ then id else Λ'.clear (fun x => decide (x = Γ'.consₗ)) k) (unrev q))
state_after: no goals
tactic: split_ifs <;> exact H
Theorem: Nat.ModEq.add_left_cancel
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
h₁ : a ≡ b [MOD n]
h₂ : a + c ≡ b + d [MOD n]
⊢ c ≡ d [MOD n]
state_after: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b + ↑d - (↑a + ↑c)
⊢ ↑n ∣ ↑d - ↑c
tactic: simp only [modEq_iff_dvd, Int.ofNat_add] at *
state_before: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b + ↑d - (↑a + ↑c)
⊢ ↑n ∣ ↑d - ↑c
state_after: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑n ∣ ↑d - ↑c
tactic: rw [add_sub_add_comm] at h₂
state_before: m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑n ∣ ↑d - ↑c
state_after: case h.e'_4
m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑d - ↑c = ↑b - ↑a + (↑d - ↑c) - (↑b - ↑a)
tactic: convert _root_.dvd_sub h₂ h₁ using 1
state_before: case h.e'_4
m n a b c d : ℕ
h₁ : ↑n ∣ ↑b - ↑a
h₂ : ↑n ∣ ↑b - ↑a + (↑d - ↑c)
⊢ ↑d - ↑c = ↑b - ↑a + (↑d - ↑c) - (↑b - ↑a)
state_after: no goals
tactic: rw [add_sub_cancel_left]
Theorem: Cardinal.aleph0_le_aleph
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ ℵ₀ ≤ aleph o
state_after: o : Ordinal.{u_1}
⊢ ω ≤ ω + o
tactic: rw [aleph, aleph0_le_aleph']
state_before: o : Ordinal.{u_1}
⊢ ω ≤ ω + o
state_after: no goals
tactic: apply Ordinal.le_add_right
Theorem: QuaternionAlgebra.Basis.j_mul_k
File: Mathlib/Algebra/QuaternionBasis.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
⊢ q.j * q.k = -c₂ • q.i
state_after: no goals
tactic: rw [← i_mul_j, ← mul_assoc, j_mul_i, neg_mul, k_mul_j, neg_smul]
Theorem: Multiset.max_le_of_forall_le
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : Multiset α
n : α
h : ∀ x ∈ l, x ≤ n
⊢ fold max ⊥ l ≤ n
state_after: case h
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
n : α
a✝ : List α
h : ∀ x ∈ ⟦a✝⟧, x ≤ n
⊢ fold max ⊥ ⟦a✝⟧ ≤ n
tactic: induction l using Quotient.inductionOn
state_before: case h
ι : Type u_1
α✝ : Type u_2
β : Type u_3
α : Type u_4
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
n : α
a✝ : List α
h : ∀ x ∈ ⟦a✝⟧, x ≤ n
⊢ fold max ⊥ ⟦a✝⟧ ≤ n
state_after: no goals
tactic: simpa using List.max_le_of_forall_le _ _ h
Theorem: Field.DirectLimit.exists_inv
File: Mathlib/Algebra/DirectLimit.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : Ring R
ι : Type v
inst✝³ : Preorder ι
G : ι → Type w
inst✝² : Nonempty ι
inst✝¹ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝ : (i : ι) → Field (G i)
f : (i j : ι) → i ≤ j → G i → G j
f' : (i j : ι) → i ≤ j → G i →+* G j
p : Ring.DirectLimit G f
i : ι
x : G i
H : (Ring.DirectLimit.of G f i) x ≠ 0
⊢ (Ring.DirectLimit.of G f i) x * (Ring.DirectLimit.of G f i) x⁻¹ = 1
state_after: no goals
tactic: erw [← (Ring.DirectLimit.of _ _ _).map_mul,
        mul_inv_cancel fun h : x = 0 => H <| by rw [h, (Ring.DirectLimit.of _ _ _).map_zero],
        (Ring.DirectLimit.of _ _ _).map_one]
Theorem: inf_sq_eq_mul_div_mabs_div
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ a b : α
⊢ (a ⊓ b) ^ 2 = a * b / mabs (b / a)
state_after: no goals
tactic: rw [← inf_mul_sup a b, ← sup_div_inf_eq_mabs_div, div_eq_mul_inv, div_eq_mul_inv, mul_inv_rev,
    inv_inv, mul_assoc, mul_inv_cancel_comm_assoc, ← pow_two]
Theorem: Set.BijOn.exists
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
p : β → Prop
hf : BijOn f s t
⊢ (∃ b ∈ t, p b) → ∃ a ∈ s, p (f a)
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b✝ : β
p : β → Prop
hf : BijOn f s t
b : β
hb : b ∈ t
h : p b
⊢ ∃ a ∈ s, p (f a)
tactic: rintro ⟨b, hb, h⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b✝ : β
p : β → Prop
hf : BijOn f s t
b : β
hb : b ∈ t
h : p b
⊢ ∃ a ∈ s, p (f a)
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
p : β → Prop
hf : BijOn f s t
a : α
ha : a ∈ s
hb : f a ∈ t
h : p (f a)
⊢ ∃ a ∈ s, p (f a)
tactic: obtain ⟨a, ha, rfl⟩ := hf.surjOn hb
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
p : β → Prop
hf : BijOn f s t
a : α
ha : a ∈ s
hb : f a ∈ t
h : p (f a)
⊢ ∃ a ∈ s, p (f a)
state_after: no goals
tactic: exact ⟨a, ha, h⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
p : β → Prop
hf : BijOn f s t
⊢ (∃ a ∈ s, p (f a)) → ∃ b ∈ t, p b
state_after: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
p : β → Prop
hf : BijOn f s t
a : α
ha : a ∈ s
h : p (f a)
⊢ ∃ b ∈ t, p b
tactic: rintro ⟨a, ha, h⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p✝ : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a✝ : α
b : β
p : β → Prop
hf : BijOn f s t
a : α
ha : a ∈ s
h : p (f a)
⊢ ∃ b ∈ t, p b
state_after: no goals
tactic: exact ⟨f a, hf.mapsTo ha, h⟩
Theorem: FractionalIdeal.ideal_factor_ne_zero
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹¹ : CommRing R✝
S : Submonoid R✝
P : Type u_2
inst✝¹⁰ : CommRing P
inst✝⁹ : Algebra R✝ P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁸ : CommRing R₁
K✝ : Type u_4
inst✝⁷ : Field K✝
inst✝⁶ : Algebra R₁ K✝
inst✝⁵ : IsFractionRing R₁ K✝
inst✝⁴ : IsDomain R₁
R : Type u_6
inst✝³ : CommRing R
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
I : FractionalIdeal R⁰ K
hI : I ≠ 0
a : R
J : Ideal R
haJ : I = spanSingleton R⁰ ((algebraMap R K) a)⁻¹ * ↑J
h : J = 0
⊢ False
state_after: R✝ : Type u_1
inst✝¹¹ : CommRing R✝
S : Submonoid R✝
P : Type u_2
inst✝¹⁰ : CommRing P
inst✝⁹ : Algebra R✝ P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁸ : CommRing R₁
K✝ : Type u_4
inst✝⁷ : Field K✝
inst✝⁶ : Algebra R₁ K✝
inst✝⁵ : IsFractionRing R₁ K✝
inst✝⁴ : IsDomain R₁
R : Type u_6
inst✝³ : CommRing R
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
I : FractionalIdeal R⁰ K
hI : I ≠ 0
a : R
J : Ideal R
haJ : I = 0
h : J = 0
⊢ False
tactic: rw [h, Ideal.zero_eq_bot, coeIdeal_bot, MulZeroClass.mul_zero] at haJ
state_before: R✝ : Type u_1
inst✝¹¹ : CommRing R✝
S : Submonoid R✝
P : Type u_2
inst✝¹⁰ : CommRing P
inst✝⁹ : Algebra R✝ P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁸ : CommRing R₁
K✝ : Type u_4
inst✝⁷ : Field K✝
inst✝⁶ : Algebra R₁ K✝
inst✝⁵ : IsFractionRing R₁ K✝
inst✝⁴ : IsDomain R₁
R : Type u_6
inst✝³ : CommRing R
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
I : FractionalIdeal R⁰ K
hI : I ≠ 0
a : R
J : Ideal R
haJ : I = 0
h : J = 0
⊢ False
state_after: no goals
tactic: exact hI haJ
Theorem: Partrec.nat_casesOn_right
File: Mathlib/Computability/Partrec.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 σ
f : α → ℕ
g : α → σ
h : α → ℕ →. σ
hf : Computable f
hg : Computable g
hh : Partrec₂ h
a : α
⊢ Nat.rec (↑g a) (fun y IH => IH.bind fun i => h (a, y, i).1 (f (a, y, i).1).pred) (f a) =
    Nat.casesOn (f a) (Part.some (g a)) (h a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α → σ
h : α → ℕ →. σ
hf : Computable f
hg : Computable g
hh : Partrec₂ h
a : α
⊢ Nat.rec (Part.some (g a)) (fun y IH => IH.bind fun i => h a (f a - 1)) (f a) =
    Nat.rec (Part.some (g a)) (fun n n_ih => h a n) (f a)
tactic: simp only [PFun.coe_val, Nat.pred_eq_sub_one]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α → σ
h : α → ℕ →. σ
hf : Computable f
hg : Computable g
hh : Partrec₂ h
a : α
⊢ Nat.rec (Part.some (g a)) (fun y IH => IH.bind fun i => h a (f a - 1)) (f a) =
    Nat.rec (Part.some (g a)) (fun n n_ih => h a n) (f a)
state_after: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α → σ
h : α → ℕ →. σ
hf : Computable f
hg : Computable g
hh : Partrec₂ h
a : α
n : ℕ
⊢ ((Nat.rec (Part.some (g a)) (fun y IH => IH.bind fun i => h a n) n).bind fun i => h a n) = h a n
tactic: cases' f a with n <;> simp
state_before: case succ
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α → σ
h : α → ℕ →. σ
hf : Computable f
hg : Computable g
hh : Partrec₂ h
a : α
n : ℕ
⊢ ((Nat.rec (Part.some (g a)) (fun y IH => IH.bind fun i => h a n) n).bind fun i => h a n) = h a n
state_after: case succ.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α → σ
h : α → ℕ →. σ
hf : Computable f
hg : Computable g
hh : Partrec₂ h
a : α
n : ℕ
b : σ
H : b ∈ (Nat.rec (Part.some (g a)) (fun y IH => IH.bind fun i => h a n) n).bind fun i => h a n
⊢ b ∈ h a n

case succ.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → ℕ
g : α → σ
h : α → ℕ →. σ
hf : Computable f
hg : Computable g
hh : Partrec₂ h
a : α
n : ℕ
b : σ
H : b ∈ h a n
⊢ b ∈ (Nat.rec (Part.some (g a)) (fun y IH => IH.bind fun i => h a n) n).bind fun i => h a n
tactic: refine ext fun b => ⟨fun H => ?_, fun H => ?_⟩
Theorem: Cubic.card_roots_of_disc_ne_zero
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
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
hd : P.disc ≠ 0
⊢ (map φ P).roots.toFinset.card = 3
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
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
hd : P.disc ≠ 0
⊢ ∃ x y z, (map φ P).roots = {x, y, z}
tactic: rw [toFinset_card_of_nodup <| (disc_ne_zero_iff_roots_nodup ha h3).mp hd,
    ← splits_iff_card_roots ha, splits_iff_roots_eq_three ha]
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
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : (map φ P).roots = {x, y, z}
hd : P.disc ≠ 0
⊢ ∃ x y z, (map φ P).roots = {x, y, z}
state_after: no goals
tactic: exact ⟨x, ⟨y, ⟨z, h3⟩⟩⟩
Theorem: MeasureTheory.measure_biUnion_eq_iSup
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ι → Set α
t : Set ι
ht : t.Countable
hd : DirectedOn ((fun x x_1 => x ⊆ x_1) on s) t
⊢ μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ι → Set α
t : Set ι
ht : t.Countable
hd : DirectedOn ((fun x x_1 => x ⊆ x_1) on s) t
this : Encodable ↑t
⊢ μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i)
tactic: haveI := ht.toEncodable
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ι → Set α
t : Set ι
ht : t.Countable
hd : DirectedOn ((fun x x_1 => x ⊆ x_1) on s) t
this : Encodable ↑t
⊢ μ (⋃ i ∈ t, s i) = ⨆ i ∈ t, μ (s i)
state_after: no goals
tactic: rw [biUnion_eq_iUnion, measure_iUnion_eq_iSup hd.directed_val, ← iSup_subtype'']
Theorem: FDRep.char_one
File: Mathlib/RepresentationTheory/Character.lean

Proof steps:
state_before: k : Type u
inst✝¹ : Field k
G : Type u
inst✝ : Monoid G
V : FDRep k G
⊢ V.character 1 = ↑(finrank k (CoeSort.coe V))
state_after: no goals
tactic: simp only [character, map_one, trace_one]
Theorem: lipschitzWith_inv_iff
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α✝ : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝³ : SeminormedCommGroup E✝
inst✝² : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E✝
r r₁ r₂ : ℝ
α : Type u_5
E : Type u_6
inst✝¹ : SeminormedCommGroup E
inst✝ : PseudoEMetricSpace α
K Kf Kg : ℝ≥0
f g : α → E
s : Set α
x : α
⊢ LipschitzWith K f⁻¹ ↔ LipschitzWith K f
state_after: no goals
tactic: simp [LipschitzWith]
Theorem: Ordinal.le_one_iff
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a : Ordinal.{u_3}
⊢ a ≤ 1 ↔ a = 0 ∨ a = 1
state_after: no goals
tactic: simpa using @le_succ_bot_iff _ _ _ a _
Theorem: CliffordAlgebra.ofEven_comp_toEven
File: Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (ofEven Q) ((toEven Q) ((ι Q) m)) = (ofEven Q) ⟨↑((toEven Q) ((ι Q) m)), ⋯⟩
state_after: no goals
tactic: rw [Subtype.coe_eta]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (ofEven Q) ⟨↑((toEven Q) ((ι Q) m)), ⋯⟩ =
    ((ι Q) 0 + (algebraMap R (CliffordAlgebra Q)) 1) * ((ι Q) m - (algebraMap R (CliffordAlgebra Q)) 0)
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (ofEven Q) ⟨e0 Q * (v Q) m, ⋯⟩ =
    ((ι Q) 0 + (algebraMap R (CliffordAlgebra Q)) 1) * ((ι Q) m - (algebraMap R (CliffordAlgebra Q)) 0)
tactic: simp_rw [toEven_ι]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (ofEven Q) ⟨e0 Q * (v Q) m, ⋯⟩ =
    ((ι Q) 0 + (algebraMap R (CliffordAlgebra Q)) 1) * ((ι Q) m - (algebraMap R (CliffordAlgebra Q)) 0)
state_after: no goals
tactic: exact ofEven_ι Q _ _
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ ((ι Q) 0 + (algebraMap R (CliffordAlgebra Q)) 1) * ((ι Q) m - (algebraMap R (CliffordAlgebra Q)) 0) = (ι Q) m
state_after: no goals
tactic: rw [map_one, map_zero, map_zero, sub_zero, zero_add, one_mul]
Theorem: norm_image_sub_le_of_norm_deriv_le_segment
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b C : ℝ
hf : DifferentiableOn ℝ f (Icc a b)
bound : ∀ x ∈ Ico a b, ‖derivWithin f (Icc a b) x‖ ≤ C
⊢ ∀ x ∈ Icc a b, ‖f x - f a‖ ≤ C * (x - a)
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b C : ℝ
hf : DifferentiableOn ℝ f (Icc a b)
bound : ∀ x ∈ Ico a b, ‖derivWithin f (Icc a b) x‖ ≤ C
⊢ ∀ x ∈ Icc a b, HasDerivWithinAt f (derivWithin f (Icc a b) x) (Icc a b) x
tactic: refine norm_image_sub_le_of_norm_deriv_le_segment' ?_ bound
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b C : ℝ
hf : DifferentiableOn ℝ f (Icc a b)
bound : ∀ x ∈ Ico a b, ‖derivWithin f (Icc a b) x‖ ≤ C
⊢ ∀ x ∈ Icc a b, HasDerivWithinAt f (derivWithin f (Icc a b) x) (Icc a b) x
state_after: no goals
tactic: exact fun x hx => (hf x hx).hasDerivWithinAt