ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CompleteOrthogonalIdempotents.option
File: Mathlib/RingTheory/Idempotents.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
he : OrthogonalIdempotents e
⊢ (1 - ∑ i : I, e i) * ∑ i : I, e i = 0
state_after: no goals
tactic: simp [sub_mul, he.isIdempotentElem_sum.eq]
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
he : OrthogonalIdempotents e
⊢ (∑ i : I, e i) * (1 - ∑ i : I, e i) = 0
state_after: no goals
tactic: simp [mul_sub, he.isIdempotentElem_sum.eq]
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
he : OrthogonalIdempotents e
⊢ ∑ i : Option I, i.elim (1 - ∑ i : I, e i) e = 1
state_after: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
he : OrthogonalIdempotents e
⊢ none.elim (1 - ∑ i : I, e i) e + ∑ i : I, (some i).elim (1 - ∑ i : I, e i) e = 1
tactic: rw [Fintype.sum_option]
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : Ring S
f : R →+* S
I : Type u_3
e : I → R
he✝¹ : OrthogonalIdempotents e
inst✝ : Fintype I
he✝ : CompleteOrthogonalIdempotents e
he : OrthogonalIdempotents e
⊢ none.elim (1 - ∑ i : I, e i) e + ∑ i : I, (some i).elim (1 - ∑ i : I, e i) e = 1
state_after: no goals
tactic: exact sub_add_cancel _ _
Theorem: Ordinal.infinite_pigeonhole_set
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
⊢ ∃ a t, ∃ (h : t ⊆ s), θ ≤ #↑t ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f ⟨x, ⋯⟩ = a
state_after: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ ∃ a t, ∃ (h : t ⊆ s), θ ≤ #↑t ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f ⟨x, ⋯⟩ = a
tactic: cases' infinite_pigeonhole_card f θ hθ h₁ h₂ with a ha
state_before: case intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ ∃ a t, ∃ (h : t ⊆ s), θ ≤ #↑t ∧ ∀ ⦃x : β⦄ (hx : x ∈ t), f ⟨x, ⋯⟩ = a
state_after: case intro.refine_1
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ {x | ∃ (h : x ∈ s), f ⟨x, h⟩ = a} ⊆ s

case intro.refine_2
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ θ ≤ #↑{x | ∃ (h : x ∈ s), f ⟨x, h⟩ = a}

case intro.refine_3
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ ∀ ⦃x : β⦄ (hx : x ∈ {x | ∃ (h : x ∈ s), f ⟨x, h⟩ = a}), f ⟨x, ⋯⟩ = a
tactic: refine ⟨a, { x | ∃ h, f ⟨x, h⟩ = a }, ?_, ?_, ?_⟩
state_before: case intro.refine_3
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
⊢ ∀ ⦃x : β⦄ (hx : x ∈ {x | ∃ (h : x ∈ s), f ⟨x, h⟩ = a}), f ⟨x, ⋯⟩ = a
state_after: case intro.refine_3.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
x : β
w✝ : x ∈ s
hx' : f ⟨x, w✝⟩ = a
⊢ f ⟨x, ⋯⟩ = a
tactic: rintro x ⟨_, hx'⟩
state_before: case intro.refine_3.intro
α✝ : Type u_1
r : α✝ → α✝ → Prop
β α : Type u
s : Set β
f : ↑s → α
θ : Cardinal.{u}
hθ : θ ≤ #↑s
h₁ : ℵ₀ ≤ θ
h₂ : #α < θ.ord.cof
a : α
ha : θ ≤ #↑(f ⁻¹' {a})
x : β
w✝ : x ∈ s
hx' : f ⟨x, w✝⟩ = a
⊢ f ⟨x, ⋯⟩ = a
state_after: no goals
tactic: exact hx'
Theorem: Ideal.IsDedekindDomain.ramificationIdx_eq_factors_count
File: Mathlib/NumberTheory/RamificationInertia.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
inst✝ : IsDedekindDomain S
hp0 : map f p ≠ ⊥
hP : P.IsPrime
hP0 : P ≠ ⊥
⊢ ramificationIdx f p P = Multiset.count P (factors (map f p))
state_after: no goals
tactic: rw [IsDedekindDomain.ramificationIdx_eq_normalizedFactors_count hp0 hP hP0,
    factors_eq_normalizedFactors]
Theorem: Function.Commute.iterate_pos_le_iff_map_le
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
⊢ f^[n] x ≤ g^[n] x ↔ f x ≤ g x
state_after: no goals
tactic: simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt' hg hf hn)
Theorem: List.unzip_enum_eq_prod
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
l : List α
⊢ l.enum.unzip = (range l.length, l)
state_after: no goals
tactic: simp only [enum_eq_zip_range, unzip_zip, length_range]
Theorem: Nat.xor_left_injective
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n m m' : ℕ
h : m ^^^ n = m' ^^^ n
⊢ m = m'
state_after: no goals
tactic: rw [← xor_cancel_right n m, ← xor_cancel_right n m', h]
Theorem: List.le_max_of_le
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ l : List α
a x : α
hx : x ∈ l
h : a ≤ x
⊢ a ≤ foldr max ⊥ l
state_after: case nil
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l : List α
a x : α
h : a ≤ x
hx : x ∈ []
⊢ a ≤ foldr max ⊥ []

case cons
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
l✝ : List α
a x : α
h : a ≤ x
y : α
l : List α
IH : x ∈ l → a ≤ foldr max ⊥ l
hx : x ∈ y :: l
⊢ a ≤ foldr max ⊥ (y :: l)
tactic: induction' l with y l IH
Theorem: List.getElem_le_maximum_of_length_pos
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
i : ℕ
w : i < l.length
h : optParam (0 < l.length) ⋯
⊢ l[i] ≤ maximum_of_length_pos h
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
i : ℕ
w : i < l.length
h : optParam (0 < l.length) ⋯
⊢ l[i] ∈ l
tactic: apply le_maximum_of_length_pos_of_mem
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
l : List α
a m : α
i : ℕ
w : i < l.length
h : optParam (0 < l.length) ⋯
⊢ l[i] ∈ l
state_after: no goals
tactic: exact get_mem l i w
Theorem: Real.abs_rpow_le_abs_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z x y : ℝ
⊢ |x ^ y| ≤ |x| ^ y
state_after: case inl
x✝ y✝ z x y : ℝ
hx : 0 ≤ x
⊢ |x ^ y| ≤ |x| ^ y

case inr
x✝ y✝ z x y : ℝ
hx : x < 0
⊢ |x ^ y| ≤ |x| ^ y
tactic: rcases le_or_lt 0 x with hx | hx
Theorem: TopologicalSpace.Closeds.isAtom_iff
File: Mathlib/Topology/Sets/Closeds.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T1Space α
s : Closeds α
⊢ IsAtom s ↔ ∃ x, s = singleton x
state_after: no goals
tactic: simp [← Closeds.isAtom_coe, Set.isAtom_iff, SetLike.ext_iff, Set.ext_iff]
Theorem: OnePoint.isOpen_iff_of_mem'
File: Mathlib/Topology/Compactification/OnePoint.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
h : ∞ ∈ s
⊢ IsOpen s ↔ IsCompact (some ⁻¹' s)ᶜ ∧ IsOpen (some ⁻¹' s)
state_after: no goals
tactic: simp [isOpen_def, h]
Theorem: List.sum_range_sub'
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
n : ℕ
f : ℕ → G
⊢ (map (fun k => f k / f (k + 1)) (range n)).prod = f 0 / f n
state_after: case zero
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
f : ℕ → G
⊢ (map (fun k => f k / f (k + 1)) (range 0)).prod = f 0 / f 0

case succ
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : Group G
f : ℕ → G
n : ℕ
h : (map (fun k => f k / f (k + 1)) (range n)).prod = f 0 / f n
⊢ (map (fun k => f k / f (k + 1)) (range (n + 1))).prod = f 0 / f (n + 1)
tactic: induction' n with n h
Theorem: Sum.noMinOrder_iff
File: Mathlib/Data/Sum/Order.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : α
⊢ ∃ b, b < a
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a b : α
h : inl b < inl a
⊢ ∃ b, b < a

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : α
b : β
h : inr b < inl a
⊢ ∃ b, b < a
tactic: obtain ⟨b | b, h⟩ := exists_lt (inl a : α ⊕ β)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : β
⊢ ∃ b, b < a
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a : β
b : α
h : inl b < inr a
⊢ ∃ b, b < a

case intro.inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : LT α
inst✝ : LT β
x✝ : NoMinOrder (α ⊕ β)
a b : β
h : inr b < inr a
⊢ ∃ b, b < a
tactic: obtain ⟨b | b, h⟩ := exists_lt (inr a : α ⊕ β)
Theorem: CategoryTheory.Limits.limit.lift_map
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F G : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : HasLimit G
c : Cone F
α : F ⟶ G
⊢ lift F c ≫ limMap α = lift G ((Cones.postcompose α).obj c)
state_after: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F G : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : HasLimit G
c : Cone F
α : F ⟶ G
j✝ : J
⊢ (lift F c ≫ limMap α) ≫ π G j✝ = lift G ((Cones.postcompose α).obj c) ≫ π G j✝
tactic: ext
state_before: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F G : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : HasLimit G
c : Cone F
α : F ⟶ G
j✝ : J
⊢ (lift F c ≫ limMap α) ≫ π G j✝ = lift G ((Cones.postcompose α).obj c) ≫ π G j✝
state_after: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F G : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : HasLimit G
c : Cone F
α : F ⟶ G
j✝ : J
⊢ c.π.app j✝ ≫ α.app j✝ = ((Cones.postcompose α).obj c).π.app j✝
tactic: rw [assoc, limMap_π, limit.lift_π_assoc, limit.lift_π]
state_before: case w
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F G : J ⥤ C
inst✝¹ : HasLimit F
inst✝ : HasLimit G
c : Cone F
α : F ⟶ G
j✝ : J
⊢ c.π.app j✝ ≫ α.app j✝ = ((Cones.postcompose α).obj c).π.app j✝
state_after: no goals
tactic: rfl
Theorem: BoxIntegral.integral_neg
File: Mathlib/Analysis/BoxIntegral/Basic.lean

Proof steps:
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
h : ¬Integrable I l f vol
⊢ integral I l (-f) vol = -integral I l f vol
state_after: no goals
tactic: rw [integral, integral, dif_neg h, dif_neg (mt Integrable.of_neg h), neg_zero]
Theorem: Filter.HasBasis.vitaliFamily
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
ι : Sort u_2
p : ι → Prop
s : ι → Set α
x : α
h : (𝓝 x).HasBasis p s
⊢ (v.filterAt x).HasBasis p fun i => {t | t ∈ v.setsAt x ∧ t ⊆ s i}
state_after: no goals
tactic: simpa only [← Set.setOf_inter_eq_sep] using h.smallSets.inf_principal _
Theorem: MeasureTheory.AEDisjoint.union_left_iff
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
m : MeasurableSpace α
μ : Measure α
s t u v : Set α
⊢ AEDisjoint μ (s ∪ t) u ↔ AEDisjoint μ s u ∧ AEDisjoint μ t u
state_after: no goals
tactic: simp [union_eq_iUnion, and_comm]
Theorem: Ring.inverse_zero
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
⊢ inverse 0 = 0
state_after: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
a✝ : Nontrivial M₀
⊢ inverse 0 = 0
tactic: nontriviality
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
a✝ : Nontrivial M₀
⊢ inverse 0 = 0
state_after: no goals
tactic: exact inverse_non_unit _ not_isUnit_zero
Theorem: Int.two_mul
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * ↑n = ↑n + ↑n
state_after: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * n = n + n
tactic: norm_cast
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * n = n + n
state_after: no goals
tactic: exact n.two_mul
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ 2 * -[n+1] = -[n+1] + -[n+1]
state_after: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑2 * -[n+1] = -[n+1] + -[n+1]
tactic: change (2 : ℕ) * (_ : ℤ) = _
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ ↑2 * -[n+1] = -[n+1] + -[n+1]
state_after: a b c d m n✝ : ℤ
n : ℕ
⊢ -↑n.succ + -↑n.succ = -[n+1] + -[n+1]
tactic: rw [Int.ofNat_mul_negSucc, Nat.two_mul, ofNat_add, Int.neg_add]
state_before: a b c d m n✝ : ℤ
n : ℕ
⊢ -↑n.succ + -↑n.succ = -[n+1] + -[n+1]
state_after: no goals
tactic: rfl
Theorem: bernsteinPolynomial.linearIndependent_aux
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
n k : ℕ
h : k ≤ n + 1
⊢ LinearIndependent ℚ fun ν => bernsteinPolynomial ℚ n ↑ν
state_after: case zero
R : Type u_1
inst✝ : CommRing R
n : ℕ
h : 0 ≤ n + 1
⊢ LinearIndependent ℚ fun ν => bernsteinPolynomial ℚ n ↑ν

case succ
R : Type u_1
inst✝ : CommRing R
n k : ℕ
ih : k ≤ n + 1 → LinearIndependent ℚ fun ν => bernsteinPolynomial ℚ n ↑ν
h : k + 1 ≤ n + 1
⊢ LinearIndependent ℚ fun ν => bernsteinPolynomial ℚ n ↑ν
tactic: induction' k with k ih
Theorem: CategoryTheory.Iso.homToEquiv_symm_apply
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z✝ : C
α : X ≅ Y
Z : C
⊢ Function.LeftInverse (fun g => g ≫ α.inv) fun f => f ≫ α.hom
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z✝ : C
α : X ≅ Y
Z : C
⊢ Function.RightInverse (fun g => g ≫ α.inv) fun f => f ≫ α.hom
state_after: no goals
tactic: aesop_cat
Theorem: ProbabilityTheory.IndepFun.integral_mul
File: Mathlib/Probability/Integration.lean

Proof steps:
state_before: Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
⊢ integral μ (X * Y) = integral μ X * integral μ Y
state_after: case pos
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : X =ᶠ[ae μ] 0
⊢ integral μ (X * Y) = integral μ X * integral μ Y

case neg
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
⊢ integral μ (X * Y) = integral μ X * integral μ Y
tactic: by_cases h'X : X =ᵐ[μ] 0
state_before: case neg
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
⊢ integral μ (X * Y) = integral μ X * integral μ Y
state_after: case pos
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
h'Y : Y =ᶠ[ae μ] 0
⊢ integral μ (X * Y) = integral μ X * integral μ Y

case neg
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
h'Y : ¬Y =ᶠ[ae μ] 0
⊢ integral μ (X * Y) = integral μ X * integral μ Y
tactic: by_cases h'Y : Y =ᵐ[μ] 0
state_before: case neg
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
h'Y : ¬Y =ᶠ[ae μ] 0
⊢ integral μ (X * Y) = integral μ X * integral μ Y
state_after: case pos
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
h'Y : ¬Y =ᶠ[ae μ] 0
h : Integrable (X * Y) μ
⊢ integral μ (X * Y) = integral μ X * integral μ Y

case neg
Ω : Type u_1
mΩ : MeasurableSpace Ω
μ : Measure Ω
f g : Ω → ℝ≥0∞
X Y : Ω → ℝ
hXY : IndepFun X Y μ
hX : AEStronglyMeasurable X μ
hY : AEStronglyMeasurable Y μ
h'X : ¬X =ᶠ[ae μ] 0
h'Y : ¬Y =ᶠ[ae μ] 0
h : ¬Integrable (X * Y) μ
⊢ integral μ (X * Y) = integral μ X * integral μ Y
tactic: by_cases h : Integrable (X * Y) μ
Theorem: Multiset.prod_eq_foldr
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s✝ t : Multiset α
a : α
m : Multiset ι
f g : ι → α
s : Multiset α
x y z : α
⊢ (fun x x_1 => x * x_1) x ((fun x x_1 => x * x_1) y z) = (fun x x_1 => x * x_1) y ((fun x x_1 => x * x_1) x z)
state_after: no goals
tactic: simp [mul_left_comm]
Theorem: Fintype.sum_bool
File: Mathlib/Data/Fintype/BigOperators.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : CommMonoid α
f : Bool → α
⊢ ∏ b : Bool, f b = f true * f false
state_after: no goals
tactic: simp
Theorem: SimpleGraph.fromEdgeSet_mono
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

Proof steps:
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
h : s ⊆ t
⊢ fromEdgeSet s ≤ fromEdgeSet t
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
h : s ⊆ t
v w : V
⊢ (fromEdgeSet s).Adj v w → (fromEdgeSet t).Adj v w
tactic: rintro v w
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
h : s ⊆ t
v w : V
⊢ (fromEdgeSet s).Adj v w → (fromEdgeSet t).Adj v w
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
h : s ⊆ t
v w : V
⊢ s(v, w) ∈ s → ¬v = w → s(v, w) ∈ t
tactic: simp (config := { contextual := true }) only [fromEdgeSet_adj, Ne, not_false_iff,
    and_true_iff, and_imp]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v✝ w✝ : V
e : Sym2 V
s✝ s t : Set (Sym2 V)
h : s ⊆ t
v w : V
⊢ s(v, w) ∈ s → ¬v = w → s(v, w) ∈ t
state_after: no goals
tactic: exact fun vws _ => h vws
Theorem: PadicSeq.norm_neg
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
a : PadicSeq p
⊢ ∀ (k : ℕ), padicNorm p (↑(-a) k) = padicNorm p (↑a k)
state_after: no goals
tactic: simp
Theorem: Filter.comap_map
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter α
m : α → β
h : Injective m
s : Set α
hs : s ∈ f
⊢ m ⁻¹' (m '' s) ⊆ s
state_after: no goals
tactic: simp only [preimage_image_eq s h, Subset.rfl]
Theorem: WeierstrassCurve.Affine.evalEval_polynomialY_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
⊢ evalEval 0 0 W.polynomialY = W.a₃
state_after: no goals
tactic: simp only [evalEval_polynomialY, zero_add, mul_zero]
Theorem: OrderedAddCommGroup.to_contravariantClass_left_le
File: Mathlib/Algebra/Order/Group/Defs.lean

Proof steps:
state_before: α✝ α : Type u
inst✝ : OrderedCommGroup α
a b c : α
bc : a * b ≤ a * c
⊢ b ≤ c
state_after: no goals
tactic: simpa using mul_le_mul_left' bc a⁻¹
Theorem: UV.card_compress
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
⊢ (compress u v a).card = a.card
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
⊢ (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a).card = a.card
tactic: unfold compress
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
⊢ (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a).card = a.card
state_after: case pos
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
h : Disjoint u a ∧ v ≤ a
⊢ ((a ⊔ u) \ v).card = a.card

case neg
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
u v a✝ : Finset α
r : ℕ
huv : u.card = v.card
a : Finset α
h : ¬(Disjoint u a ∧ v ≤ a)
⊢ a.card = a.card
tactic: split_ifs with h
Theorem: CharP.quotient_iff_le_ker_natCast
File: Mathlib/Algebra/CharP/Quotient.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
⊢ CharP (R ⧸ I) n ↔ Ideal.comap (Nat.castRingHom R) I ≤ RingHom.ker (Nat.castRingHom R)
state_after: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
⊢ (∀ (x : ℕ), ↑x ∈ I → ↑x = 0) ↔ Ideal.comap (Nat.castRingHom R) I ≤ Ideal.comap (Nat.castRingHom R) ⊥
tactic: rw [CharP.quotient_iff, RingHom.ker_eq_comap_bot]
state_before: R : Type u_1
inst✝¹ : CommRing R
n : ℕ
inst✝ : CharP R n
I : Ideal R
⊢ (∀ (x : ℕ), ↑x ∈ I → ↑x = 0) ↔ Ideal.comap (Nat.castRingHom R) I ≤ Ideal.comap (Nat.castRingHom R) ⊥
state_after: no goals
tactic: rfl
Theorem: Complex.exp_eq_exp_re_mul_sin_add_cos
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cexp x = cexp ↑x.re * (cos ↑x.im + sin ↑x.im * I)
state_after: no goals
tactic: rw [← exp_add_mul_I, re_add_im]
Theorem: single_mem_stdSimplex
File: Mathlib/Analysis/Convex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝² : OrderedSemiring 𝕜
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
i : ι
⊢ ∑ x : ι, Pi.single i 1 x = 1
state_after: no goals
tactic: simp
Theorem: DFA.reindex_apply_accept
File: Mathlib/Computability/DFA.lean

Proof steps:
state_before: α : Type u
σ : Type v
M✝ : DFA α σ
α' : Type u_1
σ' : Type u_2
g : σ ≃ σ'
M : DFA α σ
⊢ (fun M => { step := fun s a => g.symm (M.step (g s) a), start := g.symm M.start, accept := ⇑g ⁻¹' M.accept })
      ((fun M => { step := fun s a => g (M.step (g.symm s) a), start := g M.start, accept := ⇑g.symm ⁻¹' M.accept })
        M) =
    M
state_after: no goals
tactic: simp
state_before: α : Type u
σ : Type v
M✝ : DFA α σ
α' : Type u_1
σ' : Type u_2
g : σ ≃ σ'
M : DFA α σ'
⊢ (fun M => { step := fun s a => g (M.step (g.symm s) a), start := g M.start, accept := ⇑g.symm ⁻¹' M.accept })
      ((fun M => { step := fun s a => g.symm (M.step (g s) a), start := g.symm M.start, accept := ⇑g ⁻¹' M.accept })
        M) =
    M
state_after: no goals
tactic: simp