ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: iter_deriv_zpow'
File: Mathlib/Analysis/Calculus/Deriv/ZPow.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : 𝕜
s : Set 𝕜
m✝ m : ℤ
k : ℕ
⊢ (deriv^[k] fun x => x ^ m) = fun x => (∏ i ∈ Finset.range k, (↑m - ↑i)) * x ^ (m - ↑k)
state_after: case zero
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : 𝕜
s : Set 𝕜
m✝ m : ℤ
⊢ (deriv^[0] fun x => x ^ m) = fun x => (∏ i ∈ Finset.range 0, (↑m - ↑i)) * x ^ (m - ↑0)

case succ
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : 𝕜
s : Set 𝕜
m✝ m : ℤ
k : ℕ
ihk : (deriv^[k] fun x => x ^ m) = fun x => (∏ i ∈ Finset.range k, (↑m - ↑i)) * x ^ (m - ↑k)
⊢ (deriv^[k + 1] fun x => x ^ m) = fun x => (∏ i ∈ Finset.range (k + 1), (↑m - ↑i)) * x ^ (m - ↑(k + 1))
tactic: induction' k with k ihk
Theorem: Set.pairwise_union_of_symmetric
File: Mathlib/Data/Set/Pairwise/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r p q : α → α → Prop
f g : ι → α
s t u : Set α
a b : α
hr : Symmetric r
⊢ (s.Pairwise r ∧ t.Pairwise r ∧ ∀ a ∈ s, ∀ b ∈ t, a ≠ b → r a b ∧ r b a) ↔
    s.Pairwise r ∧ t.Pairwise r ∧ ∀ a ∈ s, ∀ b ∈ t, a ≠ b → r a b
state_after: no goals
tactic: simp only [hr.iff, and_self_iff]
Theorem: Matrix.charpoly.univ_map_eval₂Hom
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Univ.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
n : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fintype n
inst✝ : DecidableEq n
f : R →+* S
M : n × n → S
⊢ Polynomial.map (eval₂Hom f M) (univ R n) = (of (Function.curry M)).charpoly
state_after: R : Type u_1
S : Type u_2
n : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fintype n
inst✝ : DecidableEq n
f : R →+* S
M : n × n → S
⊢ ((mvPolynomialX n n R).map (eval₂ f M)).charpoly =
    ((mvPolynomialX n n R).map (eval₂ f fun p => of (Function.curry M) p.1 p.2)).charpoly
tactic: rw [univ, ← charpoly_map, coe_eval₂Hom, ← mvPolynomialX_map_eval₂ f (Matrix.of M.curry)]
state_before: R : Type u_1
S : Type u_2
n : Type u_3
inst✝³ : CommRing R
inst✝² : CommRing S
inst✝¹ : Fintype n
inst✝ : DecidableEq n
f : R →+* S
M : n × n → S
⊢ ((mvPolynomialX n n R).map (eval₂ f M)).charpoly =
    ((mvPolynomialX n n R).map (eval₂ f fun p => of (Function.curry M) p.1 p.2)).charpoly
state_after: no goals
tactic: simp only [of_apply, Function.curry_apply, Prod.mk.eta]
Theorem: aemeasurable_zero_measure
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
⊢ AEMeasurable f 0
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
a✝ : Nontrivial α
⊢ AEMeasurable f 0
tactic: nontriviality α
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
a✝ : Nontrivial α
⊢ AEMeasurable f 0
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
a✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ AEMeasurable f 0
tactic: inhabit α
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
a✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ AEMeasurable f 0
state_after: no goals
tactic: exact ⟨fun _ => f default, measurable_const, rfl⟩
Theorem: lp.isLUB_norm
File: Mathlib/Analysis/Normed/Lp/lpSpace.lean

Proof steps:
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : ↥(lp E ⊤)
⊢ IsLUB (Set.range fun i => ‖↑f i‖) ‖f‖
state_after: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : ↥(lp E ⊤)
⊢ IsLUB (Set.range fun i => ‖↑f i‖) (⨆ i, ‖↑f i‖)
tactic: rw [lp.norm_eq_ciSup]
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : ↥(lp E ⊤)
⊢ IsLUB (Set.range fun i => ‖↑f i‖) (⨆ i, ‖↑f i‖)
state_after: no goals
tactic: exact isLUB_ciSup (lp.memℓp f)
Theorem: groupCohomology.oneCocycles_map_inv
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(oneCocycles A)
g : G
⊢ (A.ρ g) (↑f g⁻¹) = -↑f g
state_after: no goals
tactic: rw [← add_eq_zero_iff_eq_neg, ← oneCocycles_map_one f, ← mul_inv_self g,
    (mem_oneCocycles_iff f.1).1 f.2 g g⁻¹]
Theorem: CategoryTheory.CostructuredArrow.isoMk_hom_right_down_down
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f f' : CostructuredArrow S T
g : f.left ≅ f'.left
w : autoParam (S.map g.hom ≫ f'.hom = f.hom) _auto✝
⊢ f.right = f'.right
state_after: no goals
tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f f' : CostructuredArrow S T
g : f.left ≅ f'.left
w : autoParam (S.map g.hom ≫ f'.hom = f.hom) _auto✝
⊢ S.map g.hom ≫ f'.hom = f.hom ≫ (Functor.fromPUnit T).map (eqToIso ⋯).hom
state_after: no goals
tactic: simpa using w
Theorem: Quaternion.norm_piLp_equiv_symm_equivTuple
File: Mathlib/Analysis/Quaternion.lean

Proof steps:
state_before: x : ℍ
⊢ ‖(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x)‖ = ‖x‖
state_after: x : ℍ
⊢ √(⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0, (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0⟫_ℝ +
            ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1,
              (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1⟫_ℝ +
          ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2,
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2⟫_ℝ +
        ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3,
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3⟫_ℝ) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)
tactic: rw [norm_eq_sqrt_real_inner, norm_eq_sqrt_real_inner, inner_self, normSq_def', PiLp.inner_apply,
    Fin.sum_univ_four]
state_before: x : ℍ
⊢ √(⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0, (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0⟫_ℝ +
            ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1,
              (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1⟫_ℝ +
          ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2,
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2⟫_ℝ +
        ⟪(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3,
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3⟫_ℝ) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)
state_after: x : ℍ
⊢ √((WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0 ^ 2 +
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1 ^ 2 +
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2 ^ 2 +
        (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3 ^ 2) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)
tactic: simp_rw [RCLike.inner_apply, starRingEnd_apply, star_trivial, ← sq]
state_before: x : ℍ
⊢ √((WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 0 ^ 2 +
            (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 1 ^ 2 +
          (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 2 ^ 2 +
        (WithLp.equiv 2 (Fin 4 → ℝ)).symm ((equivTuple ℝ) x) 3 ^ 2) =
    √(x.re ^ 2 + x.imI ^ 2 + x.imJ ^ 2 + x.imK ^ 2)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.MonoidalCategory.dite_tensor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝³ : MonoidalCategory C✝
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
U V W✝ X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
W X Y Z : C
f : W ⟶ X
g : P → (Y ⟶ Z)
g' : ¬P → (Y ⟶ Z)
⊢ (if h : P then g h else g' h) ⊗ f = if h : P then g h ⊗ f else g' h ⊗ f
state_after: no goals
tactic: split_ifs <;> rfl
Theorem: unitInterval.symm_zero
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: ⊢ ↑(σ 0) = ↑1
state_after: no goals
tactic: simp [symm]
Theorem: ProbabilityTheory.cgf_undef
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
hX : ¬Integrable (fun ω => rexp (t * X ω)) μ
⊢ cgf X μ t = 0
state_after: no goals
tactic: simp only [cgf, mgf_undef hX, log_zero]
Theorem: List.sum_le_foldr_max
File: Mathlib/Algebra/Order/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
l : List M
⊢ f l.sum ≤ foldr max 0 (map f l)
state_after: case nil
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
⊢ f [].sum ≤ foldr max 0 (map f [])

case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr max 0 (map f tl)
⊢ f (hd :: tl).sum ≤ foldr max 0 (map f (hd :: tl))
tactic: induction' l with hd tl IH
state_before: case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr max 0 (map f tl)
⊢ f (hd :: tl).sum ≤ foldr max 0 (map f (hd :: tl))
state_after: case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr (fun x y => max (f x) y) 0 tl
⊢ f (hd + tl.sum) ≤ max (f hd) (foldr (fun x y => max (f x) y) 0 tl)
tactic: simp only [List.sum_cons, List.foldr_map, List.foldr] at IH ⊢
state_before: case cons
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝² : AddMonoid M
inst✝¹ : AddMonoid N
inst✝ : LinearOrder N
f : M → N
h0 : f 0 ≤ 0
hadd : ∀ (x y : M), f (x + y) ≤ max (f x) (f y)
hd : M
tl : List M
IH : f tl.sum ≤ foldr (fun x y => max (f x) y) 0 tl
⊢ f (hd + tl.sum) ≤ max (f hd) (foldr (fun x y => max (f x) y) 0 tl)
state_after: no goals
tactic: exact (hadd _ _).trans (max_le_max le_rfl IH)
Theorem: nhds_swap
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
x : X
y : Y
⊢ 𝓝 (x, y) = map Prod.swap (𝓝 (y, x))
state_after: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
x : X
y : Y
⊢ map (fun p => (p.2, p.1)) (𝓝 y ×ˢ 𝓝 x) = map Prod.swap (𝓝 y ×ˢ 𝓝 x)
tactic: rw [nhds_prod_eq, Filter.prod_comm, nhds_prod_eq]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
x : X
y : Y
⊢ map (fun p => (p.2, p.1)) (𝓝 y ×ˢ 𝓝 x) = map Prod.swap (𝓝 y ×ˢ 𝓝 x)
state_after: no goals
tactic: rfl
Theorem: Finset.prod_sdiff_lt_prod_sdiff
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
inst✝ : DecidableEq ι
⊢ ∏ i ∈ s \ t, f i < ∏ i ∈ t \ s, f i ↔ ∏ i ∈ s, f i < ∏ i ∈ t, f i
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
inst✝ : DecidableEq ι
⊢ Disjoint (t \ s) (s ∩ t)
tactic: rw [← mul_lt_mul_iff_right, ← prod_union (disjoint_sdiff_inter _ _), sdiff_union_inter,
    ← prod_union, inter_comm, sdiff_union_inter]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
inst✝ : DecidableEq ι
⊢ Disjoint (t \ s) (s ∩ t)
state_after: no goals
tactic: simpa only [inter_comm] using disjoint_sdiff_inter t s
Theorem: AntilipschitzWith.mul_div_lipschitzWith
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α✝ : Type u_2
E✝ : Type u_3
F : Type u_4
inst✝³ : SeminormedCommGroup E✝
inst✝² : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E✝
r r₁ r₂ : ℝ
α : Type u_5
E : Type u_6
inst✝¹ : SeminormedCommGroup E
inst✝ : PseudoEMetricSpace α
K Kf Kg : ℝ≥0
f g : α → E
s : Set α
x : α
hf : AntilipschitzWith Kf f
hg : LipschitzWith Kg (g / f)
hK : Kg < Kf⁻¹
⊢ AntilipschitzWith (Kf⁻¹ - Kg)⁻¹ g
state_after: no goals
tactic: simpa only [Pi.div_apply, mul_div_cancel] using hf.mul_lipschitzWith hg hK
Theorem: StieltjesFunction.measure_Icc
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f : StieltjesFunction
a b : ℝ
⊢ f.measure (Icc a b) = ofReal (↑f b - leftLim (↑f) a)
state_after: case inl
f : StieltjesFunction
a b : ℝ
hab : a ≤ b
⊢ f.measure (Icc a b) = ofReal (↑f b - leftLim (↑f) a)

case inr
f : StieltjesFunction
a b : ℝ
hab : b < a
⊢ f.measure (Icc a b) = ofReal (↑f b - leftLim (↑f) a)
tactic: rcases le_or_lt a b with (hab | hab)
Theorem: Asymptotics.isBigOWith_norm_left
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → ℝ
⊢ IsBigOWith c l (fun x => ‖f' x‖) g ↔ IsBigOWith c l f' g
state_after: no goals
tactic: simp only [IsBigOWith_def, norm_norm]
Theorem: balancedCore_eq_iInter
File: Mathlib/Analysis/LocallyConvex/BalancedCoreHull.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ balancedCore 𝕜 s = ⋂ r, ⋂ (_ : 1 ≤ ‖r‖), r • s
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ balancedCoreAux 𝕜 s ⊆ balancedCore 𝕜 s
tactic: refine balancedCore_subset_balancedCoreAux.antisymm ?_
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ balancedCoreAux 𝕜 s ⊆ balancedCore 𝕜 s
state_after: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ 0 ∈ balancedCoreAux 𝕜 s
tactic: refine (balancedCoreAux_balanced ?_).subset_balancedCore_of_subset (balancedCoreAux_subset s)
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
hs : 0 ∈ s
⊢ 0 ∈ balancedCoreAux 𝕜 s
state_after: no goals
tactic: exact balancedCore_subset_balancedCoreAux (balancedCore_zero_mem hs)
Theorem: PFunctor.M.dest_corec
File: Mathlib/Data/PFunctor/Univariate/M.lean

Proof steps:
state_before: F : PFunctor.{u}
X : Type u_1
f : X → ↑F X
P : PFunctor.{u}
α : Type u_2
g : α → ↑P α
x : α
⊢ (M.corec g x).dest = P.map (M.corec g) (g x)
state_after: no goals
tactic: rw [corec_def, dest_mk]
Theorem: Equiv.Perm.Disjoint.mul_apply_eq_iff
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
f g h σ τ : Perm α
hστ : σ.Disjoint τ
a : α
⊢ (σ * τ) a = a ↔ σ a = a ∧ τ a = a
state_after: α : Type u_1
f g h✝ σ τ : Perm α
hστ : σ.Disjoint τ
a : α
h : (σ * τ) a = a
⊢ σ a = a ∧ τ a = a
tactic: refine ⟨fun h => ?_, fun h => by rw [mul_apply, h.2, h.1]⟩
state_before: α : Type u_1
f g h✝ σ τ : Perm α
hστ : σ.Disjoint τ
a : α
h : (σ * τ) a = a
⊢ σ a = a ∧ τ a = a
state_after: case inl
α : Type u_1
f g h✝ σ τ : Perm α
hστ : σ.Disjoint τ
a : α
h : (σ * τ) a = a
hσ : σ a = a
⊢ σ a = a ∧ τ a = a

case inr
α : Type u_1
f g h✝ σ τ : Perm α
hστ : σ.Disjoint τ
a : α
h : (σ * τ) a = a
hτ : τ a = a
⊢ σ a = a ∧ τ a = a
tactic: cases' hστ a with hσ hτ
Theorem: Cardinal.add_lt_of_lt
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b c : Cardinal.{u_1}
hc : ℵ₀ ≤ c
h1 : a < c
h2 : b < c
h : ℵ₀ ≤ max a b
⊢ max a b + max a b < c
state_after: a b c : Cardinal.{u_1}
hc : ℵ₀ ≤ c
h1 : a < c
h2 : b < c
h : ℵ₀ ≤ max a b
⊢ max a b < c
tactic: rw [add_eq_self h]
state_before: a b c : Cardinal.{u_1}
hc : ℵ₀ ≤ c
h1 : a < c
h2 : b < c
h : ℵ₀ ≤ max a b
⊢ max a b < c
state_after: no goals
tactic: exact max_lt h1 h2
Theorem: List.argmax_concat
File: Mathlib/Data/List/MinMax.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f✝ : α → β
l✝ : List α
o : Option α
a✝ m : α
f : α → β
a : α
l : List α
⊢ argmax f (l ++ [a]) = Option.casesOn (argmax f l) (some a) fun c => if f c < f a then some a else some c
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f✝ : α → β
l✝ : List α
o : Option α
a✝ m : α
f : α → β
a : α
l : List α
⊢ foldl (argAux fun b c => f c < f b) none (l ++ [a]) =
    Option.casesOn (foldl (argAux fun b c => f c < f b) none l) (some a) fun c => if f c < f a then some a else some c
tactic: rw [argmax, argmax]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f✝ : α → β
l✝ : List α
o : Option α
a✝ m : α
f : α → β
a : α
l : List α
⊢ foldl (argAux fun b c => f c < f b) none (l ++ [a]) =
    Option.casesOn (foldl (argAux fun b c => f c < f b) none l) (some a) fun c => if f c < f a then some a else some c
state_after: no goals
tactic: simp [argAux]
Theorem: Orientation.rotation_map_complex
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
θ : Real.Angle
f : V ≃ₗᵢ[ℝ] ℂ
hf : (map (Fin 2) f.toLinearEquiv) o = Complex.orientation
x : V
⊢ f ((o.rotation θ) x) = ↑θ.expMapCircle * f x
state_after: no goals
tactic: rw [← Complex.rotation, ← hf, o.rotation_map, LinearIsometryEquiv.symm_apply_apply]
Theorem: affineCombination_eq_centerMass
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι✝ : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι✝
c : R
t✝ : Finset ι✝
w✝ : ι✝ → R
z : ι✝ → E
ι : Type u_8
t : Finset ι
p : ι → E
w : ι → R
hw₂ : ∑ i ∈ t, w i = 1
⊢ (affineCombination R t p) w = t.centerMass w p
state_after: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι✝ : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι✝
c : R
t✝ : Finset ι✝
w✝ : ι✝ → R
z : ι✝ → E
ι : Type u_8
t : Finset ι
p : ι → E
w : ι → R
hw₂ : ∑ i ∈ t, w i = 1
⊢ ∑ i ∈ t, w i • (p i -ᵥ 0) = ∑ i ∈ t, w i • p i
tactic: rw [affineCombination_eq_weightedVSubOfPoint_vadd_of_sum_eq_one _ w _ hw₂ (0 : E),
    Finset.weightedVSubOfPoint_apply, vadd_eq_add, add_zero, t.centerMass_eq_of_sum_1 _ hw₂]
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι✝ : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι✝
c : R
t✝ : Finset ι✝
w✝ : ι✝ → R
z : ι✝ → E
ι : Type u_8
t : Finset ι
p : ι → E
w : ι → R
hw₂ : ∑ i ∈ t, w i = 1
⊢ ∑ i ∈ t, w i • (p i -ᵥ 0) = ∑ i ∈ t, w i • p i
state_after: no goals
tactic: simp_rw [vsub_eq_sub, sub_zero]
Theorem: CategoryTheory.Monad.Algebra.isoMk_inv_f
File: Mathlib/CategoryTheory/Monad/Algebra.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
A B : T.Algebra
h : A.A ≅ B.A
w : autoParam (T.map h.hom ≫ B.a = A.a ≫ h.hom) _auto✝
⊢ T.map h.inv ≫ A.a = B.a ≫ h.inv
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
A B : T.Algebra
h : A.A ≅ B.A
w : autoParam (T.map h.hom ≫ B.a = A.a ≫ h.hom) _auto✝
⊢ T.map (h.inv ≫ h.hom) ≫ B.a = B.a
tactic: rw [h.eq_comp_inv, Category.assoc, ← w, ← Functor.map_comp_assoc]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
A B : T.Algebra
h : A.A ≅ B.A
w : autoParam (T.map h.hom ≫ B.a = A.a ≫ h.hom) _auto✝
⊢ T.map (h.inv ≫ h.hom) ≫ B.a = B.a
state_after: no goals
tactic: simp
Theorem: OrderRingHom.cancel_right
File: Mathlib/Algebra/Order/Hom/Ring.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : NonAssocSemiring α
inst✝⁶ : Preorder α
inst✝⁵ : NonAssocSemiring β
inst✝⁴ : Preorder β
inst✝³ : NonAssocSemiring γ
inst✝² : Preorder γ
inst✝¹ : NonAssocSemiring δ
inst✝ : Preorder δ
f₁ f₂ : β →+*o γ
g : α →+*o β
hg : Surjective ⇑g
h : f₁ = f₂
⊢ f₁.comp g = f₂.comp g
state_after: no goals
tactic: rw [h]