ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.Separable.of_dvd
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
f g : R[X]
hf : f.Separable
hfg : g ∣ f
⊢ g.Separable
state_after: case intro
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
g f' : R[X]
hf : (g * f').Separable
⊢ g.Separable
tactic: rcases hfg with ⟨f', rfl⟩
state_before: case intro
R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
g f' : R[X]
hf : (g * f').Separable
⊢ g.Separable
state_after: no goals
tactic: exact Separable.of_mul_left hf
Theorem: Real.sign_of_neg
File: Mathlib/Data/Real/Sign.lean

Proof steps:
state_before: r : ℝ
hr : r < 0
⊢ r.sign = -1
state_after: no goals
tactic: rw [sign, if_pos hr]
Theorem: Rat.classNumber_eq
File: Mathlib/NumberTheory/NumberField/ClassNumber.lean

Proof steps:
state_before: ⊢ IsPrincipalIdealRing (𝓞 ℚ)
state_after: no goals
tactic: convert IsPrincipalIdealRing.of_surjective
      (Rat.ringOfIntegersEquiv.symm : ℤ →+* 𝓞 ℚ) Rat.ringOfIntegersEquiv.symm.surjective
Theorem: CharP.quotient_iff
File: Mathlib/Algebra/CharP/Quotient.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
⊢ CharP (R ⧸ I) n ↔ ∀ (x : ℕ), ↑x ∈ I → ↑x = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
x✝ : CharP (R ⧸ I) n
x : ℕ
hx : ↑x ∈ I
⊢ ↑x = 0
tactic: refine ⟨fun _ x hx => ?_, CharP.quotient' n I⟩
state_before: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
x✝ : CharP (R ⧸ I) n
x : ℕ
hx : ↑x ∈ I
⊢ ↑x = 0
state_after: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
x✝ : CharP (R ⧸ I) n
x : ℕ
hx : ↑x ∈ I
⊢ n ∣ x
tactic: CharP.cast_eq_zero_iff R n,
state_before: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
x✝ : CharP (R ⧸ I) n
x : ℕ
hx : ↑x ∈ I
⊢ n ∣ x
state_after: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
x✝ : CharP (R ⧸ I) n
x : ℕ
hx : ↑x ∈ I
⊢ ↑x = 0
tactic: ← CharP.cast_eq_zero_iff (R ⧸ I) n _
state_before: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
x✝ : CharP (R ⧸ I) n
x : ℕ
hx : ↑x ∈ I
⊢ ↑x = 0
state_after: no goals
tactic: exact (Submodule.Quotient.mk_eq_zero I).mpr hx
Theorem: Filter.tendsto_div_const_iff
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Div G✝
inst✝³ : ContinuousDiv G✝
G : Type u_1
inst✝² : CommGroupWithZero G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousDiv G
b : G
hb : b ≠ 0
c : G
f : α → G
l : Filter α
⊢ Tendsto (fun x => f x / b) l (𝓝 (c / b)) ↔ Tendsto f l (𝓝 c)
state_after: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Div G✝
inst✝³ : ContinuousDiv G✝
G : Type u_1
inst✝² : CommGroupWithZero G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousDiv G
b : G
hb : b ≠ 0
c : G
f : α → G
l : Filter α
h : Tendsto (fun x => f x / b) l (𝓝 (c / b))
⊢ Tendsto f l (𝓝 c)
tactic: refine ⟨fun h ↦ ?_, fun h ↦ Filter.Tendsto.div_const' h b⟩
state_before: G✝ : Type w
H : Type x
α : Type u
β : Type v
inst✝⁵ : TopologicalSpace G✝
inst✝⁴ : Div G✝
inst✝³ : ContinuousDiv G✝
G : Type u_1
inst✝² : CommGroupWithZero G
inst✝¹ : TopologicalSpace G
inst✝ : ContinuousDiv G
b : G
hb : b ≠ 0
c : G
f : α → G
l : Filter α
h : Tendsto (fun x => f x / b) l (𝓝 (c / b))
⊢ Tendsto f l (𝓝 c)
state_after: no goals
tactic: convert h.div_const' b⁻¹ with k <;> rw [div_div, mul_inv_cancel hb, div_one]
Theorem: CategoryTheory.ShortComplex.leftRightHomologyComparison'_eq_liftH
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
h₁ : S.LeftHomologyData
h₂ : S.RightHomologyData
⊢ h₁.f' ≫ h₁.i ≫ h₂.p = 0
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁✝ : S₁.HomologyData
h₂✝ : S₂.HomologyData
h₁ : S.LeftHomologyData
h₂ : S.RightHomologyData
⊢ h₁.descH (h₁.i ≫ h₂.p) ⋯ ≫ h₂.g' = 0
state_after: no goals
tactic: rw [← cancel_epi h₁.π, LeftHomologyData.π_descH_assoc, assoc,
          RightHomologyData.p_g', LeftHomologyData.wi, comp_zero]
Theorem: Real.rpow_add_nat'
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
h : y + ↑n ≠ 0
⊢ x ^ (y + ↑n) = x ^ y * x ^ n
state_after: no goals
tactic: rw [rpow_add' hx h, rpow_natCast]
Theorem: Filter.Eventually.and_frequently
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p q : α → Prop
f : Filter α
hp : ∀ᶠ (x : α) in f, p x
hq : ∃ᶠ (x : α) in f, q x
⊢ ∃ᶠ (x : α) in f, p x ∧ q x
state_after: no goals
tactic: simpa only [and_comm] using hq.and_eventually hp
Theorem: List.sorted_ofFn_iff
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: n : ℕ
α : Type u
f : Fin n → α
r : α → α → Prop
⊢ Sorted r (ofFn f) ↔ ((fun x x_1 => x < x_1) ⇒ r) f f
state_after: n : ℕ
α : Type u
f : Fin n → α
r : α → α → Prop
⊢ (∀ (i j : Fin (ofFn f).length), i < j → r (f (Fin.cast ⋯ i)) (f (Fin.cast ⋯ j))) ↔
    ∀ ⦃a b : Fin n⦄, a < b → r (f a) (f b)
tactic: simp_rw [Sorted, pairwise_iff_get, get_ofFn, Relator.LiftFun]
state_before: n : ℕ
α : Type u
f : Fin n → α
r : α → α → Prop
⊢ (∀ (i j : Fin (ofFn f).length), i < j → r (f (Fin.cast ⋯ i)) (f (Fin.cast ⋯ j))) ↔
    ∀ ⦃a b : Fin n⦄, a < b → r (f a) (f b)
state_after: no goals
tactic: exact Iff.symm (Fin.rightInverse_cast _).surjective.forall₂
Theorem: Multiset.noncommSum_eq_sum
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
f : α✝ → β → β
op : α✝ → α✝ → α✝
inst✝³ : Monoid α✝
inst✝² : Monoid β
inst✝¹ : FunLike F α✝ β
α : Type u_6
inst✝ : CommMonoid α
s : Multiset α
⊢ s.noncommProd ⋯ = s.prod
state_after: case h
F : Type u_1
ι : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
f : α✝ → β → β
op : α✝ → α✝ → α✝
inst✝³ : Monoid α✝
inst✝² : Monoid β
inst✝¹ : FunLike F α✝ β
α : Type u_6
inst✝ : CommMonoid α
a✝ : List α
⊢ noncommProd ⟦a✝⟧ ⋯ = prod ⟦a✝⟧
tactic: induction s using Quotient.inductionOn
state_before: case h
F : Type u_1
ι : Type u_2
α✝ : Type u_3
β : Type u_4
γ : Type u_5
f : α✝ → β → β
op : α✝ → α✝ → α✝
inst✝³ : Monoid α✝
inst✝² : Monoid β
inst✝¹ : FunLike F α✝ β
α : Type u_6
inst✝ : CommMonoid α
a✝ : List α
⊢ noncommProd ⟦a✝⟧ ⋯ = prod ⟦a✝⟧
state_after: no goals
tactic: simp
Theorem: Ordinal.nmul_nadd_lt₃'
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c d a' b' c' : Ordinal.{u}
ha : a' < a
hb : b' < b
hc : c' < c
⊢ a' ⨳ (b ⨳ c) ♯ a ⨳ (b' ⨳ c) ♯ a ⨳ (b ⨳ c') ♯ a' ⨳ (b' ⨳ c') <
    a ⨳ (b ⨳ c) ♯ a' ⨳ (b' ⨳ c) ♯ a' ⨳ (b ⨳ c') ♯ a ⨳ (b' ⨳ c')
state_after: a b c d a' b' c' : Ordinal.{u}
ha : a' < a
hb : b' < b
hc : c' < c
⊢ b ⨳ c ⨳ a' ♯ b' ⨳ c ⨳ a ♯ b ⨳ c' ⨳ a ♯ b' ⨳ c' ⨳ a' < b ⨳ c ⨳ a ♯ b' ⨳ c ⨳ a' ♯ b ⨳ c' ⨳ a' ♯ b' ⨳ c' ⨳ a
tactic: simp only [nmul_comm _ (_ ⨳ _)]
Theorem: BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

Proof steps:
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
⊢ ∀ᶠ (t : Finset (ι × ℝ)) in atTop, π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.iUnion
state_after: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
t : Finset (ι × ℝ)
ht : ∀ (I_1 J : Box ι), J ∈ π.boxes → ∀ J' ∈ splitMany I_1 t, ¬Disjoint ↑J ↑J' → J' ≤ J
⊢ π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.iUnion
tactic: refine (eventually_not_disjoint_imp_le_of_mem_splitMany π.boxes).mono fun t ht => ?_
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I J : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
t : Finset (ι × ℝ)
ht : ∀ (I_1 J : Box ι), J ∈ π.boxes → ∀ J' ∈ splitMany I_1 t, ¬Disjoint ↑J ↑J' → J' ≤ J
⊢ π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.iUnion
state_after: case refine_1
ι : Type u_1
M : Type u_2
n : ℕ
I J✝ : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
t : Finset (ι × ℝ)
ht : ∀ (I_1 J : Box ι), J ∈ π.boxes → ∀ J' ∈ splitMany I_1 t, ¬Disjoint ↑J ↑J' → J' ≤ J
J : Box ι
hJ : J ∈ π
⊢ (splitMany I t).restrict J ≤ ((splitMany I t).filter fun J => ↑J ⊆ π.iUnion).restrict J

case refine_2
ι : Type u_1
M : Type u_2
n : ℕ
I J✝ : Box ι
i : ι
x : ℝ
inst✝ : Finite ι
π : Prepartition I
t : Finset (ι × ℝ)
ht : ∀ (I_1 J : Box ι), J ∈ π.boxes → ∀ J' ∈ splitMany I_1 t, ¬Disjoint ↑J ↑J' → J' ≤ J
J : Box ι
hJ : J ∈ (splitMany I t).filter fun J => ↑J ⊆ π.iUnion
⊢ ∃ I' ∈ π, J ≤ I'
tactic: refine le_antisymm ((biUnion_le_iff _).2 fun J hJ => ?_) (le_inf (fun J hJ => ?_) (filter_le _ _))
Theorem: Rat.add_assoc
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ n₁ /. ↑d₁ + n₂ /. ↑d₂ + n₃ /. ↑d₃ = n₁ /. ↑d₁ + (n₂ /. ↑d₂ + n₃ /. ↑d₃)
state_after: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ ((n₁ * ↑d₂ + n₂ * ↑d₁) * ↑d₃ + n₃ * (↑d₁ * ↑d₂)) /. (↑d₁ * ↑d₂ * ↑d₃) =
    (n₁ * (↑d₂ * ↑d₃) + (n₂ * ↑d₃ + n₃ * ↑d₂) * ↑d₁) /. (↑d₁ * (↑d₂ * ↑d₃))
tactic: simp only [ne_eq, Int.natCast_eq_zero, h₁, not_false_eq_true, h₂, divInt_add_divInt,
      Int.mul_eq_zero, or_self, h₃]
state_before: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ ((n₁ * ↑d₂ + n₂ * ↑d₁) * ↑d₃ + n₃ * (↑d₁ * ↑d₂)) /. (↑d₁ * ↑d₂ * ↑d₃) =
    (n₁ * (↑d₂ * ↑d₃) + (n₂ * ↑d₃ + n₃ * ↑d₂) * ↑d₁) /. (↑d₁ * (↑d₂ * ↑d₃))
state_after: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * (↑d₂ * ↑d₃) + (n₂ * ↑d₁ * ↑d₃ + n₃ * (↑d₁ * ↑d₂))) /. (↑d₁ * (↑d₂ * ↑d₃)) =
    (n₁ * (↑d₂ * ↑d₃) + (n₂ * ↑d₃ * ↑d₁ + n₃ * ↑d₂ * ↑d₁)) /. (↑d₁ * (↑d₂ * ↑d₃))
tactic: rw [Int.mul_assoc, Int.add_mul, Int.add_mul, Int.mul_assoc, Int.add_assoc]
state_before: q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ (n₁ * (↑d₂ * ↑d₃) + (n₂ * ↑d₁ * ↑d₃ + n₃ * (↑d₁ * ↑d₂))) /. (↑d₁ * (↑d₂ * ↑d₃)) =
    (n₁ * (↑d₂ * ↑d₃) + (n₂ * ↑d₃ * ↑d₁ + n₃ * ↑d₂ * ↑d₁)) /. (↑d₁ * (↑d₂ * ↑d₃))
state_after: case e_a.e_a
q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ n₂ * ↑d₁ * ↑d₃ + n₃ * (↑d₁ * ↑d₂) = n₂ * ↑d₃ * ↑d₁ + n₃ * ↑d₂ * ↑d₁
tactic: congr 2
state_before: case e_a.e_a
q a b c : ℚ
n₁ : ℤ
d₁ : ℕ
h₁ : d₁ ≠ 0
n₂ : ℤ
d₂ : ℕ
h₂ : d₂ ≠ 0
n₃ : ℤ
d₃ : ℕ
h₃ : d₃ ≠ 0
⊢ n₂ * ↑d₁ * ↑d₃ + n₃ * (↑d₁ * ↑d₂) = n₂ * ↑d₃ * ↑d₁ + n₃ * ↑d₂ * ↑d₁
state_after: no goals
tactic: ac_rfl
Theorem: SimpleGraph.edgeDensity_add_edgeDensity_compl
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
s s₁ s₂ t t₁ t₂ : Finset α
a b : α
inst✝ : DecidableEq α
hs : s.Nonempty
ht : t.Nonempty
h : Disjoint s t
⊢ G.edgeDensity s t + Gᶜ.edgeDensity s t = 1
state_after: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
s s₁ s₂ t t₁ t₂ : Finset α
a b : α
inst✝ : DecidableEq α
hs : s.Nonempty
ht : t.Nonempty
h : Disjoint s t
⊢ ↑(G.interedges s t).card + ↑(Gᶜ.interedges s t).card = ↑s.card * ↑t.card

𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
G : SimpleGraph α
inst✝¹ : DecidableRel G.Adj
s s₁ s₂ t t₁ t₂ : Finset α
a b : α
inst✝ : DecidableEq α
hs : s.Nonempty
ht : t.Nonempty
h : Disjoint s t
⊢ ↑s.card * ↑t.card ≠ 0
tactic: rw [edgeDensity_def, edgeDensity_def, div_add_div_same, div_eq_one_iff_eq]
Theorem: Bool.and_le_left
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ∀ (x y : Bool), (x && y) ≤ x
state_after: no goals
tactic: decide
Theorem: SlashAction.smul_slash_of_tower
File: Mathlib/NumberTheory/ModularForms/SlashActions.lean

Proof steps:
state_before: R : Type u_1
β : Type u_2
G : Type u_3
α : Type u_4
γ : Type u_5
inst✝⁷ : Group G
inst✝⁶ : AddGroup α
inst✝⁵ : Monoid γ
inst✝⁴ : MulAction γ α
inst✝³ : SMul R γ
inst✝² : SMul R α
inst✝¹ : IsScalarTower R γ α
inst✝ : SlashAction β G α γ
k : β
g : G
a : α
r : R
⊢ (r • a) ∣[k;γ] g = r • a ∣[k;γ] g
state_after: no goals
tactic: rw [← smul_one_smul γ r a, SlashAction.smul_slash, smul_one_smul]
Theorem: monovaryOn_iff_mul_rearrangement
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedRing α
f g : ι → α
s : Set ι
a b c d : α
⊢ MonovaryOn f g s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃j : ι⦄, j ∈ s → f i * g j + f j * g i ≤ f i * g i + f j * g j
state_after: no goals
tactic: simp only [smul_eq_mul, monovaryOn_iff_smul_rearrangement]
Theorem: Polynomial.natDegree_sub
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Ring R
p q : R[X]
⊢ (p - q).natDegree = (q - p).natDegree
state_after: no goals
tactic: rw [← natDegree_neg, neg_sub]
Theorem: IsLowerSet.disjoint_upperClosure_right
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
hs : IsLowerSet s
⊢ Disjoint s ↑(upperClosure t) ↔ Disjoint s t
state_after: no goals
tactic: simpa only [disjoint_comm] using hs.disjoint_upperClosure_left
Theorem: Representation.asAlgebraHom_single
File: Mathlib/RepresentationTheory/Basic.lean

Proof steps:
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
r : k
⊢ ρ.asAlgebraHom (Finsupp.single g r) = r • ρ g
state_after: no goals
tactic: simp only [asAlgebraHom_def, MonoidAlgebra.lift_single]
Theorem: MvPFunctor.supp_eq
File: Mathlib/Data/PFunctor/Multivariate/Basic.lean

Proof steps:
state_before: n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
a : P.A
f : P.B a ⟹ α
i : Fin2 n
⊢ supp ⟨a, f⟩ i = f i '' univ
state_after: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
a : P.A
f : P.B a ⟹ α
i : Fin2 n
x : α i
⊢ x ∈ supp ⟨a, f⟩ i ↔ x ∈ f i '' univ
tactic: ext x
state_before: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
a : P.A
f : P.B a ⟹ α
i : Fin2 n
x : α i
⊢ x ∈ supp ⟨a, f⟩ i ↔ x ∈ f i '' univ
state_after: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
a : P.A
f : P.B a ⟹ α
i : Fin2 n
x : α i
⊢ (∀ ⦃P_1 : (i : Fin2 n) → α i → Prop⦄, LiftP P_1 ⟨a, f⟩ → P_1 i x) ↔ ∃ y, f i y = x
tactic: simp only [supp, image_univ, mem_range, mem_setOf_eq]
state_before: case h
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
a : P.A
f : P.B a ⟹ α
i : Fin2 n
x : α i
⊢ (∀ ⦃P_1 : (i : Fin2 n) → α i → Prop⦄, LiftP P_1 ⟨a, f⟩ → P_1 i x) ↔ ∃ y, f i y = x
state_after: case h.mp
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
a : P.A
f : P.B a ⟹ α
i : Fin2 n
x : α i
h : ∀ ⦃P_1 : (i : Fin2 n) → α i → Prop⦄, LiftP P_1 ⟨a, f⟩ → P_1 i x
⊢ ∃ y, f i y = x

case h.mpr
n m : ℕ
P : MvPFunctor.{u} n
Q : Fin2 n → MvPFunctor.{u} m
α✝ β : TypeVec.{u} m
α : TypeVec.{u} n
a : P.A
f : P.B a ⟹ α
i : Fin2 n
x : α i
h : ∃ y, f i y = x
⊢ ∀ ⦃P_1 : (i : Fin2 n) → α i → Prop⦄, LiftP P_1 ⟨a, f⟩ → P_1 i x
tactic: constructor <;> intro h
Theorem: CategoryTheory.Limits.Concrete.pullbackMk_surjective
File: Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
X₁ X₂ S : C
f₁ : X₁ ⟶ S
f₂ : X₂ ⟶ S
inst✝¹ : HasPullback f₁ f₂
inst✝ : PreservesLimit (cospan f₁ f₂) (forget C)
x : (forget C).obj (pullback f₁ f₂)
⊢ ∃ x₁ x₂, ∃ (h : f₁ x₁ = f₂ x₂), x = pullbackMk f₁ f₂ x₁ x₂ h
state_after: case intro.mk.mk
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
X₁ X₂ S : C
f₁ : X₁ ⟶ S
f₂ : X₂ ⟶ S
inst✝¹ : HasPullback f₁ f₂
inst✝ : PreservesLimit (cospan f₁ f₂) (forget C)
x₁ : (forget C).obj X₁
x₂ : (forget C).obj X₂
h : f₁ (x₁, x₂).1 = f₂ (x₁, x₂).2
⊢ ∃ x₁_1 x₂_1, ∃ (h_1 : f₁ x₁_1 = f₂ x₂_1), (pullbackEquiv f₁ f₂).symm ⟨(x₁, x₂), h⟩ = pullbackMk f₁ f₂ x₁_1 x₂_1 h_1
tactic: obtain ⟨⟨⟨x₁, x₂⟩, h⟩, rfl⟩ := (pullbackEquiv f₁ f₂).symm.surjective x
state_before: case intro.mk.mk
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
X₁ X₂ S : C
f₁ : X₁ ⟶ S
f₂ : X₂ ⟶ S
inst✝¹ : HasPullback f₁ f₂
inst✝ : PreservesLimit (cospan f₁ f₂) (forget C)
x₁ : (forget C).obj X₁
x₂ : (forget C).obj X₂
h : f₁ (x₁, x₂).1 = f₂ (x₁, x₂).2
⊢ ∃ x₁_1 x₂_1, ∃ (h_1 : f₁ x₁_1 = f₂ x₂_1), (pullbackEquiv f₁ f₂).symm ⟨(x₁, x₂), h⟩ = pullbackMk f₁ f₂ x₁_1 x₂_1 h_1
state_after: no goals
tactic: exact ⟨x₁, x₂, h, rfl⟩
Theorem: Continuous.exists_forall_le
File: Mathlib/Topology/Algebra/Order/Compact.lean

Proof steps:
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty β
f : β → α
hf : Continuous f
hlim : Tendsto f (cocompact β) atTop
⊢ ∃ x, ∀ (y : β), f x ≤ f y
state_after: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty β
f : β → α
hf : Continuous f
hlim : Tendsto f (cocompact β) atTop
inhabited_h : Inhabited β
⊢ ∃ x, ∀ (y : β), f x ≤ f y
tactic: inhabit β
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty β
f : β → α
hf : Continuous f
hlim : Tendsto f (cocompact β) atTop
inhabited_h : Inhabited β
⊢ ∃ x, ∀ (y : β), f x ≤ f y
state_after: no goals
tactic: exact hf.exists_forall_le' default (hlim.eventually <| eventually_ge_atTop _)
Theorem: Finset.dens_filter_add_dens_filter_not_eq_dens
File: Mathlib/Data/Finset/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : Fintype α
s t : Finset α
a b : α
inst✝² : DecidableEq α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : (x : α) → Decidable ¬p x
⊢ (filter p s).dens + (filter (fun a => ¬p a) s).dens = s.dens
state_after: no goals
tactic: rw [← dens_union_of_disjoint (disjoint_filter_filter_neg ..), filter_union_filter_neg_eq]
Theorem: Multiset.countP_nsmul
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝ : DecidablePred p
s : Multiset α
n : ℕ
⊢ countP p (n • s) = n * countP p s
state_after: no goals
tactic: induction n <;> simp [*, succ_nsmul, succ_mul, zero_nsmul]
Theorem: IsLocalization.isDomain_of_le_nonZeroDivisors
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁰ : CommRing R
M✝ : Submonoid R
S : Type u_2
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Type u_3
inst✝⁷ : CommRing P
K : Type u_4
inst✝⁶ : IsLocalization M✝ S
Q : Type u_5
inst✝⁵ : CommRing Q
g : R →+* P
inst✝⁴ : Algebra P Q
A : Type u_6
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra A S
M : Submonoid A
inst✝ : IsLocalization M S
hM : M ≤ nonZeroDivisors A
⊢ IsDomain S
state_after: R : Type u_1
inst✝¹⁰ : CommRing R
M✝ : Submonoid R
S : Type u_2
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Type u_3
inst✝⁷ : CommRing P
K : Type u_4
inst✝⁶ : IsLocalization M✝ S
Q : Type u_5
inst✝⁵ : CommRing Q
g : R →+* P
inst✝⁴ : Algebra P Q
A : Type u_6
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra A S
M : Submonoid A
inst✝ : IsLocalization M S
hM : M ≤ nonZeroDivisors A
⊢ Nontrivial S

R : Type u_1
inst✝¹⁰ : CommRing R
M✝ : Submonoid R
S : Type u_2
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Type u_3
inst✝⁷ : CommRing P
K : Type u_4
inst✝⁶ : IsLocalization M✝ S
Q : Type u_5
inst✝⁵ : CommRing Q
g : R →+* P
inst✝⁴ : Algebra P Q
A : Type u_6
inst✝³ : CommRing A
inst✝² : IsDomain A
inst✝¹ : Algebra A S
M : Submonoid A
inst✝ : IsLocalization M S
hM : M ≤ nonZeroDivisors A
⊢ NoZeroDivisors S
tactic: apply @NoZeroDivisors.to_isDomain _ _ (id _) (id _)
Theorem: EisensteinSeries.div_max_sq_ge_one
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

Proof steps:
state_before: z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
⊢ 1 ≤ (↑(x 0) / ‖x‖) ^ 2 ∨ 1 ≤ (↑(x 1) / ‖x‖) ^ 2
state_after: case refine_1
z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
H0 : max (x 0).natAbs (x 1).natAbs = (x 0).natAbs
⊢ 1 ≤ (↑(x 0) / ‖x‖) ^ 2

case refine_2
z : ℍ
x : Fin 2 → ℤ
hx : x ≠ 0
H1 : max (x 0).natAbs (x 1).natAbs = (x 1).natAbs
⊢ 1 ≤ (↑(x 1) / ‖x‖) ^ 2
tactic: refine (max_choice (x 0).natAbs (x 1).natAbs).imp (fun H0 ↦ ?_) (fun H1 ↦ ?_)
Theorem: Cycle.nontrivial_coe_nodup_iff
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
l : List α
hl : l.Nodup
⊢ (↑l).Nontrivial ↔ 2 ≤ l.length
state_after: α : Type u_1
l : List α
hl : l.Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑l ∧ y ∈ ↑l) ↔ 2 ≤ l.length
tactic: rw [Nontrivial]
state_before: α : Type u_1
l : List α
hl : l.Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑l ∧ y ∈ ↑l) ↔ 2 ≤ l.length
state_after: case nil
α : Type u_1
hl : [].Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑[] ∧ y ∈ ↑[]) ↔ 2 ≤ [].length

case cons.nil
α : Type u_1
hd : α
hl : [hd].Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑[hd] ∧ y ∈ ↑[hd]) ↔ 2 ≤ [hd].length

case cons.cons
α : Type u_1
hd hd' : α
tl : List α
hl : (hd :: hd' :: tl).Nodup
⊢ (∃ x y, x ≠ y ∧ x ∈ ↑(hd :: hd' :: tl) ∧ y ∈ ↑(hd :: hd' :: tl)) ↔ 2 ≤ (hd :: hd' :: tl).length
tactic: rcases l with (_ | ⟨hd, _ | ⟨hd', tl⟩⟩)
Theorem: Asymptotics.isBigO_atTop_iff_eventually_exists
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 α✝
α : Type u_17
inst✝¹ : SemilatticeSup α
inst✝ : Nonempty α
f : α → E
g : α → F
⊢ f =O[atTop] g ↔ ∀ᶠ (n₀ : α) in atTop, ∃ c, ∀ n ≥ n₀, ‖f n‖ ≤ c * ‖g n‖
state_after: no goals
tactic: rw [isBigO_iff, exists_eventually_atTop]
Theorem: RatFunc.liftOn_div
File: Mathlib/FieldTheory/RatFunc/Basic.lean

Proof steps:
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
P : Sort v
p q : K[X]
f : K[X] → K[X] → P
f0 : ∀ (p : K[X]), f p 0 = f 0 1
H' : ∀ {p q p' q' : K[X]}, q ≠ 0 → q' ≠ 0 → q' * p = q * p' → f p q = f p' q'
H : optParam (∀ {p q p' q' : K[X]}, q ∈ K[X]⁰ → q' ∈ K[X]⁰ → q' * p = q * p' → f p q = f p' q') ⋯
⊢ ((algebraMap K[X] (RatFunc K)) p / (algebraMap K[X] (RatFunc K)) q).liftOn f H = f p q
state_after: no goals
tactic: rw [← mk_eq_div, liftOn_mk _ _ f f0 @H']