tasksource/leandojo huggingface dataset:
Theorem: MvPowerSeries.constantCoeff_inv
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [← coeff_zero_eq_constantCoeff_apply, coeff_inv, if_pos rfl]
state_before: σ : Type u_1
R : Type ?u.1677822
k : Type u_2
inst✝ : Field k
φ : MvPowerSeries σ k
⊢ ↑(constantCoeff σ k) φ⁻¹ = (↑(constantCoeff σ k) φ)⁻¹
Theorem: Fin.partialProd_succ'
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp [partialProd]
state_before: α : Type u_1
β : Type ?u.93394
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ partialProd f (succ j) = f 0 * partialProd (tail f) j

tactic: rfl
state_before: α : Type u_1
β : Type ?u.93394
inst✝ : Monoid α
n : ℕ
f : Fin (n + 1) → α
j : Fin (n + 1)
⊢ f 0 * List.prod (List.take (↑j) (List.ofFn fun i => f (succ i))) =
    f 0 * List.prod (List.take (↑j) (List.ofFn (tail f)))
Theorem: Filter.map₂_mk_eq_prod
File: Mathlib/Order/Filter/NAry.lean

tactic: simp only [← map_prod_eq_map₂, map_id']
state_before: α : Type u_1
α' : Type ?u.19006
β : Type u_2
β' : Type ?u.19012
γ : Type ?u.19015
γ' : Type ?u.19018
δ : Type ?u.19021
δ' : Type ?u.19024
ε : Type ?u.19027
ε' : Type ?u.19030
m : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
f : Filter α
g : Filter β
⊢ map₂ Prod.mk f g = f ×ˢ g
Theorem: Set.Finite.toFinset_subset
File: Mathlib/Data/Set/Finite.lean

tactic: rw [← Finset.coe_subset, Finite.coe_toFinset]
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t✝ : Set α
a : α
hs : Set.Finite s
ht : Set.Finite t✝
t : Finset α
⊢ Finite.toFinset hs ⊆ t ↔ s ⊆ ↑t
Theorem: ContinuousLinearEquiv.coe_ofBijective
File: Mathlib/Analysis/NormedSpace/Banach.lean

tactic: ext
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
f✝ : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
f : E →L[𝕜] F
hinj : ker f = ⊥
hsurj : LinearMap.range f = ⊤
⊢ ↑(ofBijective f hinj hsurj) = f

tactic: rfl
state_before: case h
𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
F : Type u_3
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
f✝ : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
f : E →L[𝕜] F
hinj : ker f = ⊥
hsurj : LinearMap.range f = ⊤
x✝ : E
⊢ ↑↑(ofBijective f hinj hsurj) x✝ = ↑f x✝
Theorem: MeasureTheory.tendsto_integral_of_dominated_convergence
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_1
E : Type u_2
F✝ : Type ?u.989419
𝕜 : Type ?u.989422
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F✝
inst✝¹ : NormedSpace ℝ F✝
inst✝ : CompleteSpace F✝
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
F : ℕ → α → E
f : α → E
bound : α → ℝ
F_measurable : ∀ (n : ℕ), AEStronglyMeasurable (F n) μ
bound_integrable : Integrable bound
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
⊢ Tendsto (fun n => ∫ (a : α), F n a ∂μ) atTop (𝓝 (∫ (a : α), f a ∂μ))

tactic: exact tendsto_setToFun_of_dominated_convergence (dominatedFinMeasAdditive_weightedSMul μ)
  bound F_measurable bound_integrable h_bound h_lim
state_before: α : Type u_1
E : Type u_2
F✝ : Type ?u.989419
𝕜 : Type ?u.989422
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F✝
inst✝¹ : NormedSpace ℝ F✝
inst✝ : CompleteSpace F✝
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
F : ℕ → α → E
f : α → E
bound : α → ℝ
F_measurable : ∀ (n : ℕ), AEStronglyMeasurable (F n) μ
bound_integrable : Integrable bound
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
⊢ Tendsto (fun n => if hf : Integrable fun a => F n a then ↑L1.integralCLM (Integrable.toL1 (fun a => F n a) hf) else 0)
    atTop (𝓝 (if hf : Integrable fun a => f a then ↑L1.integralCLM (Integrable.toL1 (fun a => f a) hf) else 0))
Theorem: Ordnode.pos_size_of_mem
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases t
state_before: α : Type u_1
inst✝¹ : LE α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
x : α
t : Ordnode α
h : Sized t
h_mem : x ∈ t
⊢ 0 < size t
Theorem: Option.map_pbind
File: Mathlib/Data/Option/Basic.lean

tactic: cases x <;> simp only [pbind, map_none']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.6070
p : α → Prop
f✝ : (a : α) → p a → β
x✝ : Option α
f : β → γ
x : Option α
g : (a : α) → a ∈ x → Option β
⊢ Option.map f (pbind x g) = pbind x fun a H => Option.map f (g a H)
Theorem: catalan_three
File: Mathlib/Combinatorics/Catalan.lean

tactic: unfold catalan
state_before: ⊢ catalan 3 = 5

tactic: rfl
state_before: ⊢ ∑ i : Fin (Nat.succ 2), catalan ↑i * catalan (2 - ↑i) = 5
Theorem: QuadraticForm.toMatrix'_smul
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [toMatrix', LinearEquiv.map_smul, LinearMap.map_smul]
state_before: S : Type ?u.547922
R : Type ?u.547925
R₁ : Type u_1
M : Type ?u.547931
n : Type w
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq n
inst✝³ : CommRing R₁
inst✝² : AddCommMonoid M
inst✝¹ : Module R₁ M
inst✝ : Invertible 2
a : R₁
Q : QuadraticForm R₁ (n → R₁)
⊢ toMatrix' (a • Q) = a • toMatrix' Q
Theorem: CategoryTheory.Limits.ImageMap.mk.injEq'
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp only [Functor.id_obj, eq_iff_iff, iff_true]
state_before: C : Type u
inst✝⁴ : Category C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ (map = map') = True

tactic: apply ImageMap.map_uniq_aux _ map_ι _ map_ι'
state_before: C : Type u
inst✝⁴ : Category C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map = map'
Theorem: Nat.Ico_succ_left_eq_erase_Ico
File: Mathlib/Data/Nat/Interval.lean

tactic: ext x
state_before: a b c : ℕ
⊢ Ico (succ a) b = erase (Ico a b) a

tactic: rw [Ico_succ_left, mem_erase, mem_Ico, mem_Ioo, ← and_assoc, ne_comm, @and_comm (a ≠ x),
  lt_iff_le_and_ne]
state_before: case a
a b c x : ℕ
⊢ x ∈ Ico (succ a) b ↔ x ∈ erase (Ico a b) a
Theorem: Real.coe_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [Real.sqrt, Real.toNNReal_coe]
state_before: x✝ y : ℝ
x : ℝ≥0
⊢ ↑(↑NNReal.sqrt x) = sqrt ↑x
Theorem: BoxIntegral.hasIntegral_iff
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simp [@forall_swap ℝ≥0 (TaggedPrepartition I)]
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
⊢ (∀ (ib : ℝ),
      0 < ib →
        ∃ ia,
          (∀ (c : ℝ≥0), RCond l (ia c)) ∧
            ∀ (x : TaggedPrepartition I),
              x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall y ib) ↔
    ∀ (ε : ℝ),
      ε > 0 →
        ∃ r,
          (∀ (c : ℝ≥0), RCond l (r c)) ∧
            ∀ (c : ℝ≥0) (π : TaggedPrepartition I),
              MemBaseSet l I c (r c) π → IsPartition π → dist (integralSum f vol π) y ≤ ε
Theorem: Action.Iso.conj_ρ
File: Mathlib/RepresentationTheory/Action.lean

tactic: rw [Iso.conj_apply, Iso.eq_inv_comp]
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
M N : Action V G
f : M ≅ N
g : ↑G
⊢ ↑N.ρ g = ↑(Iso.conj ((forget V G).mapIso f)) (↑M.ρ g)

tactic: simp [f.hom.comm]
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
M N : Action V G
f : M ≅ N
g : ↑G
⊢ ((forget V G).mapIso f).hom ≫ ↑N.ρ g = ↑M.ρ g ≫ ((forget V G).mapIso f).hom
Theorem: Matrix.transvection_zero
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simp [transvection]
state_before: n : Type u_1
p : Type ?u.1470
R : Type u₂
𝕜 : Type ?u.1475
inst✝³ : Field 𝕜
inst✝² : DecidableEq n
inst✝¹ : DecidableEq p
inst✝ : CommRing R
i j : n
⊢ transvection i j 0 = 1
Theorem: SimpleGraph.ComponentCompl.mem_of_adj
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: rw [← h, ConnectedComponent.eq]
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G K
c d : V
x✝ : c ∈ C
dnK : ¬d ∈ K
cd : Adj G c d
cnK : ¬c ∈ K
h : componentComplMk G cnK = C
⊢ componentComplMk G dnK = C

tactic: exact Adj.reachable cd.symm
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G K
c d : V
x✝ : c ∈ C
dnK : ¬d ∈ K
cd : Adj G c d
cnK : ¬c ∈ K
h : componentComplMk G cnK = C
⊢ Reachable (induce (Kᶜ) G) { val := d, property := dnK } { val := c, property := cnK }
Theorem: RatFunc.monic_denom
File: Mathlib/FieldTheory/RatFunc.lean

tactic: induction x using RatFunc.induction_on with
  | f p q hq =>
    rw [denom_div p hq, mul_comm]
    exact Polynomial.monic_mul_leadingCoeff_inv (right_div_gcd_ne_zero hq)
state_before: K : Type u
inst✝ : Field K
x : RatFunc K
⊢ Monic (denom x)

tactic: rw [denom_div p hq, mul_comm]
state_before: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ Monic (denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q))

tactic: exact Polynomial.monic_mul_leadingCoeff_inv (right_div_gcd_ne_zero hq)
state_before: case f
K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ Monic (q / gcd p q * ↑C (leadingCoeff (q / gcd p q))⁻¹)
Theorem: FractionalIdeal.spanSingleton_eq_zero_iff
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simpa using congr_arg Subtype.val h
state_before: R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1326146
inst✝³ : CommRing R₁
K : Type ?u.1326152
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
y : P
h : spanSingleton S y = 0
⊢ span R {y} = ⊥

tactic: simp [h]
state_before: R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1326146
inst✝³ : CommRing R₁
K : Type ?u.1326152
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
y : P
h : y = 0
⊢ spanSingleton S y = 0
Theorem: MeasureTheory.snorm'_const_of_isProbabilityMeasure
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm'_const c hq_pos, measure_univ]
state_before: α : Type u_1
E : Type ?u.1108617
F : Type u_2
G : Type ?u.1108623
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
c : F
hq_pos : 0 < q
inst✝ : IsProbabilityMeasure μ
⊢ snorm' (fun x => c) q μ = ↑‖c‖₊
Theorem: Polynomial.ker_evalRingHom
File: Mathlib/Data/Polynomial/Div.lean

tactic: ext y
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
⊢ RingHom.ker (evalRingHom x) = Ideal.span {X - ↑C x}

tactic: simp [Ideal.mem_span_singleton, dvd_iff_isRoot, RingHom.mem_ker]
state_before: case h
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
x : R
y : R[X]
⊢ y ∈ RingHom.ker (evalRingHom x) ↔ y ∈ Ideal.span {X - ↑C x}
Theorem: List.perm_split
File: Mathlib/Data/List/Sort.lean

tactic: cases' e : split l with l₁ l₂
state_before: α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : split (a :: l) = (l₁', l₂')
⊢ a :: l ~ l₁' ++ l₂'

tactic: injection (split_cons_of_eq _ e).symm.trans h
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : split (a :: l) = (l₁', l₂')
l₁ l₂ : List α
e : split l = (l₁, l₂)
⊢ a :: l ~ l₁' ++ l₂'

tactic: substs l₁' l₂'
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : split (a :: l) = (l₁', l₂')
l₁ l₂ : List α
e : split l = (l₁, l₂)
fst_eq✝ : a :: l₂ = l₁'
snd_eq✝ : l₁ = l₂'
⊢ a :: l ~ l₁' ++ l₂'

tactic: exact ((perm_split e).trans perm_append_comm).cons a
state_before: case mk
α : Type uu
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : split l = (l₁, l₂)
h : split (a :: l) = (a :: l₂, l₁)
⊢ a :: l ~ a :: l₂ ++ l₁
Theorem: Metric.Bounded.smul
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: obtain ⟨R, hR⟩ : ∃ R : ℝ, ∀ x ∈ s, ‖x‖ ≤ R := hs.exists_norm_le
state_before: 𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
hs : Bounded s
c : 𝕜
⊢ Bounded (c • s)

tactic: refine' bounded_iff_forall_norm_le.2 ⟨‖c‖ * R, fun z hz => _⟩
state_before: case intro
𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
hs : Bounded s
c : 𝕜
R : ℝ
hR : ∀ (x : E), x ∈ s → ‖x‖ ≤ R
⊢ Bounded (c • s)

tactic: obtain ⟨y, ys, rfl⟩ : ∃ y : E, y ∈ s ∧ c • y = z := mem_smul_set.1 hz
state_before: case intro
𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
hs : Bounded s
c : 𝕜
R : ℝ
hR : ∀ (x : E), x ∈ s → ‖x‖ ≤ R
z : E
hz : z ∈ c • s
⊢ ‖z‖ ≤ ‖c‖ * R

tactic: calc
  ‖c • y‖ = ‖c‖ * ‖y‖ := norm_smul _ _
  _ ≤ ‖c‖ * R := mul_le_mul_of_nonneg_left (hR y ys) (norm_nonneg _)
state_before: case intro.intro.intro
𝕜 : Type u_2
E : Type u_1
inst✝² : NormedField 𝕜
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
hs : Bounded s
c : 𝕜
R : ℝ
hR : ∀ (x : E), x ∈ s → ‖x‖ ≤ R
y : E
ys : y ∈ s
hz : c • y ∈ c • s
⊢ ‖c • y‖ ≤ ‖c‖ * R
Theorem: Rat.add_le_add_left
File: Mathlib/Data/Rat/Order.lean

tactic: rw [Rat.le_iff_Nonneg, add_sub_add_left_eq_sub, Rat.le_iff_Nonneg]
state_before: a✝ b✝ c✝ a b c : ℚ
⊢ c + a ≤ c + b ↔ a ≤ b
Theorem: Int.fract_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: simp [fract]
state_before: F : Type ?u.158043
α : Type u_1
β : Type ?u.158049
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ fract 1 = 0
Theorem: CategoryTheory.IsFiltered.coeq₃_condition₁
File: Mathlib/CategoryTheory/Filtered.lean

tactic: simp only [coeq₃Hom, ← Category.assoc, coeq_condition f g]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : IsFilteredOrEmpty C
j₁ j₂ : C
f g h : j₁ ⟶ j₂
⊢ f ≫ coeq₃Hom f g h = g ≫ coeq₃Hom f g h
Theorem: DoubleCentralizer.range_toProd
File: Mathlib/Analysis/NormedSpace/Star/Multiplier.lean

tactic: rintro ⟨a, rfl⟩
state_before: 𝕜 : Type u_2
A : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
x : (A →L[𝕜] A) × (A →L[𝕜] A)
⊢ x ∈ Set.range toProd → x ∈ {lr | ∀ (x y : A), ↑lr.snd x * y = x * ↑lr.fst y}

tactic: exact a.central
state_before: case intro
𝕜 : Type u_2
A : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NonUnitalNormedRing A
inst✝² : NormedSpace 𝕜 A
inst✝¹ : SMulCommClass 𝕜 A A
inst✝ : IsScalarTower 𝕜 A A
a : 𝓜(𝕜, A)
⊢ a.toProd ∈ {lr | ∀ (x y : A), ↑lr.snd x * y = x * ↑lr.fst y}
Theorem: HasStrictFDerivAt.exists_lipschitzOnWith_of_nnnorm_lt
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: have := hf.add_isBigOWith (f'.isBigOWith_comp _ _) hK
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.210344
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.210439
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
hf : HasStrictFDerivAt f f' x
K : ℝ≥0
hK : ‖f'‖₊ < K
⊢ ∃ s, s ∈ 𝓝 x ∧ LipschitzOnWith K f s

tactic: simp only [sub_add_cancel, IsBigOWith] at this
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.210344
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.210439
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
hf : HasStrictFDerivAt f f' x
K : ℝ≥0
hK : ‖f'‖₊ < K
this :
  IsBigOWith ((fun a => ↑a) K) (𝓝 (x, x)) (fun x => f x.fst - f x.snd - ↑f' (x.fst - x.snd) + ↑f' (x.fst - x.snd))
    fun p => p.fst - p.snd
⊢ ∃ s, s ∈ 𝓝 x ∧ LipschitzOnWith K f s

tactic: rcases exists_nhds_square this with ⟨U, Uo, xU, hU⟩
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.210344
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.210439
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
hf : HasStrictFDerivAt f f' x
K : ℝ≥0
hK : ‖f'‖₊ < K
this : ∀ᶠ (x : E × E) in 𝓝 (x, x), ‖f x.fst - f x.snd‖ ≤ ↑K * ‖x.fst - x.snd‖
⊢ ∃ s, s ∈ 𝓝 x ∧ LipschitzOnWith K f s

tactic: exact
  ⟨U, Uo.mem_nhds xU, lipschitzOnWith_iff_norm_sub_le.2 fun x hx y hy => hU (mk_mem_prod hx hy)⟩
state_before: case intro.intro.intro
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.210344
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.210439
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
hf : HasStrictFDerivAt f f' x
K : ℝ≥0
hK : ‖f'‖₊ < K
this : ∀ᶠ (x : E × E) in 𝓝 (x, x), ‖f x.fst - f x.snd‖ ≤ ↑K * ‖x.fst - x.snd‖
U : Set E
Uo : IsOpen U
xU : x ∈ U
hU : U ×ˢ U ⊆ {x | (fun x => ‖f x.fst - f x.snd‖ ≤ ↑K * ‖x.fst - x.snd‖) x}
⊢ ∃ s, s ∈ 𝓝 x ∧ LipschitzOnWith K f s
Theorem: Polynomial.natDegree_C_mul_X
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [pow_one] using natDegree_C_mul_X_pow 1 a ha
state_before: R : Type u
S : Type v
a✝ b c d : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
a : R
ha : a ≠ 0
⊢ natDegree (↑C a * X) = 1
Theorem: MeasureTheory.Content.contentRegular_exists_compact
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: by_contra hc
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : ContentRegular μ
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
⊢ ∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(toFun μ s)) K' ≤ (fun s => ↑(toFun μ s)) K + ↑ε

tactic: simp only [not_exists, not_and, not_le] at hc
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : ContentRegular μ
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ¬∃ K', K.carrier ⊆ interior K'.carrier ∧ (fun s => ↑(toFun μ s)) K' ≤ (fun s => ↑(toFun μ s)) K + ↑ε
⊢ False

tactic: have lower_bound_iInf : μ K + ε ≤
    ⨅ (K' : TopologicalSpace.Compacts G) (_ : (K : Set G) ⊆ interior (K' : Set G)), μ K' :=
  le_iInf fun K' => le_iInf fun K'_hyp => le_of_lt (hc K' K'_hyp)
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : ContentRegular μ
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(toFun μ K) + ↑ε < ↑(toFun μ x)
⊢ False

tactic: rw [← H] at lower_bound_iInf
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : ContentRegular μ
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(toFun μ K) + ↑ε < ↑(toFun μ x)
lower_bound_iInf :
  (fun s => ↑(toFun μ s)) K + ↑ε ≤ ⨅ (K' : Compacts G) (_ : ↑K ⊆ interior ↑K'), (fun s => ↑(toFun μ s)) K'
⊢ False

tactic: exact (lt_self_iff_false (μ K)).mp (lt_of_le_of_lt' lower_bound_iInf
  (ENNReal.lt_add_right (ne_top_of_lt (μ.lt_top K)) (ENNReal.coe_ne_zero.mpr hε)))
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
H : ContentRegular μ
K : Compacts G
ε : ℝ≥0
hε : ε ≠ 0
hc : ∀ (x : Compacts G), K.carrier ⊆ interior x.carrier → ↑(toFun μ K) + ↑ε < ↑(toFun μ x)
lower_bound_iInf : (fun s => ↑(toFun μ s)) K + ↑ε ≤ (fun s => ↑(toFun μ s)) K
⊢ False
Theorem: Finset.smul_univ₀
File: Mathlib/Data/Finset/Pointwise.lean

tactic: rw [← coe_subset] at hs
state_before: F : Type ?u.897847
α : Type u_2
β : Type u_1
γ : Type ?u.897856
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : ¬s ⊆ 0
⊢ ↑(s • univ) = ↑univ

tactic: push_cast at hs⊢
state_before: F : Type ?u.897847
α : Type u_2
β : Type u_1
γ : Type ?u.897856
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : ¬↑s ⊆ ↑0
⊢ ↑(s • univ) = ↑univ

tactic: exact Set.smul_univ₀ hs
state_before: F : Type ?u.897847
α : Type u_2
β : Type u_1
γ : Type ?u.897856
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : ¬↑s ⊆ 0
⊢ ↑s • Set.univ = Set.univ
Theorem: Int.ofNat_lt
File: Std/Data/Int/Lemmas.lean

tactic: rw [lt_iff_add_one_le, ← ofNat_succ, ofNat_le]
state_before: n m : Nat
⊢ ↑n < ↑m ↔ n < m

tactic: rfl
state_before: n m : Nat
⊢ succ n ≤ m ↔ n < m
Theorem: List.eq_cons_of_length_one
File: Mathlib/Data/List/Basic.lean

tactic: refine' ext_get (by convert h) fun n h₁ h₂ => _
state_before: ι : Type ?u.104743
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h : length l = 1
⊢ l = [nthLe l 0 (_ : 0 < length l)]

tactic: simp only [get_singleton]
state_before: ι : Type ?u.104743
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h : length l = 1
n : ℕ
h₁ : n < length l
h₂ : n < length [nthLe l 0 (_ : 0 < length l)]
⊢ get l { val := n, isLt := h₁ } = get [nthLe l 0 (_ : 0 < length l)] { val := n, isLt := h₂ }

tactic: congr
state_before: ι : Type ?u.104743
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h : length l = 1
n : ℕ
h₁ : n < length l
h₂ : n < length [nthLe l 0 (_ : 0 < length l)]
⊢ get l { val := n, isLt := h₁ } = nthLe l 0 (_ : 0 < length l)

tactic: exact eq_bot_iff.mpr (Nat.lt_succ_iff.mp h₂)
state_before: case e_a.e_val
ι : Type ?u.104743
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h : length l = 1
n : ℕ
h₁ : n < length l
h₂ : n < length [nthLe l 0 (_ : 0 < length l)]
⊢ n = 0

tactic: convert h
state_before: ι : Type ?u.104743
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
h : length l = 1
⊢ length l = length [nthLe l 0 (_ : 0 < length l)]
Theorem: dist_div_left
File: Mathlib/Topology/MetricSpace/IsometricSMul.lean

tactic: simp [div_eq_mul_inv]
state_before: M : Type u
G : Type v
X : Type w
inst✝³ : Group G
inst✝² : PseudoMetricSpace G
inst✝¹ : IsometricSMul G G
inst✝ : IsometricSMul Gᵐᵒᵖ G
a b c : G
⊢ dist (a / b) (a / c) = dist b c