tasksource/leandojo huggingface dataset:
Theorem: Filter.tendsto_const_mul_pow_atTop_iff
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: refine' ⟨fun h => ⟨_, _⟩, fun h => tendsto_const_mul_pow_atTop h.1 h.2⟩
state_before: ι : Type ?u.223673
ι' : Type ?u.223676
α : Type u_1
β : Type ?u.223682
γ : Type ?u.223685
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
⊢ Tendsto (fun x => c * x ^ n) atTop atTop ↔ n ≠ 0 ∧ 0 < c

tactic: rintro rfl
state_before: case refine'_1
ι : Type ?u.223673
ι' : Type ?u.223676
α : Type u_1
β : Type ?u.223682
γ : Type ?u.223685
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
h : Tendsto (fun x => c * x ^ n) atTop atTop
⊢ n ≠ 0

tactic: simp only [pow_zero, not_tendsto_const_atTop] at h
state_before: case refine'_1
ι : Type ?u.223673
ι' : Type ?u.223676
α : Type u_1
β : Type ?u.223682
γ : Type ?u.223685
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
h : Tendsto (fun x => c * x ^ 0) atTop atTop
⊢ False

tactic: rcases((h.eventually_gt_atTop 0).and (eventually_ge_atTop 0)).exists with ⟨k, hck, hk⟩
state_before: case refine'_2
ι : Type ?u.223673
ι' : Type ?u.223676
α : Type u_1
β : Type ?u.223682
γ : Type ?u.223685
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
h : Tendsto (fun x => c * x ^ n) atTop atTop
⊢ 0 < c

tactic: exact pos_of_mul_pos_left hck (pow_nonneg hk _)
state_before: case refine'_2.intro.intro
ι : Type ?u.223673
ι' : Type ?u.223676
α : Type u_1
β : Type ?u.223682
γ : Type ?u.223685
inst✝ : LinearOrderedSemifield α
l : Filter β
f : β → α
r c : α
n : ℕ
h : Tendsto (fun x => c * x ^ n) atTop atTop
k : α
hck : 0 < c * k ^ n
hk : 0 ≤ k
⊢ 0 < c
Theorem: EReal.add_lt_add_of_lt_of_le'
File: Mathlib/Data/Real/EReal.lean

tactic: rcases h'.eq_or_lt with (rfl | hlt)
state_before: x y z t : EReal
h : x < y
h' : z ≤ t
hbot : t ≠ ⊥
htop : t = ⊤ → z = ⊤ → x = ⊥
⊢ x + z < y + t

tactic: rcases eq_or_ne z ⊤ with (rfl | hz)
state_before: case inl
x y z : EReal
h : x < y
h' : z ≤ z
hbot : z ≠ ⊥
htop : z = ⊤ → z = ⊤ → x = ⊥
⊢ x + z < y + z

tactic: lift z to ℝ using ⟨hz, hbot⟩
state_before: case inl.inr
x y z : EReal
h : x < y
h' : z ≤ z
hbot : z ≠ ⊥
htop : z = ⊤ → z = ⊤ → x = ⊥
hz : z ≠ ⊤
⊢ x + z < y + z

tactic: exact add_lt_add_right_coe h z
state_before: case inl.inr.intro
x y : EReal
h : x < y
z : ℝ
h' : ↑z ≤ ↑z
hbot : ↑z ≠ ⊥
htop : ↑z = ⊤ → ↑z = ⊤ → x = ⊥
hz : ↑z ≠ ⊤
⊢ x + ↑z < y + ↑z

tactic: obtain rfl := htop rfl rfl
state_before: case inl.inl
x y : EReal
h : x < y
h' : ⊤ ≤ ⊤
hbot : ⊤ ≠ ⊥
htop : ⊤ = ⊤ → ⊤ = ⊤ → x = ⊥
⊢ x + ⊤ < y + ⊤

tactic: simpa
state_before: case inl.inl
y : EReal
h' : ⊤ ≤ ⊤
hbot : ⊤ ≠ ⊥
h : ⊥ < y
htop : ⊤ = ⊤ → ⊤ = ⊤ → ⊥ = ⊥
⊢ ⊥ + ⊤ < y + ⊤

tactic: exact add_lt_add h hlt
state_before: case inr
x y z t : EReal
h : x < y
h' : z ≤ t
hbot : t ≠ ⊥
htop : t = ⊤ → z = ⊤ → x = ⊥
hlt : z < t
⊢ x + z < y + t
Theorem: padicNorm.sum_lt
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: refine' s.induction_on (by rintro ⟨-, ⟨⟩⟩) _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
⊢ Finset.Nonempty s → (∀ (i : α), i ∈ s → padicNorm p (F i) < t) → padicNorm p (∑ i in s, F i) < t

tactic: rintro a S haS IH - ht
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
⊢ ∀ ⦃a : α⦄ {s : Finset α},
    ¬a ∈ s →
      (Finset.Nonempty s → (∀ (i : α), i ∈ s → padicNorm p (F i) < t) → padicNorm p (∑ i in s, F i) < t) →
        Finset.Nonempty (insert a s) →
          (∀ (i : α), i ∈ insert a s → padicNorm p (F i) < t) → padicNorm p (∑ i in insert a s, F i) < t

tactic: by_cases hs : S.Nonempty
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) < t) → padicNorm p (∑ i in S, F i) < t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) < t
⊢ padicNorm p (∑ i in insert a S, F i) < t

tactic: rintro ⟨-, ⟨⟩⟩
state_before: p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
⊢ Finset.Nonempty ∅ → (∀ (i : α), i ∈ ∅ → padicNorm p (F i) < t) → padicNorm p (∑ i in ∅, F i) < t

tactic: rw [Finset.sum_insert haS]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) < t) → padicNorm p (∑ i in S, F i) < t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) < t
hs : Finset.Nonempty S
⊢ padicNorm p (∑ i in insert a S, F i) < t

tactic: exact
  lt_of_le_of_lt padicNorm.nonarchimedean
    (max_lt (ht a (Finset.mem_insert_self a S))
      (IH hs fun b hb ↦ ht b (Finset.mem_insert_of_mem hb)))
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) < t) → padicNorm p (∑ i in S, F i) < t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) < t
hs : Finset.Nonempty S
⊢ padicNorm p (F a + ∑ x in S, F x) < t

tactic: simp_all
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
α : Type u_1
F : α → ℚ
t : ℚ
s : Finset α
a : α
S : Finset α
haS : ¬a ∈ S
IH : Finset.Nonempty S → (∀ (i : α), i ∈ S → padicNorm p (F i) < t) → padicNorm p (∑ i in S, F i) < t
ht : ∀ (i : α), i ∈ insert a S → padicNorm p (F i) < t
hs : ¬Finset.Nonempty S
⊢ padicNorm p (∑ i in insert a S, F i) < t
Theorem: Nat.Prime.irrational_sqrt
File: Mathlib/Data/Real/Irrational.lean

tactic: simp [multiplicity.multiplicity_self
  (mt isUnit_iff_dvd_one.1 (mt Int.coe_nat_dvd.1 hp.not_dvd_one))]
state_before: p : ℕ
hp : Prime p
⊢ Part.get (multiplicity ↑p ↑p) (_ : multiplicity.Finite ↑p ↑p) % 2 = 1
Theorem: Matrix.mul_invOf_self_assoc
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [← Matrix.mul_assoc, Matrix.mul_invOf_self, Matrix.one_mul]
state_before: l : Type ?u.9084
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A : Matrix n n α
B : Matrix n m α
inst✝ : Invertible A
⊢ A ⬝ (⅟A ⬝ B) = B
Theorem: Set.image_sub_const_Icc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Icc b c = Icc (b - a) (c - a)
Theorem: MeasureTheory.Measure.InnerRegular.smul
File: Mathlib/MeasureTheory/Measure/Regular.lean

tactic: intro U hU r hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U : Set α
ε : ℝ≥0∞
H : InnerRegular μ p q
c : ℝ≥0∞
⊢ InnerRegular (c • μ) p q

tactic: rw [smul_apply, H.measure_eq_iSup hU, smul_eq_mul] at hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
H : InnerRegular μ p q
c : ℝ≥0∞
U : Set α
hU : q U
r : ℝ≥0∞
hr : r < ↑↑(c • μ) U
⊢ ∃ K, K ⊆ U ∧ p K ∧ r < ↑↑(c • μ) K

tactic: simpa only [ENNReal.mul_iSup, lt_iSup_iff, exists_prop] using hr
state_before: α : Type u_1
m : MeasurableSpace α
μ : Measure α
p q : Set α → Prop
U✝ : Set α
ε : ℝ≥0∞
H : InnerRegular μ p q
c : ℝ≥0∞
U : Set α
hU : q U
r : ℝ≥0∞
hr : r < c * ⨆ (K : Set α) (_ : K ⊆ U) (_ : p K), ↑↑μ K
⊢ ∃ K, K ⊆ U ∧ p K ∧ r < ↑↑(c • μ) K
Theorem: MaximalSpectrum.toPrimeSpectrum_injective
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Maximal.lean

tactic: simpa only [MaximalSpectrum.mk.injEq] using (PrimeSpectrum.ext_iff _ _).mp h
state_before: R : Type u
inst✝ : CommRing R
x✝¹ x✝ : MaximalSpectrum R
asIdeal✝¹ : Ideal R
IsMaximal✝¹ : Ideal.IsMaximal asIdeal✝¹
asIdeal✝ : Ideal R
IsMaximal✝ : Ideal.IsMaximal asIdeal✝
h :
  toPrimeSpectrum { asIdeal := asIdeal✝¹, IsMaximal := IsMaximal✝¹ } =
    toPrimeSpectrum { asIdeal := asIdeal✝, IsMaximal := IsMaximal✝ }
⊢ { asIdeal := asIdeal✝¹, IsMaximal := IsMaximal✝¹ } = { asIdeal := asIdeal✝, IsMaximal := IsMaximal✝ }
Theorem: HahnSeries.order_pow
File: Mathlib/RingTheory/HahnSeries.lean

tactic: induction' n with h IH
state_before: Γ✝ : Type ?u.1298389
R : Type u_2
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_1
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
x : HahnSeries Γ R
n : ℕ
⊢ order (x ^ n) = n • order x

tactic: rcases eq_or_ne x 0 with (rfl | hx)
state_before: case succ
Γ✝ : Type ?u.1298389
R : Type u_2
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_1
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
x : HahnSeries Γ R
h : ℕ
IH : order (x ^ h) = h • order x
⊢ order (x ^ Nat.succ h) = Nat.succ h • order x

tactic: rw [pow_succ', order_mul (pow_ne_zero _ hx) hx, succ_nsmul', IH]
state_before: case succ.inr
Γ✝ : Type ?u.1298389
R : Type u_2
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_1
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
x : HahnSeries Γ R
h : ℕ
IH : order (x ^ h) = h • order x
hx : x ≠ 0
⊢ order (x ^ Nat.succ h) = Nat.succ h • order x

tactic: simp
state_before: case zero
Γ✝ : Type ?u.1298389
R : Type u_2
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_1
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
x : HahnSeries Γ R
⊢ order (x ^ Nat.zero) = Nat.zero • order x

tactic: simp
state_before: case succ.inl
Γ✝ : Type ?u.1298389
R : Type u_2
inst✝³ : OrderedCancelAddCommMonoid Γ✝
Γ : Type u_1
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
h : ℕ
IH : order (0 ^ h) = h • order 0
⊢ order (0 ^ Nat.succ h) = Nat.succ h • order 0
Theorem: Cardinal.mk_vector
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α✝ β α : Type u
n : ℕ
⊢ (#Fin n → α) = (#α) ^ n
Theorem: Concept.snd_subset_snd_iff
File: Mathlib/Order/Concept.lean

tactic: refine' ⟨fun h => _, fun h => _⟩
state_before: ι : Sort ?u.9043
α : Type u_2
β : Type u_1
γ : Type ?u.9052
κ : ι → Sort ?u.9057
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
⊢ c.snd ⊆ d.snd ↔ d ≤ c

tactic: rw [← fst_subset_fst_iff, ← c.closure_snd, ← d.closure_snd]
state_before: case refine'_1
ι : Sort ?u.9043
α : Type u_2
β : Type u_1
γ : Type ?u.9052
κ : ι → Sort ?u.9057
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.snd ⊆ d.snd
⊢ d ≤ c

tactic: exact extentClosure_anti _ h
state_before: case refine'_1
ι : Sort ?u.9043
α : Type u_2
β : Type u_1
γ : Type ?u.9052
κ : ι → Sort ?u.9057
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : c.snd ⊆ d.snd
⊢ extentClosure r d.snd ⊆ extentClosure r c.snd

tactic: rw [← c.closure_fst, ← d.closure_fst]
state_before: case refine'_2
ι : Sort ?u.9043
α : Type u_2
β : Type u_1
γ : Type ?u.9052
κ : ι → Sort ?u.9057
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : d ≤ c
⊢ c.snd ⊆ d.snd

tactic: exact intentClosure_anti _ h
state_before: case refine'_2
ι : Sort ?u.9043
α : Type u_2
β : Type u_1
γ : Type ?u.9052
κ : ι → Sort ?u.9057
r : α → β → Prop
s s₁ s₂ : Set α
t t₁ t₂ : Set β
c d : Concept α β r
h : d ≤ c
⊢ intentClosure r c.fst ⊆ intentClosure r d.fst
Theorem: Nat.div_lt_iff_lt_mul
File: Std/Data/Nat/Lemmas.lean

tactic: rw [← Nat.not_le, ← Nat.not_le]
state_before: k x y : Nat
Hk : 0 < k
⊢ x / k < y ↔ x < y * k

tactic: exact not_congr (le_div_iff_mul_le Hk)
state_before: k x y : Nat
Hk : 0 < k
⊢ ¬y ≤ x / k ↔ ¬y * k ≤ x
Theorem: exists_open_with_compact_closure
File: Mathlib/Topology/Separation.lean

tactic: rcases exists_compact_mem_nhds x with ⟨K, hKc, hxK⟩
state_before: α : Type u
β : Type v
inst✝⁴ : TopologicalSpace α
γ : Type ?u.140885
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : LocallyCompactSpace α
inst✝ : T2Space α
x : α
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ IsCompact (closure U)

tactic: rcases mem_nhds_iff.1 hxK with ⟨t, h1t, h2t, h3t⟩
state_before: case intro.intro
α : Type u
β : Type v
inst✝⁴ : TopologicalSpace α
γ : Type ?u.140885
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : LocallyCompactSpace α
inst✝ : T2Space α
x : α
K : Set α
hKc : IsCompact K
hxK : K ∈ 𝓝 x
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ IsCompact (closure U)

tactic: exact ⟨t, h2t, h3t, isCompact_closure_of_subset_compact hKc h1t⟩
state_before: case intro.intro.intro.intro.intro
α : Type u
β : Type v
inst✝⁴ : TopologicalSpace α
γ : Type ?u.140885
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : LocallyCompactSpace α
inst✝ : T2Space α
x : α
K : Set α
hKc : IsCompact K
hxK : K ∈ 𝓝 x
t : Set α
h1t : t ⊆ K
h2t : IsOpen t
h3t : x ∈ t
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ IsCompact (closure U)
Theorem: IsGLB.insert
File: Mathlib/Order/Bounds/Basic.lean

tactic: rw [insert_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : SemilatticeInf γ
a b : γ
s : Set γ
hs : IsGLB s b
⊢ IsGLB (Insert.insert a s) (a ⊓ b)

tactic: exact isGLB_singleton.union hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : SemilatticeInf γ
a b : γ
s : Set γ
hs : IsGLB s b
⊢ IsGLB ({a} ∪ s) (a ⊓ b)
Theorem: IsLocalization.mk'_mem_iff
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: constructor <;> intro h
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.672634
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
I : Ideal S
⊢ mk' S x y ∈ I ↔ ↑(algebraMap R S) x ∈ I

tactic: rw [← mk'_spec S x y, mul_comm]
state_before: case mp
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.672634
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
I : Ideal S
h : mk' S x y ∈ I
⊢ ↑(algebraMap R S) x ∈ I

tactic: exact I.mul_mem_left ((algebraMap R S) y) h
state_before: case mp
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.672634
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
I : Ideal S
h : mk' S x y ∈ I
⊢ ↑(algebraMap R S) ↑y * mk' S x y ∈ I

tactic: rw [← mk'_spec S x y] at h
state_before: case mpr
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.672634
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
I : Ideal S
h : ↑(algebraMap R S) x ∈ I
⊢ mk' S x y ∈ I

tactic: obtain ⟨b, hb⟩ := isUnit_iff_exists_inv.1 (map_units S y)
state_before: case mpr
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.672634
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
I : Ideal S
h : mk' S x y * ↑(algebraMap R S) ↑y ∈ I
⊢ mk' S x y ∈ I

tactic: have := I.mul_mem_left b h
state_before: case mpr.intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.672634
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
I : Ideal S
h : mk' S x y * ↑(algebraMap R S) ↑y ∈ I
b : S
hb : ↑(algebraMap R S) ↑y * b = 1
⊢ mk' S x y ∈ I

tactic: rwa [mul_comm, mul_assoc, hb, mul_one] at this
state_before: case mpr.intro
R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type ?u.672634
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : { x // x ∈ M }
I : Ideal S
h : mk' S x y * ↑(algebraMap R S) ↑y ∈ I
b : S
hb : ↑(algebraMap R S) ↑y * b = 1
this : b * (mk' S x y * ↑(algebraMap R S) ↑y) ∈ I
⊢ mk' S x y ∈ I
Theorem: BoundedContinuousFunction.nndist_eq_iSup
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

tactic: simp_rw [val_eq_coe, coe_iSup, coe_nndist]
state_before: F : Type ?u.308003
α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : PseudoMetricSpace β
inst✝ : PseudoMetricSpace γ
f g : α →ᵇ β
x : α
C : ℝ
⊢ (⨆ (x : α), dist (↑f x) (↑g x)) = ↑(⨆ (x : α), nndist (↑f x) (↑g x))
Theorem: List.zipWith_nil_right
File: Mathlib/Data/List/Zip.lean

tactic: simp
state_before: α : Type u
β : Type u_2
γ : Type u_1
δ : Type ?u.385
ε : Type ?u.388
f : α → β → γ
l : List α
⊢ zipWith f l [] = []
Theorem: Filter.exists_forall_mem_of_hasBasis_mem_blimsup
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [blimsup_eq_iInf_biSup] at hx
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.183305
ι : Type u_2
p✝ : ι → Prop
s : ι → Set α
l : Filter β
b : ι → Set β
q : ι → Prop
hl : HasBasis l q b
u : β → Set α
p : β → Prop
x : α
hx : x ∈ blimsup u l p
⊢ ∃ f, ∀ (i : ↑{i | q i}), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b ↑i

tactic: simp only [iSup_eq_iUnion, iInf_eq_iInter, mem_iInter, mem_iUnion, exists_prop] at hx
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.183305
ι : Type u_2
p✝ : ι → Prop
s : ι → Set α
l : Filter β
b : ι → Set β
q : ι → Prop
hl : HasBasis l q b
u : β → Set α
p : β → Prop
x : α
hx : x ∈ ⨅ (s : Set β) (_ : s ∈ l), ⨆ (b : β) (_ : p b ∧ b ∈ s), u b
⊢ ∃ f, ∀ (i : ↑{i | q i}), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b ↑i

tactic: choose g hg hg' using hx
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.183305
ι : Type u_2
p✝ : ι → Prop
s : ι → Set α
l : Filter β
b : ι → Set β
q : ι → Prop
hl : HasBasis l q b
u : β → Set α
p : β → Prop
x : α
hx : ∀ (i : Set β), i ∈ l → ∃ i_2, (p i_2 ∧ i_2 ∈ i) ∧ x ∈ u i_2
⊢ ∃ f, ∀ (i : ↑{i | q i}), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b ↑i

tactic: refine' ⟨fun i : { i | q i } => g (b i) (hl.mem_of_mem i.2), fun i => ⟨_, _⟩⟩
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.183305
ι : Type u_2
p✝ : ι → Prop
s : ι → Set α
l : Filter β
b : ι → Set β
q : ι → Prop
hl : HasBasis l q b
u : β → Set α
p : β → Prop
x : α
g : (i : Set β) → i ∈ l → β
hg : ∀ (i : Set β) (i_1 : i ∈ l), p (g i i_1) ∧ g i i_1 ∈ i
hg' : ∀ (i : Set β) (i_1 : i ∈ l), x ∈ u (g i i_1)
⊢ ∃ f, ∀ (i : ↑{i | q i}), x ∈ u (f i) ∧ p (f i) ∧ f i ∈ b ↑i

tactic: exact hg' (b i) (hl.mem_of_mem i.2)
state_before: case refine'_1
α : Type u_3
β : Type u_1
γ : Type ?u.183305
ι : Type u_2
p✝ : ι → Prop
s : ι → Set α
l : Filter β
b : ι → Set β
q : ι → Prop
hl : HasBasis l q b
u : β → Set α
p : β → Prop
x : α
g : (i : Set β) → i ∈ l → β
hg : ∀ (i : Set β) (i_1 : i ∈ l), p (g i i_1) ∧ g i i_1 ∈ i
hg' : ∀ (i : Set β) (i_1 : i ∈ l), x ∈ u (g i i_1)
i : ↑{i | q i}
⊢ x ∈ u ((fun i => g (b ↑i) (_ : b ↑i ∈ l)) i)

tactic: exact hg (b i) (hl.mem_of_mem i.2)
state_before: case refine'_2
α : Type u_3
β : Type u_1
γ : Type ?u.183305
ι : Type u_2
p✝ : ι → Prop
s : ι → Set α
l : Filter β
b : ι → Set β
q : ι → Prop
hl : HasBasis l q b
u : β → Set α
p : β → Prop
x : α
g : (i : Set β) → i ∈ l → β
hg : ∀ (i : Set β) (i_1 : i ∈ l), p (g i i_1) ∧ g i i_1 ∈ i
hg' : ∀ (i : Set β) (i_1 : i ∈ l), x ∈ u (g i i_1)
i : ↑{i | q i}
⊢ p ((fun i => g (b ↑i) (_ : b ↑i ∈ l)) i) ∧ (fun i => g (b ↑i) (_ : b ↑i ∈ l)) i ∈ b ↑i
Theorem: Bool.or_coe_iff
File: Mathlib/Init/Data/Bool/Lemmas.lean

tactic: simp
state_before: a b : Bool
⊢ (a || b) = true ↔ a = true ∨ b = true
Theorem: Nat.le_find_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: simp_rw [← not_lt, find_lt_iff, not_exists, not_and]
state_before: m n✝ k : ℕ
p q : ℕ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n : ℕ
⊢ n ≤ Nat.find h ↔ ∀ (m : ℕ), m < n → ¬p m
Theorem: IsClosed.exists_closed_singleton
File: Mathlib/Topology/Separation.lean

tactic: obtain ⟨V, Vsub, Vne, Vcls, hV⟩ := hS.exists_minimal_nonempty_closed_subset hne
state_before: α✝ : Type u
β : Type v
inst✝³ : TopologicalSpace α✝
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T0Space α
inst✝ : CompactSpace α
S : Set α
hS : IsClosed S
hne : Set.Nonempty S
⊢ ∃ x, x ∈ S ∧ IsClosed {x}

tactic: rcases minimal_nonempty_closed_eq_singleton Vcls Vne hV with ⟨x, rfl⟩
state_before: case intro.intro.intro.intro
α✝ : Type u
β : Type v
inst✝³ : TopologicalSpace α✝
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T0Space α
inst✝ : CompactSpace α
S : Set α
hS : IsClosed S
hne : Set.Nonempty S
V : Set α
Vsub : V ⊆ S
Vne : Set.Nonempty V
Vcls : IsClosed V
hV : ∀ (V' : Set α), V' ⊆ V → Set.Nonempty V' → IsClosed V' → V' = V
⊢ ∃ x, x ∈ S ∧ IsClosed {x}

tactic: exact ⟨x, Vsub (mem_singleton x), Vcls⟩
state_before: case intro.intro.intro.intro.intro
α✝ : Type u
β : Type v
inst✝³ : TopologicalSpace α✝
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : T0Space α
inst✝ : CompactSpace α
S : Set α
hS : IsClosed S
hne : Set.Nonempty S
x : α
Vsub : {x} ⊆ S
Vne : Set.Nonempty {x}
Vcls : IsClosed {x}
hV : ∀ (V' : Set α), V' ⊆ {x} → Set.Nonempty V' → IsClosed V' → V' = {x}
⊢ ∃ x, x ∈ S ∧ IsClosed {x}
Theorem: Polynomial.HasSeparableContraction.eq_degree
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: let ⟨a, ha⟩ := hf.dvd_degree'
state_before: F : Type u_1
inst✝ : CommSemiring F
q : ℕ
f✝ : F[X]
hf✝ : HasSeparableContraction q f✝
f : F[X]
hf : HasSeparableContraction 1 f
⊢ degree hf = natDegree f

tactic: rw [← ha, one_pow a, mul_one]
state_before: F : Type u_1
inst✝ : CommSemiring F
q : ℕ
f✝ : F[X]
hf✝ : HasSeparableContraction q f✝
f : F[X]
hf : HasSeparableContraction 1 f
a : ℕ
ha : degree hf * 1 ^ a = natDegree f
⊢ degree hf = natDegree f
Theorem: Polynomial.trailingDegree_neg
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: unfold trailingDegree
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ trailingDegree (-p) = trailingDegree p

tactic: rw [support_neg]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Ring R
p : R[X]
⊢ Finset.min (support (-p)) = Finset.min (support p)
Theorem: Nat.succ_div_of_dvd
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rw [succ_div, if_pos hba]
state_before: a✝ b✝ m n k a b : ℕ
hba : b ∣ a + 1
⊢ (a + 1) / b = a / b + 1
Theorem: Ordinal.opow_limit
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: simp only [opow_def, if_neg a0]
state_before: a b : Ordinal
a0 : a ≠ 0
h : IsLimit b
⊢ a ^ b = bsup b fun c x => a ^ c

tactic: rw [limitRecOn_limit _ _ _ _ h]
state_before: a b : Ordinal
a0 : a ≠ 0
h : IsLimit b
⊢ (limitRecOn b 1 (fun x IH => IH * a) fun b x => bsup b) =
    bsup b fun c x => limitRecOn c 1 (fun x IH => IH * a) fun b x => bsup b
Theorem: Nat.choose_le_succ
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: cases c <;> simp [Nat.choose_succ_succ]
state_before: a c : ℕ
⊢ choose a c ≤ choose (succ a) c
Theorem: Finset.le_prod_of_submultiplicative
File: Mathlib/Algebra/BigOperators/Order.lean

tactic: refine' le_trans (Multiset.le_prod_of_submultiplicative f h_one h_mul _) _
state_before: ι : Type u_3
α : Type ?u.11325
β : Type ?u.11328
M : Type u_2
N : Type u_1
G : Type ?u.11337
k : Type ?u.11340
R : Type ?u.11343
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ f (∏ i in s, g i) ≤ ∏ i in s, f (g i)

tactic: rw [Multiset.map_map]
state_before: ι : Type u_3
α : Type ?u.11325
β : Type ?u.11328
M : Type u_2
N : Type u_1
G : Type ?u.11337
k : Type ?u.11340
R : Type ?u.11343
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ Multiset.prod (Multiset.map f (Multiset.map (fun i => g i) s.val)) ≤ ∏ i in s, f (g i)

tactic: rfl
state_before: ι : Type u_3
α : Type ?u.11325
β : Type ?u.11328
M : Type u_2
N : Type u_1
G : Type ?u.11337
k : Type ?u.11340
R : Type ?u.11343
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f : M → N
h_one : f 1 = 1
h_mul : ∀ (x y : M), f (x * y) ≤ f x * f y
s : Finset ι
g : ι → M
⊢ Multiset.prod (Multiset.map (f ∘ fun i => g i) s.val) ≤ ∏ i in s, f (g i)
Theorem: nndist_div_right
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: simp only [div_eq_mul_inv, nndist_mul_right]
state_before: M : Type u
G : Type v
X : Type w
inst✝² : DivInvMonoid M
inst✝¹ : PseudoMetricSpace M
inst✝ : IsometricSMul Mᵐᵒᵖ M
a b c : M
⊢ nndist (a / c) (b / c) = nndist a b
Theorem: Finset.iInf_finset_image
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [← iInf_coe, coe_image, iInf_image, iInf_coe]
state_before: F : Type ?u.451621
α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.451633
κ : Type ?u.451636
inst✝¹ : CompleteLattice β
inst✝ : DecidableEq α
f : γ → α
g : α → β
s : Finset γ
⊢ (⨅ (x : α) (_ : x ∈ image f s), g x) = ⨅ (y : γ) (_ : y ∈ s), g (f y)