tasksource/leandojo huggingface dataset:
Theorem: Qpf.Fix.rec_eq
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: have : recF g ∘ fixToW = Fix.rec g := by
  apply funext
  apply Quotient.ind
  intro x
  apply recF_eq_of_Wequiv
  rw [fixToW]
  apply Wrepr_equiv
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : F (Fix F)
⊢ rec g (mk x) = g (rec g <$> x)

tactic: conv =>
  lhs
  rw [Fix.rec, Fix.mk]
  dsimp
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : F (Fix F)
this : recF g ∘ fixToW = rec g
⊢ rec g (mk x) = g (rec g <$> x)

tactic: cases' h : repr x with a f
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : F (Fix F)
this : recF g ∘ fixToW = rec g
⊢ recF g (PFunctor.W.mk (fixToW <$> repr x)) = g (rec g <$> x)

tactic: rw [PFunctor.map_eq, recF_eq, ← PFunctor.map_eq, PFunctor.W.dest_mk, ← PFunctor.comp_map, abs_map,
  ← h, abs_repr, this]
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : F (Fix F)
this : recF g ∘ fixToW = rec g
a : (P F).A
f : PFunctor.B (P F) a → Fix F
h : repr x = { fst := a, snd := f }
⊢ recF g (PFunctor.W.mk (fixToW <$> { fst := a, snd := f })) = g (rec g <$> x)

tactic: apply funext
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : F (Fix F)
⊢ recF g ∘ fixToW = rec g

tactic: apply Quotient.ind
state_before: case h
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : F (Fix F)
⊢ ∀ (x : Fix F), (recF g ∘ fixToW) x = rec g x

tactic: intro x
state_before: case h.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x : F (Fix F)
⊢ ∀ (a : PFunctor.W (P F)), (recF g ∘ fixToW) (Quotient.mk Wsetoid a) = rec g (Quotient.mk Wsetoid a)

tactic: apply recF_eq_of_Wequiv
state_before: case h.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x✝ : F (Fix F)
x : PFunctor.W (P F)
⊢ (recF g ∘ fixToW) (Quotient.mk Wsetoid x) = rec g (Quotient.mk Wsetoid x)

tactic: rw [fixToW]
state_before: case h.a.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x✝ : F (Fix F)
x : PFunctor.W (P F)
⊢ Wequiv (fixToW (Quotient.mk Wsetoid x)) x

tactic: apply Wrepr_equiv
state_before: case h.a.a
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
g : F α → α
x✝ : F (Fix F)
x : PFunctor.W (P F)
⊢ Wequiv
    (Quotient.lift Wrepr
      (_ :
        ∀ (x y : PFunctor.W (P F)),
          Wequiv x y → recF (fun x => PFunctor.W.mk (repr x)) x = recF (fun x => PFunctor.W.mk (repr x)) y)
      (Quotient.mk Wsetoid x))
    x
Theorem: isSelfAdjoint_add_star_self
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, add_comm, star_add, star_star]
state_before: R : Type u_1
A : Type ?u.12261
inst✝¹ : AddCommMonoid R
inst✝ : StarAddMonoid R
x : R
⊢ IsSelfAdjoint (x + star x)
Theorem: List.chain'_range_succ
File: Mathlib/Data/List/Range.lean

tactic: rw [range_succ]
state_before: α : Type u
r : ℕ → ℕ → Prop
n : ℕ
⊢ Chain' r (range (succ n)) ↔ ∀ (m : ℕ), m < n → r m (succ m)

tactic: induction' n with n hn
state_before: α : Type u
r : ℕ → ℕ → Prop
n : ℕ
⊢ Chain' r (range n ++ [n]) ↔ ∀ (m : ℕ), m < n → r m (succ m)

tactic: simp
state_before: case zero
α : Type u
r : ℕ → ℕ → Prop
⊢ Chain' r (range zero ++ [zero]) ↔ ∀ (m : ℕ), m < zero → r m (succ m)

tactic: rw [range_succ]
state_before: case succ
α : Type u
r : ℕ → ℕ → Prop
n : ℕ
hn : Chain' r (range n ++ [n]) ↔ ∀ (m : ℕ), m < n → r m (succ m)
⊢ Chain' r (range (succ n) ++ [succ n]) ↔ ∀ (m : ℕ), m < succ n → r m (succ m)

tactic: simp only [append_assoc, singleton_append, chain'_append_cons_cons, chain'_singleton,
  and_true_iff]
state_before: case succ
α : Type u
r : ℕ → ℕ → Prop
n : ℕ
hn : Chain' r (range n ++ [n]) ↔ ∀ (m : ℕ), m < n → r m (succ m)
⊢ Chain' r (range n ++ [n] ++ [succ n]) ↔ ∀ (m : ℕ), m < succ n → r m (succ m)

tactic: rw [hn, forall_lt_succ]
state_before: case succ
α : Type u
r : ℕ → ℕ → Prop
n : ℕ
hn : Chain' r (range n ++ [n]) ↔ ∀ (m : ℕ), m < n → r m (succ m)
⊢ Chain' r (range n ++ [n]) ∧ r n (succ n) ↔ ∀ (m : ℕ), m < succ n → r m (succ m)
Theorem: Submodule.FG.prod
File: Mathlib/RingTheory/Finiteness.lean

tactic: rw [LinearMap.span_inl_union_inr, htb.2, htc.2]
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
P : Type u_3
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
f : M →ₗ[R] P
sb : Submodule R M
sc : Submodule R P
hsb : FG sb
hsc : FG sc
tb : Set M
htb : Set.Finite tb ∧ span R tb = sb
tc : Set P
htc : Set.Finite tc ∧ span R tc = sc
⊢ span R (↑(LinearMap.inl R M P) '' tb ∪ ↑(LinearMap.inr R M P) '' tc) = Submodule.prod sb sc
Theorem: BoxIntegral.Prepartition.mem_inf
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp only [inf_def, mem_biUnion, mem_restrict]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁✝ π₂✝ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π₁ π₂ : Prepartition I
⊢ J ∈ π₁ ⊓ π₂ ↔ ∃ J₁, J₁ ∈ π₁ ∧ ∃ J₂, J₂ ∈ π₂ ∧ ↑J = ↑J₁ ⊓ ↑J₂
Theorem: TensorAlgebra.ι_comp_lift
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

tactic: convert (lift R).symm_apply_apply f
state_before: R : Type u_2
inst✝⁴ : CommSemiring R
M : Type u_3
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : M →ₗ[R] A
⊢ LinearMap.comp (AlgHom.toLinearMap (↑(lift R) f)) (ι R) = f
Theorem: frontier_Ioo
File: Mathlib/Topology/Order/Basic.lean

tactic: rw [frontier, closure_Ioo h.ne, interior_Ioo, Icc_diff_Ioo_same h.le]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
h : a < b
⊢ frontier (Ioo a b) = {a, b}
Theorem: Real.one_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [Real.pi, mul_div_cancel_left _ (two_ne_zero' ℝ)]
state_before: ⊢ 1 ≤ π / 2

tactic: exact (Classical.choose_spec exists_cos_eq_zero).1.1
state_before: ⊢ 1 ≤ choose exists_cos_eq_zero
Theorem: Multiset.dedup_ext
File: Mathlib/Data/Multiset/Dedup.lean

tactic: simp [Nodup.ext]
state_before: α : Type u_1
β : Type ?u.9380
inst✝ : DecidableEq α
s t : Multiset α
⊢ dedup s = dedup t ↔ ∀ (a : α), a ∈ s ↔ a ∈ t
Theorem: Part.ne_none_iff
File: Mathlib/Data/Part.lean

tactic: constructor
state_before: α : Type u_1
β : Type ?u.5585
γ : Type ?u.5588
o : Part α
⊢ o ≠ none ↔ ∃ x, o = some x

tactic: rw [Ne, eq_none_iff', not_not]
state_before: case mp
α : Type u_1
β : Type ?u.5585
γ : Type ?u.5588
o : Part α
⊢ o ≠ none → ∃ x, o = some x

tactic: exact fun h => ⟨o.get h, eq_some_iff.2 (get_mem h)⟩
state_before: case mp
α : Type u_1
β : Type ?u.5585
γ : Type ?u.5588
o : Part α
⊢ o.Dom → ∃ x, o = some x

tactic: rintro ⟨x, rfl⟩
state_before: case mpr
α : Type u_1
β : Type ?u.5585
γ : Type ?u.5588
o : Part α
⊢ (∃ x, o = some x) → o ≠ none

tactic: apply some_ne_none
state_before: case mpr.intro
α : Type u_1
β : Type ?u.5585
γ : Type ?u.5588
x : α
⊢ some x ≠ none
Theorem: bex_imp
File: Mathlib/Logic/Basic.lean

tactic: simp
state_before: α : Sort u_1
r p q : α → Prop
P Q : (x : α) → p x → Prop
b : Prop
⊢ (∃ x h, P x h) → b ↔ ∀ (x : α) (h : p x), P x h → b
Theorem: Polynomial.bit1_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: simp only [bit1, add_comp, bit0_comp, one_comp]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
⊢ comp (bit1 p) q = bit1 (comp p q)
Theorem: Set.image_const_add_Ioo
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: simp only [add_comm a, image_add_const_Ioo]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ (fun x => a + x) '' Ioo b c = Ioo (a + b) (a + c)
Theorem: exists_lt_rieszContentAux_add_pos
File: Mathlib/MeasureTheory/Integral/RieszMarkovKakutani.lean

tactic: obtain ⟨α, ⟨⟨f, f_hyp⟩, α_hyp⟩⟩ :=
  exists_lt_of_csInf_lt (riesz_content_aux_image_nonempty Λ K)
    (lt_add_of_pos_right (rieszContentAux Λ K) εpos)
state_before: X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
⊢ ∃ f, (∀ (x : X), x ∈ K → 1 ≤ ↑f x) ∧ ↑Λ f < rieszContentAux Λ K + ε

tactic: refine' ⟨f, f_hyp.left, _⟩
state_before: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ (x : X), x ∈ K → 1 ≤ ↑f x} ∧ ↑Λ f = α
⊢ ∃ f, (∀ (x : X), x ∈ K → 1 ≤ ↑f x) ∧ ↑Λ f < rieszContentAux Λ K + ε

tactic: rw [f_hyp.right]
state_before: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ (x : X), x ∈ K → 1 ≤ ↑f x} ∧ ↑Λ f = α
⊢ ↑Λ f < rieszContentAux Λ K + ε

tactic: exact α_hyp
state_before: case intro.intro.intro
X : Type u_1
inst✝ : TopologicalSpace X
Λ : (X →ᵇ ℝ≥0) →ₗ[ℝ≥0] ℝ≥0
K : Compacts X
ε : ℝ≥0
εpos : 0 < ε
α : ℝ≥0
α_hyp : α < rieszContentAux Λ K + ε
f : X →ᵇ ℝ≥0
f_hyp : f ∈ {f | ∀ (x : X), x ∈ K → 1 ≤ ↑f x} ∧ ↑Λ f = α
⊢ α < rieszContentAux Λ K + ε
Theorem: ZFSet.toSet_sdiff
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: change (ZFSet.sep (fun z => z ∉ y) x).toSet = _
state_before: x y : ZFSet
⊢ toSet (x \ y) = toSet x \ toSet y

tactic: ext
state_before: x y : ZFSet
⊢ toSet (ZFSet.sep (fun z => ¬z ∈ y) x) = toSet x \ toSet y

tactic: simp
state_before: case h
x y x✝ : ZFSet
⊢ x✝ ∈ toSet (ZFSet.sep (fun z => ¬z ∈ y) x) ↔ x✝ ∈ toSet x \ toSet y
Theorem: div_add_same
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← div_self h, add_div]
state_before: α : Type u_1
β : Type ?u.2192
K : Type ?u.2195
inst✝ : DivisionSemiring α
a b c d : α
h : b ≠ 0
⊢ (a + b) / b = a / b + 1
Theorem: Ordinal.apply_le_nfpBFamily
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: refine' ⟨fun h => _, fun h i hi => _⟩
state_before: o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
⊢ (∀ (i : Ordinal) (hi : i < o), f i hi b ≤ nfpBFamily o f a) ↔ b ≤ nfpBFamily o f a

tactic: have ho' : 0 < o := Ordinal.pos_iff_ne_zero.2 ho
state_before: case refine'_1
o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
h : ∀ (i : Ordinal) (hi : i < o), f i hi b ≤ nfpBFamily o f a
⊢ b ≤ nfpBFamily o f a

tactic: exact ((H 0 ho').self_le b).trans (h 0 ho')
state_before: case refine'_1
o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
h : ∀ (i : Ordinal) (hi : i < o), f i hi b ≤ nfpBFamily o f a
ho' : 0 < o
⊢ b ≤ nfpBFamily o f a

tactic: rw [← nfpBFamily_fp (H i hi)]
state_before: case refine'_2
o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
h : b ≤ nfpBFamily o f a
i : Ordinal
hi : i < o
⊢ f i hi b ≤ nfpBFamily o f a

tactic: exact (H i hi).monotone h
state_before: case refine'_2
o : Ordinal
f : (b : Ordinal) → b < o → Ordinal → Ordinal
ho : o ≠ 0
H : ∀ (i : Ordinal) (hi : i < o), IsNormal (f i hi)
a : Ordinal
b : Ordinal
h : b ≤ nfpBFamily o f a
i : Ordinal
hi : i < o
⊢ f i hi b ≤ f i hi (nfpBFamily o f a)
Theorem: Array.foldrM_eq_foldrM_data
File: Std/Data/Array/Init/Lemmas.lean

tactic: rw [foldrM_eq_reverse_foldlM_data, List.foldlM_reverse]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝ : Monad m
f : α → β → m β
init : β
arr : Array α
⊢ foldrM f init arr (size arr) = List.foldrM f init arr.data
Theorem: ContinuousMap.uniformInducing_equivBoundedOfCompact
File: Mathlib/Topology/ContinuousFunction/Compact.lean

tactic: simp only [hasBasis_compactConvergenceUniformity.mem_iff, uniformity_basis_dist_le.mem_iff]
state_before: α : Type u_1
β : Type u_2
E : Type ?u.908
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
⊢ ∀ (s : Set (C(α, β) × C(α, β))),
    s ∈ uniformity C(α, β) ↔
      ∃ t,
        t ∈ uniformity (α →ᵇ β) ∧
          ∀ (x y : C(α, β)), (↑(equivBoundedOfCompact α β) x, ↑(equivBoundedOfCompact α β) y) ∈ t → (x, y) ∈ s

tactic: exact fun s =>
  ⟨fun ⟨⟨a, b⟩, ⟨_, ⟨ε, hε, hb⟩⟩, hs⟩ =>
    ⟨{ p | ∀ x, (p.1 x, p.2 x) ∈ b }, ⟨ε, hε, fun _ h x => hb ((dist_le hε.le).mp h x)⟩,
      fun f g h => hs fun x _ => h x⟩,
    fun ⟨_, ⟨ε, hε, ht⟩, hs⟩ =>
    ⟨⟨Set.univ, { p | dist p.1 p.2 ≤ ε }⟩, ⟨isCompact_univ, ⟨ε, hε, fun _ h => h⟩⟩,
      fun ⟨f, g⟩ h => hs _ _ (ht ((dist_le hε.le).mpr fun x => h x (mem_univ x)))⟩⟩
state_before: α : Type u_1
β : Type u_2
E : Type ?u.908
inst✝³ : TopologicalSpace α
inst✝² : CompactSpace α
inst✝¹ : MetricSpace β
inst✝ : NormedAddCommGroup E
⊢ ∀ (s : Set (C(α, β) × C(α, β))),
    (∃ i,
        (IsCompact i.fst ∧ ∃ i_1, 0 < i_1 ∧ {p | dist p.fst p.snd ≤ i_1} ⊆ i.snd) ∧
          {fg | ∀ (x : α), x ∈ i.fst → (↑fg.fst x, ↑fg.snd x) ∈ i.snd} ⊆ s) ↔
      ∃ t,
        (∃ i, 0 < i ∧ {p | dist p.fst p.snd ≤ i} ⊆ t) ∧
          ∀ (x y : C(α, β)), (↑(equivBoundedOfCompact α β) x, ↑(equivBoundedOfCompact α β) y) ∈ t → (x, y) ∈ s
Theorem: CategoryTheory.Limits.MulticospanIndex.fstPiMap_π
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

tactic: simp [fstPiMap]
state_before: C : Type u
inst✝² : Category C
I : MulticospanIndex C
inst✝¹ : HasProduct I.left
inst✝ : HasProduct I.right
b : I.R
⊢ fstPiMap I ≫ Pi.π I.right b = Pi.π I.left (fstTo I b) ≫ fst I b
Theorem: CategoryTheory.Limits.hasStrictTerminalObjects_of_terminal_is_strict
File: Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean

tactic: rw [assoc, IsIso.inv_hom_id]
state_before: C : Type u
inst✝ : Category C
I : C
h : ∀ (A : C) (f : I ⟶ A), IsIso f
I' A : C
f : I' ⟶ A
hI' : IsTerminal I'
this : IsIso (IsTerminal.from hI' I ≫ f)
⊢ (inv (IsTerminal.from hI' I ≫ f) ≫ IsTerminal.from hI' I) ≫ f = 𝟙 A
Theorem: hasFDerivWithinAt_inter
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: simp [HasFDerivWithinAt, nhdsWithin_restrict' s h]
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.236817
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.236912
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : t ∈ 𝓝 x
⊢ HasFDerivWithinAt f f' (s ∩ t) x ↔ HasFDerivWithinAt f f' s x
Theorem: Complex.exists_root
File: Mathlib/Analysis/Complex/Polynomial.lean

tactic: contrapose! hf
state_before: f : ℂ[X]
hf : 0 < degree f
⊢ ∃ z, IsRoot f z

tactic: obtain ⟨c, hc⟩ := (f.differentiable.inv hf).exists_const_forall_eq_of_bounded this
state_before: f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
this : Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
⊢ degree f ≤ 0

tactic: obtain ⟨z₀, h₀⟩ := f.exists_forall_norm_le
state_before: case this
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
⊢ Metric.Bounded (Set.range (fun x => eval x f)⁻¹)

tactic: simp only [Pi.inv_apply, bounded_iff_forall_norm_le, Set.forall_range_iff, norm_inv]
state_before: case this.intro
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
z₀ : ℂ
h₀ : ∀ (y : ℂ), ‖eval z₀ f‖ ≤ ‖eval y f‖
⊢ Metric.Bounded (Set.range (fun x => eval x f)⁻¹)

tactic: exact ⟨‖eval z₀ f‖⁻¹, fun z => inv_le_inv_of_le (norm_pos_iff.2 <| hf z₀) (h₀ z)⟩
state_before: case this.intro
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
z₀ : ℂ
h₀ : ∀ (y : ℂ), ‖eval z₀ f‖ ≤ ‖eval y f‖
⊢ ∃ C, ∀ (i : ℂ), ‖eval i f‖⁻¹ ≤ C

tactic: obtain rfl : f = C c⁻¹ := Polynomial.funext fun z => by rw [eval_C, ← hc z, inv_inv]
state_before: case intro
f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
this : Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
c : ℂ
hc : ∀ (z : ℂ), (eval z f)⁻¹ = c
⊢ degree f ≤ 0

tactic: exact degree_C_le
state_before: case intro
c : ℂ
hf : ∀ (z : ℂ), ¬IsRoot (↑C c⁻¹) z
this : Metric.Bounded (Set.range (fun x => eval x (↑C c⁻¹))⁻¹)
hc : ∀ (z : ℂ), (eval z (↑C c⁻¹))⁻¹ = c
⊢ degree (↑C c⁻¹) ≤ 0

tactic: rw [eval_C, ← hc z, inv_inv]
state_before: f : ℂ[X]
hf : ∀ (z : ℂ), ¬IsRoot f z
this : Metric.Bounded (Set.range (fun x => eval x f)⁻¹)
c : ℂ
hc : ∀ (z : ℂ), (eval z f)⁻¹ = c
z : ℂ
⊢ eval z f = eval z (↑C c⁻¹)
Theorem: equicontinuous_iff_continuous
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: simp_rw [Equicontinuous, continuous_iff_continuousAt, equicontinuousAt_iff_continuousAt]
state_before: ι : Type u_1
κ : Type ?u.79183
X : Type u_2
Y : Type ?u.79189
Z : Type ?u.79192
α : Type u_3
β : Type ?u.79198
γ : Type ?u.79201
𝓕 : Type ?u.79204
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
F : ι → X → α
⊢ Equicontinuous F ↔ Continuous (↑UniformFun.ofFun ∘ Function.swap F)
Theorem: Nat.digits_getLast
File: Mathlib/Data/Nat/Digits.lean

tactic: by_cases hm : m = 0
state_before: n b m : ℕ
h : 1 < b
p : digits b m ≠ []
q : digits b (m / b) ≠ []
⊢ List.getLast (digits b m) p = List.getLast (digits b (m / b)) q

tactic: simp only [digits_eq_cons_digits_div h hm]
state_before: case neg
n b m : ℕ
h : 1 < b
p : digits b m ≠ []
q : digits b (m / b) ≠ []
hm : ¬m = 0
⊢ List.getLast (digits b m) p = List.getLast (digits b (m / b)) q

tactic: rw [List.getLast_cons]
state_before: case neg
n b m : ℕ
h : 1 < b
p : digits b m ≠ []
q : digits b (m / b) ≠ []
hm : ¬m = 0
⊢ List.getLast (m % b :: digits b (m / b)) (_ : m % b :: digits b (m / b) ≠ []) = List.getLast (digits b (m / b)) q

tactic: simp [hm]
state_before: case pos
n b m : ℕ
h : 1 < b
p : digits b m ≠ []
q : digits b (m / b) ≠ []
hm : m = 0
⊢ List.getLast (digits b m) p = List.getLast (digits b (m / b)) q
Theorem: Finset.lcm_dvd_iff
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: apply Iff.trans Multiset.lcm_dvd
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1482
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ lcm s f ∣ a ↔ ∀ (b : β), b ∈ s → f b ∣ a

tactic: simp only [Multiset.mem_map, and_imp, exists_imp]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1482
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ (b : α), b ∈ Multiset.map f s.val → b ∣ a) ↔ ∀ (b : β), b ∈ s → f b ∣ a

tactic: exact ⟨fun k b hb ↦ k _ _ hb rfl, fun k a' b hb h ↦ h ▸ k _ hb⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1482
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (∀ (b : α) (x : β), x ∈ s.val → f x = b → b ∣ a) ↔ ∀ (b : β), b ∈ s → f b ∣ a
Theorem: Ordinal.deriv_eq_enumOrd
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: convert derivFamily_eq_enumOrd fun _ : Unit => H
state_before: f : Ordinal → Ordinal
H : IsNormal f
⊢ deriv f = enumOrd (fixedPoints f)

tactic: exact (Set.iInter_const _).symm
state_before: case h.e'_3.h.e'_1
f : Ordinal → Ordinal
H : IsNormal f
⊢ fixedPoints f = ⋂ (i : Unit), fixedPoints f
Theorem: List.perm_insertionSort
File: Mathlib/Data/List/Sort.lean

tactic: simpa [insertionSort] using (perm_orderedInsert _ _ _).trans ((perm_insertionSort l).cons b)
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
b : α
l : List α
⊢ insertionSort r (b :: l) ~ b :: l
Theorem: CategoryTheory.Limits.kernelSubobject_factors
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp
state_before: C : Type u
inst✝² : Category C
X Y Z : C
inst✝¹ : HasZeroMorphisms C
f : X ⟶ Y
inst✝ : HasKernel f
W : C
h : W ⟶ X
w : h ≫ f = 0
⊢ kernel.lift f h w ≫ MonoOver.arrow (MonoOver.mk' (kernel.ι f)) = h
Theorem: Set.singleton_sigma_singleton
File: Mathlib/Data/Set/Sigma.lean

tactic: rw [sigma_singleton, image_singleton]
state_before: ι : Type u_1
ι' : Type ?u.8240
α : ι → Type u_2
β : ι → Type ?u.8250
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a✝ : α i
a : (i : ι) → α i
⊢ (Set.Sigma {i} fun i => {a i}) = {{ fst := i, snd := a i }}
Theorem: conjugate_le_conjugate'
File: Mathlib/Algebra/Star/Order.lean

tactic: simpa only [star_star] using conjugate_le_conjugate hab (star c)
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a b : R
hab : a ≤ b
c : R
⊢ c * a * star c ≤ c * b * star c
Theorem: Function.Surjective.isBezout
File: Mathlib/RingTheory/Bezout.lean

tactic: rw [iff_span_pair_isPrincipal]
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
⊢ IsBezout S

tactic: intro x y
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
⊢ ∀ (x y : S), Submodule.IsPrincipal (Ideal.span {x, y})

tactic: obtain ⟨⟨x, rfl⟩, ⟨y, rfl⟩⟩ := hf x, hf y
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
x y : S
⊢ Submodule.IsPrincipal (Ideal.span {x, y})

tactic: use f (gcd x y)
state_before: case intro.intro
R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
x y : R
⊢ Submodule.IsPrincipal (Ideal.span {↑f x, ↑f y})

tactic: trans Ideal.map f (Ideal.span {gcd x y})
state_before: case intro.intro
R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
x y : R
⊢ Ideal.span {↑f x, ↑f y} = Submodule.span S {↑f (gcd x y)}

tactic: rw [span_gcd, Ideal.map_span, Set.image_insert_eq, Set.image_singleton]
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
x y : R
⊢ Ideal.span {↑f x, ↑f y} = Ideal.map f (Ideal.span {gcd x y})

tactic: rw [Ideal.map_span, Set.image_singleton]
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
x y : R
⊢ Ideal.map f (Ideal.span {gcd x y}) = Submodule.span S {↑f (gcd x y)}

tactic: rfl
state_before: R : Type u
inst✝² : CommRing R
S : Type v
inst✝¹ : CommRing S
f : R →+* S
hf : Function.Surjective ↑f
inst✝ : IsBezout R
x y : R
⊢ Ideal.span {↑f (gcd x y)} = Submodule.span S {↑f (gcd x y)}
Theorem: sum_div_card_sq_le_sum_sq_div_card
File: Mathlib/Algebra/Order/Chebyshev.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.24207
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
⊢ ((∑ i in s, f i) / ↑(card s)) ^ 2 ≤ (∑ i in s, f i ^ 2) / ↑(card s)

tactic: rw [← card_pos, ← @Nat.cast_pos α] at hs
state_before: case inr
ι : Type u_2
α : Type u_1
β : Type ?u.24207
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : Finset.Nonempty s
⊢ ((∑ i in s, f i) / ↑(card s)) ^ 2 ≤ (∑ i in s, f i ^ 2) / ↑(card s)

tactic: rw [div_pow, div_le_div_iff (sq_pos_of_ne_zero _ hs.ne') hs, sq (s.card : α), mul_left_comm, ←
  mul_assoc]
state_before: case inr
ι : Type u_2
α : Type u_1
β : Type ?u.24207
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : 0 < ↑(card s)
⊢ ((∑ i in s, f i) / ↑(card s)) ^ 2 ≤ (∑ i in s, f i ^ 2) / ↑(card s)

tactic: exact mul_le_mul_of_nonneg_right sq_sum_le_card_mul_sum_sq hs.le
state_before: case inr
ι : Type u_2
α : Type u_1
β : Type ?u.24207
inst✝ : LinearOrderedField α
s : Finset ι
f : ι → α
hs : 0 < ↑(card s)
⊢ (∑ i in s, f i) ^ 2 * ↑(card s) ≤ (↑(card s) * ∑ i in s, f i ^ 2) * ↑(card s)

tactic: simp
state_before: case inl
ι : Type u_2
α : Type u_1
β : Type ?u.24207
inst✝ : LinearOrderedField α
f : ι → α
⊢ ((∑ i in ∅, f i) / ↑(card ∅)) ^ 2 ≤ (∑ i in ∅, f i ^ 2) / ↑(card ∅)