ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: strictConcaveOn_cos_Icc
File: Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean

Proof steps:
state_before: ⊢ StrictConcaveOn ℝ (Icc (-(π / 2)) (π / 2)) cos
state_after: x : ℝ
hx : x ∈ interior (Icc (-(π / 2)) (π / 2))
⊢ deriv^[2] cos x < 0
tactic: apply strictConcaveOn_of_deriv2_neg (convex_Icc _ _) continuousOn_cos fun x hx => ?_
state_before: x : ℝ
hx : x ∈ interior (Icc (-(π / 2)) (π / 2))
⊢ deriv^[2] cos x < 0
state_after: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
⊢ deriv^[2] cos x < 0
tactic: rw [interior_Icc] at hx
state_before: x : ℝ
hx : x ∈ Ioo (-(π / 2)) (π / 2)
⊢ deriv^[2] cos x < 0
state_after: no goals
tactic: simp [cos_pos_of_mem_Ioo hx]
Theorem: Int.even_mul
File: Mathlib/Algebra/Group/Int.lean

Proof steps:
state_before: u v m n : ℤ
⊢ Even (m * n) ↔ Even m ∨ Even n
state_after: no goals
tactic: cases' emod_two_eq_zero_or_one m with h₁ h₁ <;>
  cases' emod_two_eq_zero_or_one n with h₂ h₂ <;>
  simp [even_iff, h₁, h₂, Int.mul_emod]
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
hj : j = 0
⊢ False
state_after: no goals
tactic: simp [hj, Fin.not_lt_zero] at H
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.δ j ≫ X.δ i = X.δ i.castSucc ≫ X.δ (j.pred ⋯)
state_after: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ j).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ (j.pred ⋯)).op
tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : i.castSucc < j
⊢ X.map (SimplexCategory.δ j).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ i.castSucc).op ≫ X.map (SimplexCategory.δ (j.pred ⋯)).op
state_after: no goals
tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
Theorem: MeasureTheory.setIntegral_gt_gt
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f✝ g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
R : ℝ
f : X → ℝ
hR : 0 ≤ R
hfint : IntegrableOn f {x | R < f x} μ
hμ : μ {x | R < f x} ≠ 0
⊢ (μ {x | R < f x}).toReal * R < ∫ (x : X) in {x | R < f x}, f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f✝ g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
R : ℝ
f : X → ℝ
hR : 0 ≤ R
hfint : IntegrableOn f {x | R < f x} μ
hμ : μ {x | R < f x} ≠ 0
this : IntegrableOn (fun x => R) {x | R < f x} μ
⊢ (μ {x | R < f x}).toReal * R < ∫ (x : X) in {x | R < f x}, f x ∂μ
tactic: have : IntegrableOn (fun _ => R) {x | ↑R < f x} μ := by
    refine ⟨aestronglyMeasurable_const, lt_of_le_of_lt ?_ hfint.2⟩
    refine setLIntegral_mono_ae hfint.1.ennnorm <| ae_of_all _ fun x hx => ?_
    simp only [ENNReal.coe_le_coe, Real.nnnorm_of_nonneg hR,
      Real.nnnorm_of_nonneg (hR.trans <| le_of_lt hx), Subtype.mk_le_mk]
    exact le_of_lt hx
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f✝ g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
R : ℝ
f : X → ℝ
hR : 0 ≤ R
hfint : IntegrableOn f {x | R < f x} μ
hμ : μ {x | R < f x} ≠ 0
this : IntegrableOn (fun x => R) {x | R < f x} μ
⊢ (μ {x | R < f x}).toReal * R < ∫ (x : X) in {x | R < f x}, f x ∂μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f✝ g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
R : ℝ
f : X → ℝ
hR : 0 ≤ R
hfint : IntegrableOn f {x | R < f x} μ
hμ : μ {x | R < f x} ≠ 0
this : IntegrableOn (fun x => R) {x | R < f x} μ
⊢ 0 < μ ((support fun a => f a - R) ∩ {x | R < f x})

case hf
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f✝ g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
R : ℝ
f : X → ℝ
hR : 0 ≤ R
hfint : IntegrableOn f {x | R < f x} μ
hμ : μ {x | R < f x} ≠ 0
this : IntegrableOn (fun x => R) {x | R < f x} μ
⊢ 0 ≤ᶠ[ae (μ.restrict {x | R < f x})] fun a => f a - R

case hfi
X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝² : MeasurableSpace X
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f✝ g : X → E
s t : Set X
μ ν : Measure X
l l' : Filter X
R : ℝ
f : X → ℝ
hR : 0 ≤ R
hfint : IntegrableOn f {x | R < f x} μ
hμ : μ {x | R < f x} ≠ 0
this : IntegrableOn (fun x => R) {x | R < f x} μ
⊢ IntegrableOn (fun a => f a - R) {x | R < f x} μ
tactic: rw [← sub_pos, ← smul_eq_mul, ← setIntegral_const, ← integral_sub hfint this,
    setIntegral_pos_iff_support_of_nonneg_ae]
Theorem: Composition.blocksFun_congr
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : Composition n
n₁ n₂ : ℕ
c₁ : Composition n₁
c₂ : Composition n₂
i₁ : Fin c₁.length
i₂ : Fin c₂.length
hn : n₁ = n₂
hc : c₁.blocks = c₂.blocks
hi : ↑i₁ = ↑i₂
⊢ c₁.blocksFun i₁ = c₂.blocksFun i₂
state_after: case refl
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ : Fin c₁.length
c₂ : Composition n₁
i₂ : Fin c₂.length
hc : c₁.blocks = c₂.blocks
hi : ↑i₁ = ↑i₂
⊢ c₁.blocksFun i₁ = c₂.blocksFun i₂
tactic: cases hn
state_before: case refl
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ : Fin c₁.length
c₂ : Composition n₁
i₂ : Fin c₂.length
hc : c₁.blocks = c₂.blocks
hi : ↑i₁ = ↑i₂
⊢ c₁.blocksFun i₁ = c₂.blocksFun i₂
state_after: case refl
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ : Fin c₁.length
c₂ : Composition n₁
i₂ : Fin c₂.length
hc : c₁ = c₂
hi : ↑i₁ = ↑i₂
⊢ c₁.blocksFun i₁ = c₂.blocksFun i₂
tactic: rw [← Composition.ext_iff] at hc
state_before: case refl
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ : Fin c₁.length
c₂ : Composition n₁
i₂ : Fin c₂.length
hc : c₁ = c₂
hi : ↑i₁ = ↑i₂
⊢ c₁.blocksFun i₁ = c₂.blocksFun i₂
state_after: case refl.refl
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ i₂ : Fin c₁.length
hi : ↑i₁ = ↑i₂
⊢ c₁.blocksFun i₁ = c₁.blocksFun i₂
tactic: cases hc
state_before: case refl.refl
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ i₂ : Fin c₁.length
hi : ↑i₁ = ↑i₂
⊢ c₁.blocksFun i₁ = c₁.blocksFun i₂
state_after: case refl.refl.e_a
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ i₂ : Fin c₁.length
hi : ↑i₁ = ↑i₂
⊢ i₁ = i₂
tactic: congr
state_before: case refl.refl.e_a
n : ℕ
c : Composition n
n₁ : ℕ
c₁ : Composition n₁
i₁ i₂ : Fin c₁.length
hi : ↑i₁ = ↑i₂
⊢ i₁ = i₂
state_after: no goals
tactic: rwa [Fin.ext_iff]
Theorem: ProjectiveSpectrum.gc_homogeneousIdeal
File: Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝³ : CommSemiring R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
I : HomogeneousIdeal 𝒜
t : (Set (ProjectiveSpectrum 𝒜))ᵒᵈ
⊢ (fun I => zeroLocus 𝒜 ↑I) I ≤ t ↔ I ≤ (fun t => vanishingIdeal t) t
state_after: no goals
tactic: simpa [show I.toIdeal ≤ (vanishingIdeal t).toIdeal ↔ I ≤ vanishingIdeal t from Iff.rfl] using
    subset_zeroLocus_iff_le_vanishingIdeal t I.toIdeal
Theorem: Finset.Colex.toColex_lt_singleton
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ { ofColex := s } < { ofColex := {a} } ↔ ∀ b ∈ s, b < a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ (∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a)) ∧ s ≠ {a} ↔ ∀ b ∈ s, b < a
tactic: rw [lt_iff_le_and_ne, toColex_le_singleton, toColex_ne_toColex]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
a b : α
⊢ (∀ b ∈ s, b ≤ a ∧ (a ∈ s → b = a)) ∧ s ≠ {a} ↔ ∀ b ∈ s, b < a
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
s t u : Finset α
b✝ b : α
hb : b ∈ s
h : (∀ b_1 ∈ s, b_1 ≤ b ∧ (b ∈ s → b_1 = b)) ∧ s ≠ {b}
⊢ False

case refine_2
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
f : α → β
𝒜 𝒜₁ 𝒜₂ : Finset (Finset α)
t u : Finset α
a b : α
h : ∀ b ∈ {a}, b < a
⊢ False
tactic: refine ⟨fun h b hb ↦ (h.1 _ hb).1.lt_of_ne ?_,
    fun h ↦ ⟨fun b hb ↦ ⟨(h _ hb).le, fun ha ↦ (lt_irrefl _ <| h _ ha).elim⟩, ?_⟩⟩ <;> rintro rfl
Theorem: Combinatorics.Line.prod_apply
File: Mathlib/Combinatorics/HalesJewett.lean

Proof steps:
state_before: η : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ : Type u_4
l✝ : Line α✝ ι✝
i : ι✝
a x✝ : α✝
α : Type u_5
ι : Type u_6
ι' : Type u_7
l : Line α ι
l' : Line α ι'
x : α
⊢ (fun x i => ((l.prod l').idxFun i).getD x) x =
    Sum.elim ((fun x i => (l.idxFun i).getD x) x) ((fun x i => (l'.idxFun i).getD x) x)
state_after: case h
η : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ : Type u_4
l✝ : Line α✝ ι✝
i✝ : ι✝
a x✝ : α✝
α : Type u_5
ι : Type u_6
ι' : Type u_7
l : Line α ι
l' : Line α ι'
x : α
i : ι ⊕ ι'
⊢ (fun x i => ((l.prod l').idxFun i).getD x) x i =
    Sum.elim ((fun x i => (l.idxFun i).getD x) x) ((fun x i => (l'.idxFun i).getD x) x) i
tactic: funext i
state_before: case h
η : Type u_1
α✝ : Type u_2
ι✝ : Type u_3
κ : Type u_4
l✝ : Line α✝ ι✝
i✝ : ι✝
a x✝ : α✝
α : Type u_5
ι : Type u_6
ι' : Type u_7
l : Line α ι
l' : Line α ι'
x : α
i : ι ⊕ ι'
⊢ (fun x i => ((l.prod l').idxFun i).getD x) x i =
    Sum.elim ((fun x i => (l.idxFun i).getD x) x) ((fun x i => (l'.idxFun i).getD x) x) i
state_after: no goals
tactic: cases i <;> rfl
Theorem: wbtw_iff_left_eq_or_right_mem_image_Ici
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
⊢ Wbtw R x y z ↔ x = y ∨ z ∈ ⇑(lineMap x y) '' Set.Ici 1
state_after: case refine_1
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
h : Wbtw R x y z
⊢ x = y ∨ z ∈ ⇑(lineMap x y) '' Set.Ici 1

case refine_2
R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y z : P
h : x = y ∨ z ∈ ⇑(lineMap x y) '' Set.Ici 1
⊢ Wbtw R x y z
tactic: refine ⟨fun h => ?_, fun h => ?_⟩
Theorem: subset_of_eq_of_subset
File: Mathlib/Order/RelClasses.lean

Proof steps:
state_before: α : Type u
β : Type v
r : α → α → Prop
s : β → β → Prop
inst✝ : HasSubset α
a b c : α
hab : a = b
hbc : b ⊆ c
⊢ a ⊆ c
state_after: no goals
tactic: rwa [hab]
Theorem: Nat.cast_choose_two
File: Mathlib/Data/Nat/Choose/Cast.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : DivisionRing K
inst✝ : CharZero K
a : ℕ
⊢ ↑(a.choose 2) = ↑a * (↑a - 1) / 2
state_after: no goals
tactic: rw [← cast_descFactorial_two, descFactorial_eq_factorial_mul_choose, factorial_two, mul_comm,
    cast_mul, cast_two, eq_div_iff_mul_eq (two_ne_zero : (2 : K) ≠ 0)]
Theorem: Polynomial.card_nthRoots
File: Mathlib/Algebra/Polynomial/Roots.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n✝ : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
n : ℕ
a : R
⊢ Multiset.card (nthRoots n a) ≤ n
state_after: no goals
tactic: classical exact
  (if hn : n = 0 then
    if h : (X : R[X]) ^ n - C a = 0 then by
      simp [Nat.zero_le, nthRoots, roots, h, dif_pos rfl, empty_eq_zero, Multiset.card_zero]
    else
      WithBot.coe_le_coe.1
        (le_trans (card_roots h)
          (by
            rw [hn, pow_zero, ← C_1, ← RingHom.map_sub]
            exact degree_C_le))
  else by
    rw [← Nat.cast_le (α := WithBot ℕ)]
    rw [← degree_X_pow_sub_C (Nat.pos_of_ne_zero hn) a]
    exact card_roots (X_pow_sub_C_ne_zero (Nat.pos_of_ne_zero hn) a))
Theorem: slope_sub_smul
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

Proof steps:
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → E
a b : k
h : a ≠ b
⊢ slope (fun x => (x - a) • f x) a b = f b
state_after: no goals
tactic: simp [slope, inv_smul_smul₀ (sub_ne_zero.2 h.symm)]
Theorem: Int.csInf_of_not_bdd_below
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

Proof steps:
state_before: s : Set ℤ
h : ¬BddBelow s
⊢ ¬(s.Nonempty ∧ BddBelow s)
state_after: no goals
tactic: simp [h]
Theorem: List.formPerm_apply_getLast
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l : List α
x✝ x : α
xs : List α
⊢ (x :: xs).formPerm ((x :: xs).getLast ⋯) = x
state_after: no goals
tactic: induction' xs using List.reverseRecOn with xs y _ generalizing x <;> simp
Theorem: PresheafOfModules.Derivation.d_one
File: Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S : Cᵒᵖ ⥤ CommRingCat
F : C ⥤ D
S' R : Dᵒᵖ ⥤ CommRingCat
M N : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)
φ : S ⟶ F.op ⋙ R
φ' : S' ⟶ R
d : M.Derivation φ
X : Dᵒᵖ
⊢ d.d 1 = 0
state_after: no goals
tactic: simpa using d.d_mul (X := X) 1 1
Theorem: Set.two_lt_ncard
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
f : α → β
hs : autoParam s.Finite _auto✝
⊢ 2 < s.ncard ↔ ∃ a ∈ s, ∃ b ∈ s, ∃ c ∈ s, a ≠ b ∧ a ≠ c ∧ b ≠ c
state_after: no goals
tactic: simp only [two_lt_ncard_iff hs, exists_and_left, exists_prop]
Theorem: Pell.dvd_of_ysq_dvd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0 : n = 0
⊢ yn a1 n ∣ t
state_after: no goals
tactic: rwa [n0] at nt ⊢
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
⊢ yn a1 n ∣ t
state_after: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
⊢ yn a1 n ∣ t
tactic: let ⟨k, ke⟩ := nt
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
⊢ yn a1 n ∣ t
state_after: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
this : yn a1 n ∣ k * xn a1 n ^ (k - 1)
⊢ yn a1 n ∣ t
tactic: have : yn a1 n ∣ k * xn a1 n ^ (k - 1) :=
      Nat.dvd_of_mul_dvd_mul_right (strictMono_y a1 n0l) <|
        modEq_zero_iff_dvd.1 <| by
          have xm := (xy_modEq_yn a1 n k).right; rw [← ke] at xm
          exact (xm.of_dvd <| by simp [_root_.pow_succ]).symm.trans h.modEq_zero_nat
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
this : yn a1 n ∣ k * xn a1 n ^ (k - 1)
⊢ yn a1 n ∣ t
state_after: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
this : yn a1 n ∣ k * xn a1 n ^ (k - 1)
⊢ yn a1 n ∣ n * k
tactic: rw [ke]
state_before: a : ℕ
a1 : 1 < a
n t : ℕ
h : yn a1 n * yn a1 n ∣ yn a1 t
nt : n ∣ t
n0l : 0 < n
k : ℕ
ke : t = n * k
this : yn a1 n ∣ k * xn a1 n ^ (k - 1)
⊢ yn a1 n ∣ n * k
state_after: no goals
tactic: exact dvd_mul_of_dvd_right (((xy_coprime _ _).pow_left _).symm.dvd_of_dvd_mul_right this) _
Theorem: MeasureTheory.integrable_map_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → δ
g : δ → β
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f μ
⊢ Integrable g (Measure.map f μ) ↔ Integrable (g ∘ f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → δ
g : δ → β
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f μ
⊢ Memℒp g 1 (Measure.map f μ) ↔ Memℒp (g ∘ f) 1 μ
tactic: simp_rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → δ
g : δ → β
hg : AEStronglyMeasurable g (Measure.map f μ)
hf : AEMeasurable f μ
⊢ Memℒp g 1 (Measure.map f μ) ↔ Memℒp (g ∘ f) 1 μ
state_after: no goals
tactic: exact memℒp_map_measure_iff hg hf
Theorem: summable_int_iff_summable_nat_and_neg
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

Proof steps:
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
⊢ Multipliable f ↔ (Multipliable fun n => f ↑n) ∧ Multipliable fun n => f (-↑n)
state_after: case refine_1
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective Nat.cast

case refine_2
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective fun n => -↑n
tactic: refine ⟨fun p ↦ ⟨?_, ?_⟩, fun ⟨hf₁, hf₂⟩ ↦ Multipliable.of_nat_of_neg hf₁ hf₂⟩ <;>
  apply p.comp_injective
state_before: case refine_1
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective Nat.cast

case refine_2
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective fun n => -↑n
state_after: no goals
tactic: exacts [Nat.cast_injective, neg_injective.comp Nat.cast_injective]
Theorem: LinearMap.mulLeft_eq_zero_iff
File: Mathlib/Algebra/Algebra/Bilinear.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
⊢ mulLeft R a = 0 ↔ a = 0
state_after: case mp
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
h : mulLeft R a = 0
⊢ a = 0

case mpr
R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
a : A
h : a = 0
⊢ mulLeft R a = 0
tactic: constructor <;> intro h
Theorem: multiplicity.multiplicity_self
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : ¬IsUnit a
ha0 : a ≠ 0
⊢ multiplicity a a = 1
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : ¬IsUnit a
ha0 : a ≠ 0
⊢ multiplicity a a = ↑1
tactic: rw [← Nat.cast_one]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
a : α
ha : ¬IsUnit a
ha0 : a ≠ 0
⊢ multiplicity a a = ↑1
state_after: no goals
tactic: exact eq_coe_iff.2 ⟨by simp, fun ⟨b, hb⟩ => ha (isUnit_iff_dvd_one.2
            ⟨b, mul_left_cancel₀ ha0 <| by simpa [_root_.pow_succ, mul_assoc] using hb⟩)⟩
Theorem: List.Ico.filter_lt_of_le_bot
File: Mathlib/Data/List/Intervals.lean

Proof steps:
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ ¬decide (k < l) = true
state_after: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k
tactic: simp only [decide_eq_true_eq, not_lt]
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ l ≤ k
state_after: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ n ≤ k
tactic: apply le_trans hln
state_before: n m l : ℕ
hln : l ≤ n
k : ℕ
hk : k ∈ Ico n m
⊢ n ≤ k
state_after: no goals
tactic: exact (mem.1 hk).1
Theorem: List.findIdx_lt_length
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
⊢ findIdx p xs < xs.length ↔ ∃ x ∈ xs, p x = true
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
⊢ xs.length ≤ findIdx p xs ↔ ¬∃ x ∈ xs, p x = true
tactic: rw [← not_iff_not, not_lt]
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
⊢ xs.length ≤ findIdx p xs ↔ ¬∃ x ∈ xs, p x = true
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
this : findIdx p xs = xs.length ↔ findIdx p xs ≤ xs.length ∧ xs.length ≤ findIdx p xs
⊢ xs.length ≤ findIdx p xs ↔ ¬∃ x ∈ xs, p x = true
tactic: have := @le_antisymm_iff _ _ (xs.findIdx p) xs.length
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
this : findIdx p xs = xs.length ↔ findIdx p xs ≤ xs.length ∧ xs.length ≤ findIdx p xs
⊢ xs.length ≤ findIdx p xs ↔ ¬∃ x ∈ xs, p x = true
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
this : findIdx p xs = xs.length ↔ xs.length ≤ findIdx p xs
⊢ xs.length ≤ findIdx p xs ↔ ¬∃ x ∈ xs, p x = true
tactic: simp only [findIdx_le_length, true_and] at this
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
this : findIdx p xs = xs.length ↔ xs.length ≤ findIdx p xs
⊢ xs.length ≤ findIdx p xs ↔ ¬∃ x ∈ xs, p x = true
state_after: α : Type u
β : Type v
p : α → Bool
xs : List α
this : findIdx p xs = xs.length ↔ xs.length ≤ findIdx p xs
⊢ (∀ x ∈ xs, ¬p x = true) ↔ ∀ (x : α), ¬(x ∈ xs ∧ p x = true)
tactic: rw [← this, findIdx_eq_length, not_exists]
state_before: α : Type u
β : Type v
p : α → Bool
xs : List α
this : findIdx p xs = xs.length ↔ xs.length ≤ findIdx p xs
⊢ (∀ x ∈ xs, ¬p x = true) ↔ ∀ (x : α), ¬(x ∈ xs ∧ p x = true)
state_after: no goals
tactic: simp only [Bool.not_eq_true, not_and]