tasksource/leandojo huggingface dataset:
Theorem: integral_sin_pow_succ_le
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: let H x h := pow_le_pow_of_le_one (sin_nonneg_of_mem_Icc h) (sin_le_one x) (n.le_add_right 1)
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in 0 ..π, sin x ^ (n + 1)) ≤ ∫ (x : ℝ) in 0 ..π, sin x ^ n

tactic: refine' integral_mono_on pi_pos.le _ _ H <;> exact (continuous_sin.pow _).intervalIntegrable 0 π
state_before: a b : ℝ
n : ℕ
H : ∀ (x : ℝ), x ∈ Set.Icc 0 π → sin x ^ (n + 1) ≤ sin x ^ n :=
  fun x h => pow_le_pow_of_le_one (sin_nonneg_of_mem_Icc h) (sin_le_one x) (Nat.le_add_right n 1)
⊢ (∫ (x : ℝ) in 0 ..π, sin x ^ (n + 1)) ≤ ∫ (x : ℝ) in 0 ..π, sin x ^ n
Theorem: CategoryTheory.inv_eqToHom
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X Y : C
h : X = Y
⊢ inv (eqToHom h) = eqToHom (_ : Y = X)
Theorem: Order.succ_lt_succ_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: simp
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : SuccOrder α
a b : α
inst✝ : NoMaxOrder α
⊢ succ a < succ b ↔ a < b
Theorem: Nat.pow_succ_factorization_not_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: intro h
state_before: n p : ℕ
hn : n ≠ 0
hp : Prime p
⊢ ¬p ^ (↑(factorization n) p + 1) ∣ n

tactic: rw [← factorization_le_iff_dvd (pow_pos hp.pos _).ne' hn] at h
state_before: n p : ℕ
hn : n ≠ 0
hp : Prime p
h : p ^ (↑(factorization n) p + 1) ∣ n
⊢ False

tactic: simpa [hp.factorization] using h p
state_before: n p : ℕ
hn : n ≠ 0
hp : Prime p
h : factorization (p ^ (↑(factorization n) p + 1)) ≤ factorization n
⊢ False
Theorem: Array.foldl_data_eq_map
File: Std/Data/Array/Init/Lemmas.lean

tactic: induction l generalizing acc <;> simp [*]
state_before: α : Type u_1
β : Type u_2
l : List α
acc : Array β
G : α → β
⊢ (List.foldl (fun acc a => push acc (G a)) acc l).data = acc.data ++ List.map G l
Theorem: Complex.arg_eq_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: by_cases h₀ : z = 0
state_before: z : ℂ
⊢ arg z = π ↔ z.re < 0 ∧ z.im = 0

tactic: simp [h₀, lt_irrefl, Real.pi_ne_zero.symm]
state_before: case pos
z : ℂ
h₀ : z = 0
⊢ arg z = π ↔ z.re < 0 ∧ z.im = 0

case neg
z : ℂ
h₀ : ¬z = 0
⊢ arg z = π ↔ z.re < 0 ∧ z.im = 0

tactic: constructor
state_before: case neg
z : ℂ
h₀ : ¬z = 0
⊢ arg z = π ↔ z.re < 0 ∧ z.im = 0

tactic: intro h
state_before: case neg.mp
z : ℂ
h₀ : ¬z = 0
⊢ arg z = π → z.re < 0 ∧ z.im = 0

tactic: rw [← abs_mul_cos_add_sin_mul_I z, h]
state_before: case neg.mp
z : ℂ
h₀ : ¬z = 0
h : arg z = π
⊢ z.re < 0 ∧ z.im = 0

tactic: simp [h₀]
state_before: case neg.mp
z : ℂ
h₀ : ¬z = 0
h : arg z = π
⊢ (↑(↑abs z) * (cos ↑π + sin ↑π * I)).re < 0 ∧ (↑(↑abs z) * (cos ↑π + sin ↑π * I)).im = 0

tactic: cases' z with x y
state_before: case neg.mpr
z : ℂ
h₀ : ¬z = 0
⊢ z.re < 0 ∧ z.im = 0 → arg z = π

tactic: rintro ⟨h : x < 0, rfl : y = 0⟩
state_before: case neg.mpr.mk
x y : ℝ
h₀ : ¬{ re := x, im := y } = 0
⊢ { re := x, im := y }.re < 0 ∧ { re := x, im := y }.im = 0 → arg { re := x, im := y } = π

tactic: rw [← arg_neg_one, ← arg_real_mul (-1) (neg_pos.2 h)]
state_before: case neg.mpr.mk.intro
x : ℝ
h : x < 0
h₀ : ¬{ re := x, im := 0 } = 0
⊢ arg { re := x, im := 0 } = π

tactic: simp [← ofReal_def]
state_before: case neg.mpr.mk.intro
x : ℝ
h : x < 0
h₀ : ¬{ re := x, im := 0 } = 0
⊢ arg { re := x, im := 0 } = arg (↑(-x) * -1)
Theorem: BoxIntegral.Prepartition.biUnion_le_iff
File: Mathlib/Analysis/BoxIntegral/Partition/Basic.lean

tactic: constructor <;> intro H J hJ
state_before: ι : Type u_1
I J J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
⊢ biUnion π πi ≤ π' ↔ ∀ (J : Box ι), J ∈ π → πi J ≤ restrict π' J

tactic: rw [← π.restrict_biUnion πi hJ]
state_before: case mp
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : biUnion π πi ≤ π'
J : Box ι
hJ : J ∈ π
⊢ πi J ≤ restrict π' J

tactic: exact restrict_mono H
state_before: case mp
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : biUnion π πi ≤ π'
J : Box ι
hJ : J ∈ π
⊢ restrict (biUnion π πi) J ≤ restrict π' J

tactic: rw [mem_biUnion] at hJ
state_before: case mpr
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : ∀ (J : Box ι), J ∈ π → πi J ≤ restrict π' J
J : Box ι
hJ : J ∈ biUnion π πi
⊢ ∃ I', I' ∈ π' ∧ J ≤ I'

tactic: rcases hJ with ⟨J₁, h₁, hJ⟩
state_before: case mpr
ι : Type u_1
I J✝ J₁ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : ∀ (J : Box ι), J ∈ π → πi J ≤ restrict π' J
J : Box ι
hJ : ∃ J', J' ∈ π ∧ J ∈ πi J'
⊢ ∃ I', I' ∈ π' ∧ J ≤ I'

tactic: rcases H J₁ h₁ hJ with ⟨J₂, h₂, Hle⟩
state_before: case mpr.intro.intro
ι : Type u_1
I J✝ J₁✝ J₂ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : ∀ (J : Box ι), J ∈ π → πi J ≤ restrict π' J
J J₁ : Box ι
h₁ : J₁ ∈ π
hJ : J ∈ πi J₁
⊢ ∃ I', I' ∈ π' ∧ J ≤ I'

tactic: rcases π'.mem_restrict.mp h₂ with ⟨J₃, h₃, H⟩
state_before: case mpr.intro.intro.intro.intro
ι : Type u_1
I J✝ J₁✝ J₂✝ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H : ∀ (J : Box ι), J ∈ π → πi J ≤ restrict π' J
J J₁ : Box ι
h₁ : J₁ ∈ π
hJ : J ∈ πi J₁
J₂ : Box ι
h₂ : J₂ ∈ restrict π' J₁
Hle : J ≤ J₂
⊢ ∃ I', I' ∈ π' ∧ J ≤ I'

tactic: exact ⟨J₃, h₃, Hle.trans <| WithBot.coe_le_coe.1 <| H.trans_le inf_le_right⟩
state_before: case mpr.intro.intro.intro.intro.intro.intro
ι : Type u_1
I J✝ J₁✝ J₂✝ : Box ι
π π₁ π₂ : Prepartition I
x : ι → ℝ
πi✝ πi₁ πi₂ πi : (J : Box ι) → Prepartition J
π' : Prepartition I
H✝ : ∀ (J : Box ι), J ∈ π → πi J ≤ restrict π' J
J J₁ : Box ι
h₁ : J₁ ∈ π
hJ : J ∈ πi J₁
J₂ : Box ι
h₂ : J₂ ∈ restrict π' J₁
Hle : J ≤ J₂
J₃ : Box ι
h₃ : J₃ ∈ π'
H : ↑J₂ = ↑J₁ ⊓ ↑J₃
⊢ ∃ I', I' ∈ π' ∧ J ≤ I'
Theorem: Int.csInf_eq_least_of_bdd
File: Mathlib/Data/Int/ConditionallyCompleteOrder.lean

tactic: have : s.Nonempty ∧ BddBelow s := ⟨Hinh, b, Hb⟩
state_before: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ (z : ℤ), z ∈ s → b ≤ z
Hinh : ∃ z, z ∈ s
⊢ sInf s = ↑(leastOfBdd b Hb Hinh)

tactic: simp only [sInf, this, and_self, dite_true]
state_before: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ (z : ℤ), z ∈ s → b ≤ z
Hinh : ∃ z, z ∈ s
this : Set.Nonempty s ∧ BddBelow s
⊢ sInf s = ↑(leastOfBdd b Hb Hinh)

tactic: convert (coe_leastOfBdd_eq Hb (Classical.choose_spec (⟨b, Hb⟩ : BddBelow s)) Hinh).symm
state_before: s : Set ℤ
inst✝ : DecidablePred fun x => x ∈ s
b : ℤ
Hb : ∀ (z : ℤ), z ∈ s → b ≤ z
Hinh : ∃ z, z ∈ s
this : Set.Nonempty s ∧ BddBelow s
⊢ ↑(leastOfBdd (choose (_ : BddBelow s)) (_ : choose (_ : BddBelow s) ∈ lowerBounds s) (_ : Set.Nonempty s)) =
    ↑(leastOfBdd b Hb Hinh)
Theorem: Multiset.le_smul_dedup
File: Mathlib/Data/Multiset/Fold.lean

tactic: rw [count_nsmul]
state_before: α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
⊢ count a s ≤ count a (fold max 0 (map (fun a => count a s) s) • dedup s)

tactic: by_cases h : a ∈ s
state_before: α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
⊢ count a s ≤ fold max 0 (map (fun a => count a s) s) * count a (dedup s)

tactic: refine' le_trans _ (Nat.mul_le_mul_left _ <| count_pos.2 <| mem_dedup.2 h)
state_before: case pos
α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
h : a ∈ s
⊢ count a s ≤ fold max 0 (map (fun a => count a s) s) * count a (dedup s)

tactic: have : count a s ≤ fold max 0 (map (fun a => count a s) (a ::ₘ erase s a)) :=
  by simp [le_max_left]
state_before: case pos
α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
h : a ∈ s
⊢ count a s ≤ fold max 0 (map (fun a => count a s) s) * succ 0

tactic: rw [cons_erase h] at this
state_before: case pos
α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
h : a ∈ s
this : count a s ≤ fold max 0 (map (fun a => count a s) (a ::ₘ erase s a))
⊢ count a s ≤ fold max 0 (map (fun a => count a s) s) * succ 0

tactic: simpa [mul_succ] using this
state_before: case pos
α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
h : a ∈ s
this : count a s ≤ fold max 0 (map (fun a => count a s) s)
⊢ count a s ≤ fold max 0 (map (fun a => count a s) s) * succ 0

tactic: simp [le_max_left]
state_before: α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
h : a ∈ s
⊢ count a s ≤ fold max 0 (map (fun a => count a s) (a ::ₘ erase s a))

tactic: simp [count_eq_zero.2 h, Nat.zero_le]
state_before: case neg
α : Type u_1
β : Type ?u.22330
inst✝ : DecidableEq α
s : Multiset α
a : α
h : ¬a ∈ s
⊢ count a s ≤ fold max 0 (map (fun a => count a s) s) * count a (dedup s)
Theorem: zpow_nonneg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [zpow_ofNat]
state_before: ι : Type ?u.12689
α : Type u_1
β : Type ?u.12695
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ ↑n

tactic: exact pow_nonneg ha _
state_before: ι : Type ?u.12689
α : Type u_1
β : Type ?u.12695
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ n

tactic: rw [zpow_neg, inv_nonneg, zpow_ofNat]
state_before: ι : Type ?u.12689
α : Type u_1
β : Type ?u.12695
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ (-↑(n + 1))

tactic: exact pow_nonneg ha _
state_before: ι : Type ?u.12689
α : Type u_1
β : Type ?u.12695
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n✝ : ℤ
ha : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ (n + 1)
Theorem: List.Func.mem_get_of_le
File: Mathlib/Data/List/Func.lean

tactic: cases h1
state_before: α : Type u
β : Type v
γ : Type w
a : α
as as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
x✝ : ℕ
h1 : x✝ < length []
⊢ get x✝ [] ∈ []

tactic: rw [mem_cons]
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a : α
as : List α
x✝ : 0 < length (a :: as)
⊢ get 0 (a :: as) ∈ a :: as

tactic: exact Or.inl rfl
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
a : α
as : List α
x✝ : 0 < length (a :: as)
⊢ get 0 (a :: as) = a ∨ get 0 (a :: as) ∈ as

tactic: rw [mem_cons]
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : n + 1 < length (a :: as)
⊢ get (n + 1) (a :: as) ∈ a :: as

tactic: apply Or.inr
state_before: α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : n + 1 < length (a :: as)
⊢ get (n + 1) (a :: as) = a ∨ get (n + 1) (a :: as) ∈ as

tactic: unfold get
state_before: case h
α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : n + 1 < length (a :: as)
⊢ get (n + 1) (a :: as) ∈ as

tactic: apply mem_get_of_le
state_before: case h
α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : n + 1 < length (a :: as)
⊢ get (Nat.add n 0) as ∈ as

tactic: apply Nat.lt_of_succ_lt_succ h1
state_before: case h.a
α : Type u
β : Type v
γ : Type w
a✝ : α
as✝ as1 as2 as3 : List α
inst✝¹ : Inhabited α
inst✝ : Inhabited β
n : ℕ
a : α
as : List α
h1 : n + 1 < length (a :: as)
⊢ Nat.add n 0 < length as
Theorem: AddLECancellable.add_tsub_tsub_cancel
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: rw [add_assoc, add_tsub_cancel_of_le h, add_comm]
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hac : AddLECancellable (a - c)
h : c ≤ a
⊢ a + b = b + c + (a - c)
Theorem: Function.Periodic.div
File: Mathlib/Algebra/Periodic.lean

tactic: simp_all
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30906
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Add α
inst✝ : Div β
hf : Periodic f c
hg : Periodic g c
⊢ Periodic (f / g) c
Theorem: Cubic.leadingCoeff_of_c_ne_zero
File: Mathlib/Algebra/CubicDiscriminant.lean

tactic: rw [of_b_eq_zero ha hb, leadingCoeff_linear hc]
state_before: R : Type u_1
S : Type ?u.556672
F : Type ?u.556675
K : Type ?u.556678
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
ha : P.a = 0
hb : P.b = 0
hc : P.c ≠ 0
⊢ leadingCoeff (toPoly P) = P.c
Theorem: MeasureTheory.AECover.iSup_lintegral_eq_of_countably_generated
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

tactic: have := hφ.lintegral_tendsto_of_countably_generated hfm
state_before: α : Type u_2
ι : Type u_1
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : Nonempty ι
inst✝¹ : NeBot l
inst✝ : IsCountablyGenerated l
φ : ι → Set α
hφ : AECover μ l φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
⊢ (⨆ (i : ι), ∫⁻ (x : α) in φ i, f x ∂μ) = ∫⁻ (x : α), f x ∂μ

tactic: refine' ciSup_eq_of_forall_le_of_forall_lt_exists_gt
  (fun i => lintegral_mono' Measure.restrict_le_self le_rfl) fun w hw => _
state_before: α : Type u_2
ι : Type u_1
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : Nonempty ι
inst✝¹ : NeBot l
inst✝ : IsCountablyGenerated l
φ : ι → Set α
hφ : AECover μ l φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
this : Tendsto (fun i => ∫⁻ (x : α) in φ i, f x ∂μ) l (𝓝 (∫⁻ (x : α), f x ∂μ))
⊢ (⨆ (i : ι), ∫⁻ (x : α) in φ i, f x ∂μ) = ∫⁻ (x : α), f x ∂μ

tactic: rcases exists_between hw with ⟨m, hm₁, hm₂⟩
state_before: α : Type u_2
ι : Type u_1
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : Nonempty ι
inst✝¹ : NeBot l
inst✝ : IsCountablyGenerated l
φ : ι → Set α
hφ : AECover μ l φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
this : Tendsto (fun i => ∫⁻ (x : α) in φ i, f x ∂μ) l (𝓝 (∫⁻ (x : α), f x ∂μ))
w : ℝ≥0∞
hw : w < ∫⁻ (x : α), f x ∂μ
⊢ ∃ i, w < ∫⁻ (x : α) in φ i, f x ∂μ

tactic: rcases(eventually_ge_of_tendsto_gt hm₂ this).exists with ⟨i, hi⟩
state_before: case intro.intro
α : Type u_2
ι : Type u_1
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : Nonempty ι
inst✝¹ : NeBot l
inst✝ : IsCountablyGenerated l
φ : ι → Set α
hφ : AECover μ l φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
this : Tendsto (fun i => ∫⁻ (x : α) in φ i, f x ∂μ) l (𝓝 (∫⁻ (x : α), f x ∂μ))
w : ℝ≥0∞
hw : w < ∫⁻ (x : α), f x ∂μ
m : ℝ≥0∞
hm₁ : w < m
hm₂ : m < ∫⁻ (x : α), f x ∂μ
⊢ ∃ i, w < ∫⁻ (x : α) in φ i, f x ∂μ

tactic: exact ⟨i, lt_of_lt_of_le hm₁ hi⟩
state_before: case intro.intro.intro
α : Type u_2
ι : Type u_1
inst✝³ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝² : Nonempty ι
inst✝¹ : NeBot l
inst✝ : IsCountablyGenerated l
φ : ι → Set α
hφ : AECover μ l φ
f : α → ℝ≥0∞
hfm : AEMeasurable f
this : Tendsto (fun i => ∫⁻ (x : α) in φ i, f x ∂μ) l (𝓝 (∫⁻ (x : α), f x ∂μ))
w : ℝ≥0∞
hw : w < ∫⁻ (x : α), f x ∂μ
m : ℝ≥0∞
hm₁ : w < m
hm₂ : m < ∫⁻ (x : α), f x ∂μ
i : ι
hi : m ≤ ∫⁻ (x : α) in φ i, f x ∂μ
⊢ ∃ i, w < ∫⁻ (x : α) in φ i, f x ∂μ
Theorem: MvPolynomial.coeff_zero_X
File: Mathlib/Data/MvPolynomial/Basic.lean

tactic: cases Finsupp.single_eq_zero.1 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
i : σ
h : Finsupp.single i 1 = 0
⊢ False
Theorem: CauSeq.pow_equiv_pow
File: Mathlib/Data/Real/CauSeq.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
n : ℕ
⊢ f1 ^ n ≈ f2 ^ n

tactic: simp only [Nat.zero_eq, pow_zero, Setoid.refl]
state_before: case zero
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
⊢ f1 ^ Nat.zero ≈ f2 ^ Nat.zero

tactic: simpa only [pow_succ] using mul_equiv_mul hf ih
state_before: case succ
α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f1 f2 : CauSeq β abv
hf : f1 ≈ f2
n : ℕ
ih : f1 ^ n ≈ f2 ^ n
⊢ f1 ^ Nat.succ n ≈ f2 ^ Nat.succ n
Theorem: measurable_biSup
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: haveI : Encodable s := hs.toEncodable
state_before: α : Type u_3
β : Type ?u.1524783
γ : Type ?u.1524786
γ₂ : Type ?u.1524789
δ : Type u_2
ι✝ : Sort y
s✝ t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
s : Set ι
f : ι → δ → α
hs : Set.Countable s
hf : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun b => ⨆ (i : ι) (_ : i ∈ s), f i b

tactic: simp only [iSup_subtype']
state_before: α : Type u_3
β : Type ?u.1524783
γ : Type ?u.1524786
γ₂ : Type ?u.1524789
δ : Type u_2
ι✝ : Sort y
s✝ t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
s : Set ι
f : ι → δ → α
hs : Set.Countable s
hf : ∀ (i : ι), Measurable (f i)
this : Encodable ↑s
⊢ Measurable fun b => ⨆ (i : ι) (_ : i ∈ s), f i b

tactic: exact measurable_iSup fun i => hf i
state_before: α : Type u_3
β : Type ?u.1524783
γ : Type ?u.1524786
γ₂ : Type ?u.1524789
δ : Type u_2
ι✝ : Sort y
s✝ t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
inst✝² : CompleteLinearOrder α
inst✝¹ : OrderTopology α
inst✝ : SecondCountableTopology α
ι : Type u_1
s : Set ι
f : ι → δ → α
hs : Set.Countable s
hf : ∀ (i : ι), Measurable (f i)
this : Encodable ↑s
⊢ Measurable fun b => ⨆ (x : { i // i ∈ s }), f (↑x) b
Theorem: Polynomial.map_cyclotomic_int
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: by_cases hzero : n = 0
state_before: n : ℕ
R : Type u_1
inst✝ : Ring R
⊢ map (Int.castRingHom R) (cyclotomic n ℤ) = cyclotomic n R

tactic: simp [cyclotomic, hzero]
state_before: case neg
n : ℕ
R : Type u_1
inst✝ : Ring R
hzero : ¬n = 0
⊢ map (Int.castRingHom R) (cyclotomic n ℤ) = cyclotomic n R

tactic: simp only [hzero, cyclotomic, dif_pos, Polynomial.map_one]
state_before: case pos
n : ℕ
R : Type u_1
inst✝ : Ring R
hzero : n = 0
⊢ map (Int.castRingHom R) (cyclotomic n ℤ) = cyclotomic n R
Theorem: TsirelsonInequality.sqrt_two_inv_mul_self
File: Mathlib/Algebra/Star/CHSH.lean

tactic: rw [← mul_inv]
state_before: R : Type u
⊢ (Real.sqrt 2)⁻¹ * (Real.sqrt 2)⁻¹ = 2⁻¹

tactic: norm_num
state_before: R : Type u
⊢ (Real.sqrt 2 * Real.sqrt 2)⁻¹ = 2⁻¹
Theorem: Prod.mk_one_mul_mk_one
File: Mathlib/Algebra/Group/Prod.lean

tactic: rw [mk_mul_mk, mul_one]
state_before: A : Type ?u.2634
B : Type ?u.2637
G : Type ?u.2640
H : Type ?u.2643
M : Type u_1
N : Type u_2
P : Type ?u.2652
inst✝¹ : Mul M
inst✝ : Monoid N
a₁ a₂ : M
⊢ (a₁, 1) * (a₂, 1) = (a₁ * a₂, 1)
Theorem: Set.insert_pi
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.128441
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i✝ i : ι
s : Set ι
t : (i : ι) → Set (α i)
⊢ pi (insert i s) t = eval i ⁻¹' t i ∩ pi s t

tactic: simp [pi, or_imp, forall_and]
state_before: case h
ι : Type u_1
α : ι → Type u_2
β : ι → Type ?u.128441
s✝ s₁ s₂ : Set ι
t✝ t₁ t₂ : (i : ι) → Set (α i)
i✝ i : ι
s : Set ι
t : (i : ι) → Set (α i)
x✝ : (i : ι) → α i
⊢ x✝ ∈ pi (insert i s) t ↔ x✝ ∈ eval i ⁻¹' t i ∩ pi s t
Theorem: tsub_min
File: Mathlib/Algebra/Order/Sub/Canonical.lean

tactic: cases' le_total a b with h h
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - min a b = a - b

tactic: rw [min_eq_left h, tsub_self, tsub_eq_zero_of_le h]
state_before: case inl
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : a ≤ b
⊢ a - min a b = a - b

tactic: rw [min_eq_right h]
state_before: case inr
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
h : b ≤ a
⊢ a - min a b = a - b
Theorem: MvPolynomial.totalDegree_add
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: have := Finsupp.support_add hn
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.397208
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a b : MvPolynomial σ R
n : σ →₀ ℕ
hn : n ∈ support (a + b)
⊢ (sum n fun x e => e) ≤ max (totalDegree a) (totalDegree b)

tactic: rw [Finset.mem_union] at this
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.397208
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a b : MvPolynomial σ R
n : σ →₀ ℕ
hn : n ∈ support (a + b)
this : n ∈ a.support ∪ b.support
⊢ (sum n fun x e => e) ≤ max (totalDegree a) (totalDegree b)

tactic: cases' this with h h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.397208
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a b : MvPolynomial σ R
n : σ →₀ ℕ
hn : n ∈ support (a + b)
this : n ∈ a.support ∨ n ∈ b.support
⊢ (sum n fun x e => e) ≤ max (totalDegree a) (totalDegree b)

tactic: exact le_max_of_le_left (le_totalDegree h)
state_before: case inl
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.397208
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a b : MvPolynomial σ R
n : σ →₀ ℕ
hn : n ∈ support (a + b)
h : n ∈ a.support
⊢ (sum n fun x e => e) ≤ max (totalDegree a) (totalDegree b)

tactic: exact le_max_of_le_right (le_totalDegree h)
state_before: case inr
R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.397208
r : R
e : ℕ
n✝ m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q a b : MvPolynomial σ R
n : σ →₀ ℕ
hn : n ∈ support (a + b)
h : n ∈ b.support
⊢ (sum n fun x e => e) ≤ max (totalDegree a) (totalDegree b)