tasksource/leandojo huggingface dataset:
Theorem: quotient_nhd_basis
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: have : ∀ ε : ℝ, mk '' ball (0 : M) ε = { x : M ⧸ S | ‖x‖ < ε }
state_before: M : Type u_1
N : Type ?u.386793
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
⊢ Filter.HasBasis (𝓝 0) (fun ε => 0 < ε) fun ε => {x | ‖x‖ < ε}

tactic: rw [← mk_zero, nhds_eq, ← funext this]
state_before: M : Type u_1
N : Type ?u.386793
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
this : ∀ (ε : ℝ), mk '' ball 0 ε = {x | ‖x‖ < ε}
⊢ Filter.HasBasis (𝓝 0) (fun ε => 0 < ε) fun ε => {x | ‖x‖ < ε}

tactic: exact .map _ Metric.nhds_basis_ball
state_before: M : Type u_1
N : Type ?u.386793
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
this : ∀ (ε : ℝ), mk '' ball 0 ε = {x | ‖x‖ < ε}
⊢ Filter.HasBasis (Filter.map mk (𝓝 0)) (fun ε => 0 < ε) fun x => mk '' ball 0 x

tactic: refine fun ε ↦ Set.ext <| forall_mk.2 fun x ↦ ?_
state_before: case this
M : Type u_1
N : Type ?u.386793
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
⊢ ∀ (ε : ℝ), mk '' ball 0 ε = {x | ‖x‖ < ε}

tactic: rw [ball_zero_eq, mem_setOf_eq, norm_lt_iff, mem_image]
state_before: case this
M : Type u_1
N : Type ?u.386793
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
ε : ℝ
x : M
⊢ ↑x ∈ mk '' ball 0 ε ↔ ↑x ∈ {x | ‖x‖ < ε}

tactic: exact exists_congr fun _ ↦ and_comm
state_before: case this
M : Type u_1
N : Type ?u.386793
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
ε : ℝ
x : M
⊢ (∃ x_1, x_1 ∈ {x | ‖x‖ < ε} ∧ ↑x_1 = ↑x) ↔ ∃ m, ↑m = ↑x ∧ ‖m‖ < ε
Theorem: Equiv.Perm.Disjoint.orderOf
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: rw [hστ.commute.mul_pow, Disjoint.mul_eq_one_iff (hστ.pow_disjoint_pow n n)]
state_before: α : Type u
β : Type v
σ τ : Perm α
hστ : Disjoint σ τ
n : ℕ
⊢ (σ * τ) ^ n = 1 ↔ σ ^ n = 1 ∧ τ ^ n = 1
Theorem: Cubic.card_roots_of_disc_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [toFinset_card_of_nodup <| (disc_ne_zero_iff_roots_nodup ha h3).mp hd,
  ← splits_iff_card_roots ha, splits_iff_roots_eq_three ha]
state_before: R : Type ?u.1301913
S : Type ?u.1301916
F : Type u_2
K : Type u_1
P : Cubic F
inst✝² : Field F
inst✝¹ : Field K
φ : F →+* K
x y z : K
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
hd : disc P ≠ 0
⊢ Finset.card (toFinset (roots (map φ P))) = 3

tactic: exact ⟨x, ⟨y, ⟨z, h3⟩⟩⟩
state_before: R : Type ?u.1301913
S : Type ?u.1301916
F : Type u_2
K : Type u_1
P : Cubic F
inst✝² : Field F
inst✝¹ : Field K
φ : F →+* K
x y z : K
inst✝ : DecidableEq K
ha : P.a ≠ 0
h3 : roots (map φ P) = {x, y, z}
hd : disc P ≠ 0
⊢ ∃ x y z, roots (map φ P) = {x, y, z}
Theorem: Polynomial.erase_ne
File: Mathlib/Data/Polynomial/Basic.lean

tactic: simp [coeff_erase, h]
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q p : R[X]
n i : ℕ
h : i ≠ n
⊢ coeff (erase n p) i = coeff p i
Theorem: Submodule.mem_sSup_of_mem
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: have := le_sSup hs
state_before: R : Type u_2
S✝ : Type ?u.168464
M : Type u_1
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S

tactic: rw [LE.le] at this
state_before: R : Type u_2
S✝ : Type ?u.168464
M : Type u_1
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
this : s ≤ sSup S
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S

tactic: exact this
state_before: R : Type u_2
S✝ : Type ?u.168464
M : Type u_1
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q : Submodule R M
S : Set (Submodule R M)
s : Submodule R M
hs : s ∈ S
this : Preorder.toLE.1 s (sSup S)
⊢ ∀ {x : M}, x ∈ s → x ∈ sSup S
Theorem: isClosed_induced_iff'
File: Mathlib/Topology/Order.lean

tactic: letI := t.induced f
state_before: α : Type u_2
β : Type u_1
t✝ : TopologicalSpace β
f✝ : α → β
t : TopologicalSpace β
f : α → β
s : Set α
⊢ IsClosed s ↔ ∀ (a : α), f a ∈ closure (f '' s) → a ∈ s

tactic: simp only [← closure_subset_iff_isClosed, subset_def, closure_induced]
state_before: α : Type u_2
β : Type u_1
t✝ : TopologicalSpace β
f✝ : α → β
t : TopologicalSpace β
f : α → β
s : Set α
this : TopologicalSpace α := induced f t
⊢ IsClosed s ↔ ∀ (a : α), f a ∈ closure (f '' s) → a ∈ s
Theorem: Polynomial.hasseDeriv_apply
File: Mathlib/Data/Polynomial/HasseDeriv.lean

tactic: dsimp [hasseDeriv]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ ↑(hasseDeriv k) f = sum f fun i r => ↑(monomial (i - k)) (↑(choose i k) * r)

tactic: congr
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (sum f fun n r => ↑(monomial (n - k)) (choose n k • r)) = sum f fun i r => ↑(monomial (i - k)) (↑(choose i k) * r)

tactic: ext
state_before: case e_f
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
⊢ (fun n r => ↑(monomial (n - k)) (choose n k • r)) = fun i r => ↑(monomial (i - k)) (↑(choose i k) * r)

tactic: congr
state_before: case e_f.h.h.a
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ coeff (↑(monomial (x✝¹ - k)) (choose x✝¹ k • x✝)) n✝ = coeff (↑(monomial (x✝¹ - k)) (↑(choose x✝¹ k) * x✝)) n✝

tactic: apply nsmul_eq_mul
state_before: case e_f.h.h.a.e_a.h.e_6.h
R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
x✝¹ : ℕ
x✝ : R
n✝ : ℕ
⊢ choose x✝¹ k • x✝ = ↑(choose x✝¹ k) * x✝
Theorem: isFixedPt_of_tendsto_iterate
File: Mathlib/Dynamics/FixedPoints/Topology.lean

tactic: refine' tendsto_nhds_unique ((tendsto_add_atTop_iff_nat 1).1 _) hy
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T2Space α
f : α → α
x y : α
hy : Tendsto (fun n => (f^[n]) x) atTop (𝓝 y)
hf : ContinuousAt f y
⊢ IsFixedPt f y

tactic: simp only [iterate_succ' f]
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T2Space α
f : α → α
x y : α
hy : Tendsto (fun n => (f^[n]) x) atTop (𝓝 y)
hf : ContinuousAt f y
⊢ Tendsto (fun n => (f^[n + 1]) x) atTop (𝓝 (f y))

tactic: exact hf.tendsto.comp hy
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : T2Space α
f : α → α
x y : α
hy : Tendsto (fun n => (f^[n]) x) atTop (𝓝 y)
hf : ContinuousAt f y
⊢ Tendsto (fun n => (f ∘ f^[n]) x) atTop (𝓝 (f y))
Theorem: Finsupp.update_eq_sub_add_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [update_eq_erase_add_single, erase_eq_sub_single]
state_before: α : Type u_2
β : Type ?u.565928
γ : Type ?u.565931
ι : Type ?u.565934
M : Type ?u.565937
M' : Type ?u.565940
N : Type ?u.565943
P : Type ?u.565946
G : Type u_1
H : Type ?u.565952
R : Type ?u.565955
S : Type ?u.565958
inst✝ : AddGroup G
f : α →₀ G
a : α
b : G
⊢ update f a b = f - single a (↑f a) + single a b
Theorem: List.formPerm_pow_length_eq_one_of_nodup
File: Mathlib/GroupTheory/Perm/List.lean

tactic: ext x
state_before: α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x : α
hl : Nodup l
⊢ formPerm l ^ length l = 1

tactic: by_cases hx : x ∈ l
state_before: case H
α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
⊢ ↑(formPerm l ^ length l) x = ↑1 x

tactic: obtain ⟨k, hk, rfl⟩ := nthLe_of_mem hx
state_before: case pos
α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
hx : x ∈ l
⊢ ↑(formPerm l ^ length l) x = ↑1 x

tactic: simp [formPerm_pow_apply_nthLe _ hl, Nat.mod_eq_of_lt hk]
state_before: case pos.intro.intro
α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x : α
hl : Nodup l
k : ℕ
hk : k < length l
hx : nthLe l k hk ∈ l
⊢ ↑(formPerm l ^ length l) (nthLe l k hk) = ↑1 (nthLe l k hk)

tactic: have : x ∉ { x | (l.formPerm ^ l.length) x ≠ x } := by
  intro H
  refine' hx _
  replace H := set_support_zpow_subset l.formPerm l.length H
  simpa using support_formPerm_le' _ H
state_before: case neg
α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
hx : ¬x ∈ l
⊢ ↑(formPerm l ^ length l) x = ↑1 x

tactic: simpa using this
state_before: case neg
α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
hx : ¬x ∈ l
this : ¬x ∈ {x | ↑(formPerm l ^ length l) x ≠ x}
⊢ ↑(formPerm l ^ length l) x = ↑1 x

tactic: intro H
state_before: α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
hx : ¬x ∈ l
⊢ ¬x ∈ {x | ↑(formPerm l ^ length l) x ≠ x}

tactic: refine' hx _
state_before: α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
hx : ¬x ∈ l
H : x ∈ {x | ↑(formPerm l ^ length l) x ≠ x}
⊢ False

tactic: replace H := set_support_zpow_subset l.formPerm l.length H
state_before: α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
hx : ¬x ∈ l
H : x ∈ {x | ↑(formPerm l ^ length l) x ≠ x}
⊢ x ∈ l

tactic: simpa using support_formPerm_le' _ H
state_before: α : Type u_1
β : Type ?u.842481
inst✝ : DecidableEq α
l : List α
x✝ : α
hl : Nodup l
x : α
hx : ¬x ∈ l
H : x ∈ {x | ↑(formPerm l) x ≠ x}
⊢ x ∈ l
Theorem: mul_sub_mul_div_mul_nonpos_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [mul_comm b c, ← div_sub_div _ _ hc hd, sub_nonpos]
state_before: ι : Type ?u.193207
α : Type u_1
β : Type ?u.193213
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hc : c ≠ 0
hd : d ≠ 0
⊢ (a * d - b * c) / (c * d) ≤ 0 ↔ a / c ≤ b / d
Theorem: iSup_const
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup, range_const, sSup_singleton]
state_before: α : Type u_2
β : Type ?u.86729
β₂ : Type ?u.86732
γ : Type ?u.86735
ι : Sort u_1
ι' : Sort ?u.86741
κ : ι → Sort ?u.86746
κ' : ι' → Sort ?u.86751
inst✝¹ : CompleteLattice α
f g s t : ι → α
a b : α
inst✝ : Nonempty ι
⊢ (⨆ (x : ι), a) = a
Theorem: deriv.lhopital_zero_atTop_on_Ioi
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: have hdf : ∀ x ∈ Ioi a, DifferentiableAt ℝ f x := fun x hx =>
  (hdf x hx).differentiableAt (Ioi_mem_nhds hx)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : DifferentiableOn ℝ f (Ioi a)
hg' : ∀ (x : ℝ), x ∈ Ioi a → deriv g x ≠ 0
hftop : Tendsto f atTop (𝓝 0)
hgtop : Tendsto g atTop (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atTop l
⊢ Tendsto (fun x => f x / g x) atTop l

tactic: have hdg : ∀ x ∈ Ioi a, DifferentiableAt ℝ g x := fun x hx =>
  by_contradiction fun h => hg' x hx (deriv_zero_of_not_differentiableAt h)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioi a)
hg' : ∀ (x : ℝ), x ∈ Ioi a → deriv g x ≠ 0
hftop : Tendsto f atTop (𝓝 0)
hgtop : Tendsto g atTop (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atTop l
hdf : ∀ (x : ℝ), x ∈ Ioi a → DifferentiableAt ℝ f x
⊢ Tendsto (fun x => f x / g x) atTop l

tactic: exact HasDerivAt.lhopital_zero_atTop_on_Ioi (fun x hx => (hdf x hx).hasDerivAt)
  (fun x hx => (hdg x hx).hasDerivAt) hg' hftop hgtop hdiv
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioi a)
hg' : ∀ (x : ℝ), x ∈ Ioi a → deriv g x ≠ 0
hftop : Tendsto f atTop (𝓝 0)
hgtop : Tendsto g atTop (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) atTop l
hdf : ∀ (x : ℝ), x ∈ Ioi a → DifferentiableAt ℝ f x
hdg : ∀ (x : ℝ), x ∈ Ioi a → DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) atTop l
Theorem: PGame.lt_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg x, neg_lt_neg_iff, neg_neg]
state_before: x y : PGame
⊢ y < -x ↔ x < -y
Theorem: RelEmbedding.acc
File: Mathlib/Order/RelIso/Basic.lean

tactic: generalize h : f a = b
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41887
δ : Type ?u.41890
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a : α
⊢ Acc s (↑f a) → Acc r a

tactic: intro ac
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41887
δ : Type ?u.41890
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a : α
b : β
h : ↑f a = b
⊢ Acc s b → Acc r a

tactic: induction' ac with _ H IH generalizing a
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.41887
δ : Type ?u.41890
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a : α
b : β
h : ↑f a = b
ac : Acc s b
⊢ Acc r a

tactic: subst h
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.41887
δ : Type ?u.41890
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a✝ : α
b : β
h✝ : ↑f a✝ = b
x✝ : β
H : ∀ (y : β), s y x✝ → Acc s y
IH : ∀ (y : β), s y x✝ → ∀ (a : α), ↑f a = y → Acc r a
a : α
h : ↑f a = x✝
⊢ Acc r a

tactic: exact ⟨_, fun a' h => IH (f a') (f.map_rel_iff.2 h) _ rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.41887
δ : Type ?u.41890
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : r ↪r s
a✝ : α
b : β
h : ↑f a✝ = b
a : α
H : ∀ (y : β), s y (↑f a) → Acc s y
IH : ∀ (y : β), s y (↑f a) → ∀ (a : α), ↑f a = y → Acc r a
⊢ Acc r a
Theorem: Real.sinh_neg_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean

tactic: simpa only [sinh_zero] using @sinh_lt_sinh x 0
state_before: x y z : ℝ
⊢ sinh x < 0 ↔ x < 0
Theorem: SimpleGraph.mem_incidenceSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp [incidenceSet]
state_before: ι : Sort ?u.137668
𝕜 : Type ?u.137671
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
v w : V
⊢ Quotient.mk (Sym2.Rel.setoid V) (v, w) ∈ incidenceSet G v ↔ Adj G v w
Theorem: Filter.tendsto_comp_val_Ioi_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [← map_val_Ioi_atTop a, tendsto_map'_iff]
state_before: ι : Type ?u.337904
ι' : Type ?u.337907
α : Type u_1
β : Type u_2
γ : Type ?u.337916
inst✝¹ : SemilatticeSup α
inst✝ : NoMaxOrder α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto f atTop l

tactic: rfl
state_before: ι : Type ?u.337904
ι' : Type ?u.337907
α : Type u_1
β : Type u_2
γ : Type ?u.337916
inst✝¹ : SemilatticeSup α
inst✝ : NoMaxOrder α
a : α
f : α → β
l : Filter β
⊢ Tendsto (fun x => f ↑x) atTop l ↔ Tendsto (f ∘ Subtype.val) atTop l
Theorem: tendsto_factorial_div_pow_self_atTop
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: exact_mod_cast n.factorial_pos.le
state_before: α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
n : ℕ
⊢ 0 ≤ ↑n !

tactic: exact_mod_cast n.zero_le
state_before: α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
n : ℕ
⊢ 0 ≤ ↑n

tactic: refine' (eventually_gt_atTop 0).mono fun n hn => _
state_before: α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
⊢ ∀ᶠ (b : ℕ) in atTop, ↑b ! / ↑b ^ b ≤ 1 / ↑b

tactic: rcases Nat.exists_eq_succ_of_ne_zero hn.ne.symm with ⟨k, rfl⟩
state_before: α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
n : ℕ
hn : 0 < n
⊢ ↑n ! / ↑n ^ n ≤ 1 / ↑n

tactic: rw [← prod_range_add_one_eq_factorial, pow_eq_prod_const, div_eq_mul_inv, ← inv_eq_one_div,
  prod_natCast, Nat.cast_succ, ← prod_inv_distrib, ← prod_mul_distrib,
  Finset.prod_range_succ']
state_before: case intro
α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
⊢ ↑(succ k)! / ↑(succ k) ^ succ k ≤ 1 / ↑(succ k)

tactic: simp only [prod_range_succ', one_mul, Nat.cast_add, zero_add, Nat.cast_one]
state_before: case intro
α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
⊢ (∏ k_1 in Finset.range k, ↑(k_1 + 1 + 1) * (↑k + 1)⁻¹) * (↑(0 + 1) * (↑k + 1)⁻¹) ≤ (↑k + 1)⁻¹

tactic: refine'
      mul_le_of_le_one_left (inv_nonneg.mpr <| by exact_mod_cast hn.le) (prod_le_one _ _) <;>
    intro x hx <;>
  rw [Finset.mem_range] at hx
state_before: case intro
α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
⊢ (∏ x in Finset.range k, (↑x + 1 + 1) * (↑k + 1)⁻¹) * (↑k + 1)⁻¹ ≤ (↑k + 1)⁻¹

tactic: exact_mod_cast hn.le
state_before: α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
⊢ 0 ≤ ↑k + 1

tactic: refine' mul_nonneg _ (inv_nonneg.mpr _) <;> norm_cast <;> linarith
state_before: case intro.refine'_1
α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
x : ℕ
hx : x < k
⊢ 0 ≤ (↑x + 1 + 1) * (↑k + 1)⁻¹

tactic: refine' (div_le_one <| by exact_mod_cast hn).mpr _
state_before: case intro.refine'_2
α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
x : ℕ
hx : x < k
⊢ (↑x + 1 + 1) * (↑k + 1)⁻¹ ≤ 1

tactic: norm_cast
state_before: case intro.refine'_2
α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
x : ℕ
hx : x < k
⊢ ↑x + 1 + 1 ≤ ↑k + 1

tactic: linarith
state_before: case intro.refine'_2
α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
x : ℕ
hx : x < k
⊢ x + 1 + 1 ≤ k + 1

tactic: exact_mod_cast hn
state_before: α : Type ?u.482700
β : Type ?u.482703
ι : Type ?u.482706
k : ℕ
hn : 0 < succ k
x : ℕ
hx : x < k
⊢ 0 < ↑k + 1
Theorem: Differentiable.apply_eq_apply_of_bounded
File: Mathlib/Analysis/Complex/Liouville.lean

tactic: set g : ℂ → F := f ∘ fun t : ℂ => t • (w - z) + z
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Metric.Bounded (range f)
z w : E
⊢ f z = f w

tactic: suffices g 0 = g 1 by simpa
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Metric.Bounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ f z = f w

tactic: apply liouville_theorem_aux
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Metric.Bounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ g 0 = g 1

tactic: exacts [hf.comp ((differentiable_id.smul_const (w - z)).add_const z),
  hb.mono (range_comp_subset_range _ _)]
state_before: case hf
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Metric.Bounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ Differentiable ℂ g

case hb
E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Metric.Bounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
⊢ Metric.Bounded (range g)

tactic: simpa
state_before: E : Type u
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℂ E
F : Type v
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℂ F
f : E → F
hf : Differentiable ℂ f
hb : Metric.Bounded (range f)
z w : E
g : ℂ → F := f ∘ fun t => t • (w - z) + z
this : g 0 = g 1
⊢ f z = f w
Theorem: Polynomial.zero_divByMonic
File: Mathlib/Data/Polynomial/Div.lean

tactic: unfold divByMonic divModByMonicAux
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
⊢ 0 /ₘ p = 0

tactic: dsimp
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
⊢ (if h : Monic p then
      (if h_1 : degree p ≤ degree 0 ∧ 0 ≠ 0 then
          let z := ↑C (leadingCoeff 0) * X ^ (natDegree 0 - natDegree p);
          let_fun _wf := (_ : degree (0 - ↑C (leadingCoeff 0) * X ^ (natDegree 0 - natDegree p) * p) < degree 0);
          let dm := divModByMonicAux (0 - z * p) (_ : Monic p);
          (z + dm.fst, dm.snd)
        else (0, 0)).fst
    else 0) =
    0

tactic: by_cases hp : Monic p
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
⊢ (if h : Monic p then
      (if degree p ≤ ⊥ ∧ ¬0 = 0 then
          (↑C 0 * X ^ (0 - natDegree p) + (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).fst,
            (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).snd)
        else (0, 0)).fst
    else 0) =
    0

tactic: rw [dif_pos hp, if_neg (mt And.right (not_not_intro rfl))]
state_before: case pos
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
hp : Monic p
⊢ (if h : Monic p then
      (if degree p ≤ ⊥ ∧ ¬0 = 0 then
          (↑C 0 * X ^ (0 - natDegree p) + (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).fst,
            (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).snd)
        else (0, 0)).fst
    else 0) =
    0

tactic: rw [dif_neg hp]
state_before: case neg
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Ring R
p✝ q p : R[X]
hp : ¬Monic p
⊢ (if h : Monic p then
      (if degree p ≤ ⊥ ∧ ¬0 = 0 then
          (↑C 0 * X ^ (0 - natDegree p) + (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).fst,
            (divModByMonicAux (0 - ↑C 0 * X ^ (0 - natDegree p) * p) (_ : Monic p)).snd)
        else (0, 0)).fst
    else 0) =
    0
Theorem: PowerSeries.rescale_neg_one_X
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [rescale_X, map_neg, map_one, neg_one_mul]
state_before: R : Type ?u.3551663
A : Type u_1
inst✝ : CommRing A
⊢ ↑(rescale (-1)) X = -X
Theorem: MeasureTheory.Measure.exists_measure_inter_spanningSets_pos
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← not_iff_not]
state_before: α : Type u_1
β : Type ?u.733391
γ : Type ?u.733394
δ : Type ?u.733397
ι : Type ?u.733400
R : Type ?u.733403
R' : Type ?u.733406
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (∃ n, 0 < ↑↑μ (s ∩ spanningSets μ n)) ↔ 0 < ↑↑μ s

tactic: simp only [not_exists, not_lt, nonpos_iff_eq_zero]
state_before: α : Type u_1
β : Type ?u.733391
γ : Type ?u.733394
δ : Type ?u.733397
ι : Type ?u.733400
R : Type ?u.733403
R' : Type ?u.733406
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (¬∃ n, 0 < ↑↑μ (s ∩ spanningSets μ n)) ↔ ¬0 < ↑↑μ s

tactic: exact forall_measure_inter_spanningSets_eq_zero s
state_before: α : Type u_1
β : Type ?u.733391
γ : Type ?u.733394
δ : Type ?u.733397
ι : Type ?u.733400
R : Type ?u.733403
R' : Type ?u.733406
m0 : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝¹ : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
s : Set α
⊢ (∀ (x : ℕ), ↑↑μ (s ∩ spanningSets μ x) = 0) ↔ ↑↑μ s = 0
Theorem: Polynomial.le_natTrailingDegree
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: rw [natTrailingDegree_eq_support_min' hp]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
hn : ∀ (m : ℕ), m < n → coeff p m = 0
⊢ n ≤ natTrailingDegree p

tactic: exact Finset.le_min' _ _ _ fun m hm => not_lt.1 fun hmn => mem_support_iff.1 hm <| hn _ hmn
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
hp : p ≠ 0
hn : ∀ (m : ℕ), m < n → coeff p m = 0
⊢ n ≤ min' (support p) (_ : Finset.Nonempty (support p))
Theorem: Holor.cprankMax_nil
File: Mathlib/Data/Holor.lean

tactic: have h := CPRankMax.succ 0 x 0 (CPRankMax1.nil x) CPRankMax.zero
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
x : Holor α []
⊢ CPRankMax 1 x

tactic: rwa [add_zero x, zero_add] at h
state_before: α : Type
d : ℕ
ds ds₁ ds₂ ds₃ : List ℕ
inst✝¹ : Monoid α
inst✝ : AddMonoid α
x : Holor α []
h : CPRankMax (0 + 1) (x + 0)
⊢ CPRankMax 1 x
Theorem: List.Ico.succ_top
File: Mathlib/Data/List/Intervals.lean

tactic: rwa [← succ_singleton, append_consecutive]
state_before: n m : ℕ
h : n ≤ m
⊢ Ico n (m + 1) = Ico n m ++ [m]

tactic: exact Nat.le_succ _
state_before: case hml
n m : ℕ
h : n ≤ m
⊢ m ≤ m + 1