tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.Box.mem_splitCenterBox
File: Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean

tactic: simp only [splitCenterBox, mem_def, ← forall_and]
state_before: ι : Type u_1
I J : Box ι
s : Set ι
y : ι → ℝ
⊢ y ∈ splitCenterBox I s ↔ y ∈ I ∧ ∀ (i : ι), (lower I i + upper I i) / 2 < y i ↔ i ∈ s

tactic: refine' forall_congr' fun i ↦ _
state_before: ι : Type u_1
I J : Box ι
s : Set ι
y : ι → ℝ
⊢ (∀ (i : ι),
      y i ∈
        Set.Ioc (Set.piecewise s (fun i => (lower I i + upper I i) / 2) I.lower i)
          (Set.piecewise s I.upper (fun i => (lower I i + upper I i) / 2) i)) ↔
    ∀ (x : ι), y x ∈ Set.Ioc (lower I x) (upper I x) ∧ ((lower I x + upper I x) / 2 < y x ↔ x ∈ s)

tactic: dsimp only [Set.piecewise]
state_before: ι : Type u_1
I J : Box ι
s : Set ι
y : ι → ℝ
i : ι
⊢ y i ∈
      Set.Ioc (Set.piecewise s (fun i => (lower I i + upper I i) / 2) I.lower i)
        (Set.piecewise s I.upper (fun i => (lower I i + upper I i) / 2) i) ↔
    y i ∈ Set.Ioc (lower I i) (upper I i) ∧ ((lower I i + upper I i) / 2 < y i ↔ i ∈ s)

tactic: split_ifs with hs <;> simp only [hs, iff_true_iff, iff_false_iff, not_lt]
state_before: ι : Type u_1
I J : Box ι
s : Set ι
y : ι → ℝ
i : ι
⊢ y i ∈
      Set.Ioc (if i ∈ s then (lower I i + upper I i) / 2 else lower I i)
        (if i ∈ s then upper I i else (lower I i + upper I i) / 2) ↔
    y i ∈ Set.Ioc (lower I i) (upper I i) ∧ ((lower I i + upper I i) / 2 < y i ↔ i ∈ s)

tactic: exacts [⟨fun H ↦ ⟨⟨(left_lt_add_div_two.2 (I.lower_lt_upper i)).trans H.1, H.2⟩, H.1⟩,
    fun H ↦ ⟨H.2, H.1.2⟩⟩,
  ⟨fun H ↦ ⟨⟨H.1, H.2.trans (add_div_two_lt_right.2 (I.lower_lt_upper i)).le⟩, H.2⟩,
    fun H ↦ ⟨H.1.1, H.2⟩⟩]
state_before: case inl
ι : Type u_1
I J : Box ι
s : Set ι
y : ι → ℝ
i : ι
hs : i ∈ s
⊢ y i ∈ Set.Ioc ((lower I i + upper I i) / 2) (upper I i) ↔
    y i ∈ Set.Ioc (lower I i) (upper I i) ∧ (lower I i + upper I i) / 2 < y i

case inr
ι : Type u_1
I J : Box ι
s : Set ι
y : ι → ℝ
i : ι
hs : ¬i ∈ s
⊢ y i ∈ Set.Ioc (lower I i) ((lower I i + upper I i) / 2) ↔
    y i ∈ Set.Ioc (lower I i) (upper I i) ∧ y i ≤ (lower I i + upper I i) / 2
Theorem: IsFractionRing.mul_inv_cancel
File: Mathlib/RingTheory/Localization/FractionRing.lean

tactic: rw [IsFractionRing.inv, dif_neg hx, ←
  IsUnit.mul_left_inj
    (map_units K
      ⟨(sec _ x).1,
        mem_nonZeroDivisors_iff_ne_zero.2 fun h0 =>
          hx <| eq_zero_of_fst_eq_zero (sec_spec (nonZeroDivisors A) x) h0⟩),
  one_mul, mul_assoc]
state_before: R : Type ?u.66348
inst✝¹⁰ : CommRing R
M : Submonoid R
S : Type ?u.66540
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Type ?u.66777
inst✝⁷ : CommRing P
A : Type u_2
inst✝⁶ : CommRing A
inst✝⁵ : IsDomain A
K : Type u_1
inst✝⁴ : CommRing K
inst✝³ : Algebra R K
inst✝² : IsFractionRing R K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
hx : x ≠ 0
⊢ x * IsFractionRing.inv A x = 1

tactic: rw [mk'_spec, ← eq_mk'_iff_mul_eq]
state_before: R : Type ?u.66348
inst✝¹⁰ : CommRing R
M : Submonoid R
S : Type ?u.66540
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Type ?u.66777
inst✝⁷ : CommRing P
A : Type u_2
inst✝⁶ : CommRing A
inst✝⁵ : IsDomain A
K : Type u_1
inst✝⁴ : CommRing K
inst✝³ : Algebra R K
inst✝² : IsFractionRing R K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
hx : x ≠ 0
⊢ x *
      (mk' K ↑(sec (nonZeroDivisors A) x).snd
          { val := (sec (nonZeroDivisors A) x).fst,
            property := (_ : (sec (nonZeroDivisors A) x).fst ∈ nonZeroDivisors A) } *
        ↑(algebraMap A K)
          ↑{ val := (sec (nonZeroDivisors A) x).fst,
              property := (_ : (sec (nonZeroDivisors A) x).fst ∈ nonZeroDivisors A) }) =
    ↑(algebraMap A K)
      ↑{ val := (sec (nonZeroDivisors A) x).fst, property := (_ : (sec (nonZeroDivisors A) x).fst ∈ nonZeroDivisors A) }

tactic: exact (mk'_sec _ x).symm
state_before: R : Type ?u.66348
inst✝¹⁰ : CommRing R
M : Submonoid R
S : Type ?u.66540
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
P : Type ?u.66777
inst✝⁷ : CommRing P
A : Type u_2
inst✝⁶ : CommRing A
inst✝⁵ : IsDomain A
K : Type u_1
inst✝⁴ : CommRing K
inst✝³ : Algebra R K
inst✝² : IsFractionRing R K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
hx : x ≠ 0
⊢ x =
    mk'
      ((fun x => K)
        ↑{ val := (sec (nonZeroDivisors A) x).fst,
            property := (_ : (sec (nonZeroDivisors A) x).fst ∈ nonZeroDivisors A) })
      (↑{ val := (sec (nonZeroDivisors A) x).fst,
          property := (_ : (sec (nonZeroDivisors A) x).fst ∈ nonZeroDivisors A) })
      (sec (nonZeroDivisors A) x).snd
Theorem: CategoryTheory.Limits.IsLimit.uniq_cone_morphism
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: intro g
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
s t : Cone F
h : IsLimit t
f f' : s ⟶ t
⊢ ∀ {g : s ⟶ t}, g = liftConeMorphism h s

tactic: apply ConeMorphism.ext
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
s t : Cone F
h : IsLimit t
f f' g : s ⟶ t
⊢ g = liftConeMorphism h s

tactic: exact h.uniq _ _ g.w
state_before: case w
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
s t : Cone F
h : IsLimit t
f f' g : s ⟶ t
⊢ g.Hom = (liftConeMorphism h s).Hom
Theorem: ProbabilityTheory.cond_inter_self
File: Mathlib/Probability/ConditionalProbability.lean

tactic: rw [cond_apply _ hms, ← Set.inter_assoc, Set.inter_self, ← cond_apply _ hms]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
μ : MeasureTheory.Measure Ω
s t✝ : Set Ω
hms : MeasurableSet s
t : Set Ω
⊢ ↑↑(μ[|s]) (s ∩ t) = ↑↑(μ[|s]) t
Theorem: SimpleGraph.neighborSet_subgraphOfAdj
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: split_ifs <;> subst_vars <;> simp [*]
state_before: ι : Sort ?u.224643
V : Type u
W : Type v
G : SimpleGraph V
G' : SimpleGraph W
inst✝ : DecidableEq V
u v w : V
hvw : Adj G v w
⊢ Subgraph.neighborSet (subgraphOfAdj G hvw) u = (if u = v then {w} else ∅) ∪ if u = w then {v} else ∅
Theorem: List.mem_insertNth
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: ι : Type ?u.120563
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a✝ a b : α
as : List α
x✝ : 0 ≤ length as
⊢ a ∈ insertNth 0 b as ↔ a = b ∨ a ∈ as

tactic: rw [List.insertNth_succ_cons, mem_cons, mem_insertNth (Nat.le_of_succ_le_succ h),
  ← or_assoc, @or_comm (a = a'), or_assoc, mem_cons]
state_before: ι : Type ?u.120563
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a✝ a b : α
n : ℕ
a' : α
as : List α
h : n + 1 ≤ length (a' :: as)
⊢ a ∈ insertNth (n + 1) b (a' :: as) ↔ a = b ∨ a ∈ a' :: as
Theorem: Filter.exists_mem_and_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: constructor
state_before: α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
⊢ ((∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u) ↔ ∃ u, u ∈ f ∧ P u ∧ Q u

tactic: rintro ⟨⟨u, huf, hPu⟩, v, hvf, hQv⟩
state_before: case mp
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
⊢ ((∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u) → ∃ u, u ∈ f ∧ P u ∧ Q u

tactic: exact
  ⟨u ∩ v, inter_mem huf hvf, hP (inter_subset_left _ _) hPu, hQ (inter_subset_right _ _) hQv⟩
state_before: case mp.intro.intro.intro.intro.intro
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
u : Set α
huf : u ∈ f
hPu : P u
v : Set α
hvf : v ∈ f
hQv : Q v
⊢ ∃ u, u ∈ f ∧ P u ∧ Q u

tactic: rintro ⟨u, huf, hPu, hQu⟩
state_before: case mpr
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
⊢ (∃ u, u ∈ f ∧ P u ∧ Q u) → (∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u

tactic: exact ⟨⟨u, huf, hPu⟩, u, huf, hQu⟩
state_before: case mpr.intro.intro.intro
α : Type u
f g : Filter α
s t : Set α
P Q : Set α → Prop
hP : Antitone P
hQ : Antitone Q
u : Set α
huf : u ∈ f
hPu : P u
hQu : Q u
⊢ (∃ u, u ∈ f ∧ P u) ∧ ∃ u, u ∈ f ∧ Q u
Theorem: tendstoUniformly_iff_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp [tendstoUniformly_iff_tendstoUniformlyOnFilter, tendstoUniformlyOnFilter_iff_tendsto]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F✝ : ι → α → β
f✝ : α → β
s s' : Set α
x : α
p✝ : Filter ι
p' : Filter α
g : ι → α
F : ι → α → β
f : α → β
p : Filter ι
⊢ TendstoUniformly F f p ↔ Tendsto (fun q => (f q.snd, F q.fst q.snd)) (p ×ˢ ⊤) (𝓤 β)
Theorem: Bornology.isBounded_iUnion
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [← sUnion_range, isBounded_sUnion (finite_range s), forall_range_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.8981
s✝ : Set α
inst✝¹ : Bornology α
inst✝ : Finite ι
s : ι → Set α
⊢ IsBounded (⋃ (i : ι), s i) ↔ ∀ (i : ι), IsBounded (s i)
Theorem: Polynomial.degree_derivative_le
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: rw [H, derivative_zero]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
H : p = 0
⊢ degree (↑derivative p) = degree p
Theorem: MeasureTheory.Content.sup_disjoint
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: simp [apply_eq_coe_toFun, μ.sup_disjoint' _ _ h]
state_before: G : Type w
inst✝ : TopologicalSpace G
μ : Content G
K₁ K₂ : Compacts G
h : Disjoint ↑K₁ ↑K₂
⊢ (fun s => ↑(toFun μ s)) (K₁ ⊔ K₂) = (fun s => ↑(toFun μ s)) K₁ + (fun s => ↑(toFun μ s)) K₂
Theorem: PGame.lf_neg_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
state_before: x y : PGame
⊢ y ⧏ -x ↔ x ⧏ -y
Theorem: UniformOnFun.postcomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: rw [uniformContinuous_iff]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.77663
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : UniformContinuous f
⊢ UniformContinuous (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖))

tactic: exact (UniformOnFun.mono (uniformContinuous_iff.mp hf) subset_rfl).trans_eq UniformOnFun.comap_eq
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Type ?u.77663
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝¹ : UniformSpace β
𝔖 : Set (Set α)
inst✝ : UniformSpace γ
f : γ → β
hf : UniformContinuous f
⊢ uniformSpace α γ 𝔖 ≤ UniformSpace.comap (↑(ofFun 𝔖) ∘ (fun x x_1 => x ∘ x_1) f ∘ ↑(toFun 𝔖)) (uniformSpace α β 𝔖)
Theorem: CategoryTheory.Iso.symm_self_conj
File: Mathlib/CategoryTheory/Conj.lean

tactic: rw [← trans_conj, α.self_symm_id, refl_conj]
state_before: C : Type u
inst✝ : Category C
X Y : C
α : X ≅ Y
f : End X
⊢ ↑(conj α.symm) (↑(conj α) f) = f
Theorem: Complex.cos_eq_iff_quadratic
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← sub_eq_zero]
state_before: z w : ℂ
⊢ cos z = w ↔ exp (z * I) ^ 2 - 2 * w * exp (z * I) + 1 = 0

tactic: field_simp [cos, exp_neg, exp_ne_zero]
state_before: z w : ℂ
⊢ cos z - w = 0 ↔ exp (z * I) ^ 2 - 2 * w * exp (z * I) + 1 = 0

tactic: refine' Eq.congr _ rfl
state_before: z w : ℂ
⊢ exp (z * I) * exp (z * I) + 1 - exp (z * I) * 2 * w = 0 ↔ exp (z * I) ^ 2 - 2 * w * exp (z * I) + 1 = 0

tactic: ring
state_before: z w : ℂ
⊢ exp (z * I) * exp (z * I) + 1 - exp (z * I) * 2 * w = exp (z * I) ^ 2 - 2 * w * exp (z * I) + 1
Theorem: uniformContinuous_sInf_dom
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: delta UniformContinuous
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.145087
f : α → β
u₁ : Set (UniformSpace α)
u₂ : UniformSpace β
u : UniformSpace α
h₁ : u ∈ u₁
hf : UniformContinuous f
⊢ UniformContinuous f

tactic: rw [sInf_eq_iInf', iInf_uniformity]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.145087
f : α → β
u₁ : Set (UniformSpace α)
u₂ : UniformSpace β
u : UniformSpace α
h₁ : u ∈ u₁
hf : UniformContinuous f
⊢ Tendsto (fun x => (f x.fst, f x.snd)) (𝓤 α) (𝓤 β)

tactic: exact tendsto_iInf' ⟨u, h₁⟩ hf
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.145087
f : α → β
u₁ : Set (UniformSpace α)
u₂ : UniformSpace β
u : UniformSpace α
h₁ : u ∈ u₁
hf : UniformContinuous f
⊢ Tendsto (fun x => (f x.fst, f x.snd)) (⨅ (i : ↑u₁), 𝓤 α) (𝓤 β)
Theorem: Real.ofCauchy_sup
File: Mathlib/Data/Real/Basic.lean

tactic: rw [sup_def]
state_before: x y : ℝ
a b : CauSeq ℚ abs
⊢ { cauchy := Quotient.mk equiv (a ⊔ b) } = Real.sup { cauchy := Quotient.mk equiv a } { cauchy := Quotient.mk equiv b }

tactic: rfl
state_before: x y : ℝ
a b : CauSeq ℚ abs
⊢ { cauchy := Quotient.mk equiv (a ⊔ b) } =
    match { cauchy := Quotient.mk equiv a }, { cauchy := Quotient.mk equiv b } with
    | { cauchy := x }, { cauchy := y } =>
      { cauchy := Quotient.map₂ (fun x x_1 => x ⊔ x_1) Real.definition.proof_2✝ x y }
Theorem: SModEq.add
File: Mathlib/LinearAlgebra/SModEq.lean

tactic: rw [SModEq.def] at hxy₁ hxy₂⊢
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
U U₁ U₂ : Submodule R M
x x₁ x₂ y y₁ y₂ z z₁ z₂ : M
N : Type ?u.55774
inst✝¹ : AddCommGroup N
inst✝ : Module R N
V V₁ V₂ : Submodule R N
hxy₁ : x₁ ≡ y₁ [SMOD U]
hxy₂ : x₂ ≡ y₂ [SMOD U]
⊢ x₁ + x₂ ≡ y₁ + y₂ [SMOD U]

tactic: simp_rw [Quotient.mk_add, hxy₁, hxy₂]
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
U U₁ U₂ : Submodule R M
x x₁ x₂ y y₁ y₂ z z₁ z₂ : M
N : Type ?u.55774
inst✝¹ : AddCommGroup N
inst✝ : Module R N
V V₁ V₂ : Submodule R N
hxy₁ : Submodule.Quotient.mk x₁ = Submodule.Quotient.mk y₁
hxy₂ : Submodule.Quotient.mk x₂ = Submodule.Quotient.mk y₂
⊢ Submodule.Quotient.mk (x₁ + x₂) = Submodule.Quotient.mk (y₁ + y₂)
Theorem: ENNReal.strictMono_rpow_of_pos
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: intro x y hxy
state_before: z : ℝ
h : 0 < z
⊢ StrictMono fun x => x ^ z

tactic: lift x to ℝ≥0 using ne_top_of_lt hxy
state_before: z : ℝ
h : 0 < z
x y : ℝ≥0∞
hxy : x < y
⊢ (fun x => x ^ z) x < (fun x => x ^ z) y

tactic: rcases eq_or_ne y ∞ with (rfl | hy)
state_before: case intro
z : ℝ
h : 0 < z
y : ℝ≥0∞
x : ℝ≥0
hxy : ↑x < y
⊢ (fun x => x ^ z) ↑x < (fun x => x ^ z) y

tactic: simp only [top_rpow_of_pos h, coe_rpow_of_nonneg _ h.le, coe_lt_top]
state_before: case intro.inl
z : ℝ
h : 0 < z
x : ℝ≥0
hxy : ↑x < ⊤
⊢ (fun x => x ^ z) ↑x < (fun x => x ^ z) ⊤

tactic: lift y to ℝ≥0 using hy
state_before: case intro.inr
z : ℝ
h : 0 < z
y : ℝ≥0∞
x : ℝ≥0
hxy : ↑x < y
hy : y ≠ ⊤
⊢ (fun x => x ^ z) ↑x < (fun x => x ^ z) y

tactic: simp only [coe_rpow_of_nonneg _ h.le, NNReal.rpow_lt_rpow (coe_lt_coe.1 hxy) h, coe_lt_coe]
state_before: case intro.inr.intro
z : ℝ
h : 0 < z
x y : ℝ≥0
hxy : ↑x < ↑y
⊢ (fun x => x ^ z) ↑x < (fun x => x ^ z) ↑y
Theorem: Multiset.map_add_right_Ioc
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: simp_rw [add_comm _ c]
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => x + c) (Ioc a b) = Ioc (a + c) (b + c)

tactic: exact map_add_left_Ioc _ _ _
state_before: α : Type u_1
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (fun x => c + x) (Ioc a b) = Ioc (c + a) (c + b)
Theorem: MeasureTheory.OuterMeasure.boundedBy_eq_ofFunction
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: have : (fun s : Set α => ⨆ _ : s.Nonempty, m s) = m := by
  ext1 t
  cases' t.eq_empty_or_nonempty with h h <;> simp [h, Set.not_nonempty_empty, m_empty]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
⊢ ↑(boundedBy m) s = ↑(OuterMeasure.ofFunction m m_empty) s

tactic: simp [boundedBy, this]
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
this : (fun s => ⨆ (_ : Set.Nonempty s), m s) = m
⊢ ↑(boundedBy m) s = ↑(OuterMeasure.ofFunction m m_empty) s

tactic: ext1 t
state_before: α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s : Set α
⊢ (fun s => ⨆ (_ : Set.Nonempty s), m s) = m

tactic: cases' t.eq_empty_or_nonempty with h h <;> simp [h, Set.not_nonempty_empty, m_empty]
state_before: case h
α : Type u_1
m : Set α → ℝ≥0∞
m_empty : m ∅ = 0
s t : Set α
⊢ (⨆ (_ : Set.Nonempty t), m t) = m t
Theorem: Polynomial.separable_X_sub_C
File: Mathlib/FieldTheory/Separable.lean

tactic: simpa only [sub_eq_add_neg, C_neg] using separable_X_add_C (-x)
state_before: R : Type u
inst✝ : CommRing R
x : R
⊢ Separable (X - ↑C x)
Theorem: Cardinal.lt_aleph0_iff_finite
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp only [lt_aleph0, mk_eq_nat_iff, finite_iff_exists_equiv_fin]
state_before: α✝ β α : Type u
⊢ (#α) < ℵ₀ ↔ Finite α
Theorem: CategoryTheory.Split.exact
File: Mathlib/Algebra/Homology/ShortExact/Preadditive.lean

tactic: obtain ⟨φ, χ, -, -, h1, -, h2⟩ := h
state_before: 𝒜 : Type u_1
inst✝³ : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝² : Preadditive 𝒜
inst✝¹ : HasKernels 𝒜
inst✝ : HasImages 𝒜
h : Split f g
⊢ Exact f g

tactic: exact exact_of_split h1 h2
state_before: case mk.intro.intro.intro.intro.intro.intro
𝒜 : Type u_1
inst✝³ : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝² : Preadditive 𝒜
inst✝¹ : HasKernels 𝒜
inst✝ : HasImages 𝒜
φ : B ⟶ A
χ : C ⟶ B
h1 : f ≫ g = 0
h2 : φ ≫ f + g ≫ χ = 𝟙 B
⊢ Exact f g
Theorem: StarConvex.affine_preimage
File: Mathlib/Analysis/Convex/Star.lean

tactic: intro y hy a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
s✝ t : Set E
f : E →ᵃ[𝕜] F
s : Set F
hs : StarConvex 𝕜 (↑f x) s
⊢ StarConvex 𝕜 x (↑f ⁻¹' s)

tactic: rw [mem_preimage, Convex.combo_affine_apply hab]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ : E
s✝ t : Set E
f : E →ᵃ[𝕜] F
s : Set F
hs : StarConvex 𝕜 (↑f x) s
y : E
hy : y ∈ ↑f ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ ↑f ⁻¹' s

tactic: exact hs hy ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedRing 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ : E
s✝ t : Set E
f : E →ᵃ[𝕜] F
s : Set F
hs : StarConvex 𝕜 (↑f x) s
y : E
hy : y ∈ ↑f ⁻¹' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • ↑f x + b • ↑f y ∈ s
Theorem: Filter.tendsto_mul_const_atTop_iff
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [mul_comm _ r, tendsto_const_mul_atTop_iff]
state_before: ι : Type ?u.236788
ι' : Type ?u.236791
α : Type u_2
β : Type u_1
γ : Type ?u.236800
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : NeBot l
⊢ Tendsto (fun x => f x * r) l atTop ↔ 0 < r ∧ Tendsto f l atTop ∨ r < 0 ∧ Tendsto f l atBot
Theorem: ContinuousLinearMap.iteratedFDeriv_comp_right
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: simp only [← iteratedFDerivWithin_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.528096
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
g : G →L[𝕜] E
f : E → F
hf : ContDiff 𝕜 n f
x : G
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDeriv 𝕜 i (f ∘ ↑g) x =
    ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDeriv 𝕜 i f (↑g x)) fun x => g

tactic: exact g.iteratedFDerivWithin_comp_right hf.contDiffOn uniqueDiffOn_univ uniqueDiffOn_univ
    (mem_univ _) hi
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type ?u.528096
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x✝ x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
g : G →L[𝕜] E
f : E → F
hf : ContDiff 𝕜 n f
x : G
i : ℕ
hi : ↑i ≤ n
⊢ iteratedFDerivWithin 𝕜 i (f ∘ ↑g) univ x =
    ContinuousMultilinearMap.compContinuousLinearMap (iteratedFDerivWithin 𝕜 i f univ (↑g x)) fun x => g
Theorem: Int.mul_div_assoc'
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_comm, Int.mul_div_assoc _ h, Int.mul_comm]
state_before: b a c : Int
h : c ∣ a
⊢ div (a * b) c = div a c * b
Theorem: MvPolynomial.totalDegree_le_degrees_card
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
rw [totalDegree_eq]
exact Finset.sup_le fun s hs => Multiset.card_le_of_le <| Finset.le_sup hs
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.350050
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ totalDegree p ≤ ↑Multiset.card (degrees p)

tactic: rw [totalDegree_eq]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.350050
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ totalDegree p ≤ ↑Multiset.card (degrees p)

tactic: exact Finset.sup_le fun s hs => Multiset.card_le_of_le <| Finset.le_sup hs
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.350050
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
⊢ (Finset.sup (support p) fun m => ↑Multiset.card (↑toMultiset m)) ≤ ↑Multiset.card (degrees p)
Theorem: WithTop.image_coe_Iio
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Iio, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left (Iio_subset_Iio le_top)]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Iio a = Iio ↑a
Theorem: FirstOrder.Language.card_sum
File: Mathlib/ModelTheory/Basic.lean

tactic: simp only [card_eq_card_functions_add_card_relations, card_functions_sum, card_relations_sum,
  sum_add_distrib', lift_add, lift_sum, lift_lift]
state_before: L : Language
L' : Language
⊢ card (Language.sum L L') = lift (card L) + lift (card L')

tactic: simp only [add_assoc, add_comm (Cardinal.sum fun i => (#L'.Functions i).lift)]
state_before: L : Language
L' : Language
⊢ ((sum fun i => lift (#Functions L i)) + sum fun i => lift (#Functions L' i)) +
      ((sum fun i => lift (#Relations L i)) + sum fun i => lift (#Relations L' i)) =
    ((sum fun i => lift (#Functions L i)) + sum fun i => lift (#Relations L i)) +
      ((sum fun i => lift (#Functions L' i)) + sum fun i => lift (#Relations L' i))
Theorem: AffineBasis.basisOf_reindex
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: ext j
state_before: ι : Type u_5
ι' : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j : ι
e : ι ≃ ι'
i : ι'
⊢ basisOf (reindex b e) i =
    Basis.reindex (basisOf b (↑e.symm i)) (Equiv.subtypeEquiv e (_ : ∀ (x : ι), ¬x = ↑e.symm i ↔ ¬↑e x = i))

tactic: simp
state_before: case a
ι : Type u_5
ι' : Type u_1
k : Type u_2
V : Type u_3
P : Type u_4
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j✝ : ι
e : ι ≃ ι'
i : ι'
j : { j // j ≠ i }
⊢ ↑(basisOf (reindex b e) i) j =
    ↑(Basis.reindex (basisOf b (↑e.symm i)) (Equiv.subtypeEquiv e (_ : ∀ (x : ι), ¬x = ↑e.symm i ↔ ¬↑e x = i))) j