1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LucasLehmer.residue_eq_zero_iff_sMod_eq_zero
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: dsimp [lucasLehmerResidue]
state_before: p : ℕ
w : 1 < p
⊢ lucasLehmerResidue p = 0 ↔ sMod p (p - 2) = 0
state_after: p : ℕ
w : 1 < p
⊢ sZMod p (p - 2) = 0 ↔ sMod p (p - 2) = 0

tactic: rw [sZMod_eq_sMod p]
state_before: p : ℕ
w : 1 < p
⊢ sZMod p (p - 2) = 0 ↔ sMod p (p - 2) = 0
state_after: p : ℕ
w : 1 < p
⊢ ↑(sMod p (p - 2)) = 0 ↔ sMod p (p - 2) = 0

tactic: constructor
state_before: p : ℕ
w : 1 < p
⊢ ↑(sMod p (p - 2)) = 0 ↔ sMod p (p - 2) = 0
state_after: case mp
p : ℕ
w : 1 < p
⊢ ↑(sMod p (p - 2)) = 0 → sMod p (p - 2) = 0

case mpr
p : ℕ
w : 1 < p
⊢ sMod p (p - 2) = 0 → ↑(sMod p (p - 2)) = 0

tactic: intro h
state_before: case mp
p : ℕ
w : 1 < p
⊢ ↑(sMod p (p - 2)) = 0 → sMod p (p - 2) = 0
state_after: case mp
p : ℕ
w : 1 < p
h : ↑(sMod p (p - 2)) = 0
⊢ sMod p (p - 2) = 0

tactic: simp? [ZMod.intCast_zmod_eq_zero_iff_dvd] at h says
  simp only [ZMod.intCast_zmod_eq_zero_iff_dvd, ofNat_pos, pow_pos, cast_pred,
    cast_pow, cast_ofNat] at h
state_before: case mp
p : ℕ
w : 1 < p
h : ↑(sMod p (p - 2)) = 0
⊢ sMod p (p - 2) = 0
state_after: case mp
p : ℕ
w : 1 < p
h : 2 ^ p - 1 ∣ sMod p (p - 2)
⊢ sMod p (p - 2) = 0

tactic: apply Int.eq_zero_of_dvd_of_nonneg_of_lt _ _ h <;> clear h
state_before: case mp
p : ℕ
w : 1 < p
h : 2 ^ p - 1 ∣ sMod p (p - 2)
⊢ sMod p (p - 2) = 0
state_after: p : ℕ
w : 1 < p
⊢ 0 ≤ sMod p (p - 2)

p : ℕ
w : 1 < p
⊢ sMod p (p - 2) < 2 ^ p - 1

tactic: simp only [ZMod.intCast_zmod_eq_zero_iff_dvd, ofNat_pos, pow_pos, cast_pred,
  cast_pow, cast_ofNat] at h
state_before: case mp
p : ℕ
w : 1 < p
h : ↑(sMod p (p - 2)) = 0
⊢ sMod p (p - 2) = 0
state_after: case mp
p : ℕ
w : 1 < p
h : 2 ^ p - 1 ∣ sMod p (p - 2)
⊢ sMod p (p - 2) = 0

tactic: exact sMod_nonneg _ (by positivity) _
state_before: p : ℕ
w : 1 < p
⊢ 0 ≤ sMod p (p - 2)
state_after: no goals

tactic: positivity
state_before: p : ℕ
w : 1 < p
⊢ p ≠ 0
state_after: no goals

tactic: exact sMod_lt _ (by positivity) _
state_before: p : ℕ
w : 1 < p
⊢ sMod p (p - 2) < 2 ^ p - 1
state_after: no goals

tactic: intro h
state_before: case mpr
p : ℕ
w : 1 < p
⊢ sMod p (p - 2) = 0 → ↑(sMod p (p - 2)) = 0
state_after: case mpr
p : ℕ
w : 1 < p
h : sMod p (p - 2) = 0
⊢ ↑(sMod p (p - 2)) = 0

tactic: rw [h]
state_before: case mpr
p : ℕ
w : 1 < p
h : sMod p (p - 2) = 0
⊢ ↑(sMod p (p - 2)) = 0
state_after: case mpr
p : ℕ
w : 1 < p
h : sMod p (p - 2) = 0
⊢ ↑0 = 0

tactic: simp
state_before: case mpr
p : ℕ
w : 1 < p
h : sMod p (p - 2) = 0
⊢ ↑0 = 0
state_after: no goals
Theorem: MeasureTheory.Measure.addHaar_preimage_smul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rw [map_addHaar_smul μ hr, coe_smul, Pi.smul_apply, smul_eq_mul]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : μ.IsAddHaarMeasure
F : Type u_2
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
r : ℝ
hr : r ≠ 0
s : Set E
⊢ (map (fun x => r • x) μ) s = ENNReal.ofReal |(r ^ finrank ℝ E)⁻¹| * μ s
state_after: no goals
Theorem: ENNReal.add_halves
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [div_eq_mul_inv, ← mul_add, inv_two_add_inv_two, mul_one]
state_before: a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a / 2 + a / 2 = a
state_after: no goals
Theorem: Nat.div_eq_self
File: Mathlib/Data/Nat/Defs.lean

tactic: constructor
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m / n = m ↔ m = 0 ∨ n = 1
state_after: case mp
a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m / n = m → m = 0 ∨ n = 1

case mpr
a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m = 0 ∨ n = 1 → m / n = m

tactic: intro
state_before: case mp
a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m / n = m → m = 0 ∨ n = 1
state_after: case mp
a b c d m n k : ℕ
p q : ℕ → Prop
a✝ : m / n = m
⊢ m = 0 ∨ n = 1

tactic: match n with
| 0 => simp_all
| 1 => right; rfl
| n+2 =>
  left
  have : m / (n + 2) ≤ m / 2 := div_le_div_left (by simp) (by decide)
  refine eq_zero_of_le_half ?_
  simp_all
state_before: case mp
a b c d m n k : ℕ
p q : ℕ → Prop
a✝ : m / n = m
⊢ m = 0 ∨ n = 1
state_after: no goals

tactic: simp_all
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
a✝ : m / 0 = m
⊢ m = 0 ∨ 0 = 1
state_after: no goals

tactic: right
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
a✝ : m / 1 = m
⊢ m = 0 ∨ 1 = 1
state_after: case h
a b c d m n k : ℕ
p q : ℕ → Prop
a✝ : m / 1 = m
⊢ 1 = 1

tactic: rfl
state_before: case h
a b c d m n k : ℕ
p q : ℕ → Prop
a✝ : m / 1 = m
⊢ 1 = 1
state_after: no goals

tactic: left
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
⊢ m = 0 ∨ n + 2 = 1
state_after: case h
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
⊢ m = 0

tactic: have : m / (n + 2) ≤ m / 2 := div_le_div_left (by simp) (by decide)
state_before: case h
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
⊢ m = 0
state_after: case h
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
this : m / (n + 2) ≤ m / 2
⊢ m = 0

tactic: refine eq_zero_of_le_half ?_
state_before: case h
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
this : m / (n + 2) ≤ m / 2
⊢ m = 0
state_after: case h
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
this : m / (n + 2) ≤ m / 2
⊢ m ≤ m / 2

tactic: simp_all
state_before: case h
a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
this : m / (n + 2) ≤ m / 2
⊢ m ≤ m / 2
state_after: no goals

tactic: simp
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
⊢ 2 ≤ n + 2
state_after: no goals

tactic: decide
state_before: a b c d m n✝ k : ℕ
p q : ℕ → Prop
n : ℕ
a✝ : m / (n + 2) = m
⊢ 0 < 2
state_after: no goals

tactic: rintro (rfl | rfl) <;> simp
state_before: case mpr
a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m = 0 ∨ n = 1 → m / n = m
state_after: no goals
Theorem: closure_iUnion
File: Mathlib/Topology/AlexandrovDiscrete.lean

tactic: simpa only [← interior_compl, compl_iUnion] using interior_iInter fun i ↦ (f i)ᶜ
state_before: ι : Sort u_1
κ : ι → Sort u_2
α : Type u_3
β : Type u_4
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : AlexandrovDiscrete α
S : Set (Set α)
f✝ f : ι → Set α
⊢ (closure (⋃ i, f i))ᶜ = (⋃ i, closure (f i))ᶜ
state_after: no goals
Theorem: Cardinal.exists_aleph
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [aleph, Ordinal.add_sub_cancel_of_le, aleph'_alephIdx]
state_before: c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ c = aleph (c.alephIdx - ω)
state_after: c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ ω ≤ c.alephIdx

tactic: rwa [← aleph0_le_aleph', aleph'_alephIdx]
state_before: c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ ω ≤ c.alephIdx
state_after: no goals
Theorem: lowerClosure_prod
File: Mathlib/Order/UpperLower/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
⊢ lowerClosure (s ×ˢ t) = lowerClosure s ×ˢ lowerClosure t
state_after: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(lowerClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(lowerClosure s ×ˢ lowerClosure t)

tactic: simp [Prod.le_def, @and_and_and_comm _ (_ ∈ t)]
state_before: case a.h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s : Set α
t : Set β
x✝ : α × β
⊢ x✝ ∈ ↑(lowerClosure (s ×ˢ t)) ↔ x✝ ∈ ↑(lowerClosure s ×ˢ lowerClosure t)
state_after: no goals
Theorem: MeasureTheory.SignedMeasure.findExistsOneDivLT_min
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [findExistsOneDivLT, dif_pos hi] at hm
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
m : ℕ
hm : m < MeasureTheory.SignedMeasure.findExistsOneDivLT s i
⊢ ¬MeasureTheory.SignedMeasure.ExistsOneDivLT s i m
state_after: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
m : ℕ
hm : m < Nat.find ⋯
⊢ ¬MeasureTheory.SignedMeasure.ExistsOneDivLT s i m

tactic: exact Nat.find_min _ hm
state_before: α : Type u_1
β : Type u_2
inst✝³ : MeasurableSpace α
M : Type u_3
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
m : ℕ
hm : m < Nat.find ⋯
⊢ ¬MeasureTheory.SignedMeasure.ExistsOneDivLT s i m
state_after: no goals
Theorem: contDiffOn_top
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: simp only [le_top, forall_prop_of_true]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
⊢ (∀ (m : ℕ), ↑m ≤ ⊤ → ContDiffOn 𝕜 (↑m) f s) ↔ ∀ (n : ℕ), ContDiffOn 𝕜 (↑n) f s
state_after: no goals
Theorem: Polynomial.self_mul_modByMonic
File: Mathlib/Algebra/Polynomial/Div.lean

tactic: rw [modByMonic_eq_zero_iff_dvd hq]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
⊢ q * p %ₘ q = 0
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
⊢ q ∣ q * p

tactic: exact dvd_mul_right q p
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p q : R[X]
hq : q.Monic
⊢ q ∣ q * p
state_after: no goals
Theorem: HasStrictDerivAt.smul_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: have := hc.smul (hasStrictDerivAt_const x f)
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasStrictDerivAt c c' x
f : F
⊢ HasStrictDerivAt (fun y => c y • f) (c' • f) x
state_after: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasStrictDerivAt c c' x
f : F
this : HasStrictDerivAt (fun y => c y • f) (c x • 0 + c' • f) x
⊢ HasStrictDerivAt (fun y => c y • f) (c' • f) x

tactic: rwa [smul_zero, zero_add] at this
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
inst✝³ : NontriviallyNormedField 𝕜'
inst✝² : NormedAlgebra 𝕜 𝕜'
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
c : 𝕜 → 𝕜'
c' : 𝕜'
hc : HasStrictDerivAt c c' x
f : F
this : HasStrictDerivAt (fun y => c y • f) (c x • 0 + c' • f) x
⊢ HasStrictDerivAt (fun y => c y • f) (c' • f) x
state_after: no goals
Theorem: IsQuasiregular.map
File: Mathlib/Algebra/Algebra/Quasispectrum.lean

tactic: rw [isQuasiregular_iff] at hx ⊢
state_before: F : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : NonUnitalSemiring R
inst✝² : NonUnitalSemiring S
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
f : F
x : R
hx : IsQuasiregular x
⊢ IsQuasiregular (f x)
state_after: F : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : NonUnitalSemiring R
inst✝² : NonUnitalSemiring S
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
f : F
x : R
hx : ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0
⊢ ∃ y, y + f x + f x * y = 0 ∧ f x + y + y * f x = 0

tactic: obtain ⟨y, hy₁, hy₂⟩ := hx
state_before: F : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : NonUnitalSemiring R
inst✝² : NonUnitalSemiring S
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
f : F
x : R
hx : ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0
⊢ ∃ y, y + f x + f x * y = 0 ∧ f x + y + y * f x = 0
state_after: case intro.intro
F : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : NonUnitalSemiring R
inst✝² : NonUnitalSemiring S
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
f : F
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ ∃ y, y + f x + f x * y = 0 ∧ f x + y + y * f x = 0

tactic: exact ⟨f y, by simpa using And.intro congr(f $(hy₁)) congr(f $(hy₂))⟩
state_before: case intro.intro
F : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : NonUnitalSemiring R
inst✝² : NonUnitalSemiring S
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
f : F
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ ∃ y, y + f x + f x * y = 0 ∧ f x + y + y * f x = 0
state_after: no goals

tactic: simpa using And.intro congr(f $(hy₁)) congr(f $(hy₂))
state_before: F : Type u_1
R : Type u_2
S : Type u_3
inst✝³ : NonUnitalSemiring R
inst✝² : NonUnitalSemiring S
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
f : F
x y : R
hy₁ : y + x + x * y = 0
hy₂ : x + y + y * x = 0
⊢ f y + f x + f x * f y = 0 ∧ f x + f y + f y * f x = 0
state_after: no goals
Theorem: Real.iSup_mul_of_nonpos
File: Mathlib/Data/Real/Pointwise.lean

tactic: simp only [Real.mul_iSup_of_nonpos ha, mul_comm]
state_before: ι : Sort u_1
α : Type u_2
inst✝ : LinearOrderedField α
r : ℝ
ha : r ≤ 0
f : ι → ℝ
⊢ (⨆ i, f i) * r = ⨅ i, f i * r
state_after: no goals
Theorem: Complex.exp_nat_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [Nat.cast_zero, zero_mul, exp_zero, pow_zero]
state_before: x✝ y x : ℂ
⊢ cexp (↑0 * x) = cexp x ^ 0
state_after: no goals

tactic: rw [pow_succ, Nat.cast_add_one, add_mul, exp_add, ← exp_nat_mul _ n, one_mul]
state_before: x✝ y x : ℂ
n : ℕ
⊢ cexp (↑n.succ * x) = cexp x ^ n.succ
state_after: no goals
Theorem: Module.End.finite_hasEigenvalue
File: Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean

tactic: have h : minpoly K f ≠ 0 := minpoly.ne_zero (Algebra.IsIntegral.isIntegral (R := K) f)
state_before: K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
⊢ Set.Finite f.HasEigenvalue
state_after: K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ Set.Finite f.HasEigenvalue

tactic: convert (minpoly K f).rootSet_finite K
state_before: K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ Set.Finite f.HasEigenvalue
state_after: case h.e'_2
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ f.HasEigenvalue = (minpoly K f).rootSet K

tactic: ext μ
state_before: case h.e'_2
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ : K
h : minpoly K f ≠ 0
⊢ f.HasEigenvalue = (minpoly K f).rootSet K
state_after: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ μ ∈ f.HasEigenvalue ↔ μ ∈ (minpoly K f).rootSet K

tactic: change f.HasEigenvalue μ ↔ _
state_before: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ μ ∈ f.HasEigenvalue ↔ μ ∈ (minpoly K f).rootSet K
state_after: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ f.HasEigenvalue μ ↔ μ ∈ (minpoly K f).rootSet K

tactic: rw [hasEigenvalue_iff_isRoot, mem_rootSet_of_ne h, IsRoot, coe_aeval_eq_eval]
state_before: case h.e'_2.h
K : Type v
V : Type w
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : FiniteDimensional K V
f : End K V
μ✝ : K
h : minpoly K f ≠ 0
μ : K
⊢ f.HasEigenvalue μ ↔ μ ∈ (minpoly K f).rootSet K
state_after: no goals
Theorem: SimpleGraph.Walk.length_support
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : G.Walk u v
⊢ p.support.length = p.length + 1
state_after: no goals
Theorem: LieModule.posFittingCompOf_le_posFittingComp
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: rw [posFittingComp]
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ posFittingCompOf R M x ≤ posFittingComp R L M
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ posFittingCompOf R M x ≤ ⨆ x, posFittingCompOf R M x

tactic: exact le_iSup (posFittingCompOf R M) x
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ posFittingCompOf R M x ≤ ⨆ x, posFittingCompOf R M x
state_after: no goals
Theorem: IsCentralScalar.unop_smul_eq_smul
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: induction m
state_before: M✝ : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α✝ : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
M : Type u_10
α : Type u_11
inst✝² : SMul M α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
m : Mᵐᵒᵖ
a : α
⊢ MulOpposite.unop m • a = m • a
state_after: case h
M✝ : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α✝ : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
M : Type u_10
α : Type u_11
inst✝² : SMul M α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
a : α
X✝ : M
⊢ MulOpposite.unop (MulOpposite.op X✝) • a = MulOpposite.op X✝ • a

tactic: exact (IsCentralScalar.op_smul_eq_smul _ a).symm
state_before: case h
M✝ : Type u_1
N : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α✝ : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
M : Type u_10
α : Type u_11
inst✝² : SMul M α
inst✝¹ : SMul Mᵐᵒᵖ α
inst✝ : IsCentralScalar M α
a : α
X✝ : M
⊢ MulOpposite.unop (MulOpposite.op X✝) • a = MulOpposite.op X✝ • a
state_after: no goals
Theorem: PiNat.min_firstDiff_le
File: Mathlib/Topology/MetricSpace/PiNat.lean

tactic: by_contra! H
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
⊢ min (firstDiff x y) (firstDiff y z) ≤ firstDiff x z
state_after: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < min (firstDiff x y) (firstDiff y z)
⊢ False

tactic: rw [lt_min_iff] at H
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < min (firstDiff x y) (firstDiff y z)
⊢ False
state_after: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ False

tactic: refine apply_firstDiff_ne h ?_
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ False
state_after: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ x (firstDiff x z) = z (firstDiff x z)

tactic: calc
  x (firstDiff x z) = y (firstDiff x z) := apply_eq_of_lt_firstDiff H.1
  _ = z (firstDiff x z) := apply_eq_of_lt_firstDiff H.2
state_before: E : ℕ → Type u_1
x y z : (n : ℕ) → E n
h : x ≠ z
H : firstDiff x z < firstDiff x y ∧ firstDiff x z < firstDiff y z
⊢ x (firstDiff x z) = z (firstDiff x z)
state_after: no goals
Theorem: MeasureTheory.ae_restrict_union_eq
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: simp [union_eq_iUnion, iSup_bool_eq]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t✝ s t : Set α
⊢ ae (μ.restrict (s ∪ t)) = ae (μ.restrict s) ⊔ ae (μ.restrict t)
state_after: no goals
Theorem: MulRingNorm.apply_natAbs_eq
File: Mathlib/Analysis/Normed/Ring/Seminorm.lean

tactic: obtain ⟨n, rfl | rfl⟩ := eq_nat_or_neg x <;>
simp only [natAbs_neg, natAbs_ofNat, cast_neg, cast_natCast, map_neg_eq_map]
state_before: F : Type u_1
R✝ : Type u_2
S : Type u_3
x✝ y : R✝
r : ℝ
R : Type u_4
inst✝ : Ring R
x : ℤ
f : MulRingNorm R
⊢ f ↑x.natAbs = f ↑x
state_after: no goals
Theorem: Ordinal.typein_lt_self
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp_rw [← type_lt o]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
i : (Quotient.out o).α
⊢ typein (fun x x_1 => x < x_1) i < o
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
i : (Quotient.out o).α
⊢ typein (fun x x_1 => x < x_1) i < type fun x x_1 => x < x_1

tactic: apply typein_lt_type
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
i : (Quotient.out o).α
⊢ typein (fun x x_1 => x < x_1) i < type fun x x_1 => x < x_1
state_after: no goals
Theorem: OneHom.comp_one
File: Mathlib/Algebra/Group/Hom/Defs.lean

tactic: ext
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : OneHom N P
⊢ f.comp 1 = 1
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : OneHom N P
x✝ : M
⊢ (f.comp 1) x✝ = 1 x✝

tactic: simp only [OneHom.map_one, OneHom.coe_comp, Function.comp_apply, OneHom.one_apply]
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : OneHom N P
x✝ : M
⊢ (f.comp 1) x✝ = 1 x✝
state_after: no goals