ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: edist_le_tsum_of_edist_le_of_tendsto
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
⊢ edist (f n) a ≤ ∑' (m : ℕ), d (n + m)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ m ∈ {x | (fun c => edist (f n) (f c) ≤ ∑' (m : ℕ), d (n + m)) x}
tactic: refine le_of_tendsto (tendsto_const_nhds.edist ha) (mem_atTop_sets.2 ⟨n, fun m hnm => ?_⟩)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ m ∈ {x | (fun c => edist (f n) (f c) ≤ ∑' (m : ℕ), d (n + m)) x}
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ edist (f n) (f m) ≤ ∑' (m : ℕ), d (n + m)
tactic: change edist _ _ ≤ _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ edist (f n) (f m) ≤ ∑' (m : ℕ), d (n + m)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ ∑ i ∈ Finset.Ico n m, d i ≤ ∑' (m : ℕ), d (n + m)
tactic: refine le_trans (edist_le_Ico_sum_of_edist_le hnm fun _ _ => hf _) ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ ∑ i ∈ Finset.Ico n m, d i ≤ ∑' (m : ℕ), d (n + m)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ ∑ k ∈ Finset.range (m - n), d (n + k) ≤ ∑' (m : ℕ), d (n + m)
tactic: rw [Finset.sum_Ico_eq_sum_range]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : PseudoEMetricSpace α
f : ℕ → α
d : ℕ → ℝ≥0∞
hf : ∀ (n : ℕ), edist (f n) (f n.succ) ≤ d n
a : α
ha : Tendsto f atTop (𝓝 a)
n m : ℕ
hnm : m ≥ n
⊢ ∑ k ∈ Finset.range (m - n), d (n + k) ≤ ∑' (m : ℕ), d (n + m)
state_after: no goals
tactic: exact sum_le_tsum _ (fun _ _ => zero_le _) ENNReal.summable
Theorem: MeasureTheory.not_isFiniteMeasure_iff
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
⊢ ¬IsFiniteMeasure μ ↔ μ univ = ⊤
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
h : ¬IsFiniteMeasure μ
⊢ μ univ = ⊤
tactic: refine ⟨fun h => ?_, fun h => fun h' => h'.measure_univ_lt_top.ne h⟩
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
h : ¬IsFiniteMeasure μ
⊢ μ univ = ⊤
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
h : ¬IsFiniteMeasure μ
h' : ¬μ univ = ⊤
⊢ False
tactic: by_contra h'
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
h : ¬IsFiniteMeasure μ
h' : ¬μ univ = ⊤
⊢ False
state_after: no goals
tactic: exact h ⟨lt_top_iff_ne_top.mpr h'⟩
Theorem: MeasureTheory.Measure.toSignedMeasure_apply
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
⊢ (fun s => if MeasurableSet s then (μ s).toReal else 0) ∅ = 0
state_after: no goals
tactic: simp [μ.empty]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ HasSum (fun i => (fun s => if MeasurableSet s then (μ s).toReal else 0) (f i))
    ((fun s => if MeasurableSet s then (μ s).toReal else 0) (⋃ i, f i))
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ HasSum (fun i => (μ (f i)).toReal) (∑' (i : ℕ), μ (f i)).toReal
tactic: simp only [*, MeasurableSet.iUnion hf₁, if_true, measure_iUnion hf₂ hf₁]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ HasSum (fun i => (μ (f i)).toReal) (∑' (i : ℕ), μ (f i)).toReal
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ HasSum (fun i => (μ (f i)).toReal) (∑' (a : ℕ), (μ (f a)).toReal)

α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ ∀ (a : ℕ), μ (f a) ≠ ⊤
tactic: rw [ENNReal.tsum_toReal_eq]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ HasSum (fun i => (μ (f i)).toReal) (∑' (a : ℕ), (μ (f a)).toReal)

α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ : Measure α
hμ : IsFiniteMeasure μ
f : ℕ → Set α
hf₁ : ∀ (i : ℕ), MeasurableSet (f i)
hf₂ : Pairwise (Disjoint on f)
⊢ ∀ (a : ℕ), μ (f a) ≠ ⊤
state_after: no goals
tactic: exacts [(summable_measure_toReal hf₁ hf₂).hasSum, fun _ ↦ measure_ne_top _ _]
Theorem: CliffordAlgebra.EquivEven.neg_v_mul_e0
File: Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ -((v Q) m * e0 Q) = e0 Q * (v Q) m
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (v Q) m * e0 Q = -(e0 Q * (v Q) m)
tactic: rw [neg_eq_iff_eq_neg]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
m : M
⊢ (v Q) m * e0 Q = -(e0 Q * (v Q) m)
state_after: no goals
tactic: exact (neg_e0_mul_v _ m).symm
Theorem: CategoryTheory.Comma.preLeft_map_left
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁷ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁶ : Category.{v₂, u₂} B
T : Type u₃
inst✝⁵ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝⁴ : Category.{?u.129256, u_1} A'
inst✝³ : Category.{?u.129260, u_2} B'
inst✝² : Category.{?u.129264, u_3} T'
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
F : C ⥤ A
L : A ⥤ T
R : B ⥤ T
X✝ Y✝ : Comma (F ⋙ L) R
f : X✝ ⟶ Y✝
⊢ L.map (F.map f.left) ≫ ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) Y✝).hom =
    ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) X✝).hom ≫ R.map f.right
state_after: no goals
tactic: simpa using f.w
Theorem: Subgroup.IsComplement.mul_eq
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S T
x : G
⊢ x ∈ S * T
state_after: no goals
tactic: simpa [mem_mul] using (h.existsUnique x).exists
Theorem: String.Pos.valid_endPos
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: s : String
⊢ s.data ++ [] = s.data
state_after: no goals
tactic: simp
Theorem: InnerProductSpace.Core.inner_sub_left
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✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y z : F
⊢ ⟪x - y, z⟫_𝕜 = ⟪x, z⟫_𝕜 - ⟪y, z⟫_𝕜
state_after: no goals
tactic: simp [sub_eq_add_neg, inner_add_left, inner_neg_left]
Theorem: normUnit_mul_normUnit
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
⊢ normUnit (a * ↑(normUnit a)) = 1
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
a✝ : Nontrivial α
⊢ normUnit (a * ↑(normUnit a)) = 1
tactic: nontriviality α using Subsingleton.elim a 0
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
a✝ : Nontrivial α
⊢ normUnit (a * ↑(normUnit a)) = 1
state_after: case inl
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a✝ : Nontrivial α
⊢ normUnit (0 * ↑(normUnit 0)) = 1

case inr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
a✝ : Nontrivial α
h : a ≠ 0
⊢ normUnit (a * ↑(normUnit a)) = 1
tactic: obtain rfl | h := eq_or_ne a 0
Theorem: MeasureTheory.OuterMeasure.map_sup
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
m✝ : OuterMeasure α
β : Type u_3
f : α → β
m m' : OuterMeasure α
s : Set β
⊢ ((map f) (m ⊔ m')) s = ((map f) m ⊔ (map f) m') s
state_after: no goals
tactic: simp only [map_apply, sup_apply]
Theorem: AddSubgroup.norm_normedMk_le
File: Mathlib/Analysis/Normed/Group/Quotient.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
⊢ ‖S.normedMk m‖ ≤ 1 * ‖m‖
state_after: no goals
tactic: simp [quotient_norm_mk_le']
Theorem: Odd.neg_one_zpow
File: Mathlib/Algebra/Field/Power.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DivisionRing α
n : ℤ
h : Odd n
⊢ (-1) ^ n = -1
state_after: no goals
tactic: rw [h.neg_zpow, one_zpow]
Theorem: Algebra.IsAlgebraic.algEquivEquivAlgHom_apply
File: Mathlib/RingTheory/Algebraic.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L ≃ₐ[K] L
⊢ (fun ϕ => AlgEquiv.ofBijective ϕ ⋯) ((fun ϕ => ↑ϕ) x✝) = x✝
state_after: case h
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L ≃ₐ[K] L
a✝ : L
⊢ ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) ((fun ϕ => ↑ϕ) x✝)) a✝ = x✝ a✝
tactic: ext
state_before: case h
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L ≃ₐ[K] L
a✝ : L
⊢ ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) ((fun ϕ => ↑ϕ) x✝)) a✝ = x✝ a✝
state_after: no goals
tactic: rfl
state_before: K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝ : L →ₐ[K] L
⊢ (fun ϕ => ↑ϕ) ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) x✝) = x✝
state_after: case H
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝¹ : L →ₐ[K] L
x✝ : L
⊢ ((fun ϕ => ↑ϕ) ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case H
K : Type u_1
L : Type u_2
R : Type u_3
S : Type u_4
A : Type u_5
inst✝⁴ : CommRing K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : NoZeroSMulDivisors K L
inst✝ : Algebra.IsAlgebraic K L
x✝¹ : L →ₐ[K] L
x✝ : L
⊢ ((fun ϕ => ↑ϕ) ((fun ϕ => AlgEquiv.ofBijective ϕ ⋯) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.regularTopology.equalizerCondition_iff_isIso_lift
File: Mathlib/CategoryTheory/Sites/Coherent/RegularSheaves.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{?u.37395, u_2} D
inst✝ : Category.{?u.37399, u_3} E
P : Cᵒᵖ ⥤ Type u_4
⊢ EqualizerCondition P ↔
    ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π], IsIso (equalizer.lift (P.map π.op) ⋯)
state_after: case mp
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{?u.37395, u_2} D
inst✝ : Category.{?u.37399, u_3} E
P : Cᵒᵖ ⥤ Type u_4
⊢ EqualizerCondition P →
    ∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π], IsIso (equalizer.lift (P.map π.op) ⋯)

case mpr
C : Type u_1
D : Type u_2
E : Type u_3
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{?u.37395, u_2} D
inst✝ : Category.{?u.37399, u_3} E
P : Cᵒᵖ ⥤ Type u_4
⊢ (∀ (X B : C) (π : X ⟶ B) [inst : EffectiveEpi π] [inst : HasPullback π π], IsIso (equalizer.lift (P.map π.op) ⋯)) →
    EqualizerCondition P
tactic: constructor
Theorem: Finset.filter_eq_self
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
s t : Finset α
⊢ filter p s = s ↔ ∀ x ∈ s, p x
state_after: no goals
tactic: simp [Finset.ext_iff]
Theorem: Real.abs_rpow_le_exp_log_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x✝ y✝ z x y : ℝ
⊢ |x ^ y| ≤ rexp (log x * y)
state_after: x✝ y✝ z x y : ℝ
⊢ |x| ^ y ≤ rexp (log x * y)
tactic: refine (abs_rpow_le_abs_rpow x y).trans ?_
state_before: x✝ y✝ z x y : ℝ
⊢ |x| ^ y ≤ rexp (log x * y)
state_after: case pos
x✝ y✝ z x y : ℝ
hx : x = 0
⊢ |x| ^ y ≤ rexp (log x * y)

case neg
x✝ y✝ z x y : ℝ
hx : ¬x = 0
⊢ |x| ^ y ≤ rexp (log x * y)
tactic: by_cases hx : x = 0
Theorem: Polynomial.reverse_add_C
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f p : R[X]
t : R
⊢ (p + C t).reverse = p.reverse + C t * X ^ p.natDegree
state_after: no goals
tactic: simp [reverse]
Theorem: CategoryTheory.MonoidalCategory.fullBraidedSubcategoryInclusion_μ
File: Mathlib/CategoryTheory/Monoidal/Subcategory.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    inv ((fullMonoidalSubcategoryInclusion P).μ X Y) ≫
      (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
        (fullMonoidalSubcategoryInclusion P).μ Y X
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).μ X Y ≫ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
      (fullMonoidalSubcategoryInclusion P).μ Y X
tactic: rw [IsIso.eq_inv_comp]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : MonoidalCategory C
P : C → Prop
inst✝² : MonoidalPredicate P
P' : C → Prop
inst✝¹ : MonoidalPredicate P'
inst✝ : BraidedCategory C
X Y : FullSubcategory P
⊢ (fullMonoidalSubcategoryInclusion P).μ X Y ≫ (fullMonoidalSubcategoryInclusion P).map (β_ X Y).hom =
    (β_ ((fullMonoidalSubcategoryInclusion P).obj X) ((fullMonoidalSubcategoryInclusion P).obj Y)).hom ≫
      (fullMonoidalSubcategoryInclusion P).μ Y X
state_after: no goals
tactic: aesop_cat
Theorem: Complex.re_mul_ofReal
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: z : ℂ
r : ℝ
⊢ (z * ↑r).re = z.re * r
state_after: no goals
tactic: simp [ofReal']
Theorem: Set.ordConnected_inter_Icc_iff
File: Mathlib/Order/Interval/Set/OrdConnected.lean

Proof steps:
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x y : α
hx : x ∈ s
hy : y ∈ s
⊢ (s ∩ Icc x y).OrdConnected ↔ Ioo x y ⊆ s
state_after: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x y : α
hx : x ∈ s
hy : y ∈ s
h : (s ∩ Icc x y).OrdConnected
z : α
hz : z ∈ Icc x y
⊢ z ∈ s
tactic: refine ⟨fun h ↦ Ioo_subset_Icc_self.trans fun z hz ↦ ?_, ordConnected_inter_Icc_of_subset⟩
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x y : α
hx : x ∈ s
hy : y ∈ s
h : (s ∩ Icc x y).OrdConnected
z : α
hz : z ∈ Icc x y
⊢ z ∈ s
state_after: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x y : α
hx : x ∈ s
hy : y ∈ s
h : (s ∩ Icc x y).OrdConnected
z : α
hz : z ∈ Icc x y
hxy : x ≤ y
⊢ z ∈ s
tactic: have hxy : x ≤ y := hz.1.trans hz.2
state_before: α : Type u_1
inst✝ : PartialOrder α
s : Set α
x y : α
hx : x ∈ s
hy : y ∈ s
h : (s ∩ Icc x y).OrdConnected
z : α
hz : z ∈ Icc x y
hxy : x ≤ y
⊢ z ∈ s
state_after: no goals
tactic: exact h.out ⟨hx, left_mem_Icc.2 hxy⟩ ⟨hy, right_mem_Icc.2 hxy⟩ hz |>.1
Theorem: CategoryTheory.algebraEquivUnder_inverse
File: Mathlib/CategoryTheory/Monad/Products.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryCoproducts C
A : (coprodMonad X).Algebra
⊢ coprod.inl ≫
      (coprodMonad X).map (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom ≫
        ((algebraToUnder X ⋙ underToAlgebra X).obj A).a =
    coprod.inl ≫ ((𝟭 (coprodMonad X).Algebra).obj A).a ≫ (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : C
inst✝ : HasBinaryCoproducts C
A : (coprodMonad X).Algebra
⊢ coprod.inr ≫
      (coprodMonad X).map (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom ≫
        ((algebraToUnder X ⋙ underToAlgebra X).obj A).a =
    coprod.inr ≫ ((𝟭 (coprodMonad X).Algebra).obj A).a ≫ (Iso.refl ((𝟭 (coprodMonad X).Algebra).obj A).A).hom
state_after: no goals
tactic: simpa using A.unit.symm
Theorem: Matrix.IsHermitian.spectral_theorem
File: Mathlib/LinearAlgebra/Matrix/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
n : Type u_2
inst✝¹ : Fintype n
A : Matrix n n 𝕜
inst✝ : DecidableEq n
hA : A.IsHermitian
⊢ A = ↑hA.eigenvectorUnitary * diagonal (RCLike.ofReal ∘ hA.eigenvalues) * star ↑hA.eigenvectorUnitary
state_after: no goals
tactic: rw [← star_mul_self_mul_eq_diagonal, mul_assoc, mul_assoc,
    (Matrix.mem_unitaryGroup_iff).mp (eigenvectorUnitary hA).2, mul_one,
    ← mul_assoc, (Matrix.mem_unitaryGroup_iff).mp (eigenvectorUnitary hA).2, one_mul]
Theorem: Module.DualBases.mem_of_mem_span
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
x : M
hmem : x ∈ Submodule.span R (e '' H)
⊢ ∀ (i : ι), (ε i) x ≠ 0 → i ∈ H
state_after: R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
x : M
hmem : x ∈ Submodule.span R (e '' H)
i : ι
hi : (ε i) x ≠ 0
⊢ i ∈ H
tactic: intro i hi
state_before: R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
x : M
hmem : x ∈ Submodule.span R (e '' H)
i : ι
hi : (ε i) x ≠ 0
⊢ i ∈ H
state_after: case intro.intro
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
i : ι
l : ι →₀ R
supp_l : l ∈ Finsupp.supported R R H
hmem : (Finsupp.total ι M R e) l ∈ Submodule.span R (e '' H)
hi : (ε i) ((Finsupp.total ι M R e) l) ≠ 0
⊢ i ∈ H
tactic: rcases (Finsupp.mem_span_image_iff_total _).mp hmem with ⟨l, supp_l, rfl⟩
state_before: case intro.intro
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
i : ι
l : ι →₀ R
supp_l : l ∈ Finsupp.supported R R H
hmem : (Finsupp.total ι M R e) l ∈ Submodule.span R (e '' H)
hi : (ε i) ((Finsupp.total ι M R e) l) ≠ 0
⊢ i ∈ H
state_after: case intro.intro
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
i : ι
l : ι →₀ R
supp_l : l ∈ Finsupp.supported R R H
hmem : (Finsupp.total ι M R e) l ∈ Submodule.span R (e '' H)
hi : (ε i) ((Finsupp.total ι M R e) l) ≠ 0
⊢ ¬l i = 0
tactic: apply not_imp_comm.mp ((Finsupp.mem_supported' _ _).mp supp_l i)
state_before: case intro.intro
R : Type u_1
M : Type u_2
ι : Type u_3
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
e : ι → M
ε : ι → Dual R M
inst✝ : DecidableEq ι
h : DualBases e ε
H : Set ι
i : ι
l : ι →₀ R
supp_l : l ∈ Finsupp.supported R R H
hmem : (Finsupp.total ι M R e) l ∈ Submodule.span R (e '' H)
hi : (ε i) ((Finsupp.total ι M R e) l) ≠ 0
⊢ ¬l i = 0
state_after: no goals
tactic: rwa [← lc_def, h.dual_lc] at hi
Theorem: measurable_of_isOpen
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : OpensMeasurableSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : OpensMeasurableSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : TopologicalSpace γ₂
inst✝² : MeasurableSpace γ₂
inst✝¹ : BorelSpace γ₂
inst✝ : MeasurableSpace δ
f : δ → γ
hf : ∀ (s : Set γ), IsOpen s → MeasurableSet (f ⁻¹' s)
⊢ Measurable f
state_after: no goals
tactic: exact measurable_generateFrom hf
Theorem: ENNReal.orderIsoRpow_symm_apply
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: y : ℝ
hy : 0 < y
⊢ (orderIsoRpow y hy).symm = orderIsoRpow (1 / y) ⋯
state_after: y : ℝ
hy : 0 < y
⊢ (StrictMono.orderIsoOfRightInverse (fun x => x ^ y) ⋯ (fun x => x ^ (1 / y)) ⋯).symm =
    StrictMono.orderIsoOfRightInverse (fun x => x ^ (1 / y)) ⋯ (fun x => x ^ y) ⋯
tactic: simp only [orderIsoRpow, one_div_one_div]
state_before: y : ℝ
hy : 0 < y
⊢ (StrictMono.orderIsoOfRightInverse (fun x => x ^ y) ⋯ (fun x => x ^ (1 / y)) ⋯).symm =
    StrictMono.orderIsoOfRightInverse (fun x => x ^ (1 / y)) ⋯ (fun x => x ^ y) ⋯
state_after: no goals
tactic: rfl
Theorem: Finset.sum_antidiagonal_choose_succ_mul
File: Mathlib/Data/Nat/Choose/Sum.lean

Proof steps:
state_before: R✝ : Type u_1
M : Type u_2
R : Type u_3
inst✝¹ : CommMonoid M
inst✝ : NonAssocSemiring R
f : ℕ → ℕ → R
n : ℕ
⊢ ∑ ij ∈ antidiagonal (n + 1), ↑((n + 1).choose ij.1) * f ij.1 ij.2 =
    ∑ ij ∈ antidiagonal n, ↑(n.choose ij.1) * f ij.1 (ij.2 + 1) +
      ∑ ij ∈ antidiagonal n, ↑(n.choose ij.2) * f (ij.1 + 1) ij.2
state_after: no goals
tactic: simpa only [nsmul_eq_mul] using sum_antidiagonal_choose_succ_nsmul f n