ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicGeometry.ProjIsoSpecTopComponent.ToSpec.mk_mem_carrier
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
x : ↑(Proj.restrict ⋯).toTopCat
z : HomogeneousLocalization.NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ HomogeneousLocalization.mk z ∈ carrier x ↔ ↑z.num ∈ (↑x).asHomogeneousIdeal
state_after: R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
x : ↑(Proj.restrict ⋯).toTopCat
z : HomogeneousLocalization.NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ ↑z.num ∈ (↑x).asHomogeneousIdeal.toIdeal ↔ ↑z.num ∈ (↑x).asHomogeneousIdeal

case hI
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
x : ↑(Proj.restrict ⋯).toTopCat
z : HomogeneousLocalization.NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ (↑x).asHomogeneousIdeal.toIdeal.IsPrime

case hM
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
x : ↑(Proj.restrict ⋯).toTopCat
z : HomogeneousLocalization.NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ Disjoint ↑(Submonoid.powers f) ↑(↑x).asHomogeneousIdeal.toIdeal

case hy
R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
m : ℕ
f_deg : f ∈ 𝒜 m
x : ↑(Proj.restrict ⋯).toTopCat
z : HomogeneousLocalization.NumDenSameDeg 𝒜 (Submonoid.powers f)
⊢ IsUnit (IsLocalization.mk' (Localization (Submonoid.powers f)) 1 ⟨↑z.den, ⋯⟩)
tactic: rw [carrier, Ideal.mem_comap, HomogeneousLocalization.algebraMap_apply,
    HomogeneousLocalization.val_mk, Localization.mk_eq_mk', IsLocalization.mk'_eq_mul_mk'_one,
    mul_comm, Ideal.unit_mul_mem_iff_mem, ← Ideal.mem_comap,
    IsLocalization.comap_map_of_isPrime_disjoint (.powers f)]
Theorem: DihedralGroup.reciprocalFactors_even
File: Mathlib/GroupTheory/CommutingProbability.lean

Proof steps:
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h0 : n ≠ 0
h2 : Even n
⊢ reciprocalFactors n = 3 :: reciprocalFactors (n / 2)
state_after: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h0 : n ≠ 0
h2 : Even n
h1 : n ≠ 1
⊢ reciprocalFactors n = 3 :: reciprocalFactors (n / 2)
tactic: have h1 : n ≠ 1 := by
    rintro rfl
    norm_num at h2
state_before: M : Type u_1
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_2
inst✝¹ : Group G
inst✝ : Finite G
H : Subgroup G
n : ℕ
h0 : n ≠ 0
h2 : Even n
h1 : n ≠ 1
⊢ reciprocalFactors n = 3 :: reciprocalFactors (n / 2)
state_after: no goals
tactic: rw [reciprocalFactors, dif_neg h0, dif_neg h1, if_pos h2]
Theorem: neg_of_smul_neg_left
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁵ : Zero α
inst✝⁴ : Zero β
inst✝³ : SMulZeroClass α β
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : PosSMulReflectLT α β
h : a • b < 0
ha : 0 ≤ a
⊢ a • b < a • 0
state_after: no goals
tactic: rwa [smul_zero]
Theorem: CategoryTheory.Limits.prod.map_map
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y A₁ A₂ A₃ B₁ B₂ B₃ : C
inst✝² : HasBinaryProduct A₁ B₁
inst✝¹ : HasBinaryProduct A₂ B₂
inst✝ : HasBinaryProduct A₃ B₃
f : A₁ ⟶ A₂
g : B₁ ⟶ B₂
h : A₂ ⟶ A₃
k : B₂ ⟶ B₃
⊢ map f g ≫ map h k = map (f ≫ h) (g ≫ k)
state_after: no goals
tactic: ext <;> simp
Theorem: ProbabilityTheory.Kernel.lintegral_prod
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel α γ
inst✝ : IsSFiniteKernel η
a : α
g : β × γ → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : β × γ), g c ∂(κ ×ₖ η) a = ∫⁻ (b : β), ∫⁻ (c : γ), g (b, c) ∂η a ∂κ a
state_after: no goals
tactic: simp_rw [prod, lintegral_compProd _ _ _ hg, swapLeft_apply, prodMkLeft_apply, Prod.swap_prod_mk]
Theorem: StarAlgHom.ofId_apply
File: Mathlib/Algebra/Star/StarAlgHom.lean

Proof steps:
state_before: F : Type u_1
R✝ : Type u_2
A✝ : Type u_3
B : Type u_4
C : Type u_5
D : Type u_6
inst✝¹⁸ : CommSemiring R✝
inst✝¹⁷ : Semiring A✝
inst✝¹⁶ : Algebra R✝ A✝
inst✝¹⁵ : Star A✝
inst✝¹⁴ : Semiring B
inst✝¹³ : Algebra R✝ B
inst✝¹² : Star B
inst✝¹¹ : Semiring C
inst✝¹⁰ : Algebra R✝ C
inst✝⁹ : Star C
inst✝⁸ : Semiring D
inst✝⁷ : Algebra R✝ D
inst✝⁶ : Star D
R : Type u_7
A : Type u_8
inst✝⁵ : CommSemiring R
inst✝⁴ : StarRing R
inst✝³ : Semiring A
inst✝² : StarMul A
inst✝¹ : Algebra R A
inst✝ : StarModule R A
⊢ ∀ (x : R),
    (↑↑{ toFun := ⇑(algebraMap R A), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯,
                  commutes' := ⋯ }.toRingHom).toFun
        (star x) =
      star
        ((↑↑{ toFun := ⇑(algebraMap R A), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯,
                    commutes' := ⋯ }.toRingHom).toFun
          x)
state_after: no goals
tactic: simp [Algebra.algebraMap_eq_smul_one]
Theorem: WittVector.exists_eq_pow_p_mul'
File: Mathlib/RingTheory/WittVector/DiscreteValuationRing.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
a : 𝕎 k
ha : a ≠ 0
⊢ ∃ m b, a = ↑p ^ m * ↑b
state_after: case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
a : 𝕎 k
ha : a ≠ 0
m : ℕ
b : 𝕎 k
h₁ : b.coeff 0 ≠ 0
h₂ : a = ↑p ^ m * b
⊢ ∃ m b, a = ↑p ^ m * ↑b
tactic: obtain ⟨m, b, h₁, h₂⟩ := exists_eq_pow_p_mul a ha
state_before: case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
a : 𝕎 k
ha : a ≠ 0
m : ℕ
b : 𝕎 k
h₁ : b.coeff 0 ≠ 0
h₂ : a = ↑p ^ m * b
⊢ ∃ m b, a = ↑p ^ m * ↑b
state_after: case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
a : 𝕎 k
ha : a ≠ 0
m : ℕ
b : 𝕎 k
h₁ : b.coeff 0 ≠ 0
h₂ : a = ↑p ^ m * b
b₀ : kˣ := Units.mk0 (b.coeff 0) h₁
⊢ ∃ m b, a = ↑p ^ m * ↑b
tactic: let b₀ := Units.mk0 (b.coeff 0) h₁
state_before: case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
a : 𝕎 k
ha : a ≠ 0
m : ℕ
b : 𝕎 k
h₁ : b.coeff 0 ≠ 0
h₂ : a = ↑p ^ m * b
b₀ : kˣ := Units.mk0 (b.coeff 0) h₁
⊢ ∃ m b, a = ↑p ^ m * ↑b
state_after: case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
a : 𝕎 k
ha : a ≠ 0
m : ℕ
b : 𝕎 k
h₁ : b.coeff 0 ≠ 0
h₂ : a = ↑p ^ m * b
b₀ : kˣ := Units.mk0 (b.coeff 0) h₁
hb₀ : b.coeff 0 = ↑b₀
⊢ ∃ m b, a = ↑p ^ m * ↑b
tactic: have hb₀ : b.coeff 0 = b₀ := rfl
state_before: case intro.intro.intro
p : ℕ
hp : Fact (Nat.Prime p)
k : Type u_1
inst✝² : Field k
inst✝¹ : CharP k p
inst✝ : PerfectRing k p
a : 𝕎 k
ha : a ≠ 0
m : ℕ
b : 𝕎 k
h₁ : b.coeff 0 ≠ 0
h₂ : a = ↑p ^ m * b
b₀ : kˣ := Units.mk0 (b.coeff 0) h₁
hb₀ : b.coeff 0 = ↑b₀
⊢ ∃ m b, a = ↑p ^ m * ↑b
state_after: no goals
tactic: exact ⟨m, mkUnit hb₀, h₂⟩
Theorem: MeasureTheory.Measure.count_empty
File: Mathlib/MeasureTheory/Measure/Count.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
⊢ count ∅ = 0
state_after: no goals
tactic: rw [count_apply MeasurableSet.empty, tsum_empty]
Theorem: Nat.shiftLeft'_tt_eq_mul_pow
File: Mathlib/Data/Nat/Size.lean

Proof steps:
state_before: m : ℕ
⊢ shiftLeft' true m 0 + 1 = (m + 1) * 2 ^ 0
state_after: no goals
tactic: simp [shiftLeft', pow_zero, Nat.one_mul]
state_before: m k : ℕ
⊢ shiftLeft' true m (k + 1) + 1 = (m + 1) * 2 ^ (k + 1)
state_after: no goals
tactic: rw [shiftLeft', bit_val, cond_true, add_assoc, ← Nat.mul_add_one, shiftLeft'_tt_eq_mul_pow m k,
      mul_left_comm, mul_comm 2, pow_succ]
Theorem: RatFunc.intDegree_C
File: Mathlib/FieldTheory/RatFunc/Degree.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
k : K
⊢ (C k).intDegree = 0
state_after: no goals
tactic: rw [intDegree, num_C, natDegree_C, denom_C, natDegree_one, sub_self]
Theorem: String.extract.go₁_add_right_cancel
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: s : List Char
i b e n : Nat
⊢ go₁ s { byteIdx := i + n } { byteIdx := b + n } { byteIdx := e + n } =
    go₁ s { byteIdx := i } { byteIdx := b } { byteIdx := e }
state_after: case eq
s : List Char
i b e n : Nat
⊢ ∀ (c : Char) (cs : List Char),
    go₂ (c :: cs) { byteIdx := b + n } { byteIdx := e + n } = go₂ (c :: cs) { byteIdx := b } { byteIdx := e }

case ind
s : List Char
i b e n : Nat
⊢ ∀ (c : Char) (cs : List Char) (i : Pos),
    ¬i = { byteIdx := b } →
      go₁ cs { byteIdx := i.byteIdx + c.utf8Size + n } { byteIdx := b + n } { byteIdx := e + n } =
          go₁ cs (i + c) { byteIdx := b } { byteIdx := e } →
        (if { byteIdx := i.byteIdx + n } = { byteIdx := b + n } then
            go₂ (c :: cs) { byteIdx := i.byteIdx + n } { byteIdx := e + n }
          else go₁ cs ({ byteIdx := i.byteIdx + n } + c) { byteIdx := b + n } { byteIdx := e + n }) =
          if i = { byteIdx := b } then go₂ (c :: cs) i { byteIdx := e }
          else go₁ cs (i + c) { byteIdx := b } { byteIdx := e }
tactic: apply utf8InductionOn s ⟨i⟩ ⟨b⟩ (motive := fun s i =>
    go₁ s ⟨i.byteIdx + n⟩ ⟨b + n⟩ ⟨e + n⟩ = go₁ s i ⟨b⟩ ⟨e⟩)
    <;> simp only [ne_eq, go₁, pos_add_char, implies_true, ↓reduceIte]
Theorem: HomotopyGroup.inv_spec
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

Proof steps:
state_before: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (⟦p⟧)⁻¹ = ⟦symmAt i p⟧
state_after: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (⟦p⟧)⁻¹ = ⟦fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))⟧
tactic: rw [symmAt_indep (Classical.arbitrary N) p, ← fromLoop_symm_toLoop]
state_before: N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (⟦p⟧)⁻¹ = ⟦fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))⟧
state_after: case a
N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (loopHomeo (Classical.arbitrary N)).symm (Path.symm ((loopHomeo (Classical.arbitrary N)).toEquiv p)) ≈
    fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))
tactic: apply Quotient.sound
state_before: case a
N : Type u_1
X : Type u_2
inst✝² : TopologicalSpace X
x : X
inst✝¹ : DecidableEq N
inst✝ : Nonempty N
i : N
p : ↑(Ω^ N X x)
⊢ (loopHomeo (Classical.arbitrary N)).symm (Path.symm ((loopHomeo (Classical.arbitrary N)).toEquiv p)) ≈
    fromLoop (Classical.arbitrary N) (Path.symm (toLoop (Classical.arbitrary N) p))
state_after: no goals
tactic: rfl
Theorem: Summable.tendsto_cofinite_zero
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
⊢ Tendsto f cofinite (𝓝 1)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
⊢ e ∈ Filter.map f cofinite
tactic: intro e he
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
⊢ e ∈ Filter.map f cofinite
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
⊢ f ⁻¹' e ∈ cofinite
tactic: rw [Filter.mem_map]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
⊢ f ⁻¹' e ∈ cofinite
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
s : Finset α
hs : ∀ (t : Finset α), Disjoint t s → ∏ k ∈ t, f k ∈ e
⊢ f ⁻¹' e ∈ cofinite
tactic: rcases hf.vanishing he with ⟨s, hs⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
s : Finset α
hs : ∀ (t : Finset α), Disjoint t s → ∏ k ∈ t, f k ∈ e
⊢ f ⁻¹' e ∈ cofinite
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
G : Type u_5
inst✝² : TopologicalSpace G
inst✝¹ : CommGroup G
inst✝ : TopologicalGroup G
f : α → G
hf : Multipliable f
e : Set G
he : e ∈ 𝓝 1
s : Finset α
hs : ∀ (t : Finset α), Disjoint t s → ∏ k ∈ t, f k ∈ e
x : α
hx : x ∉ s
⊢ f x ∈ e
tactic: refine s.eventually_cofinite_nmem.mono fun x hx ↦ ?_
Theorem: NonUnitalAlgebra.map_bot
File: Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean

Proof steps:
state_before: F : Type u_1
R : Type u
A : Type v
B : Type w
inst✝¹⁰ : CommSemiring R
inst✝⁹ : NonUnitalNonAssocSemiring A
inst✝⁸ : Module R A
inst✝⁷ : IsScalarTower R A A
inst✝⁶ : SMulCommClass R A A
inst✝⁵ : NonUnitalNonAssocSemiring B
inst✝⁴ : Module R B
inst✝³ : IsScalarTower R B B
inst✝² : SMulCommClass R B B
inst✝¹ : FunLike F A B
inst✝ : NonUnitalAlgHomClass F R A B
f : A →ₙₐ[R] B
⊢ ↑(NonUnitalSubalgebra.map f ⊥) = ↑⊥
state_after: no goals
tactic: simp [NonUnitalAlgebra.coe_bot, NonUnitalSubalgebra.coe_map]
Theorem: finsum_mem_zero
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s✝ t s : Set α
⊢ ∏ᶠ (i : α) (_ : i ∈ s), 1 = 1
state_after: no goals
tactic: simp
Theorem: MeasureTheory.Measure.univ_pi_Ioi_ae_eq_Ici
File: Mathlib/MeasureTheory/Constructions/Pi.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (univ.pi fun i => Ioi (f i)) =ᶠ[ae (Measure.pi μ)] Ici f
state_after: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (univ.pi fun i => Ioi (f i)) =ᶠ[ae (Measure.pi μ)] univ.pi fun i => Ici (f i)
tactic: rw [← pi_univ_Ici]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (univ.pi fun i => Ioi (f i)) =ᶠ[ae (Measure.pi μ)] univ.pi fun i => Ici (f i)
state_after: no goals
tactic: exact pi_Ioi_ae_eq_pi_Ici
Theorem: Finset.Ioo_insert_right
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a < b
⊢ insert b (Ioo a b) = Ioc a b
state_after: no goals
tactic: rw [← coe_inj, coe_insert, coe_Ioo, coe_Ioc, Set.insert_eq, Set.union_comm, Set.Ioo_union_right h]
Theorem: re_inner_eq_norm_add_mul_self_sub_norm_mul_self_sub_norm_mul_self_div_two
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = (‖x + y‖ * ‖x + y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = (‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2
tactic: rw [@norm_add_mul_self 𝕜]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : E
⊢ re ⟪x, y⟫_𝕜 = (‖x‖ * ‖x‖ + 2 * re ⟪x, y⟫_𝕜 + ‖y‖ * ‖y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2
state_after: no goals
tactic: ring
Theorem: ONote.fastGrowing_zero'
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: o : ONote
h : o.fundamentalSequence = Sum.inl none
⊢ o.fastGrowing = Nat.succ
state_after: no goals
tactic: rw [fastGrowing_def h]
Theorem: List.getElem?_modifyNth
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
f : α → α
n : Nat
l : List α
⊢ (modifyNth f n l)[0]? = (fun a => if n = 0 then f a else a) <$> l[0]?
state_after: no goals
tactic: cases l <;> cases n <;> simp
state_before: α : Type u_1
f : α → α
n n✝ : Nat
⊢ (modifyNth f n [])[n✝ + 1]? = (fun a => if n = n✝ + 1 then f a else a) <$> [][n✝ + 1]?
state_after: no goals
tactic: cases n <;> rfl
state_before: α : Type u_1
f : α → α
head✝ : α
l : List α
m : Nat
⊢ (modifyNth f 0 (head✝ :: l))[m + 1]? = (fun a => if 0 = m + 1 then f a else a) <$> (head✝ :: l)[m + 1]?
state_after: no goals
tactic: cases h : l[m]? <;> simp [h, modifyNth, m.succ_ne_zero.symm]
state_before: α : Type u_1
f : α → α
n : Nat
a : α
l : List α
m : Nat
⊢ (modifyNth f (n + 1) (a :: l))[m + 1]? = (fun a => if n + 1 = m + 1 then f a else a) <$> (a :: l)[m + 1]?
state_after: α : Type u_1
f : α → α
n : Nat
a : α
l : List α
m : Nat
⊢ (modifyNth f n l)[m]? = Option.map (fun a => if n = m then f a else a) l[m]?
tactic: simp only [modifyNth_succ_cons, getElem?_cons_succ, Nat.reduceEqDiff, Option.map_eq_map]
state_before: α : Type u_1
f : α → α
n : Nat
a : α
l : List α
m : Nat
⊢ (modifyNth f n l)[m]? = Option.map (fun a => if n = m then f a else a) l[m]?
state_after: α : Type u_1
f : α → α
n : Nat
a : α
l : List α
m : Nat
⊢ (fun a => if n = m then f a else a) <$> l[m]? = Option.map (fun a => if n = m then f a else a) l[m]?
tactic: refine (getElem?_modifyNth f n l m).trans ?_
state_before: α : Type u_1
f : α → α
n : Nat
a : α
l : List α
m : Nat
⊢ (fun a => if n = m then f a else a) <$> l[m]? = Option.map (fun a => if n = m then f a else a) l[m]?
state_after: no goals
tactic: cases h' : l[m]? <;> by_cases h : n = m <;>
      simp [h, if_pos, if_neg, Option.map, mt Nat.succ.inj, not_false_iff, h']
Theorem: Complex.log_mul_eq_add_log_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x y : ℂ
hx₀ : x ≠ 0
hy₀ : y ≠ 0
⊢ log (x * y) = log x + log y ↔ x.arg + y.arg ∈ Set.Ioc (-π) π
state_after: x y : ℂ
hx₀ : x ≠ 0
hy₀ : y ≠ 0
⊢ (log (x * y)).re = (log x + log y).re ∧ (log (x * y)).im = (log x + log y).im ↔ (x * y).arg = x.arg + y.arg
tactic: refine Complex.ext_iff.trans <| Iff.trans ?_ <| arg_mul_eq_add_arg_iff hx₀ hy₀
state_before: x y : ℂ
hx₀ : x ≠ 0
hy₀ : y ≠ 0
⊢ (log (x * y)).re = (log x + log y).re ∧ (log (x * y)).im = (log x + log y).im ↔ (x * y).arg = x.arg + y.arg
state_after: no goals
tactic: simp_rw [add_re, add_im, log_re, log_im, AbsoluteValue.map_mul,
    Real.log_mul (abs.ne_zero hx₀) (abs.ne_zero hy₀), true_and]
Theorem: Euclidean.isCompact_closedBall
File: Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean

Proof steps:
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (closedBall x r)
state_after: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (⇑toEuclidean.symm '' Metric.closedBall (toEuclidean x) r)
tactic: rw [closedBall_eq_image]
state_before: E : Type u_1
inst✝⁶ : AddCommGroup E
inst✝⁵ : TopologicalSpace E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : T2Space E
inst✝² : Module ℝ E
inst✝¹ : ContinuousSMul ℝ E
inst✝ : FiniteDimensional ℝ E
x : E
r : ℝ
⊢ IsCompact (⇑toEuclidean.symm '' Metric.closedBall (toEuclidean x) r)
state_after: no goals
tactic: exact (isCompact_closedBall _ _).image toEuclidean.symm.continuous
Theorem: Set.mulIndicator_ae_eq_one
File: Mathlib/MeasureTheory/OuterMeasure/AE.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ s.mulIndicator f =ᶠ[ae μ] 1 ↔ μ (s ∩ Function.mulSupport f) = 0
state_after: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ μ {a | a ∈ s ∧ ¬f a = 1} = 0 ↔ μ (s ∩ Function.mulSupport f) = 0
tactic: simp [EventuallyEq, eventually_iff, ae, compl_setOf]
state_before: α : Type u_1
β : Type u_2
F : Type u_3
inst✝² : FunLike F (Set α) ℝ≥0∞
inst✝¹ : OuterMeasureClass F α
μ : F
s✝ t : Set α
M : Type u_4
inst✝ : One M
f : α → M
s : Set α
⊢ μ {a | a ∈ s ∧ ¬f a = 1} = 0 ↔ μ (s ∩ Function.mulSupport f) = 0
state_after: no goals
tactic: rfl
Theorem: Multiset.map_single_le_powerset
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ map singleton ⟦l⟧ ≤ powerset ⟦l⟧
state_after: α : Type u_1
s : Multiset α
l : List α
⊢ List.map singleton l <+~ List.map ofList l.sublists
tactic: simp only [powerset_coe, quot_mk_to_coe, coe_le, map_coe]
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ List.map singleton l <+~ List.map ofList l.sublists
state_after: α : Type u_1
s : Multiset α
l : List α
⊢ List.map (ofList ∘ pure) l <+~ List.map ofList l.sublists
tactic: show l.map (((↑) : List α → Multiset α) ∘ pure) <+~ (sublists l).map (↑)
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ List.map (ofList ∘ pure) l <+~ List.map ofList l.sublists
state_after: α : Type u_1
s : Multiset α
l : List α
⊢ List.map ofList (List.map pure l) <+~ List.map ofList l.sublists
tactic: rw [← List.map_map]
state_before: α : Type u_1
s : Multiset α
l : List α
⊢ List.map ofList (List.map pure l) <+~ List.map ofList l.sublists
state_after: no goals
tactic: exact ((map_pure_sublist_sublists _).map _).subperm