tasksource/leandojo huggingface dataset:
Theorem: dualTensorHomEquivOfBasis_symm_cancel_right
File: Mathlib/LinearAlgebra/Contraction.lean

tactic: rw [← dualTensorHomEquivOfBasis_apply b, LinearEquiv.apply_symm_apply]
state_before: ι : Type w
R : Type u
M : Type v₁
N : Type v₂
P : Type v₃
Q : Type v₄
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : AddCommGroup P
inst✝⁶ : AddCommGroup Q
inst✝⁵ : Module R M
inst✝⁴ : Module R N
inst✝³ : Module R P
inst✝² : Module R Q
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
b : Basis ι R M
x : M →ₗ[R] N
⊢ ↑(dualTensorHom R M N) (↑(LinearEquiv.symm (dualTensorHomEquivOfBasis b)) x) = x
Theorem: Nat.Icc_factorization_eq_pow_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: n p : ℕ
pp : Prime p
⊢ Icc 1 (↑(factorization n) p) = Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n)

tactic: ext x
state_before: case inr
n p : ℕ
pp : Prime p
hn : n ≠ 0
⊢ Icc 1 (↑(factorization n) p) = Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n)

tactic: simp only [mem_Icc, Finset.mem_filter, mem_Ico, and_assoc, and_congr_right_iff,
  pp.pow_dvd_iff_le_factorization hn, iff_and_self]
state_before: case inr.a
n p : ℕ
pp : Prime p
hn : n ≠ 0
x : (fun x => ℕ) p
⊢ x ∈ Icc 1 (↑(factorization n) p) ↔ x ∈ Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n)

tactic: exact fun _ H => lt_of_le_of_lt H (factorization_lt p hn)
state_before: case inr.a
n p : ℕ
pp : Prime p
hn : n ≠ 0
x : (fun x => ℕ) p
⊢ 1 ≤ x → x ≤ ↑(factorization n) p → x < n

tactic: simp
state_before: case inl
p : ℕ
pp : Prime p
⊢ Icc 1 (↑(factorization 0) p) = Finset.filter (fun i => p ^ i ∣ 0) (Ico 1 0)
Theorem: normalizeScaleRoots_monic
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: delta Monic leadingCoeff
state_before: R : Type u_1
A : Type ?u.937581
B : Type ?u.937584
S : Type ?u.937587
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
h : p ≠ 0
⊢ Monic (normalizeScaleRoots p)

tactic: rw [natDegree_eq_of_degree_eq (normalizeScaleRoots_degree p)]
state_before: R : Type u_1
A : Type ?u.937581
B : Type ?u.937584
S : Type ?u.937587
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
h : p ≠ 0
⊢ coeff (normalizeScaleRoots p) (natDegree (normalizeScaleRoots p)) = 1

tactic: suffices p = 0 → (0 : R) = 1 by simpa [normalizeScaleRoots, coeff_monomial]
state_before: R : Type u_1
A : Type ?u.937581
B : Type ?u.937584
S : Type ?u.937587
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
h : p ≠ 0
⊢ coeff (normalizeScaleRoots p) (natDegree p) = 1

tactic: exact fun h' => (h h').elim
state_before: R : Type u_1
A : Type ?u.937581
B : Type ?u.937584
S : Type ?u.937587
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
h : p ≠ 0
⊢ p = 0 → 0 = 1

tactic: simpa [normalizeScaleRoots, coeff_monomial]
state_before: R : Type u_1
A : Type ?u.937581
B : Type ?u.937584
S : Type ?u.937587
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : R →+* S
p : R[X]
x : S
h : p ≠ 0
this : p = 0 → 0 = 1
⊢ coeff (normalizeScaleRoots p) (natDegree p) = 1
Theorem: Fin.tail_cons
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [tail, cons]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α (succ i)
i : Fin n
y : α (succ i)
z : α 0
⊢ tail (cons x p) = p
Theorem: isPiSystem_iUnion_of_directed_le
File: Mathlib/MeasureTheory/PiSystem.lean

tactic: intro t1 ht1 t2 ht2 h
state_before: α : Type u_1
ι : Sort u_2
p : ι → Set (Set α)
hp_pi : ∀ (n : ι), IsPiSystem (p n)
hp_directed : Directed (fun x x_1 => x ≤ x_1) p
⊢ IsPiSystem (⋃ (n : ι), p n)

tactic: rw [Set.mem_iUnion] at ht1 ht2⊢
state_before: α : Type u_1
ι : Sort u_2
p : ι → Set (Set α)
hp_pi : ∀ (n : ι), IsPiSystem (p n)
hp_directed : Directed (fun x x_1 => x ≤ x_1) p
t1 : Set α
ht1 : t1 ∈ ⋃ (n : ι), p n
t2 : Set α
ht2 : t2 ∈ ⋃ (n : ι), p n
h : Set.Nonempty (t1 ∩ t2)
⊢ t1 ∩ t2 ∈ ⋃ (n : ι), p n

tactic: cases' ht1 with n ht1
state_before: α : Type u_1
ι : Sort u_2
p : ι → Set (Set α)
hp_pi : ∀ (n : ι), IsPiSystem (p n)
hp_directed : Directed (fun x x_1 => x ≤ x_1) p
t1 : Set α
ht1 : ∃ i, t1 ∈ p i
t2 : Set α
ht2 : ∃ i, t2 ∈ p i
h : Set.Nonempty (t1 ∩ t2)
⊢ ∃ i, t1 ∩ t2 ∈ p i

tactic: cases' ht2 with m ht2
state_before: case intro
α : Type u_1
ι : Sort u_2
p : ι → Set (Set α)
hp_pi : ∀ (n : ι), IsPiSystem (p n)
hp_directed : Directed (fun x x_1 => x ≤ x_1) p
t1 t2 : Set α
ht2 : ∃ i, t2 ∈ p i
h : Set.Nonempty (t1 ∩ t2)
n : ι
ht1 : t1 ∈ p n
⊢ ∃ i, t1 ∩ t2 ∈ p i

tactic: obtain ⟨k, hpnk, hpmk⟩ : ∃ k, p n ≤ p k ∧ p m ≤ p k := hp_directed n m
state_before: case intro.intro
α : Type u_1
ι : Sort u_2
p : ι → Set (Set α)
hp_pi : ∀ (n : ι), IsPiSystem (p n)
hp_directed : Directed (fun x x_1 => x ≤ x_1) p
t1 t2 : Set α
h : Set.Nonempty (t1 ∩ t2)
n : ι
ht1 : t1 ∈ p n
m : ι
ht2 : t2 ∈ p m
⊢ ∃ i, t1 ∩ t2 ∈ p i

tactic: exact ⟨k, hp_pi k t1 (hpnk ht1) t2 (hpmk ht2) h⟩
state_before: case intro.intro.intro.intro
α : Type u_1
ι : Sort u_2
p : ι → Set (Set α)
hp_pi : ∀ (n : ι), IsPiSystem (p n)
hp_directed : Directed (fun x x_1 => x ≤ x_1) p
t1 t2 : Set α
h : Set.Nonempty (t1 ∩ t2)
n : ι
ht1 : t1 ∈ p n
m : ι
ht2 : t2 ∈ p m
k : ι
hpnk : p n ≤ p k
hpmk : p m ≤ p k
⊢ ∃ i, t1 ∩ t2 ∈ p i
Theorem: PosNum.mul_to_nat
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [mul_to_nat m p, left_distrib]
state_before: α : Type ?u.81558
m p : PosNum
⊢ ↑(m * p) + ↑(m * p) = ↑m * (↑p + ↑p)

tactic: rw [mul_to_nat m p, left_distrib]
state_before: α : Type ?u.81558
m p : PosNum
⊢ ↑(m * p) + ↑(m * p) + ↑m = ↑m * (↑p + ↑p) + ↑m
Theorem: Ordnode.all_rotateR
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← all_dual, dual_rotateR, all_rotateL]
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
⊢ All P (rotateR l x r) ↔ All P l ∧ P x ∧ All P r

tactic: simp [all_dual, and_comm, and_left_comm, and_assoc]
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
⊢ All P (dual r) ∧ P x ∧ All P (dual l) ↔ All P l ∧ P x ∧ All P r
Theorem: Real.zero_lt_one
File: Mathlib/Data/Real/Basic.lean

tactic: convert ratCast_lt.2 zero_lt_one <;> simp [← ofCauchy_ratCast, ofCauchy_one, ofCauchy_zero]
state_before: x y : ℝ
⊢ 0 < 1
Theorem: RatFunc.smul_eq_C_mul
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [Algebra.smul_def, algebraMap_eq_C]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
r : K
x : RatFunc K
⊢ r • x = ↑C r * x
Theorem: List.modifyLast_append_one
File: Mathlib/Data/List/Basic.lean

tactic: cases l with
| nil =>
  simp only [nil_append, modifyLast, modifyLast.go, Array.toListAppend_eq, Array.data_toArray]
| cons _ tl =>
  simp only [cons_append, modifyLast]
  rw [modifyLast.go]
  case x_3 => exact append_ne_nil_of_ne_nil_right tl [a] (cons_ne_nil a [])
  rw [modifyLast.go_append_one, Array.toListAppend_eq, Array.push_data, Array.data_toArray,
    nil_append, cons_append, nil_append, cons_inj]
  exact modifyLast_append_one _ _ tl
state_before: ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a : α
l : List α
⊢ modifyLast f (l ++ [a]) = l ++ [f a]

tactic: simp only [nil_append, modifyLast, modifyLast.go, Array.toListAppend_eq, Array.data_toArray]
state_before: case nil
ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a : α
⊢ modifyLast f ([] ++ [a]) = [] ++ [f a]

tactic: simp only [cons_append, modifyLast]
state_before: case cons
ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a head✝ : α
tl : List α
⊢ modifyLast f (head✝ :: tl ++ [a]) = head✝ :: tl ++ [f a]

tactic: rw [modifyLast.go]
state_before: case cons
ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a head✝ : α
tl : List α
⊢ modifyLast.go f (head✝ :: (tl ++ [a])) #[] = head✝ :: (tl ++ [f a])

tactic: case x_3 => exact append_ne_nil_of_ne_nil_right tl [a] (cons_ne_nil a [])
state_before: case cons
ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a head✝ : α
tl : List α
⊢ modifyLast.go f (tl ++ [a]) (Array.push #[] head✝) = head✝ :: (tl ++ [f a])

case cons.x_3
ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a head✝ : α
tl : List α
⊢ tl ++ [a] = [] → False

tactic: rw [modifyLast.go_append_one, Array.toListAppend_eq, Array.push_data, Array.data_toArray,
  nil_append, cons_append, nil_append, cons_inj]
state_before: case cons
ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a head✝ : α
tl : List α
⊢ modifyLast.go f (tl ++ [a]) (Array.push #[] head✝) = head✝ :: (tl ++ [f a])

tactic: exact modifyLast_append_one _ _ tl
state_before: case cons
ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a head✝ : α
tl : List α
⊢ modifyLast.go f (tl ++ [a]) #[] = tl ++ [f a]

tactic: exact append_ne_nil_of_ne_nil_right tl [a] (cons_ne_nil a [])
state_before: ι : Type ?u.319092
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
a head✝ : α
tl : List α
⊢ tl ++ [a] = [] → False
Theorem: CategoryTheory.Limits.kernelIsoOfEq_trans
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: cases w₁
state_before: C : Type u
inst✝⁵ : Category C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f g h : X ⟶ Y
inst✝² : HasKernel f
inst✝¹ : HasKernel g
inst✝ : HasKernel h
w₁ : f = g
w₂ : g = h
⊢ kernelIsoOfEq w₁ ≪≫ kernelIsoOfEq w₂ = kernelIsoOfEq (_ : f = h)

tactic: cases w₂
state_before: case refl
C : Type u
inst✝⁵ : Category C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f h : X ⟶ Y
inst✝² : HasKernel f
inst✝¹ : HasKernel h
inst✝ : HasKernel f
w₂ : f = h
⊢ kernelIsoOfEq (_ : f = f) ≪≫ kernelIsoOfEq w₂ = kernelIsoOfEq (_ : f = h)

tactic: ext
state_before: case refl.refl
C : Type u
inst✝⁵ : Category C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f : X ⟶ Y
inst✝² inst✝¹ inst✝ : HasKernel f
⊢ kernelIsoOfEq (_ : f = f) ≪≫ kernelIsoOfEq (_ : f = f) = kernelIsoOfEq (_ : f = f)

tactic: simp [kernelIsoOfEq]
state_before: case refl.refl.w.h
C : Type u
inst✝⁵ : Category C
inst✝⁴ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝³ : HasKernel f✝
f : X ⟶ Y
inst✝² inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq (_ : f = f) ≪≫ kernelIsoOfEq (_ : f = f)).hom ≫ equalizer.ι f 0 =
    (kernelIsoOfEq (_ : f = f)).hom ≫ equalizer.ι f 0
Theorem: SimplicialObject.Splitting.ι_πSummand_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean

tactic: dsimp [ιSummand, πSummand]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
h : B ≠ A
⊢ ιSummand s A ≫ πSummand s B = 0

tactic: simp only [summand, assoc, IsIso.hom_inv_id_assoc]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
h : B ≠ A
⊢ ((ιCoprod s.N A ≫ map X s.ι Δ) ≫
      inv (map X s.ι Δ) ≫
        Sigma.desc fun B_1 =>
          if h : B_1 = B then eqToHom (_ : summand s.N Δ B_1 = N s (SimplexCategory.len B.fst.unop)) else 0) =
    0

tactic: erw [colimit.ι_desc, Cofan.mk_ι_app]
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
h : B ≠ A
⊢ (ιCoprod s.N A ≫
      Sigma.desc fun B_1 =>
        if h : B_1 = B then eqToHom (_ : summand s.N Δ B_1 = N s (SimplexCategory.len B.fst.unop)) else 0) =
    0

tactic: exact dif_neg h.symm
state_before: C : Type u_2
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
X : SimplicialObject C
s : Splitting X
inst✝ : HasZeroMorphisms C
Δ : SimplexCategoryᵒᵖ
A B : IndexSet Δ
h : B ≠ A
⊢ (if h : { as := A }.as = B then eqToHom (_ : summand s.N Δ { as := A }.as = N s (SimplexCategory.len B.fst.unop))
    else 0) =
    0
Theorem: Ideal.map_prodComm_prod
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: refine' Trans.trans (ideal_prod_eq _) _
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I I' : Ideal R
J J' : Ideal S
⊢ map (↑RingEquiv.prodComm) (prod I J) = prod J I

tactic: simp [map_map]
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I I' : Ideal R
J J' : Ideal S
⊢ prod (map (RingHom.fst S R) (map (↑RingEquiv.prodComm) (prod I J)))
      (map (RingHom.snd S R) (map (↑RingEquiv.prodComm) (prod I J))) =
    prod J I
Theorem: Nat.factor_iff_mem_factorization
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp only [support_factorization, List.mem_toFinset]
state_before: n p : ℕ
⊢ p ∈ (factorization n).support ↔ p ∈ factors n
Theorem: MvPolynomial.map_injective
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: intro p q h
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
hf : Injective ↑f
⊢ Injective ↑(map f)

tactic: simp only [ext_iff, coeff_map] at h⊢
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ↑f
p q : MvPolynomial σ R
h : ↑(map f) p = ↑(map f) q
⊢ p = q

tactic: intro m
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ↑f
p q : MvPolynomial σ R
h : ∀ (m : σ →₀ ℕ), ↑f (coeff m p) = ↑f (coeff m q)
⊢ ∀ (m : σ →₀ ℕ), coeff m p = coeff m q

tactic: exact hf (h m)
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p✝ q✝ : MvPolynomial σ R
f : R →+* S₁
hf : Injective ↑f
p q : MvPolynomial σ R
h : ∀ (m : σ →₀ ℕ), ↑f (coeff m p) = ↑f (coeff m q)
m : σ →₀ ℕ
⊢ coeff m p = coeff m q
Theorem: SimplexCategory.skeletal
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: suffices Fintype.card (Fin (X.len + 1)) = Fintype.card (Fin (Y.len + 1)) by
  ext
  simpa
state_before: X Y : SimplexCategory
x✝ : IsIsomorphic X Y
I : X ≅ Y
⊢ X = Y

tactic: apply Fintype.card_congr
state_before: X Y : SimplexCategory
x✝ : IsIsomorphic X Y
I : X ≅ Y
⊢ Fintype.card (Fin (len X + 1)) = Fintype.card (Fin (len Y + 1))

tactic: exact Equiv.ulift.symm.trans
  (((skeletalFunctor.{0} ⋙ forget NonemptyFinLinOrdCat).mapIso I).toEquiv.trans Equiv.ulift)
state_before: case f
X Y : SimplexCategory
x✝ : IsIsomorphic X Y
I : X ≅ Y
⊢ Fin (len X + 1) ≃ Fin (len Y + 1)

tactic: ext
state_before: X Y : SimplexCategory
x✝ : IsIsomorphic X Y
I : X ≅ Y
this : Fintype.card (Fin (len X + 1)) = Fintype.card (Fin (len Y + 1))
⊢ X = Y

tactic: simpa
state_before: case a
X Y : SimplexCategory
x✝ : IsIsomorphic X Y
I : X ≅ Y
this : Fintype.card (Fin (len X + 1)) = Fintype.card (Fin (len Y + 1))
⊢ len X = len Y
Theorem: MeasureTheory.lintegral_withDensity_le_lintegral_mul
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← iSup_lintegral_measurable_le_eq_lintegral, ← iSup_lintegral_measurable_le_eq_lintegral]
state_before: α : Type u_1
β : Type ?u.1805192
γ : Type ?u.1805195
δ : Type ?u.1805198
m m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ (∫⁻ (a : α), g a ∂Measure.withDensity μ f) ≤ ∫⁻ (a : α), (f * g) a ∂μ

tactic: refine' iSup₂_le fun i i_meas => iSup_le fun hi => _
state_before: α : Type u_1
β : Type ?u.1805192
γ : Type ?u.1805195
δ : Type ?u.1805198
m m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g : α → ℝ≥0∞
⊢ (⨆ (g_1 : α → ℝ≥0∞) (_ : Measurable g_1) (_ : g_1 ≤ fun a => g a), ∫⁻ (a : α), g_1 a ∂Measure.withDensity μ f) ≤
    ⨆ (g_1 : α → ℝ≥0∞) (_ : Measurable g_1) (_ : g_1 ≤ fun a => (f * g) a), ∫⁻ (a : α), g_1 a ∂μ

tactic: have A : f * i ≤ f * g := fun x => mul_le_mul_left' (hi x) _
state_before: α : Type u_1
β : Type ?u.1805192
γ : Type ?u.1805195
δ : Type ?u.1805198
m m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ fun a => g a
⊢ (∫⁻ (a : α), i a ∂Measure.withDensity μ f) ≤
    ⨆ (g_1 : α → ℝ≥0∞) (_ : Measurable g_1) (_ : g_1 ≤ fun a => (f * g) a), ∫⁻ (a : α), g_1 a ∂μ

tactic: refine' le_iSup₂_of_le (f * i) (f_meas.mul i_meas) _
state_before: α : Type u_1
β : Type ?u.1805192
γ : Type ?u.1805195
δ : Type ?u.1805198
m m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ fun a => g a
A : f * i ≤ f * g
⊢ (∫⁻ (a : α), i a ∂Measure.withDensity μ f) ≤
    ⨆ (g_1 : α → ℝ≥0∞) (_ : Measurable g_1) (_ : g_1 ≤ fun a => (f * g) a), ∫⁻ (a : α), g_1 a ∂μ

tactic: exact le_iSup_of_le A (le_of_eq (lintegral_withDensity_eq_lintegral_mul _ f_meas i_meas))
state_before: α : Type u_1
β : Type ?u.1805192
γ : Type ?u.1805195
δ : Type ?u.1805198
m m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
f_meas : Measurable f
g i : α → ℝ≥0∞
i_meas : Measurable i
hi : i ≤ fun a => g a
A : f * i ≤ f * g
⊢ (∫⁻ (a : α), i a ∂Measure.withDensity μ f) ≤ ⨆ (_ : f * i ≤ fun a => (f * g) a), ∫⁻ (a : α), (f * i) a ∂μ
Theorem: abs_dvd
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: cases' abs_choice a with h h <;> simp only [h, neg_dvd]
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : LinearOrder α
a✝ b✝ a b : α
⊢ abs a ∣ b ↔ a ∣ b
Theorem: SimpleGraph.colorable_of_chromaticNumber_pos
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: obtain ⟨h, hn⟩ := Nat.nonempty_of_pos_sInf h
state_before: V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
h : 0 < chromaticNumber G
⊢ Colorable G (chromaticNumber G)

tactic: exact colorable_chromaticNumber hn
state_before: case intro
V : Type u
G : SimpleGraph V
α : Type v
C : Coloring G α
h✝ : 0 < chromaticNumber G
h : ℕ
hn : h ∈ {n | Colorable G n}
⊢ Colorable G (chromaticNumber G)
Theorem: List.get_cons_length
File: Std/Data/List/Lemmas.lean

tactic: simp [h]
state_before: α : Type ?u.87760
x : α
xs : List α
n : Nat
h : n = length xs
⊢ n < length (x :: xs)

tactic: rw [getLast_eq_get]
state_before: α : Type u_1
x : α
xs : List α
n : Nat
h : n = length xs
⊢ get (x :: xs) { val := n, isLt := (_ : n < succ (length xs)) } = getLast (x :: xs) (_ : x :: xs ≠ [])

tactic: cases h
state_before: α : Type u_1
x : α
xs : List α
n : Nat
h : n = length xs
⊢ get (x :: xs) { val := n, isLt := (_ : n < succ (length xs)) } =
    get (x :: xs) { val := length (x :: xs) - 1, isLt := (_ : length (x :: xs) - 1 < length (x :: xs)) }

tactic: rfl
state_before: case refl
α : Type u_1
x : α
xs : List α
⊢ get (x :: xs) { val := length xs, isLt := (_ : length xs < succ (length xs)) } =
    get (x :: xs) { val := length (x :: xs) - 1, isLt := (_ : length (x :: xs) - 1 < length (x :: xs)) }
Theorem: PosNum.cmp_to_nat_lemma
File: Mathlib/Data/Num/Lemmas.lean

tactic: intro h
state_before: α : Type ?u.105479
m n : PosNum
⊢ ↑m < ↑n → ↑m + ↑m + 1 + 1 ≤ ↑n + ↑n

tactic: rw [Nat.add_right_comm m m 1, add_assoc]
state_before: α : Type ?u.105479
m n : PosNum
h : ↑m < ↑n
⊢ ↑m + ↑m + 1 + 1 ≤ ↑n + ↑n

tactic: exact add_le_add h h
state_before: α : Type ?u.105479
m n : PosNum
h : ↑m < ↑n
⊢ ↑m + 1 + (↑m + 1) ≤ ↑n + ↑n
Theorem: tendstoUniformlyOn_empty
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
u : Set (β × β)
x✝ : u ∈ 𝓤 β
⊢ ∀ᶠ (n : ι) in p, ∀ (x : α), x ∈ ∅ → (f x, F n x) ∈ u
Theorem: MeasureTheory.Lp.dist_def
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: simp_rw [dist, norm_def]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.386814
G : Type ?u.386817
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : { x // x ∈ Lp E p }
⊢ dist f g = ENNReal.toReal (snorm (↑↑f - ↑↑g) p μ)

tactic: refine congr_arg _ ?_
state_before: α : Type u_1
E : Type u_2
F : Type ?u.386814
G : Type ?u.386817
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : { x // x ∈ Lp E p }
⊢ ENNReal.toReal (snorm (↑↑(f - g)) p μ) = ENNReal.toReal (snorm (↑↑f - ↑↑g) p μ)

tactic: apply snorm_congr_ae (coeFn_sub _ _)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.386814
G : Type ?u.386817
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f g : { x // x ∈ Lp E p }
⊢ snorm (↑↑(f - g)) p μ = snorm (↑↑f - ↑↑g) p μ
Theorem: BoxIntegral.Prepartition.isPartition_iff_iUnion_eq
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: simp_rw [IsPartition, Set.Subset.antisymm_iff, π.iUnion_subset, true_and_iff, Set.subset_def,
  mem_iUnion, Box.mem_coe]
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π✝ π₁ π₂ : Prepartition I
x : ι → ℝ
πi πi₁ πi₂ : (J : Box ι) → Prepartition J
π : Prepartition I
⊢ IsPartition π ↔ Prepartition.iUnion π = ↑I
Theorem: Finset.centerMass_subset
File: Mathlib/Analysis/Convex/Combination.lean

tactic: rw [centerMass, sum_subset ht h, smul_sum, centerMass, smul_sum]
state_before: R : Type u_2
E : Type u_3
F : Type ?u.65551
ι : Type u_1
ι' : Type ?u.65557
α : Type ?u.65560
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
t' : Finset ι
ht : t ⊆ t'
h : ∀ (i : ι), i ∈ t' → ¬i ∈ t → w i = 0
⊢ centerMass t w z = centerMass t' w z

tactic: apply sum_subset ht
state_before: R : Type u_2
E : Type u_3
F : Type ?u.65551
ι : Type u_1
ι' : Type ?u.65557
α : Type ?u.65560
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
t' : Finset ι
ht : t ⊆ t'
h : ∀ (i : ι), i ∈ t' → ¬i ∈ t → w i = 0
⊢ ∑ x in t, (∑ x in t', w x)⁻¹ • w x • z x = ∑ x in t', (∑ i in t', w i)⁻¹ • w x • z x

tactic: intro i hit' hit
state_before: R : Type u_2
E : Type u_3
F : Type ?u.65551
ι : Type u_1
ι' : Type ?u.65557
α : Type ?u.65560
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
t' : Finset ι
ht : t ⊆ t'
h : ∀ (i : ι), i ∈ t' → ¬i ∈ t → w i = 0
⊢ ∀ (x : ι), x ∈ t' → ¬x ∈ t → (∑ x in t', w x)⁻¹ • w x • z x = 0

tactic: rw [h i hit' hit, zero_smul, smul_zero]
state_before: R : Type u_2
E : Type u_3
F : Type ?u.65551
ι : Type u_1
ι' : Type ?u.65557
α : Type ?u.65560
inst✝⁷ : LinearOrderedField R
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i✝ j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
t' : Finset ι
ht : t ⊆ t'
h : ∀ (i : ι), i ∈ t' → ¬i ∈ t → w i = 0
i : ι
hit' : i ∈ t'
hit : ¬i ∈ t
⊢ (∑ x in t', w x)⁻¹ • w i • z i = 0