ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ideal.IsPrime.mul_mem_iff_mem_or_mem
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I✝ I : Ideal α
hI : I.IsPrime
x y : α
⊢ x ∈ I ∨ y ∈ I → x * y ∈ I
state_after: case inl
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I✝ I : Ideal α
hI : I.IsPrime
x y : α
h : x ∈ I
⊢ x * y ∈ I

case inr
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I✝ I : Ideal α
hI : I.IsPrime
x y : α
h : y ∈ I
⊢ x * y ∈ I
tactic: rintro (h | h)
state_before: case inl
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I✝ I : Ideal α
hI : I.IsPrime
x y : α
h : x ∈ I
⊢ x * y ∈ I

case inr
α : Type u
β : Type v
a b : α
inst✝ : CommSemiring α
I✝ I : Ideal α
hI : I.IsPrime
x y : α
h : y ∈ I
⊢ x * y ∈ I
state_after: no goals
tactic: exacts [I.mul_mem_right y h, I.mul_mem_left x h]
Theorem: Polynomial.Chebyshev.T_sub_one
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ T R (n - 1) = 2 * X * T R n - T R (n + 1)
state_after: no goals
tactic: linear_combination (norm := ring_nf) T_add_two R (n - 1)
Theorem: Multiset.replicate_inter
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
n : ℕ
x : α
s : Multiset α
⊢ replicate n x ∩ s = replicate (min n (count x s)) x
state_after: case a
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
n : ℕ
x : α
s : Multiset α
y : α
⊢ count y (replicate n x ∩ s) = count y (replicate (min n (count x s)) x)
tactic: ext y
state_before: case a
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
n : ℕ
x : α
s : Multiset α
y : α
⊢ count y (replicate n x ∩ s) = count y (replicate (min n (count x s)) x)
state_after: case a
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
n : ℕ
x : α
s : Multiset α
y : α
⊢ min (if y = x then n else 0) (count y s) = if y = x then min n (count x s) else 0
tactic: rw [count_inter, count_replicate, count_replicate]
state_before: case a
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
n : ℕ
x : α
s : Multiset α
y : α
⊢ min (if y = x then n else 0) (count y s) = if y = x then min n (count x s) else 0
state_after: case pos
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
n : ℕ
x : α
s : Multiset α
y : α
h : y = x
⊢ min (if y = x then n else 0) (count y s) = if y = x then min n (count x s) else 0

case neg
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
n : ℕ
x : α
s : Multiset α
y : α
h : ¬y = x
⊢ min (if y = x then n else 0) (count y s) = if y = x then min n (count x s) else 0
tactic: by_cases h : y = x
Theorem: CategoryTheory.Limits.IsImage.isoExt_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF.lift F' ≫ hF'.lift F) ≫ F.m = 𝟙 F.I ≫ F.m
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : X ⟶ Y
F F' : MonoFactorisation f
hF : IsImage F
hF' : IsImage F'
⊢ (hF'.lift F ≫ hF.lift F') ≫ F'.m = 𝟙 F'.I ≫ F'.m
state_after: no goals
tactic: simp
Theorem: TopCat.Presheaf.germ_ext
File: Mathlib/Topology/Sheaves/Stalks.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimits C
X Y Z : TopCat
inst✝ : ConcreteCategory C
F : Presheaf C X
U V : Opens ↑X
x : ↑X
hxU : x ∈ U
hxV : x ∈ V
W : Opens ↑X
hxW : x ∈ W
iWU : W ⟶ U
iWV : W ⟶ V
sU : (forget C).obj (F.obj (op U))
sV : (forget C).obj (F.obj (op V))
ih : (F.map iWU.op) sU = (F.map iWV.op) sV
⊢ (F.germ ⟨x, hxU⟩) sU = (F.germ ⟨x, hxV⟩) sV
state_after: no goals
tactic: erw [← F.germ_res iWU ⟨x, hxW⟩, ← F.germ_res iWV ⟨x, hxW⟩, comp_apply, comp_apply, ih]
Theorem: CategoryTheory.FunctorToTypes.binaryCoproductEquiv_apply
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : (F ⨿ G).obj a
⊢ (fun z => (binaryCoproductIso F G).inv.app a z) ((fun z => (binaryCoproductIso F G).hom.app a z) x✝) = x✝
state_after: no goals
tactic: simp only [hom_inv_id_app_apply]
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x✝ : F.obj a ⊕ G.obj a
⊢ (fun z => (binaryCoproductIso F G).hom.app a z) ((fun z => (binaryCoproductIso F G).inv.app a z) x✝) = x✝
state_after: no goals
tactic: simp only [inv_hom_id_app_apply]
Theorem: Polynomial.ascPochhammer_smeval_eq_eval
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝ : Semiring R
r : R
n : ℕ
⊢ (ascPochhammer ℕ n).smeval r = eval r (ascPochhammer R n)
state_after: no goals
tactic: rw [eval_eq_smeval, ascPochhammer_smeval_cast R]
Theorem: CategoryTheory.Bicategory.rightZigzagIso_inv
File: Mathlib/CategoryTheory/Bicategory/Adjunction.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c : B
f : a ⟶ b
g : b ⟶ a
η : 𝟙 a ≅ f ≫ g
ε : g ≫ f ≅ 𝟙 b
⊢ (rightZigzagIso η ε).inv = leftZigzag ε.inv η.inv
state_after: no goals
tactic: simp [bicategoricalComp, bicategoricalIsoComp]
Theorem: Equiv.bijOn_swap
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
e : α ≃ β
s : Set α
t : Set β
inst✝ : DecidableEq α
a b : α
ha : a ∈ s
hb : b ∈ s
x : α
⊢ (swap a b) x ∈ s ↔ x ∈ s
state_after: no goals
tactic: obtain rfl | hxa := eq_or_ne x a <;>
    obtain rfl | hxb := eq_or_ne x b <;>
    simp [*, swap_apply_of_ne_of_ne]
Theorem: Finsupp.erase_update_of_ne
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a a' : α
ha : a ≠ a'
b : M
⊢ erase a (f.update a' b) = (erase a f).update a' b
state_after: no goals
tactic: rw [erase_eq_update_zero, erase_eq_update_zero, update_comm _ ha]
Theorem: Finset.add_sum_Ico_eq_sum_Icc
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝² : PartialOrder α
inst✝¹ : CommMonoid M
f : α → M
a b : α
inst✝ : LocallyFiniteOrder α
h : a ≤ b
⊢ f b * ∏ x ∈ Ico a b, f x = ∏ x ∈ Icc a b, f x
state_after: no goals
tactic: rw [Icc_eq_cons_Ico h, prod_cons]
Theorem: ArithmeticFunction.cardDistinctFactors_eq_cardFactors_iff_squarefree
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
n : ℕ
h0 : n ≠ 0
⊢ ω n = Ω n ↔ Squarefree n
state_after: R : Type u_1
n : ℕ
h0 : n ≠ 0
⊢ n.primeFactorsList.dedup.length = Ω n ↔ n.primeFactorsList.Nodup
tactic: rw [squarefree_iff_nodup_primeFactorsList h0, cardDistinctFactors_apply]
state_before: R : Type u_1
n : ℕ
h0 : n ≠ 0
⊢ n.primeFactorsList.dedup.length = Ω n ↔ n.primeFactorsList.Nodup
state_after: case mp
R : Type u_1
n : ℕ
h0 : n ≠ 0
h : n.primeFactorsList.dedup.length = Ω n
⊢ n.primeFactorsList.Nodup

case mpr
R : Type u_1
n : ℕ
h0 : n ≠ 0
h : n.primeFactorsList.Nodup
⊢ n.primeFactorsList.dedup.length = Ω n
tactic: constructor <;> intro h
Theorem: UniqueMul.mulHom_image_iff
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ⇑f
h : UniqueMul A B a0 b0
x✝¹ x✝ : H
⊢ x✝¹ ∈ Finset.image (⇑f) A → x✝ ∈ Finset.image (⇑f) B → x✝¹ * x✝ = f a0 * f b0 → x✝¹ = f a0 ∧ x✝ = f b0
state_after: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ⇑f
h : UniqueMul A B a0 b0
x✝¹ x✝ : H
⊢ (∃ a ∈ A, f a = x✝¹) → (∃ a ∈ B, f a = x✝) → x✝¹ * x✝ = f a0 * f b0 → x✝¹ = f a0 ∧ x✝ = f b0
tactic: simp_rw [Finset.mem_image]
state_before: G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ⇑f
h : UniqueMul A B a0 b0
x✝¹ x✝ : H
⊢ (∃ a ∈ A, f a = x✝¹) → (∃ a ∈ B, f a = x✝) → x✝¹ * x✝ = f a0 * f b0 → x✝¹ = f a0 ∧ x✝ = f b0
state_after: case intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ⇑f
h : UniqueMul A B a0 b0
a : G
aA : a ∈ A
b : G
bB : b ∈ B
ab : f a * f b = f a0 * f b0
⊢ f a = f a0 ∧ f b = f b0
tactic: rintro ⟨a, aA, rfl⟩ ⟨b, bB, rfl⟩ ab
state_before: case intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ⇑f
h : UniqueMul A B a0 b0
a : G
aA : a ∈ A
b : G
bB : b ∈ B
ab : f a * f b = f a0 * f b0
⊢ f a = f a0 ∧ f b = f b0
state_after: case intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ⇑f
h : UniqueMul A B a0 b0
a : G
aA : a ∈ A
b : G
bB : b ∈ B
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
tactic: simp_rw [← map_mul, hf.eq_iff] at ab ⊢
state_before: case intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ⇑f
h : UniqueMul A B a0 b0
a : G
aA : a ∈ A
b : G
bB : b ∈ B
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
state_after: no goals
tactic: exact h aA bB ab
Theorem: Real.inv_logb_div_base
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b✝ x y a b : ℝ
h₁ : a ≠ 0
h₂ : b ≠ 0
c : ℝ
⊢ (logb (a / b) c)⁻¹ = (logb a c)⁻¹ - (logb b c)⁻¹
state_after: b✝ x y a b : ℝ
h₁ : a ≠ 0
h₂ : b ≠ 0
c : ℝ
⊢ logb c (a / b) = logb c a - logb c b
tactic: simp_rw [inv_logb]
state_before: b✝ x y a b : ℝ
h₁ : a ≠ 0
h₂ : b ≠ 0
c : ℝ
⊢ logb c (a / b) = logb c a - logb c b
state_after: no goals
tactic: exact logb_div h₁ h₂
Theorem: CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ IsCoseparator G ↔ (preadditiveYoneda.obj G).Faithful
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveYoneda.obj G ⋙ forget AddCommGrp).Faithful ↔ (preadditiveYoneda.obj G).Faithful
tactic: rw [isCoseparator_iff_faithful_yoneda_obj, ← whiskering_preadditiveYoneda, Functor.comp_obj,
    whiskeringRight_obj_obj]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : Preadditive C
G : C
⊢ (preadditiveYoneda.obj G ⋙ forget AddCommGrp).Faithful ↔ (preadditiveYoneda.obj G).Faithful
state_after: no goals
tactic: exact ⟨fun h => Functor.Faithful.of_comp _ (forget AddCommGrp),
    fun h => Functor.Faithful.comp _ _⟩
Theorem: AlternatingMap.compLinearMap_zero
File: Mathlib/LinearAlgebra/Alternating/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁵ : Semiring R
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type u_11
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : M [⋀^ι]→ₗ[R] N
⊢ f.compLinearMap 0 = 0
state_after: case H
R : Type u_1
inst✝¹⁵ : Semiring R
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type u_11
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : M [⋀^ι]→ₗ[R] N
x✝ : ι → M₂
⊢ (f.compLinearMap 0) x✝ = 0 x✝
tactic: ext
state_before: case H
R : Type u_1
inst✝¹⁵ : Semiring R
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type u_11
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : M [⋀^ι]→ₗ[R] N
x✝ : ι → M₂
⊢ (f.compLinearMap 0) x✝ = 0 x✝
state_after: case H
R : Type u_1
inst✝¹⁵ : Semiring R
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type u_11
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : M [⋀^ι]→ₗ[R] N
x✝ : ι → M₂
⊢ f 0 = 0
tactic: simp_rw [compLinearMap_apply, LinearMap.zero_apply, ← Pi.zero_def, zero_apply]
state_before: case H
R : Type u_1
inst✝¹⁵ : Semiring R
M : Type u_2
inst✝¹⁴ : AddCommMonoid M
inst✝¹³ : Module R M
N : Type u_3
inst✝¹² : AddCommMonoid N
inst✝¹¹ : Module R N
P : Type u_4
inst✝¹⁰ : AddCommMonoid P
inst✝⁹ : Module R P
M' : Type u_5
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
N' : Type u_6
inst✝⁶ : AddCommGroup N'
inst✝⁵ : Module R N'
ι : Type u_7
ι' : Type u_8
ι'' : Type u_9
M₂ : Type u_10
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₂
M₃ : Type u_11
inst✝² : AddCommMonoid M₃
inst✝¹ : Module R M₃
inst✝ : Nonempty ι
f : M [⋀^ι]→ₗ[R] N
x✝ : ι → M₂
⊢ f 0 = 0
state_after: no goals
tactic: exact map_zero f
Theorem: AlgebraicGeometry.isIntegral_of_irreducibleSpace_of_isReduced
File: Mathlib/AlgebraicGeometry/Properties.lean

Proof steps:
state_before: X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ IsIntegral X
state_after: case nonempty
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ autoParam (Nonempty ↑↑X.toPresheafedSpace) _auto✝

case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ autoParam (∀ (U : X.Opens) [inst : Nonempty ↑↑(↑U).toPresheafedSpace], IsDomain ↑Γ(X, U)) _auto✝
tactic: constructor
state_before: case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ autoParam (∀ (U : X.Opens) [inst : Nonempty ↑↑(↑U).toPresheafedSpace], IsDomain ↑Γ(X, U)) _auto✝
state_after: case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : X.Opens
hU : Nonempty ↑↑(↑U).toPresheafedSpace
⊢ IsDomain ↑Γ(X, U)
tactic: intro U hU
state_before: case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : X.Opens
hU : Nonempty ↑↑(↑U).toPresheafedSpace
⊢ IsDomain ↑Γ(X, U)
state_after: case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : X.Opens
hU : Nonempty ↑↑(↑U).toPresheafedSpace
this : ∃ x y, x ≠ y
⊢ IsDomain ↑Γ(X, U)
tactic: haveI := (@LocallyRingedSpace.component_nontrivial X.toLocallyRingedSpace U hU).1
state_before: case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : X.Opens
hU : Nonempty ↑↑(↑U).toPresheafedSpace
this : ∃ x y, x ≠ y
⊢ IsDomain ↑Γ(X, U)
state_after: case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : X.Opens
hU : Nonempty ↑↑(↑U).toPresheafedSpace
this✝ : ∃ x y, x ≠ y
this : NoZeroDivisors ↑(X.presheaf.obj (op U))
⊢ IsDomain ↑Γ(X, U)
tactic: have : NoZeroDivisors
      (X.toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace.presheaf.obj (op U)) := by
    refine ⟨fun {a b} e => ?_⟩
    simp_rw [← basicOpen_eq_bot_iff, ← Opens.not_nonempty_iff_eq_bot]
    by_contra! h
    obtain ⟨_, ⟨x, hx₁, rfl⟩, ⟨x, hx₂, e'⟩⟩ :=
      nonempty_preirreducible_inter (X.basicOpen a).2 (X.basicOpen b).2 h.1 h.2
    replace e' := Subtype.eq e'
    subst e'
    replace e := congr_arg (X.presheaf.germ x) e
    rw [RingHom.map_mul, RingHom.map_zero] at e
    refine zero_ne_one' (X.presheaf.stalk x.1) (isUnit_zero_iff.1 ?_)
    convert hx₁.mul hx₂
    exact e.symm
state_before: case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : X.Opens
hU : Nonempty ↑↑(↑U).toPresheafedSpace
this✝ : ∃ x y, x ≠ y
this : NoZeroDivisors ↑(X.presheaf.obj (op U))
⊢ IsDomain ↑Γ(X, U)
state_after: no goals
tactic: exact NoZeroDivisors.to_isDomain _
Theorem: le_map_div_mul_map_div
File: Mathlib/Algebra/Order/Hom/Basic.lean

Proof steps:
state_before: ι : Type u_1
F : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝⁴ : FunLike F α β
inst✝³ : Group α
inst✝² : CommSemigroup β
inst✝¹ : LE β
inst✝ : SubmultiplicativeHomClass F α β
f : F
a b c : α
⊢ f (a / c) ≤ f (a / b) * f (b / c)
state_after: no goals
tactic: simpa only [div_mul_div_cancel'] using map_mul_le_mul f (a / b) (b / c)
Theorem: ProbabilityTheory.Indep_iff_IndepSets
File: Mathlib/Probability/Independence/Basic.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s : ι → Set Ω
m₁ m₂ _mΩ : MeasurableSpace Ω
μ : Measure Ω
⊢ Indep m₁ m₂ μ ↔ IndepSets {s | MeasurableSet s} {s | MeasurableSet s} μ
state_after: no goals
tactic: simp only [Indep, IndepSets, Kernel.Indep]
Theorem: MeasureTheory.inv_ae
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ (ae μ)⁻¹ = ae μ
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ ae μ ≤ (ae μ)⁻¹
tactic: refine le_antisymm (quasiMeasurePreserving_inv μ).tendsto_ae ?_
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ ae μ ≤ (ae μ)⁻¹
state_after: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ (ae μ)⁻¹⁻¹ ≤ (ae μ)⁻¹
tactic: nth_rewrite 1 [← inv_inv (ae μ)]
state_before: G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SFinite ν
inst✝² : SFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : μ.IsMulLeftInvariant
⊢ (ae μ)⁻¹⁻¹ ≤ (ae μ)⁻¹
state_after: no goals
tactic: exact Filter.map_mono (quasiMeasurePreserving_inv μ).tendsto_ae
Theorem: WellFounded.lt_succ_iff
File: Mathlib/Order/WellFounded.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wo : IsWellOrder α r
x : α
h : ∃ y, r x y
y : α
⊢ r y (⋯.succ x) ↔ r y x ∨ y = x
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wo : IsWellOrder α r
x : α
h : ∃ y, r x y
y : α
⊢ r y (⋯.succ x) → r y x ∨ y = x

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wo : IsWellOrder α r
x : α
h : ∃ y, r x y
y : α
⊢ r y x ∨ y = x → r y (⋯.succ x)
tactic: constructor
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wo : IsWellOrder α r
x : α
h : ∃ y, r x y
y : α
⊢ r y x ∨ y = x → r y (⋯.succ x)
state_after: case mpr.inl
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wo : IsWellOrder α r
x : α
h : ∃ y, r x y
y : α
hy : r y x
⊢ r y (⋯.succ x)

case mpr.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wo : IsWellOrder α r
y : α
h : ∃ y_1, r y y_1
⊢ r y (⋯.succ y)
tactic: rintro (hy | rfl)
state_before: case mpr.inr
α : Type u_1
β : Type u_2
γ : Type u_3
r✝ r' r : α → α → Prop
wo : IsWellOrder α r
y : α
h : ∃ y_1, r y y_1
⊢ r y (⋯.succ y)
state_after: no goals
tactic: exact wo.wf.lt_succ h
Theorem: CauSeq.zero_limZero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
ε : α
ε0 : ε > 0
j : ℕ
x✝ : j ≥ 0
⊢ abv (↑0 j) < ε
state_after: no goals
tactic: simpa [abv_zero abv] using ε0
Theorem: descPochhammer_zero_eval_zero
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
⊢ eval 0 (descPochhammer R 0) = 1
state_after: no goals
tactic: simp
Theorem: Polynomial.bernoulli_three_eval_one_quarter
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: ⊢ eval (1 / 4) (bernoulli 3) = 3 / 64
state_after: ⊢ eval (1 / 4) (∑ i ∈ Finset.range 0, (monomial (3 - i)) (_root_.bernoulli i * ↑(Nat.choose 3 i))) +
            _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) +
          _root_.bernoulli 1 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
tactic: simp_rw [Polynomial.bernoulli, Finset.sum_range_succ, Polynomial.eval_add,
    Polynomial.eval_monomial]
state_before: ⊢ eval (1 / 4) (∑ i ∈ Finset.range 0, (monomial (3 - i)) (_root_.bernoulli i * ↑(Nat.choose 3 i))) +
            _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) +
          _root_.bernoulli 1 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
state_after: ⊢ _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
tactic: rw [Finset.sum_range_zero, Polynomial.eval_zero, zero_add, bernoulli_one]
state_before: ⊢ _root_.bernoulli 0 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        _root_.bernoulli 2 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      _root_.bernoulli 3 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
state_after: ⊢ 1 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        1 / 6 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      0 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
tactic: rw [bernoulli_eq_bernoulli'_of_ne_one zero_ne_one, bernoulli'_zero,
    bernoulli_eq_bernoulli'_of_ne_one (by decide : 2 ≠ 1), bernoulli'_two,
    bernoulli_eq_bernoulli'_of_ne_one (by decide : 3 ≠ 1), bernoulli'_three]
state_before: ⊢ 1 * ↑(Nat.choose 3 0) * (1 / 4) ^ (3 - 0) + -1 / 2 * ↑(Nat.choose 3 1) * (1 / 4) ^ (3 - 1) +
        1 / 6 * ↑(Nat.choose 3 2) * (1 / 4) ^ (3 - 2) +
      0 * ↑(Nat.choose 3 3) * (1 / 4) ^ (3 - 3) =
    3 / 64
state_after: no goals
tactic: norm_num