ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Stream'.Seq.mem_cons_iff
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
⊢ a = b ∨ a ∈ s → a ∈ cons b s
state_after: no goals
tactic: rintro (rfl | m) <;> [apply mem_cons; exact mem_cons_of_mem _ m]
Theorem: PadicInt.norm_lt_one_mul
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
hz2 : ‖z2‖ < 1
⊢ ‖z1 * z2‖ = ‖z1‖ * ‖z2‖
state_after: no goals
tactic: simp
Theorem: SimpleGraph.end_hom_mk_of_mk
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
K✝ L✝ L' M : Set V
s : (j : (Finset V)ᵒᵖ) → G.componentComplFunctor.obj j
sec : s ∈ G.end
K L : (Finset V)ᵒᵖ
h : L ⟶ K
v : V
vnL : v ∉ Opposite.unop L
hs : s L = G.componentComplMk vnL
⊢ s K = G.componentComplMk ⋯
state_after: V : Type u
G : SimpleGraph V
K✝ L✝ L' M : Set V
s : (j : (Finset V)ᵒᵖ) → G.componentComplFunctor.obj j
sec : s ∈ G.end
K L : (Finset V)ᵒᵖ
h : L ⟶ K
v : V
vnL : v ∉ Opposite.unop L
hs : s L = G.componentComplMk vnL
⊢ G.componentComplFunctor.map h (G.componentComplMk vnL) = G.componentComplMk ⋯
tactic: rw [← sec h, hs]
state_before: V : Type u
G : SimpleGraph V
K✝ L✝ L' M : Set V
s : (j : (Finset V)ᵒᵖ) → G.componentComplFunctor.obj j
sec : s ∈ G.end
K L : (Finset V)ᵒᵖ
h : L ⟶ K
v : V
vnL : v ∉ Opposite.unop L
hs : s L = G.componentComplMk vnL
⊢ G.componentComplFunctor.map h (G.componentComplMk vnL) = G.componentComplMk ⋯
state_after: no goals
tactic: apply ComponentCompl.hom_mk _ (le_of_op_hom h : _ ⊆ _)
Theorem: Option.map₂_eq_none_iff
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
⊢ map₂ f a b = none ↔ a = none ∨ b = none
state_after: no goals
tactic: cases a <;> cases b <;> simp
Theorem: LinearMap.rTensor_neg
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : CommSemiring R
M : Type u_2
N : Type u_3
P : Type u_4
Q : Type u_5
S : Type u_6
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : AddCommGroup S
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R Q
inst✝ : Module R S
f : N →ₗ[R] P
⊢ rTensor M (-f) = -rTensor M f
state_after: R : Type u_1
inst✝¹⁰ : CommSemiring R
M : Type u_2
N : Type u_3
P : Type u_4
Q : Type u_5
S : Type u_6
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : AddCommGroup S
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R Q
inst✝ : Module R S
f : N →ₗ[R] P
⊢ (rTensorHom M) (-f) = -(rTensorHom M) f
tactic: simp only [← coe_rTensorHom]
state_before: R : Type u_1
inst✝¹⁰ : CommSemiring R
M : Type u_2
N : Type u_3
P : Type u_4
Q : Type u_5
S : Type u_6
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : AddCommGroup S
inst✝⁴ : Module R M
inst✝³ : Module R N
inst✝² : Module R P
inst✝¹ : Module R Q
inst✝ : Module R S
f : N →ₗ[R] P
⊢ (rTensorHom M) (-f) = -(rTensorHom M) f
state_after: no goals
tactic: exact (rTensorHom (R := R) (N := N) (P := P) M).map_neg f
Theorem: MvPolynomial.quotient_mk_comp_C_injective
File: Mathlib/FieldTheory/MvPolynomial.lean

Proof steps:
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
⊢ Function.Injective ⇑((Ideal.Quotient.mk I).comp C)
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : ((Ideal.Quotient.mk I).comp C) x = 0
⊢ x = 0
tactic: refine (injective_iff_map_eq_zero _).2 fun x hx => ?_
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : ((Ideal.Quotient.mk I).comp C) x = 0
⊢ x = 0
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
⊢ x = 0
tactic: rw [RingHom.comp_apply, Ideal.Quotient.eq_zero_iff_mem] at hx
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
⊢ x = 0
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
⊢ 1 ∈ I
tactic: refine _root_.by_contradiction fun hx0 => absurd (I.eq_top_iff_one.2 ?_) hI
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
⊢ 1 ∈ I
state_after: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
this : C x⁻¹ * C x ∈ I
⊢ 1 ∈ I
tactic: have := I.mul_mem_left (MvPolynomial.C x⁻¹) hx
state_before: σ : Type u
K : Type v
inst✝ : Field K
I : Ideal (MvPolynomial σ K)
hI : I ≠ ⊤
x : K
hx : C x ∈ I
hx0 : ¬x = 0
this : C x⁻¹ * C x ∈ I
⊢ 1 ∈ I
state_after: no goals
tactic: rwa [← MvPolynomial.C.map_mul, inv_mul_cancel hx0, MvPolynomial.C_1] at this
Theorem: add_neg_le_add_neg_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b
state_after: no goals
tactic: rw [mul_comm c, mul_inv_le_inv_mul_iff, mul_comm]
Theorem: MeasureTheory.Lp.compMeasurePreservingₗ_apply
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
β : Type u_5
inst✝³ : MeasurableSpace β
μb : Measure β
f✝ : α → β
𝕜 : Type u_6
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
f : α → β
hf : MeasurePreserving f μ μb
c : 𝕜
g : ↥(Lp E p μb)
⊢ { toFun := (↑__spread✝⁻⁰).toFun, map_add' := ⋯ }.toFun (c • g) =
    (RingHom.id 𝕜) c • { toFun := (↑__spread✝⁻⁰).toFun, map_add' := ⋯ }.toFun g
state_after: case mk.mk
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
β : Type u_5
inst✝³ : MeasurableSpace β
μb : Measure β
f✝ : α → β
𝕜 : Type u_6
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
f : α → β
hf : MeasurePreserving f μ μb
c : 𝕜
val✝ : β →ₘ[μb] E
a✝ : { f // AEStronglyMeasurable f μb }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μb
⊢ { toFun := (↑__spread✝⁻⁰).toFun, map_add' := ⋯ }.toFun (c • ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    (RingHom.id 𝕜) c • { toFun := (↑__spread✝⁻⁰).toFun, map_add' := ⋯ }.toFun ⟨Quot.mk Setoid.r a✝, property✝⟩
tactic: rcases g with ⟨⟨_⟩, _⟩
state_before: case mk.mk
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedAddCommGroup G
β : Type u_5
inst✝³ : MeasurableSpace β
μb : Measure β
f✝ : α → β
𝕜 : Type u_6
inst✝² : NormedRing 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
f : α → β
hf : MeasurePreserving f μ μb
c : 𝕜
val✝ : β →ₘ[μb] E
a✝ : { f // AEStronglyMeasurable f μb }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μb
⊢ { toFun := (↑__spread✝⁻⁰).toFun, map_add' := ⋯ }.toFun (c • ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    (RingHom.id 𝕜) c • { toFun := (↑__spread✝⁻⁰).toFun, map_add' := ⋯ }.toFun ⟨Quot.mk Setoid.r a✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: Finset.Ici_mul_Ici_subset'
File: Mathlib/Data/Finset/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : Mul α
inst✝⁴ : Preorder α
inst✝³ : DecidableEq α
inst✝² : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝¹ : CovariantClass α α (Function.swap HMul.hMul) LE.le
inst✝ : LocallyFiniteOrderTop α
a b : α
⊢ ↑(Ici a * Ici b) ⊆ ↑(Ici (a * b))
state_after: no goals
tactic: simpa using Set.Ici_mul_Ici_subset' _ _
Theorem: ZMod.gauss_lemma_aux
File: Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
hap : ↑a ≠ 0
⊢ ↑(p / 2)! ≠ 0
state_after: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
hap : ↑a ≠ 0
⊢ p / 2 < p
tactic: rw [Ne, CharP.cast_eq_zero_iff (ZMod p) p, hp.1.dvd_factorial, not_le]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
hap : ↑a ≠ 0
⊢ p / 2 < p
state_after: no goals
tactic: exact Nat.div_lt_self hp.1.pos (by decide)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : ℤ
hap : ↑a ≠ 0
⊢ ↑a ^ (p / 2) * ↑(p / 2)! = ↑((-1) ^ (filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card) * ↑(p / 2)!
state_after: no goals
tactic: simpa using gauss_lemma_aux₁ p hap
Theorem: CategoryTheory.isCodetector_op_iff
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C
⊢ IsCodetector (op G) ↔ IsDetector G
state_after: no goals
tactic: rw [IsDetector, IsCodetector, ← isCodetecting_op_iff, Set.singleton_op]
Theorem: Cardinal.lt_power_cof
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
⊢ ⟦α⟧ < ⟦α⟧ ^ (ord ⟦α⟧).cof
state_after: case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
⊢ ⟦α⟧ < ⟦α⟧ ^ (ord ⟦α⟧).cof
tactic: rcases ord_eq α with ⟨r, wo, re⟩
state_before: case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
⊢ ⟦α⟧ < ⟦α⟧ ^ (ord ⟦α⟧).cof
state_after: case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this : (ord ⟦α⟧).IsLimit
⊢ ⟦α⟧ < ⟦α⟧ ^ (ord ⟦α⟧).cof
tactic: have := ord_isLimit h
state_before: case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this : (ord ⟦α⟧).IsLimit
⊢ ⟦α⟧ < ⟦α⟧ ^ (ord ⟦α⟧).cof
state_after: case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this : (type r).IsLimit
⊢ #α < #α ^ (type r).cof
tactic: rw [mk'_def, re] at this ⊢
state_before: case intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this : (type r).IsLimit
⊢ #α < #α ^ (type r).cof
state_after: case intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this : (type r).IsLimit
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = (type r).cof
⊢ #α < #α ^ (type r).cof
tactic: rcases cof_eq' r this with ⟨S, H, Se⟩
state_before: case intro.intro.intro.intro
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this : (type r).IsLimit
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = (type r).cof
⊢ #α < #α ^ (type r).cof
state_after: case intro.intro.intro.intro.refine_2
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this✝ : (type r).IsLimit
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = (type r).cof
this : (sum fun a => #{ x // r x ↑a }) < prod fun x => #α
⊢ #α < #α ^ (type r).cof

case intro.intro.intro.intro.refine_1
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
c : Cardinal.{u}
α : Type u
h : ℵ₀ ≤ ⟦α⟧
r : α → α → Prop
wo : IsWellOrder α r
re : (#α).ord = type r
this : (type r).IsLimit
S : Set α
H : ∀ (a : α), ∃ b ∈ S, r a b
Se : #↑S = (type r).cof
i : ↑S
⊢ (fun a => #{ x // r x ↑a }) i < (fun x => #α) i
tactic: have := sum_lt_prod (fun a : S => #{ x // r x a }) (fun _ => #α) fun i => ?_
Theorem: CategoryTheory.Functor.balanced_of_preserves
File: Mathlib/CategoryTheory/Functor/ReflectsIso.lean

Proof steps:
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
F : C ⥤ D
inst✝³ : F.ReflectsIsomorphisms
inst✝² : F.PreservesEpimorphisms
inst✝¹ : F.PreservesMonomorphisms
inst✝ : Balanced D
X✝ Y✝ : C
f : X✝ ⟶ Y✝
x✝¹ : Mono f
x✝ : Epi f
⊢ IsIso f
state_after: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
F : C ⥤ D
inst✝³ : F.ReflectsIsomorphisms
inst✝² : F.PreservesEpimorphisms
inst✝¹ : F.PreservesMonomorphisms
inst✝ : Balanced D
X✝ Y✝ : C
f : X✝ ⟶ Y✝
x✝¹ : Mono f
x✝ : Epi f
⊢ IsIso (F.map f)
tactic: rw [← isIso_iff_of_reflects_iso (F := F)]
state_before: C : Type u₁
inst✝⁶ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
E : Type u₃
inst✝⁴ : Category.{v₃, u₃} E
F : C ⥤ D
inst✝³ : F.ReflectsIsomorphisms
inst✝² : F.PreservesEpimorphisms
inst✝¹ : F.PreservesMonomorphisms
inst✝ : Balanced D
X✝ Y✝ : C
f : X✝ ⟶ Y✝
x✝¹ : Mono f
x✝ : Epi f
⊢ IsIso (F.map f)
state_after: no goals
tactic: exact isIso_of_mono_of_epi _
Theorem: Multiset.mem_sup_map_support_iff
File: Mathlib/Data/Finsupp/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
inst✝¹ : DecidableEq ι
inst✝ : Zero M
s : Multiset (ι →₀ M)
x : ι
x✝ : List (ι →₀ M)
⊢ x ∈ (map Finsupp.support (Quot.mk Setoid.r x✝)).sup ↔ ∃ f ∈ Quot.mk Setoid.r x✝, x ∈ f.support
state_after: no goals
tactic: simpa only [Multiset.quot_mk_to_coe'', Multiset.map_coe, Multiset.sup_coe, List.foldr_map]
    using List.mem_foldr_sup_support_iff
Theorem: Finset.mem_smul_finset
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : DecidableEq β
inst✝ : SMul α β
s s₁ s₂ t u : Finset β
a : α
b x : β
⊢ x ∈ a • s ↔ ∃ y ∈ s, a • y = x
state_after: no goals
tactic: simp only [Finset.smul_finset_def, and_assoc, mem_image, exists_prop, Prod.exists, mem_product]
Theorem: Ordinal.lift_cof
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{v}
⊢ Cardinal.lift.{u, v} o.cof = (lift.{u, v} o).cof
state_after: α : Type u_1
r : α → α → Prop
o : Ordinal.{v}
⊢ ∀ (α : Type v) (r : α → α → Prop) [inst : IsWellOrder α r],
    Cardinal.lift.{u, v} (type r).cof = (lift.{u, v} (type r)).cof
tactic: refine inductionOn o ?_
state_before: α : Type u_1
r : α → α → Prop
o : Ordinal.{v}
⊢ ∀ (α : Type v) (r : α → α → Prop) [inst : IsWellOrder α r],
    Cardinal.lift.{u, v} (type r).cof = (lift.{u, v} (type r)).cof
state_after: α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ Cardinal.lift.{u, v} (type r).cof = (lift.{u, v} (type r)).cof
tactic: intro α r _
state_before: α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ Cardinal.lift.{u, v} (type r).cof = (lift.{u, v} (type r)).cof
state_after: case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ Cardinal.lift.{u, v} (type r).cof ≤ (lift.{u, v} (type r)).cof

case a
α✝ : Type u_1
r✝ : α✝ → α✝ → Prop
o : Ordinal.{v}
α : Type v
r : α → α → Prop
inst✝ : IsWellOrder α r
⊢ (lift.{u, v} (type r)).cof ≤ Cardinal.lift.{u, v} (type r).cof
tactic: apply le_antisymm
Theorem: MeasureTheory.Measure.restrict_univ
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t s : Set α
hs : MeasurableSet s
⊢ (μ.restrict univ) s = μ s
state_after: no goals
tactic: simp [hs]
Theorem: riemannZeta_four
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

Proof steps:
state_before: ⊢ riemannZeta 4 = ↑π ^ 4 / 90
state_after: case h.e'_2

⊢ riemannZeta 4 = ↑(∑' (b : ℕ), 1 / ↑b ^ 4)

case h.e'_3

⊢ ↑π ^ 4 / 90 = ↑(π ^ 4 / 90)
tactic: convert congr_arg ((↑) : ℝ → ℂ) hasSum_zeta_four.tsum_eq
Theorem: Nat.primeFactorsList_two
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: ⊢ primeFactorsList 2 = [2]
state_after: no goals
tactic: simp [primeFactorsList]
Theorem: LinearMap.coprod_inl_inr
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
S : Type u_3
inst✝¹³ : Semiring R
inst✝¹² : Semiring S
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M₂
inst✝⁹ : AddCommMonoid M₃
inst✝⁸ : AddCommMonoid M₄
inst✝⁷ : AddCommMonoid M₅
inst✝⁶ : AddCommMonoid M₆
inst✝⁵ : Module R M
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M₄
inst✝¹ : Module R M₅
inst✝ : Module R M₆
f : M →ₗ[R] M₂
⊢ (inl R M M₂).coprod (inr R M M₂) = id
state_after: no goals
tactic: ext <;>
    simp only [Prod.mk_add_mk, add_zero, id_apply, coprod_apply, inl_apply, inr_apply, zero_add]
Theorem: intervalIntegral.intervalIntegrable_one_div_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ IntervalIntegrable (fun x => 1 / (1 + x ^ 2)) μ a b
state_after: case refine_1
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ Continuous fun x => 1 + x ^ 2

case refine_2
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d x : ℝ
⊢ 1 + x ^ 2 ≠ 0
tactic: refine (continuous_const.div ?_ fun x => ?_).intervalIntegrable a b
Theorem: ONote.repr_mul
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: o : ONote
x✝ : NF 0
h₂ : o.NF
⊢ (0 * o).repr = repr 0 * o.repr
state_after: no goals
tactic: cases o <;> exact (zero_mul _).symm
state_before: e₁ : ONote
n₁ : ℕ+
a₁ e₂ : ONote
n₂ : ℕ+
a₂ : ONote
h₁ : (e₁.oadd n₁ a₁).NF
h₂ : (e₂.oadd n₂ a₂).NF
⊢ (e₁.oadd n₁ a₁ * e₂.oadd n₂ a₂).repr = (e₁.oadd n₁ a₁).repr * (e₂.oadd n₂ a₂).repr
state_after: e₁ : ONote
n₁ : ℕ+
a₁ e₂ : ONote
n₂ : ℕ+
a₂ : ONote
h₁ : (e₁.oadd n₁ a₁).NF
h₂ : (e₂.oadd n₂ a₂).NF
IH : ((e₁.oadd n₁ a₁).mul a₂).repr = (e₁.oadd n₁ a₁).repr * a₂.repr
⊢ (e₁.oadd n₁ a₁ * e₂.oadd n₂ a₂).repr = (e₁.oadd n₁ a₁).repr * (e₂.oadd n₂ a₂).repr
tactic: have IH : repr (mul _ _) = _ := @repr_mul _ _ h₁ h₂.snd
state_before: e₁ : ONote
n₁ : ℕ+
a₁ e₂ : ONote
n₂ : ℕ+
a₂ : ONote
h₁ : (e₁.oadd n₁ a₁).NF
h₂ : (e₂.oadd n₂ a₂).NF
IH : ((e₁.oadd n₁ a₁).mul a₂).repr = (e₁.oadd n₁ a₁).repr * a₂.repr
⊢ (Mul.mul (e₁.oadd n₁ a₁) (e₂.oadd n₂ a₂)).repr = (e₁.oadd n₁ a₁).repr * (e₂.oadd n₂ a₂).repr
state_after: e₁ : ONote
n₁ : ℕ+
a₁ e₂ : ONote
n₂ : ℕ+
a₂ : ONote
h₁ : (e₁.oadd n₁ a₁).NF
h₂ : (e₂.oadd n₂ a₂).NF
IH : ((e₁.oadd n₁ a₁).mul a₂).repr = (e₁.oadd n₁ a₁).repr * a₂.repr
ao : a₁.repr + ω ^ e₁.repr * ↑↑n₁ = ω ^ e₁.repr * ↑↑n₁
⊢ (Mul.mul (e₁.oadd n₁ a₁) (e₂.oadd n₂ a₂)).repr = (e₁.oadd n₁ a₁).repr * (e₂.oadd n₂ a₂).repr
tactic: have ao : repr a₁ + ω ^ repr e₁ * (n₁ : ℕ) = ω ^ repr e₁ * (n₁ : ℕ) := by
      apply add_absorp h₁.snd'.repr_lt
      simpa using (Ordinal.mul_le_mul_iff_left <| opow_pos _ omega_pos).2 (natCast_le.2 n₁.2)
state_before: e₁ : ONote
n₁ : ℕ+
a₁ e₂ : ONote
n₂ : ℕ+
a₂ : ONote
h₁ : (e₁.oadd n₁ a₁).NF
h₂ : (e₂.oadd n₂ a₂).NF
IH : ((e₁.oadd n₁ a₁).mul a₂).repr = (e₁.oadd n₁ a₁).repr * a₂.repr
ao : a₁.repr + ω ^ e₁.repr * ↑↑n₁ = ω ^ e₁.repr * ↑↑n₁
⊢ (Mul.mul (e₁.oadd n₁ a₁) (e₂.oadd n₂ a₂)).repr = (e₁.oadd n₁ a₁).repr * (e₂.oadd n₂ a₂).repr
state_after: case pos
e₁ : ONote
n₁ : ℕ+
a₁ e₂ : ONote
n₂ : ℕ+
a₂ : ONote
h₁ : (e₁.oadd n₁ a₁).NF
h₂ : (e₂.oadd n₂ a₂).NF
IH : ((e₁.oadd n₁ a₁).mul a₂).repr = (e₁.oadd n₁ a₁).repr * a₂.repr
ao : a₁.repr + ω ^ e₁.repr * ↑↑n₁ = ω ^ e₁.repr * ↑↑n₁
e0 : e₂ = 0
⊢ (Mul.mul (e₁.oadd n₁ a₁) (e₂.oadd n₂ a₂)).repr = (e₁.oadd n₁ a₁).repr * (e₂.oadd n₂ a₂).repr

case neg
e₁ : ONote
n₁ : ℕ+
a₁ e₂ : ONote
n₂ : ℕ+
a₂ : ONote
h₁ : (e₁.oadd n₁ a₁).NF
h₂ : (e₂.oadd n₂ a₂).NF
IH : ((e₁.oadd n₁ a₁).mul a₂).repr = (e₁.oadd n₁ a₁).repr * a₂.repr
ao : a₁.repr + ω ^ e₁.repr * ↑↑n₁ = ω ^ e₁.repr * ↑↑n₁
e0 : ¬e₂ = 0
⊢ (Mul.mul (e₁.oadd n₁ a₁) (e₂.oadd n₂ a₂)).repr = (e₁.oadd n₁ a₁).repr * (e₂.oadd n₂ a₂).repr
tactic: by_cases e0 : e₂ = 0
Theorem: FermatLastTheoremForThreeGen.Solution.lambda_dvd_a_add_eta_mul_b
File: Mathlib/NumberTheory/FLT/Three.lean

Proof steps:
state_before: K : Type u_1
inst✝³ : Field K
inst✝² : NumberField K
inst✝¹ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
S' : Solution' hζ
inst✝ : DecidableRel fun a b => a ∣ b
⊢ 2 ≠ 0
state_after: no goals
tactic: decide
state_before: K : Type u_1
inst✝³ : Field K
inst✝² : NumberField K
inst✝¹ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
S' : Solution' hζ
inst✝ : DecidableRel fun a b => a ∣ b
⊢ λ * S.b = λ * S.b
state_after: no goals
tactic: rw [mul_comm]
Theorem: Module.End.hasEigenvalue_of_hasGenEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

Proof steps:
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
⊢ f.HasEigenvalue μ
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : f.eigenspace μ = ⊥
⊢ False
tactic: intro contra
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : f.eigenspace μ = ⊥
⊢ False
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : f.eigenspace μ = ⊥
⊢ (f.genEigenspace μ) k = ⊥
tactic: apply hμ
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : f.eigenspace μ = ⊥
⊢ (f.genEigenspace μ) k = ⊥
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : Function.Injective ⇑(f - (algebraMap R (End R M)) μ)
⊢ Function.Injective ⇑((f - (algebraMap R (End R M)) μ) ^ k)
tactic: erw [LinearMap.ker_eq_bot] at contra ⊢
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : Function.Injective ⇑(f - (algebraMap R (End R M)) μ)
⊢ Function.Injective ⇑((f - (algebraMap R (End R M)) μ) ^ k)
state_after: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : Function.Injective ⇑(f - (algebraMap R (End R M)) μ)
⊢ Function.Injective (⇑(f - (algebraMap R (End R M)) μ))^[k]
tactic: rw [LinearMap.coe_pow]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
μ : R
k : ℕ
hμ : f.HasGenEigenvalue μ k
contra : Function.Injective ⇑(f - (algebraMap R (End R M)) μ)
⊢ Function.Injective (⇑(f - (algebraMap R (End R M)) μ))^[k]
state_after: no goals
tactic: exact Function.Injective.iterate contra k