ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Turing.ToPartrec.stepNormal.is_ret
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: c : Code
k : Cont
v : List ℕ
⊢ ∃ k' v', stepNormal c k v = Cfg.ret k' v'
state_after: no goals
tactic: induction c generalizing k v with
  | cons _f fs IHf _IHfs => apply IHf
  | comp f _g _IHf IHg => apply IHg
  | case f g IHf IHg =>
    rw [stepNormal]
    simp only []
    cases v.headI <;> [apply IHf; apply IHg]
  | fix f IHf => apply IHf
  | _ => exact ⟨_, _, rfl⟩
Theorem: MeasureTheory.OuterMeasure.ofFunction_caratheodory
File: Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean

Proof steps:
state_before: α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
⊢ MeasurableSet s
state_after: α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
⊢ ∀ (t : Set α),
    (OuterMeasure.ofFunction m h₀) (t ∩ s) + (OuterMeasure.ofFunction m h₀) (t \ s) ≤ (OuterMeasure.ofFunction m h₀) t
tactic: apply (isCaratheodory_iff_le _).mpr
state_before: α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
⊢ ∀ (t : Set α),
    (OuterMeasure.ofFunction m h₀) (t ∩ s) + (OuterMeasure.ofFunction m h₀) (t \ s) ≤ (OuterMeasure.ofFunction m h₀) t
state_after: α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
f : ℕ → Set α
hf : t ⊆ ⋃ i, f i
⊢ (OuterMeasure.ofFunction m h₀) (t ∩ s) + (OuterMeasure.ofFunction m h₀) (t \ s) ≤ ∑' (i : ℕ), m (f i)
tactic: refine fun t => le_iInf fun f => le_iInf fun hf => ?_
state_before: α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
f : ℕ → Set α
hf : t ⊆ ⋃ i, f i
⊢ (OuterMeasure.ofFunction m h₀) (t ∩ s) + (OuterMeasure.ofFunction m h₀) (t \ s) ≤ ∑' (i : ℕ), m (f i)
state_after: case refine_1
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
f : ℕ → Set α
hf : t ⊆ ⋃ i, f i
⊢ t ∩ s ⊆ ⋃ i, (fun i => f i ∩ s) i

case refine_2
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
f : ℕ → Set α
hf : t ⊆ ⋃ i, f i
⊢ t \ s ⊆ ⋃ i, (fun i => f i \ s) i

case refine_3
α : Type u_1
m : Set α → ℝ≥0∞
s : Set α
h₀ : m ∅ = 0
hs : ∀ (t : Set α), m (t ∩ s) + m (t \ s) ≤ m t
t : Set α
f : ℕ → Set α
hf : t ⊆ ⋃ i, f i
⊢ ∑' (i : ℕ), m ((fun i => f i ∩ s) i) + ∑' (i : ℕ), m ((fun i => f i \ s) i) ≤ ∑' (i : ℕ), m (f i)
tactic: refine
    le_trans
      (add_le_add ((iInf_le_of_le fun i => f i ∩ s) <| iInf_le _ ?_)
        ((iInf_le_of_le fun i => f i \ s) <| iInf_le _ ?_))
      ?_
Theorem: MeasureTheory.withDensityᵥ_rnDeriv_smul
File: Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
m✝ : MeasurableSpace α✝
α : Type u_3
m : MeasurableSpace α
μ ν : Measure α
E : Type u_4
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
inst✝¹ : μ.HaveLebesgueDecomposition ν
hμν : μ ≪ ν
inst✝ : SigmaFinite μ
f : α → E
hf : Integrable f μ
⊢ (ν.withDensityᵥ fun x => (μ.rnDeriv ν x).toReal • f x) = μ.withDensityᵥ f
state_after: no goals
tactic: rw [withDensityᵥ_smul_eq_withDensityᵥ_withDensity' (measurable_rnDeriv μ ν).aemeasurable
    (rnDeriv_lt_top μ ν) ((integrable_rnDeriv_smul_iff hμν).mpr hf), withDensity_rnDeriv_eq μ ν hμν]
Theorem: Set.IccExtend_eq_self
File: Mathlib/Order/Interval/Set/ProjIcc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x : α
f : α → β
ha : ∀ x < a, f x = f a
hb : ∀ (x : α), b < x → f x = f b
⊢ IccExtend h (f ∘ Subtype.val) = f
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ : α
f : α → β
ha : ∀ x < a, f x = f a
hb : ∀ (x : α), b < x → f x = f b
x : α
⊢ IccExtend h (f ∘ Subtype.val) x = f x
tactic: ext x
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ : α
f : α → β
ha : ∀ x < a, f x = f a
hb : ∀ (x : α), b < x → f x = f b
x : α
⊢ IccExtend h (f ∘ Subtype.val) x = f x
state_after: case h.inl
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ : α
f : α → β
ha : ∀ x < a, f x = f a
hb : ∀ (x : α), b < x → f x = f b
x : α
hxa : x < a
⊢ IccExtend h (f ∘ Subtype.val) x = f x

case h.inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ : α
f : α → β
ha : ∀ x < a, f x = f a
hb : ∀ (x : α), b < x → f x = f b
x : α
hax : a ≤ x
⊢ IccExtend h (f ∘ Subtype.val) x = f x
tactic: cases' lt_or_le x a with hxa hax
Theorem: Nat.choose_two_right
File: Mathlib/Data/Nat/Choose/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ n.choose 2 = n * (n - 1) / 2
state_after: case zero

⊢ choose 0 2 = 0 * (0 - 1) / 2

case succ
n : ℕ
ih : n.choose 2 = n * (n - 1) / 2
⊢ (n + 1).choose 2 = (n + 1) * (n + 1 - 1) / 2
tactic: induction' n with n ih
Theorem: X_pow_sub_C_splits_of_isPrimitiveRoot
File: Mathlib/FieldTheory/KummerExtension.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
n : ℕ
ζ : K
hζ : IsPrimitiveRoot ζ n
α a : K
e : α ^ n = a
⊢ Splits (RingHom.id K) (X ^ n - C a)
state_after: no goals
tactic: cases n.eq_zero_or_pos with
  | inl hn =>
    rw [hn, pow_zero, ← C.map_one, ← map_sub]
    exact splits_C _ _
  | inr hn =>
    rw [splits_iff_card_roots, ← nthRoots, hζ.card_nthRoots, natDegree_X_pow_sub_C, if_pos ⟨α, e⟩]
Theorem: WithBot.sum_eq_bot_iff
File: Mathlib/Algebra/BigOperators/WithTop.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : AddCommMonoid α
inst✝ : LT α
s : Finset ι
f : ι → WithBot α
⊢ ∑ i ∈ s, f i = ⊥ ↔ ∃ i ∈ s, f i = ⊥
state_after: no goals
tactic: induction s using Finset.cons_induction <;> simp [*]
Theorem: LSeries_iteratedDeriv
File: Mathlib/NumberTheory/LSeries/Deriv.lean

Proof steps:
state_before: f : ℕ → ℂ
m : ℕ
s : ℂ
h : abscissaOfAbsConv f < ↑s.re
⊢ iteratedDeriv m (LSeries f) s = (-1) ^ m * LSeries (logMul^[m] f) s
state_after: case zero
f : ℕ → ℂ
s : ℂ
h : abscissaOfAbsConv f < ↑s.re
⊢ iteratedDeriv 0 (LSeries f) s = (-1) ^ 0 * LSeries (logMul^[0] f) s

case succ
f : ℕ → ℂ
m : ℕ
ih : ∀ {s : ℂ}, abscissaOfAbsConv f < ↑s.re → iteratedDeriv m (LSeries f) s = (-1) ^ m * LSeries (logMul^[m] f) s
s : ℂ
h : abscissaOfAbsConv f < ↑s.re
⊢ iteratedDeriv (m + 1) (LSeries f) s = (-1) ^ (m + 1) * LSeries (logMul^[m + 1] f) s
tactic: induction' m with m ih generalizing s
Theorem: Matrix.det_of_lowerTriangular
File: Mathlib/LinearAlgebra/Matrix/Block.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : LinearOrder m
M : Matrix m m R
h : M.BlockTriangular ⇑toDual
⊢ M.det = ∏ i : m, M i i
state_after: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : LinearOrder m
M : Matrix m m R
h : M.BlockTriangular ⇑toDual
⊢ Mᵀ.det = ∏ i : m, M i i
tactic: rw [← det_transpose]
state_before: α : Type u_1
β : Type u_2
m : Type u_3
n : Type u_4
o : Type u_5
m' : α → Type u_6
n' : α → Type u_7
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
inst✝ : LinearOrder m
M : Matrix m m R
h : M.BlockTriangular ⇑toDual
⊢ Mᵀ.det = ∏ i : m, M i i
state_after: no goals
tactic: exact det_of_upperTriangular h.transpose
Theorem: Finset.disjSups_empty_left
File: Mathlib/Data/Finset/Sups.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ ∅ ○ t = ∅
state_after: no goals
tactic: simp [disjSups]
Theorem: PadicInt.maximalIdeal_eq_span_p
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ maximalIdeal ℤ_[p] = Ideal.span {↑p}
state_after: case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ maximalIdeal ℤ_[p] ≤ Ideal.span {↑p}

case a
p : ℕ
hp : Fact (Nat.Prime p)
⊢ Ideal.span {↑p} ≤ maximalIdeal ℤ_[p]
tactic: apply le_antisymm
Theorem: Comon_.trivial_counit
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ (λ_ (𝟙_ C)).inv ≫ 𝟙_ C ◁ (λ_ (𝟙_ C)).inv = (λ_ (𝟙_ C)).inv ≫ (λ_ (𝟙_ C)).inv ▷ 𝟙_ C ≫ (α_ (𝟙_ C) (𝟙_ C) (𝟙_ C)).hom
state_after: no goals
tactic: coherence
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ (λ_ (𝟙_ C)).inv ≫ 𝟙 (𝟙_ C) ▷ 𝟙_ C = (λ_ (𝟙_ C)).inv
state_after: no goals
tactic: coherence
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
⊢ (λ_ (𝟙_ C)).inv ≫ 𝟙_ C ◁ 𝟙 (𝟙_ C) = (ρ_ (𝟙_ C)).inv
state_after: no goals
tactic: coherence
Theorem: MeasureTheory.tilted_of_not_integrable
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ μ.tilted f = 0
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ (μ.withDensity fun x => ENNReal.ofReal (rexp (f x) / 0)) = 0
tactic: rw [Measure.tilted, integral_undef hf]
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
hf : ¬Integrable (fun x => rexp (f x)) μ
⊢ (μ.withDensity fun x => ENNReal.ofReal (rexp (f x) / 0)) = 0
state_after: no goals
tactic: simp
Theorem: Equiv.Perm.fixed_point_card_lt_of_ne_one
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ (filter (fun x => σ x = x) univ).card < Fintype.card α - 1
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ 1 < (filter (fun x => ¬σ x = x) univ).card
tactic: rw [Nat.lt_sub_iff_add_lt, ← Nat.lt_sub_iff_add_lt', ← Finset.card_compl, Finset.compl_filter]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
σ : Perm α
h : σ ≠ 1
⊢ 1 < (filter (fun x => ¬σ x = x) univ).card
state_after: no goals
tactic: exact one_lt_card_support_of_ne_one h
Theorem: WittVector.mapFun.injective
File: Mathlib/RingTheory/WittVector/Basic.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Injective f
⊢ Injective (mapFun f)
state_after: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Injective f
a₁✝ a₂✝ : 𝕎 α
h : mapFun f a₁✝ = mapFun f a₂✝
⊢ a₁✝ = a₂✝
tactic: intros _ _ h
state_before: p : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Injective f
a₁✝ a₂✝ : 𝕎 α
h : mapFun f a₁✝ = mapFun f a₂✝
⊢ a₁✝ = a₂✝
state_after: case h
p✝ : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p✝)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Injective f
a₁✝ a₂✝ : WittVector p✝ α
h : mapFun f a₁✝ = mapFun f a₂✝
p : ℕ
⊢ a₁✝.coeff p = a₂✝.coeff p
tactic: ext p
state_before: case h
p✝ : ℕ
R : Type u_1
S : Type u_2
T : Type u_3
hp : Fact (Nat.Prime p✝)
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : CommRing T
α : Type u_4
β : Type u_5
f : α → β
hf : Injective f
a₁✝ a₂✝ : WittVector p✝ α
h : mapFun f a₁✝ = mapFun f a₂✝
p : ℕ
⊢ a₁✝.coeff p = a₂✝.coeff p
state_after: no goals
tactic: exact hf (congr_arg (fun x => coeff x p) h : _)
Theorem: Behrend.bound_aux
File: Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n ≤ ↑(rothNumberNat ((2 * d - 1) ^ n))
state_after: case h.e'_3
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n = ↑(d ^ n) / ↑(n * d ^ 2)
tactic: convert bound_aux' n d using 1
state_before: case h.e'_3
α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ^ (n - 2) / ↑n = ↑(d ^ n) / ↑(n * d ^ 2)
state_after: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ≠ 0
tactic: rw [cast_mul, cast_pow, mul_comm, ← div_div, pow_sub₀ _ _ hn, ← div_eq_mul_inv, cast_pow]
state_before: α : Type u_1
β : Type u_2
n d k N : ℕ
x : Fin n → ℕ
hd : d ≠ 0
hn : 2 ≤ n
⊢ ↑d ≠ 0
state_after: no goals
tactic: rwa [cast_ne_zero]
Theorem: List.isSublist_iff_sublist
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
l₁ l₂ : List α
⊢ l₁.isSublist l₂ = true ↔ l₁ <+ l₂
state_after: case cons.cons
α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
head✝¹ : α
tail✝¹ : List α
head✝ : α
tail✝ : List α
⊢ (if (head✝¹ == head✝) = true then tail✝¹.isSublist tail✝ = true else (head✝¹ :: tail✝¹).isSublist tail✝ = true) ↔
    head✝¹ :: tail✝¹ <+ head✝ :: tail✝
tactic: cases l₁ <;> cases l₂ <;> simp [isSublist]
Theorem: Fintype.piFinset_singleton
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
f x✝ : (a : α) → δ a
⊢ (x✝ ∈ piFinset fun i => {f i}) ↔ x✝ ∈ {f}
state_after: no goals
tactic: simp only [Function.funext_iff, Fintype.mem_piFinset, mem_singleton]
Theorem: Profinite.pullback_fst_eq
File: Mathlib/Topology/Category/Profinite/Limits.lean

Proof steps:
state_before: X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.fst f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.fst f g
state_after: X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.fst f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.fst f g
tactic: dsimp [pullbackIsoPullback]
state_before: X Y B : Profinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.fst f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.fst f g
state_after: no goals
tactic: simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_π]
Theorem: Function.Injective.compl_image_eq
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
⊢ (f '' s)ᶜ = f '' sᶜ ∪ (range f)ᶜ
state_after: case h
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
y : β
⊢ y ∈ (f '' s)ᶜ ↔ y ∈ f '' sᶜ ∪ (range f)ᶜ
tactic: ext y
state_before: case h
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
y : β
⊢ y ∈ (f '' s)ᶜ ↔ y ∈ f '' sᶜ ∪ (range f)ᶜ
state_after: case h.inl.intro
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
x : α
⊢ f x ∈ (f '' s)ᶜ ↔ f x ∈ f '' sᶜ ∪ (range f)ᶜ

case h.inr
α : Type u_1
β : Type u_2
ι : Sort u_3
f : α → β
hf : Injective f
s : Set α
y : β
hx : y ∉ range f
⊢ y ∈ (f '' s)ᶜ ↔ y ∈ f '' sᶜ ∪ (range f)ᶜ
tactic: rcases em (y ∈ range f) with (⟨x, rfl⟩ | hx)
Theorem: AffineSubspace.direction_inf_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s₁ s₂ : AffineSubspace k P
p : P
h₁ : p ∈ s₁
h₂ : p ∈ s₂
⊢ (s₁ ⊓ s₂).direction = s₁.direction ⊓ s₂.direction
state_after: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s₁ s₂ : AffineSubspace k P
p : P
h₁ : p ∈ s₁
h₂ : p ∈ s₂
v : V
⊢ v ∈ (s₁ ⊓ s₂).direction ↔ v ∈ s₁.direction ⊓ s₂.direction
tactic: ext v
state_before: case h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
s₁ s₂ : AffineSubspace k P
p : P
h₁ : p ∈ s₁
h₂ : p ∈ s₂
v : V
⊢ v ∈ (s₁ ⊓ s₂).direction ↔ v ∈ s₁.direction ⊓ s₂.direction
state_after: no goals
tactic: rw [Submodule.mem_inf, ← vadd_mem_iff_mem_direction v h₁, ← vadd_mem_iff_mem_direction v h₂, ←
    vadd_mem_iff_mem_direction v ((mem_inf_iff p s₁ s₂).2 ⟨h₁, h₂⟩), mem_inf_iff]
Theorem: Real.Angle.sin_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: ⊢ sin 0 = 0
state_after: no goals
tactic: rw [← coe_zero, sin_coe, Real.sin_zero]
Theorem: MeasureTheory.Measure.haar.addPrehaar_mem_addHaarProduct
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
⊢ prehaar (↑K₀) U ∈ haarProduct ↑K₀
state_after: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∈
    (fun K => Icc 0 ↑(index ↑K ↑K₀)) { carrier := K, isCompact' := hK }
tactic: rintro ⟨K, hK⟩ _
state_before: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∈
    (fun K => Icc 0 ↑(index ↑K ↑K₀)) { carrier := K, isCompact' := hK }
state_after: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ 0 ≤ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∧
    prehaar (↑K₀) U { carrier := K, isCompact' := hK } ≤ ↑(index ↑{ carrier := K, isCompact' := hK } ↑K₀)
tactic: rw [mem_Icc]
state_before: case mk
G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : (interior U).Nonempty
K : Set G
hK : IsCompact K
a✝ : { carrier := K, isCompact' := hK } ∈ univ
⊢ 0 ≤ prehaar (↑K₀) U { carrier := K, isCompact' := hK } ∧
    prehaar (↑K₀) U { carrier := K, isCompact' := hK } ≤ ↑(index ↑{ carrier := K, isCompact' := hK } ↑K₀)
state_after: no goals
tactic: exact ⟨prehaar_nonneg K₀ _, prehaar_le_index K₀ _ hU⟩
Theorem: Set.Icc.coe_eq_zero
File: Mathlib/Algebra/Order/Interval/Set/Instances.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ ↑x = 0 ↔ x = 0
state_after: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ x = 0 ↔ ↑x = 0
tactic: symm
state_before: α : Type u_1
inst✝ : OrderedSemiring α
x : ↑(Icc 0 1)
⊢ x = 0 ↔ ↑x = 0
state_after: no goals
tactic: exact Subtype.ext_iff
Theorem: LightCondensed.ofSheafForgetLightProfinite_val
File: Mathlib/Condensed/Light/Explicit.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : Category.{?u.8867, u_1} A
inst✝² : ConcreteCategory A
inst✝¹ : ReflectsFiniteLimits (CategoryTheory.forget A)
F : LightProfiniteᵒᵖ ⥤ A
inst✝ : PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)
hF : EqualizerCondition (F ⋙ CategoryTheory.forget A)
⊢ IsSheaf (coherentTopology LightProfinite) F
state_after: A : Type u_1
inst✝³ : Category.{?u.8867, u_1} A
inst✝² : ConcreteCategory A
inst✝¹ : ReflectsFiniteLimits (CategoryTheory.forget A)
F : LightProfiniteᵒᵖ ⥤ A
inst✝ : PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)
hF : EqualizerCondition (F ⋙ CategoryTheory.forget A)
⊢ IsSheaf (coherentTopology LightProfinite) (F ⋙ CategoryTheory.forget A)
tactic: apply isSheaf_coherent_of_hasPullbacks_of_comp F (CategoryTheory.forget A)
state_before: A : Type u_1
inst✝³ : Category.{?u.8867, u_1} A
inst✝² : ConcreteCategory A
inst✝¹ : ReflectsFiniteLimits (CategoryTheory.forget A)
F : LightProfiniteᵒᵖ ⥤ A
inst✝ : PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)
hF : EqualizerCondition (F ⋙ CategoryTheory.forget A)
⊢ IsSheaf (coherentTopology LightProfinite) (F ⋙ CategoryTheory.forget A)
state_after: A : Type u_1
inst✝³ : Category.{?u.8867, u_1} A
inst✝² : ConcreteCategory A
inst✝¹ : ReflectsFiniteLimits (CategoryTheory.forget A)
F : LightProfiniteᵒᵖ ⥤ A
inst✝ : PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)
hF : EqualizerCondition (F ⋙ CategoryTheory.forget A)
⊢ Nonempty (PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)) ∧ EqualizerCondition (F ⋙ CategoryTheory.forget A)
tactic: rw [isSheaf_iff_preservesFiniteProducts_and_equalizerCondition]
state_before: A : Type u_1
inst✝³ : Category.{?u.8867, u_1} A
inst✝² : ConcreteCategory A
inst✝¹ : ReflectsFiniteLimits (CategoryTheory.forget A)
F : LightProfiniteᵒᵖ ⥤ A
inst✝ : PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)
hF : EqualizerCondition (F ⋙ CategoryTheory.forget A)
⊢ Nonempty (PreservesFiniteProducts (F ⋙ CategoryTheory.forget A)) ∧ EqualizerCondition (F ⋙ CategoryTheory.forget A)
state_after: no goals
tactic: exact ⟨⟨⟨fun _ _ ↦ inferInstance⟩⟩, hF⟩
Theorem: HasDerivAt.comp_ofReal
File: Mathlib/Analysis/Complex/RealDeriv.lean

Proof steps:
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
hf : HasDerivAt e e' ↑z
⊢ HasDerivAt (fun y => e ↑y) e' z
state_after: no goals
tactic: simpa only [ofRealCLM_apply, ofReal_one, mul_one] using hf.comp z ofRealCLM.hasDerivAt
Theorem: CategoryTheory.Limits.π_comp_cokernelIsoOfEq_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
f g : X ⟶ Y
inst✝¹ : HasCokernel f
inst✝ : HasCokernel g
h : f = g
⊢ cokernel.π f ≫ (cokernelIsoOfEq h).hom = cokernel.π g
state_after: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasCokernel f
⊢ cokernel.π f ≫ (cokernelIsoOfEq ⋯).hom = cokernel.π f
tactic: cases h
state_before: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasCokernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasCokernel f
⊢ cokernel.π f ≫ (cokernelIsoOfEq ⋯).hom = cokernel.π f
state_after: no goals
tactic: simp