ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.not_summable_indicator_one_div_natCast
File: Mathlib/Analysis/PSeries.lean

Proof steps:
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
⊢ ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n)
tactic: have : NeZero m := ⟨hm⟩
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable ({n | ↑n = k}.indicator fun n => 1 / ↑n)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)
tactic: rw [← summable_nat_add_iff 1]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)
tactic: have h (n : ℕ) : {n : ℕ | (n : ZMod m) = k - 1}.indicator (fun n : ℕ ↦ (1 / (n + 1 :) : ℝ)) n =
      if (n : ZMod m) = k - 1 then (1 / (n + 1) : ℝ) else (0 : ℝ) := by
    simp only [indicator_apply, mem_setOf_eq, cast_add, cast_one]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k}.indicator (fun n => 1 / ↑n) (n + 1)
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n
tactic: simp_rw [indicator_apply, mem_setOf, cast_add, cast_one, ← eq_sub_iff_add_eq, ← h]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n
state_after: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => 1 / ↑(n + 1)
tactic: rw [summable_indicator_mod_iff (fun n₁ n₂ h ↦ by gcongr) (k - 1)]
state_before: m : ℕ
hm : m ≠ 0
k : ZMod m
this : NeZero m
h : ∀ (n : ℕ), {n | ↑n = k - 1}.indicator (fun n => 1 / ↑(n + 1)) n = if ↑n = k - 1 then 1 / (↑n + 1) else 0
⊢ ¬Summable fun n => 1 / ↑(n + 1)
state_after: no goals
tactic: exact mt (summable_nat_add_iff (f := fun n : ℕ ↦ 1 / (n : ℝ)) 1).mp not_summable_one_div_natCast
Theorem: norm_mk_lt'
File: Mathlib/Analysis/Normed/Group/Quotient.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
state_after: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : (mk' S) n = (mk' S) m
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
tactic: obtain ⟨n : M, hn : mk' S n = mk' S m, hn' : ‖n‖ < ‖mk' S m‖ + ε⟩ :=
    norm_mk_lt (QuotientAddGroup.mk' S m) hε
state_before: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : (mk' S) n = (mk' S) m
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
state_after: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
tactic: erw [eq_comm, QuotientAddGroup.eq] at hn
state_before: case intro.intro
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ∃ s ∈ S, ‖m + s‖ < ‖(mk' S) m‖ + ε
state_after: case right
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ‖m + (-m + n)‖ < ‖(mk' S) m‖ + ε
tactic: use -m + n, hn
state_before: case right
M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
ε : ℝ
hε : 0 < ε
n : M
hn : -m + n ∈ S
hn' : ‖n‖ < ‖(mk' S) m‖ + ε
⊢ ‖m + (-m + n)‖ < ‖(mk' S) m‖ + ε
state_after: no goals
tactic: rwa [add_neg_cancel_left]
Theorem: Setoid.eq_top_iff
File: Mathlib/Data/Setoid/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Setoid α
⊢ s = ⊤ ↔ ∀ (x y : α), s.Rel x y
state_after: α : Type u_1
β : Type u_2
s : Setoid α
⊢ (∀ {x y : α}, ⊤ x y → s.Rel x y) ↔ ∀ (x y : α), s.Rel x y
tactic: rw [_root_.eq_top_iff, Setoid.le_def, Setoid.top_def]
state_before: α : Type u_1
β : Type u_2
s : Setoid α
⊢ (∀ {x y : α}, ⊤ x y → s.Rel x y) ↔ ∀ (x y : α), s.Rel x y
state_after: no goals
tactic: simp only [Pi.top_apply, Prop.top_eq_true, forall_true_left]
Theorem: Cardinal.exists_nat_eq_of_le_nat
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
c : Cardinal.{u_1}
n : ℕ
h : c ≤ ↑n
⊢ ∃ m ≤ n, c = ↑m
state_after: case intro
α β : Type u
n c : ℕ
h : ↑c ≤ ↑n
⊢ ∃ m ≤ n, ↑c = ↑m
tactic: lift c to ℕ using h.trans_lt (nat_lt_aleph0 _)
state_before: case intro
α β : Type u
n c : ℕ
h : ↑c ≤ ↑n
⊢ ∃ m ≤ n, ↑c = ↑m
state_after: no goals
tactic: exact ⟨c, mod_cast h, rfl⟩
Theorem: AlgebraicGeometry.RingedSpace.zeroLocus_singleton
File: Mathlib/Geometry/RingedSpace/Basic.lean

Proof steps:
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj (op U))
⊢ X.zeroLocus {f} = (X.basicOpen f).carrierᶜ
state_after: no goals
tactic: simp [zeroLocus]
Theorem: AddMonoidHom.coprod_unique
File: Mathlib/Algebra/Group/Prod.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
G : Type u_3
H : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommMonoid P
f✝ : M →* P
g : N →* P
f : M × N →* P
x : M × N
⊢ ((f.comp (inl M N)).coprod (f.comp (inr M N))) x = f x
state_after: no goals
tactic: simp [coprod_apply, inl_apply, inr_apply, ← map_mul]
Theorem: Submonoid.fromLeftInv_eq_inv
File: Mathlib/GroupTheory/Submonoid/Inverses.lean

Proof steps:
state_before: M : Type u_1
inst✝ : Group M
S : Submonoid M
x : ↥S.leftInv
⊢ ↑(S.fromLeftInv x) = (↑x)⁻¹
state_after: no goals
tactic: rw [← mul_right_inj (x : M), mul_right_inv, mul_fromLeftInv]
Theorem: Real.dist_0_eq_abs
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x : ℝ
⊢ dist x 0 = |x|
state_after: no goals
tactic: simp [Real.dist_eq]
Theorem: List.permutations'Aux_get_zero
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
⊢ 0 < (permutations'Aux x s).length
state_after: no goals
tactic: simp
Theorem: PNat.le_sub_one_of_lt
File: Mathlib/Data/PNat/Basic.lean

Proof steps:
state_before: a b : ℕ+
hab : a < b
⊢ a ≤ b - 1
state_after: a b : ℕ+
hab : a < b
⊢ ↑a ≤ if 1 < b then ↑b - ↑1 else 1
tactic: rw [← coe_le_coe, sub_coe]
state_before: a b : ℕ+
hab : a < b
⊢ ↑a ≤ if 1 < b then ↑b - ↑1 else 1
state_after: case pos
a b : ℕ+
hab : a < b
h : 1 < b
⊢ ↑a ≤ ↑b - ↑1

case neg
a b : ℕ+
hab : a < b
h : ¬1 < b
⊢ ↑a ≤ 1
tactic: split_ifs with h
Theorem: AddMonCat.uliftFunctor_obj
File: Mathlib/Algebra/Category/MonCat/Basic.lean

Proof steps:
state_before: X : MonCat
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (𝟙 X) =
    𝟙
      ({ obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.obj
        X)
state_after: no goals
tactic: rfl
state_before: X Y Z : MonCat
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => of (ULift.{v, u} ↑X),
          map := fun {X Y} f =>
            ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
      (f ≫ g) =
    { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        f ≫
      { obj := fun X => of (ULift.{v, u} ↑X),
            map := fun {X Y} f =>
              ofHom (MulEquiv.ulift.symm.toMonoidHom.comp (MonoidHom.comp f MulEquiv.ulift.toMonoidHom)) }.map
        g
state_after: no goals
tactic: rfl
Theorem: AkraBazziRecurrence.deriv_smoothingFn
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
x : ℝ
hx : 1 < x
⊢ deriv ε x = -x⁻¹ / log x ^ 2
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv ε x = -x⁻¹ / log x ^ 2
tactic: have : log x ≠ 0 := Real.log_ne_zero_of_pos_of_ne_one (by positivity) (ne_of_gt hx)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv ε x = -x⁻¹ / log x ^ 2
state_after: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv (fun z => 1 / log z) x = -x⁻¹ / log x ^ 2
tactic: show deriv (fun z => 1 / log z) x = -x⁻¹ / (log x ^ 2)
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : Nonempty α
T : ℕ → ℝ
g : ℝ → ℝ
a b : α → ℝ
r : α → ℕ → ℕ
R : AkraBazziRecurrence T g a b r
x : ℝ
hx : 1 < x
this : log x ≠ 0
⊢ deriv (fun z => 1 / log z) x = -x⁻¹ / log x ^ 2
state_after: no goals
tactic: rw [deriv_div] <;> aesop
Theorem: Polynomial.exists_unique_nilpotent_sub_and_aeval_eq_zero
File: Mathlib/Dynamics/Newton.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
x : S
h : IsNilpotent ((aeval x) P)
h' : IsUnit ((aeval x) (derivative P))
⊢ ∃! r, IsNilpotent (x - r) ∧ (aeval r) P = 0
state_after: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
x : S
h : IsNilpotent ((aeval x) P)
h' : IsUnit ((aeval x) (derivative P))
⊢ ∃! r, IsNilpotent (r - x) ∧ (aeval r) P = 0
tactic: simp_rw [(neg_sub _ x).symm, isNilpotent_neg_iff]
state_before: R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
x : S
h : IsNilpotent ((aeval x) P)
h' : IsUnit ((aeval x) (derivative P))
⊢ ∃! r, IsNilpotent (r - x) ∧ (aeval r) P = 0
state_after: case refine_1
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
x : S
h : IsNilpotent ((aeval x) P)
h' : IsUnit ((aeval x) (derivative P))
⊢ ∃ x_1, IsNilpotent (x_1 - x) ∧ (aeval x_1) P = 0

case refine_2
R : Type u_1
S : Type u_2
inst✝² : CommRing R
inst✝¹ : CommRing S
inst✝ : Algebra R S
P : R[X]
x : S
h : IsNilpotent ((aeval x) P)
h' : IsUnit ((aeval x) (derivative P))
r₁ r₂ : S
x✝¹ : IsNilpotent (r₁ - x) ∧ (aeval r₁) P = 0
x✝ : IsNilpotent (r₂ - x) ∧ (aeval r₂) P = 0
hr₁ : IsNilpotent (r₁ - x)
hr₁' : (aeval r₁) P = 0
hr₂ : IsNilpotent (r₂ - x)
hr₂' : (aeval r₂) P = 0
⊢ r₁ = r₂
tactic: refine exists_unique_of_exists_of_unique ?_ fun r₁ r₂ ⟨hr₁, hr₁'⟩ ⟨hr₂, hr₂'⟩ ↦ ?_
Theorem: Ordinal.nfp_lt_ord
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
f : Ordinal.{u_2} → Ordinal.{u_2}
c : Ordinal.{u_2}
hc : ℵ₀ < c.cof
hf : ∀ i < c, f i < c
a : Ordinal.{u_2}
⊢ Cardinal.lift.{u_2, 0} #Unit < c.cof
state_after: no goals
tactic: simpa using Cardinal.one_lt_aleph0.trans hc
Theorem: List.getElem?_iterate
File: Mathlib/Data/List/Iterate.lean

Proof steps:
state_before: α : Type u_1
f : α → α
a : α
n : ℕ
x✝ : 0 < n + 1
⊢ (iterate f a (n + 1))[0]? = some (f^[0] a)
state_after: no goals
tactic: simp
state_before: α : Type u_1
f : α → α
a : α
n i : ℕ
h : i + 1 < n + 1
⊢ (iterate f a (n + 1))[i + 1]? = some (f^[i + 1] a)
state_after: no goals
tactic: simp [getElem?_iterate f (f a) n i (by simpa using h)]
Theorem: PadicInt.prime_p
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ Prime ↑p
state_after: p : ℕ
hp : Fact (Nat.Prime p)
⊢ (maximalIdeal ℤ_[p]).IsPrime

p : ℕ
hp : Fact (Nat.Prime p)
⊢ ↑p ≠ 0
tactic: rw [← Ideal.span_singleton_prime, ← maximalIdeal_eq_span_p]
Theorem: tendsto_neg_nhdsWithin_Ioi
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝⁶ : TopologicalSpace G
inst✝⁵ : Group G
inst✝⁴ : TopologicalGroup G
inst✝³ : TopologicalSpace α
f : α → G
s : Set α
x : α
inst✝² : TopologicalSpace H
inst✝¹ : OrderedCommGroup H
inst✝ : ContinuousInv H
a : H
⊢ Tendsto (fun a => a⁻¹) (𝓟 (Ioi a)) (𝓟 (Iio a⁻¹))
state_after: no goals
tactic: simp [tendsto_principal_principal]
Theorem: MeasureTheory.ite_ae_eq_of_measure_compl_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ sᶜ = 0
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] f
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] f
tactic: rw [← mem_ae_iff] at hs_zero
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] f
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ ∀ a ∈ s, (if a ∈ s then f a else g a) = f a
tactic: filter_upwards [hs_zero]
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ ∀ a ∈ s, (if a ∈ s then f a else g a) = f a
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ (if a✝¹ ∈ s then f a✝¹ else g a✝¹) = f a✝¹
tactic: intros
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ (if a✝¹ ∈ s then f a✝¹ else g a✝¹) = f a✝¹
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ f a✝¹ = f a✝¹
tactic: split_ifs
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ f a✝¹ = f a✝¹
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.Measure.haarScalarFactor_eq_integral_div
File: Mathlib/MeasureTheory/Measure/Haar/Unique.lean

Proof steps:
state_before: G : Type u_1
inst✝⁷ : TopologicalSpace G
inst✝⁶ : Group G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
f : G → ℝ
hf : Continuous f
h'f : HasCompactSupport f
int_nonzero : ∫ (x : G), f x ∂μ ≠ 0
⊢ ↑(μ'.haarScalarFactor μ) = (∫ (x : G), f x ∂μ') / ∫ (x : G), f x ∂μ
state_after: G : Type u_1
inst✝⁷ : TopologicalSpace G
inst✝⁶ : Group G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
f : G → ℝ
hf : Continuous f
h'f : HasCompactSupport f
int_nonzero : ∫ (x : G), f x ∂μ ≠ 0
this : ∫ (x : G), f x ∂μ' = ∫ (x : G), f x ∂μ'.haarScalarFactor μ • μ
⊢ ↑(μ'.haarScalarFactor μ) = (∫ (x : G), f x ∂μ') / ∫ (x : G), f x ∂μ
tactic: have := integral_isMulLeftInvariant_eq_smul_of_hasCompactSupport μ' μ hf h'f
state_before: G : Type u_1
inst✝⁷ : TopologicalSpace G
inst✝⁶ : Group G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
f : G → ℝ
hf : Continuous f
h'f : HasCompactSupport f
int_nonzero : ∫ (x : G), f x ∂μ ≠ 0
this : ∫ (x : G), f x ∂μ' = ∫ (x : G), f x ∂μ'.haarScalarFactor μ • μ
⊢ ↑(μ'.haarScalarFactor μ) = (∫ (x : G), f x ∂μ') / ∫ (x : G), f x ∂μ
state_after: G : Type u_1
inst✝⁷ : TopologicalSpace G
inst✝⁶ : Group G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
f : G → ℝ
hf : Continuous f
h'f : HasCompactSupport f
int_nonzero : ∫ (x : G), f x ∂μ ≠ 0
this : ∫ (x : G), f x ∂μ' = μ'.haarScalarFactor μ • ∫ (x : G), f x ∂μ
⊢ ↑(μ'.haarScalarFactor μ) = (∫ (x : G), f x ∂μ') / ∫ (x : G), f x ∂μ
tactic: rw [integral_smul_nnreal_measure] at this
state_before: G : Type u_1
inst✝⁷ : TopologicalSpace G
inst✝⁶ : Group G
inst✝⁵ : TopologicalGroup G
inst✝⁴ : MeasurableSpace G
inst✝³ : BorelSpace G
μ' μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : IsFiniteMeasureOnCompacts μ'
inst✝ : μ'.IsMulLeftInvariant
f : G → ℝ
hf : Continuous f
h'f : HasCompactSupport f
int_nonzero : ∫ (x : G), f x ∂μ ≠ 0
this : ∫ (x : G), f x ∂μ' = μ'.haarScalarFactor μ • ∫ (x : G), f x ∂μ
⊢ ↑(μ'.haarScalarFactor μ) = (∫ (x : G), f x ∂μ') / ∫ (x : G), f x ∂μ
state_after: no goals
tactic: exact EuclideanDomain.eq_div_of_mul_eq_left int_nonzero this.symm
Theorem: Nat.one_add_le_iff
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ 1 + m ≤ n ↔ m < n
state_after: no goals
tactic: simp only [Nat.add_comm, add_one_le_iff]
Theorem: Module.piEquiv_apply_apply
File: Mathlib/LinearAlgebra/StdBasis.lean

Proof steps:
state_before: ι✝ : Type u_1
R✝ : Type u_2
M✝ : Type u_3
N : Type u_4
inst✝⁹ : Finite ι✝
inst✝⁸ : CommSemiring R✝
inst✝⁷ : AddCommMonoid M✝
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R✝ M✝
inst✝⁴ : Module R✝ N
ι : Type u_5
R : Type u_6
M : Type u_7
inst✝³ : Fintype ι
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
v : ι → M
w : ι → R
⊢ ((piEquiv ι R M) v) w = ∑ i : ι, w i • v i
state_after: ι✝ : Type u_1
R✝ : Type u_2
M✝ : Type u_3
N : Type u_4
inst✝⁹ : Finite ι✝
inst✝⁸ : CommSemiring R✝
inst✝⁷ : AddCommMonoid M✝
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R✝ M✝
inst✝⁴ : Module R✝ N
ι : Type u_5
R : Type u_6
M : Type u_7
inst✝³ : Fintype ι
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
v : ι → M
w : ι → R
⊢ ∑ x : ι, ((Pi.basisFun R ι).repr w) x • v x = ∑ i : ι, w i • v i
tactic: simp only [piEquiv, Basis.constr_apply_fintype, Basis.equivFun_apply]
state_before: ι✝ : Type u_1
R✝ : Type u_2
M✝ : Type u_3
N : Type u_4
inst✝⁹ : Finite ι✝
inst✝⁸ : CommSemiring R✝
inst✝⁷ : AddCommMonoid M✝
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R✝ M✝
inst✝⁴ : Module R✝ N
ι : Type u_5
R : Type u_6
M : Type u_7
inst✝³ : Fintype ι
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
v : ι → M
w : ι → R
⊢ ∑ x : ι, ((Pi.basisFun R ι).repr w) x • v x = ∑ i : ι, w i • v i
state_after: no goals
tactic: congr
Theorem: xor_iff_not_iff'
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: a b : Prop
⊢ Xor' a b ↔ (¬a ↔ b)
state_after: no goals
tactic: simp only [← @xor_not_left _ b, not_not]
Theorem: CochainComplex.HomComplex.Cochain.shiftAddHom_apply
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n✝ : ℤ
γ γ₁ γ₂ : Cochain K L n✝
n a : ℤ
⊢ ∀ (a_1 b : Cochain K L n), (fun γ => γ.shift a) (a_1 + b) = (fun γ => γ.shift a) a_1 + (fun γ => γ.shift a) b
state_after: no goals
tactic: simp
Theorem: ContractingWith.dist_inequality
File: Mathlib/Topology/MetricSpace/Contracting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MetricSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
this : dist x y ≤ dist x (f x) + dist y (f y) + ↑K * dist x y
⊢ dist x y ≤ (dist x (f x) + dist y (f y)) / (1 - ↑K)
state_after: no goals
tactic: rwa [le_div_iff hf.one_sub_K_pos, mul_comm, _root_.sub_mul, one_mul, sub_le_iff_le_add]
Theorem: Finset.range_orderEmbOfFin
File: Mathlib/Data/Finset/Sort.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
k : ℕ
h : s.card = k
⊢ Set.range ⇑(s.orderEmbOfFin h) = ↑s
state_after: no goals
tactic: simp only [orderEmbOfFin, Set.range_comp ((↑) : _ → α) (s.orderIsoOfFin h),
  RelEmbedding.coe_trans, Set.image_univ, Finset.orderEmbOfFin, RelIso.range_eq,
    OrderEmbedding.subtype_apply, OrderIso.coe_toOrderEmbedding, eq_self_iff_true,
    Subtype.range_coe_subtype, Finset.setOf_mem, Finset.coe_inj]
Theorem: Submodule.span_smul_of_span_eq_top
File: Mathlib/Algebra/Algebra/Tower.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
s : Set S
hs : span R s = ⊤
t : Set A
p : A
hp : p ∈ restrictScalars R (span S t)
s0 : S
y : A
hy : y ∈ t
⊢ s0 • y ∈ span R (s • t)
state_after: case refine_1
R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
s : Set S
hs : span R s = ⊤
t : Set A
p : A
hp : p ∈ restrictScalars R (span S t)
s0 : S
y : A
hy : y ∈ t
⊢ 0 • y ∈ span R (s • t)

case refine_2
R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
s : Set S
hs : span R s = ⊤
t : Set A
p : A
hp : p ∈ restrictScalars R (span S t)
s0 : S
y : A
hy : y ∈ t
⊢ ∀ (x y_1 : S), x • y ∈ span R (s • t) → y_1 • y ∈ span R (s • t) → (x + y_1) • y ∈ span R (s • t)

case refine_3
R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid A
inst✝³ : Module R S
inst✝² : Module S A
inst✝¹ : Module R A
inst✝ : IsScalarTower R S A
s : Set S
hs : span R s = ⊤
t : Set A
p : A
hp : p ∈ restrictScalars R (span S t)
s0 : S
y : A
hy : y ∈ t
⊢ ∀ (a : R) (x : S), x • y ∈ span R (s • t) → (a • x) • y ∈ span R (s • t)
tactic: refine span_induction (hs ▸ mem_top : s0 ∈ span R s)
        (fun x hx ↦ subset_span ⟨x, hx, y, hy, rfl⟩) ?_ ?_ ?_