ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Pretriangulated.mem_distTriang_op_iff
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasShift C ℤ
inst✝³ : HasZeroObject C
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
T : Triangle Cᵒᵖ
⊢ T ∈ distinguishedTriangles ↔ Opposite.unop ((triangleOpEquivalence C).inverse.obj T) ∈ distinguishedTriangles
state_after: no goals
tactic: rfl
Theorem: Complex.sin_add
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ sin (x + y) = sin x * cos y + cos x * sin y
state_after: no goals
tactic: rw [← mul_left_inj' I_ne_zero, ← sinh_mul_I, add_mul, add_mul, mul_right_comm, ← sinh_mul_I,
    mul_assoc, ← sinh_mul_I, ← cosh_mul_I, ← cosh_mul_I, sinh_add]
Theorem: Sylow.smul_eq_of_normal
File: Mathlib/GroupTheory/Sylow.lean

Proof steps:
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
g : G
P : Sylow p G
h : (↑P).Normal
⊢ g • P = P
state_after: no goals
tactic: simp only [Sylow.smul_eq_iff_mem_normalizer, normalizer_eq_top.mpr h, mem_top]
Theorem: Polynomial.natDegree_prod
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
⊢ (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree
state_after: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
⊢ (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree
tactic: nontriviality R
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
⊢ (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree
state_after: case h
R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
⊢ ∏ i ∈ s, (f i).leadingCoeff ≠ 0
tactic: apply natDegree_prod'
state_before: case h
R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
⊢ ∏ i ∈ s, (f i).leadingCoeff ≠ 0
state_after: case h
R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
⊢ ∀ a ∈ s, (f a).leadingCoeff ≠ 0
tactic: rw [prod_ne_zero_iff]
state_before: case h
R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
⊢ ∀ a ∈ s, (f a).leadingCoeff ≠ 0
state_after: case h
R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
x : ι
hx : x ∈ s
⊢ (f x).leadingCoeff ≠ 0
tactic: intro x hx
state_before: case h
R : Type u
ι : Type w
s : Finset ι
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
f : ι → R[X]
t : Multiset R[X]
h : ∀ i ∈ s, f i ≠ 0
a✝ : Nontrivial R
x : ι
hx : x ∈ s
⊢ (f x).leadingCoeff ≠ 0
state_after: no goals
tactic: simp [h x hx]
Theorem: Polynomial.card_support_le_one_of_eraseLead_eq_zero
File: Mathlib/Algebra/Polynomial/EraseLead.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
⊢ f.support.card ≤ 1
state_after: case pos
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
hpz : f = 0
⊢ f.support.card ≤ 1

case neg
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
hpz : ¬f = 0
⊢ f.support.card ≤ 1
tactic: by_cases hpz : f = 0
state_before: case pos
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
hpz : f = 0
⊢ f.support.card ≤ 1

case neg
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
hpz : ¬f = 0
⊢ f.support.card ≤ 1
state_after: case neg
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
hpz : ¬f = 0
⊢ f.support.card ≤ 1
tactic: case pos => simp [hpz]
state_before: case neg
R : Type u_1
inst✝ : Semiring R
f : R[X]
h : f.eraseLead = 0
hpz : ¬f = 0
⊢ f.support.card ≤ 1
state_after: no goals
tactic: case neg => exact le_of_eq (card_support_eq_one_of_eraseLead_eq_zero hpz h)
Theorem: continuous_iInf_rng
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f : α → β
ι : Sort u_2
t₁ : TopologicalSpace α
t₂ : ι → TopologicalSpace β
⊢ Continuous f ↔ ∀ (i : ι), Continuous f
state_after: no goals
tactic: simp only [continuous_iff_coinduced_le, le_iInf_iff]
Theorem: equicontinuousWithinAt_iff_continuousWithinAt
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : X
⊢ EquicontinuousWithinAt F S x₀ ↔ ContinuousWithinAt (⇑UniformFun.ofFun ∘ swap F) S x₀
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : X
⊢ EquicontinuousWithinAt F S x₀ ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : X) in 𝓝[S] x₀,
        (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α i}
tactic: rw [ContinuousWithinAt, (UniformFun.hasBasis_nhds ι α _).tendsto_right_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : X
⊢ EquicontinuousWithinAt F S x₀ ↔
    ∀ i ∈ 𝓤 α,
      ∀ᶠ (x : X) in 𝓝[S] x₀,
        (⇑UniformFun.ofFun ∘ swap F) x ∈ {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α i}
state_after: no goals
tactic: rfl
Theorem: Int.smul_one_eq_cast
File: Mathlib/Algebra/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
R✝ : Type u_2
k : Type u_3
S : Type u_4
M : Type u_5
M₂ : Type u_6
M₃ : Type u_7
ι : Type u_8
R : Type u_9
inst✝ : NonAssocRing R
m : ℤ
⊢ m • 1 = ↑m
state_after: no goals
tactic: rw [zsmul_eq_mul, mul_one]
Theorem: List.map_get_sublist
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
l : List α
is : List (Fin l.length)
h : Pairwise (fun x x_1 => ↑x < ↑x_1) is
⊢ map l.get is <+ l
state_after: α : Type u_1
l : List α
is : List (Fin l.length)
h : Pairwise (fun x x_1 => ↑x < ↑x_1) is
⊢ ∀ (n : Nat) (l' : List α), l' = drop n l → (∀ (i : Fin l.length), i ∈ is → n ≤ ↑i) → map l.get is <+ l'
tactic: suffices ∀ n l', l' = l.drop n → (∀ i ∈ is, n ≤ i) → map (get l) is <+ l'
    from this 0 l (by simp) (by simp)
state_before: α : Type u_1
l : List α
is : List (Fin l.length)
h : Pairwise (fun x x_1 => ↑x < ↑x_1) is
⊢ ∀ (n : Nat) (l' : List α), l' = drop n l → (∀ (i : Fin l.length), i ∈ is → n ≤ ↑i) → map l.get is <+ l'
state_after: α : Type u_1
l : List α
is : List (Fin l.length)
h : Pairwise (fun x x_1 => ↑x < ↑x_1) is
n : Nat
l' : List α
hl' : l' = drop n l
his : ∀ (i : Fin l.length), i ∈ is → n ≤ ↑i
⊢ map l.get is <+ l'
tactic: intro n l' hl' his
state_before: α : Type u_1
l : List α
is : List (Fin l.length)
h : Pairwise (fun x x_1 => ↑x < ↑x_1) is
n : Nat
l' : List α
hl' : l' = drop n l
his : ∀ (i : Fin l.length), i ∈ is → n ≤ ↑i
⊢ map l.get is <+ l'
state_after: no goals
tactic: induction is generalizing n l' with
  | nil => simp
  | cons hd tl IH =>
    simp; cases hl'
    have := IH h.of_cons (hd+1) _ rfl (pairwise_cons.mp h).1
    specialize his hd (.head _)
    have := (drop_eq_getElem_cons ..).symm ▸ this.cons₂ (get l hd)
    have := Sublist.append (nil_sublist (take hd l |>.drop n)) this
    rwa [nil_append, ← (drop_append_of_le_length ?_), take_append_drop] at this
    simp [Nat.min_eq_left (Nat.le_of_lt hd.isLt), his]
Theorem: WithTop.sum_eq_top_iff
File: Mathlib/Algebra/BigOperators/WithTop.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : AddCommMonoid α
inst✝ : LT α
s : Finset ι
f : ι → WithTop α
⊢ ∑ i ∈ s, f i = ⊤ ↔ ∃ i ∈ s, f i = ⊤
state_after: no goals
tactic: induction s using Finset.cons_induction <;> simp [*]
Theorem: IsLocalMinOn.hasFDerivWithinAt_eq_zero
File: Mathlib/Analysis/Calculus/LocalExtr/Basic.lean

Proof steps:
state_before: E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f : E → ℝ
f' : E →L[ℝ] ℝ
s : Set E
a x y : E
h : IsLocalMinOn f s a
hf : HasFDerivWithinAt f f' s a
hy : y ∈ posTangentConeAt s a
hy' : -y ∈ posTangentConeAt s a
⊢ f' y = 0
state_after: no goals
tactic: simpa using h.neg.hasFDerivWithinAt_eq_zero hf.neg hy hy'
Theorem: uniformEmbedding_iff'
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ UniformEmbedding f ↔ Injective f ∧ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
state_after: no goals
tactic: rw [uniformEmbedding_iff, and_comm, uniformInducing_iff']
Theorem: _private.Mathlib.NumberTheory.FermatPsp.0.Nat.AB_id_helper
File: Mathlib/NumberTheory/FermatPsp.lean

Proof steps:
state_before: b p : ℕ
x✝ : 2 ≤ b
hp : Odd p
⊢ (b ^ p - 1) / (b - 1) * ((b ^ p + 1) / (b + 1)) = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
state_after: b p : ℕ
x✝ : 2 ≤ b
hp : Odd p
q₁ : b - 1 ∣ b ^ p - 1
⊢ (b ^ p - 1) / (b - 1) * ((b ^ p + 1) / (b + 1)) = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
tactic: have q₁ : b - 1 ∣ b ^ p - 1 := by simpa only [one_pow] using nat_sub_dvd_pow_sub_pow b 1 p
state_before: b p : ℕ
x✝ : 2 ≤ b
hp : Odd p
q₁ : b - 1 ∣ b ^ p - 1
⊢ (b ^ p - 1) / (b - 1) * ((b ^ p + 1) / (b + 1)) = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
state_after: b p : ℕ
x✝ : 2 ≤ b
hp : Odd p
q₁ : b - 1 ∣ b ^ p - 1
q₂ : b + 1 ∣ b ^ p + 1
⊢ (b ^ p - 1) / (b - 1) * ((b ^ p + 1) / (b + 1)) = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
tactic: have q₂ : b + 1 ∣ b ^ p + 1 := by simpa only [one_pow] using hp.nat_add_dvd_pow_add_pow b 1
state_before: b p : ℕ
x✝ : 2 ≤ b
hp : Odd p
q₁ : b - 1 ∣ b ^ p - 1
q₂ : b + 1 ∣ b ^ p + 1
⊢ (b ^ p - 1) / (b - 1) * ((b ^ p + 1) / (b + 1)) = (b ^ (2 * p) - 1) / (b ^ 2 - 1)
state_after: case h.e'_3.h.e'_5
b p : ℕ
x✝ : 2 ≤ b
hp : Odd p
q₁ : b - 1 ∣ b ^ p - 1
q₂ : b + 1 ∣ b ^ p + 1
⊢ b ^ (2 * p) - 1 = (b ^ p) ^ 2 - 1 ^ 2
tactic: convert Nat.div_mul_div_comm q₁ q₂ using 2 <;> rw [mul_comm (_ - 1), ← Nat.sq_sub_sq]
state_before: case h.e'_3.h.e'_5
b p : ℕ
x✝ : 2 ≤ b
hp : Odd p
q₁ : b - 1 ∣ b ^ p - 1
q₂ : b + 1 ∣ b ^ p + 1
⊢ b ^ (2 * p) - 1 = (b ^ p) ^ 2 - 1 ^ 2
state_after: no goals
tactic: ring_nf
Theorem: MeasureTheory.Adapted.upcrossingStrat_adapted
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
⊢ Adapted ℱ (upcrossingStrat a b f N)
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n : ℕ
⊢ StronglyMeasurable (upcrossingStrat a b f N n)
tactic: intro n
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n : ℕ
⊢ StronglyMeasurable (upcrossingStrat a b f N n)
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n : ℕ
⊢ StronglyMeasurable fun ω =>
    ∑ k ∈ Finset.range N,
      ({n | lowerCrossingTime a b f N k ω ≤ n} ∩ {n | n < upperCrossingTime a b f N (k + 1) ω}).indicator 1 n
tactic: change StronglyMeasurable[ℱ n] fun ω =>
    ∑ k ∈ Finset.range N, ({n | lowerCrossingTime a b f N k ω ≤ n} ∩
      {n | n < upperCrossingTime a b f N (k + 1) ω}).indicator 1 n
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n : ℕ
⊢ StronglyMeasurable fun ω =>
    ∑ k ∈ Finset.range N,
      ({n | lowerCrossingTime a b f N k ω ≤ n} ∩ {n | n < upperCrossingTime a b f N (k + 1) ω}).indicator 1 n
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n i : ℕ
x✝ : i ∈ Finset.range N
⊢ MeasurableSet fun ω => {n | n < upperCrossingTime a b f N (i + 1) ω} n
tactic: refine Finset.stronglyMeasurable_sum _ fun i _ =>
    stronglyMeasurable_const.indicator ((hf.isStoppingTime_lowerCrossingTime n).inter ?_)
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n i : ℕ
x✝ : i ∈ Finset.range N
⊢ MeasurableSet fun ω => {n | n < upperCrossingTime a b f N (i + 1) ω} n
state_after: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n i : ℕ
x✝ : i ∈ Finset.range N
⊢ MeasurableSet fun ω => {n | ¬upperCrossingTime a b f N (i + 1) ω ≤ n} n
tactic: simp_rw [← not_le]
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n✝ m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
hf : Adapted ℱ f
n i : ℕ
x✝ : i ∈ Finset.range N
⊢ MeasurableSet fun ω => {n | ¬upperCrossingTime a b f N (i + 1) ω ≤ n} n
state_after: no goals
tactic: exact (hf.isStoppingTime_upperCrossingTime n).compl
Theorem: IsDedekindDomain.HeightOneSpectrum.valuation_of_algebraMap
File: Mathlib/RingTheory/DedekindDomain/AdicValuation.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDedekindDomain R
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
r : R
⊢ v.valuation ((algebraMap R K) r) = v.intValuation r
state_after: no goals
tactic: rw [valuation_def, Valuation.extendToLocalization_apply_map_apply]
Theorem: Set.toFinset_singleton
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
a : α
inst✝ : Fintype ↑{a}
⊢ {a}.toFinset = {a}
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
a : α
inst✝ : Fintype ↑{a}
a✝ : α
⊢ a✝ ∈ {a}.toFinset ↔ a✝ ∈ {a}
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
a : α
inst✝ : Fintype ↑{a}
a✝ : α
⊢ a✝ ∈ {a}.toFinset ↔ a✝ ∈ {a}
state_after: no goals
tactic: simp
Theorem: hasDerivAt_gronwallBound_shift
File: Mathlib/Analysis/ODE/Gronwall.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K ε x a : ℝ
⊢ HasDerivAt (fun y => gronwallBound δ K ε (y - a)) (K * gronwallBound δ K ε (x - a) + ε) x
state_after: case h.e'_7
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K ε x a : ℝ
⊢ K * gronwallBound δ K ε (x - a) + ε = (K * gronwallBound δ K ε (id x - a) + ε) * 1
tactic: convert (hasDerivAt_gronwallBound δ K ε _).comp x ((hasDerivAt_id x).sub_const a) using 1
state_before: case h.e'_7
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K ε x a : ℝ
⊢ K * gronwallBound δ K ε (x - a) + ε = (K * gronwallBound δ K ε (id x - a) + ε) * 1
state_after: no goals
tactic: rw [id, mul_one]
Theorem: MulAction.pretransitive_iff_unique_quotient_of_nonempty
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : MulAction G β
inst✝ : Nonempty α
⊢ IsPretransitive G α ↔ Nonempty (Unique (orbitRel.Quotient G α))
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : MulAction G β
inst✝ : Nonempty α
⊢ Subsingleton (orbitRel.Quotient G α) → Nonempty (orbitRel.Quotient G α)
tactic: rw [unique_iff_subsingleton_and_nonempty, pretransitive_iff_subsingleton_quotient, iff_self_and]
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝³ : Group G
inst✝² : MulAction G α
inst✝¹ : MulAction G β
inst✝ : Nonempty α
⊢ Subsingleton (orbitRel.Quotient G α) → Nonempty (orbitRel.Quotient G α)
state_after: no goals
tactic: exact fun _ ↦ (nonempty_quotient_iff _).mpr inferInstance
Theorem: eigenvalue_pos_of_pos
File: Mathlib/Analysis/InnerProductSpace/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 < RCLike.re ⟪x, T x⟫_𝕜
⊢ 0 < μ
state_after: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 < RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
⊢ 0 < μ
tactic: obtain ⟨v, hv⟩ := hμ.exists_hasEigenvector
state_before: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 < RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
⊢ 0 < μ
state_after: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 < RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
⊢ 0 < μ
tactic: have hpos : (0 : ℝ) < ‖v‖ ^ 2 := by simpa only [sq_pos_iff, norm_ne_zero_iff] using hv.2
state_before: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 < RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
⊢ 0 < μ
state_after: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 < RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
this : RCLike.re ⟪v, T v⟫_𝕜 = μ * ‖v‖ ^ 2
⊢ 0 < μ
tactic: have : RCLike.re ⟪v, T v⟫ = μ * ‖v‖ ^ 2 := by
    have := congr_arg RCLike.re (inner_product_apply_eigenvector hv.1)
    -- Porting note: why can't `exact_mod_cast` do this? These lemmas are marked `norm_cast`
    rw [← RCLike.ofReal_pow, ← RCLike.ofReal_mul] at this
    exact mod_cast this
state_before: case intro
𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : ℝ
T : E →ₗ[𝕜] E
hμ : HasEigenvalue T ↑μ
hnn : ∀ (x : E), 0 < RCLike.re ⟪x, T x⟫_𝕜
v : E
hv : HasEigenvector T (↑μ) v
hpos : 0 < ‖v‖ ^ 2
this : RCLike.re ⟪v, T v⟫_𝕜 = μ * ‖v‖ ^ 2
⊢ 0 < μ
state_after: no goals
tactic: exact (mul_pos_iff_of_pos_right hpos).mp (this ▸ hnn v)
Theorem: PMF.toOuterMeasure_pure_apply
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
⊢ (pure a).toOuterMeasure s = if a ∈ s then 1 else 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = if a ∈ s then 1 else 0
tactic: refine (toOuterMeasure_apply (pure a) s).trans ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = if a ∈ s then 1 else 0
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∈ s
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = 1

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a a' : α
s : Set α
ha : a ∉ s
⊢ ∑' (x : α), s.indicator (⇑(pure a)) x = 0
tactic: split_ifs with ha
Theorem: CategoryTheory.Functor.Iteration.coconeOfLE_ι_app
File: Mathlib/CategoryTheory/SmallObject/Iteration.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.11479, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
F : { i // i ≤ j } ⥤ C
i : J
hi : i ≤ j
x✝ : { k // k < i }
k : J
hk : k < i
⊢ ⋯.functor.obj ⟨k, hk⟩ ≤ ⟨i, hi⟩
state_after: no goals
tactic: simpa using hk.le
state_before: C : Type u_1
inst✝³ : Category.{?u.11479, u_1} C
Φ : C ⥤ C
ε : 𝟭 C ⟶ Φ
J : Type u
inst✝² : LinearOrder J
inst✝¹ : IsWellOrder J fun x x_1 => x < x_1
inst✝ : OrderBot J
j : J
F : { i // i ≤ j } ⥤ C
i : J
hi : i ≤ j
x✝² x✝¹ : { k // k < i }
k₁ : J
hk₁ : k₁ < i
k₂ : J
hk₂ : k₂ < i
x✝ : ⟨k₁, hk₁⟩ ⟶ ⟨k₂, hk₂⟩
⊢ (restrictionLT F hi).map x✝ ≫
      (fun x =>
          match x with
          | ⟨k, hk⟩ => F.map (homOfLE ⋯))
        ⟨k₂, hk₂⟩ =
    (fun x =>
          match x with
          | ⟨k, hk⟩ => F.map (homOfLE ⋯))
        ⟨k₁, hk₁⟩ ≫
      ((const { k // k < i }).obj (F.obj ⟨i, hi⟩)).map x✝
state_after: no goals
tactic: simp [comp_id, ← Functor.map_comp, homOfLE_comp]
Theorem: _private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piScalarRightInv_single
File: Mathlib/LinearAlgebra/TensorProduct/Pi.lean

Proof steps:
state_before: R : Type u_1
inst✝⁸ : CommSemiring R
S : Type u_2
inst✝⁷ : CommSemiring S
inst✝⁶ : Algebra R S
N : Type u_3
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : Module S N
inst✝² : IsScalarTower R S N
ι : Type u_4
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
x : N
i : ι
⊢ (TensorProduct.piScalarRightInv R S N ι) (Pi.single i x) = x ⊗ₜ[R] Pi.single i 1
state_after: no goals
tactic: simp [piScalarRightInv, Pi.single_apply, TensorProduct.ite_tmul]
Theorem: ContinuousLinearMapWOT.ext_dual_iff
File: Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : RCLike 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : TopologicalSpace E
inst✝² : Module 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
A B : E →WOT[𝕜]F
h : A = B
x✝¹ : E
x✝ : NormedSpace.Dual 𝕜 F
⊢ x✝ (A x✝¹) = x✝ (B x✝¹)
state_after: no goals
tactic: simp [h]
Theorem: NumberField.ComplexEmbedding.IsConj.isUnramified_mk_iff
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝⁷ : Field k
K : Type u_2
inst✝⁶ : Field K
F : Type u_3
inst✝⁵ : Field F
inst✝⁴ : NumberField K
inst✝³ : Algebra k K
inst✝² : Algebra k F
inst✝¹ : Algebra K F
inst✝ : IsScalarTower k K F
σ : K ≃ₐ[k] K
w : InfinitePlace K
φ : K →+* ℂ
h : ComplexEmbedding.IsConj φ σ
⊢ IsUnramified k (mk φ) ↔ σ = 1
state_after: no goals
tactic: rw [h.ext_iff, ComplexEmbedding.isConj_one_iff, ← not_iff_not, not_isUnramified_iff,
    ← not_isReal_iff_isComplex, comap_mk, isReal_mk_iff, isReal_mk_iff, eq_true h.isReal_comp,
    and_true]
Theorem: MvPowerSeries.C_inv
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
r : k
⊢ ((C σ k) r)⁻¹ = (C σ k) r⁻¹
state_after: case inl
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
⊢ ((C σ k) 0)⁻¹ = (C σ k) 0⁻¹

case inr
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
r : k
hr : r ≠ 0
⊢ ((C σ k) r)⁻¹ = (C σ k) r⁻¹
tactic: rcases eq_or_ne r 0 with (rfl | hr)
state_before: case inr
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
r : k
hr : r ≠ 0
⊢ ((C σ k) r)⁻¹ = (C σ k) r⁻¹
state_after: case inr
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
r : k
hr : r ≠ 0
⊢ (constantCoeff σ k) ((C σ k) r) ≠ 0
tactic: rw [MvPowerSeries.inv_eq_iff_mul_eq_one, ← map_mul, inv_mul_cancel hr, map_one]
state_before: case inr
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
r : k
hr : r ≠ 0
⊢ (constantCoeff σ k) ((C σ k) r) ≠ 0
state_after: no goals
tactic: simpa using hr