ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.setToFun_nonneg
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : NormedAddCommGroup F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : CompleteSpace F
T✝ T' T'' : Set α → E →L[ℝ] F
C✝ C' C'' : ℝ
f✝ g : α → E
G' : Type u_7
G'' : Type u_8
inst✝⁴ : NormedLatticeAddCommGroup G''
inst✝³ : NormedSpace ℝ G''
inst✝² : CompleteSpace G''
inst✝¹ : NormedLatticeAddCommGroup G'
inst✝ : NormedSpace ℝ G'
T : Set α → G' →L[ℝ] G''
C : ℝ
hT : DominatedFinMeasAdditive μ T C
hT_nonneg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∀ (x : G'), 0 ≤ x → 0 ≤ (T s) x
f : α → G'
hf : 0 ≤ᶠ[ae μ] f
⊢ 0 ≤ setToFun μ T hT f
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : NormedAddCommGroup F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : CompleteSpace F
T✝ T' T'' : Set α → E →L[ℝ] F
C✝ C' C'' : ℝ
f✝ g : α → E
G' : Type u_7
G'' : Type u_8
inst✝⁴ : NormedLatticeAddCommGroup G''
inst✝³ : NormedSpace ℝ G''
inst✝² : CompleteSpace G''
inst✝¹ : NormedLatticeAddCommGroup G'
inst✝ : NormedSpace ℝ G'
T : Set α → G' →L[ℝ] G''
C : ℝ
hT : DominatedFinMeasAdditive μ T C
hT_nonneg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∀ (x : G'), 0 ≤ x → 0 ≤ (T s) x
f : α → G'
hf : 0 ≤ᶠ[ae μ] f
hfi : Integrable f μ
⊢ 0 ≤ setToFun μ T hT f

case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace ℝ E
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace ℝ F
inst✝⁸ : NormedAddCommGroup F'
inst✝⁷ : NormedSpace ℝ F'
inst✝⁶ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝⁵ : CompleteSpace F
T✝ T' T'' : Set α → E →L[ℝ] F
C✝ C' C'' : ℝ
f✝ g : α → E
G' : Type u_7
G'' : Type u_8
inst✝⁴ : NormedLatticeAddCommGroup G''
inst✝³ : NormedSpace ℝ G''
inst✝² : CompleteSpace G''
inst✝¹ : NormedLatticeAddCommGroup G'
inst✝ : NormedSpace ℝ G'
T : Set α → G' →L[ℝ] G''
C : ℝ
hT : DominatedFinMeasAdditive μ T C
hT_nonneg : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → ∀ (x : G'), 0 ≤ x → 0 ≤ (T s) x
f : α → G'
hf : 0 ≤ᶠ[ae μ] f
hfi : ¬Integrable f μ
⊢ 0 ≤ setToFun μ T hT f
tactic: by_cases hfi : Integrable f μ
Theorem: StrictMono.strictMono_iterate_of_lt_map
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : StrictMono f
hx : x < f x
n : ℕ
⊢ f^[n] x < f^[n + 1] x
state_after: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : StrictMono f
hx : x < f x
n : ℕ
⊢ f^[n] x < f^[n] (f x)
tactic: rw [iterate_succ_apply]
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : StrictMono f
hx : x < f x
n : ℕ
⊢ f^[n] x < f^[n] (f x)
state_after: no goals
tactic: exact hf.iterate n hx
Theorem: Ring.choose_zero_right'
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ choose r 0 = (r + 1) ^ 0
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ multichoose (r - ↑0 + 1) 0 = (r + 1) ^ 0
tactic: dsimp only [choose]
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ multichoose (r - ↑0 + 1) 0 = (r + 1) ^ 0
state_after: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 0 • x) (multichoose (r - ↑0 + 1) 0) = (fun x => Nat.factorial 0 • x) ((r + 1) ^ 0)
tactic: refine nsmul_right_injective (Nat.factorial 0) (Nat.factorial_ne_zero 0) ?_
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
r : R
⊢ (fun x => Nat.factorial 0 • x) (multichoose (r - ↑0 + 1) 0) = (fun x => Nat.factorial 0 • x) ((r + 1) ^ 0)
state_after: no goals
tactic: simp [factorial_nsmul_multichoose_eq_ascPochhammer]
Theorem: PMF.bindOnSupport_eq_zero_iff
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (p.bindOnSupport f) b = 0 ↔ ∀ (a : α) (ha : p a ≠ 0), (f a ha) b = 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (∀ (i : α), ¬p i = 0 → (if h : p i = 0 then 0 else (f i h) b) = 0) ↔ ∀ (a : α) (ha : p a ≠ 0), (f a ha) b = 0
tactic: simp only [bindOnSupport_apply, ENNReal.tsum_eq_zero, mul_eq_zero, or_iff_not_imp_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
b : β
⊢ (∀ (i : α), ¬p i = 0 → (if h : p i = 0 then 0 else (f i h) b) = 0) ↔ ∀ (a : α) (ha : p a ≠ 0), (f a ha) b = 0
state_after: no goals
tactic: exact ⟨fun h a ha => Trans.trans (dif_neg ha).symm (h a ha),
    fun h a ha => Trans.trans (dif_neg ha) (h a ha)⟩
Theorem: CategoryTheory.Functor.final_of_adjunction
File: Mathlib/CategoryTheory/Limits/Final.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
c : C
u : StructuredArrow c R := StructuredArrow.mk (adj.unit.app c)
f g : StructuredArrow c R
⊢ u.hom ≫ R.map ((adj.homEquiv c f.right).symm f.hom) = f.hom
state_after: no goals
tactic: simp [u]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
L : C ⥤ D
R : D ⥤ C
adj : L ⊣ R
c : C
u : StructuredArrow c R := StructuredArrow.mk (adj.unit.app c)
f g : StructuredArrow c R
⊢ u.hom ≫ R.map ((adj.homEquiv c g.right).symm g.hom) = g.hom
state_after: no goals
tactic: simp [u]
Theorem: LieModule.mem_weightSpaceOf
File: Mathlib/Algebra/Lie/Weights/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : R
x : L
m : M
⊢ m ∈ weightSpaceOf M χ x ↔ ∃ k, (((toEnd R L M) x - χ • 1) ^ k) m = 0
state_after: no goals
tactic: simp [weightSpaceOf]
Theorem: PowerSeries.mk_one_pow_eq_mk_choose_add
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

Proof steps:
state_before: S : Type u_1
inst✝ : CommRing S
d : ℕ
⊢ mk 1 ^ (d + 1) = mk fun n => ↑((d + n).choose d)
state_after: no goals
tactic: induction d with
  | zero => ext; simp
  | succ d hd =>
      ext n
      rw [pow_add, hd, pow_one, mul_comm, coeff_mul]
      simp_rw [coeff_mk, Pi.one_apply, one_mul]
      norm_cast
      rw [Finset.sum_antidiagonal_choose_add, ← Nat.choose_succ_succ, Nat.succ_eq_add_one,
        add_right_comm]
Theorem: Real.volume_pi_Ico_toReal
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ι → ℝ
h : a ≤ b
⊢ (volume (univ.pi fun i => Ico (a i) (b i))).toReal = ∏ i : ι, (b i - a i)
state_after: no goals
tactic: simp only [volume_pi_Ico, ENNReal.toReal_prod, ENNReal.toReal_ofReal (sub_nonneg.2 (h _))]
Theorem: CategoryTheory.Grothendieck.comp_fiber
File: Mathlib/CategoryTheory/Grothendieck.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.6198, u_1} C
inst✝ : Category.{?u.6202, u_2} D
F : C ⥤ Cat
X Y Z : Grothendieck F
f : X.Hom Y
g : Y.Hom Z
⊢ (F.map (f.base ≫ g.base)).obj X.fiber = (F.map g.base).obj ((F.map f.base).obj X.fiber)
state_after: no goals
tactic: erw [Functor.map_comp, Functor.comp_obj]
Theorem: Set.Subsingleton.einfsep
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.Subsingleton
⊢ s.einfsep = ⊤
state_after: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.Subsingleton
⊢ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → edist x y = ⊤
tactic: rw [einfsep_top]
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.Subsingleton
⊢ ∀ x ∈ s, ∀ y ∈ s, x ≠ y → edist x y = ⊤
state_after: no goals
tactic: exact fun _ hx _ hy hxy => (hxy <| hs hx hy).elim
Theorem: Filter.Tendsto.mul_atTop
File: Mathlib/Topology/Algebra/Order/Field.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l (𝓝 C)
hg : Tendsto g l atTop
⊢ Tendsto (fun x => f x * g x) l atTop
state_after: no goals
tactic: simpa only [mul_comm] using hg.atTop_mul hC hf
Theorem: Basis.toDual_total_left
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ (b.toDual ((Finsupp.total ι M R ⇑b) f)) (b i) = f i
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ ∑ d ∈ f.support, (b.toDual (f d • b d)) (b i) = f i
tactic: rw [Finsupp.total_apply, Finsupp.sum, _root_.map_sum, LinearMap.sum_apply]
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ ∑ d ∈ f.support, (b.toDual (f d • b d)) (b i) = f i
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ (if i ∈ f.support then f i else 0) = f i
tactic: simp_rw [LinearMap.map_smul, LinearMap.smul_apply, toDual_apply, smul_eq_mul, mul_boole,
    Finset.sum_ite_eq']
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
⊢ (if i ∈ f.support then f i else 0) = f i
state_after: case pos
R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
h : i ∈ f.support
⊢ f i = f i

case neg
R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι : Type uι
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : DecidableEq ι
b : Basis ι R M
f : ι →₀ R
i : ι
h : i ∉ f.support
⊢ 0 = f i
tactic: split_ifs with h
Theorem: MulEquiv.comp_right_injective
File: Mathlib/Algebra/Group/Equiv/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
A : Type u_4
B : Type u_5
M : Type u_6
N : Type u_7
P : Type u_8
Q : Type u_9
G : Type u_10
H : Type u_11
inst✝³ : EquivLike F α β
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
e : M ≃* N
f : P →* M
⊢ (↑e.symm).comp ((↑e).comp f) = f
state_after: no goals
tactic: simp [← MonoidHom.comp_assoc]
Theorem: FreeGroup.Red.Step.append_left_iff
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ Step ([] ++ L₁) ([] ++ L₂) ↔ Step L₁ L₂
state_after: no goals
tactic: simp
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
p : α × Bool
l : List (α × Bool)
⊢ Step (p :: l ++ L₁) (p :: l ++ L₂) ↔ Step L₁ L₂
state_after: no goals
tactic: simp [Step.append_left_iff l, Step.cons_cons_iff]
Theorem: Array.size_filter_le
File: .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : Array α
⊢ (filter p l 0).size ≤ l.size
state_after: α : Type u_1
p : α → Bool
l : Array α
⊢ (List.filter p l.data).length ≤ l.data.length
tactic: simp only [← data_length, filter_data]
state_before: α : Type u_1
p : α → Bool
l : Array α
⊢ (List.filter p l.data).length ≤ l.data.length
state_after: no goals
tactic: apply List.length_filter_le
Theorem: Finsupp.support_onFinset
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
inst✝ : DecidableEq M
s : Finset α
f : α → M
hf : ∀ (a : α), f a ≠ 0 → a ∈ s
⊢ (onFinset s f hf).support = filter (fun a => f a ≠ 0) s
state_after: α : 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
inst✝ : DecidableEq M
s : Finset α
f : α → M
hf : ∀ (a : α), f a ≠ 0 → a ∈ s
⊢ filter (fun x => ¬f x = 0) s = filter (fun a => ¬f a = 0) s
tactic: dsimp [onFinset]
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
inst✝ : DecidableEq M
s : Finset α
f : α → M
hf : ∀ (a : α), f a ≠ 0 → a ∈ s
⊢ filter (fun x => ¬f x = 0) s = filter (fun a => ¬f a = 0) s
state_after: no goals
tactic: congr
Theorem: Ordinal.nfpFamily_le_fp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
⊢ List.foldr f a l ≤ b
state_after: case pos
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : IsEmpty ι
⊢ List.foldr f a l ≤ b

case neg
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
a b : Ordinal.{max u v}
ab : a ≤ b
h : ∀ (i : ι), f i b ≤ b
l : List ι
hι : ¬IsEmpty ι
⊢ List.foldr f a l ≤ b
tactic: by_cases hι : IsEmpty ι
Theorem: Sym2.sortEquiv_apply_coe
File: Mathlib/Data/Sym/Sym2/Order.lean

Proof steps:
state_before: α : Type ?u.2288
inst✝ : LinearOrder α
a b : α
⊢ ↑((fun s => ⟨(s.inf, s.sup), ⋯⟩) s(a, b)) = (a, b) ∨ ↑((fun s => ⟨(s.inf, s.sup), ⋯⟩) s(a, b)) = (a, b).swap
state_after: no goals
tactic: cases le_total a b with
    | inl h => simp [h]
    | inr h => simp [h]
state_before: α : Type ?u.2288
inst✝ : LinearOrder α
x y : α
hxy : (x, y).1 ≤ (x, y).2
⊢ (↑((fun s => ⟨(s.inf, s.sup), ⋯⟩) ((fun p => Sym2.mk ↑p) ⟨(x, y), hxy⟩))).1 = (↑⟨(x, y), hxy⟩).1
state_after: no goals
tactic: simp [hxy]
state_before: α : Type ?u.2288
inst✝ : LinearOrder α
x y : α
hxy : (x, y).1 ≤ (x, y).2
⊢ (↑((fun s => ⟨(s.inf, s.sup), ⋯⟩) ((fun p => Sym2.mk ↑p) ⟨(x, y), hxy⟩))).2 = (↑⟨(x, y), hxy⟩).2
state_after: no goals
tactic: simp [hxy]
Theorem: intervalIntegral.integral_undef
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
h : ¬IntervalIntegrable f μ a b
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
h : ¬IntegrableOn f (Ι a b) μ
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0
tactic: rw [intervalIntegrable_iff] at h
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
h : ¬IntegrableOn f (Ι a b) μ
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0
state_after: no goals
tactic: rw [intervalIntegral_eq_integral_uIoc, integral_undef h, smul_zero]
Theorem: Set.ncard_union_add_ncard_inter
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
hs : autoParam s.Finite _auto✝
ht : autoParam t.Finite _auto✝
⊢ (s ∪ t).ncard + (s ∩ t).ncard = s.ncard + t.ncard
state_after: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
hs : autoParam s.Finite _auto✝
ht : autoParam t.Finite _auto✝
⊢ ↑(s ∪ t).ncard + ↑(s ∩ t).ncard = ↑s.ncard + ↑t.ncard
tactic: to_encard_tac
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
hs : autoParam s.Finite _auto✝
ht : autoParam t.Finite _auto✝
⊢ ↑(s ∪ t).ncard + ↑(s ∩ t).ncard = ↑s.ncard + ↑t.ncard
state_after: no goals
tactic: rw [hs.cast_ncard_eq, ht.cast_ncard_eq, (hs.union ht).cast_ncard_eq,
    (hs.subset inter_subset_left).cast_ncard_eq, encard_union_add_encard_inter]
Theorem: Finset.prod_range_succ_comm
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
n : ℕ
⊢ ∏ x ∈ range (n + 1), f x = f n * ∏ x ∈ range n, f x
state_after: no goals
tactic: rw [range_succ, prod_insert not_mem_range_self]
Theorem: ComplexShape.Embedding.not_boundaryGE_next'
File: Mathlib/Algebra/Homology/Embedding/Boundary.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
j k : ι
hj : ¬e.BoundaryGE j
hk : c.next j = k
⊢ ¬e.BoundaryGE k
state_after: case pos
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
j k : ι
hj : ¬e.BoundaryGE j
hk : c.next j = k
hjk : c.Rel j k
⊢ ¬e.BoundaryGE k

case neg
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
inst✝ : e.IsRelIff
j k : ι
hj : ¬e.BoundaryGE j
hk : c.next j = k
hjk : ¬c.Rel j k
⊢ ¬e.BoundaryGE k
tactic: by_cases hjk : c.Rel j k
Theorem: Orientation.rightAngleRotation_map_complex
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
f : E ≃ₗᵢ[ℝ] ℂ
hf : (map (Fin 2) f.toLinearEquiv) o = Complex.orientation
x : E
⊢ f (o.rightAngleRotation x) = I * f x
state_after: no goals
tactic: rw [← Complex.rightAngleRotation, ← hf, rightAngleRotation_map (hF := _),
    LinearIsometryEquiv.symm_apply_apply]
Theorem: Commute.pow_dvd_pow_of_add_pow_eq_zero
File: Mathlib/Algebra/Ring/Divisibility/Lemmas.lean

Proof steps:
state_before: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ y ^ p
state_after: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p * (-1) ^ p
tactic: rw [← neg_neg y, neg_pow']
state_before: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p * (-1) ^ p
state_after: case h
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p
tactic: apply dvd_mul_of_dvd_left
state_before: case h
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ x ^ m ∣ (-y) ^ p
state_after: case h
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ (x - -y) ^ n = 0
tactic: apply h_comm.neg_right.pow_dvd_pow_of_sub_pow_eq_zero hp
state_before: case h
R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
h : (x + y) ^ n = 0
⊢ (x - -y) ^ n = 0
state_after: no goals
tactic: simpa
Theorem: FormalMultilinearSeries.leftInv_removeZero
File: Mathlib/Analysis/Analytic/Inverse.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
⊢ p.removeZero.leftInv i = p.leftInv i
state_after: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
n : ℕ
⊢ p.removeZero.leftInv i n = p.leftInv i n
tactic: ext1 n
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
n : ℕ
⊢ p.removeZero.leftInv i n = p.leftInv i n
state_after: case h.H
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
n : ℕ
IH : ∀ m < n, p.removeZero.leftInv i m = p.leftInv i m
⊢ p.removeZero.leftInv i n = p.leftInv i n
tactic: induction' n using Nat.strongRec' with n IH
state_before: case h.H
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
n : ℕ
IH : ∀ m < n, p.removeZero.leftInv i m = p.leftInv i m
⊢ p.removeZero.leftInv i n = p.leftInv i n
state_after: no goals
tactic: match n with
  | 0 => simp -- if one replaces `simp` with `refl`, the proof times out in the kernel.
  | 1 => simp -- TODO: why?
  | n + 2 =>
    simp only [leftInv, neg_inj]
    refine Finset.sum_congr rfl fun c cuniv => ?_
    rcases c with ⟨c, hc⟩
    ext v
    dsimp
    simp [IH _ hc]
Theorem: tendsto_list_sum
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f : ι → α → M
x : Filter α
a : ι → M
x✝ : ∀ i ∈ [], Tendsto (f i) x (𝓝 (a i))
⊢ Tendsto (fun b => (List.map (fun c => f c b) []).prod) x (𝓝 (List.map a []).prod)
state_after: no goals
tactic: simp [tendsto_const_nhds]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => (List.map (fun c => f✝ c b) (f :: l)).prod) x (𝓝 (List.map a (f :: l)).prod)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => f✝ f b * (List.map (fun c => f✝ c b) l).prod) x (𝓝 (a f * (List.map a l).prod))
tactic: simp only [List.map_cons, List.prod_cons]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
f✝ : ι → α → M
x : Filter α
a : ι → M
f : ι
l : List ι
h : ∀ i ∈ f :: l, Tendsto (f✝ i) x (𝓝 (a i))
⊢ Tendsto (fun b => f✝ f b * (List.map (fun c => f✝ c b) l).prod) x (𝓝 (a f * (List.map a l).prod))
state_after: no goals
tactic: exact
      (h f (List.mem_cons_self _ _)).mul
        (tendsto_list_prod l fun c hc => h c (List.mem_cons_of_mem _ hc))
Theorem: IntermediateField.lift_top
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
K : IntermediateField F E
⊢ lift ⊤ = K
state_after: no goals
tactic: rw [lift, ← AlgHom.fieldRange_eq_map, fieldRange_val]