tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Abelian.Functor.exact_of_map_projectiveResolution
File: Mathlib/CategoryTheory/Abelian/LeftDerived.lean

tactic: simp only [Iso.symm_hom, HomologicalComplex.xPrevIso_comp_dTo]
state_before: C : Type u
inst✝⁵ : Category C
D : Type u
inst✝⁴ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝³ : Abelian C
inst✝² : Abelian D
inst✝¹ : Functor.Additive F
P : ProjectiveResolution X
inst✝ : PreservesFiniteColimits F
⊢ (HomologicalComplex.xPrevIso ((mapHomologicalComplex F (ComplexShape.down ℕ)).obj P.complex)
            (_ : 0 + 1 = 0 + 1)).symm.hom ≫
      HomologicalComplex.dTo ((mapHomologicalComplex F (ComplexShape.down ℕ)).obj P.complex) 0 =
    F.map (HomologicalComplex.d P.complex 1 0) ≫ (Iso.refl (F.obj (HomologicalComplex.X P.complex 0))).hom

tactic: simp only [mapHomologicalComplex_obj_d, Iso.refl_hom, Category.comp_id]
state_before: C : Type u
inst✝⁵ : Category C
D : Type u
inst✝⁴ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝³ : Abelian C
inst✝² : Abelian D
inst✝¹ : Functor.Additive F
P : ProjectiveResolution X
inst✝ : PreservesFiniteColimits F
⊢ HomologicalComplex.d ((mapHomologicalComplex F (ComplexShape.down ℕ)).obj P.complex) (0 + 1) 0 =
    F.map (HomologicalComplex.d P.complex 1 0) ≫ (Iso.refl (F.obj (HomologicalComplex.X P.complex 0))).hom

tactic: rfl
state_before: C : Type u
inst✝⁵ : Category C
D : Type u
inst✝⁴ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝³ : Abelian C
inst✝² : Abelian D
inst✝¹ : Functor.Additive F
P : ProjectiveResolution X
inst✝ : PreservesFiniteColimits F
⊢ F.map (HomologicalComplex.d P.complex (0 + 1) 0) = F.map (HomologicalComplex.d P.complex 1 0)

tactic: simp
state_before: C : Type u
inst✝⁵ : Category C
D : Type u
inst✝⁴ : Category D
F : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝³ : Abelian C
inst✝² : Abelian D
inst✝¹ : Functor.Additive F
P : ProjectiveResolution X
inst✝ : PreservesFiniteColimits F
⊢ (Iso.refl (F.obj (HomologicalComplex.X P.complex 0))).hom ≫ F.map (HomologicalComplex.Hom.f P.π 0) =
    F.map (HomologicalComplex.Hom.f P.π 0) ≫
      (Iso.refl (F.obj (HomologicalComplex.X ((ChainComplex.single₀ C).obj X) 0))).hom
Theorem: String.extract.go₂_add_right_cancel
File: Std/Data/String/Lemmas.lean

tactic: apply utf8InductionOn s ⟨i⟩ ⟨e⟩ (motive := fun s i =>
  go₂ s ⟨i.byteIdx + n⟩ ⟨e + n⟩ = go₂ s i ⟨e⟩) <;> simp [go₂]
state_before: s : List Char
i e n : Nat
⊢ go₂ s { byteIdx := i + n } { byteIdx := e + n } = go₂ s { byteIdx := i } { byteIdx := e }

tactic: intro c cs ⟨i⟩ h ih
state_before: case ind
s : List Char
i e n : Nat
⊢ ∀ (c : Char) (cs : List Char) (i : Pos),
    ¬i = { byteIdx := e } →
      go₂ cs { byteIdx := i.byteIdx + csize c + n } { byteIdx := e + n } = go₂ cs (i + c) { byteIdx := e } →
        (if { byteIdx := i.byteIdx + n } = { byteIdx := e + n } then []
          else c :: go₂ cs ({ byteIdx := i.byteIdx + n } + c) { byteIdx := e + n }) =
          if i = { byteIdx := e } then [] else c :: go₂ cs (i + c) { byteIdx := e }

tactic: simp [Pos.ext_iff, Pos.addChar_eq] at h ⊢
state_before: case ind
s : List Char
i✝ e n : Nat
c : Char
cs : List Char
i : Nat
h : ¬{ byteIdx := i } = { byteIdx := e }
ih :
  go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } =
    go₂ cs ({ byteIdx := i } + c) { byteIdx := e }
⊢ (if { byteIdx := { byteIdx := i }.byteIdx + n } = { byteIdx := e + n } then []
    else c :: go₂ cs ({ byteIdx := { byteIdx := i }.byteIdx + n } + c) { byteIdx := e + n }) =
    if { byteIdx := i } = { byteIdx := e } then [] else c :: go₂ cs ({ byteIdx := i } + c) { byteIdx := e }

tactic: simp [Nat.add_right_cancel_iff, h]
state_before: case ind
s : List Char
i✝ e n : Nat
c : Char
cs : List Char
i : Nat
ih :
  go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } =
    go₂ cs ({ byteIdx := i } + c) { byteIdx := e }
h : ¬i = e
⊢ (if i + n = e + n then [] else c :: go₂ cs { byteIdx := i + n + csize c } { byteIdx := e + n }) =
    if i = e then [] else c :: go₂ cs { byteIdx := i + csize c } { byteIdx := e }

tactic: rw [Nat.add_right_comm]
state_before: case ind
s : List Char
i✝ e n : Nat
c : Char
cs : List Char
i : Nat
ih :
  go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } =
    go₂ cs ({ byteIdx := i } + c) { byteIdx := e }
h : ¬i = e
⊢ go₂ cs { byteIdx := i + n + csize c } { byteIdx := e + n } = go₂ cs { byteIdx := i + csize c } { byteIdx := e }

tactic: exact ih
state_before: case ind
s : List Char
i✝ e n : Nat
c : Char
cs : List Char
i : Nat
ih :
  go₂ cs { byteIdx := { byteIdx := i }.byteIdx + csize c + n } { byteIdx := e + n } =
    go₂ cs ({ byteIdx := i } + c) { byteIdx := e }
h : ¬i = e
⊢ go₂ cs { byteIdx := i + csize c + n } { byteIdx := e + n } = go₂ cs { byteIdx := i + csize c } { byteIdx := e }
Theorem: MeasurableSpace.generateFrom_singleton_univ
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.21280
γ : Type ?u.21283
δ : Type ?u.21286
δ' : Type ?u.21289
ι : Sort ?u.21292
s t u : Set α
⊢ ∀ (t : Set α), t ∈ {univ} → MeasurableSet t
Theorem: Cardinal.toNat_le_iff_le_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← natCast_le, cast_toNat_of_lt_aleph0 hc, cast_toNat_of_lt_aleph0 hd]
state_before: α β : Type u
c d : Cardinal
hc : c < ℵ₀
hd : d < ℵ₀
⊢ ↑toNat c ≤ ↑toNat d ↔ c ≤ d
Theorem: Nat.four_pow_lt_mul_centralBinom
File: Mathlib/Data/Nat/Choose/Central.lean

tactic: induction' n using Nat.strong_induction_on with n IH
state_before: n : ℕ
n_big : 4 ≤ n
⊢ 4 ^ n < n * centralBinom n

tactic: rcases lt_trichotomy n 4 with (hn | rfl | hn)
state_before: case h
n✝ : ℕ
n_big✝ : 4 ≤ n✝
n : ℕ
IH : ∀ (m : ℕ), m < n → 4 ≤ m → 4 ^ m < m * centralBinom m
n_big : 4 ≤ n
⊢ 4 ^ n < n * centralBinom n

tactic: obtain ⟨n, rfl⟩ : ∃ m, n = m + 1 := Nat.exists_eq_succ_of_ne_zero (Nat.not_eq_zero_of_lt hn)
state_before: case h.inr.inr
n✝ : ℕ
n_big✝ : 4 ≤ n✝
n : ℕ
IH : ∀ (m : ℕ), m < n → 4 ≤ m → 4 ^ m < m * centralBinom m
n_big : 4 ≤ n
hn : 4 < n
⊢ 4 ^ n < n * centralBinom n

tactic: calc
  4 ^ (n + 1) < 4 * (n * centralBinom n) := lt_of_eq_of_lt (pow_succ'' n 4) $
    (mul_lt_mul_left <| zero_lt_four' ℕ).mpr (IH n n.lt_succ_self (Nat.le_of_lt_succ hn))
  _ ≤ 2 * (2 * n + 1) * centralBinom n := by rw [← mul_assoc]; linarith
  _ = (n + 1) * centralBinom (n + 1) := (succ_mul_centralBinom_succ n).symm
state_before: case h.inr.inr.intro
n✝ : ℕ
n_big✝ : 4 ≤ n✝
n : ℕ
IH : ∀ (m : ℕ), m < n + 1 → 4 ≤ m → 4 ^ m < m * centralBinom m
n_big : 4 ≤ n + 1
hn : 4 < n + 1
⊢ 4 ^ (n + 1) < (n + 1) * centralBinom (n + 1)

tactic: clear IH
state_before: case h.inl
n✝ : ℕ
n_big✝ : 4 ≤ n✝
n : ℕ
IH : ∀ (m : ℕ), m < n → 4 ≤ m → 4 ^ m < m * centralBinom m
n_big : 4 ≤ n
hn : n < 4
⊢ 4 ^ n < n * centralBinom n

tactic: exact False.elim ((not_lt.2 n_big) hn)
state_before: case h.inl
n✝ : ℕ
n_big✝ : 4 ≤ n✝
n : ℕ
n_big : 4 ≤ n
hn : n < 4
⊢ 4 ^ n < n * centralBinom n

tactic: norm_num [centralBinom, choose]
state_before: case h.inr.inl
n : ℕ
n_big✝ : 4 ≤ n
IH : ∀ (m : ℕ), m < 4 → 4 ≤ m → 4 ^ m < m * centralBinom m
n_big : 4 ≤ 4
⊢ 4 ^ 4 < 4 * centralBinom 4

tactic: rw [← mul_assoc]
state_before: n✝ : ℕ
n_big✝ : 4 ≤ n✝
n : ℕ
IH : ∀ (m : ℕ), m < n + 1 → 4 ≤ m → 4 ^ m < m * centralBinom m
n_big : 4 ≤ n + 1
hn : 4 < n + 1
⊢ 4 * (n * centralBinom n) ≤ 2 * (2 * n + 1) * centralBinom n

tactic: linarith
state_before: n✝ : ℕ
n_big✝ : 4 ≤ n✝
n : ℕ
IH : ∀ (m : ℕ), m < n + 1 → 4 ≤ m → 4 ^ m < m * centralBinom m
n_big : 4 ≤ n + 1
hn : 4 < n + 1
⊢ 4 * n * centralBinom n ≤ 2 * (2 * n + 1) * centralBinom n
Theorem: eventually_mem_of_tendsto_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp_rw [nhdsWithin_eq, tendsto_iInf, mem_setOf_eq, tendsto_principal, mem_inter_iff,
  eventually_and] at h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.188629
δ : Type ?u.188632
inst✝ : TopologicalSpace α
f : β → α
a : α
s : Set α
l : Filter β
h : Tendsto f l (𝓝[s] a)
⊢ ∀ᶠ (i : β) in l, f i ∈ s

tactic: exact (h univ ⟨mem_univ a, isOpen_univ⟩).2
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.188629
δ : Type ?u.188632
inst✝ : TopologicalSpace α
f : β → α
a : α
s : Set α
l : Filter β
h : ∀ (i : Set α), a ∈ i ∧ IsOpen i → (∀ᶠ (x : β) in l, f x ∈ i) ∧ ∀ᶠ (x : β) in l, f x ∈ s
⊢ ∀ᶠ (i : β) in l, f i ∈ s
Theorem: Ordinal.nat_cast_mul
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp
state_before: m : ℕ
⊢ ↑(m * 0) = ↑m * ↑0

tactic: rw [Nat.mul_succ, Nat.cast_add, nat_cast_mul m n, Nat.cast_succ, mul_add_one]
state_before: m n : ℕ
⊢ ↑(m * (n + 1)) = ↑m * ↑(n + 1)
Theorem: WithZeroTopology.tendsto_zero
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

tactic: simp [nhds_zero]
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
⊢ Tendsto f l (𝓝 0) ↔ ∀ (γ₀ : Γ₀), γ₀ ≠ 0 → ∀ᶠ (x : α) in l, f x < γ₀
Theorem: MvPowerSeries.C_inv
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rcases eq_or_ne r 0 with (rfl | hr)
state_before: σ : Type u_1
R : Type ?u.1971115
k : Type u_2
inst✝ : Field k
r : k
⊢ (↑(C σ k) r)⁻¹ = ↑(C σ k) r⁻¹

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.1971115
k : Type u_2
inst✝ : Field k
r : k
hr : r ≠ 0
⊢ (↑(C σ k) r)⁻¹ = ↑(C σ k) r⁻¹

tactic: simpa using hr
state_before: case inr
σ : Type u_1
R : Type ?u.1971115
k : Type u_2
inst✝ : Field k
r : k
hr : r ≠ 0
⊢ ↑(constantCoeff σ k) (↑(C σ k) r) ≠ 0

tactic: simp
state_before: case inl
σ : Type u_1
R : Type ?u.1971115
k : Type u_2
inst✝ : Field k
⊢ (↑(C σ k) 0)⁻¹ = ↑(C σ k) 0⁻¹
Theorem: padicNorm.of_int
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [hz, zero_le_one]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : z = 0
⊢ padicNorm p ↑z ≤ 1

tactic: unfold padicNorm
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ padicNorm p ↑z ≤ 1

tactic: rw [if_neg _]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ (if ↑z = 0 then 0 else ↑p ^ (-padicValRat p ↑z)) ≤ 1

tactic: exact_mod_cast hz
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ ¬↑z = 0

tactic: refine' zpow_le_one_of_nonpos _ _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ ↑p ^ (-padicValRat p ↑z) ≤ 1

tactic: exact_mod_cast le_of_lt hp.1.one_lt
state_before: case refine'_1
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ 1 ≤ ↑p

tactic: rw [padicValRat.of_int, neg_nonpos]
state_before: case refine'_2
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ -padicValRat p ↑z ≤ 0

tactic: norm_cast
state_before: case refine'_2
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ 0 ≤ ↑(padicValInt p z)

tactic: simp
state_before: case refine'_2
p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
hz : ¬z = 0
⊢ 0 ≤ padicValInt p z
Theorem: ContDiffAt.rpow_const_of_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: rw [← contDiffWithinAt_univ] at *
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : E → ℝ
f' g' : E →L[ℝ] ℝ
x : E
s : Set E
c p : ℝ
n : ℕ∞
m : ℕ
hf : ContDiffAt ℝ (↑m) f x
h : ↑m ≤ p
⊢ ContDiffAt ℝ (↑m) (fun x => f x ^ p) x

tactic: exact hf.rpow_const_of_le h
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
f g : E → ℝ
f' g' : E →L[ℝ] ℝ
x : E
s : Set E
c p : ℝ
n : ℕ∞
m : ℕ
hf : ContDiffWithinAt ℝ (↑m) f Set.univ x
h : ↑m ≤ p
⊢ ContDiffWithinAt ℝ (↑m) (fun x => f x ^ p) Set.univ x
Theorem: Ordinal.one_nadd
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: rw [nadd_comm, nadd_one]
state_before: a b c : Ordinal
⊢ 1 ♯ a = succ a
Theorem: MeasureTheory.Measure.MutuallySingular.sum_left
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

tactic: refine' ⟨fun h i => h.mono (le_sum _ _) le_rfl, fun H => _⟩
state_before: α : Type u_2
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ : Measure α
ι : Type u_1
inst✝ : Countable ι
μ : ι → Measure α
⊢ sum μ ⟂ₘ ν ↔ ∀ (i : ι), μ i ⟂ₘ ν

tactic: choose s hsm hsμ hsν using H
state_before: α : Type u_2
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ : Measure α
ι : Type u_1
inst✝ : Countable ι
μ : ι → Measure α
H : ∀ (i : ι), μ i ⟂ₘ ν
⊢ sum μ ⟂ₘ ν

tactic: refine' ⟨⋂ i, s i, MeasurableSet.iInter hsm, _, _⟩
state_before: α : Type u_2
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ : Measure α
ι : Type u_1
inst✝ : Countable ι
μ : ι → Measure α
s : ι → Set α
hsm : ∀ (i : ι), MeasurableSet (s i)
hsμ : ∀ (i : ι), ↑↑(μ i) (s i) = 0
hsν : ∀ (i : ι), ↑↑ν (s iᶜ) = 0
⊢ sum μ ⟂ₘ ν

tactic: rw [sum_apply _ (MeasurableSet.iInter hsm), ENNReal.tsum_eq_zero]
state_before: case refine'_1
α : Type u_2
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ : Measure α
ι : Type u_1
inst✝ : Countable ι
μ : ι → Measure α
s : ι → Set α
hsm : ∀ (i : ι), MeasurableSet (s i)
hsμ : ∀ (i : ι), ↑↑(μ i) (s i) = 0
hsν : ∀ (i : ι), ↑↑ν (s iᶜ) = 0
⊢ ↑↑(sum μ) (⋂ (i : ι), s i) = 0

tactic: exact fun i => measure_mono_null (iInter_subset _ _) (hsμ i)
state_before: case refine'_1
α : Type u_2
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ : Measure α
ι : Type u_1
inst✝ : Countable ι
μ : ι → Measure α
s : ι → Set α
hsm : ∀ (i : ι), MeasurableSet (s i)
hsμ : ∀ (i : ι), ↑↑(μ i) (s i) = 0
hsν : ∀ (i : ι), ↑↑ν (s iᶜ) = 0
⊢ ∀ (i : ι), ↑↑(μ i) (⋂ (b : ι), s b) = 0

tactic: rwa [compl_iInter, measure_iUnion_null_iff]
state_before: case refine'_2
α : Type u_2
m0 : MeasurableSpace α
μ✝ μ₁ μ₂ ν ν₁ ν₂ : Measure α
ι : Type u_1
inst✝ : Countable ι
μ : ι → Measure α
s : ι → Set α
hsm : ∀ (i : ι), MeasurableSet (s i)
hsμ : ∀ (i : ι), ↑↑(μ i) (s i) = 0
hsν : ∀ (i : ι), ↑↑ν (s iᶜ) = 0
⊢ ↑↑ν ((⋂ (i : ι), s i)ᶜ) = 0
Theorem: tendsto_inv_atTop_zero'
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: refine (atTop_basis.tendsto_iff ⟨fun s => mem_nhdsWithin_Ioi_iff_exists_Ioc_subset⟩).2 ?_
state_before: 𝕜 : Type u_1
α : Type ?u.26472
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
⊢ Tendsto (fun r => r⁻¹) atTop (𝓝[Ioi 0] 0)

tactic: refine fun b hb => ⟨b⁻¹, trivial, fun x hx => ?_⟩
state_before: 𝕜 : Type u_1
α : Type ?u.26472
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
⊢ ∀ (ib : 𝕜), ib ∈ Ioi 0 → ∃ ia, True ∧ ∀ (x : 𝕜), x ∈ Ici ia → x⁻¹ ∈ Ioc 0 ib

tactic: have : 0 < x := lt_of_lt_of_le (inv_pos.2 hb) hx
state_before: 𝕜 : Type u_1
α : Type ?u.26472
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
b : 𝕜
hb : b ∈ Ioi 0
x : 𝕜
hx : x ∈ Ici b⁻¹
⊢ x⁻¹ ∈ Ioc 0 b

tactic: exact ⟨inv_pos.2 this, (inv_le this hb).2 hx⟩
state_before: 𝕜 : Type u_1
α : Type ?u.26472
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
b : 𝕜
hb : b ∈ Ioi 0
x : 𝕜
hx : x ∈ Ici b⁻¹
this : 0 < x
⊢ x⁻¹ ∈ Ioc 0 b
Theorem: Polynomial.natDegree_pow_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: induction' n with i hi
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.695996
p : R[X]
n : ℕ
⊢ natDegree (p ^ n) ≤ n * natDegree p

tactic: simp
state_before: case zero
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.695996
p : R[X]
⊢ natDegree (p ^ Nat.zero) ≤ Nat.zero * natDegree p

tactic: rw [pow_succ, Nat.succ_mul, add_comm]
state_before: case succ
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.695996
p : R[X]
i : ℕ
hi : natDegree (p ^ i) ≤ i * natDegree p
⊢ natDegree (p ^ Nat.succ i) ≤ Nat.succ i * natDegree p

tactic: apply le_trans natDegree_mul_le
state_before: case succ
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.695996
p : R[X]
i : ℕ
hi : natDegree (p ^ i) ≤ i * natDegree p
⊢ natDegree (p * p ^ i) ≤ natDegree p + i * natDegree p

tactic: exact add_le_add_left hi _
state_before: case succ
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q : R[X]
ι : Type ?u.695996
p : R[X]
i : ℕ
hi : natDegree (p ^ i) ≤ i * natDegree p
⊢ natDegree p + natDegree (p ^ i) ≤ natDegree p + i * natDegree p
Theorem: Polynomial.not_dvd_of_natDegree_lt
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: by_contra hcontra
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h0 : q ≠ 0
hl : natDegree q < natDegree p
⊢ ¬p ∣ q

tactic: exact h0 (eq_zero_of_dvd_of_natDegree_lt hcontra hl)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p✝ q✝ p q : R[X]
h0 : q ≠ 0
hl : natDegree q < natDegree p
hcontra : p ∣ q
⊢ False
Theorem: one_div_le_neg_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [one_div_neg_one_eq_neg_one] at this
state_before: ι : Type ?u.182424
α : Type u_1
β : Type ?u.182430
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h1 : a < 0
h2 : -1 ≤ a
this : 1 / a ≤ 1 / -1
⊢ 1 / a ≤ -1
Theorem: Finsupp.card_Ioc
File: Mathlib/Data/Finsupp/Interval.lean

tactic: rw [card_Ioc_eq_card_Icc_sub_one, card_Icc]
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : Zero α
inst✝ : LocallyFiniteOrder α
f g : ι →₀ α
⊢ card (Ioc f g) = ∏ i in f.support ∪ g.support, card (Icc (↑f i) (↑g i)) - 1
Theorem: FirstOrder.Language.Term.realize_functions_apply₁
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Functions.apply₁, Term.realize]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.5630
P : Type ?u.5633
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 1
t : Term L α
v : α → M
⊢ realize v (Functions.apply₁ f t) = funMap f ![realize v t]

tactic: refine' congr rfl (funext fun i => _)
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.5630
P : Type ?u.5633
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 1
t : Term L α
v : α → M
⊢ (funMap f fun i => realize v (Matrix.vecCons t ![] i)) = funMap f ![realize v t]

tactic: simp only [Matrix.cons_val_fin_one]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.5630
P : Type ?u.5633
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
f : Functions L 1
t : Term L α
v : α → M
i : Fin 1
⊢ realize v (Matrix.vecCons t ![] i) = Matrix.vecCons (realize v t) ![] i
Theorem: Polynomial.divByMonic_mul_pow_rootMultiplicity_eq
File: Mathlib/Data/Polynomial/Div.lean

tactic: have : Monic ((X - C a) ^ rootMultiplicity a p) := (monic_X_sub_C _).pow _
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
⊢ p /ₘ (X - ↑C a) ^ rootMultiplicity a p * (X - ↑C a) ^ rootMultiplicity a p = p

tactic: conv_rhs =>
    rw [← modByMonic_add_div p this,
      (dvd_iff_modByMonic_eq_zero this).2 (pow_rootMultiplicity_dvd _ _)]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
this : Monic ((X - ↑C a) ^ rootMultiplicity a p)
⊢ p /ₘ (X - ↑C a) ^ rootMultiplicity a p * (X - ↑C a) ^ rootMultiplicity a p = p

tactic: simp [mul_comm]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a✝ b : R
n : ℕ
inst✝ : CommRing R
p✝ q p : R[X]
a : R
this : Monic ((X - ↑C a) ^ rootMultiplicity a p)
⊢ p /ₘ (X - ↑C a) ^ rootMultiplicity a p * (X - ↑C a) ^ rootMultiplicity a p =
    0 + (X - ↑C a) ^ rootMultiplicity a p * (p /ₘ (X - ↑C a) ^ rootMultiplicity a p)
Theorem: isGLB_empty_iff
File: Mathlib/Order/Bounds/Basic.lean

tactic: simp [IsGLB]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
a b : α
⊢ IsGLB ∅ a ↔ IsTop a
Theorem: min_lt_min_right_iff
File: Mathlib/Order/MinMax.lean

tactic: simp_rw [min_comm a, min_lt_min_left_iff]
state_before: α : Type u
β : Type v
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a b c d : α
⊢ min a b < min a c ↔ b < c ∧ b < a
Theorem: Real.Angle.toReal_coe_eq_self_sub_two_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: convert @toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff θ 1 <;> norm_num
state_before: θ : ℝ
⊢ toReal ↑θ = θ - 2 * π ↔ θ ∈ Set.Ioc π (3 * π)
Theorem: ENNReal.mul_ne_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [lt_top_iff_ne_top] using mul_lt_top
state_before: α : Type ?u.91147
β : Type ?u.91150
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a ≠ ⊤ → b ≠ ⊤ → a * b ≠ ⊤
Theorem: Turing.ToPartrec.Code.tail_eval
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [eval]
state_before: ⊢ eval tail = fun v => pure (List.tail v)
Theorem: ContinuousMap.homotopic_const_iff
File: Mathlib/Topology/Homotopy/Path.lean

tactic: inhabit Y
state_before: X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
⊢ Homotopic (const Y x₀) (const Y x₁) ↔ Joined x₀ x₁

tactic: refine ⟨fun ⟨H⟩ ↦ ⟨⟨(H.toContinuousMap.comp .prodSwap).curry default, ?_, ?_⟩⟩,
  fun ⟨p⟩ ↦ ⟨p.toHomotopyConst⟩⟩ <;> simp
state_before: X : Type u
Y : Type v
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
inst✝ : Nonempty Y
inhabited_h : Inhabited Y
⊢ Homotopic (const Y x₀) (const Y x₁) ↔ Joined x₀ x₁
Theorem: norm_map_one_of_pow_eq_one
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: rw [← pow_left_inj, ← norm_pow, ← map_pow, h, map_one, norm_one, one_pow]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.289026
ι : Type ?u.289029
inst✝¹ : NormedDivisionRing α
inst✝ : Monoid β
φ : β →* α
x : β
k : ℕ+
h : x ^ ↑k = 1
⊢ ‖↑φ x‖ = 1

tactic: exacts [norm_nonneg _, zero_le_one, k.pos]
state_before: case Hxpos
α : Type u_2
β : Type u_1
γ : Type ?u.289026
ι : Type ?u.289029
inst✝¹ : NormedDivisionRing α
inst✝ : Monoid β
φ : β →* α
x : β
k : ℕ+
h : x ^ ↑k = 1
⊢ 0 ≤ ‖↑φ x‖

case Hypos
α : Type u_2
β : Type u_1
γ : Type ?u.289026
ι : Type ?u.289029
inst✝¹ : NormedDivisionRing α
inst✝ : Monoid β
φ : β →* α
x : β
k : ℕ+
h : x ^ ↑k = 1
⊢ 0 ≤ 1

case Hnpos
α : Type u_2
β : Type u_1
γ : Type ?u.289026
ι : Type ?u.289029
inst✝¹ : NormedDivisionRing α
inst✝ : Monoid β
φ : β →* α
x : β
k : ℕ+
h : x ^ ↑k = 1
⊢ 0 < ↑k
Theorem: Finset.insertNone_eraseNone
File: Mathlib/Data/Finset/Option.lean

tactic: ext (_ | x) <;> simp
state_before: α : Type u_1
β : Type ?u.15322
inst✝ : DecidableEq (Option α)
s : Finset (Option α)
⊢ ↑insertNone (↑eraseNone s) = insert none s
Theorem: Subgroup.index_iInf_le
File: Mathlib/GroupTheory/Index.lean

tactic: simp_rw [← relindex_top_right, relindex_iInf_le]
state_before: G : Type u_2
inst✝¹ : Group G
H K L : Subgroup G
ι : Type u_1
inst✝ : Fintype ι
f : ι → Subgroup G
⊢ index (⨅ (i : ι), f i) ≤ ∏ i : ι, index (f i)
Theorem: NormedRing.inverse_one_sub_nth_order
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: rwa [← dist_zero_right]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
n : ℕ
t : R
ht : dist t 0 < 1
⊢ ‖t‖ < 1
Theorem: Complex.edist_of_re_eq
File: Mathlib/Analysis/Complex/Basic.lean

tactic: rw [edist_nndist, edist_nndist, nndist_of_re_eq h]
state_before: E : Type ?u.13430
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
z w : ℂ
h : z.re = w.re
⊢ edist z w = edist z.im w.im