ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.CosimplicialObject.cechConerveEquiv_symm_apply
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
⊢ Function.LeftInverse (equivalenceRightToLeft F X) (equivalenceLeftToRight F X)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F.augmentedCechConerve ⟶ X
⊢ equivalenceRightToLeft F X (equivalenceLeftToRight F X A) = A
tactic: intro A
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F.augmentedCechConerve ⟶ X
⊢ equivalenceRightToLeft F X (equivalenceLeftToRight F X A) = A
state_after: case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F.augmentedCechConerve ⟶ X
⊢ (equivalenceRightToLeft F X (equivalenceLeftToRight F X A)).left = A.left

case h₂.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F.augmentedCechConerve ⟶ X
x : SimplexCategory
⊢ (equivalenceRightToLeft F X (equivalenceLeftToRight F X A)).right.app x = A.right.app x
tactic: ext x : 2
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
⊢ Function.RightInverse (equivalenceRightToLeft F X) (equivalenceLeftToRight F X)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F ⟶ Augmented.toArrow.obj X
⊢ equivalenceLeftToRight F X (equivalenceRightToLeft F X A) = A
tactic: intro A
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F ⟶ Augmented.toArrow.obj X
⊢ equivalenceLeftToRight F X (equivalenceRightToLeft F X A) = A
state_after: case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F ⟶ Augmented.toArrow.obj X
⊢ (equivalenceLeftToRight F X (equivalenceRightToLeft F X A)).left = A.left

case h₂
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : F ⟶ Augmented.toArrow.obj X
⊢ (equivalenceLeftToRight F X (equivalenceRightToLeft F X A)).right = A.right
tactic: ext
Theorem: Finset.sum_Ico_Ico_comm
File: Mathlib/Algebra/BigOperators/Intervals.lean

Proof steps:
state_before: α : Type u_1
M✝ : Type u_2
inst✝¹ : CommMonoid M✝
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M✝
M : Type u_3
inst✝ : AddCommMonoid M
a b : ℕ
f : ℕ → ℕ → M
⊢ ∑ i ∈ Ico a b, ∑ j ∈ Ico i b, f i j = ∑ j ∈ Ico a b, ∑ i ∈ Ico a (j + 1), f i j
state_after: α : Type u_1
M✝ : Type u_2
inst✝¹ : CommMonoid M✝
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M✝
M : Type u_3
inst✝ : AddCommMonoid M
a b : ℕ
f : ℕ → ℕ → M
⊢ ∑ x ∈ (Ico a b).sigma fun i => Ico i b, f x.fst x.snd = ∑ x ∈ (Ico a b).sigma fun j => Ico a (j + 1), f x.snd x.fst
tactic: rw [Finset.sum_sigma', Finset.sum_sigma']
state_before: α : Type u_1
M✝ : Type u_2
inst✝¹ : CommMonoid M✝
s₂ s₁ s : Finset α
a✝ : α
g f✝ : α → M✝
M : Type u_3
inst✝ : AddCommMonoid M
a b : ℕ
f : ℕ → ℕ → M
⊢ ∑ x ∈ (Ico a b).sigma fun i => Ico i b, f x.fst x.snd = ∑ x ∈ (Ico a b).sigma fun j => Ico a (j + 1), f x.snd x.fst
state_after: no goals
tactic: refine sum_nbij' (fun x ↦ ⟨x.2, x.1⟩) (fun x ↦ ⟨x.2, x.1⟩) ?_ ?_ (fun _ _ ↦ rfl) (fun _ _ ↦ rfl)
    (fun _ _ ↦ rfl) <;>
  simp only [Finset.mem_Ico, Sigma.forall, Finset.mem_sigma] <;>
  rintro a b ⟨⟨h₁, h₂⟩, ⟨h₃, h₄⟩⟩ <;>
  omega
Theorem: MeasureTheory.condexp_finset_sum
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean

Proof steps:
state_before: α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s✝ : Set α
ι : Type u_5
s : Finset ι
f : ι → α → F'
hf : ∀ i ∈ s, Integrable (f i) μ
⊢ μ[∑ i ∈ s, f i|m] =ᶠ[ae μ] ∑ i ∈ s, μ[f i|m]
state_after: case empty
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s : Set α
ι : Type u_5
f : ι → α → F'
hf : ∀ i ∈ ∅, Integrable (f i) μ
⊢ μ[∑ i ∈ ∅, f i|m] =ᶠ[ae μ] ∑ i ∈ ∅, μ[f i|m]

case insert
α : Type u_1
F : Type u_2
F' : Type u_3
𝕜 : Type u_4
p : ℝ≥0∞
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
m m0 : MeasurableSpace α
μ : Measure α
f✝ g : α → F'
s✝ : Set α
ι : Type u_5
f : ι → α → F'
i : ι
s : Finset ι
his : i ∉ s
heq : (∀ i ∈ s, Integrable (f i) μ) → μ[∑ i ∈ s, f i|m] =ᶠ[ae μ] ∑ i ∈ s, μ[f i|m]
hf : ∀ i_1 ∈ insert i s, Integrable (f i_1) μ
⊢ μ[∑ i ∈ insert i s, f i|m] =ᶠ[ae μ] ∑ i ∈ insert i s, μ[f i|m]
tactic: induction' s using Finset.induction_on with i s his heq hf
Theorem: minpoly.ToAdjoin.injective
File: Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx : IsIntegral R x
⊢ Injective ⇑(Minpoly.toAdjoin R x)
state_after: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx : IsIntegral R x
P₁ : AdjoinRoot (minpoly R x)
hP₁ : (Minpoly.toAdjoin R x) P₁ = 0
⊢ P₁ = 0
tactic: refine (injective_iff_map_eq_zero _).2 fun P₁ hP₁ => ?_
state_before: R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx : IsIntegral R x
P₁ : AdjoinRoot (minpoly R x)
hP₁ : (Minpoly.toAdjoin R x) P₁ = 0
⊢ P₁ = 0
state_after: case intro
R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx : IsIntegral R x
P : R[X]
hP₁ : (Minpoly.toAdjoin R x) ((AdjoinRoot.mk (minpoly R x)) P) = 0
⊢ (AdjoinRoot.mk (minpoly R x)) P = 0
tactic: obtain ⟨P, rfl⟩ := mk_surjective P₁
state_before: case intro
R : Type u_1
S : Type u_2
inst✝⁶ : CommRing R
inst✝⁵ : CommRing S
inst✝⁴ : IsDomain R
inst✝³ : Algebra R S
inst✝² : IsDomain S
inst✝¹ : NoZeroSMulDivisors R S
inst✝ : IsIntegrallyClosed R
x : S
hx : IsIntegral R x
P : R[X]
hP₁ : (Minpoly.toAdjoin R x) ((AdjoinRoot.mk (minpoly R x)) P) = 0
⊢ (AdjoinRoot.mk (minpoly R x)) P = 0
state_after: no goals
tactic: rwa [Minpoly.toAdjoin_apply', liftHom_mk, ← Subalgebra.coe_eq_zero, aeval_subalgebra_coe,
    isIntegrallyClosed_dvd_iff hx, ← AdjoinRoot.mk_eq_zero] at hP₁
Theorem: ENNReal.mul_div_mul_left
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hc : c ≠ 0
hc' : c ≠ ⊤
⊢ c * a / (c * b) = a / b
state_after: no goals
tactic: rw [div_eq_mul_inv, div_eq_mul_inv, ENNReal.mul_inv (Or.inl hc) (Or.inl hc'), mul_mul_mul_comm,
    ENNReal.mul_inv_cancel hc hc', one_mul]
Theorem: ENNReal.toReal_eq_toReal_iff
File: Mathlib/Data/ENNReal/Basic.lean

Proof steps:
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
⊢ x.toReal = y.toReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0
state_after: no goals
tactic: simp only [ENNReal.toReal, NNReal.coe_inj, toNNReal_eq_toNNReal_iff]
Theorem: dist_birkhoffAverage_apply_birkhoffAverage
File: Mathlib/Dynamics/BirkhoffSum/NormedSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
inst✝³ : NormedAddCommGroup E
𝕜 : Type u_3
inst✝² : RCLike 𝕜
inst✝¹ : Module 𝕜 E
inst✝ : BoundedSMul 𝕜 E
f : α → α
g : α → E
n : ℕ
x : α
⊢ dist (birkhoffAverage 𝕜 f g n (f x)) (birkhoffAverage 𝕜 f g n x) = dist (g (f^[n] x)) (g x) / ↑n
state_after: no goals
tactic: simp [dist_birkhoffAverage_birkhoffAverage, dist_birkhoffSum_apply_birkhoffSum]
Theorem: IsLeftRegular.of_mul
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsLeftRegular (a * b)
⊢ Function.Injective ((fun x => a * x) ∘ fun x => b * x)
state_after: no goals
tactic: rwa [comp_mul_left a b]
Theorem: NumberField.InfinitePlace.IsReal.comap
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
f : k →+* K
w : InfinitePlace K
hφ : w.IsReal
⊢ (w.comap f).IsReal
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
f : k →+* K
w : InfinitePlace K
hφ : w.IsReal
⊢ ComplexEmbedding.IsReal (w.embedding.comp f)
tactic: rw [← mk_embedding w, comap_mk, isReal_mk_iff]
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
f : k →+* K
w : InfinitePlace K
hφ : w.IsReal
⊢ ComplexEmbedding.IsReal (w.embedding.comp f)
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
f : k →+* K
w : InfinitePlace K
hφ : ComplexEmbedding.IsReal w.embedding
⊢ ComplexEmbedding.IsReal (w.embedding.comp f)
tactic: rw [← mk_embedding w, isReal_mk_iff] at hφ
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
f : k →+* K
w : InfinitePlace K
hφ : ComplexEmbedding.IsReal w.embedding
⊢ ComplexEmbedding.IsReal (w.embedding.comp f)
state_after: no goals
tactic: exact hφ.comp f
Theorem: CategoryTheory.Square.toArrowArrowFunctor_obj_right_right
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: SetTheory.PGame.rightMoves_nim
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: o : Ordinal.{u_1}
⊢ (nim o).RightMoves = (Quotient.out o).α
state_after: o : Ordinal.{u_1}
⊢ (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)).RightMoves =
    (Quotient.out o).α
tactic: rw [nim_def]
state_before: o : Ordinal.{u_1}
⊢ (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
        nim (typein (fun x x_1 => x < x_1) o₂)).RightMoves =
    (Quotient.out o).α
state_after: no goals
tactic: rfl
Theorem: TorusIntegrable.function_integrable
File: Mathlib/MeasureTheory/Integral/TorusIntegral.lean

Proof steps:
state_before: n : ℕ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : (Fin n → ℂ) → E
c : Fin n → ℂ
R : Fin n → ℝ
inst✝ : NormedSpace ℂ E
hf : TorusIntegrable f c R
⊢ IntegrableOn (fun θ => (∏ i : Fin n, ↑(R i) * cexp (↑(θ i) * I) * I) • f (torusMap c R θ)) (Icc 0 fun x => 2 * π)
    volume
state_after: case refine_1
n : ℕ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : (Fin n → ℂ) → E
c : Fin n → ℂ
R : Fin n → ℝ
inst✝ : NormedSpace ℂ E
hf : TorusIntegrable f c R
⊢ AEStronglyMeasurable (fun θ => (∏ i : Fin n, ↑(R i) * cexp (↑(θ i) * I) * I) • f (torusMap c R θ))
    (volume.restrict (Icc 0 fun x => 2 * π))

case refine_2
n : ℕ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : (Fin n → ℂ) → E
c : Fin n → ℂ
R : Fin n → ℝ
inst✝ : NormedSpace ℂ E
hf : TorusIntegrable f c R
⊢ ∀ᵐ (a : Fin n → ℝ) ∂volume.restrict (Icc 0 fun x => 2 * π),
    ‖(∏ i : Fin n, ↑(R i) * cexp (↑(a i) * I) * I) • f (torusMap c R a)‖ ≤ (∏ i : Fin n, |R i|) * ‖f (torusMap c R a)‖
tactic: refine (hf.norm.const_mul (∏ i, |R i|)).mono' ?_ ?_
state_before: case refine_2
n : ℕ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
f g : (Fin n → ℂ) → E
c : Fin n → ℂ
R : Fin n → ℝ
inst✝ : NormedSpace ℂ E
hf : TorusIntegrable f c R
⊢ ∀ᵐ (a : Fin n → ℝ) ∂volume.restrict (Icc 0 fun x => 2 * π),
    ‖(∏ i : Fin n, ↑(R i) * cexp (↑(a i) * I) * I) • f (torusMap c R a)‖ ≤ (∏ i : Fin n, |R i|) * ‖f (torusMap c R a)‖
state_after: no goals
tactic: simp [norm_smul, map_prod]
Theorem: Subsemigroup.mem_iSup_of_mem
File: Mathlib/Algebra/Group/Subsemigroup/Membership.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S
state_after: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
this : S i ≤ iSup S
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S
tactic: have : S i ≤ iSup S := le_iSup _ _
state_before: ι : Sort u_1
M : Type u_2
A : Type u_3
B : Type u_4
inst✝ : Mul M
S : ι → Subsemigroup M
i : ι
this : S i ≤ iSup S
⊢ ∀ {x : M}, x ∈ S i → x ∈ iSup S
state_after: no goals
tactic: tauto
Theorem: HahnSeries.leadingCoeff_eq_iff
File: Mathlib/RingTheory/HahnSeries/Basic.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x.leadingCoeff = 0 ↔ x = 0
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x.leadingCoeff = 0 → x = 0
tactic: refine { mp := ?_, mpr := fun hx => hx ▸ leadingCoeff_zero }
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x.leadingCoeff = 0 → x = 0
state_after: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x ≠ 0 → x.leadingCoeff ≠ 0
tactic: contrapose!
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
x : HahnSeries Γ R
⊢ x ≠ 0 → x.leadingCoeff ≠ 0
state_after: no goals
tactic: exact fun hx => (leadingCoeff_of_ne hx) ▸ coeff_orderTop_ne (orderTop_of_ne hx)
Theorem: ULift.closedEmbedding_down
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝ : TopologicalSpace X
⊢ IsClosed (range down)
state_after: no goals
tactic: simp only [ULift.down_surjective.range_eq, isClosed_univ]
Theorem: Filter.limsup_piecewise
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✝¹ : CompleteDistribLattice α
f : Filter β
p q : β → Prop
u : β → α
s : Set β
inst✝ : DecidablePred fun x => x ∈ s
v : β → α
⊢ ((blimsup (s.piecewise u v) f fun x => x ∈ s) ⊔ blimsup (s.piecewise u v) f fun x => x ∉ s) =
    (blimsup u f fun x => x ∈ s) ⊔ blimsup v f fun x => x ∉ s
state_after: no goals
tactic: refine congr_arg₂ _ (blimsup_congr ?_) (blimsup_congr ?_) <;>
    filter_upwards with _ h using by simp [h]
Theorem: WeierstrassCurve.Affine.equation_iff_variableChange
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x y ↔ (variableChange W { u := 1, r := x, s := 0, t := y }).toAffine.Equation 0 0
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ -(y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)) = 0 ↔
    1 ^ 6 *
        (W.a₆ + { u := 1, r := x, s := 0, t := y }.r * W.a₄ + { u := 1, r := x, s := 0, t := y }.r ^ 2 * W.a₂ +
                { u := 1, r := x, s := 0, t := y }.r ^ 3 -
              { u := 1, r := x, s := 0, t := y }.t * W.a₃ -
            { u := 1, r := x, s := 0, t := y }.t ^ 2 -
          { u := 1, r := x, s := 0, t := y }.r * { u := 1, r := x, s := 0, t := y }.t * W.a₁) =
      0
tactic: rw [equation_iff', ← neg_eq_zero, equation_zero, variableChange_a₆, inv_one, Units.val_one]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ -(y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)) = 0 ↔
    1 ^ 6 *
        (W.a₆ + { u := 1, r := x, s := 0, t := y }.r * W.a₄ + { u := 1, r := x, s := 0, t := y }.r ^ 2 * W.a₂ +
                { u := 1, r := x, s := 0, t := y }.r ^ 3 -
              { u := 1, r := x, s := 0, t := y }.t * W.a₃ -
            { u := 1, r := x, s := 0, t := y }.t ^ 2 -
          { u := 1, r := x, s := 0, t := y }.r * { u := 1, r := x, s := 0, t := y }.t * W.a₁) =
      0
state_after: case a.h.e'_2
R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ -(y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)) =
    1 ^ 6 *
      (W.a₆ + { u := 1, r := x, s := 0, t := y }.r * W.a₄ + { u := 1, r := x, s := 0, t := y }.r ^ 2 * W.a₂ +
              { u := 1, r := x, s := 0, t := y }.r ^ 3 -
            { u := 1, r := x, s := 0, t := y }.t * W.a₃ -
          { u := 1, r := x, s := 0, t := y }.t ^ 2 -
        { u := 1, r := x, s := 0, t := y }.r * { u := 1, r := x, s := 0, t := y }.t * W.a₁)
tactic: congr! 1
state_before: case a.h.e'_2
R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ -(y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆)) =
    1 ^ 6 *
      (W.a₆ + { u := 1, r := x, s := 0, t := y }.r * W.a₄ + { u := 1, r := x, s := 0, t := y }.r ^ 2 * W.a₂ +
              { u := 1, r := x, s := 0, t := y }.r ^ 3 -
            { u := 1, r := x, s := 0, t := y }.t * W.a₃ -
          { u := 1, r := x, s := 0, t := y }.t ^ 2 -
        { u := 1, r := x, s := 0, t := y }.r * { u := 1, r := x, s := 0, t := y }.t * W.a₁)
state_after: no goals
tactic: ring1
Theorem: WithBot.map₂_bot_right
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
f : α → β → γ
a : WithBot α
⊢ map₂ f a ⊥ = ⊥
state_after: no goals
tactic: cases a <;> rfl
Theorem: MeasureTheory.IsSetSemiring.empty_not_mem_diffFinset₀
File: Mathlib/MeasureTheory/SetSemiring.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
⊢ ∅ ∉ hC.diffFinset₀ hs hI
state_after: no goals
tactic: classical
  simp only [diffFinset₀, mem_sdiff, Finset.mem_singleton, eq_self_iff_true, not_true,
    and_false_iff, not_false_iff]
Theorem: Polynomial.Monic.not_irreducible_iff_exists_add_mul_eq_coeff
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hm : p.Monic
hnd : p.natDegree = 2
⊢ ¬Irreducible p ↔ ∃ c₁ c₂, p.coeff 0 = c₁ * c₂ ∧ p.coeff 1 = c₁ + c₂
state_after: case inl
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hm : p.Monic
hnd : p.natDegree = 2
h✝ : Subsingleton R
⊢ ¬Irreducible p ↔ ∃ c₁ c₂, p.coeff 0 = c₁ * c₂ ∧ p.coeff 1 = c₁ + c₂

case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hm : p.Monic
hnd : p.natDegree = 2
h✝ : Nontrivial R
⊢ ¬Irreducible p ↔ ∃ c₁ c₂, p.coeff 0 = c₁ * c₂ ∧ p.coeff 1 = c₁ + c₂
tactic: cases subsingleton_or_nontrivial R
state_before: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hm : p.Monic
hnd : p.natDegree = 2
h✝ : Nontrivial R
⊢ ¬Irreducible p ↔ ∃ c₁ c₂, p.coeff 0 = c₁ * c₂ ∧ p.coeff 1 = c₁ + c₂
state_after: case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hm : p.Monic
hnd : p.natDegree = 2
h✝ : Nontrivial R
⊢ (¬∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → g.natDegree ∉ Ioc 0 (2 / 2)) ↔
    ∃ c₁ c₂, p.coeff 0 = c₁ * c₂ ∧ p.coeff 1 = c₁ + c₂

case inr
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hm : p.Monic
hnd : p.natDegree = 2
h✝ : Nontrivial R
⊢ p ≠ 1
tactic: rw [hm.irreducible_iff_natDegree', and_iff_right, hnd]
Theorem: continuousVAdd_inf
File: Mathlib/Topology/Algebra/MulAction.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
X : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : SMul M X
t₁ t₂ : TopologicalSpace X
inst✝¹ : ContinuousSMul M X
inst✝ : ContinuousSMul M X
⊢ ContinuousSMul M X
state_after: ι : Sort u_1
M : Type u_2
X : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : SMul M X
t₁ t₂ : TopologicalSpace X
inst✝¹ : ContinuousSMul M X
inst✝ : ContinuousSMul M X
b : Bool
⊢ ContinuousSMul M X
tactic: refine continuousSMul_iInf fun b => ?_
state_before: ι : Sort u_1
M : Type u_2
X : Type u_3
inst✝³ : TopologicalSpace M
inst✝² : SMul M X
t₁ t₂ : TopologicalSpace X
inst✝¹ : ContinuousSMul M X
inst✝ : ContinuousSMul M X
b : Bool
⊢ ContinuousSMul M X
state_after: no goals
tactic: cases b <;> assumption
Theorem: List.length_of_sublistsLen
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l l' : List α
h : l' ∈ sublistsLen 0 l
⊢ l'.length = 0
state_after: no goals
tactic: simp_all
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen (n + 1) (a :: l)
⊢ l'.length = n + 1
state_after: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen (n + 1) l ∨ ∃ a_1 ∈ sublistsLen n l, a :: a_1 = l'
⊢ l'.length = n + 1
tactic: rw [sublistsLen_succ_cons, mem_append, mem_map] at h
state_before: α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen (n + 1) l ∨ ∃ a_1 ∈ sublistsLen n l, a :: a_1 = l'
⊢ l'.length = n + 1
state_after: case inl
α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen (n + 1) l
⊢ l'.length = n + 1

case inr.intro.intro
α : Type u
β : Type v
γ : Type w
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen n l
⊢ (a :: l').length = n + 1
tactic: rcases h with (h | ⟨l', h, rfl⟩)
Theorem: CentroidHom.star_centerToCentroidCenter
File: Mathlib/Algebra/Star/CentroidHom.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : StarRing α
z : ↥(NonUnitalStarSubsemiring.center α)
⊢ star (centerToCentroidCenter z) = centerToCentroidCenter (star z)
state_after: case a.h
α : Type u_1
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : StarRing α
z : ↥(NonUnitalStarSubsemiring.center α)
a : α
⊢ ↑(star (centerToCentroidCenter z)) a = ↑(centerToCentroidCenter (star z)) a
tactic: ext a
state_before: case a.h
α : Type u_1
inst✝¹ : NonUnitalNonAssocSemiring α
inst✝ : StarRing α
z : ↥(NonUnitalStarSubsemiring.center α)
a : α
⊢ ↑(star (centerToCentroidCenter z)) a = ↑(centerToCentroidCenter (star z)) a
state_after: no goals
tactic: calc
      (star (centerToCentroidCenter z)) a = star (z * star a) := rfl
      _ = star (star a) * star z := by simp only [star_mul, star_star, StarMemClass.coe_star]
      _ = a * star z := by rw [star_star]
      _ = (star z) * a := by rw [(star z).property.comm]
      _ = (centerToCentroidCenter ((star z) : NonUnitalStarSubsemiring.center α)) a := rfl
Theorem: WeierstrassCurve.ΨSq_even
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
m : ℕ
⊢ W.ΨSq (2 * (↑m + 3)) =
    (W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) -
          W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2) ^
        2 *
      W.Ψ₂Sq
state_after: no goals
tactic: erw [ΨSq_ofNat, preΨ'_even, if_pos <| even_two_mul _]