ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: norm_indicator_le_of_subset
File: Mathlib/Analysis/NormedSpace/IndicatorFunction.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
inst✝ : SeminormedAddCommGroup E
s t : Set α
f✝ : α → E
a✝ : α
h : s ⊆ t
f : α → E
a : α
⊢ ‖s.indicator f a‖ ≤ ‖t.indicator f a‖
state_after: α : Type u_1
E : Type u_2
inst✝ : SeminormedAddCommGroup E
s t : Set α
f✝ : α → E
a✝ : α
h : s ⊆ t
f : α → E
a : α
⊢ s.indicator (fun a => ‖f a‖) a ≤ t.indicator (fun a => ‖f a‖) a
tactic: simp only [norm_indicator_eq_indicator_norm]
state_before: α : Type u_1
E : Type u_2
inst✝ : SeminormedAddCommGroup E
s t : Set α
f✝ : α → E
a✝ : α
h : s ⊆ t
f : α → E
a : α
⊢ s.indicator (fun a => ‖f a‖) a ≤ t.indicator (fun a => ‖f a‖) a
state_after: no goals
tactic: exact indicator_le_indicator_of_subset ‹_› (fun _ => norm_nonneg _) _
Theorem: Set.isWF_univ_iff
File: Mathlib/Order/WellFoundedSet.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
π : ι → Type u_5
inst✝ : LT α
s t : Set α
⊢ univ.IsWF ↔ WellFounded fun x x_1 => x < x_1
state_after: no goals
tactic: simp [IsWF, wellFoundedOn_iff]
Theorem: analyticWithinAt_iff_exists_analyticAt
File: Mathlib/Analysis/Analytic/Within.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : CompleteSpace F
f : E → F
s : Set E
x : E
⊢ AnalyticWithinAt 𝕜 f s x ↔ ContinuousWithinAt f s x ∧ ∃ g, f =ᶠ[𝓝[s] x] g ∧ AnalyticAt 𝕜 g x
state_after: α : Type u_1
𝕜 : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : CompleteSpace F
f : E → F
s : Set E
x : E
⊢ (∃ p, ContinuousWithinAt f s x ∧ ∃ g, f =ᶠ[𝓝[s] x] g ∧ HasFPowerSeriesAt g p x) ↔
    ContinuousWithinAt f s x ∧ ∃ g, f =ᶠ[𝓝[s] x] g ∧ ∃ p, HasFPowerSeriesAt g p x
tactic: simp only [AnalyticWithinAt, AnalyticAt, hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : NormedAddCommGroup G
inst✝³ : NormedSpace 𝕜 G
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : CompleteSpace F
f : E → F
s : Set E
x : E
⊢ (∃ p, ContinuousWithinAt f s x ∧ ∃ g, f =ᶠ[𝓝[s] x] g ∧ HasFPowerSeriesAt g p x) ↔
    ContinuousWithinAt f s x ∧ ∃ g, f =ᶠ[𝓝[s] x] g ∧ ∃ p, HasFPowerSeriesAt g p x
state_after: no goals
tactic: tauto
Theorem: HasDerivAt.lhopital_zero_nhds
File: Mathlib/Analysis/Calculus/LHopital.lean

Proof steps:
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[≠] a) l
state_after: no goals
tactic: apply @lhopital_zero_nhds' _ _ _ f' _ g' <;>
    (first | apply eventually_nhdsWithin_of_eventually_nhds |
      apply tendsto_nhdsWithin_of_tendsto_nhds) <;> assumption
Theorem: Rat.intCast_mul
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a b : Int
⊢ ↑(a * b) = ↑a * ↑b
state_after: a b : Int
⊢ ↑(a * b) = normalize ((↑a).num * (↑b).num) ((↑a).den * (↑b).den) ⋯
tactic: rw [mul_def]
state_before: a b : Int
⊢ ↑(a * b) = normalize ((↑a).num * (↑b).num) ((↑a).den * (↑b).den) ⋯
state_after: no goals
tactic: simp [normalize_eq]
Theorem: String.utf8GetAux_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: cs cs' : List Char
i p : Nat
hp : i + utf8Len cs = p
⊢ utf8GetAux (cs ++ cs') { byteIdx := i } { byteIdx := p } = cs'.headD default
state_after: no goals
tactic: match cs, cs' with
  | [], [] => rfl
  | [], c::cs' => simp [← hp, utf8GetAux]
  | c::cs, cs' =>
    simp only [utf8GetAux, List.append_eq, Char.reduceDefault, ↓Char.isValue]
    rw [if_neg]
    case hnc => simp only [← hp, utf8Len_cons, Pos.ext_iff]; exact ne_self_add_add_csize
    refine utf8GetAux_of_valid cs cs' ?_
    simpa [Nat.add_assoc, Nat.add_comm] using hp
Theorem: neg_div_neg_eq
File: Mathlib/Algebra/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -a / -b = a / b
state_after: no goals
tactic: rw [div_neg_eq_neg_div, neg_div, neg_neg]
Theorem: isGreatest_univ_iff
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
⊢ IsGreatest univ a ↔ IsTop a
state_after: no goals
tactic: simp [IsGreatest, mem_upperBounds, IsTop]
Theorem: Real.arccos_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ arccos x = 0 ↔ 1 ≤ x
state_after: no goals
tactic: simp [arccos, sub_eq_zero]
Theorem: invOf_mul_eq_iff_eq_mul_left
File: Mathlib/Algebra/Group/Invertible/Defs.lean

Proof steps:
state_before: α : Type u
inst✝¹ : Monoid α
a b c : α
inst✝ : Invertible c
⊢ ⅟c * a = b ↔ a = c * b
state_after: no goals
tactic: rw [← mul_left_inj_of_invertible (c := c), mul_invOf_self_assoc]
Theorem: eq_sub_iff_add_eq'
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : CommGroup G
a b c d : G
⊢ a = b / c ↔ c * a = b
state_after: no goals
tactic: rw [eq_div_iff_mul_eq', mul_comm]
Theorem: MeasureTheory.hasFiniteIntegral_iff_edist
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 : α → β
⊢ HasFiniteIntegral f μ ↔ ∫⁻ (a : α), edist (f a) 0 ∂μ < ⊤
state_after: no goals
tactic: simp only [hasFiniteIntegral_iff_norm, edist_dist, dist_zero_right]
Theorem: Function.Commute.iterate_pos_eq_iff_map_eq
File: Mathlib/Order/Iterate.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
⊢ f^[n] x = g^[n] x ↔ f x = g x
state_after: no goals
tactic: simp only [le_antisymm_iff, h.iterate_pos_le_iff_map_le hf hg hn,
    h.symm.iterate_pos_le_iff_map_le' hg hf hn]
Theorem: Function.mulSupport_eq_iff
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M
s : Set α
⊢ mulSupport f = s ↔ (∀ x ∈ s, f x ≠ 1) ∧ ∀ x ∉ s, f x = 1
state_after: no goals
tactic: simp (config := { contextual := true }) only [Set.ext_iff, mem_mulSupport, ne_eq, iff_def,
    not_imp_comm, and_comm, forall_and]
Theorem: Finset.Ioo_filter_lt
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
⊢ filter (fun x => x < c) (Ioo a b) = Ioo a (min b c)
state_after: case a
ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝¹ b✝ a b c a✝ : α
⊢ a✝ ∈ filter (fun x => x < c) (Ioo a b) ↔ a✝ ∈ Ioo a (min b c)
tactic: ext
state_before: case a
ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝¹ b✝ a b c a✝ : α
⊢ a✝ ∈ filter (fun x => x < c) (Ioo a b) ↔ a✝ ∈ Ioo a (min b c)
state_after: no goals
tactic: simp [and_assoc]
Theorem: MeasureTheory.IsStoppingTime.measurableSet_ge_of_countable_range
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝¹ : PartialOrder ι✝
τ✝ : Ω → ι✝
f✝ : Filtration ι✝ m
ι : Type u_4
inst✝ : LinearOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
⊢ MeasurableSet {ω | i ≤ τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝¹ : PartialOrder ι✝
τ✝ : Ω → ι✝
f✝ : Filtration ι✝ m
ι : Type u_4
inst✝ : LinearOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | i ≤ τ ω}
tactic: have : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ := by
    ext1 ω; simp only [Set.mem_setOf_eq, Set.mem_compl_iff, not_lt]
state_before: Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝¹ : PartialOrder ι✝
τ✝ : Ω → ι✝
f✝ : Filtration ι✝ m
ι : Type u_4
inst✝ : LinearOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | i ≤ τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝¹ : PartialOrder ι✝
τ✝ : Ω → ι✝
f✝ : Filtration ι✝ m
ι : Type u_4
inst✝ : LinearOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | τ ω < i}ᶜ
tactic: rw [this]
state_before: Ω : Type u_1
β : Type u_2
ι✝ : Type u_3
m : MeasurableSpace Ω
inst✝¹ : PartialOrder ι✝
τ✝ : Ω → ι✝
f✝ : Filtration ι✝ m
ι : Type u_4
inst✝ : LinearOrder ι
τ : Ω → ι
f : Filtration ι m
hτ : IsStoppingTime f τ
h_countable : (Set.range τ).Countable
i : ι
this : {ω | i ≤ τ ω} = {ω | τ ω < i}ᶜ
⊢ MeasurableSet {ω | τ ω < i}ᶜ
state_after: no goals
tactic: exact (hτ.measurableSet_lt_of_countable_range h_countable i).compl
Theorem: NormedAddGroupHom.incl_apply
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
W : Type u_2
V₁ : Type u_3
V₂ : Type u_4
V₃ : Type u_5
inst✝⁴ : SeminormedAddCommGroup V
inst✝³ : SeminormedAddCommGroup W
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
s : AddSubgroup V
v : ↥s
⊢ ‖↑v‖ ≤ 1 * ‖v‖
state_after: no goals
tactic: rw [one_mul, AddSubgroup.coe_norm]
Theorem: Subgroup.map_symm_eq_iff_map_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
H✝ K : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H : Subgroup N
e : G ≃* N
⊢ map (↑e.symm) H = K ↔ map (↑e) K = H
state_after: case mp
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✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H : Subgroup N
e : G ≃* N
⊢ map (↑e) (map (↑e.symm) H) = H

case mpr
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
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
e : G ≃* N
⊢ map (↑e.symm) (map (↑e) K) = K
tactic: constructor <;> rintro rfl
Theorem: ENNReal.tendsto_const_mul_rpow_nhds_zero_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: c : ℝ≥0∞
hc : c ≠ ⊤
y : ℝ
hy : 0 < y
⊢ Tendsto (fun x => c * x ^ y) (𝓝 0) (𝓝 0)
state_after: case h.e'_5.h.e'_3
c : ℝ≥0∞
hc : c ≠ ⊤
y : ℝ
hy : 0 < y
⊢ 0 = c * 0 ^ y

case convert_3
c : ℝ≥0∞
hc : c ≠ ⊤
y : ℝ
hy : 0 < y
⊢ 0 ^ y ≠ 0 ∨ c ≠ ⊤
tactic: convert ENNReal.Tendsto.const_mul (ENNReal.continuous_rpow_const.tendsto 0) _
Theorem: Composition.ne_ones_iff
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c✝ c : Composition n
⊢ c ≠ ones n ↔ ∃ i ∈ c.blocks, 1 < i
state_after: n : ℕ
c✝ c : Composition n
⊢ (¬∀ i ∈ c.blocks, i = 1) ↔ ∃ i ∈ c.blocks, 1 < i
tactic: refine (not_congr eq_ones_iff).trans ?_
state_before: n : ℕ
c✝ c : Composition n
⊢ (¬∀ i ∈ c.blocks, i = 1) ↔ ∃ i ∈ c.blocks, 1 < i
state_after: n : ℕ
c✝ c : Composition n
this : ∀ j ∈ c.blocks, j = 1 ↔ j ≤ 1
⊢ (¬∀ i ∈ c.blocks, i = 1) ↔ ∃ i ∈ c.blocks, 1 < i
tactic: have : ∀ j ∈ c.blocks, j = 1 ↔ j ≤ 1 := fun j hj => by simp [le_antisymm_iff, c.one_le_blocks hj]
state_before: n : ℕ
c✝ c : Composition n
this : ∀ j ∈ c.blocks, j = 1 ↔ j ≤ 1
⊢ (¬∀ i ∈ c.blocks, i = 1) ↔ ∃ i ∈ c.blocks, 1 < i
state_after: no goals
tactic: simp (config := { contextual := true }) [this]
Theorem: FermatLastTheoremForThreeGen.ex_cube_add_cube_eq_and_isCoprime_and_not_dvd_and_dvd
File: Mathlib/NumberTheory/FLT/Three.lean

Proof steps:
state_before: K : Type u_1
inst✝³ : Field K
inst✝² : NumberField K
inst✝¹ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
S' : Solution' hζ
inst✝ : DecidableRel fun a b => a ∣ b
⊢ ∃ a' b', a' ^ 3 + b' ^ 3 = ↑S'.u * S'.c ^ 3 ∧ IsCoprime a' b' ∧ ¬λ ∣ a' ∧ ¬λ ∣ b' ∧ λ ^ 2 ∣ a' + b'
state_after: case inl
K : Type u_1
inst✝³ : Field K
inst✝² : NumberField K
inst✝¹ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
S' : Solution' hζ
inst✝ : DecidableRel fun a b => a ∣ b
h : λ ^ 2 ∣ S'.a + S'.b
⊢ ∃ a' b', a' ^ 3 + b' ^ 3 = ↑S'.u * S'.c ^ 3 ∧ IsCoprime a' b' ∧ ¬λ ∣ a' ∧ ¬λ ∣ b' ∧ λ ^ 2 ∣ a' + b'

case inr.inl
K : Type u_1
inst✝³ : Field K
inst✝² : NumberField K
inst✝¹ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
S' : Solution' hζ
inst✝ : DecidableRel fun a b => a ∣ b
h : λ ^ 2 ∣ S'.a + ↑η * S'.b
⊢ ∃ a' b', a' ^ 3 + b' ^ 3 = ↑S'.u * S'.c ^ 3 ∧ IsCoprime a' b' ∧ ¬λ ∣ a' ∧ ¬λ ∣ b' ∧ λ ^ 2 ∣ a' + b'

case inr.inr
K : Type u_1
inst✝³ : Field K
inst✝² : NumberField K
inst✝¹ : IsCyclotomicExtension {3} ℚ K
ζ : K
hζ : IsPrimitiveRoot ζ ↑3
S : Solution hζ
S' : Solution' hζ
inst✝ : DecidableRel fun a b => a ∣ b
h : λ ^ 2 ∣ S'.a + ↑η ^ 2 * S'.b
⊢ ∃ a' b', a' ^ 3 + b' ^ 3 = ↑S'.u * S'.c ^ 3 ∧ IsCoprime a' b' ∧ ¬λ ∣ a' ∧ ¬λ ∣ b' ∧ λ ^ 2 ∣ a' + b'
tactic: rcases lambda_sq_dvd_or_dvd_or_dvd S' with h | h | h
Theorem: MeasureTheory.IntegrableOn.smul_continuousOn
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
𝕜 : Type u_6
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : T2Space X
inst✝ : SecondCountableTopologyEither X E
f : X → 𝕜
hf : IntegrableOn f K μ
g : X → E
hg : ContinuousOn g K
hK : IsCompact K
⊢ IntegrableOn (fun x => f x • g x) K μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
𝕜 : Type u_6
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : T2Space X
inst✝ : SecondCountableTopologyEither X E
f : X → 𝕜
hf : IntegrableOn f K μ
g : X → E
hg : ContinuousOn g K
hK : IsCompact K
⊢ Integrable (fun a => ‖f a • g a‖) (μ.restrict K)

X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedAddCommGroup F
f✝ g✝ : X → E
μ : Measure X
s : Set X
inst✝⁴ : OpensMeasurableSpace X
A K : Set X
𝕜 : Type u_6
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : T2Space X
inst✝ : SecondCountableTopologyEither X E
f : X → 𝕜
hf : IntegrableOn f K μ
g : X → E
hg : ContinuousOn g K
hK : IsCompact K
⊢ AEStronglyMeasurable (fun x => f x • g x) (μ.restrict K)
tactic: rw [IntegrableOn, ← integrable_norm_iff]
Theorem: Mathlib.Meta.NormNum.jacobiSymNat.mod_left
File: Mathlib/Tactic/NormNum/LegendreSymbol.lean

Proof steps:
state_before: a b ab : ℕ
r : ℤ
hab : a % b = ab
hr : jacobiSymNat ab b = r
⊢ jacobiSymNat a b = r
state_after: a b ab : ℕ
r : ℤ
hab : a % b = ab
hr : jacobiSymNat ab b = r
⊢ jacobiSym (↑a % ↑b) b = jacobiSym (↑(a % b)) b
tactic: rw [← hr, jacobiSymNat, jacobiSymNat, _root_.jacobiSym.mod_left a b, ← hab]
state_before: a b ab : ℕ
r : ℤ
hab : a % b = ab
hr : jacobiSymNat ab b = r
⊢ jacobiSym (↑a % ↑b) b = jacobiSym (↑(a % b)) b
state_after: no goals
tactic: rfl
Theorem: Real.real_sqrt_lt_nat_sqrt_succ
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x✝ y✝ x y : ℝ
a : ℕ
⊢ √↑a < ↑a.sqrt + 1
state_after: x✝ y✝ x y : ℝ
a : ℕ
⊢ a < (a.sqrt + 1) ^ 2

x✝ y✝ x y : ℝ
a : ℕ
⊢ 0 ≤ a.sqrt + 1
tactic: rw [sqrt_lt (by simp)] <;> norm_cast
Theorem: YoungDiagram.rowLen_anti
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: μ : YoungDiagram
i1 i2 : ℕ
hi : i1 ≤ i2
⊢ μ.rowLen i2 ≤ μ.rowLen i1
state_after: μ : YoungDiagram
i1 i2 : ℕ
hi : i1 ≤ i2
h_lt : μ.rowLen i1 < μ.rowLen i2
⊢ False
tactic: by_contra! h_lt
state_before: μ : YoungDiagram
i1 i2 : ℕ
hi : i1 ≤ i2
h_lt : μ.rowLen i1 < μ.rowLen i2
⊢ False
state_after: μ : YoungDiagram
i1 i2 : ℕ
hi : i1 ≤ i2
h_lt : μ.rowLen i1 < μ.rowLen i2
⊢ μ.rowLen i1 < μ.rowLen i1
tactic: rw [← lt_self_iff_false (μ.rowLen i1)]
state_before: μ : YoungDiagram
i1 i2 : ℕ
hi : i1 ≤ i2
h_lt : μ.rowLen i1 < μ.rowLen i2
⊢ μ.rowLen i1 < μ.rowLen i1
state_after: μ : YoungDiagram
i1 i2 : ℕ
hi : i1 ≤ i2
h_lt : (i2, μ.rowLen i1) ∈ μ
⊢ (i1, μ.rowLen i1) ∈ μ
tactic: rw [← mem_iff_lt_rowLen] at h_lt ⊢
state_before: μ : YoungDiagram
i1 i2 : ℕ
hi : i1 ≤ i2
h_lt : (i2, μ.rowLen i1) ∈ μ
⊢ (i1, μ.rowLen i1) ∈ μ
state_after: no goals
tactic: exact μ.up_left_mem hi (by rfl) h_lt
Theorem: ConjClasses.mem_carrier_iff_mk_eq
File: Mathlib/Algebra/Group/Conj.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a : α
b : ConjClasses α
⊢ a ∈ b.carrier ↔ ConjClasses.mk a = b
state_after: α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ {b : ConjClasses α}, a ∈ b.carrier ↔ ConjClasses.mk a = b
tactic: revert b
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ {b : ConjClasses α}, a ∈ b.carrier ↔ ConjClasses.mk a = b
state_after: α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ (a_1 : α), a ∈ (ConjClasses.mk a_1).carrier ↔ ConjClasses.mk a = ConjClasses.mk a_1
tactic: rw [forall_isConj]
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a : α
⊢ ∀ (a_1 : α), a ∈ (ConjClasses.mk a_1).carrier ↔ ConjClasses.mk a = ConjClasses.mk a_1
state_after: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ (ConjClasses.mk b).carrier ↔ ConjClasses.mk a = ConjClasses.mk b
tactic: intro b
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ (ConjClasses.mk b).carrier ↔ ConjClasses.mk a = ConjClasses.mk b
state_after: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ conjugatesOf b ↔ IsConj b a
tactic: rw [carrier, eq_comm, mk_eq_mk_iff_isConj, ← quotient_mk_eq_mk, Quotient.lift_mk]
state_before: α : Type u
β : Type v
inst✝ : Monoid α
a b : α
⊢ a ∈ conjugatesOf b ↔ IsConj b a
state_after: no goals
tactic: rfl
Theorem: Complex.interior_setOf_le_im
File: Mathlib/Analysis/Complex/ReImTopology.lean

Proof steps:
state_before: a : ℝ
⊢ interior {z | a ≤ z.im} = {z | a < z.im}
state_after: no goals
tactic: simpa only [interior_Ici] using interior_preimage_im (Ici a)
Theorem: bernsteinPolynomial.iterate_derivative_at_1_ne_zero
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ eval 1 ((⇑derivative)^[n - ν] (bernsteinPolynomial R n ν)) ≠ 0
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval ν.succ (ascPochhammer ℕ (n - ν)) = 0
tactic: rw [bernsteinPolynomial.iterate_derivative_at_1 _ _ _ h, Ne, neg_one_pow_mul_eq_zero_iff, ←
    Nat.cast_succ, ← ascPochhammer_eval_cast, ← Nat.cast_zero, Nat.cast_inj]
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : CharZero R
n ν : ℕ
h : ν ≤ n
⊢ ¬eval ν.succ (ascPochhammer ℕ (n - ν)) = 0
state_after: no goals
tactic: exact (ascPochhammer_pos _ _ (Nat.succ_pos ν)).ne'
Theorem: smul_eq_self_of_mem_zpowers
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
x y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
hx : x ∈ zpowers y
a : α
hs : y • a = a
⊢ x • a = a
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ y ^ k • a = a
tactic: obtain ⟨k, rfl⟩ := Subgroup.mem_zpowers_iff.mp hx
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ y ^ k • a = a
state_after: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ (MulAction.toPerm y ^ k) a = a
tactic: rw [← MulAction.toPerm_apply, ← MulAction.toPermHom_apply, MonoidHom.map_zpow _ y k,
    MulAction.toPermHom_apply]
state_before: case intro
G : Type u_1
H : Type u_2
A : Type u_3
α✝ : Type u_4
β : Type u_5
inst✝¹ : Group G
y : G
i : ℤ
α : Type u_6
inst✝ : MulAction G α
a : α
hs : y • a = a
k : ℤ
hx : y ^ k ∈ zpowers y
⊢ (MulAction.toPerm y ^ k) a = a
state_after: no goals
tactic: exact Function.IsFixedPt.perm_zpow (by exact hs) k
Theorem: Int.induction_on
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
p : ℤ → Prop
i : ℤ
hz : p 0
hp : ∀ (i : ℕ), p ↑i → p (↑i + 1)
hn : ∀ (i : ℕ), p (-↑i) → p (-↑i - 1)
⊢ p i
state_after: no goals
tactic: induction i with
  | ofNat i =>
    induction i with
    | zero => exact hz
    | succ i ih => exact hp _ ih
  | negSucc i =>
    suffices ∀ n : ℕ, p (-n) from this (i + 1)
    intro n; induction n with
    | zero => simp [hz]
    | succ n ih => convert hn _ ih using 1; simp [ofNat_succ, Int.neg_add, Int.sub_eq_add_neg]
Theorem: ZFSet.toSet_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: ⊢ ∅.toSet = ∅
state_after: no goals
tactic: simp [toSet]
Theorem: isSeparatedMap_iff_nhds
File: Mathlib/Topology/SeparatedMap.lean

Proof steps:
state_before: X : Type u_1
Y : Sort u_2
A : Type ?u.6722
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace A
f : X → Y
⊢ IsSeparatedMap f ↔ ∀ (x₁ x₂ : X), f x₁ = f x₂ → x₁ ≠ x₂ → ∃ s₁ ∈ 𝓝 x₁, ∃ s₂ ∈ 𝓝 x₂, Disjoint s₁ s₂
state_after: no goals
tactic: simp_rw [isSeparatedMap_iff_disjoint_nhds, Filter.disjoint_iff]