tasksource/leandojo huggingface dataset:
Theorem: toIocMod_apply_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIocMod_eq_iff hp, Set.right_mem_Ioc]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ toIocMod hp a (a + p) = a + p

tactic: exact ⟨lt_add_of_pos_right _ hp, 0, by simp⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a < a + p ∧ ∃ z, a + p = a + p + z • p

tactic: simp
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a + p = a + p + 0 • p
Theorem: TFAE_mem_nhdsWithin_Iio
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [exists_prop, OrderDual.exists, dual_Ioi, dual_Ioc, dual_Ioo] using
  TFAE_mem_nhdsWithin_Ioi h.dual (ofDual ⁻¹' s)
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a b : α
h : a < b
s : Set α
⊢ TFAE
    [s ∈ 𝓝[Iio b] b, s ∈ 𝓝[Ico a b] b, s ∈ 𝓝[Ioo a b] b, ∃ l, l ∈ Ico a b ∧ Ioo l b ⊆ s, ∃ l, l ∈ Iio b ∧ Ioo l b ⊆ s]
Theorem: FirstOrder.Language.Theory.SemanticallyEquivalent.refl
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: rw [BoundedFormula.realize_iff]
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : BoundedFormula L α n
M : ModelType T
v : α → ↑M
xs : Fin n → ↑M
⊢ BoundedFormula.Realize (φ ⇔ φ) v xs
Theorem: prod_mem_nhds_iff
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_prod_eq, prod_mem_prod_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.38336
δ : Type ?u.38339
ε : Type ?u.38342
ζ : Type ?u.38345
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set α
t : Set β
a : α
b : β
⊢ s ×ˢ t ∈ 𝓝 (a, b) ↔ s ∈ 𝓝 a ∧ t ∈ 𝓝 b
Theorem: EuclideanDomain.mod_eq_sub_mul_div
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: rw [div_add_mod]
state_before: R✝ : Type u
inst✝¹ : EuclideanDomain R✝
R : Type u_1
inst✝ : EuclideanDomain R
a b : R
⊢ b * (a / b) + a % b - b * (a / b) = a - b * (a / b)
Theorem: NNReal.rpow_one_div_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← rpow_eq_rpow_iff hz, rpow_self_rpow_inv hz]
state_before: x y : ℝ≥0
z : ℝ
hz : z ≠ 0
⊢ x ^ (1 / z) = y ↔ x = y ^ z
Theorem: Set.exists_max_image
File: Mathlib/Data/Set/Finite.lean

tactic: simpa only [exists_prop, Finite.mem_toFinset] using
  h1.toFinset.exists_max_image f ⟨x, h1.mem_toFinset.2 hx⟩
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : LinearOrder β
s : Set α
f : α → β
h1 : Set.Finite s
x : α
hx : x ∈ s
⊢ ∃ a, a ∈ s ∧ ∀ (b : α), b ∈ s → f b ≤ f a
Theorem: hyperoperation_one
File: Mathlib/Data/Nat/Hyperoperation.lean

tactic: ext (m k)
state_before: ⊢ hyperoperation 1 = fun x x_1 => x + x_1

tactic: induction' k with bn bih
state_before: case h.h
m k : ℕ
⊢ hyperoperation 1 m k = m + k

tactic: rw [Nat.add_zero m, hyperoperation]
state_before: case h.h.zero
m : ℕ
⊢ hyperoperation 1 m Nat.zero = m + Nat.zero

tactic: rw [hyperoperation_recursion, bih, hyperoperation_zero]
state_before: case h.h.succ
m bn : ℕ
bih : hyperoperation 1 m bn = m + bn
⊢ hyperoperation 1 m (Nat.succ bn) = m + Nat.succ bn

tactic: exact Nat.add_assoc m bn 1
state_before: case h.h.succ
m bn : ℕ
bih : hyperoperation 1 m bn = m + bn
⊢ Nat.succ (m + bn) = m + Nat.succ bn
Theorem: ModelWithCorners.symm_map_nhdsWithin_image
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rw [← I.map_nhdsWithin_eq, map_map, I.symm_comp_self, map_id]
state_before: 𝕜 : Type u_3
inst✝³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
H : Type u_1
inst✝ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
x : H
s : Set H
⊢ map (↑(ModelWithCorners.symm I)) (𝓝[↑I '' s] ↑I x) = 𝓝[s] x
Theorem: MeasureTheory.Measure.add_haar_image_homothety
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: simp only [← image_smul, image_image, ← sub_eq_add_neg]
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.1956140
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
s : Set E
⊢ ↑↑μ (↑(AffineMap.homothety x r) '' s) = ↑↑μ ((fun y => y + x) '' (r • (fun y => y + -x) '' s))

tactic: rfl
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.1956140
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
s : Set E
⊢ ↑↑μ ((fun a => ↑(AffineMap.homothety x r) a) '' s) = ↑↑μ ((fun x_1 => r • (x_1 - x) + x) '' s)

tactic: simp only [image_add_right, measure_preimage_add_right, add_haar_smul]
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.1956140
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
s : Set E
⊢ ↑↑μ ((fun y => y + x) '' (r • (fun y => y + -x) '' s)) = ENNReal.ofReal (abs (r ^ finrank ℝ E)) * ↑↑μ s
Theorem: Finpartition.mem_bind
File: Mathlib/Order/Partition/Finpartition.lean

tactic: rw [bind, mem_biUnion]
state_before: α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q : (i : α) → i ∈ P.parts → Finpartition i
⊢ b ∈ (bind P Q).parts ↔ ∃ A hA, b ∈ (Q A hA).parts

tactic: constructor
state_before: α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q : (i : α) → i ∈ P.parts → Finpartition i
⊢ (∃ a_1, a_1 ∈ attach P.parts ∧ b ∈ (Q ↑a_1 (_ : ↑a_1 ∈ P.parts)).parts) ↔ ∃ A hA, b ∈ (Q A hA).parts

tactic: rintro ⟨⟨A, hA⟩, -, h⟩
state_before: case mp
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q : (i : α) → i ∈ P.parts → Finpartition i
⊢ (∃ a_1, a_1 ∈ attach P.parts ∧ b ∈ (Q ↑a_1 (_ : ↑a_1 ∈ P.parts)).parts) → ∃ A hA, b ∈ (Q A hA).parts

tactic: exact ⟨A, hA, h⟩
state_before: case mp.intro.mk.intro
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q : (i : α) → i ∈ P.parts → Finpartition i
A : α
hA : A ∈ P.parts
h : b ∈ (Q ↑{ val := A, property := hA } (_ : ↑{ val := A, property := hA } ∈ P.parts)).parts
⊢ ∃ A hA, b ∈ (Q A hA).parts

tactic: rintro ⟨A, hA, h⟩
state_before: case mpr
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q : (i : α) → i ∈ P.parts → Finpartition i
⊢ (∃ A hA, b ∈ (Q A hA).parts) → ∃ a_2, a_2 ∈ attach P.parts ∧ b ∈ (Q ↑a_2 (_ : ↑a_2 ∈ P.parts)).parts

tactic: exact ⟨⟨A, hA⟩, mem_attach _ ⟨A, hA⟩, h⟩
state_before: case mpr.intro.intro
α : Type u_1
inst✝² : DistribLattice α
inst✝¹ : OrderBot α
inst✝ : DecidableEq α
a b c : α
P : Finpartition a
Q : (i : α) → i ∈ P.parts → Finpartition i
A : α
hA : A ∈ P.parts
h : b ∈ (Q A hA).parts
⊢ ∃ a_1, a_1 ∈ attach P.parts ∧ b ∈ (Q ↑a_1 (_ : ↑a_1 ∈ P.parts)).parts
Theorem: Real.tanh_eq_sinh_div_cosh
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh_eq_sinh_div_cosh]
state_before: x y : ℝ
⊢ ↑(tanh x) = ↑(sinh x / cosh x)
Theorem: geom_sum_Ico_le_of_lt_one
File: Mathlib/Algebra/GeomSum.lean

tactic: rcases le_or_lt m n with (hmn | hmn)
state_before: α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
⊢ ∑ i in Ico m n, x ^ i ≤ x ^ m / (1 - x)

tactic: rw [geom_sum_Ico' h'x.ne hmn]
state_before: case inl
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ ∑ i in Ico m n, x ^ i ≤ x ^ m / (1 - x)

tactic: apply div_le_div (pow_nonneg hx _) _ (sub_pos.2 h'x) le_rfl
state_before: case inl
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ (x ^ m - x ^ n) / (1 - x) ≤ x ^ m / (1 - x)

tactic: simpa using pow_nonneg hx _
state_before: α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : m ≤ n
⊢ x ^ m - x ^ n ≤ x ^ m

tactic: rw [Ico_eq_empty, sum_empty]
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ ∑ i in Ico m n, x ^ i ≤ x ^ m / (1 - x)

tactic: apply div_nonneg (pow_nonneg hx _)
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ 0 ≤ x ^ m / (1 - x)

tactic: simpa using h'x.le
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ 0 ≤ 1 - x

tactic: simpa using hmn.le
state_before: case inr
α : Type u
inst✝ : LinearOrderedField α
x : α
hx : 0 ≤ x
h'x : x < 1
m n : ℕ
hmn : n < m
⊢ ¬m < n
Theorem: Submodule.prodEquivOfIsCompl_symm_apply_fst_eq_zero
File: Mathlib/LinearAlgebra/Projection.lean

tactic: conv_rhs => rw [← (prodEquivOfIsCompl p q h).apply_symm_apply x]
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.101515
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.102031
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.102994
inst✝² : Semiring S
M : Type ?u.103000
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ (↑(LinearEquiv.symm (prodEquivOfIsCompl p q h)) x).fst = 0 ↔ x ∈ q

tactic: rw [coe_prodEquivOfIsCompl', Submodule.add_mem_iff_left _ (Submodule.coe_mem _),
  mem_right_iff_eq_zero_of_disjoint h.disjoint]
state_before: R : Type u_2
inst✝⁹ : Ring R
E : Type u_1
inst✝⁸ : AddCommGroup E
inst✝⁷ : Module R E
F : Type ?u.101515
inst✝⁶ : AddCommGroup F
inst✝⁵ : Module R F
G : Type ?u.102031
inst✝⁴ : AddCommGroup G
inst✝³ : Module R G
p q : Submodule R E
S : Type ?u.102994
inst✝² : Semiring S
M : Type ?u.103000
inst✝¹ : AddCommMonoid M
inst✝ : Module S M
m : Submodule S M
h : IsCompl p q
x : E
⊢ (↑(LinearEquiv.symm (prodEquivOfIsCompl p q h)) x).fst = 0 ↔
    ↑(prodEquivOfIsCompl p q h) (↑(LinearEquiv.symm (prodEquivOfIsCompl p q h)) x) ∈ q
Theorem: Int.coprime_of_sq_sum'
File: Mathlib/NumberTheory/Fermat4.lean

tactic: apply IsCoprime.mul_right (Int.coprime_of_sq_sum (isCoprime_comm.mp h))
state_before: r s : ℤ
h : IsCoprime r s
⊢ IsCoprime (r ^ 2 + s ^ 2) (r * s)

tactic: rw [add_comm]
state_before: r s : ℤ
h : IsCoprime r s
⊢ IsCoprime (r ^ 2 + s ^ 2) s

tactic: apply Int.coprime_of_sq_sum h
state_before: r s : ℤ
h : IsCoprime r s
⊢ IsCoprime (s ^ 2 + r ^ 2) s
Theorem: MonoidAlgebra.single_one_comm
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: refine Finsupp.ext fun _ => ?_
state_before: k : Type u₁
G : Type u₂
R : Type ?u.844334
inst✝¹ : CommSemiring k
inst✝ : MulOneClass G
r : k
f : MonoidAlgebra k G
⊢ single 1 r * f = f * single 1 r

tactic: rw [single_one_mul_apply, mul_single_one_apply, mul_comm]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.844334
inst✝¹ : CommSemiring k
inst✝ : MulOneClass G
r : k
f : MonoidAlgebra k G
x✝ : G
⊢ ↑(single 1 r * f) x✝ = ↑(f * single 1 r) x✝
Theorem: Filter.prod_inj
File: Mathlib/Order/Filter/Prod.lean

tactic: refine' ⟨fun h => _, fun h => h.1 ▸ h.2 ▸ rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17832
δ : Type ?u.17835
ι : Sort ?u.17838
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
g₁ g₂ : Filter β
inst✝¹ : NeBot f₁
inst✝ : NeBot g₁
⊢ f₁ ×ˢ g₁ = f₂ ×ˢ g₂ ↔ f₁ = f₂ ∧ g₁ = g₂

tactic: have hle : f₁ ≤ f₂ ∧ g₁ ≤ g₂ := prod_le_prod.1 h.le
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17832
δ : Type ?u.17835
ι : Sort ?u.17838
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
g₁ g₂ : Filter β
inst✝¹ : NeBot f₁
inst✝ : NeBot g₁
h : f₁ ×ˢ g₁ = f₂ ×ˢ g₂
⊢ f₁ = f₂ ∧ g₁ = g₂

tactic: haveI := neBot_of_le hle.1
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17832
δ : Type ?u.17835
ι : Sort ?u.17838
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
g₁ g₂ : Filter β
inst✝¹ : NeBot f₁
inst✝ : NeBot g₁
h : f₁ ×ˢ g₁ = f₂ ×ˢ g₂
hle : f₁ ≤ f₂ ∧ g₁ ≤ g₂
⊢ f₁ = f₂ ∧ g₁ = g₂

tactic: haveI := neBot_of_le hle.2
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17832
δ : Type ?u.17835
ι : Sort ?u.17838
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
g₁ g₂ : Filter β
inst✝¹ : NeBot f₁
inst✝ : NeBot g₁
h : f₁ ×ˢ g₁ = f₂ ×ˢ g₂
hle : f₁ ≤ f₂ ∧ g₁ ≤ g₂
this : NeBot f₂
⊢ f₁ = f₂ ∧ g₁ = g₂

tactic: exact ⟨hle.1.antisymm <| (prod_le_prod.1 h.ge).1, hle.2.antisymm <| (prod_le_prod.1 h.ge).2⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.17832
δ : Type ?u.17835
ι : Sort ?u.17838
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
g₁ g₂ : Filter β
inst✝¹ : NeBot f₁
inst✝ : NeBot g₁
h : f₁ ×ˢ g₁ = f₂ ×ˢ g₂
hle : f₁ ≤ f₂ ∧ g₁ ≤ g₂
this✝ : NeBot f₂
this : NeBot g₂
⊢ f₁ = f₂ ∧ g₁ = g₂
Theorem: NNReal.rpow_neg_one
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: simp [rpow_neg]
state_before: x : ℝ≥0
⊢ x ^ (-1) = x⁻¹
Theorem: Set.nonempty_sInter
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [nonempty_iff_ne_empty, sInter_eq_empty_iff]
state_before: α : Type u_1
β : Type ?u.140766
γ : Type ?u.140769
ι : Sort ?u.140772
ι' : Sort ?u.140775
ι₂ : Sort ?u.140778
κ : ι → Sort ?u.140783
κ₁ : ι → Sort ?u.140788
κ₂ : ι → Sort ?u.140793
κ' : ι' → Sort ?u.140798
c : Set (Set α)
⊢ Set.Nonempty (⋂₀ c) ↔ ∃ a, ∀ (b : Set α), b ∈ c → a ∈ b
Theorem: Polynomial.expand_expand
File: Mathlib/Data/Polynomial/Expand.lean

tactic: simp_rw [expand_C]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
r : R
⊢ ↑(expand R p) (↑(expand R q) (↑C r)) = ↑(expand R (p * q)) (↑C r)

tactic: simp_rw [AlgHom.map_add, ihf, ihg]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f✝ f g : R[X]
ihf : ↑(expand R p) (↑(expand R q) f) = ↑(expand R (p * q)) f
ihg : ↑(expand R p) (↑(expand R q) g) = ↑(expand R (p * q)) g
⊢ ↑(expand R p) (↑(expand R q) (f + g)) = ↑(expand R (p * q)) (f + g)

tactic: simp_rw [AlgHom.map_mul, expand_C, AlgHom.map_pow, expand_X, AlgHom.map_pow, expand_X, pow_mul]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
f : R[X]
n : ℕ
r : R
x✝ : ↑(expand R p) (↑(expand R q) (↑C r * X ^ n)) = ↑(expand R (p * q)) (↑C r * X ^ n)
⊢ ↑(expand R p) (↑(expand R q) (↑C r * X ^ (n + 1))) = ↑(expand R (p * q)) (↑C r * X ^ (n + 1))
Theorem: bernsteinPolynomial.iterate_derivative_at_1_eq_zero_of_lt
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: intro w
state_before: R : Type u_1
inst✝ : CommRing R
n ν k : ℕ
⊢ k < n - ν → eval 1 ((↑derivative^[k]) (bernsteinPolynomial R n ν)) = 0

tactic: rw [flip' _ _ _ (tsub_pos_iff_lt.mp (pos_of_gt w)).le]
state_before: R : Type u_1
inst✝ : CommRing R
n ν k : ℕ
w : k < n - ν
⊢ eval 1 ((↑derivative^[k]) (bernsteinPolynomial R n ν)) = 0

tactic: simp [Polynomial.eval_comp, iterate_derivative_at_0_eq_zero_of_lt R n w]
state_before: R : Type u_1
inst✝ : CommRing R
n ν k : ℕ
w : k < n - ν
⊢ eval 1 ((↑derivative^[k]) (comp (bernsteinPolynomial R n (n - ν)) (1 - X))) = 0
Theorem: Nat.size_bit
File: Mathlib/Data/Nat/Size.lean

tactic: rw [size]
state_before: b : Bool
n : ℕ
h : bit b n ≠ 0
⊢ size (bit b n) = succ (size n)

tactic: conv =>
  lhs
  rw [binaryRec]
  simp [h]
state_before: b : Bool
n : ℕ
h : bit b n ≠ 0
⊢ binaryRec 0 (fun x x => succ) (bit b n) = succ (binaryRec 0 (fun x x => succ) n)

tactic: rw [div2_bit]
state_before: b : Bool
n : ℕ
h : bit b n ≠ 0
⊢ succ (binaryRec 0 (fun x x => succ) (div2 (bit b n))) = succ (binaryRec 0 (fun x x => succ) n)
Theorem: Complex.det_conjAe
File: Mathlib/Data/Complex/Determinant.lean

tactic: rw [← LinearMap.det_toMatrix basisOneI, toMatrix_conjAe, Matrix.det_fin_two_of]
state_before: ⊢ ↑LinearMap.det (AlgEquiv.toLinearMap conjAe) = -1

tactic: simp
state_before: ⊢ 1 * -1 - 0 * 0 = -1
Theorem: Fin.card_Ioc
File: Mathlib/Data/Fin/Interval.lean

tactic: rw [← Nat.card_Ioc, ← map_valEmbedding_Ioc, card_map]
state_before: n : ℕ
a b : Fin n
⊢ card (Ioc a b) = ↑b - ↑a
Theorem: ValuationRing.iff_ideal_total
File: Mathlib/RingTheory/Valuation/ValuationRing.lean

tactic: classical
refine' ⟨fun _ => ⟨le_total⟩, fun H => iff_dvd_total.mpr ⟨fun a b => _⟩⟩
have := @IsTotal.total _ _ H (Ideal.span {a}) (Ideal.span {b})
simp_rw [Ideal.span_singleton_le_span_singleton] at this
exact this.symm
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type ?u.525453
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
⊢ ValuationRing R ↔ IsTotal (Ideal R) fun x x_1 => x ≤ x_1

tactic: refine' ⟨fun _ => ⟨le_total⟩, fun H => iff_dvd_total.mpr ⟨fun a b => _⟩⟩
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type ?u.525453
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
⊢ ValuationRing R ↔ IsTotal (Ideal R) fun x x_1 => x ≤ x_1

tactic: have := @IsTotal.total _ _ H (Ideal.span {a}) (Ideal.span {b})
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type ?u.525453
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
H : IsTotal (Ideal R) fun x x_1 => x ≤ x_1
a b : R
⊢ a ∣ b ∨ b ∣ a

tactic: simp_rw [Ideal.span_singleton_le_span_singleton] at this
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type ?u.525453
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
H : IsTotal (Ideal R) fun x x_1 => x ≤ x_1
a b : R
this : Ideal.span {a} ≤ Ideal.span {b} ∨ Ideal.span {b} ≤ Ideal.span {a}
⊢ a ∣ b ∨ b ∣ a

tactic: exact this.symm
state_before: R : Type u_1
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type ?u.525453
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
H : IsTotal (Ideal R) fun x x_1 => x ≤ x_1
a b : R
this : b ∣ a ∨ a ∣ b
⊢ a ∣ b ∨ b ∣ a
Theorem: Inducing.secondCountableTopology
File: Mathlib/Topology/Bases.lean

tactic: rw [hf.1]
state_before: α : Type u_2
β : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
inst✝ : SecondCountableTopology β
hf : Inducing f
⊢ SecondCountableTopology α

tactic: exact secondCountableTopology_induced α β f
state_before: α : Type u_2
β : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
f : α → β
inst✝ : SecondCountableTopology β
hf : Inducing f
⊢ SecondCountableTopology α
Theorem: Filter.blimsup_eq_limsup_subtype
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [blimsup_eq, limsup_eq, Function.comp_apply, eventually_comap, SetCoe.forall,
  Subtype.coe_mk, mem_setOf_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.61523
ι : Type ?u.61526
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
p : β → Prop
⊢ blimsup u f p = limsup (u ∘ Subtype.val) (comap Subtype.val f)

tactic: congr
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.61523
ι : Type ?u.61526
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
p : β → Prop
⊢ sInf {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = sInf {a | ∀ᶠ (b : β) in f, ∀ (a_1 : { x // p x }), ↑a_1 = b → u ↑a_1 ≤ a}

tactic: ext a
state_before: case e_a
α : Type u_2
β : Type u_1
γ : Type ?u.61523
ι : Type ?u.61526
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
p : β → Prop
⊢ {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = {a | ∀ᶠ (b : β) in f, ∀ (a_1 : { x // p x }), ↑a_1 = b → u ↑a_1 ≤ a}

tactic: simp_rw [Subtype.forall]
state_before: case e_a.h
α : Type u_2
β : Type u_1
γ : Type ?u.61523
ι : Type ?u.61526
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
p : β → Prop
a : α
⊢ a ∈ {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ a ∈ {a | ∀ᶠ (b : β) in f, ∀ (a_1 : { x // p x }), ↑a_1 = b → u ↑a_1 ≤ a}

tactic: exact eventually_congr (
     eventually_of_forall
      fun x => ⟨fun hx y hy hxy => hxy.symm ▸ hx (hxy ▸ hy), fun hx hx' => hx x hx' rfl⟩)
state_before: case e_a.h
α : Type u_2
β : Type u_1
γ : Type ?u.61523
ι : Type ?u.61526
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
p : β → Prop
a : α
⊢ a ∈ {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ a ∈ {a | ∀ᶠ (b : β) in f, ∀ (a_1 : β), p a_1 → a_1 = b → u a_1 ≤ a}
Theorem: eq_mul_of_div_eq
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp [← h]
state_before: α : Type ?u.59378
β : Type ?u.59381
G : Type u_1
inst✝ : Group G
a b c d : G
h : a / c = b
⊢ a = b * c
Theorem: Int.mod_coprime
File: Mathlib/Data/Int/ModEq.lean

tactic: rw [← Nat.gcd_eq_gcd_ab, hgcd]
state_before: m n a✝ b✝ c d : ℤ
a b : ℕ
hab : Nat.coprime a b
hgcd : Nat.gcd a b = 1
⊢ ↑a * Nat.gcdA a b + ↑b * Nat.gcdB a b ≡ 1 [ZMOD ↑b]

tactic: rfl
state_before: m n a✝ b✝ c d : ℤ
a b : ℕ
hab : Nat.coprime a b
hgcd : Nat.gcd a b = 1
⊢ ↑1 ≡ 1 [ZMOD ↑b]
Theorem: CategoryTheory.Functor.map_homCongr
File: Mathlib/CategoryTheory/Conj.lean

tactic: simp
state_before: C : Type u
inst✝¹ : Category C
D : Type u₁
inst✝ : Category D
F : C ⥤ D
X Y X₁ Y₁ : C
α : X ≅ X₁
β : Y ≅ Y₁
f : X ⟶ Y
⊢ F.map (↑(Iso.homCongr α β) f) = ↑(Iso.homCongr (F.mapIso α) (F.mapIso β)) (F.map f)
Theorem: Filter.ptendsto'_of_ptendsto
File: Mathlib/Order/Filter/Partial.lean

tactic: rw [ptendsto_def, ptendsto'_def]
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : PFun.Dom f ∈ l₁
⊢ PTendsto f l₁ l₂ → PTendsto' f l₁ l₂

tactic: intro h' s sl₂
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : PFun.Dom f ∈ l₁
⊢ (∀ (s : Set β), s ∈ l₂ → PFun.core f s ∈ l₁) → ∀ (s : Set β), s ∈ l₂ → PFun.preimage f s ∈ l₁

tactic: rw [PFun.preimage_eq]
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : PFun.Dom f ∈ l₁
h' : ∀ (s : Set β), s ∈ l₂ → PFun.core f s ∈ l₁
s : Set β
sl₂ : s ∈ l₂
⊢ PFun.preimage f s ∈ l₁

tactic: exact inter_mem (h' s sl₂) h
state_before: α : Type u
β : Type v
γ : Type w
f : α →. β
l₁ : Filter α
l₂ : Filter β
h : PFun.Dom f ∈ l₁
h' : ∀ (s : Set β), s ∈ l₂ → PFun.core f s ∈ l₁
s : Set β
sl₂ : s ∈ l₂
⊢ PFun.core f s ∩ PFun.Dom f ∈ l₁
Theorem: Set.pairwise_disjoint_Ioo_int_cast
File: Mathlib/Data/Set/Intervals/Group.lean

tactic: simpa only [zero_add] using pairwise_disjoint_Ioo_add_int_cast (0 : α)
state_before: α : Type u_1
inst✝ : OrderedRing α
a : α
⊢ Pairwise (Disjoint on fun n => Ioo (↑n) (↑n + 1))
Theorem: List.eq_nil_iff_forall_not_mem
File: Std/Data/List/Lemmas.lean

tactic: simp [subset_def]
state_before: α : Type u_1
l : List α
⊢ l ⊆ [] ↔ ∀ (a : α), ¬a ∈ l
Theorem: Nat.mul_sub_right_distrib
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction m with
| zero => simp
| succ m ih => rw [Nat.sub_succ, Nat.mul_pred_left, ih, succ_mul, Nat.sub_sub]; done
state_before: n m k : Nat
⊢ (n - m) * k = n * k - m * k

tactic: simp
state_before: case zero
n k : Nat
⊢ (n - zero) * k = n * k - zero * k

tactic: rw [Nat.sub_succ, Nat.mul_pred_left, ih, succ_mul, Nat.sub_sub]
state_before: case succ
n k m : Nat
ih : (n - m) * k = n * k - m * k
⊢ (n - succ m) * k = n * k - succ m * k
Theorem: Nat.add_mul_mod_self_left
File: Std/Data/Nat/Lemmas.lean

tactic: match z with
| 0 => rw [Nat.mul_zero, Nat.add_zero]
| succ z => rw [mul_succ, ← Nat.add_assoc, add_mod_right, add_mul_mod_self_left (z := z)]
state_before: x y z : Nat
⊢ (x + y * z) % y = x % y

tactic: rw [Nat.mul_zero, Nat.add_zero]
state_before: x y z : Nat
⊢ (x + y * 0) % y = x % y

tactic: rw [mul_succ, ← Nat.add_assoc, add_mod_right, add_mul_mod_self_left (z := z)]
state_before: x y z✝ z : Nat
⊢ (x + y * succ z) % y = x % y