ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AkraBazziRecurrence.eventually_log_b_mul_pos
File: Mathlib/Computability/AkraBazzi/AkraBazzi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ᶠ (n : ℕ) in atTop, ∀ (i : α), 0 < log (b i * ↑n)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, 0 < log (b i * ↑x)
tactic: rw [Filter.eventually_all]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
⊢ ∀ (i : α), ∀ᶠ (x : ℕ) in atTop, 0 < log (b i * ↑x)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
⊢ ∀ᶠ (x : ℕ) in atTop, 0 < log (b i * ↑x)
tactic: intro i
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
⊢ ∀ᶠ (x : ℕ) in atTop, 0 < log (b i * ↑x)
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
h : Tendsto (fun n => log (b i * ↑n)) atTop atTop
⊢ ∀ᶠ (x : ℕ) in atTop, 0 < log (b i * ↑x)
tactic: have h : Tendsto (fun (n : ℕ) => log (b i * n)) atTop atTop :=
    Tendsto.comp tendsto_log_atTop
      <| Tendsto.const_mul_atTop (b_pos R i) tendsto_natCast_atTop_atTop
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
i : α
h : Tendsto (fun n => log (b i * ↑n)) atTop atTop
⊢ ∀ᶠ (x : ℕ) in atTop, 0 < log (b i * ↑x)
state_after: no goals
tactic: exact h.eventually_gt_atTop 0
Theorem: AddSubgroup.map_comap_eq
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H : Subgroup N
⊢ ↑(map f (comap f H)) = ↑(f.range ⊓ H)
state_after: no goals
tactic: rw [coe_map, coe_comap, Set.image_preimage_eq_inter_range, coe_inf, coe_range, Set.inter_comm]
Theorem: LinearMap.toMatrixAlgEquiv_toLinAlgEquiv
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝⁸ : Fintype n
inst✝⁷ : Fintype m
inst✝⁶ : DecidableEq n
M₁ : Type u_5
M₂ : Type u_6
inst✝⁵ : AddCommMonoid M₁
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M₁
inst✝² : Module R M₂
v₁ : Basis n R M₁
v₂ : Basis m R M₂
M₃ : Type u_7
inst✝¹ : AddCommMonoid M₃
inst✝ : Module R M₃
v₃ : Basis l R M₃
M : Matrix n n R
⊢ (toMatrixAlgEquiv v₁) ((toLinAlgEquiv v₁) M) = M
state_after: no goals
tactic: rw [← Matrix.toLinAlgEquiv_symm, AlgEquiv.symm_apply_apply]
Theorem: Nat.Icc_succ_left
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
⊢ Icc a.succ b = Ioc a b
state_after: case a
a b c x : ℕ
⊢ x ∈ Icc a.succ b ↔ x ∈ Ioc a b
tactic: ext x
state_before: case a
a b c x : ℕ
⊢ x ∈ Icc a.succ b ↔ x ∈ Ioc a b
state_after: no goals
tactic: rw [mem_Icc, mem_Ioc, succ_le_iff]
Theorem: Filter.Tendsto.atBot_zsmul_const
File: Mathlib/Order/Filter/Archimedean.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto f l atBot
⊢ Tendsto (fun x => f x • r) l atBot
state_after: α : Type u_1
R : Type u_2
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto (fun x => -f x) l atTop
⊢ Tendsto (fun x => -f x • r) l atTop
tactic: simp only [← tendsto_neg_atTop_iff, ← neg_zsmul] at hf ⊢
state_before: α : Type u_1
R : Type u_2
l : Filter α
f✝ : α → R
r : R
inst✝¹ : LinearOrderedAddCommGroup R
inst✝ : Archimedean R
f : α → ℤ
hr : 0 < r
hf : Tendsto (fun x => -f x) l atTop
⊢ Tendsto (fun x => -f x • r) l atTop
state_after: no goals
tactic: exact hf.atTop_zsmul_const hr
Theorem: CategoryTheory.Limits.biproduct.ι_π
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : DecidableEq J
f : J → C
inst✝ : HasBiproduct f
j j' : J
⊢ ι f j ≫ π f j' = if h : j = j' then eqToHom ⋯ else 0
state_after: no goals
tactic: convert (biproduct.bicone f).ι_π j j'
Theorem: Subgroup.le_normalizer_of_normal
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
hK : (H.subgroupOf K).Normal
HK : H ≤ K
x : G
hx : x ∈ K
y : G
yH : x * y * x⁻¹ ∈ H
⊢ y ∈ H
state_after: no goals
tactic: simpa [mem_subgroupOf, mul_assoc] using
      hK.conj_mem ⟨x * y * x⁻¹, HK yH⟩ yH ⟨x⁻¹, K.inv_mem hx⟩
Theorem: isOpen_iff_ultrafilter
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ IsOpen s ↔ ∀ x ∈ s, ∀ (l : Ultrafilter X), ↑l ≤ 𝓝 x → s ∈ l
state_after: no goals
tactic: simp_rw [isOpen_iff_mem_nhds, ← mem_iff_ultrafilter]
Theorem: AlgebraicTopology.DoldKan.HigherFacesVanish.inclusionOfMooreComplexMap
File: Mathlib/AlgebraicTopology/DoldKan/Normalized.lean

Proof steps:
state_before: A : Type u_1
inst✝¹ : Category.{u_2, u_1} A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
j : Fin (n + 1)
x✝ : n + 1 ≤ ↑j + (n + 1)
⊢ (AlgebraicTopology.inclusionOfMooreComplexMap X).f (n + 1) ≫ X.δ j.succ = 0
state_after: A : Type u_1
inst✝¹ : Category.{u_2, u_1} A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
j : Fin (n + 1)
x✝ : n + 1 ≤ ↑j + (n + 1)
⊢ (Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).arrow ≫ X.δ j.succ = 0
tactic: dsimp [AlgebraicTopology.inclusionOfMooreComplexMap, NormalizedMooreComplex.objX]
state_before: A : Type u_1
inst✝¹ : Category.{u_2, u_1} A
inst✝ : Abelian A
X : SimplicialObject A
n : ℕ
j : Fin (n + 1)
x✝ : n + 1 ≤ ↑j + (n + 1)
⊢ (Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).arrow ≫ X.δ j.succ = 0
state_after: no goals
tactic: rw [← factorThru_arrow _ _ (finset_inf_arrow_factors Finset.univ _ j
    (by simp only [Finset.mem_univ])), assoc, kernelSubobject_arrow_comp, comp_zero]
Theorem: nhdsSet_Icc
File: Mathlib/Topology/Order/NhdsSet.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
a b c d : α
h : a ≤ b
⊢ 𝓝ˢ (Icc a b) = 𝓝 a ⊔ 𝓝 b ⊔ 𝓟 (Ioo a b)
state_after: case inl
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
a c d : α
h : a ≤ a
⊢ 𝓝ˢ (Icc a a) = 𝓝 a ⊔ 𝓝 a ⊔ 𝓟 (Ioo a a)

case inr
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
a b c d : α
h : a ≤ b
hlt : a < b
⊢ 𝓝ˢ (Icc a b) = 𝓝 a ⊔ 𝓝 b ⊔ 𝓟 (Ioo a b)
tactic: rcases h.eq_or_lt with rfl | hlt
Theorem: monovary_inv_right
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ Monovary f g⁻¹ ↔ Antivary f g
state_after: no goals
tactic: simpa [Monovary, Antivary] using forall_swap
Theorem: MeasureTheory.Measure.le_comap_apply
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
μ : Measure β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → NullMeasurableSet (f '' s) μ
s : Set α
⊢ μ (f '' s) ≤ (comap f μ) s
state_after: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
μ : Measure β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → NullMeasurableSet (f '' s) μ
s : Set α
⊢ μ (f '' s) ≤ (((OuterMeasure.comap f) μ.toOuterMeasure).toMeasure ⋯) s
tactic: rw [comap, dif_pos (And.intro hfi hf)]
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β✝
inst✝¹ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β✝
β : Type u_8
inst✝ : MeasurableSpace α
mβ : MeasurableSpace β
f : α → β
μ : Measure β
hfi : Injective f
hf : ∀ (s : Set α), MeasurableSet s → NullMeasurableSet (f '' s) μ
s : Set α
⊢ μ (f '' s) ≤ (((OuterMeasure.comap f) μ.toOuterMeasure).toMeasure ⋯) s
state_after: no goals
tactic: exact le_toMeasure_apply _ _ _
Theorem: Real.arccos_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ 0 < arccos x ↔ x < 1
state_after: no goals
tactic: simp [arccos]
Theorem: Nat.iSup_le_succ
File: Mathlib/Data/Nat/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CompleteLattice α
u : ℕ → α
n : ℕ
⊢ ⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1)
state_after: no goals
tactic: simp_rw [← Nat.lt_succ_iff, iSup_lt_succ]
Theorem: CochainComplex.homOfDegreewiseSplit_f
File: Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S : ShortComplex (CochainComplex C ℤ)
σ : (n : ℤ) → (S.map (eval C (ComplexShape.up ℤ) n)).Splitting
n : ℤ
⊢ (homOfDegreewiseSplit S σ).f n = (↑(cocycleOfDegreewiseSplit S σ)).v n (n + 1) ⋯
state_after: no goals
tactic: simp [homOfDegreewiseSplit, Cochain.rightShift_v _ _ _ _ _ _ _ _ rfl]
Theorem: List.get_eq_iff
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
l : List α✝
n : Fin l.length
x : α✝
⊢ l.get n = x ↔ l.get? ↑n = some x
state_after: no goals
tactic: simp
Theorem: PadicInt.norm_eq_of_norm_add_lt_left
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ ‖z1 + z2‖ ≥ ‖z1‖
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z1‖
tactic: rw [norm_add_eq_max_of_ne hne]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
h : ‖z1 + z2‖ < ‖z1‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z1‖
state_after: no goals
tactic: apply le_max_left
Theorem: ZMod.χ₄_eq_neg_one_pow
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

Proof steps:
state_before: n : ℕ
hn : n % 2 = 1
⊢ χ₄ ↑n = (-1) ^ (n / 2)
state_after: n : ℕ
hn : n % 2 = 1
⊢ (if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1) = (-1) ^ (n / 2)
tactic: rw [χ₄_nat_eq_if_mod_four]
state_before: n : ℕ
hn : n % 2 = 1
⊢ (if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1) = (-1) ^ (n / 2)
state_after: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ (n / 2)
tactic: simp only [hn, Nat.one_ne_zero, if_false]
state_before: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ (n / 2)
state_after: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ ((4 * (n / 4) + n % 4) / 2)
tactic: nth_rewrite 3 [← Nat.div_add_mod n 4]
state_before: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ ((4 * (n / 4) + n % 4) / 2)
state_after: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ ((2 * 2 * (n / 4) + n % 4) / 2)
tactic: nth_rewrite 3 [show 4 = 2 * 2 by omega]
state_before: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ ((2 * 2 * (n / 4) + n % 4) / 2)
state_after: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ (n % 4 / 2)
tactic: rw [mul_assoc, add_comm, Nat.add_mul_div_left _ _ zero_lt_two, pow_add, pow_mul,
    neg_one_sq, one_pow, mul_one]
state_before: n : ℕ
hn : n % 2 = 1
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ (n % 4 / 2)
state_after: n : ℕ
hn : n % 2 = 1
help : ∀ m < 4, m % 2 = 1 → (if m = 1 then 1 else -1) = (-1) ^ (m / 2)
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ (n % 4 / 2)
tactic: have help : ∀ m : ℕ, m < 4 → m % 2 = 1 → ite (m = 1) (1 : ℤ) (-1) = (-1) ^ (m / 2) := by decide
state_before: n : ℕ
hn : n % 2 = 1
help : ∀ m < 4, m % 2 = 1 → (if m = 1 then 1 else -1) = (-1) ^ (m / 2)
⊢ (if n % 4 = 1 then 1 else -1) = (-1) ^ (n % 4 / 2)
state_after: no goals
tactic: exact help _ (Nat.mod_lt n (by omega)) <| (Nat.mod_mod_of_dvd n (by omega : 2 ∣ 4)).trans hn
Theorem: Quaternion.im_exp
File: Mathlib/Analysis/NormedSpace/QuaternionExponential.lean

Proof steps:
state_before: q : ℍ
⊢ (exp ℝ q).im = (exp ℝ q.re * (Real.sin ‖q.im‖ / ‖q.im‖)) • q.im
state_after: no goals
tactic: simp [exp_eq, smul_smul]
Theorem: ProbabilityTheory.integrable_kernel_prod_mk_left
File: Mathlib/Probability/Kernel/IntegralCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a✝ a : α
s : Set (β × γ)
hs : MeasurableSet s
h2s : ((κ ⊗ₖ η) a) s ≠ ⊤
⊢ Integrable (fun b => ((η (a, b)) (Prod.mk b ⁻¹' s)).toReal) (κ a)
state_after: case left
α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a✝ a : α
s : Set (β × γ)
hs : MeasurableSet s
h2s : ((κ ⊗ₖ η) a) s ≠ ⊤
⊢ AEStronglyMeasurable (fun b => ((η (a, b)) (Prod.mk b ⁻¹' s)).toReal) (κ a)

case right
α : Type u_1
β : Type u_2
γ : Type u_3
E : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝² : NormedAddCommGroup E
κ : Kernel α β
inst✝¹ : IsSFiniteKernel κ
η : Kernel (α × β) γ
inst✝ : IsSFiniteKernel η
a✝ a : α
s : Set (β × γ)
hs : MeasurableSet s
h2s : ((κ ⊗ₖ η) a) s ≠ ⊤
⊢ HasFiniteIntegral (fun b => ((η (a, b)) (Prod.mk b ⁻¹' s)).toReal) (κ a)
tactic: constructor
Theorem: Set.Ioc_inter_Ioo_of_left_lt
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
h : b₁ < b₂
x : α
⊢ x ∈ Ioc a₁ b₁ ∩ Ioo a₂ b₂ ↔ x ∈ Ioc (max a₁ a₂) b₁
state_after: no goals
tactic: simp [and_assoc, @and_left_comm (x ≤ _), and_iff_left_iff_imp.2 fun h' => lt_of_le_of_lt h' h]
Theorem: Nat.nth_zero
File: Mathlib/Data/Nat/Nth.lean

Proof steps:
state_before: p : ℕ → Prop
⊢ nth p 0 = sInf (setOf p)
state_after: p : ℕ → Prop
⊢ sInf {x | p x ∧ ∀ k < 0, nth p k < x} = sInf (setOf p)
tactic: rw [nth_eq_sInf]
state_before: p : ℕ → Prop
⊢ sInf {x | p x ∧ ∀ k < 0, nth p k < x} = sInf (setOf p)
state_after: no goals
tactic: simp
Theorem: Real.aemeasurable_of_aemeasurable_exp
File: Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean

Proof steps:
state_before: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
μ : MeasureTheory.Measure α
hf : AEMeasurable (fun x => rexp (f x)) μ
⊢ AEMeasurable f μ
state_after: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
μ : MeasureTheory.Measure α
hf : AEMeasurable (fun x => rexp (f x)) μ
this : f = fun x => log (rexp (f x))
⊢ AEMeasurable f μ
tactic: have : f = fun x ↦ log (exp (f x)) := by ext; rw [log_exp]
state_before: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
μ : MeasureTheory.Measure α
hf : AEMeasurable (fun x => rexp (f x)) μ
this : f = fun x => log (rexp (f x))
⊢ AEMeasurable f μ
state_after: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
μ : MeasureTheory.Measure α
hf : AEMeasurable (fun x => rexp (f x)) μ
this : f = fun x => log (rexp (f x))
⊢ AEMeasurable (fun x => log (rexp (f x))) μ
tactic: rw [this]
state_before: α : Type u_1
x✝ : MeasurableSpace α
f : α → ℝ
μ : MeasureTheory.Measure α
hf : AEMeasurable (fun x => rexp (f x)) μ
this : f = fun x => log (rexp (f x))
⊢ AEMeasurable (fun x => log (rexp (f x))) μ
state_after: no goals
tactic: exact measurable_log.comp_aemeasurable hf
Theorem: CauSeq.mul_inv_cancel
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
f : CauSeq β abv
hf : ¬f.LimZero
ε : α
ε0 : ε > 0
K : α
K0 : K > 0
i : ℕ
H : ∀ j ≥ i, K ≤ abv (↑f j)
j : ℕ
ij : j ≥ i
⊢ abv (↑(f * f.inv hf - 1) j) < ε
state_after: no goals
tactic: simpa [(abv_pos abv).1 (lt_of_lt_of_le K0 (H _ ij)), abv_zero abv] using ε0
Theorem: _private.Mathlib.RingTheory.WittVector.Basic.0.WittVector.ghostFun_neg
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
x y : 𝕎 R
⊢ WittVector.ghostFun (-x) = -WittVector.ghostFun x
state_after: no goals
tactic: ghost_fun_tac -X 0, ![x.coeff]
Theorem: LipschitzOnWith.of_le_add
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoMetricSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
K : ℝ≥0
s : Set α
f✝ : α → β
f : α → ℝ
h : ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + dist x y
⊢ ∀ x ∈ s, ∀ y ∈ s, f x ≤ f y + ↑1 * dist x y
state_after: no goals
tactic: simpa only [NNReal.coe_one, one_mul]
Theorem: Polynomial.natSepDegree_X_sub_C
File: Mathlib/FieldTheory/SeparableDegree.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
x : F
⊢ (X - C x).natSepDegree = 1
state_after: no goals
tactic: simp only [natSepDegree, aroots_X_sub_C, Multiset.toFinset_singleton, Finset.card_singleton]
Theorem: TopCat.Presheaf.isSheaf_of_isTerminal_of_indiscrete
File: Mathlib/Topology/Sheaves/PUnit.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : TopCat
hind : X.str = ⊤
F : Presheaf C X
it : IsTerminal (F.obj (op ⊥))
c : C
U : TopologicalSpace.Opens ↑X
s : Sieve U
hs : s ∈ (Opens.grothendieckTopology ↑X).sieves U
⊢ Presieve.IsSheafFor (F ⋙ coyoneda.obj (op c)) s.arrows
state_after: case inl
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
hind : X.str = ⊤
F : Presheaf C X
it : IsTerminal (F.obj (op ⊥))
c : C
s : Sieve ⊥
hs : s ∈ (Opens.grothendieckTopology ↑X).sieves ⊥
⊢ Presieve.IsSheafFor (F ⋙ coyoneda.obj (op c)) s.arrows

case inr
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
hind : X.str = ⊤
F : Presheaf C X
it : IsTerminal (F.obj (op ⊥))
c : C
U : TopologicalSpace.Opens ↑X
s : Sieve U
hs : s ∈ (Opens.grothendieckTopology ↑X).sieves U
hne : U ≠ ⊥
⊢ Presieve.IsSheafFor (F ⋙ coyoneda.obj (op c)) s.arrows
tactic: obtain rfl | hne := eq_or_ne U ⊥
Theorem: ENNReal.toReal_mono'
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b
ht : b = ⊤ → a = ⊤
⊢ a.toReal ≤ b.toReal
state_after: case inl
b c d : ℝ≥0∞
r p q : ℝ≥0
h : ⊤ ≤ b
ht : b = ⊤ → ⊤ = ⊤
⊢ ⊤.toReal ≤ b.toReal

case inr
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b
ht : b = ⊤ → a = ⊤
ha : a ≠ ⊤
⊢ a.toReal ≤ b.toReal
tactic: rcases eq_or_ne a ∞ with rfl | ha
Theorem: Basis.flag_le_ker_dual
File: Mathlib/LinearAlgebra/Basis/Flag.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
⊢ b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
a✝ : Nontrivial R
⊢ b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)
tactic: nontriviality R
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
n : ℕ
b : Basis (Fin n) R M
k : Fin n
a✝ : Nontrivial R
⊢ b.flag k.castSucc ≤ LinearMap.ker (b.dualBasis k)
state_after: no goals
tactic: rw [coe_dualBasis, b.flag_le_ker_coord_iff]
Theorem: DivisorChain.first_of_chain_isUnit
File: Mathlib/RingTheory/ChainOfDivisors.lean

Proof steps:
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
⊢ IsUnit (c 0)
state_after: case intro
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
i : Fin (n + 1)
hr : 1 = c i
⊢ IsUnit (c 0)
tactic: obtain ⟨i, hr⟩ := h₂.mp Associates.one_le
state_before: case intro
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
i : Fin (n + 1)
hr : 1 = c i
⊢ IsUnit (c 0)
state_after: case intro
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
i : Fin (n + 1)
hr : 1 = c i
⊢ c 0 ≤ c i
tactic: rw [Associates.isUnit_iff_eq_one, ← Associates.le_one_iff, hr]
state_before: case intro
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
i : Fin (n + 1)
hr : 1 = c i
⊢ c 0 ≤ c i
state_after: no goals
tactic: exact h₁.monotone (Fin.zero_le i)
Theorem: le_self_pow
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
n m : ℕ
ha : 1 ≤ a
h : m ≠ 0
⊢ a ≤ a ^ m
state_after: no goals
tactic: simpa only [pow_one] using pow_le_pow_right ha <| Nat.pos_iff_ne_zero.2 h
Theorem: MeasureTheory.Measure.AbsolutelyContinuous.map
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
f✝ : α → β
h : μ ≪ ν
f : α → β
hf : Measurable f
s : Set β
hs : MeasurableSet s
⊢ (map f ν) s = 0 → (map f μ) s = 0
state_after: no goals
tactic: simpa [hf, hs] using @h _