tasksource/leandojo huggingface dataset:
Theorem: Filter.blimsup_congr'
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [blimsup_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.110090
ι : Type ?u.110093
inst✝ : CompleteLattice α
f : Filter β
p q : β → Prop
u : β → α
h : ∀ᶠ (x : β) in f, u x ≠ ⊥ → (p x ↔ q x)
⊢ blimsup u f p = blimsup u f q

tactic: congr
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.110090
ι : Type ?u.110093
inst✝ : CompleteLattice α
f : Filter β
p q : β → Prop
u : β → α
h : ∀ᶠ (x : β) in f, u x ≠ ⊥ → (p x ↔ q x)
⊢ sInf {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = sInf {a | ∀ᶠ (x : β) in f, q x → u x ≤ a}

tactic: ext a
state_before: case e_a
α : Type u_2
β : Type u_1
γ : Type ?u.110090
ι : Type ?u.110093
inst✝ : CompleteLattice α
f : Filter β
p q : β → Prop
u : β → α
h : ∀ᶠ (x : β) in f, u x ≠ ⊥ → (p x ↔ q x)
⊢ {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = {a | ∀ᶠ (x : β) in f, q x → u x ≤ a}

tactic: refine' eventually_congr (h.mono fun b hb => _)
state_before: case e_a.h
α : Type u_2
β : Type u_1
γ : Type ?u.110090
ι : Type ?u.110093
inst✝ : CompleteLattice α
f : Filter β
p q : β → Prop
u : β → α
h : ∀ᶠ (x : β) in f, u x ≠ ⊥ → (p x ↔ q x)
a : α
⊢ a ∈ {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ a ∈ {a | ∀ᶠ (x : β) in f, q x → u x ≤ a}

tactic: cases' eq_or_ne (u b) ⊥ with hu hu
state_before: case e_a.h
α : Type u_2
β : Type u_1
γ : Type ?u.110090
ι : Type ?u.110093
inst✝ : CompleteLattice α
f : Filter β
p q : β → Prop
u : β → α
h : ∀ᶠ (x : β) in f, u x ≠ ⊥ → (p x ↔ q x)
a : α
b : β
hb : u b ≠ ⊥ → (p b ↔ q b)
⊢ p b → u b ≤ a ↔ q b → u b ≤ a

tactic: rw [hb hu]
state_before: case e_a.h.inr
α : Type u_2
β : Type u_1
γ : Type ?u.110090
ι : Type ?u.110093
inst✝ : CompleteLattice α
f : Filter β
p q : β → Prop
u : β → α
h : ∀ᶠ (x : β) in f, u x ≠ ⊥ → (p x ↔ q x)
a : α
b : β
hb : u b ≠ ⊥ → (p b ↔ q b)
hu : u b ≠ ⊥
⊢ p b → u b ≤ a ↔ q b → u b ≤ a

tactic: simp [hu]
state_before: case e_a.h.inl
α : Type u_2
β : Type u_1
γ : Type ?u.110090
ι : Type ?u.110093
inst✝ : CompleteLattice α
f : Filter β
p q : β → Prop
u : β → α
h : ∀ᶠ (x : β) in f, u x ≠ ⊥ → (p x ↔ q x)
a : α
b : β
hb : u b ≠ ⊥ → (p b ↔ q b)
hu : u b = ⊥
⊢ p b → u b ≤ a ↔ q b → u b ≤ a
Theorem: Mathlib.Tactic.Ring.add_overlap_pf_zero
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [h, ← mul_add]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a b x : R
e : ℕ
h : a + b = ↑0
⊢ x ^ e * a + x ^ e * b = ↑0
Theorem: Real.measure_ext_Ioo_rat
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simp only [mem_iUnion, mem_singleton_iff]
state_before: α : Type ?u.2411683
β : Type ?u.2411686
γ : Type ?u.2411689
γ₂ : Type ?u.2411692
δ : Type ?u.2411695
ι : Sort y
s t u : Set α
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), ↑↑μ (Ioo ↑a ↑b) = ↑↑ν (Ioo ↑a ↑b)
⊢ ∀ (s : Set ℝ), (s ∈ ⋃ (a : ℚ) (b : ℚ) (_ : a < b), {Ioo ↑a ↑b}) → ↑↑μ s = ↑↑ν s

tactic: rintro _ ⟨a, b, -, rfl⟩
state_before: α : Type ?u.2411683
β : Type ?u.2411686
γ : Type ?u.2411689
γ₂ : Type ?u.2411692
δ : Type ?u.2411695
ι : Sort y
s t u : Set α
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), ↑↑μ (Ioo ↑a ↑b) = ↑↑ν (Ioo ↑a ↑b)
⊢ ∀ (s : Set ℝ), (∃ i i_1 h, s = Ioo ↑i ↑i_1) → ↑↑μ s = ↑↑ν s

tactic: apply h
state_before: case intro.intro.intro
α : Type ?u.2411683
β : Type ?u.2411686
γ : Type ?u.2411689
γ₂ : Type ?u.2411692
δ : Type ?u.2411695
ι : Sort y
s t u : Set α
μ ν : MeasureTheory.Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
h : ∀ (a b : ℚ), ↑↑μ (Ioo ↑a ↑b) = ↑↑ν (Ioo ↑a ↑b)
a b : ℚ
⊢ ↑↑μ (Ioo ↑a ↑b) = ↑↑ν (Ioo ↑a ↑b)
Theorem: Nat.mul_two
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.mul_succ]
state_before: n : Nat
⊢ n * 2 = n + n
Theorem: Submodule.orthogonal_eq_inter
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: apply le_antisymm
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.42949
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Kᗮ = ⨅ (v : { x // x ∈ K }), LinearMap.ker (↑(innerSL 𝕜) ↑v)

tactic: rw [le_iInf_iff]
state_before: case a
𝕜 : Type u_2
E : Type u_1
F : Type ?u.42949
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ Kᗮ ≤ ⨅ (v : { x // x ∈ K }), LinearMap.ker (↑(innerSL 𝕜) ↑v)

tactic: rintro ⟨v, hv⟩ w hw
state_before: case a
𝕜 : Type u_2
E : Type u_1
F : Type ?u.42949
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ ∀ (i : { x // x ∈ K }), Kᗮ ≤ LinearMap.ker (↑(innerSL 𝕜) ↑i)

tactic: simpa using hw _ hv
state_before: case a.mk
𝕜 : Type u_2
E : Type u_1
F : Type ?u.42949
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
v : E
hv : v ∈ K
w : E
hw : w ∈ Kᗮ
⊢ w ∈ LinearMap.ker (↑(innerSL 𝕜) ↑{ val := v, property := hv })

tactic: intro v hv w hw
state_before: case a
𝕜 : Type u_2
E : Type u_1
F : Type ?u.42949
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ (⨅ (v : { x // x ∈ K }), LinearMap.ker (↑(innerSL 𝕜) ↑v)) ≤ Kᗮ

tactic: simp only [mem_iInf] at hv
state_before: case a
𝕜 : Type u_2
E : Type u_1
F : Type ?u.42949
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
v : E
hv : v ∈ ⨅ (v : { x // x ∈ K }), LinearMap.ker (↑(innerSL 𝕜) ↑v)
w : E
hw : w ∈ K
⊢ inner w v = 0

tactic: exact hv ⟨w, hw⟩
state_before: case a
𝕜 : Type u_2
E : Type u_1
F : Type ?u.42949
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
v w : E
hw : w ∈ K
hv : ∀ (i : { x // x ∈ K }), v ∈ LinearMap.ker (↑(innerSL 𝕜) ↑i)
⊢ inner w v = 0
Theorem: Real.toNNReal_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: nth_rw 1 [← Real.coe_toNNReal x hx]
state_before: x y : ℝ
hx : 0 ≤ x
⊢ toNNReal (x ^ y) = toNNReal x ^ y

tactic: rw [← NNReal.coe_rpow, Real.toNNReal_coe]
state_before: x y : ℝ
hx : 0 ≤ x
⊢ toNNReal (↑(toNNReal x) ^ y) = toNNReal x ^ y
Theorem: neg_div'
File: Mathlib/Algebra/Field/Basic.lean

tactic: simp [neg_div]
state_before: α : Type ?u.31980
β : Type ?u.31983
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a✝ b✝ a b : K
⊢ -(b / a) = -b / a
Theorem: left_mem_openSegment_iff
File: Mathlib/Analysis/Convex/Segment.lean

tactic: constructor
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.172150
G : Type ?u.172153
ι : Type ?u.172156
π : ι → Type ?u.172161
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x y : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
⊢ x ∈ openSegment 𝕜 x y ↔ x = y

tactic: rintro ⟨a, b, _, hb, hab, hx⟩
state_before: case mp
𝕜 : Type u_1
E : Type u_2
F : Type ?u.172150
G : Type ?u.172153
ι : Type ?u.172156
π : ι → Type ?u.172161
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x y : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
⊢ x ∈ openSegment 𝕜 x y → x = y

tactic: refine' smul_right_injective _ hb.ne' ((add_right_inj (a • x)).1 _)
state_before: case mp.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.172150
G : Type ?u.172153
ι : Type ?u.172156
π : ι → Type ?u.172161
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x y : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
a b : 𝕜
w✝ : 0 < a
hb : 0 < b
hab : a + b = 1
hx : a • x + b • y = x
⊢ x = y

tactic: rw [hx, ← add_smul, hab, one_smul]
state_before: case mp.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.172150
G : Type ?u.172153
ι : Type ?u.172156
π : ι → Type ?u.172161
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x y : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
a b : 𝕜
w✝ : 0 < a
hb : 0 < b
hab : a + b = 1
hx : a • x + b • y = x
⊢ a • x + (fun x x_1 => x • x_1) b x = a • x + (fun x x_1 => x • x_1) b y

tactic: rintro rfl
state_before: case mpr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.172150
G : Type ?u.172153
ι : Type ?u.172156
π : ι → Type ?u.172161
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x y : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
⊢ x = y → x ∈ openSegment 𝕜 x y

tactic: rw [openSegment_same]
state_before: case mpr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.172150
G : Type ?u.172153
ι : Type ?u.172156
π : ι → Type ?u.172161
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
⊢ x ∈ openSegment 𝕜 x x

tactic: exact mem_singleton _
state_before: case mpr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.172150
G : Type ?u.172153
ι : Type ?u.172156
π : ι → Type ?u.172161
inst✝⁴ : LinearOrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : Module 𝕜 E
x : E
inst✝¹ : DenselyOrdered 𝕜
inst✝ : NoZeroSMulDivisors 𝕜 E
⊢ x ∈ {x}
Theorem: CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: rw [← K.w (WalkingMulticospan.Hom.fst b)]
state_before: C : Type u
inst✝ : Category C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.right b) = ι K (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b

tactic: rfl
state_before: C : Type u
inst✝ : Category C
I : MulticospanIndex C
K : Multifork I
b : I.R
⊢ K.π.app (WalkingMulticospan.left (MulticospanIndex.fstTo I b)) ≫
      (MulticospanIndex.multicospan I).map (WalkingMulticospan.Hom.fst b) =
    ι K (MulticospanIndex.fstTo I b) ≫ MulticospanIndex.fst I b
Theorem: IsUnit.div_mul_right
File: Mathlib/Algebra/Hom/Units.lean

tactic: rw [mul_comm, h.div_mul_left]
state_before: F : Type ?u.62190
G : Type ?u.62193
α : Type u_1
M : Type ?u.62199
N : Type ?u.62202
inst✝ : DivisionCommMonoid α
a b✝ c d : α
h : IsUnit a
b : α
⊢ a / (a * b) = 1 / b
Theorem: Submonoid.LocalizationMap.inv_inj
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [← mul_one (f y), eq_comm, ← mul_inv_left hf y (f z) 1, h]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.513796
inst✝ : CommMonoid P
f : M →* N
hf : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)
y z : { x // x ∈ S }
h : (↑(IsUnit.liftRight (MonoidHom.restrict f S) hf) y)⁻¹ = (↑(IsUnit.liftRight (MonoidHom.restrict f S) hf) z)⁻¹
⊢ ↑f ↑y = ↑f ↑z

tactic: exact Units.inv_mul (IsUnit.liftRight (f.restrict S) hf z)⁻¹
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.513796
inst✝ : CommMonoid P
f : M →* N
hf : ∀ (y : { x // x ∈ S }), IsUnit (↑f ↑y)
y z : { x // x ∈ S }
h : (↑(IsUnit.liftRight (MonoidHom.restrict f S) hf) y)⁻¹ = (↑(IsUnit.liftRight (MonoidHom.restrict f S) hf) z)⁻¹
⊢ ↑f ↑z * ↑(↑(IsUnit.liftRight (MonoidHom.restrict f S) hf) z)⁻¹ = 1
Theorem: WithTop.image_coe_Icc
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Icc, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left
    (Subset.trans Icc_subset_Iic_self <| Iic_subset_Iio.2 <| coe_lt_top b)]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Icc a b = Icc ↑a ↑b
Theorem: MeasureTheory.iSup₂_lintegral_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: convert (monotone_lintegral μ).le_map_iSup₂ f with a
state_before: α : Type u_3
β : Type ?u.277932
γ : Type ?u.277935
δ : Type ?u.277938
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_1
ι' : ι → Sort u_2
f : (i : ι) → ι' i → α → ℝ≥0∞
⊢ (⨆ (i : ι) (j : ι' i), ∫⁻ (a : α), f i j a ∂μ) ≤ ∫⁻ (a : α), ⨆ (i : ι) (j : ι' i), f i j a ∂μ

tactic: simp only [iSup_apply]
state_before: case h.e'_4.h.e'_4.h
α : Type u_3
β : Type ?u.277932
γ : Type ?u.277935
δ : Type ?u.277938
m : MeasurableSpace α
μ ν : Measure α
ι : Sort u_1
ι' : ι → Sort u_2
f : (i : ι) → ι' i → α → ℝ≥0∞
a : α
⊢ (⨆ (i : ι) (j : ι' i), f i j a) = iSup (fun i => ⨆ (j : ι' i), f i j) a
Theorem: NNReal.lt_iff_exists_rat_btwn
File: Mathlib/Data/Real/NNReal.lean

tactic: simp [Real.coe_toNNReal _ this, NNReal.coe_lt_coe.symm, haq, hqb]
state_before: a b : ℝ≥0
h : ↑a < ↑b
q : ℚ
haq : ↑a < ↑q
hqb : ↑q < ↑b
this : 0 ≤ ↑q
⊢ a < Real.toNNReal ↑q ∧ Real.toNNReal ↑q < b
Theorem: Polynomial.isUnit_or_eq_zero_of_separable_expand
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [or_iff_not_imp_right]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hf : Separable (↑(expand F (p ^ n)) f)
⊢ IsUnit f ∨ n = 0

tactic: rintro hn : n ≠ 0
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hf : Separable (↑(expand F (p ^ n)) f)
⊢ ¬n = 0 → IsUnit f

tactic: have hf2 : derivative (expand F (p ^ n) f) = 0 := by
  rw [derivative_expand, Nat.cast_pow, CharP.cast_eq_zero, zero_pow hn.bot_lt,
    MulZeroClass.zero_mul, MulZeroClass.mul_zero]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hf : Separable (↑(expand F (p ^ n)) f)
hn : n ≠ 0
⊢ IsUnit f

tactic: rw [separable_def, hf2, isCoprime_zero_right, isUnit_iff] at hf
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hf : Separable (↑(expand F (p ^ n)) f)
hn : n ≠ 0
hf2 : ↑derivative (↑(expand F (p ^ n)) f) = 0
⊢ IsUnit f

tactic: rcases hf with ⟨r, hr, hrf⟩
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hf : ∃ r, IsUnit r ∧ ↑C r = ↑(expand F (p ^ n)) f
hn : n ≠ 0
hf2 : ↑derivative (↑(expand F (p ^ n)) f) = 0
⊢ IsUnit f

tactic: rw [eq_comm, expand_eq_C (pow_pos hp _)] at hrf
state_before: case intro.intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hn : n ≠ 0
hf2 : ↑derivative (↑(expand F (p ^ n)) f) = 0
r : F
hr : IsUnit r
hrf : ↑C r = ↑(expand F (p ^ n)) f
⊢ IsUnit f

tactic: rwa [hrf, isUnit_C]
state_before: case intro.intro
F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hn : n ≠ 0
hf2 : ↑derivative (↑(expand F (p ^ n)) f) = 0
r : F
hr : IsUnit r
hrf : f = ↑C r
⊢ IsUnit f

tactic: rw [derivative_expand, Nat.cast_pow, CharP.cast_eq_zero, zero_pow hn.bot_lt,
  MulZeroClass.zero_mul, MulZeroClass.mul_zero]
state_before: F : Type u
inst✝¹ : Field F
K : Type v
inst✝ : Field K
p : ℕ
HF : CharP F p
f : F[X]
n : ℕ
hp : 0 < p
hf : Separable (↑(expand F (p ^ n)) f)
hn : n ≠ 0
⊢ ↑derivative (↑(expand F (p ^ n)) f) = 0
Theorem: Finset.sum_choose_succ_mul
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: simpa only [nsmul_eq_mul] using sum_choose_succ_nsmul f n
state_before: R✝ : Type ?u.380823
M : Type ?u.380826
R : Type u_1
inst✝¹ : CommMonoid M
inst✝ : NonAssocSemiring R
f : ℕ → ℕ → R
n : ℕ
⊢ ∑ i in range (n + 2), ↑(Nat.choose (n + 1) i) * f i (n + 1 - i) =
    ∑ i in range (n + 1), ↑(Nat.choose n i) * f i (n + 1 - i) +
      ∑ i in range (n + 1), ↑(Nat.choose n i) * f (i + 1) (n - i)
Theorem: AlgebraicGeometry.StructureSheaf.comap_comp
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [comap_apply]
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
f : R →+* S
g : S →+* P
U : Opens ↑(PrimeSpectrum.Top R)
V : Opens ↑(PrimeSpectrum.Top S)
W : Opens ↑(PrimeSpectrum.Top P)
hUV : ∀ (p : ↑(PrimeSpectrum.Top S)), p ∈ V → ↑(PrimeSpectrum.comap f) p ∈ U
hVW : ∀ (p : ↑(PrimeSpectrum.Top P)), p ∈ W → ↑(PrimeSpectrum.comap g) p ∈ V
s : ↑((structureSheaf R).val.obj U.op)
p : { x // x ∈ W.op.unop }
⊢ ↑(↑(comap (RingHom.comp g f) U W
              (_ :
                ∀ (p : ↑(PrimeSpectrum.Top P)),
                  p ∈ W.carrier → ↑(PrimeSpectrum.comap f) (↑(PrimeSpectrum.comap g) p) ∈ U))
          s)
      p =
    ↑(↑(RingHom.comp (comap g V W hVW) (comap f U V hUV)) s) p

tactic: erw [Localization.localRingHom_comp _ (PrimeSpectrum.comap g p.1).asIdeal] <;>
rfl
state_before: R : Type u
inst✝² : CommRing R
S : Type u
inst✝¹ : CommRing S
P : Type u
inst✝ : CommRing P
f : R →+* S
g : S →+* P
U : Opens ↑(PrimeSpectrum.Top R)
V : Opens ↑(PrimeSpectrum.Top S)
W : Opens ↑(PrimeSpectrum.Top P)
hUV : ∀ (p : ↑(PrimeSpectrum.Top S)), p ∈ V → ↑(PrimeSpectrum.comap f) p ∈ U
hVW : ∀ (p : ↑(PrimeSpectrum.Top P)), p ∈ W → ↑(PrimeSpectrum.comap g) p ∈ V
s : ↑((structureSheaf R).val.obj U.op)
p : { x // x ∈ W.op.unop }
⊢ ↑(Localization.localRingHom (↑(PrimeSpectrum.comap (RingHom.comp g f)) ↑p).asIdeal (↑p).asIdeal (RingHom.comp g f)
          (_ :
            (↑(PrimeSpectrum.comap (RingHom.comp g f)) ↑p).asIdeal =
              (↑(PrimeSpectrum.comap (RingHom.comp g f)) ↑p).asIdeal))
      (↑s
        { val := ↑(PrimeSpectrum.comap (RingHom.comp g f)) ↑p,
          property := (_ : ↑(PrimeSpectrum.comap f) (↑(PrimeSpectrum.comap g) ↑p) ∈ U) }) =
    ↑(↑(RingHom.comp (comap g V W hVW) (comap f U V hUV)) s) p
Theorem: Num.land'_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: apply bitwise'_to_nat PosNum.land <;> intros <;> cases_type* Bool <;> rfl
state_before: α : Type ?u.607759
⊢ ∀ (m n : Num), ↑(land m n) = Nat.land' ↑m ↑n
Theorem: Set.bounded_lt_inter_lt
File: Mathlib/Order/Bounded.lean

tactic: rw [← bounded_le_iff_bounded_lt, ← bounded_le_iff_bounded_lt]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : LinearOrder α
inst✝ : NoMaxOrder α
a : α
⊢ Bounded (fun x x_1 => x < x_1) (s ∩ {b | a < b}) ↔ Bounded (fun x x_1 => x < x_1) s

tactic: exact bounded_le_inter_lt a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝¹ : LinearOrder α
inst✝ : NoMaxOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a < b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
Theorem: LinearMap.graph_eq_range_prod
File: Mathlib/LinearAlgebra/Prod.lean

tactic: ext x
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.605131
M₆ : Type ?u.605134
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
⊢ graph f = range (prod id f)

tactic: exact ⟨fun hx => ⟨x.1, Prod.ext rfl hx.symm⟩, fun ⟨u, hu⟩ => hu ▸ rfl⟩
state_before: case h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.605131
M₆ : Type ?u.605134
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : AddCommGroup M₃
inst✝⁴ : AddCommGroup M₄
inst✝³ : Module R M
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M₄
f : M →ₗ[R] M₂
g : M₃ →ₗ[R] M₄
x : M × M₂
⊢ x ∈ graph f ↔ x ∈ range (prod id f)
Theorem: Set.image_op_inv
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: simp_rw [← image_inv, Function.Semiconj.set_image op_inv s]
state_before: F : Type ?u.8077
α : Type u_1
β : Type ?u.8083
γ : Type ?u.8086
inst✝ : InvolutiveInv α
s t : Set α
a : α
⊢ op '' s⁻¹ = (op '' s)⁻¹
Theorem: Basis.orientation_adjustToOrientation
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: rw [adjustToOrientation]
state_before: R : Type u_1
inst✝⁶ : LinearOrderedCommRing R
M : Type u_3
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ Basis.orientation (adjustToOrientation e x) = x

tactic: split_ifs with h
state_before: R : Type u_1
inst✝⁶ : LinearOrderedCommRing R
M : Type u_3
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
⊢ Basis.orientation
      (if Basis.orientation e = x then e else unitsSMul e (Function.update 1 (Classical.arbitrary ι) (-1))) =
    x

tactic: exact h
state_before: case inl
R : Type u_1
inst✝⁶ : LinearOrderedCommRing R
M : Type u_3
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : Basis.orientation e = x
⊢ Basis.orientation e = x

tactic: rw [orientation_neg_single, eq_comm, ← orientation_ne_iff_eq_neg, ne_comm]
state_before: case inr
R : Type u_1
inst✝⁶ : LinearOrderedCommRing R
M : Type u_3
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : ¬Basis.orientation e = x
⊢ Basis.orientation (unitsSMul e (Function.update 1 (Classical.arbitrary ι) (-1))) = x

tactic: exact h
state_before: case inr
R : Type u_1
inst✝⁶ : LinearOrderedCommRing R
M : Type u_3
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
h : ¬Basis.orientation e = x
⊢ Basis.orientation e ≠ x
Theorem: omegaLimit_iUnion
File: Mathlib/Dynamics/OmegaLimit.lean

tactic: rw [iUnion_subset_iff]
state_before: τ : Type u_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
p : ι → Set α
⊢ (⋃ (i : ι), ω f ϕ (p i)) ⊆ ω f ϕ (⋃ (i : ι), p i)

tactic: exact fun i ↦ omegaLimit_mono_right _ _ (subset_iUnion _ _)
state_before: τ : Type u_4
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : TopologicalSpace β
f : Filter τ
ϕ : τ → α → β
s s₁ s₂ : Set α
p : ι → Set α
⊢ ∀ (i : ι), ω f ϕ (p i) ⊆ ω f ϕ (⋃ (i : ι), p i)
Theorem: bernoulli_one
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: norm_num
state_before: A : Type ?u.633621
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli 1 = -1 / 2

tactic: simp [bernoulli]
state_before: A : Type ?u.633621
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
⊢ bernoulli 1 = -(1 / 2)
Theorem: one_div_neg_one_eq_neg_one
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [neg_mul_neg, one_mul]
state_before: α : Type ?u.20702
β : Type ?u.20705
K : Type u_1
inst✝¹ : DivisionMonoid K
inst✝ : HasDistribNeg K
a b : K
⊢ -1 * -1 = 1
Theorem: ENNReal.add_iInf
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [add_comm, iInf_add]
state_before: α : Type ?u.857372
β : Type ?u.857375
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ a + iInf f = ⨅ (b : ι), a + f b

tactic: simp [add_comm]
state_before: α : Type ?u.857372
β : Type ?u.857375
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
ι : Sort u_1
f g : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ (⨅ (i : ι), f i + a) = ⨅ (b : ι), a + f b
Theorem: Nat.lor'_zero
File: Mathlib/Data/Nat/Bitwise.lean

tactic: simp [lor']
state_before: n : ℕ
⊢ lor' n 0 = n