tasksource/leandojo huggingface dataset:
Theorem: Set.einfsep_eq_iInf
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: refine' eq_of_forall_le_iff fun _ => _
state_before: α : Type u_1
β : Type ?u.28409
inst✝ : EDist α
x y : α
s t : Set α
⊢ einfsep s = ⨅ (d : ↑(offDiag s)), uncurry edist ↑d

tactic: simp_rw [le_einfsep_iff, le_iInf_iff, imp_forall_iff, SetCoe.forall, mem_offDiag,
  Prod.forall, uncurry_apply_pair, and_imp]
state_before: α : Type u_1
β : Type ?u.28409
inst✝ : EDist α
x y : α
s t : Set α
x✝ : ℝ≥0∞
⊢ x✝ ≤ einfsep s ↔ x✝ ≤ ⨅ (d : ↑(offDiag s)), uncurry edist ↑d
Theorem: Int.eq_zero_of_abs_lt_dvd
File: Mathlib/Data/Int/Order/Lemmas.lean

tactic: by_cases hm : m = 0
state_before: a b : ℤ
n : ℕ
m x : ℤ
h1 : m ∣ x
h2 : abs x < m
⊢ x = 0

tactic: rcases h1 with ⟨d, rfl⟩
state_before: case neg
a b : ℤ
n : ℕ
m x : ℤ
h1 : m ∣ x
h2 : abs x < m
hm : ¬m = 0
⊢ x = 0

tactic: apply mul_eq_zero_of_right
state_before: case neg.intro
a b : ℤ
n : ℕ
m : ℤ
hm : ¬m = 0
d : ℤ
h2 : abs (m * d) < m
⊢ m * d = 0

tactic: rw [← abs_lt_one_iff, ← mul_lt_iff_lt_one_right (abs_pos.mpr hm), ← abs_mul]
state_before: case neg.intro.h
a b : ℤ
n : ℕ
m : ℤ
hm : ¬m = 0
d : ℤ
h2 : abs (m * d) < m
⊢ d = 0

tactic: exact lt_of_lt_of_le h2 (le_abs_self m)
state_before: case neg.intro.h
a b : ℤ
n : ℕ
m : ℤ
hm : ¬m = 0
d : ℤ
h2 : abs (m * d) < m
⊢ abs (m * d) < abs m

tactic: subst m
state_before: case pos
a b : ℤ
n : ℕ
m x : ℤ
h1 : m ∣ x
h2 : abs x < m
hm : m = 0
⊢ x = 0

tactic: exact zero_dvd_iff.mp h1
state_before: case pos
a b : ℤ
n : ℕ
x : ℤ
h1 : 0 ∣ x
h2 : abs x < 0
⊢ x = 0
Theorem: Urysohns.CU.lim_of_nmem_U
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: simp only [CU.lim, approx_of_nmem_U c _ h, ciSup_const]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
c : CU X
x : X
h : ¬x ∈ c.U
⊢ CU.lim c x = 1
Theorem: Part.inter_mem_inter
File: Mathlib/Data/Part.lean

tactic: simp [inter_def]
state_before: α : Type u_1
β : Type ?u.81876
γ : Type ?u.81879
inst✝ : Inter α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ma ∩ mb ∈ a ∩ b

tactic: aesop
state_before: α : Type u_1
β : Type ?u.81876
γ : Type ?u.81879
inst✝ : Inter α
a b : Part α
ma mb : α
ha : ma ∈ a
hb : mb ∈ b
⊢ ∃ a_1, a_1 ∈ a ∧ ∃ a, a ∈ b ∧ a_1 ∩ a = ma ∩ mb
Theorem: MeasureTheory.Measure.finiteAtBot
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [measure_empty, WithTop.zero_lt_top]
state_before: α : Type u_1
β : Type ?u.722328
γ : Type ?u.722331
δ : Type ?u.722334
ι : Type ?u.722337
R : Type ?u.722340
R' : Type ?u.722343
m0✝ : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ✝ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
m0 : MeasurableSpace α
μ : Measure α
⊢ ↑↑μ ∅ < ⊤
Theorem: Action.functorCategoryMonoidalEquivalence.ε_app
File: Mathlib/RepresentationTheory/Action.lean

tactic: dsimp only [functorCategoryMonoidalEquivalence]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ (functorCategoryMonoidalEquivalence V G).toLaxMonoidalFunctor.ε.app PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)

tactic: simp only [Monoidal.fromTransported_toLaxMonoidalFunctor_ε]
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ (Monoidal.fromTransported
              (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).toLaxMonoidalFunctor.ε.app
      PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)

tactic: rfl
state_before: V : Type (u + 1)
inst✝¹ : LargeCategory V
G : MonCat
inst✝ : MonoidalCategory V
⊢ ((Equivalence.unit (CategoryTheory.Equivalence.symm (functorCategoryEquivalence V G))).app
          (𝟙_ (SingleObj ↑G ⥤ V))).app
      PUnit.unit =
    𝟙 ((𝟙_ (SingleObj ↑G ⥤ V)).obj PUnit.unit)
Theorem: Nat.floor_zero
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← Nat.cast_zero, floor_coe]
state_before: F : Type ?u.25771
α : Type u_1
β : Type ?u.25777
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ ⌊0⌋₊ = 0
Theorem: Ideal.bot_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp
state_before: R : Type u
ι : Type ?u.285120
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ ⊥ * I = ⊥
Theorem: Finset.insert_union
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [insert_eq, union_assoc]
state_before: α : Type u_1
β : Type ?u.149642
γ : Type ?u.149645
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ insert a s ∪ t = insert a (s ∪ t)
Theorem: Subgroup.relindex_top_right
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← relindex_mul_index (show H ≤ ⊤ from le_top), index_top, mul_one]
state_before: G : Type u_1
inst✝ : Group G
H K L : Subgroup G
⊢ relindex H ⊤ = index H
Theorem: BoxIntegral.integralSum_smul
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simp only [integralSum, Finset.smul_sum, Pi.smul_apply, ContinuousLinearMap.map_smul]
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
c : ℝ
f : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
π : TaggedPrepartition I
⊢ integralSum (c • f) vol π = c • integralSum f vol π
Theorem: Int.nonpos_of_neg_nonneg
File: Std/Data/Int/Lemmas.lean

tactic: rwa [Int.neg_zero]
state_before: a : Int
h : 0 ≤ -a
⊢ -0 ≤ -a
Theorem: EReal.nhds_bot
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [bot_lt_iff_ne_bot]
state_before: α : Type ?u.12836
inst✝ : TopologicalSpace α
⊢ (⨅ (l : EReal) (_ : ⊥ < l), 𝓟 (Iio l)) = ⨅ (a : EReal) (_ : a ≠ ⊥), 𝓟 (Iio a)
Theorem: CategoryTheory.leftDistributor_hom
File: Mathlib/CategoryTheory/Monoidal/Preadditive.lean

tactic: ext
state_before: C : Type u_2
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
⊢ (leftDistributor X f).hom = ∑ j : J, (𝟙 X ⊗ biproduct.π f j) ≫ biproduct.ι (fun j => X ⊗ f j) j

tactic: dsimp [leftDistributor, Functor.mapBiproduct, Functor.mapBicone]
state_before: case w
C : Type u_2
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
j✝ : J
⊢ (leftDistributor X f).hom ≫ biproduct.π (fun j => X ⊗ f j) j✝ =
    (∑ j : J, (𝟙 X ⊗ biproduct.π f j) ≫ biproduct.ι (fun j => X ⊗ f j) j) ≫ biproduct.π (fun j => X ⊗ f j) j✝

tactic: erw [biproduct.lift_π]
state_before: case w
C : Type u_2
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
j✝ : J
⊢ (biproduct.lift fun j => 𝟙 X ⊗ biproduct.π f j) ≫ biproduct.π (fun j => X ⊗ f j) j✝ =
    (∑ j : J, (𝟙 X ⊗ biproduct.π f j) ≫ biproduct.ι (fun j => X ⊗ f j) j) ≫ biproduct.π (fun j => X ⊗ f j) j✝

tactic: simp only [Preadditive.sum_comp, Category.assoc, biproduct.ι_π, comp_dite, comp_zero,
  Finset.sum_dite_eq', Finset.mem_univ, ite_true, eqToHom_refl, Category.comp_id]
state_before: case w
C : Type u_2
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
inst✝³ : MonoidalCategory C
inst✝² : MonoidalPreadditive C
inst✝¹ : HasFiniteBiproducts C
J : Type
inst✝ : Fintype J
X : C
f : J → C
j✝ : J
⊢ 𝟙 X ⊗ biproduct.π f j✝ =
    (∑ j : J, (𝟙 X ⊗ biproduct.π f j) ≫ biproduct.ι (fun j => X ⊗ f j) j) ≫ biproduct.π (fun j => X ⊗ f j) j✝
Theorem: Padic.padicNormE_lim_le
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: obtain ⟨N, hN⟩ := (CauSeq.equiv_lim f) _ ha
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] norm
a : ℝ
ha : 0 < a
hf : ∀ (i : ℕ), ‖↑f i‖ ≤ a
⊢ ‖CauSeq.lim f‖ ≤ a

tactic: rw [←sub_add_cancel f.lim (f N)]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] norm
a : ℝ
ha : 0 < a
hf : ∀ (i : ℕ), ‖↑f i‖ ≤ a
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(f - const norm (CauSeq.lim f)) j‖ < a
⊢ ‖CauSeq.lim f‖ ≤ a

tactic: refine le_trans (padicNormE.nonarchimedean _ _) ?_
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] norm
a : ℝ
ha : 0 < a
hf : ∀ (i : ℕ), ‖↑f i‖ ≤ a
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(f - const norm (CauSeq.lim f)) j‖ < a
⊢ ‖CauSeq.lim f - ↑f N + ↑f N‖ ≤ a

tactic: rw [norm_sub_rev]
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] norm
a : ℝ
ha : 0 < a
hf : ∀ (i : ℕ), ‖↑f i‖ ≤ a
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(f - const norm (CauSeq.lim f)) j‖ < a
⊢ max ‖CauSeq.lim f - ↑f N‖ ‖↑f N‖ ≤ a

tactic: exact max_le (le_of_lt (hN _ le_rfl)) (hf _)
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
f : CauSeq ℚ_[p] norm
a : ℝ
ha : 0 < a
hf : ∀ (i : ℕ), ‖↑f i‖ ≤ a
N : ℕ
hN : ∀ (j : ℕ), j ≥ N → ‖↑(f - const norm (CauSeq.lim f)) j‖ < a
⊢ max ‖↑f N - CauSeq.lim f‖ ‖↑f N‖ ≤ a
Theorem: MulAction.orbit_smul
File: Mathlib/GroupTheory/GroupAction/Basic.lean

tactic: rw [inv_smul_smul]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
a : α
b : β
⊢ orbit α b = orbit α (a⁻¹ • a • b)
Theorem: MonoidAlgebra.mul_single_apply_of_not_exists_mul
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: rw [mul_apply, Finsupp.sum_comm, Finsupp.sum_single_index]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = d * g
⊢ ↑(x * single g r) g' = 0

tactic: swap
state_before: k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = d * g
⊢ (sum x fun x v => if x * g = g' then v * r else 0) = 0

k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = d * g
⊢ (sum x fun x v => if x * g = g' then v * 0 else 0) = 0

tactic: simp_rw [Finsupp.sum, MulZeroClass.mul_zero, ite_self, Finset.sum_const_zero]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = d * g
⊢ (sum x fun x v => if x * g = g' then v * 0 else 0) = 0

tactic: apply Finset.sum_eq_zero
state_before: k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = d * g
⊢ (sum x fun x v => if x * g = g' then v * r else 0) = 0

tactic: simp_rw [ite_eq_right_iff]
state_before: case h
k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = d * g
⊢ ∀ (x_1 : G), x_1 ∈ x.support → (fun x v => if x * g = g' then v * r else 0) x_1 (↑x x_1) = 0

tactic: rintro g'' _hg'' rfl
state_before: case h
k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g g' : G
x : MonoidAlgebra k G
h : ¬∃ d, g' = d * g
⊢ ∀ (x_1 : G), x_1 ∈ x.support → x_1 * g = g' → ↑x x_1 * r = 0

tactic: exfalso
state_before: case h
k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g : G
x : MonoidAlgebra k G
g'' : G
_hg'' : g'' ∈ x.support
h : ¬∃ d, g'' * g = d * g
⊢ ↑x g'' * r = 0

tactic: exact h ⟨_, rfl⟩
state_before: case h.h
k : Type u₁
G : Type u₂
R : Type ?u.506603
inst✝¹ : Semiring k
inst✝ : Mul G
r : k
g : G
x : MonoidAlgebra k G
g'' : G
_hg'' : g'' ∈ x.support
h : ¬∃ d, g'' * g = d * g
⊢ False
Theorem: Part.append_get_eq
File: Mathlib/Data/Part.lean

tactic: simp [append_def]
state_before: α : Type u_1
β : Type ?u.80296
γ : Type ?u.80299
inst✝ : Append α
a b : Part α
hab : (a ++ b).Dom
⊢ get (a ++ b) hab = get a (_ : a.Dom) ++ get b (_ : b.Dom)

tactic: aesop
state_before: α : Type u_1
β : Type ?u.80296
γ : Type ?u.80299
inst✝ : Append α
a b : Part α
hab : (a ++ b).Dom
⊢ get (Part.bind a fun y => map (fun x => y ++ x) b) (_ : (Part.bind a fun y => map (fun x => y ++ x) b).Dom) =
    get a (_ : a.Dom) ++ get b (_ : b.Dom)
Theorem: Fintype.prod_unique
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [univ_unique, prod_singleton]
state_before: ι : Type ?u.879170
β✝ : Type u
α✝ : Type v
γ : Type w
s s₁ s₂ : Finset α✝
a : α✝
f✝ g : α✝ → β✝
α : Type u_1
β : Type u_2
inst✝² : CommMonoid β
inst✝¹ : Unique α
inst✝ : Fintype α
f : α → β
⊢ ∏ x : α, f x = f default
Theorem: Ordinal.bddAbove_range
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rintro a ⟨i, rfl⟩
state_before: α : Type ?u.278295
β : Type ?u.278298
γ : Type ?u.278301
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal
⊢ ord (iSup (succ ∘ card ∘ f)) ∈ upperBounds (range f)

tactic: exact le_of_lt (Cardinal.lt_ord.2 ((lt_succ _).trans_le
  (le_ciSup (Cardinal.bddAbove_range.{_, v} _) _)))
state_before: case intro
α : Type ?u.278295
β : Type ?u.278298
γ : Type ?u.278301
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
ι : Type u
f : ι → Ordinal
i : ι
⊢ f i ≤ ord (iSup (succ ∘ card ∘ f))
Theorem: Real.contDiffAt_rpow_of_ne
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: cases' hp.lt_or_lt with hneg hpos
state_before: x y z : ℝ
p : ℝ × ℝ
hp : p.fst ≠ 0
n : ℕ∞
⊢ ContDiffAt ℝ n (fun p => p.fst ^ p.snd) p

tactic: exacts
  [(((contDiffAt_fst.log hneg.ne).mul contDiffAt_snd).exp.mul
        (contDiffAt_snd.mul contDiffAt_const).cos).congr_of_eventuallyEq
    ((continuousAt_fst.eventually (gt_mem_nhds hneg)).mono fun p hp => rpow_def_of_neg hp _),
  ((contDiffAt_fst.log hpos.ne').mul contDiffAt_snd).exp.congr_of_eventuallyEq
    ((continuousAt_fst.eventually (lt_mem_nhds hpos)).mono fun p hp => rpow_def_of_pos hp _)]
state_before: case inl
x y z : ℝ
p : ℝ × ℝ
hp : p.fst ≠ 0
n : ℕ∞
hneg : p.fst < 0
⊢ ContDiffAt ℝ n (fun p => p.fst ^ p.snd) p

case inr
x y z : ℝ
p : ℝ × ℝ
hp : p.fst ≠ 0
n : ℕ∞
hpos : 0 < p.fst
⊢ ContDiffAt ℝ n (fun p => p.fst ^ p.snd) p
Theorem: CategoryTheory.Splitting.section_retraction
File: Mathlib/Algebra/Homology/ShortExact/Preadditive.lean

tactic: delta Splitting.section retraction
state_before: 𝒜 : Type u_2
inst✝² : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝¹ : HasZeroMorphisms 𝒜
inst✝ : HasBinaryBiproducts 𝒜
h : Splitting f g
⊢ section h ≫ retraction h = 0

tactic: simp
state_before: 𝒜 : Type u_2
inst✝² : Category 𝒜
A B C A' B' C' : 𝒜
f : A ⟶ B
g : B ⟶ C
f' : A' ⟶ B'
g' : B' ⟶ C'
inst✝¹ : HasZeroMorphisms 𝒜
inst✝ : HasBinaryBiproducts 𝒜
h : Splitting f g
⊢ (biprod.inr ≫ h.iso.inv) ≫ h.iso.hom ≫ biprod.fst = 0
Theorem: Finset.exists_minimal
File: Mathlib/Data/Fintype/Card.lean

tactic: obtain ⟨c, hcs : c ∈ s⟩ := h
state_before: α✝ : Type ?u.64966
β : Type ?u.64969
γ : Type ?u.64972
α : Type u_1
inst✝ : Preorder α
s : Finset α
h : Finset.Nonempty s
⊢ ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬x < m

tactic: have : WellFounded (@LT.lt { x // x ∈ s } _) := Finite.wellFounded_of_trans_of_irrefl _
state_before: case intro
α✝ : Type ?u.64966
β : Type ?u.64969
γ : Type ?u.64972
α : Type u_1
inst✝ : Preorder α
s : Finset α
c : α
hcs : c ∈ s
⊢ ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬x < m

tactic: obtain ⟨⟨m, hms : m ∈ s⟩, -, H⟩ := this.has_min Set.univ ⟨⟨c, hcs⟩, trivial⟩
state_before: case intro
α✝ : Type ?u.64966
β : Type ?u.64969
γ : Type ?u.64972
α : Type u_1
inst✝ : Preorder α
s : Finset α
c : α
hcs : c ∈ s
this : WellFounded LT.lt
⊢ ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬x < m

tactic: exact ⟨m, hms, fun x hx hxm => H ⟨x, hx⟩ trivial hxm⟩
state_before: case intro.intro.mk.intro
α✝ : Type ?u.64966
β : Type ?u.64969
γ : Type ?u.64972
α : Type u_1
inst✝ : Preorder α
s : Finset α
c : α
hcs : c ∈ s
this : WellFounded LT.lt
m : α
hms : m ∈ s
H : ∀ (x : { x // x ∈ s }), x ∈ Set.univ → ¬x < { val := m, property := hms }
⊢ ∃ m, m ∈ s ∧ ∀ (x : α), x ∈ s → ¬x < m
Theorem: Set.list_prod_subset_list_prod
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

tactic: induction' t with h tl ih
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.71424
F : Type ?u.71427
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : List ι
f₁ f₂ : ι → Set α
hf : ∀ (i : ι), i ∈ t → f₁ i ⊆ f₂ i
⊢ List.prod (List.map f₁ t) ⊆ List.prod (List.map f₂ t)

tactic: rfl
state_before: case nil
ι : Type u_1
α : Type u_2
β : Type ?u.71424
F : Type ?u.71427
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : List ι
f₁ f₂ : ι → Set α
hf✝ : ∀ (i : ι), i ∈ t → f₁ i ⊆ f₂ i
hf : ∀ (i : ι), i ∈ [] → f₁ i ⊆ f₂ i
⊢ List.prod (List.map f₁ []) ⊆ List.prod (List.map f₂ [])

tactic: simp_rw [List.map_cons, List.prod_cons]
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type ?u.71424
F : Type ?u.71427
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : List ι
f₁ f₂ : ι → Set α
hf✝ : ∀ (i : ι), i ∈ t → f₁ i ⊆ f₂ i
h : ι
tl : List ι
ih : (∀ (i : ι), i ∈ tl → f₁ i ⊆ f₂ i) → List.prod (List.map f₁ tl) ⊆ List.prod (List.map f₂ tl)
hf : ∀ (i : ι), i ∈ h :: tl → f₁ i ⊆ f₂ i
⊢ List.prod (List.map f₁ (h :: tl)) ⊆ List.prod (List.map f₂ (h :: tl))

tactic: exact mul_subset_mul (hf h <| List.mem_cons_self _ _)
  (ih fun i hi ↦ hf i <| List.mem_cons_of_mem _ hi)
state_before: case cons
ι : Type u_1
α : Type u_2
β : Type ?u.71424
F : Type ?u.71427
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : List ι
f₁ f₂ : ι → Set α
hf✝ : ∀ (i : ι), i ∈ t → f₁ i ⊆ f₂ i
h : ι
tl : List ι
ih : (∀ (i : ι), i ∈ tl → f₁ i ⊆ f₂ i) → List.prod (List.map f₁ tl) ⊆ List.prod (List.map f₂ tl)
hf : ∀ (i : ι), i ∈ h :: tl → f₁ i ⊆ f₂ i
⊢ f₁ h * List.prod (List.map f₁ tl) ⊆ f₂ h * List.prod (List.map f₂ tl)
Theorem: Polynomial.natDegree_add_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: cases' le_max_iff.1 (degree_add_le p q) with h h <;> simp [natDegree_le_natDegree h]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
ι : Type ?u.511565
p q : R[X]
⊢ natDegree (p + q) ≤ max (natDegree p) (natDegree q)
Theorem: CategoryTheory.Limits.InitialMonoClass.of_isInitial
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: dsimp
state_before: C : Type u₁
inst✝ : Category C
I : C
hI : IsInitial I
h : ∀ (X : C), Mono (IsInitial.to hI X)
I' X : C
hI' : IsInitial I'
⊢ Mono (IsInitial.to hI' X)

tactic: rw [hI'.hom_ext (hI'.to X) ((hI'.uniqueUpToIso hI).hom ≫ hI.to X)]
state_before: C : Type u₁
inst✝ : Category C
I : C
hI : IsInitial I
h : ∀ (X : C), Mono (IsInitial.to hI X)
I' X : C
hI' : IsInitial I'
⊢ Mono (IsInitial.to hI' X)

tactic: apply mono_comp
state_before: C : Type u₁
inst✝ : Category C
I : C
hI : IsInitial I
h : ∀ (X : C), Mono (IsInitial.to hI X)
I' X : C
hI' : IsInitial I'
⊢ Mono ((IsInitial.uniqueUpToIso hI' hI).hom ≫ IsInitial.to hI X)
Theorem: differentiableAt_sub_const_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: simp only [sub_eq_add_neg, differentiableAt_add_const_iff]
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.503551
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.503646
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
c : F
⊢ DifferentiableAt 𝕜 (fun y => f y - c) x ↔ DifferentiableAt 𝕜 f x
Theorem: Valuation.self_le_supp_comap
File: Mathlib/RingTheory/Valuation/Quotient.lean

tactic: rw [comap_supp, ← Ideal.map_le_iff_le_comap]
state_before: R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v✝ : Valuation R Γ₀
J : Ideal R
v : Valuation (R ⧸ J) Γ₀
⊢ J ≤ supp (comap (Ideal.Quotient.mk J) v)

tactic: simp
state_before: R : Type u_1
Γ₀ : Type u_2
inst✝¹ : CommRing R
inst✝ : LinearOrderedCommMonoidWithZero Γ₀
v✝ : Valuation R Γ₀
J : Ideal R
v : Valuation (R ⧸ J) Γ₀
⊢ Ideal.map (Ideal.Quotient.mk J) J ≤ supp v
Theorem: Stream'.Seq.cons_injective2
File: Mathlib/Data/Seq/Seq.lean

tactic: rw [← Option.some_inj, ← get?_cons_zero, h, get?_cons_zero]
state_before: α : Type u
β : Type v
γ : Type w
x y : α
s t : Seq α
h : cons x s = cons y t
⊢ x = y

tactic: simp_rw [← get?_cons_succ x s n, h, get?_cons_succ]
state_before: α : Type u
β : Type v
γ : Type w
x y : α
s t : Seq α
h : cons x s = cons y t
n : ℕ
⊢ get? s n = get? t n
Theorem: Nat.sInf_eq_zero
File: Mathlib/Data/Nat/Lattice.lean

tactic: cases eq_empty_or_nonempty s with
| inl h => subst h
           simp only [or_true_iff, eq_self_iff_true, iff_true_iff, iInf, InfSet.sInf,
                      mem_empty_iff_false, exists_false, dif_neg, not_false_iff]
| inr h => simp only [h.ne_empty, or_false_iff, Nat.sInf_def, h, Nat.find_eq_zero]
state_before: s : Set ℕ
⊢ sInf s = 0 ↔ 0 ∈ s ∨ s = ∅

tactic: subst h
state_before: case inl
s : Set ℕ
h : s = ∅
⊢ sInf s = 0 ↔ 0 ∈ s ∨ s = ∅

tactic: simp only [or_true_iff, eq_self_iff_true, iff_true_iff, iInf, InfSet.sInf,
           mem_empty_iff_false, exists_false, dif_neg, not_false_iff]
state_before: case inl

⊢ sInf ∅ = 0 ↔ 0 ∈ ∅ ∨ ∅ = ∅

tactic: simp only [h.ne_empty, or_false_iff, Nat.sInf_def, h, Nat.find_eq_zero]
state_before: case inr
s : Set ℕ
h : Set.Nonempty s
⊢ sInf s = 0 ↔ 0 ∈ s ∨ s = ∅
Theorem: Finset.prod_val
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [Finset.prod, Multiset.map_id]
state_before: ι : Type ?u.439
β : Type u
α : Type v
γ : Type w
inst✝ : CommMonoid α
s : Finset α
⊢ Multiset.prod s.val = Finset.prod s id
Theorem: Fin.partialProd_zero
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: simp [partialProd]
state_before: α : Type u_1
β : Type ?u.86974
inst✝ : Monoid α
n : ℕ
f : Fin n → α
⊢ partialProd f 0 = 1
Theorem: MeasureTheory.lintegral_eq_iSup_eapprox_lintegral
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: congr
state_before: α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (∫⁻ (a : α), f a ∂μ) = ∫⁻ (a : α), ⨆ (n : ℕ), ↑(eapprox f n) a ∂μ

tactic: ext a
state_before: case e_f
α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (fun a => f a) = fun a => ⨆ (n : ℕ), ↑(eapprox f n) a

tactic: rw [iSup_eapprox_apply f hf]
state_before: case e_f.h
α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
a : α
⊢ f a = ⨆ (n : ℕ), ↑(eapprox f n) a

tactic: rw [lintegral_iSup]
state_before: α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (∫⁻ (a : α), ⨆ (n : ℕ), ↑(eapprox f n) a ∂μ) = ⨆ (n : ℕ), ∫⁻ (a : α), ↑(eapprox f n) a ∂μ

tactic: measurability
state_before: case hf
α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ ∀ (n : ℕ), Measurable fun a => ↑(eapprox f n) a

tactic: intro i j h
state_before: case h_mono
α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ Monotone fun n a => ↑(eapprox f n) a

tactic: exact monotone_eapprox f h
state_before: case h_mono
α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
i j : ℕ
h : i ≤ j
⊢ (fun n a => ↑(eapprox f n) a) i ≤ (fun n a => ↑(eapprox f n) a) j

tactic: congr
state_before: α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (⨆ (n : ℕ), ∫⁻ (a : α), ↑(eapprox f n) a ∂μ) = ⨆ (n : ℕ), SimpleFunc.lintegral (eapprox f n) μ

tactic: ext n
state_before: case e_s
α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
⊢ (fun n => ∫⁻ (a : α), ↑(eapprox f n) a ∂μ) = fun n => SimpleFunc.lintegral (eapprox f n) μ

tactic: rw [(eapprox f n).lintegral_eq_lintegral]
state_before: case e_s.h
α : Type u_1
β : Type ?u.485014
γ : Type ?u.485017
δ : Type ?u.485020
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : Measurable f
n : ℕ
⊢ (∫⁻ (a : α), ↑(eapprox f n) a ∂μ) = SimpleFunc.lintegral (eapprox f n) μ