ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: exists_sUnion
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
inst✝ : CompleteLattice β
S : Set (Set α)
p : α → Prop
⊢ (∃ x ∈ ⋃₀ S, p x) ↔ ∃ s ∈ S, ∃ x ∈ s, p x
state_after: no goals
tactic: simp_rw [← exists_prop, ← iSup_Prop_eq, iSup_sUnion]
Theorem: HahnSeries.support_mul_subset_add_support
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ (x * y).support ⊆ x.support + y.support
state_after: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ ((HahnModule.of R).symm (x • (HahnModule.of R) y)).support ⊆ x.support +ᵥ y.support
tactic: rw [← of_symm_smul_of_eq_mul, ← vadd_eq_add]
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
x y : HahnSeries Γ R
⊢ ((HahnModule.of R).symm (x • (HahnModule.of R) y)).support ⊆ x.support +ᵥ y.support
state_after: no goals
tactic: exact HahnModule.support_smul_subset_vadd_support
Theorem: Equiv.Perm.extendDomain_apply_image
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: α' : Type u_1
β' : Type u_2
e : Perm α'
p : β' → Prop
inst✝ : DecidablePred p
f : α' ≃ Subtype p
a : α'
⊢ (e.extendDomain f) ↑(f a) = ↑(f (e a))
state_after: no goals
tactic: simp [Perm.extendDomain]
Theorem: single_le_finsum
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M✝ : Type u_5
N : Type u_6
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_7
inst✝ : OrderedCommMonoid M
i : α
f : α → M
hf : (mulSupport f).Finite
h : ∀ (j : α), 1 ≤ f j
⊢ f i ≤ ∏ᶠ (j : α), f j
state_after: no goals
tactic: classical calc
      f i ≤ ∏ j ∈ insert i hf.toFinset, f j :=
        Finset.single_le_prod' (fun j _ => h j) (Finset.mem_insert_self _ _)
      _ = ∏ᶠ j, f j :=
        (finprod_eq_prod_of_mulSupport_toFinset_subset _ hf (Finset.subset_insert _ _)).symm
Theorem: List.foldr_fixed'
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → β
b : β
hf : ∀ (a : α), f a b = b
a : α
l : List α
⊢ foldr f b (a :: l) = b
state_after: no goals
tactic: rw [foldr_cons, foldr_fixed' hf l, hf a]
Theorem: CategoryTheory.Limits.Pi.lift_π
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β✝ : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
β : Type w
f : β → C
inst✝ : HasProduct f
P : C
p : (b : β) → P ⟶ f b
b : β
⊢ lift p ≫ π f b = p b
state_after: no goals
tactic: simp only [limit.lift_π, Fan.mk_pt, Fan.mk_π_app]
Theorem: EReal.ge_iff_le_forall_real_lt
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : EReal
⊢ (∀ (z : ℝ), ↑z < y → ↑z ≤ x) ↔ y ≤ x
state_after: x y : EReal
h : ∀ (z : ℝ), ↑z < y → ↑z ≤ x
⊢ y ≤ x
tactic: refine ⟨fun h ↦ ?_, fun h z z_lt_y ↦ le_trans (le_of_lt z_lt_y) h⟩
state_before: x y : EReal
h : ∀ (z : ℝ), ↑z < y → ↑z ≤ x
⊢ y ≤ x
state_after: no goals
tactic: induction x with
  | h_bot =>
    refine ((eq_bot_iff_forall_lt y).2 fun z ↦ ?_).le
    refine lt_of_not_le fun z_le_y ↦ (not_le_of_lt (bot_lt_coe (z - 1)) (h (z - 1)
      (lt_of_lt_of_le ?_ z_le_y)))
    exact_mod_cast sub_one_lt z
  | h_real x =>
    induction y with
    | h_bot => exact bot_le
    | h_real y =>
      norm_cast at h ⊢
      by_contra! x_lt_y
      rcases exists_between x_lt_y with ⟨z, x_lt_z, z_lt_y⟩
      exact not_le_of_lt x_lt_z (h z z_lt_y)
    | h_top =>
      exfalso
      norm_cast at h
      exact not_le_of_lt (lt_add_one x) <| h (x + 1) (coe_lt_top (x + 1))
  | h_top => exact le_top
Theorem: LSeries.abscissaOfAbsConv_le_of_le_const
File: Mathlib/NumberTheory/LSeries/Convergence.lean

Proof steps:
state_before: f : ℕ → ℂ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C
⊢ abscissaOfAbsConv f ≤ 1
state_after: case h.e'_4
f : ℕ → ℂ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C
⊢ 1 = ↑0 + 1

case convert_2
f : ℕ → ℂ
h : ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C
⊢ ∃ C, ∀ (n : ℕ), n ≠ 0 → ‖f n‖ ≤ C * ↑n ^ 0
tactic: convert abscissaOfAbsConv_le_of_le_const_mul_rpow (x := 0) ?_
Theorem: HasStrictFDerivAt.add
File: Mathlib/Analysis/Calculus/FDeriv/Add.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
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasStrictFDerivAt f f' x
hg : HasStrictFDerivAt g g' x
y : E × E
⊢ f y.1 - f y.2 - f' (y.1 - y.2) + (g y.1 - g y.2 - g' (y.1 - y.2)) =
    (fun y => f y + g y) y.1 - (fun y => f y + g y) y.2 - (f' + g') (y.1 - y.2)
state_after: 𝕜 : 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
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasStrictFDerivAt f f' x
hg : HasStrictFDerivAt g g' x
y : E × E
⊢ f y.1 - f y.2 - (f' y.1 - f' y.2) + (g y.1 - g y.2 - (g' y.1 - g' y.2)) =
    f y.1 + g y.1 - (f y.2 + g y.2) - (f' y.1 + g' y.1 - (f' y.2 + g' y.2))
tactic: simp only [LinearMap.sub_apply, LinearMap.add_apply, map_sub, map_add, add_apply]
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
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
hf : HasStrictFDerivAt f f' x
hg : HasStrictFDerivAt g g' x
y : E × E
⊢ f y.1 - f y.2 - (f' y.1 - f' y.2) + (g y.1 - g y.2 - (g' y.1 - g' y.2)) =
    f y.1 + g y.1 - (f y.2 + g y.2) - (f' y.1 + g' y.1 - (f' y.2 + g' y.2))
state_after: no goals
tactic: abel
Theorem: ProbabilityTheory.Kernel.measurable_rnDeriv_right
File: Mathlib/Probability/Kernel/RadonNikodym.lean

Proof steps:
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
a : α
⊢ Measurable fun x => κ.rnDeriv η a x
state_after: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
a : α
⊢ Measurable ((fun p => κ.rnDeriv η p.1 p.2) ∘ fun x => (a, x))
tactic: change Measurable ((fun p : α × γ ↦ rnDeriv κ η p.1 p.2) ∘ (fun x ↦ (a, x)))
state_before: α : Type u_1
γ : Type u_2
mα : MeasurableSpace α
mγ : MeasurableSpace γ
κ✝ η✝ : Kernel α γ
hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ
κ η : Kernel α γ
a : α
⊢ Measurable ((fun p => κ.rnDeriv η p.1 p.2) ∘ fun x => (a, x))
state_after: no goals
tactic: exact (measurable_rnDeriv _ _).comp measurable_prod_mk_left
Theorem: Equiv.Perm.IsCycle.support_pow_eq_iff
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
n : ℕ
⊢ (f ^ n).support = f.support ↔ ¬orderOf f ∣ n
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
n : ℕ
⊢ (f ^ n).support = f.support ↔ ¬f ^ n = 1
tactic: rw [orderOf_dvd_iff_pow_eq_one]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
n : ℕ
⊢ (f ^ n).support = f.support ↔ ¬f ^ n = 1
state_after: case mp
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
n : ℕ
⊢ (f ^ n).support = f.support → ¬f ^ n = 1

case mpr
ι : Type u_1
α : Type u_2
β : Type u_3
f g : Perm α
x y : α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hf : f.IsCycle
n : ℕ
⊢ ¬f ^ n = 1 → (f ^ n).support = f.support
tactic: constructor
Theorem: AlgebraicGeometry.LocallyRingedSpace.not_mem_prime_iff_unit_in_stalk
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

Proof steps:
state_before: X : LocallyRingedSpace
r : ↑(Γ.obj (op X))
x : ↑X.toTopCat
⊢ r ∉ (X.toΓSpecFun x).asIdeal ↔ IsUnit ((X.presheaf.Γgerm x) r)
state_after: no goals
tactic: erw [LocalRing.mem_maximalIdeal, Classical.not_not]
Theorem: Rep.ρ_inv_self_apply
File: Mathlib/RepresentationTheory/Rep.lean

Proof steps:
state_before: k G✝ : Type u
inst✝² : CommRing k
inst✝¹ : Monoid G✝
G : Type u
inst✝ : Group G
A : Rep k G
g : G
x : CoeSort.coe A
⊢ (A.ρ g⁻¹ * A.ρ g) x = x
state_after: no goals
tactic: rw [← map_mul, inv_mul_self, map_one, LinearMap.one_apply]
Theorem: Matroid.closure_biInter_eq_biInter_closure_of_biUnion_indep
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝¹ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι✝ : Sort u_3
I✝ J B : Set α
f x y : α
ι : Type u_4
A : Set ι
hA : A.Nonempty
I : ι → Set α
h : M.Indep (⋃ i ∈ A, I i)
⊢ M.closure (⋂ i ∈ A, I i) = ⋂ i ∈ A, M.closure (I i)
state_after: ι✝¹ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι✝ : Sort u_3
I✝ J B : Set α
f x y : α
ι : Type u_4
A : Set ι
hA : A.Nonempty
I : ι → Set α
h : M.Indep (⋃ i ∈ A, I i)
this : Nonempty ↑A
⊢ M.closure (⋂ i ∈ A, I i) = ⋂ i ∈ A, M.closure (I i)
tactic: have := hA.coe_sort
state_before: ι✝¹ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι✝ : Sort u_3
I✝ J B : Set α
f x y : α
ι : Type u_4
A : Set ι
hA : A.Nonempty
I : ι → Set α
h : M.Indep (⋃ i ∈ A, I i)
this : Nonempty ↑A
⊢ M.closure (⋂ i ∈ A, I i) = ⋂ i ∈ A, M.closure (I i)
state_after: no goals
tactic: convert closure_iInter_eq_iInter_closure_of_iUnion_indep (Is := fun i : A ↦ I i) (by simpa) <;>
  simp
Theorem: Real.geom_mean_le_arith_mean2_weighted
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
w₁ w₂ p₁ p₂ : ℝ
hw₁ : 0 ≤ w₁
hw₂ : 0 ≤ w₂
hp₁ : 0 ≤ p₁
hp₂ : 0 ≤ p₂
hw : w₁ + w₂ = 1
⊢ ↑(⟨w₁, hw₁⟩ + ⟨w₂, hw₂⟩) = ↑1
state_after: no goals
tactic: assumption
Theorem: HurwitzZeta.cosKernel_def
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a x : ℝ
⊢ ↑(cosKernel (↑a) x) = jacobiTheta₂ (↑a) (I * ↑x)
state_after: a x : ℝ
⊢ ↑(⋯.lift ↑a) = jacobiTheta₂ (↑a) (I * ↑x)
tactic: unfold cosKernel
state_before: a x : ℝ
⊢ ↑(⋯.lift ↑a) = jacobiTheta₂ (↑a) (I * ↑x)
state_after: no goals
tactic: simp only [Function.Periodic.lift_coe, re_eq_add_conj, jacobiTheta₂_conj, conj_ofReal, map_mul,
    conj_I, neg_mul, neg_neg, ← mul_two, mul_div_cancel_right₀ _ (two_ne_zero' ℂ)]
Theorem: ciSup_unique
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
⊢ ⨆ i, s i = s default
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
this : ∀ (i : ι), s i = s default
⊢ ⨆ i, s i = s default
tactic: have : ∀ i, s i = s default := fun i => congr_arg s (Unique.eq_default i)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
inst✝¹ : ConditionallyCompleteLattice α
s✝ t : Set α
a b : α
inst✝ : Unique ι
s : ι → α
this : ∀ (i : ι), s i = s default
⊢ ⨆ i, s i = s default
state_after: no goals
tactic: simp only [this, ciSup_const]
Theorem: Finset.image_add_right_Ioo
File: Mathlib/Algebra/Order/Interval/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Ioo a b) = Ioo (a + c) (b + c)
state_after: no goals
tactic: rw [← map_add_right_Ioo, map_eq_image, addRightEmbedding, Embedding.coeFn_mk]
Theorem: CategoryTheory.MonoidalCategory.leftUnitor_whiskerRight
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 X Y : C
⊢ (λ_ X).hom ▷ Y = (α_ (𝟙_ C) X Y).hom ≫ (λ_ (X ⊗ Y)).hom
state_after: no goals
tactic: rw [← whiskerLeft_iff, whiskerLeft_comp, ← cancel_epi (α_ _ _ _).hom, ←
      cancel_epi ((α_ _ _ _).hom ▷ _), pentagon_assoc, triangle, ← associator_naturality_middle, ←
      comp_whiskerRight_assoc, triangle, associator_naturality_left]
Theorem: TensorProduct.finsuppScalarRight_apply_tmul_apply
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Type u_2
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
ι : Type u_4
inst✝⁴ : DecidableEq ι
S : Type u_5
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
m : M
p : ι →₀ R
i : ι
⊢ ((finsuppScalarRight R M ι) (m ⊗ₜ[R] p)) i = p i • m
state_after: no goals
tactic: simp [finsuppScalarRight]
Theorem: CategoryTheory.Subobject.factorThru_right
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C
P : Subobject Z
f : X ⟶ Y
g : Y ⟶ Z
h : P.Factors g
⊢ f ≫ P.factorThru g h = P.factorThru (f ≫ g) ⋯
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C
P : Subobject Z
f : X ⟶ Y
g : Y ⟶ Z
h : P.Factors g
⊢ (f ≫ P.factorThru g h) ≫ P.arrow = P.factorThru (f ≫ g) ⋯ ≫ P.arrow
tactic: apply (cancel_mono P.arrow).mp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X✝ Y✝ Z✝ : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z : C
P : Subobject Z
f : X ⟶ Y
g : Y ⟶ Z
h : P.Factors g
⊢ (f ≫ P.factorThru g h) ≫ P.arrow = P.factorThru (f ≫ g) ⋯ ≫ P.arrow
state_after: no goals
tactic: simp
Theorem: HasDerivAt.complexToReal_fderiv
File: Mathlib/Analysis/Complex/RealDeriv.lean

Proof steps:
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h : HasDerivAt f f' x
⊢ HasFDerivAt f (f' • 1) x
state_after: no goals
tactic: simpa only [Complex.restrictScalars_one_smulRight] using h.hasFDerivAt.restrictScalars ℝ
Theorem: MonotoneOn.ae_differentiableWithinAt
File: Mathlib/Analysis/Calculus/Monotone.lean

Proof steps:
state_before: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
hs : MeasurableSet s
⊢ ∀ᵐ (x : ℝ) ∂volume.restrict s, DifferentiableWithinAt ℝ f s x
state_after: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
hs : MeasurableSet s
⊢ ∀ᵐ (x : ℝ), x ∈ s → DifferentiableWithinAt ℝ f s x
tactic: rw [ae_restrict_iff' hs]
state_before: f : ℝ → ℝ
s : Set ℝ
hf : MonotoneOn f s
hs : MeasurableSet s
⊢ ∀ᵐ (x : ℝ), x ∈ s → DifferentiableWithinAt ℝ f s x
state_after: no goals
tactic: exact hf.ae_differentiableWithinAt_of_mem
Theorem: CategoryTheory.StructuredArrow.isoMk_inv_left_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
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ≅ f'.right
w : autoParam (f.hom ≫ T.map g.hom = f'.hom) _auto✝
⊢ f.left = f'.left
state_after: no goals
tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ≅ f'.right
w : autoParam (f.hom ≫ T.map g.hom = f'.hom) _auto✝
⊢ (Functor.fromPUnit S).map (eqToIso ⋯).hom ≫ f'.hom = f.hom ≫ T.map g.hom
state_after: no goals
tactic: simpa using w.symm
Theorem: Nat.bodd_eq_bits_head
File: Mathlib/Data/Nat/Bits.lean

Proof steps:
state_before: m n✝ n : ℕ
⊢ n.bodd = n.bits.headI
state_after: case z
m n : ℕ
⊢ bodd 0 = (bits 0).headI

case f
m n✝ : ℕ
b : Bool
n : ℕ
h : n = 0 → b = true
a✝ : n.bodd = n.bits.headI
⊢ (bit b n).bodd = (bit b n).bits.headI
tactic: induction' n using Nat.binaryRec' with b n h _
state_before: case f
m n✝ : ℕ
b : Bool
n : ℕ
h : n = 0 → b = true
a✝ : n.bodd = n.bits.headI
⊢ (bit b n).bodd = (bit b n).bits.headI
state_after: no goals
tactic: simp [bodd_bit, bits_append_bit _ _ h]
Theorem: CategoryTheory.ComposableArrows.isoMk₄_hom
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 0 1 ⋯ ⋯ ≫ app₁.inv = app₀.inv ≫ f.map' 0 1 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₀ app₁ w₀]
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 1 2 ⋯ ⋯ ≫ app₂.inv = app₁.inv ≫ f.map' 1 2 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₁ app₂ w₁]
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 2 3 ⋯ ⋯ ≫ app₃.inv = app₂.inv ≫ f.map' 2 3 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₂ app₃ w₂]
state_before: C : Type u_1
inst✝ : Category.{?u.337009, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 4
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
w₃ : f.map' 3 4 ⋯ ⋯ ≫ app₄.hom = app₃.hom ≫ g.map' 3 4 ⋯ ⋯
⊢ g.map' 3 4 ⋯ ⋯ ≫ app₄.inv = app₃.inv ≫ f.map' 3 4 ⋯ ⋯
state_after: no goals
tactic: rw [map'_inv_eq_inv_map' (by valid) app₃ app₄ w₃]
Theorem: EuclideanGeometry.angle_eq_arccos_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
⊢ ∠ p₂ p₃ p₁ = Real.arccos (dist p₃ p₂ / dist p₁ p₃)
state_after: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ ∠ p₂ p₃ p₁ = Real.arccos (dist p₃ p₂ / dist p₁ p₃)
tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
    inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ⟪p₂ -ᵥ p₃, p₁ -ᵥ p₂⟫_ℝ = 0
⊢ ∠ p₂ p₃ p₁ = Real.arccos (dist p₃ p₂ / dist p₁ p₃)
state_after: no goals
tactic: rw [angle, dist_eq_norm_vsub' V p₃ p₂, dist_eq_norm_vsub V p₁ p₃, ← vsub_add_vsub_cancel p₁ p₂ p₃,
    add_comm, angle_add_eq_arccos_of_inner_eq_zero h]
Theorem: OnePoint.nhdsWithin_compl_infty_eq
File: Mathlib/Topology/Compactification/OnePoint.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ 𝓝[≠] ∞ = map some (coclosedCompact X)
state_after: case refine_1
X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ ∀ (i : Set (OnePoint X)), ∞ ∈ i ∧ IsOpen i → ∃ i', (IsClosed i' ∧ IsCompact i') ∧ some '' i'ᶜ ⊆ i ∩ {∞}ᶜ

case refine_2
X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ ∀ (i' : Set X), IsClosed i' ∧ IsCompact i' → ∃ i, (∞ ∈ i ∧ IsOpen i) ∧ i ∩ {∞}ᶜ ⊆ some '' i'ᶜ
tactic: refine (nhdsWithin_basis_open ∞ _).ext (hasBasis_coclosedCompact.map _) ?_ ?_
Theorem: CompleteLattice.WellFounded.isSupFiniteCompact
File: Mathlib/Order/CompactlyGenerated/Basic.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : WellFounded fun x x_1 => x > x_1
s : Set α
⊢ ∃ t, ↑t ⊆ s ∧ sSup s = t.sup id
state_after: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : WellFounded fun x x_1 => x > x_1
s : Set α
S : Set α := {x | ∃ t, ↑t ⊆ s ∧ t.sup id = x}
⊢ ∃ t, ↑t ⊆ s ∧ sSup s = t.sup id
tactic: let S := { x | ∃ t : Finset α, ↑t ⊆ s ∧ t.sup id = x }
state_before: ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : WellFounded fun x x_1 => x > x_1
s : Set α
S : Set α := {x | ∃ t, ↑t ⊆ s ∧ t.sup id = x}
⊢ ∃ t, ↑t ⊆ s ∧ sSup s = t.sup id
state_after: case intro.intro.intro.intro
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : WellFounded fun x x_1 => x > x_1
s : Set α
S : Set α := {x | ∃ t, ↑t ⊆ s ∧ t.sup id = x}
t : Finset α
ht₁ : ↑t ⊆ s
hm : ∀ x ∈ S, ¬x > t.sup id
⊢ ∃ t, ↑t ⊆ s ∧ sSup s = t.sup id
tactic: obtain ⟨m, ⟨t, ⟨ht₁, rfl⟩⟩, hm⟩ := h.has_min S ⟨⊥, ∅, by simp⟩
state_before: case intro.intro.intro.intro
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : WellFounded fun x x_1 => x > x_1
s : Set α
S : Set α := {x | ∃ t, ↑t ⊆ s ∧ t.sup id = x}
t : Finset α
ht₁ : ↑t ⊆ s
hm : ∀ x ∈ S, ¬x > t.sup id
⊢ ∃ t, ↑t ⊆ s ∧ sSup s = t.sup id
state_after: case intro.intro.intro.intro.refine_1
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : WellFounded fun x x_1 => x > x_1
s : Set α
S : Set α := {x | ∃ t, ↑t ⊆ s ∧ t.sup id = x}
t : Finset α
ht₁ : ↑t ⊆ s
hm : ∀ x ∈ S, ¬x > t.sup id
y : α
hy : y ∈ s
⊢ y ≤ t.sup id

case intro.intro.intro.intro.refine_2
ι : Sort u_1
α : Type u_2
inst✝ : CompleteLattice α
f : ι → α
h : WellFounded fun x x_1 => x > x_1
s : Set α
S : Set α := {x | ∃ t, ↑t ⊆ s ∧ t.sup id = x}
t : Finset α
ht₁ : ↑t ⊆ s
hm : ∀ x ∈ S, ¬x > t.sup id
⊢ t.sup id ≤ sSup s
tactic: refine ⟨t, ht₁, (sSup_le _ _ fun y hy => ?_).antisymm ?_⟩