tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.lintegral_ofReal_le_lintegral_nnnorm
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp_rw [← ofReal_norm_eq_coe_nnnorm]
state_before: α : Type u_1
β : Type ?u.295320
γ : Type ?u.295323
δ : Type ?u.295326
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
⊢ (∫⁻ (x : α), ENNReal.ofReal (f x) ∂μ) ≤ ∫⁻ (x : α), ↑‖f x‖₊ ∂μ

tactic: refine' lintegral_mono fun x => ENNReal.ofReal_le_ofReal _
state_before: α : Type u_1
β : Type ?u.295320
γ : Type ?u.295323
δ : Type ?u.295326
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
⊢ (∫⁻ (x : α), ENNReal.ofReal (f x) ∂μ) ≤ ∫⁻ (x : α), ENNReal.ofReal ‖f x‖ ∂μ

tactic: rw [Real.norm_eq_abs]
state_before: α : Type u_1
β : Type ?u.295320
γ : Type ?u.295323
δ : Type ?u.295326
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
x : α
⊢ f x ≤ ‖f x‖

tactic: exact le_abs_self (f x)
state_before: α : Type u_1
β : Type ?u.295320
γ : Type ?u.295323
δ : Type ?u.295326
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ
x : α
⊢ f x ≤ abs (f x)
Theorem: Nat.Linear.Poly.denote_mul
File: src/lean/Init/Data/Nat/Linear.lean

tactic: simp
state_before: ctx : Context
k : Nat
p : Poly
⊢ denote ctx (mul k p) = k * denote ctx p

tactic: by_cases h : k == 0 <;> simp [h]
state_before: ctx : Context
k : Nat
p : Poly
⊢ denote ctx (bif k == 0 then [] else bif k == 1 then p else mul.go k p) = k * denote ctx p

tactic: simp [eq_of_beq h]
state_before: case inl
ctx : Context
k : Nat
p : Poly
h : (k == 0) = true
⊢ 0 = k * denote ctx p

case inr
ctx : Context
k : Nat
p : Poly
h : ¬(k == 0) = true
⊢ denote ctx (bif k == 1 then p else mul.go k p) = k * denote ctx p

tactic: by_cases h : k == 1 <;> simp [h]
state_before: case inr
ctx : Context
k : Nat
p : Poly
h : ¬(k == 0) = true
⊢ denote ctx (bif k == 1 then p else mul.go k p) = k * denote ctx p

tactic: simp [eq_of_beq h]
state_before: case inr.inl
ctx : Context
k : Nat
p : Poly
h✝ : ¬(k == 0) = true
h : (k == 1) = true
⊢ denote ctx p = k * denote ctx p

case inr.inr
ctx : Context
k : Nat
p : Poly
h✝ : ¬(k == 0) = true
h : ¬(k == 1) = true
⊢ denote ctx (mul.go k p) = k * denote ctx p

tactic: induction p with
| nil  => simp
| cons kv m ih => cases kv with | _ k' v => simp [ih]
state_before: case inr.inr
ctx : Context
k : Nat
p : Poly
h✝ : ¬(k == 0) = true
h : ¬(k == 1) = true
⊢ denote ctx (mul.go k p) = k * denote ctx p

tactic: simp
state_before: case inr.inr.nil
ctx : Context
k : Nat
h✝ : ¬(k == 0) = true
h : ¬(k == 1) = true
⊢ denote ctx (mul.go k []) = k * denote ctx []

tactic: cases kv with | _ k' v => simp [ih]
state_before: case inr.inr.cons
ctx : Context
k : Nat
h✝ : ¬(k == 0) = true
h : ¬(k == 1) = true
kv : Nat × Var
m : List (Nat × Var)
ih : denote ctx (mul.go k m) = k * denote ctx m
⊢ denote ctx (mul.go k (kv :: m)) = k * denote ctx (kv :: m)

tactic: simp [ih]
state_before: case inr.inr.cons.mk
ctx : Context
k : Nat
h✝ : ¬(k == 0) = true
h : ¬(k == 1) = true
m : List (Nat × Var)
ih : denote ctx (mul.go k m) = k * denote ctx m
k' : Nat
v : Var
⊢ denote ctx (mul.go k ((k', v) :: m)) = k * denote ctx ((k', v) :: m)
Theorem: Nat.set_eq_univ
File: Mathlib/Data/Nat/Order/Lemmas.lean

tactic: rintro rfl
state_before: a b m n k : ℕ
S : Set ℕ
⊢ S = Set.univ → 0 ∈ S ∧ ∀ (k : ℕ), k ∈ S → k + 1 ∈ S

tactic: simp
state_before: a b m n k : ℕ
⊢ 0 ∈ Set.univ ∧ ∀ (k : ℕ), k ∈ Set.univ → k + 1 ∈ Set.univ
Theorem: Finset.left_mem_Icc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: simp only [mem_Icc, true_and_iff, le_rfl]
state_before: ι : Type ?u.3846
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Icc a b ↔ a ≤ b
Theorem: Finset.prod_pow_choose_succ
File: Mathlib/Data/Nat/Choose/Sum.lean

tactic: have A : (∏ i in range (n + 1), f (i + 1) (n - i) ^ (n.choose (i + 1))) * f 0 (n + 1) =
  ∏ i in range (n + 1), f i (n + 1 - i) ^ (n.choose i)
state_before: R✝ : Type ?u.210813
M✝ : Type ?u.210816
R : Type ?u.210819
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_1
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
⊢ ∏ i in range (n + 2), f i (n + 1 - i) ^ Nat.choose (n + 1) i =
    (∏ i in range (n + 1), f i (n + 1 - i) ^ Nat.choose n i) * ∏ i in range (n + 1), f (i + 1) (n - i) ^ Nat.choose n i

tactic: rw [prod_range_succ']
state_before: R✝ : Type ?u.210813
M✝ : Type ?u.210816
R : Type ?u.210819
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_1
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
A :
  (∏ i in range (n + 1), f (i + 1) (n - i) ^ Nat.choose n (i + 1)) * f 0 (n + 1) =
    ∏ i in range (n + 1), f i (n + 1 - i) ^ Nat.choose n i
⊢ ∏ i in range (n + 2), f i (n + 1 - i) ^ Nat.choose (n + 1) i =
    (∏ i in range (n + 1), f i (n + 1 - i) ^ Nat.choose n i) * ∏ i in range (n + 1), f (i + 1) (n - i) ^ Nat.choose n i

tactic: simpa [Nat.choose_succ_succ, pow_add, prod_mul_distrib, A, mul_assoc] using mul_comm _ _
state_before: R✝ : Type ?u.210813
M✝ : Type ?u.210816
R : Type ?u.210819
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_1
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
A :
  (∏ i in range (n + 1), f (i + 1) (n - i) ^ Nat.choose n (i + 1)) * f 0 (n + 1) =
    ∏ i in range (n + 1), f i (n + 1 - i) ^ Nat.choose n i
⊢ (∏ k in range (n + 1), f (k + 1) (n + 1 - (k + 1)) ^ Nat.choose (n + 1) (k + 1)) *
      f 0 (n + 1 - 0) ^ Nat.choose (n + 1) 0 =
    (∏ i in range (n + 1), f i (n + 1 - i) ^ Nat.choose n i) * ∏ i in range (n + 1), f (i + 1) (n - i) ^ Nat.choose n i

tactic: rw [prod_range_succ, prod_range_succ']
state_before: case A
R✝ : Type ?u.210813
M✝ : Type ?u.210816
R : Type ?u.210819
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_1
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
⊢ (∏ i in range (n + 1), f (i + 1) (n - i) ^ Nat.choose n (i + 1)) * f 0 (n + 1) =
    ∏ i in range (n + 1), f i (n + 1 - i) ^ Nat.choose n i

tactic: simp
state_before: case A
R✝ : Type ?u.210813
M✝ : Type ?u.210816
R : Type ?u.210819
inst✝² : CommMonoid M✝
inst✝¹ : NonAssocSemiring R
M : Type u_1
inst✝ : CommMonoid M
f : ℕ → ℕ → M
n : ℕ
⊢ (∏ x in range n, f (x + 1) (n - x) ^ Nat.choose n (x + 1)) * f (n + 1) (n - n) ^ Nat.choose n (n + 1) * f 0 (n + 1) =
    (∏ k in range n, f (k + 1) (n + 1 - (k + 1)) ^ Nat.choose n (k + 1)) * f 0 (n + 1 - 0) ^ Nat.choose n 0
Theorem: PFunctor.M.mk_inj
File: Mathlib/Data/PFunctor/Univariate/M.lean

tactic: rw [← dest_mk x, h, dest_mk]
state_before: F : PFunctor
X : Type ?u.15917
f : X → Obj F X
x y : Obj F (M F)
h : M.mk x = M.mk y
⊢ x = y
Theorem: Mon_.one_mul_hom
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: rw [← id_tensor_comp_tensor_id, Category.assoc, M.one_mul, leftUnitor_naturality]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : MonoidalCategory C
M : Mon_ C
Z : C
f : Z ⟶ M.X
⊢ (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f
Theorem: Metric.finite_approx_of_totallyBounded
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: intro ε ε_pos
state_before: α : Type u
β : Type v
X : Type ?u.66642
ι : Type ?u.66645
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ s : Set α
hs : TotallyBounded s
⊢ ∀ (ε : ℝ), ε > 0 → ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ (y : α) (_ : y ∈ t), ball y ε

tactic: rw [totallyBounded_iff_subset] at hs
state_before: α : Type u
β : Type v
X : Type ?u.66642
ι : Type ?u.66645
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ s : Set α
hs : TotallyBounded s
ε : ℝ
ε_pos : ε > 0
⊢ ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ (y : α) (_ : y ∈ t), ball y ε

tactic: exact hs _ (dist_mem_uniformity ε_pos)
state_before: α : Type u
β : Type v
X : Type ?u.66642
ι : Type ?u.66645
inst✝ : PseudoMetricSpace α
x y z : α
δ ε✝ ε₁ ε₂ : ℝ
s✝ s : Set α
hs : ∀ (d : Set (α × α)), d ∈ 𝓤 α → ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
ε : ℝ
ε_pos : ε > 0
⊢ ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ (y : α) (_ : y ∈ t), ball y ε
Theorem: MeasureTheory.lintegral_rpow_nnnorm_eq_rpow_snorm'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [snorm', ← ENNReal.rpow_mul, one_div, inv_mul_cancel, ENNReal.rpow_one]
state_before: α : Type u_1
E : Type ?u.529623
F : Type u_2
G : Type ?u.529629
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hq0_lt : 0 < q
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) = snorm' f q μ ^ q

tactic: exact (ne_of_lt hq0_lt).symm
state_before: α : Type u_1
E : Type ?u.529623
F : Type u_2
G : Type ?u.529629
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
hq0_lt : 0 < q
⊢ q ≠ 0
Theorem: innerDualCone_sUnion
File: Mathlib/Analysis/Convex/Cone/Dual.lean

tactic: simp_rw [sInf_image, sUnion_eq_biUnion, innerDualCone_iUnion]
state_before: 𝕜 : Type ?u.17912
E : Type ?u.17915
F : Type ?u.17918
G : Type ?u.17921
H : Type u_1
inst✝¹ : NormedAddCommGroup H
inst✝ : InnerProductSpace ℝ H
s t : Set H
S : Set (Set H)
⊢ innerDualCone (⋃₀ S) = sInf (innerDualCone '' S)
Theorem: List.mem_map
File: Std/Data/List/Lemmas.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
b : β
f : α → β
⊢ b ∈ map f [] ↔ ∃ a, a ∈ [] ∧ f a = b

tactic: simp [mem_map (l := l), eq_comm (a := b)]
state_before: α : Type u_1
β : Type u_2
b : β
f : α → β
head✝ : α
l : List α
⊢ b ∈ map f (head✝ :: l) ↔ ∃ a, a ∈ head✝ :: l ∧ f a = b
Theorem: ENorm.map_smul
File: Mathlib/Analysis/NormedSpace/ENorm.lean

tactic: apply le_antisymm (e.map_smul_le' c x)
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
c : 𝕜
x : V
⊢ ↑e (c • x) = ↑‖c‖₊ * ↑e x

tactic: by_cases hc : c = 0
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
c : 𝕜
x : V
⊢ ↑‖c‖₊ * ↑e x ≤ ↑e (c • x)

tactic: calc
  (‖c‖₊ : ℝ≥0∞) * e x = ‖c‖₊ * e (c⁻¹ • c • x) := by rw [inv_smul_smul₀ hc]
  _ ≤ ‖c‖₊ * (‖c⁻¹‖₊ * e (c • x)) := mul_le_mul_left' (e.map_smul_le' _ _) _
  _ = e (c • x) := by
    rw [← mul_assoc, nnnorm_inv, ENNReal.coe_inv, ENNReal.mul_inv_cancel _ ENNReal.coe_ne_top,
      one_mul]
      <;> simp [hc]
state_before: case neg
𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
c : 𝕜
x : V
hc : ¬c = 0
⊢ ↑‖c‖₊ * ↑e x ≤ ↑e (c • x)

tactic: simp [hc]
state_before: case pos
𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
c : 𝕜
x : V
hc : c = 0
⊢ ↑‖c‖₊ * ↑e x ≤ ↑e (c • x)

tactic: rw [inv_smul_smul₀ hc]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
c : 𝕜
x : V
hc : ¬c = 0
⊢ ↑‖c‖₊ * ↑e x = ↑‖c‖₊ * ↑e (c⁻¹ • c • x)

tactic: rw [← mul_assoc, nnnorm_inv, ENNReal.coe_inv, ENNReal.mul_inv_cancel _ ENNReal.coe_ne_top,
  one_mul]
  <;> simp [hc]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
c : 𝕜
x : V
hc : ¬c = 0
⊢ ↑‖c‖₊ * (↑‖c⁻¹‖₊ * ↑e (c • x)) = ↑e (c • x)
Theorem: Set.ncard_singleton
File: Mathlib/Data/Set/Ncard.lean

tactic: simp [ncard_eq_toFinset_card]
state_before: α : Type u_1
β : Type ?u.7605
s t : Set α
a✝ b x y : α
f : α → β
a : α
⊢ ncard {a} = 1
Theorem: zsmul_eq_mul
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [coe_nat_zsmul, nsmul_eq_mul, Int.cast_ofNat]
state_before: α : Type ?u.276006
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Ring R
a : R
n : ℕ
⊢ ↑n • a = ↑↑n * a

tactic: simp [Nat.cast_succ, neg_add_rev, Int.cast_negSucc, add_mul]
state_before: α : Type ?u.276006
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : Ring R
a : R
n : ℕ
⊢ -[n+1] • a = ↑-[n+1] * a
Theorem: uniformEmbedding_iff'
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rw [uniformEmbedding_iff, and_comm, uniformInducing_iff']
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ UniformEmbedding f ↔ Injective f ∧ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
Theorem: Stream'.WSeq.liftRel_think_right
File: Mathlib/Data/Seq/WSeq.lean

tactic: rw [liftRel_destruct_iff, liftRel_destruct_iff]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
⊢ LiftRel R s (think t) ↔ LiftRel R s t

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
s : WSeq α
t : WSeq β
⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct s) (destruct (think t)) ↔
    Computation.LiftRel (LiftRelO R (LiftRel R)) (destruct s) (destruct t)
Theorem: tendsto_zpow_atTop_zero
File: Mathlib/Topology/Algebra/Order/Field.lean

tactic: lift -n to ℕ using le_of_lt (neg_pos.mpr hn) with N h
state_before: 𝕜 : Type u_1
α : Type ?u.32706
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℤ
hn : n < 0
⊢ Tendsto (fun x => x ^ n) atTop (𝓝 0)

tactic: rw [← neg_pos, ← h, Nat.cast_pos] at hn
state_before: case intro
𝕜 : Type u_1
α : Type ?u.32706
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℤ
hn : n < 0
N : ℕ
h : ↑N = -n
⊢ Tendsto (fun x => x ^ n) atTop (𝓝 0)

tactic: simpa only [h, neg_neg] using tendsto_pow_neg_atTop hn.ne'
state_before: case intro
𝕜 : Type u_1
α : Type ?u.32706
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
n : ℤ
N : ℕ
hn : 0 < N
h : ↑N = -n
⊢ Tendsto (fun x => x ^ n) atTop (𝓝 0)
Theorem: EMetric.infEdist_pos_iff_not_mem_closure
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: rw [mem_closure_iff_infEdist_zero, pos_iff_ne_zero]
state_before: ι : Sort ?u.17614
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
inst✝ : PseudoEMetricSpace β
x✝ y : α
s t : Set α
Φ : α → β
x : α
E : Set α
⊢ 0 < infEdist x E ↔ ¬x ∈ closure E
Theorem: MeasurableSet.sInter
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: rw [sInter_eq_biInter]
state_before: α : Type u_1
β : Type ?u.8090
γ : Type ?u.8093
δ : Type ?u.8096
δ' : Type ?u.8099
ι : Sort ?u.8102
s✝ t u : Set α
m : MeasurableSpace α
s : Set (Set α)
hs : Set.Countable s
h : ∀ (t : Set α), t ∈ s → MeasurableSet t
⊢ MeasurableSet (⋂₀ s)

tactic: exact MeasurableSet.biInter hs h
state_before: α : Type u_1
β : Type ?u.8090
γ : Type ?u.8093
δ : Type ?u.8096
δ' : Type ?u.8099
ι : Sort ?u.8102
s✝ t u : Set α
m : MeasurableSpace α
s : Set (Set α)
hs : Set.Countable s
h : ∀ (t : Set α), t ∈ s → MeasurableSet t
⊢ MeasurableSet (⋂ (i : Set α) (_ : i ∈ s), i)
Theorem: generatePiSystem_measurableSet
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: induction' h_in_pi with s h_s s u _ _ _ h_s h_u
state_before: α : Type u_1
M : MeasurableSpace α
S : Set (Set α)
h_meas_S : ∀ (s : Set α), s ∈ S → MeasurableSet s
t : Set α
h_in_pi : t ∈ generatePiSystem S
⊢ MeasurableSet t

tactic: apply h_meas_S _ h_s
state_before: case base
α : Type u_1
M : MeasurableSpace α
S : Set (Set α)
h_meas_S : ∀ (s : Set α), s ∈ S → MeasurableSet s
t s : Set α
h_s : s ∈ S
⊢ MeasurableSet s

tactic: apply MeasurableSet.inter h_s h_u
state_before: case inter
α : Type u_1
M : MeasurableSpace α
S : Set (Set α)
h_meas_S : ∀ (s : Set α), s ∈ S → MeasurableSet s
t s u : Set α
h_s✝ : generatePiSystem S s
h_t✝ : generatePiSystem S u
h_nonempty✝ : Set.Nonempty (s ∩ u)
h_s : MeasurableSet s
h_u : MeasurableSet u
⊢ MeasurableSet (s ∩ u)
Theorem: CategoryTheory.Functor.toPreimages_nonempty_of_surjective
File: Mathlib/CategoryTheory/CofilteredSystem.lean

tactic: simp only [toPreimages_obj, nonempty_coe_sort, nonempty_iInter, mem_preimage]
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), _root_.Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : Set.Nonempty s
j : J
⊢ _root_.Nonempty ((toPreimages F s).obj j)

tactic: obtain h | ⟨⟨ji⟩⟩ := isEmpty_or_nonempty (j ⟶ i)
state_before: J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), _root_.Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : Set.Nonempty s
j : J
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s

tactic: exact ⟨(hFn j).some, fun ji => h.elim ji⟩
state_before: case inl
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), _root_.Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : Set.Nonempty s
j : J
h : IsEmpty (j ⟶ i)
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s

tactic: obtain ⟨y, ys⟩ := hs
state_before: case inr.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), _root_.Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
hs : Set.Nonempty s
j : J
ji : j ⟶ i
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s

tactic: obtain ⟨x, rfl⟩ := Fsur ji y
state_before: case inr.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), _root_.Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
j : J
ji : j ⟶ i
y : F.obj i
ys : y ∈ s
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s

tactic: exact ⟨x, fun ji' => (F.thin_diagram_of_surjective Fsur ji' ji).symm ▸ ys⟩
state_before: case inr.intro.intro.intro
J : Type u
inst✝¹ : Category J
F : J ⥤ Type v
i j✝ k : J
s : Set (F.obj i)
inst✝ : IsCofilteredOrEmpty J
hFn : ∀ (j : J), _root_.Nonempty (F.obj j)
Fsur : ∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective (F.map f)
j : J
ji : j ⟶ i
x : F.obj j
ys : F.map ji x ∈ s
⊢ ∃ x, ∀ (i_1 : j ⟶ i), F.map i_1 x ∈ s
Theorem: Filter.iSup_neBot
File: Mathlib/Order/Filter/Basic.lean

tactic: simp [neBot_iff]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.66517
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
⊢ NeBot (⨆ (i : ι), f i) ↔ ∃ i, NeBot (f i)
Theorem: hasDerivWithinAt_iff_tendsto_slope
File: Mathlib/Analysis/Calculus/Deriv/Slope.lean

tactic: simp only [HasDerivWithinAt, nhdsWithin, diff_eq, inf_assoc.symm, inf_principal.symm]
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 𝕜
⊢ HasDerivWithinAt f f' s x ↔ Tendsto (slope f x) (𝓝[s \ {x}] x) (𝓝 f')

tactic: exact hasDerivAtFilter_iff_tendsto_slope
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 𝕜
⊢ HasDerivAtFilter f f' x (𝓝 x ⊓ 𝓟 s) ↔ Tendsto (slope f x) (𝓝 x ⊓ 𝓟 s ⊓ 𝓟 ({x}ᶜ)) (𝓝 f')
Theorem: Ordnode.Valid'.balanceR_aux
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [Valid'.dual_iff, dual_balanceR]
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H₁ : size r = 0 → size l ≤ 1
H₂ : 1 ≤ size r → 1 ≤ size l → size l ≤ delta * size r
H₃ : 2 * size r ≤ 9 * size l + 5 ∨ size r ≤ 3
⊢ Valid' o₁ (balanceR l x r) o₂

tactic: have := hr.dual.balanceL_aux hl.dual
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H₁ : size r = 0 → size l ≤ 1
H₂ : 1 ≤ size r → 1 ≤ size l → size l ≤ delta * size r
H₃ : 2 * size r ≤ 9 * size l + 5 ∨ size r ≤ 3
⊢ Valid' o₂ (Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l)) o₁

tactic: rw [size_dual, size_dual] at this
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H₁ : size r = 0 → size l ≤ 1
H₂ : 1 ≤ size r → 1 ≤ size l → size l ≤ delta * size r
H₃ : 2 * size r ≤ 9 * size l + 5 ∨ size r ≤ 3
this :
  (size (Ordnode.dual r) = 0 → size (Ordnode.dual l) ≤ 1) →
    (1 ≤ size (Ordnode.dual r) → 1 ≤ size (Ordnode.dual l) → size (Ordnode.dual l) ≤ delta * size (Ordnode.dual r)) →
      2 * size (Ordnode.dual r) ≤ 9 * size (Ordnode.dual l) + 5 ∨ size (Ordnode.dual r) ≤ 3 →
        Valid' o₂ (Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l)) o₁
⊢ Valid' o₂ (Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l)) o₁

tactic: exact this H₁ H₂ H₃
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H₁ : size r = 0 → size l ≤ 1
H₂ : 1 ≤ size r → 1 ≤ size l → size l ≤ delta * size r
H₃ : 2 * size r ≤ 9 * size l + 5 ∨ size r ≤ 3
this :
  (size r = 0 → size l ≤ 1) →
    (1 ≤ size r → 1 ≤ size l → size l ≤ delta * size r) →
      2 * size r ≤ 9 * size l + 5 ∨ size r ≤ 3 → Valid' o₂ (Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l)) o₁
⊢ Valid' o₂ (Ordnode.balanceL (Ordnode.dual r) x (Ordnode.dual l)) o₁
Theorem: Filter.extraction_forall_of_eventually'
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [eventually_atTop, h]
state_before: ι : Type ?u.60772
ι' : Type ?u.60775
α : Type ?u.60778
β : Type ?u.60781
γ : Type ?u.60784
P : ℕ → ℕ → Prop
h : ∀ (n : ℕ), ∃ N, ∀ (k : ℕ), k ≥ N → P n k
⊢ ∀ (n : ℕ), ∀ᶠ (k : ℕ) in atTop, P n k
Theorem: Cardinal.mk_set_eq_nat_iff_finset
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: constructor
state_before: α✝ β : Type u
α : Type u_1
s : Set α
n : ℕ
⊢ (#↑s) = ↑n ↔ ∃ t, ↑t = s ∧ Finset.card t = n

tactic: intro h
state_before: case mp
α✝ β : Type u
α : Type u_1
s : Set α
n : ℕ
⊢ (#↑s) = ↑n → ∃ t, ↑t = s ∧ Finset.card t = n

tactic: lift s to Finset α using lt_aleph0_iff_set_finite.1 (h.symm ▸ nat_lt_aleph0 n)
state_before: case mp
α✝ β : Type u
α : Type u_1
s : Set α
n : ℕ
h : (#↑s) = ↑n
⊢ ∃ t, ↑t = s ∧ Finset.card t = n

tactic: simpa using h
state_before: case mp.intro
α✝ β : Type u
α : Type u_1
n : ℕ
s : Finset α
h : (#↑↑s) = ↑n
⊢ ∃ t, ↑t = ↑s ∧ Finset.card t = n

tactic: rintro ⟨t, rfl, rfl⟩
state_before: case mpr
α✝ β : Type u
α : Type u_1
s : Set α
n : ℕ
⊢ (∃ t, ↑t = s ∧ Finset.card t = n) → (#↑s) = ↑n

tactic: exact mk_coe_finset
state_before: case mpr.intro.intro
α✝ β : Type u
α : Type u_1
t : Finset α
⊢ (#↑↑t) = ↑(Finset.card t)
Theorem: inner_sum_smul_sum_smul_of_sum_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp_rw [sum_inner, inner_sum, real_inner_smul_left, real_inner_smul_right,
  real_inner_eq_norm_mul_self_add_norm_mul_self_sub_norm_sub_mul_self_div_two, ← div_sub_div_same,
  ← div_add_div_same, mul_sub_left_distrib, left_distrib, Finset.sum_sub_distrib,
  Finset.sum_add_distrib, ← Finset.mul_sum, ← Finset.sum_mul, h₁, h₂, MulZeroClass.zero_mul,
  MulZeroClass.mul_zero, Finset.sum_const_zero, zero_add, zero_sub, Finset.mul_sum, neg_div,
  Finset.sum_div, mul_div_assoc, mul_assoc]
state_before: 𝕜 : Type ?u.3253936
E : Type ?u.3253939
F : Type u_3
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι₁ : Type u_1
s₁ : Finset ι₁
w₁ : ι₁ → ℝ
v₁ : ι₁ → F
h₁ : ∑ i in s₁, w₁ i = 0
ι₂ : Type u_2
s₂ : Finset ι₂
w₂ : ι₂ → ℝ
v₂ : ι₂ → F
h₂ : ∑ i in s₂, w₂ i = 0
⊢ inner (∑ i₁ in s₁, w₁ i₁ • v₁ i₁) (∑ i₂ in s₂, w₂ i₂ • v₂ i₂) =
    (-∑ i₁ in s₁, ∑ i₂ in s₂, w₁ i₁ * w₂ i₂ * (‖v₁ i₁ - v₂ i₂‖ * ‖v₁ i₁ - v₂ i₂‖)) / 2