ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsIntegralClosure.of_isIntegrallyClosedIn
File: Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
iic : IsIntegrallyClosedIn R A
B : Type u_3
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : Algebra A B
inst✝² : IsScalarTower R A B
inst✝¹ : IsIntegrallyClosedIn A B
inst✝ : Algebra.IsIntegral R A
⊢ IsIntegralClosure A R B
state_after: R : Type u_1
A : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
iic : IsIntegrallyClosedIn R A
B : Type u_3
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : Algebra A B
inst✝² : IsScalarTower R A B
inst✝¹ : IsIntegrallyClosedIn A B
inst✝ : Algebra.IsIntegral R A
x : B
⊢ (∃ y, (algebraMap A B) y = x) → IsIntegral R x
tactic: refine ⟨IsIntegralClosure.algebraMap_injective _ A _, fun {x} ↦
    ⟨fun hx ↦ IsIntegralClosure.isIntegral_iff.mp (IsIntegral.tower_top (A := A) hx), ?_⟩⟩
state_before: R : Type u_1
A : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
iic : IsIntegrallyClosedIn R A
B : Type u_3
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : Algebra A B
inst✝² : IsScalarTower R A B
inst✝¹ : IsIntegrallyClosedIn A B
inst✝ : Algebra.IsIntegral R A
x : B
⊢ (∃ y, (algebraMap A B) y = x) → IsIntegral R x
state_after: case intro
R : Type u_1
A : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
iic : IsIntegrallyClosedIn R A
B : Type u_3
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : Algebra A B
inst✝² : IsScalarTower R A B
inst✝¹ : IsIntegrallyClosedIn A B
inst✝ : Algebra.IsIntegral R A
y : A
⊢ IsIntegral R ((algebraMap A B) y)
tactic: rintro ⟨y, rfl⟩
state_before: case intro
R : Type u_1
A : Type u_2
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
iic : IsIntegrallyClosedIn R A
B : Type u_3
inst✝⁵ : CommRing B
inst✝⁴ : Algebra R B
inst✝³ : Algebra A B
inst✝² : IsScalarTower R A B
inst✝¹ : IsIntegrallyClosedIn A B
inst✝ : Algebra.IsIntegral R A
y : A
⊢ IsIntegral R ((algebraMap A B) y)
state_after: no goals
tactic: exact IsIntegral.map (IsScalarTower.toAlgHom A A B) (Algebra.IsIntegral.isIntegral y)
Theorem: SetTheory.PGame.birthday_eq_zero
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: x : PGame
⊢ x.birthday = 0 ↔ IsEmpty x.LeftMoves ∧ IsEmpty x.RightMoves
state_after: no goals
tactic: rw [birthday_def, max_eq_zero, lsub_eq_zero_iff, lsub_eq_zero_iff]
Theorem: MeasurableSet.biInter
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 α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : s.Countable
h : ∀ b ∈ s, MeasurableSet (f b)
⊢ MeasurableSet (⋂ b ∈ s, f b)ᶜ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : s.Countable
h : ∀ b ∈ s, MeasurableSet (f b)
⊢ MeasurableSet (⋃ i ∈ s, (f i)ᶜ)
tactic: rw [compl_iInter₂]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort u_6
s✝ t u : Set α
m : MeasurableSpace α
f : β → Set α
s : Set β
hs : s.Countable
h : ∀ b ∈ s, MeasurableSet (f b)
⊢ MeasurableSet (⋃ i ∈ s, (f i)ᶜ)
state_after: no goals
tactic: exact .biUnion hs fun b hb => (h b hb).compl
Theorem: SimpleGraph.Path.loop_eq
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v : V
p : G.Path v v
⊢ p = Path.nil
state_after: case mk.nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v : V
h : Walk.nil.IsPath
⊢ ⟨Walk.nil, h⟩ = Path.nil

case mk.cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
v v✝ : V
h✝ : G.Adj v v✝
p✝ : G.Walk v✝ v
h : (Walk.cons h✝ p✝).IsPath
⊢ ⟨Walk.cons h✝ p✝, h⟩ = Path.nil
tactic: obtain ⟨_ | _, h⟩ := p
Theorem: Asymptotics.isBigO_map
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k✝ : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l✝ l' : Filter α
k : β → α
l : Filter β
⊢ f =O[map k l] g ↔ (f ∘ k) =O[l] (g ∘ k)
state_after: no goals
tactic: simp only [IsBigO_def, isBigOWith_map]
Theorem: CategoryTheory.isSeparator_iff_faithful_preadditiveCoyonedaObj
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ IsSeparator G ↔ (preadditiveCoyonedaObj (op G)).Faithful
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveCoyonedaObj (op G) ⋙ forget₂ (ModuleCat (End (op G))) AddCommGrp).Faithful ↔
    (preadditiveCoyonedaObj (op G)).Faithful
tactic: rw [isSeparator_iff_faithful_preadditiveCoyoneda, preadditiveCoyoneda_obj]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveCoyonedaObj (op G) ⋙ forget₂ (ModuleCat (End (op G))) AddCommGrp).Faithful ↔
    (preadditiveCoyonedaObj (op G)).Faithful
state_after: no goals
tactic: exact ⟨fun h => Functor.Faithful.of_comp _ (forget₂ _ AddCommGrp.{v}),
    fun h => Functor.Faithful.comp _ _⟩
Theorem: Function.extend_sub
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Div γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ / g₂) (e₁ / e₂) = extend f g₁ e₁ / extend f g₂ e₂
state_after: no goals
tactic: classical
  funext x
  simp [Function.extend_def, apply_dite₂]
Theorem: PartialEquiv.trans_source''
File: Mathlib/Logic/Equiv/PartialEquiv.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e' : PartialEquiv β γ
⊢ (e.trans e').source = ↑e.symm '' (e.target ∩ e'.source)
state_after: no goals
tactic: rw [e.trans_source', e.symm_image_target_inter_eq]
Theorem: MeasureTheory.pdf.eq_of_map_eq_withDensity
File: Mathlib/Probability/Density.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hmf : AEMeasurable f μ
⊢ map X ℙ = μ.withDensity f ↔ pdf X ℙ μ =ᶠ[ae μ] f
state_after: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hmf : AEMeasurable f μ
⊢ μ.withDensity (pdf X ℙ μ) = μ.withDensity f ↔ pdf X ℙ μ =ᶠ[ae μ] f
tactic: rw [map_eq_withDensity_pdf X ℙ μ]
state_before: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hmf : AEMeasurable f μ
⊢ μ.withDensity (pdf X ℙ μ) = μ.withDensity f ↔ pdf X ℙ μ =ᶠ[ae μ] f
state_after: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hmf : AEMeasurable f μ
⊢ ∫⁻ (x : E), pdf X ℙ μ x ∂μ ≠ ⊤
tactic: apply withDensity_eq_iff (measurable_pdf X ℙ μ).aemeasurable hmf
state_before: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hmf : AEMeasurable f μ
⊢ ∫⁻ (x : E), pdf X ℙ μ x ∂μ ≠ ⊤
state_after: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hmf : AEMeasurable f μ
⊢ ℙ Set.univ ≠ ⊤
tactic: rw [lintegral_eq_measure_univ]
state_before: Ω : Type u_1
E : Type u_2
inst✝² : MeasurableSpace E
m : MeasurableSpace Ω
ℙ : Measure Ω
μ : Measure E
inst✝¹ : IsFiniteMeasure ℙ
X : Ω → E
inst✝ : HasPDF X ℙ μ
f : E → ℝ≥0∞
hmf : AEMeasurable f μ
⊢ ℙ Set.univ ≠ ⊤
state_after: no goals
tactic: exact measure_ne_top _ _
Theorem: MvPolynomial.psum_zero
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ psum σ R 0 = ↑(Fintype.card σ)
state_after: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ ↑univ.card = ↑(Fintype.card σ)
tactic: simp only [psum, _root_.pow_zero, ← cast_card]
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ ↑univ.card = ↑(Fintype.card σ)
state_after: no goals
tactic: exact rfl
Theorem: PartENat.toWithTop_natCast'
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: n : ℕ
x✝ : Decidable (↑n).Dom
⊢ (↑n).toWithTop = ↑n
state_after: no goals
tactic: rw [toWithTop_natCast n]
Theorem: Filter.limsup_const
File: Mathlib/Order/LiminfLimsup.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝² : ConditionallyCompleteLattice α✝
α : Type u_6
inst✝¹ : ConditionallyCompleteLattice β
f : Filter α
inst✝ : f.NeBot
b : β
⊢ limsup (fun x => b) f = b
state_after: no goals
tactic: simpa only [limsup_eq, eventually_const] using csInf_Ici
Theorem: IsPrimitiveRoot.subOneIntegralPowerBasis_gen
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ hζ.subOneIntegralPowerBasis.gen = ⟨ζ - 1, ⋯⟩
state_after: no goals
tactic: simp [subOneIntegralPowerBasis]
Theorem: Complex.hasDerivAt_Gamma_one_half
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

Proof steps:
state_before: ⊢ HasDerivAt Gamma (-↑√π * (↑γ + 2 * log 2)) (1 / 2)
state_after: case refine_2
this : HasDerivAt Gamma ↑(-√π * (γ + 2 * Real.log 2)) ↑(1 / 2)
⊢ HasDerivAt Gamma (-↑√π * (↑γ + 2 * log 2)) (1 / 2)

case refine_1

⊢ ∀ (m : ℕ), ↑(1 / 2) ≠ -↑m
tactic: have := HasDerivAt.complex_of_real
    (differentiableAt_Gamma _ ?_) Real.hasDerivAt_Gamma_one_half Gamma_ofReal
Theorem: pow_mem_ball
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : a ∈ ball b r
⊢ a ^ n ∈ ball (b ^ n) (n • r)
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : ‖a / b‖ < r
⊢ ‖(a / b) ^ n‖ < n • r
tactic: simp only [mem_ball, dist_eq_norm_div, ← div_pow] at h ⊢
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : ‖a / b‖ < r
⊢ ‖(a / b) ^ n‖ < n • r
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : ‖a / b‖ < r
⊢ ↑n * ‖a / b‖ < n • r
tactic: refine lt_of_le_of_lt (norm_pow_le_mul_norm n (a / b)) ?_
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
hn : 0 < n
h : ‖a / b‖ < r
⊢ ↑n * ‖a / b‖ < n • r
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ < r
hn : 0 < ↑n
⊢ ↑n * ‖a / b‖ < n • r
tactic: replace hn : 0 < (n : ℝ) := by norm_cast
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ < r
hn : 0 < ↑n
⊢ ↑n * ‖a / b‖ < n • r
state_after: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ < r
hn : 0 < ↑n
⊢ ↑n * ‖a / b‖ < ↑n * r
tactic: rw [nsmul_eq_mul]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
n : ℕ
h : ‖a / b‖ < r
hn : 0 < ↑n
⊢ ↑n * ‖a / b‖ < ↑n * r
state_after: no goals
tactic: nlinarith
Theorem: List.sections_eq_nil_of_isEmpty
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: α : Type u_1
l : List α
L : List (List α)
h : (l :: L).any isEmpty = true
⊢ (l :: L).sections = []
state_after: α : Type u_1
l : List α
L : List (List α)
h : l.isEmpty = true ∨ L.any isEmpty = true
⊢ (l :: L).sections = []
tactic: simp only [any, foldr, Bool.or_eq_true] at h
state_before: α : Type u_1
l : List α
L : List (List α)
h : l.isEmpty = true ∨ L.any isEmpty = true
⊢ (l :: L).sections = []
state_after: no goals
tactic: match l, h with
    | [], .inl rfl => simp; induction sections L <;> simp [*]
    | l, .inr h => simp [sections, sections_eq_nil_of_isEmpty h]
Theorem: strictMono_mersenne
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: m n : ℕ
h : m < n
⊢ 2 ^ m < 2 ^ n
state_after: case h
m n : ℕ
h : m < n
⊢ 1 < 2
tactic: gcongr
state_before: case h
m n : ℕ
h : m < n
⊢ 1 < 2
state_after: no goals
tactic: norm_num1
Theorem: CategoryTheory.Limits.pullback.mapDesc_comp
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
W X✝ Y✝ Z X Y S T S' : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
i' : S ⟶ S'
inst✝³ : HasPullback f g
inst✝² : HasPullback (f ≫ i) (g ≫ i)
inst✝¹ : HasPullback (f ≫ i ≫ i') (g ≫ i ≫ i')
inst✝ : HasPullback ((f ≫ i) ≫ i') ((g ≫ i) ≫ i')
⊢ mapDesc f g (i ≫ i') = mapDesc f g i ≫ mapDesc (f ≫ i) (g ≫ i) i' ≫ (congrHom ⋯ ⋯).hom
state_after: no goals
tactic: aesop_cat
Theorem: ZNum.cast_bit1
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
⊢ ↑(ZNum.bit1 0) = ↑0 + ↑0 + 1
state_after: no goals
tactic: simp [ZNum.bit1]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(pos p).bit1 = ↑(pos p) + ↑(pos p) + 1
state_after: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑p.bit1 = ↑p + ↑p + 1
tactic: rw [ZNum.bit1, cast_pos, cast_pos]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑p.bit1 = ↑p + ↑p + 1
state_after: no goals
tactic: rfl
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ ↑(neg p).bit1 = ↑(neg p) + ↑(neg p) + 1
state_after: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ -↑(Num.casesOn p.pred' 1 bit1) = -↑p + -↑p + 1
tactic: rw [ZNum.bit1, cast_neg, cast_neg]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
⊢ -↑(Num.casesOn p.pred' 1 bit1) = -↑p + -↑p + 1
state_after: case zero
α : Type u_1
inst✝ : AddGroupWithOne α
p : PosNum
e : p.pred' = Num.zero
ep : p = Num.zero.succ'
⊢ -↑(Num.casesOn Num.zero 1 bit1) = -↑p + -↑p + 1

case pos
α : Type u_1
inst✝ : AddGroupWithOne α
p a : PosNum
e : p.pred' = Num.pos a
ep : p = (Num.pos a).succ'
⊢ -↑(Num.casesOn (Num.pos a) 1 bit1) = -↑p + -↑p + 1
tactic: cases' e : pred' p with a <;>
      have ep : p = _ := (succ'_pred' p).symm.trans (congr_arg Num.succ' e)
Theorem: AddChar.zmod_char_ne_one_iff
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

Proof steps:
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
⊢ ψ ≠ 1 ↔ ψ 1 ≠ 1
state_after: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
⊢ (∃ x, ψ x ≠ 1) ↔ ψ 1 ≠ 1
tactic: rw [ne_one_iff]
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
⊢ (∃ x, ψ x ≠ 1) ↔ ψ 1 ≠ 1
state_after: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
⊢ (∃ x, ψ x ≠ 1) → ψ 1 ≠ 1
tactic: refine ⟨?_, fun h => ⟨_, h⟩⟩
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
⊢ (∃ x, ψ x ≠ 1) → ψ 1 ≠ 1
state_after: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
⊢ ψ 1 = 1 → ∀ (x : ZMod n), ψ x = 1
tactic: contrapose!
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
⊢ ψ 1 = 1 → ∀ (x : ZMod n), ψ x = 1
state_after: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
h₁ : ψ 1 = 1
a : ZMod n
⊢ ψ a = 1
tactic: rintro h₁ a
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
h₁ : ψ 1 = 1
a : ZMod n
⊢ ψ a = 1
state_after: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
h₁ : ψ 1 = 1
a : ZMod n
ha₁ : a = a.val • 1
⊢ ψ a = 1
tactic: have ha₁ : a = a.val • (1 : ZMod ↑n) := by
    rw [nsmul_eq_mul, mul_one]; exact (ZMod.natCast_zmod_val a).symm
state_before: R : Type u
inst✝³ : CommRing R
R' : Type v
inst✝² : CommMonoid R'
C : Type v
inst✝¹ : CommMonoid C
n : ℕ
inst✝ : NeZero n
ψ : AddChar (ZMod n) C
h₁ : ψ 1 = 1
a : ZMod n
ha₁ : a = a.val • 1
⊢ ψ a = 1
state_after: no goals
tactic: rw [ha₁, map_nsmul_eq_pow, h₁, one_pow]
Theorem: Set.inv_mem_centralizer
File: Mathlib/Algebra/Group/Center.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
inst✝ : Group M
a b : M
ha : a ∈ S.centralizer
g : M
hg : g ∈ S
⊢ g * a⁻¹ = a⁻¹ * g
state_after: no goals
tactic: rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
Theorem: SimplexCategory.eq_σ_of_epi
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

Proof steps:
state_before: n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
⊢ ∃ i, θ = σ i
state_after: case intro.intro
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ ∃ i, θ = σ i
tactic: rcases eq_σ_comp_of_not_injective θ (by
    by_contra h
    simpa using le_of_mono (mono_iff_injective.mpr h)) with ⟨i, θ', h⟩
state_before: case intro.intro
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ ∃ i, θ = σ i
state_after: case h
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ θ = σ i
tactic: use i
state_before: case h
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
⊢ θ = σ i
state_after: case h
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
this : Epi (σ i ≫ θ')
⊢ θ = σ i
tactic: haveI : Epi (σ i ≫ θ') := by
    rw [← h]
    infer_instance
state_before: case h
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
this : Epi (σ i ≫ θ')
⊢ θ = σ i
state_after: case h
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
this✝ : Epi (σ i ≫ θ')
this : Epi θ'
⊢ θ = σ i
tactic: haveI := CategoryTheory.epi_of_epi (σ i) θ'
state_before: case h
n : ℕ
θ : [n + 1] ⟶ [n]
inst✝ : Epi θ
i : Fin (n + 1)
θ' : [n] ⟶ [n]
h : θ = σ i ≫ θ'
this✝ : Epi (σ i ≫ θ')
this : Epi θ'
⊢ θ = σ i
state_after: no goals
tactic: rw [h, eq_id_of_epi θ', Category.comp_id]
Theorem: Polynomial.Gal.splits_in_splittingField_of_comp
File: Mathlib/FieldTheory/PolynomialGaloisGroup.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
⊢ Splits (algebraMap F (p.comp q).SplittingField) p
state_after: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
P : F[X] → Prop := fun r => Splits (algebraMap F (r.comp q).SplittingField) r
⊢ Splits (algebraMap F (p.comp q).SplittingField) p
tactic: let P : F[X] → Prop := fun r => r.Splits (algebraMap F (r.comp q).SplittingField)
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
hq : q.natDegree ≠ 0
P : F[X] → Prop := fun r => Splits (algebraMap F (r.comp q).SplittingField) r
key1 : ∀ {r : F[X]}, Irreducible r → P r
key2 : ∀ {p₁ p₂ : F[X]}, P p₁ → P p₂ → P (p₁ * p₂)
⊢ Splits (algebraMap F (p.comp q).SplittingField) p
state_after: no goals
tactic: induction p using WfDvdMonoid.induction_on_irreducible with
  | h0 => exact splits_zero _
  | hu u hu => exact splits_of_isUnit (algebraMap F (SplittingField (comp u q))) hu
  -- Porting note: using `exact` instead of `apply` times out
  | hi p₁ p₂ _ hp₂ hp₁ => apply key2 (key1 hp₂) hp₁
Theorem: ProbabilityTheory.gaussianReal_absolutelyContinuous
File: Mathlib/Probability/Distributions/Gaussian.lean

Proof steps:
state_before: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ gaussianReal μ v ≪ ℙ
state_after: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ ℙ.withDensity (gaussianPDF μ v) ≪ ℙ
tactic: rw [gaussianReal_of_var_ne_zero _ hv]
state_before: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ ℙ.withDensity (gaussianPDF μ v) ≪ ℙ
state_after: no goals
tactic: exact withDensity_absolutelyContinuous _ _
Theorem: Finset.prod_le_one
File: Mathlib/Algebra/Order/BigOperators/Ring/Finset.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
inst✝³ : CommMonoidWithZero R
inst✝² : PartialOrder R
inst✝¹ : ZeroLEOneClass R
inst✝ : PosMulMono R
f g : ι → R
s t : Finset ι
h0 : ∀ i ∈ s, 0 ≤ f i
h1 : ∀ i ∈ s, f i ≤ 1
⊢ ∏ i ∈ s, f i ≤ 1
state_after: case h.e'_4
ι : Type u_1
R : Type u_2
inst✝³ : CommMonoidWithZero R
inst✝² : PartialOrder R
inst✝¹ : ZeroLEOneClass R
inst✝ : PosMulMono R
f g : ι → R
s t : Finset ι
h0 : ∀ i ∈ s, 0 ≤ f i
h1 : ∀ i ∈ s, f i ≤ 1
⊢ ∏ i ∈ s, 1 = 1
tactic: convert ← prod_le_prod h0 h1
state_before: case h.e'_4
ι : Type u_1
R : Type u_2
inst✝³ : CommMonoidWithZero R
inst✝² : PartialOrder R
inst✝¹ : ZeroLEOneClass R
inst✝ : PosMulMono R
f g : ι → R
s t : Finset ι
h0 : ∀ i ∈ s, 0 ≤ f i
h1 : ∀ i ∈ s, f i ≤ 1
⊢ ∏ i ∈ s, 1 = 1
state_after: no goals
tactic: exact Finset.prod_const_one