tasksource/leandojo huggingface dataset:
Theorem: Ordinal.nat_cast_mod
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← add_left_cancel, div_add_mod, ← nat_cast_div, ← nat_cast_mul, ← Nat.cast_add,
  Nat.div_add_mod]
state_before: m n : ℕ
⊢ ↑(m % n) = ↑m % ↑n
Theorem: mul_inv_lt_mul_inv_iff'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_comm c, mul_inv_lt_inv_mul_iff, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b
Theorem: Finset.noncommProd_commute
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: apply Multiset.noncommProd_commute
state_before: F : Type ?u.196819
ι : Type ?u.196822
α : Type u_1
β : Type u_2
γ : Type ?u.196831
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : Set.Pairwise ↑s fun a b => Commute (f a) (f b)
y : β
h : ∀ (x : α), x ∈ s → Commute y (f x)
⊢ Commute y (noncommProd s f comm)

tactic: intro y
state_before: case h
F : Type ?u.196819
ι : Type ?u.196822
α : Type u_1
β : Type u_2
γ : Type ?u.196831
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : Set.Pairwise ↑s fun a b => Commute (f a) (f b)
y : β
h : ∀ (x : α), x ∈ s → Commute y (f x)
⊢ ∀ (x : β), x ∈ Multiset.map f s.val → Commute y x

tactic: rw [Multiset.mem_map]
state_before: case h
F : Type ?u.196819
ι : Type ?u.196822
α : Type u_1
β : Type u_2
γ : Type ?u.196831
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : Set.Pairwise ↑s fun a b => Commute (f a) (f b)
y✝ : β
h : ∀ (x : α), x ∈ s → Commute y✝ (f x)
y : β
⊢ y ∈ Multiset.map f s.val → Commute y✝ y

tactic: rintro ⟨x, ⟨hx, rfl⟩⟩
state_before: case h
F : Type ?u.196819
ι : Type ?u.196822
α : Type u_1
β : Type u_2
γ : Type ?u.196831
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : Set.Pairwise ↑s fun a b => Commute (f a) (f b)
y✝ : β
h : ∀ (x : α), x ∈ s → Commute y✝ (f x)
y : β
⊢ (∃ a, a ∈ s.val ∧ f a = y) → Commute y✝ y

tactic: exact h x hx
state_before: case h.intro.intro
F : Type ?u.196819
ι : Type ?u.196822
α : Type u_1
β : Type u_2
γ : Type ?u.196831
f✝ : α → β → β
op : α → α → α
inst✝¹ : Monoid β
inst✝ : Monoid γ
s : Finset α
f : α → β
comm : Set.Pairwise ↑s fun a b => Commute (f a) (f b)
y : β
h : ∀ (x : α), x ∈ s → Commute y (f x)
x : α
hx : x ∈ s.val
⊢ Commute y (f x)
Theorem: Finsupp.ext_iff'
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical
exact if h : a ∈ f.support then h₂ a h else by
  have hf : f a = 0 := not_mem_support_iff.1 h
  have hg : g a = 0 := by rwa [h₁, not_mem_support_iff] at h
  rw [hf, hg]
state_before: α : Type u_1
β : Type ?u.14308
γ : Type ?u.14311
ι : Type ?u.14314
M : Type u_2
M' : Type ?u.14320
N : Type ?u.14323
P : Type ?u.14326
G : Type ?u.14329
H : Type ?u.14332
R : Type ?u.14335
S : Type ?u.14338
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
h₁ : f.support = g.support
h₂ : ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
a : α
⊢ ↑f a = ↑g a

tactic: exact if h : a ∈ f.support then h₂ a h else by
  have hf : f a = 0 := not_mem_support_iff.1 h
  have hg : g a = 0 := by rwa [h₁, not_mem_support_iff] at h
  rw [hf, hg]
state_before: α : Type u_1
β : Type ?u.14308
γ : Type ?u.14311
ι : Type ?u.14314
M : Type u_2
M' : Type ?u.14320
N : Type ?u.14323
P : Type ?u.14326
G : Type ?u.14329
H : Type ?u.14332
R : Type ?u.14335
S : Type ?u.14338
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
h₁ : f.support = g.support
h₂ : ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
a : α
⊢ ↑f a = ↑g a

tactic: have hf : f a = 0 := not_mem_support_iff.1 h
state_before: α : Type u_1
β : Type ?u.14308
γ : Type ?u.14311
ι : Type ?u.14314
M : Type u_2
M' : Type ?u.14320
N : Type ?u.14323
P : Type ?u.14326
G : Type ?u.14329
H : Type ?u.14332
R : Type ?u.14335
S : Type ?u.14338
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
h₁ : f.support = g.support
h₂ : ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
a : α
h : ¬a ∈ f.support
⊢ ↑f a = ↑g a

tactic: have hg : g a = 0 := by rwa [h₁, not_mem_support_iff] at h
state_before: α : Type u_1
β : Type ?u.14308
γ : Type ?u.14311
ι : Type ?u.14314
M : Type u_2
M' : Type ?u.14320
N : Type ?u.14323
P : Type ?u.14326
G : Type ?u.14329
H : Type ?u.14332
R : Type ?u.14335
S : Type ?u.14338
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
h₁ : f.support = g.support
h₂ : ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
a : α
h : ¬a ∈ f.support
hf : ↑f a = 0
⊢ ↑f a = ↑g a

tactic: rw [hf, hg]
state_before: α : Type u_1
β : Type ?u.14308
γ : Type ?u.14311
ι : Type ?u.14314
M : Type u_2
M' : Type ?u.14320
N : Type ?u.14323
P : Type ?u.14326
G : Type ?u.14329
H : Type ?u.14332
R : Type ?u.14335
S : Type ?u.14338
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
h₁ : f.support = g.support
h₂ : ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
a : α
h : ¬a ∈ f.support
hf : ↑f a = 0
hg : ↑g a = 0
⊢ ↑f a = ↑g a

tactic: rwa [h₁, not_mem_support_iff] at h
state_before: α : Type u_1
β : Type ?u.14308
γ : Type ?u.14311
ι : Type ?u.14314
M : Type u_2
M' : Type ?u.14320
N : Type ?u.14323
P : Type ?u.14326
G : Type ?u.14329
H : Type ?u.14332
R : Type ?u.14335
S : Type ?u.14338
inst✝ : Zero M
f g : α →₀ M
x✝ : f.support = g.support ∧ ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
h₁ : f.support = g.support
h₂ : ∀ (x : α), x ∈ f.support → ↑f x = ↑g x
a : α
h : ¬a ∈ f.support
hf : ↑f a = 0
⊢ ↑g a = 0
Theorem: continuousAt_of_locally_lipschitz
File: Mathlib/Topology/MetricSpace/Lipschitz.lean

tactic: refine tendsto_iff_dist_tendsto_zero.2 (squeeze_zero' (eventually_of_forall fun _ => dist_nonneg)
  (mem_of_superset (ball_mem_nhds _ hr) h) ?_)
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
x : α
r : ℝ
hr : 0 < r
K : ℝ
h : ∀ (y : α), dist y x < r → dist (f y) (f x) ≤ K * dist y x
⊢ ContinuousAt f x

tactic: refine (continuous_const.mul (continuous_id.dist continuous_const)).tendsto' _ _ ?_
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
x : α
r : ℝ
hr : 0 < r
K : ℝ
h : ∀ (y : α), dist y x < r → dist (f y) (f x) ≤ K * dist y x
⊢ Tendsto (fun a => K * dist a x) (𝓝 x) (𝓝 0)

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
x : α
r : ℝ
hr : 0 < r
K : ℝ
h : ∀ (y : α), dist y x < r → dist (f y) (f x) ≤ K * dist y x
⊢ K * dist (id x) x = 0
Theorem: CategoryTheory.isSubterminal_of_mono_isTerminal_from
File: Mathlib/CategoryTheory/Subterminal.lean

tactic: rw [← cancel_mono (hT.from A)]
state_before: C : Type u₁
inst✝¹ : Category C
A T : C
hT : IsTerminal T
inst✝ : Mono (IsTerminal.from hT A)
Z : C
f g : Z ⟶ A
⊢ f = g

tactic: apply hT.hom_ext
state_before: C : Type u₁
inst✝¹ : Category C
A T : C
hT : IsTerminal T
inst✝ : Mono (IsTerminal.from hT A)
Z : C
f g : Z ⟶ A
⊢ f ≫ IsTerminal.from hT A = g ≫ IsTerminal.from hT A
Theorem: connectedComponentIn_nonempty_iff
File: Mathlib/Topology/Connected.lean

tactic: rw [connectedComponentIn]
state_before: α : Type u
β : Type v
ι : Type ?u.50542
π : ι → Type ?u.50547
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ Set.Nonempty (connectedComponentIn F x) ↔ x ∈ F

tactic: split_ifs <;> simp [connectedComponent_nonempty, *]
state_before: α : Type u
β : Type v
ι : Type ?u.50542
π : ι → Type ?u.50547
inst✝ : TopologicalSpace α
s t u v : Set α
x : α
F : Set α
⊢ Set.Nonempty (if h : x ∈ F then Subtype.val '' connectedComponent { val := x, property := h } else ∅) ↔ x ∈ F
Theorem: NormedAddCommGroup.tendsto_atTop'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp [dist_eq_norm]
state_before: α : Type u_1
β✝ : Type ?u.395811
γ : Type ?u.395814
ι : Type ?u.395817
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : NoMaxOrder α
β : Type u_2
inst✝ : SeminormedAddCommGroup β
f : α → β
b : β
⊢ (∀ (ib : ℝ), 0 < ib → ∃ ia, True ∧ ∀ (x : α), x ∈ Set.Ioi ia → f x ∈ ball b ib) ↔
    ∀ (ε : ℝ), 0 < ε → ∃ N, ∀ (n : α), N < n → ‖f n - b‖ < ε
Theorem: iteratedDeriv_zero
File: Mathlib/Analysis/Calculus/IteratedDeriv.lean

tactic: ext x
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.116542
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDeriv 0 f = f

tactic: simp [iteratedDeriv]
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type ?u.116542
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv 0 f x = f x
Theorem: Real.continuousAt_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean

tactic: refine' ⟨fun hc h₀ => _, fun h => (hasDerivAt_tan h).continuousAt⟩
state_before: x : ℝ
⊢ ContinuousAt tan x ↔ cos x ≠ 0

tactic: exact not_tendsto_nhds_of_tendsto_atTop (tendsto_abs_tan_of_cos_eq_zero h₀) _
  (hc.norm.tendsto.mono_left inf_le_left)
state_before: x : ℝ
hc : ContinuousAt tan x
h₀ : cos x = 0
⊢ False
Theorem: Std.AssocList.modify_toList
File: Std/Data/AssocList.lean

tactic: simp [cond]
state_before: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ toList (modify a f l) =
    List.replaceF
      (fun x =>
        match x with
        | (k, v) => bif k == a then some (a, f k v) else none)
      (toList l)

tactic: induction l with simp [List.replaceF]
| cons k v es ih => cases k == a <;> simp [ih]
state_before: α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a : α
l : AssocList α β
⊢ toList (modify a f l) =
    List.replaceF
      (fun x =>
        match x.fst == a with
        | true => some (a, f x.fst x.snd)
        | false => none)
      (toList l)

tactic: cases k == a <;> simp [ih]
state_before: case cons
α : Type u_1
β : Type u_2
f : α → β → β
inst✝ : BEq α
a k : α
v : β
es : AssocList α β
ih :
  toList (modify a f es) =
    List.replaceF
      (fun x =>
        match x.fst == a with
        | true => some (a, f x.fst x.snd)
        | false => none)
      (toList es)
⊢ toList
      (match k == a with
      | true => cons a (f k v) es
      | false => cons k v (modify a f es)) =
    match
      match k == a with
      | true => some (a, f k v)
      | false => none with
    | none =>
      (k, v) ::
        List.replaceF
          (fun x =>
            match x.fst == a with
            | true => some (a, f x.fst x.snd)
            | false => none)
          (toList es)
    | some a => a :: toList es
Theorem: List.rotate_eq_self_iff_eq_replicate
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
hα : Nonempty α
⊢ (∀ (n : ℕ), rotate [] n = []) ↔ ∃ a, [] = replicate (length []) a

tactic: rw [get_replicate, ← Option.some_inj, ← get?_eq_get, ← head?_rotate h₁, h, head?_cons]
state_before: α : Type u
hα : Nonempty α
a : α
l : List α
h : ∀ (n : ℕ), rotate (a :: l) n = a :: l
n : ℕ
h₁ : n < length (a :: l)
h₂ : n < length (replicate (length (a :: l)) a)
⊢ get (a :: l) { val := n, isLt := h₁ } = get (replicate (length (a :: l)) a) { val := n, isLt := h₂ }

tactic: rw [hb, rotate_replicate]
state_before: α : Type u
hα : Nonempty α
a : α
l : List α
x✝ : ∃ a_1, a :: l = replicate (length (a :: l)) a_1
n : ℕ
b : α
hb : a :: l = replicate (length (a :: l)) b
⊢ rotate (a :: l) n = a :: l
Theorem: IsCoercive.closed_range
File: Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean

tactic: rcases coercive.antilipschitz with ⟨_, _, antilipschitz⟩
state_before: V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
⊢ IsClosed ↑(range (continuousLinearMapOfBilin B))

tactic: exact antilipschitz.isClosed_range B♯.uniformContinuous
state_before: case intro.intro
V : Type u
inst✝² : NormedAddCommGroup V
inst✝¹ : InnerProductSpace ℝ V
inst✝ : CompleteSpace V
B : V →L[ℝ] V →L[ℝ] ℝ
coercive : IsCoercive B
w✝ : ℝ≥0
left✝ : 0 < w✝
antilipschitz : AntilipschitzWith w✝ ↑(continuousLinearMapOfBilin B)
⊢ IsClosed ↑(range (continuousLinearMapOfBilin B))
Theorem: Even.neg_one_pow
File: Mathlib/Algebra/Parity.lean

tactic: rw [h.neg_pow, one_pow]
state_before: F : Type ?u.24624
α : Type u_1
β : Type ?u.24630
R : Type ?u.24633
inst✝¹ : Monoid α
n : ℕ
a : α
inst✝ : HasDistribNeg α
h : Even n
⊢ (-1) ^ n = 1
Theorem: LinearMap.inl_map_mul
File: Mathlib/LinearAlgebra/Prod.lean

tactic: simp
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.148405
M₆ : Type ?u.148408
S : Type ?u.148411
inst✝¹⁷ : Semiring R
inst✝¹⁶ : Semiring S
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid M₂
inst✝¹³ : AddCommMonoid M₃
inst✝¹² : AddCommMonoid M₄
inst✝¹¹ : AddCommMonoid M₅
inst✝¹⁰ : AddCommMonoid M₆
inst✝⁹ : Module R M
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M₃
inst✝⁶ : Module R M₄
inst✝⁵ : Module R M₅
inst✝⁴ : Module R M₆
f : M →ₗ[R] M₂
A : Type u_1
inst✝³ : NonUnitalNonAssocSemiring A
inst✝² : Module R A
B : Type u_2
inst✝¹ : NonUnitalNonAssocSemiring B
inst✝ : Module R B
a₁ a₂ : A
⊢ (↑(inl R A B) (a₁ * a₂)).snd = (↑(inl R A B) a₁ * ↑(inl R A B) a₂).snd
Theorem: IsLocalization.ringEquivOfRingEquiv_eq
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝⁷ : CommSemiring R
M : Submonoid R
S : Type u_4
inst✝⁶ : CommSemiring S
inst✝⁵ : Algebra R S
P : Type u_2
inst✝⁴ : CommSemiring P
inst✝³ : IsLocalization M S
g : R →+* P
hg : ∀ (y : { x // x ∈ M }), IsUnit (↑g ↑y)
T : Submonoid P
Q : Type u_3
inst✝² : CommSemiring Q
hy : M ≤ Submonoid.comap g T
inst✝¹ : Algebra P Q
inst✝ : IsLocalization T Q
j : R ≃+* P
H : Submonoid.map (RingEquiv.toMonoidHom j) M = T
x : R
⊢ ↑(ringEquivOfRingEquiv S Q j H) (↑(algebraMap R S) x) = ↑(algebraMap P Q) (↑j x)
Theorem: NNReal.geom_mean_le_arith_mean4_weighted
File: Mathlib/Analysis/MeanInequalities.lean

tactic: simpa only [Fin.prod_univ_succ, Fin.sum_univ_succ, Finset.prod_empty, Finset.sum_empty,
  Fintype.univ_of_isEmpty, Fin.cons_succ, Fin.cons_zero, add_zero, mul_one, ← add_assoc,
  mul_assoc] using geom_mean_le_arith_mean_weighted univ ![w₁, w₂, w₃, w₄] ![p₁, p₂, p₃, p₄]
state_before: ι : Type u
s : Finset ι
w₁ w₂ w₃ w₄ p₁ p₂ p₃ p₄ : ℝ≥0
⊢ w₁ + w₂ + w₃ + w₄ = 1 → p₁ ^ ↑w₁ * p₂ ^ ↑w₂ * p₃ ^ ↑w₃ * p₄ ^ ↑w₄ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ + w₄ * p₄
Theorem: HasDerivAt.mul_const
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.246716
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d✝ : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivAt c c' x
d : 𝔸
⊢ HasDerivAt (fun y => c y * d) (c' * d) x

tactic: exact hc.mul_const d
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.246716
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d✝ : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasDerivWithinAt c c' univ x
d : 𝔸
⊢ HasDerivWithinAt (fun y => c y * d) (c' * d) univ x
Theorem: SeminormFamily.basisSets_neg
File: Mathlib/Analysis/LocallyConvex/WithSeminorms.lean

tactic: rcases p.basisSets_iff.mp hU' with ⟨s, r, _, hU⟩
state_before: 𝕜 : Type u_2
𝕜₂ : Type ?u.50113
𝕝 : Type ?u.50116
𝕝₂ : Type ?u.50119
E : Type u_1
F : Type ?u.50125
G : Type ?u.50128
ι : Type u_3
ι' : Type ?u.50134
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
U : Set E
hU' : U ∈ basisSets p
⊢ ∃ V, V ∈ basisSets p ∧ V ⊆ (fun x => -x) ⁻¹' U

tactic: rw [hU, neg_preimage, neg_ball (s.sup p), neg_zero]
state_before: case intro.intro.intro
𝕜 : Type u_2
𝕜₂ : Type ?u.50113
𝕝 : Type ?u.50116
𝕝₂ : Type ?u.50119
E : Type u_1
F : Type ?u.50125
G : Type ?u.50128
ι : Type u_3
ι' : Type ?u.50134
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
U : Set E
hU' : U ∈ basisSets p
s : Finset ι
r : ℝ
w✝ : 0 < r
hU : U = ball (Finset.sup s p) 0 r
⊢ ∃ V, V ∈ basisSets p ∧ V ⊆ (fun x => -x) ⁻¹' U

tactic: exact ⟨U, hU', Eq.subset hU⟩
state_before: case intro.intro.intro
𝕜 : Type u_2
𝕜₂ : Type ?u.50113
𝕝 : Type ?u.50116
𝕝₂ : Type ?u.50119
E : Type u_1
F : Type ?u.50125
G : Type ?u.50128
ι : Type u_3
ι' : Type ?u.50134
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : SeminormFamily 𝕜 E ι
U : Set E
hU' : U ∈ basisSets p
s : Finset ι
r : ℝ
w✝ : 0 < r
hU : U = ball (Finset.sup s p) 0 r
⊢ ∃ V, V ∈ basisSets p ∧ V ⊆ ball (Finset.sup s p) 0 r
Theorem: Int.shiftr_add
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [shiftr_coe_nat, shiftr_coe_nat, ← Int.ofNat_add, shiftr_coe_nat, Nat.shiftr_add]
state_before: m n k : ℕ
⊢ shiftr (↑m) (↑n + ↑k) = shiftr (shiftr ↑m ↑n) ↑k

tactic: rw [shiftr_negSucc, shiftr_negSucc, ← Int.ofNat_add, shiftr_negSucc, Nat.shiftr_add]
state_before: m n k : ℕ
⊢ shiftr -[m+1] (↑n + ↑k) = shiftr (shiftr -[m+1] ↑n) ↑k
Theorem: Nat.lt_iff_add_one_le
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [succ_le_iff]
state_before: m✝ n✝ k m n : ℕ
⊢ m < n ↔ m + 1 ≤ n
Theorem: Finset.image_add_right_Icc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← map_add_right_Icc, map_eq_image]
state_before: ι : Type ?u.245092
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Icc a b) = Icc (a + c) (b + c)

tactic: rfl
state_before: ι : Type ?u.245092
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Icc a b) = image (↑(addRightEmbedding c)) (Icc a b)
Theorem: AbsoluteValue.abs_isEuclidean
File: Mathlib/Algebra/Order/EuclideanAbsoluteValue.lean

tactic: rw [abs_eq_natAbs, abs_eq_natAbs, ofNat_lt]
state_before: x y : ℤ
⊢ abs x < abs y ↔ natAbs x < natAbs y
Theorem: isometry_dcomp
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [edist_pi_def, (hf _).edist_eq]
state_before: ι✝ : Type ?u.3111
α✝ : Type u
β✝ : Type v
γ : Type w
inst✝⁵ : PseudoEMetricSpace α✝
inst✝⁴ : PseudoEMetricSpace β✝
inst✝³ : PseudoEMetricSpace γ
f✝ : α✝ → β✝
x✝ y✝ z : α✝
s : Set α✝
ι : Type u_1
inst✝² : Fintype ι
α : ι → Type u_2
β : ι → Type u_3
inst✝¹ : (i : ι) → PseudoEMetricSpace (α i)
inst✝ : (i : ι) → PseudoEMetricSpace (β i)
f : (i : ι) → α i → β i
hf : ∀ (i : ι), Isometry (f i)
x y : (i : ι) → α i
⊢ edist ((fun g i => f i (g i)) x) ((fun g i => f i (g i)) y) = edist x y
Theorem: pi_norm_le_iff_of_nonneg'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [← dist_one_right, dist_pi_le_iff hr, Pi.one_apply]
state_before: 𝓕 : Type ?u.1266224
𝕜 : Type ?u.1266227
α : Type ?u.1266230
ι : Type u_1
κ : Type ?u.1266236
E : Type ?u.1266239
F : Type ?u.1266242
G : Type ?u.1266245
π : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → SeminormedGroup (π i)
inst✝ : SeminormedGroup E
f x : (i : ι) → π i
r : ℝ
hr : 0 ≤ r
⊢ ‖x‖ ≤ r ↔ ∀ (i : ι), ‖x i‖ ≤ r
Theorem: Cardinal.add_one_of_aleph0_le
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [add_comm, ← card_ord c, ← card_one, ← card_add, one_add_of_omega_le]
state_before: c : Cardinal
h : ℵ₀ ≤ c
⊢ c + 1 = c

tactic: rwa [← ord_aleph0, ord_le_ord]
state_before: c : Cardinal
h : ℵ₀ ≤ c
⊢ ω ≤ ord c
Theorem: Asymptotics.IsBigOWith.prod_left_same
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [isBigOWith_iff] at *
state_before: α : Type u_1
β : Type ?u.170365
E : Type ?u.170368
F : Type ?u.170371
G : Type ?u.170374
E' : Type u_2
F' : Type u_4
G' : Type u_3
E'' : Type ?u.170386
F'' : Type ?u.170389
G'' : Type ?u.170392
R : Type ?u.170395
R' : Type ?u.170398
𝕜 : Type ?u.170401
𝕜' : Type ?u.170404
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
hf : IsBigOWith c l f' k'
hg : IsBigOWith c l g' k'
⊢ IsBigOWith c l (fun x => (f' x, g' x)) k'

tactic: filter_upwards [hf, hg]with x using max_le
state_before: α : Type u_1
β : Type ?u.170365
E : Type ?u.170368
F : Type ?u.170371
G : Type ?u.170374
E' : Type u_2
F' : Type u_4
G' : Type u_3
E'' : Type ?u.170386
F'' : Type ?u.170389
G'' : Type ?u.170392
R : Type ?u.170395
R' : Type ?u.170398
𝕜 : Type ?u.170401
𝕜' : Type ?u.170404
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
hf : ∀ᶠ (x : α) in l, ‖f' x‖ ≤ c * ‖k' x‖
hg : ∀ᶠ (x : α) in l, ‖g' x‖ ≤ c * ‖k' x‖
⊢ ∀ᶠ (x : α) in l, ‖(f' x, g' x)‖ ≤ c * ‖k' x‖
Theorem: Multiset.filter_cons
File: Mathlib/Data/Multiset/Basic.lean

tactic: split_ifs with h
state_before: α : Type u_1
β : Type ?u.230776
γ : Type ?u.230779
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
⊢ filter p (a ::ₘ s) = (if p a then {a} else 0) + filter p s

tactic: rw [filter_cons_of_pos _ h, singleton_add]
state_before: case inl
α : Type u_1
β : Type ?u.230776
γ : Type ?u.230779
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : p a
⊢ filter p (a ::ₘ s) = {a} + filter p s

tactic: rw [filter_cons_of_neg _ h, zero_add]
state_before: case inr
α : Type u_1
β : Type ?u.230776
γ : Type ?u.230779
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
h : ¬p a
⊢ filter p (a ::ₘ s) = 0 + filter p s
Theorem: integralClosure.isIntegral
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rwa [← aeval_def, ← Subalgebra.val_apply, aeval_algHom_apply] at hpx
state_before: R : Type u_2
A : Type u_1
B : Type ?u.734629
S : Type ?u.734632
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
x : { x // x ∈ integralClosure R A }
p : R[X]
hpm : Monic p
hpx : eval₂ (algebraMap R A) (↑x) p = 0
⊢ ↑(eval₂ (algebraMap R { x // x ∈ integralClosure R A }) x p) = ↑0
Theorem: div_nonneg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_eq_mul_inv]
state_before: ι : Type ?u.9991
α : Type u_1
β : Type ?u.9997
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ 0 ≤ a / b

tactic: exact mul_nonneg ha (inv_nonneg.2 hb)
state_before: ι : Type ?u.9991
α : Type u_1
β : Type ?u.9997
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ 0 ≤ a * b⁻¹