tasksource/leandojo huggingface dataset:
Theorem: intervalIntegrable_sub_inv_iff
File: Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean

tactic: constructor
state_before: E : Type ?u.34598
F : Type ?u.34601
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a b c : ℝ
⊢ IntervalIntegrable (fun x => (x - c)⁻¹) volume a b ↔ a = b ∨ ¬c ∈ [[a, b]]

tactic: refine' fun h => or_iff_not_imp_left.2 fun hne hc => _
state_before: case mp
E : Type ?u.34598
F : Type ?u.34601
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a b c : ℝ
⊢ IntervalIntegrable (fun x => (x - c)⁻¹) volume a b → a = b ∨ ¬c ∈ [[a, b]]

tactic: exact not_intervalIntegrable_of_sub_inv_isBigO_punctured (isBigO_refl _ _) hne hc h
state_before: case mp
E : Type ?u.34598
F : Type ?u.34601
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a b c : ℝ
h : IntervalIntegrable (fun x => (x - c)⁻¹) volume a b
hne : ¬a = b
hc : c ∈ [[a, b]]
⊢ False

tactic: rintro (rfl | h₀)
state_before: case mpr
E : Type ?u.34598
F : Type ?u.34601
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a b c : ℝ
⊢ a = b ∨ ¬c ∈ [[a, b]] → IntervalIntegrable (fun x => (x - c)⁻¹) volume a b

tactic: refine' ((continuous_sub_right c).continuousOn.inv₀ _).intervalIntegrable
state_before: case mpr.inr
E : Type ?u.34598
F : Type ?u.34601
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a b c : ℝ
h₀ : ¬c ∈ [[a, b]]
⊢ IntervalIntegrable (fun x => (x - c)⁻¹) volume a b

tactic: exact fun x hx => sub_ne_zero.2 <| ne_of_mem_of_not_mem hx h₀
state_before: case mpr.inr
E : Type ?u.34598
F : Type ?u.34601
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a b c : ℝ
h₀ : ¬c ∈ [[a, b]]
⊢ ∀ (x : ℝ), x ∈ [[a, b]] → x - c ≠ 0

tactic: exact IntervalIntegrable.refl
state_before: case mpr.inl
E : Type ?u.34598
F : Type ?u.34601
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : SecondCountableTopology E
inst✝¹ : CompleteSpace E
inst✝ : NormedAddCommGroup F
a c : ℝ
⊢ IntervalIntegrable (fun x => (x - c)⁻¹) volume a a
Theorem: CategoryTheory.Limits.Cocone.w
File: Mathlib/CategoryTheory/Limits/Cones.lean

tactic: rw [c.ι.naturality f]
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c : Cocone F
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ c.ι.app j' = c.ι.app j

tactic: apply comp_id
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u₃
inst✝¹ : Category C
D : Type u₄
inst✝ : Category D
F : J ⥤ C
c : Cocone F
j j' : J
f : j ⟶ j'
⊢ c.ι.app j ≫ ((const J).obj c.pt).map f = c.ι.app j
Theorem: HasStrictDerivAt.cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: simpa using (hf.cpow hg h0).hasStrictDerivAt
state_before: f g : ℂ → ℂ
s : Set ℂ
f' g' x c : ℂ
hf : HasStrictDerivAt f f' x
hg : HasStrictDerivAt g g' x
h0 : 0 < (f x).re ∨ (f x).im ≠ 0
⊢ HasStrictDerivAt (fun x => f x ^ g x) (g x * f x ^ (g x - 1) * f' + f x ^ g x * Complex.log (f x) * g') x
Theorem: Array.of_push_eq_push
File: src/lean/Init/Data/Array/BasicAux.lean

tactic: simp [push] at h
state_before: α : Type u_1
a b : α
as bs : Array α
h : push as a = push bs b
⊢ as = bs ∧ a = b

tactic: have ⟨h₁, h₂⟩ := List.of_concat_eq_concat h
state_before: α : Type u_1
a b : α
as bs : Array α
h : List.concat as.data a = List.concat bs.data b
⊢ as = bs ∧ a = b

tactic: cases as
state_before: α : Type u_1
a b : α
as bs : Array α
h : List.concat as.data a = List.concat bs.data b
h₁ : as.data = bs.data
h₂ : a = b
⊢ as = bs ∧ a = b

tactic: cases bs
state_before: case mk
α : Type u_1
a b : α
bs : Array α
h₂ : a = b
data✝ : List α
h : List.concat { data := data✝ }.data a = List.concat bs.data b
h₁ : { data := data✝ }.data = bs.data
⊢ { data := data✝ } = bs ∧ a = b

tactic: simp_all
state_before: case mk.mk
α : Type u_1
a b : α
h₂ : a = b
data✝¹ data✝ : List α
h : List.concat { data := data✝¹ }.data a = List.concat { data := data✝ }.data b
h₁ : { data := data✝¹ }.data = { data := data✝ }.data
⊢ { data := data✝¹ } = { data := data✝ } ∧ a = b
Theorem: inf_sup_left
File: Mathlib/Order/Lattice.lean

tactic: rw [inf_sup_self]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
⊢ x ⊓ (y ⊔ z) = x ⊓ (x ⊔ z) ⊓ (y ⊔ z)

tactic: simp only [inf_assoc, sup_inf_right, eq_self_iff_true]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
⊢ x ⊓ (x ⊔ z) ⊓ (y ⊔ z) = x ⊓ (x ⊓ y ⊔ z)

tactic: rw [sup_inf_self]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
⊢ x ⊓ (x ⊓ y ⊔ z) = (x ⊔ x ⊓ y) ⊓ (x ⊓ y ⊔ z)

tactic: rw [sup_comm]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
⊢ (x ⊔ x ⊓ y) ⊓ (x ⊓ y ⊔ z) = (x ⊓ y ⊔ x) ⊓ (x ⊓ y ⊔ z)

tactic: rw [sup_inf_left]
state_before: α : Type u
β : Type v
inst✝ : DistribLattice α
x y z : α
⊢ (x ⊓ y ⊔ x) ⊓ (x ⊓ y ⊔ z) = x ⊓ y ⊔ x ⊓ z
Theorem: Polynomial.frange_one
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [frange]
state_before: R : Type u
S : Type ?u.46907
inst✝ : Semiring R
⊢ frange 1 ⊆ {1}

tactic: rw [Finset.image_subset_iff]
state_before: R : Type u
S : Type ?u.46907
inst✝ : Semiring R
⊢ image (fun n => coeff 1 n) (support 1) ⊆ {1}

tactic: simp only [mem_support_iff, ne_eq, mem_singleton, ← C_1, coeff_C]
state_before: R : Type u
S : Type ?u.46907
inst✝ : Semiring R
⊢ ∀ (x : ℕ), x ∈ support 1 → coeff 1 x ∈ {1}

tactic: intro n hn
state_before: R : Type u
S : Type ?u.46907
inst✝ : Semiring R
⊢ ∀ (x : ℕ), ¬(if x = 0 then 1 else 0) = 0 → (if x = 0 then 1 else 0) = 1

tactic: simp only [exists_prop, ite_eq_right_iff, not_forall] at hn
state_before: R : Type u
S : Type ?u.46907
inst✝ : Semiring R
n : ℕ
hn : ¬(if n = 0 then 1 else 0) = 0
⊢ (if n = 0 then 1 else 0) = 1

tactic: simp [hn]
state_before: R : Type u
S : Type ?u.46907
inst✝ : Semiring R
n : ℕ
hn : n = 0 ∧ ¬1 = 0
⊢ (if n = 0 then 1 else 0) = 1
Theorem: Nat.minFac_eq_two_iff
File: Mathlib/Data/Nat/Prime.lean

tactic: constructor
state_before: n : ℕ
⊢ minFac n = 2 ↔ 2 ∣ n

tactic: intro h
state_before: case mp
n : ℕ
⊢ minFac n = 2 → 2 ∣ n

tactic: rw [←h]
state_before: case mp
n : ℕ
h : minFac n = 2
⊢ 2 ∣ n

tactic: exact minFac_dvd n
state_before: case mp
n : ℕ
h : minFac n = 2
⊢ minFac n ∣ n

tactic: intro h
state_before: case mpr
n : ℕ
⊢ 2 ∣ n → minFac n = 2

tactic: have ub := minFac_le_of_dvd (le_refl 2) h
state_before: case mpr
n : ℕ
h : 2 ∣ n
⊢ minFac n = 2

tactic: have lb := minFac_pos n
state_before: case mpr
n : ℕ
h : 2 ∣ n
ub : minFac n ≤ 2
⊢ minFac n = 2

tactic: refine ub.eq_or_lt.resolve_right fun h' => ?_
state_before: case mpr
n : ℕ
h : 2 ∣ n
ub : minFac n ≤ 2
lb : 0 < minFac n
⊢ minFac n = 2

tactic: have := le_antisymm (Nat.succ_le_of_lt lb) (lt_succ_iff.mp h')
state_before: case mpr
n : ℕ
h : 2 ∣ n
ub : minFac n ≤ 2
lb : 0 < minFac n
h' : minFac n < 2
⊢ False

tactic: rw [eq_comm, Nat.minFac_eq_one_iff] at this
state_before: case mpr
n : ℕ
h : 2 ∣ n
ub : minFac n ≤ 2
lb : 0 < minFac n
h' : minFac n < 2
this : succ 0 = minFac n
⊢ False

tactic: subst this
state_before: case mpr
n : ℕ
h : 2 ∣ n
ub : minFac n ≤ 2
lb : 0 < minFac n
h' : minFac n < 2
this : n = 1
⊢ False

tactic: exact not_lt_of_le (le_of_dvd zero_lt_one h) one_lt_two
state_before: case mpr
h : 2 ∣ 1
ub : minFac 1 ≤ 2
lb : 0 < minFac 1
h' : minFac 1 < 2
⊢ False
Theorem: Nat.log_le_clog
File: Mathlib/Data/Nat/Log.lean

tactic: obtain hb | hb := le_or_lt b 1
state_before: b n : ℕ
⊢ log b n ≤ clog b n

tactic: cases n with
| zero =>
  rw [log_zero_right]
  exact zero_le _
| succ n =>
  exact (pow_right_strictMono hb).le_iff_le.1
    ((pow_log_le_self b n.succ_ne_zero).trans <| le_pow_clog hb _)
state_before: case inr
b n : ℕ
hb : 1 < b
⊢ log b n ≤ clog b n

tactic: rw [log_of_left_le_one hb]
state_before: case inl
b n : ℕ
hb : b ≤ 1
⊢ log b n ≤ clog b n

tactic: exact zero_le _
state_before: case inl
b n : ℕ
hb : b ≤ 1
⊢ 0 ≤ clog b n

tactic: rw [log_zero_right]
state_before: case inr.zero
b : ℕ
hb : 1 < b
⊢ log b zero ≤ clog b zero

tactic: exact zero_le _
state_before: case inr.zero
b : ℕ
hb : 1 < b
⊢ 0 ≤ clog b zero

tactic: exact (pow_right_strictMono hb).le_iff_le.1
  ((pow_log_le_self b n.succ_ne_zero).trans <| le_pow_clog hb _)
state_before: case inr.succ
b : ℕ
hb : 1 < b
n : ℕ
⊢ log b (succ n) ≤ clog b (succ n)
Theorem: Nat.ofDigits_singleton
File: Mathlib/Data/Nat/Digits.lean

tactic: simp [ofDigits]
state_before: n✝ b n : ℕ
⊢ ofDigits b [n] = n
Theorem: Computation.liftRel_map
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← bind_pure, ← bind_pure]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
R : α → β → Prop
S : γ → δ → Prop
s1 : Computation α
s2 : Computation β
f1 : α → γ
f2 : β → δ
h1 : LiftRel R s1 s2
h2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b)
⊢ LiftRel S (map f1 s1) (map f2 s2)

tactic: apply liftRel_bind _ _ h1
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
R : α → β → Prop
S : γ → δ → Prop
s1 : Computation α
s2 : Computation β
f1 : α → γ
f2 : β → δ
h1 : LiftRel R s1 s2
h2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b)
⊢ LiftRel S (bind s1 (pure ∘ f1)) (bind s2 (pure ∘ f2))

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
R : α → β → Prop
S : γ → δ → Prop
s1 : Computation α
s2 : Computation β
f1 : α → γ
f2 : β → δ
h1 : LiftRel R s1 s2
h2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b)
⊢ ∀ {a : α} {b : β}, R a b → LiftRel S ((pure ∘ f1) a) ((pure ∘ f2) b)

tactic: intros a b h
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
R : α → β → Prop
S : γ → δ → Prop
s1 : Computation α
s2 : Computation β
f1 : α → γ
f2 : β → δ
h1 : LiftRel R s1 s2
h2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b)
⊢ ∀ {a : α} {b : β}, R a b → ∃ a_2, a_2 ∈ pure (f1 a) ∧ S a_2 (f2 b)

tactic: exact ⟨f1 a, ⟨ret_mem _, @h2 a b h⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
R : α → β → Prop
S : γ → δ → Prop
s1 : Computation α
s2 : Computation β
f1 : α → γ
f2 : β → δ
h1 : LiftRel R s1 s2
h2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b)
a : α
b : β
h : R a b
⊢ ∃ a_1, a_1 ∈ pure (f1 a) ∧ S a_1 (f2 b)
Theorem: AffineIndependent.units_lineMap
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [affineIndependent_iff_linearIndependent_vsub k _ j] at hp⊢
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
hp : AffineIndependent k p
j : ι
w : ι → kˣ
⊢ AffineIndependent k fun i => ↑(AffineMap.lineMap (p j) (p i)) ↑(w i)

tactic: simp only [AffineMap.lineMap_vsub_left, AffineMap.coe_const, AffineMap.lineMap_same, const_apply]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
j : ι
hp : LinearIndependent k fun i => p ↑i -ᵥ p j
w : ι → kˣ
⊢ LinearIndependent k fun i => ↑(AffineMap.lineMap (p j) (p ↑i)) ↑(w ↑i) -ᵥ ↑(AffineMap.lineMap (p j) (p j)) ↑(w j)

tactic: exact hp.units_smul fun i => w i
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
p : ι → P
j : ι
hp : LinearIndependent k fun i => p ↑i -ᵥ p j
w : ι → kˣ
⊢ LinearIndependent k fun i => ↑(w ↑i) • (p ↑i -ᵥ p j)
Theorem: List.dlookup_kinsert
File: Mathlib/Data/List/Sigma.lean

tactic: simp only [kinsert, dlookup_cons_eq]
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
⊢ dlookup a (kinsert a b l) = some b
Theorem: csInf_div
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: rw [div_eq_mul_inv, csInf_mul hs₀ hs₁ ht₀.inv ht₁.inv, csInf_inv ht₀ ht₁, div_eq_mul_inv]
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : Set.Nonempty s
hs₁ : BddBelow s
ht₀ : Set.Nonempty t
ht₁ : BddAbove t
⊢ sInf (s / t) = sInf s / sSup t
Theorem: MultilinearMap.map_add_univ
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simpa using f.map_piecewise_add m m' Finset.univ
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹² : Semiring R
inst✝¹¹ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹⁰ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
inst✝⁷ : AddCommMonoid M'
inst✝⁶ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝⁵ : (i : ι) → Module R (M₁ i)
inst✝⁴ : Module R M₂
inst✝³ : Module R M₃
inst✝² : Module R M'
f f' : MultilinearMap R M₁ M₂
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
m m' : (i : ι) → M₁ i
⊢ ↑f (m + m') = ∑ s : Finset ι, ↑f (Finset.piecewise s m m')
Theorem: MeasureTheory.ae_nonneg_of_forall_set_integral_nonneg_of_sigmaFinite
File: Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean

tactic: apply ae_of_forall_measure_lt_top_ae_restrict
state_before: α : Type u_1
E : Type ?u.82616
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
f✝ : α → ℝ
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → IntegrableOn f s
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
⊢ 0 ≤ᵐ[μ] f

tactic: intro t t_meas t_lt_top
state_before: case h
α : Type u_1
E : Type ?u.82616
m m0 : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
f✝ : α → ℝ
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → IntegrableOn f s
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
⊢ ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → ∀ᵐ (x : α) ∂Measure.restrict μ s, OfNat.ofNat 0 x ≤ f x

tactic: apply ae_nonneg_restrict_of_forall_set_integral_nonneg_inter (hf_int_finite t t_meas t_lt_top)
state_before: case h
α : Type u_1
E : Type ?u.82616
m m0 : MeasurableSpace α
μ : Measure α
s t✝ : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
f✝ : α → ℝ
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → IntegrableOn f s
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
t : Set α
t_meas : MeasurableSet t
t_lt_top : ↑↑μ t < ⊤
⊢ ∀ᵐ (x : α) ∂Measure.restrict μ t, OfNat.ofNat 0 x ≤ f x

tactic: intro s s_meas _
state_before: case h
α : Type u_1
E : Type ?u.82616
m m0 : MeasurableSpace α
μ : Measure α
s t✝ : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
f✝ : α → ℝ
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → IntegrableOn f s
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
t : Set α
t_meas : MeasurableSet t
t_lt_top : ↑↑μ t < ⊤
⊢ ∀ (s : Set α), MeasurableSet s → ↑↑μ (s ∩ t) < ⊤ → 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ

tactic: exact
  hf_zero _ (s_meas.inter t_meas)
    (lt_of_le_of_lt (measure_mono (Set.inter_subset_right _ _)) t_lt_top)
state_before: case h
α : Type u_1
E : Type ?u.82616
m m0 : MeasurableSpace α
μ : Measure α
s✝ t✝ : Set α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
p : ℝ≥0∞
f✝ : α → ℝ
inst✝ : SigmaFinite μ
f : α → ℝ
hf_int_finite : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → IntegrableOn f s
hf_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s < ⊤ → 0 ≤ ∫ (x : α) in s, f x ∂μ
t : Set α
t_meas : MeasurableSet t
t_lt_top : ↑↑μ t < ⊤
s : Set α
s_meas : MeasurableSet s
a✝ : ↑↑μ (s ∩ t) < ⊤
⊢ 0 ≤ ∫ (x : α) in s ∩ t, f x ∂μ
Theorem: List.set_eq_modifyNth
File: Std/Data/List/Lemmas.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
a : α
l : List α
⊢ set l 0 a = modifyNth (fun x => a) 0 l
Theorem: starConvex_iff_segment_subset
File: Mathlib/Analysis/Convex/Star.lean

tactic: constructor
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.2030
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
⊢ StarConvex 𝕜 x s ↔ ∀ ⦃y : E⦄, y ∈ s → [x-[𝕜]y] ⊆ s

tactic: rintro h y hy z ⟨a, b, ha, hb, hab, rfl⟩
state_before: case mp
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2030
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
⊢ StarConvex 𝕜 x s → ∀ ⦃y : E⦄, y ∈ s → [x-[𝕜]y] ⊆ s

tactic: exact h hy ha hb hab
state_before: case mp.intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2030
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
h : StarConvex 𝕜 x s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ s

tactic: rintro h y hy a b ha hb hab
state_before: case mpr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2030
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
⊢ (∀ ⦃y : E⦄, y ∈ s → [x-[𝕜]y] ⊆ s) → StarConvex 𝕜 x s

tactic: exact h hy ⟨a, b, ha, hb, hab, rfl⟩
state_before: case mpr
𝕜 : Type u_1
E : Type u_2
F : Type ?u.2030
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : SMul 𝕜 E
inst✝ : SMul 𝕜 F
x : E
s t : Set E
h : ∀ ⦃y : E⦄, y ∈ s → [x-[𝕜]y] ⊆ s
y : E
hy : y ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • x + b • y ∈ s
Theorem: Mathlib.Meta.NormNum.isRat_le_true
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: have h := Int.cast_mono (α := α) <| of_decide_eq_true h
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h : decide (Int.mul num✝¹ (Int.ofNat db) ≤ Int.mul num✝ (Int.ofNat da)) = true
⊢ ↑num✝¹ * ⅟↑da ≤ ↑num✝ * ⅟↑db

tactic: have ha : 0 ≤ ⅟(da : α) := invOf_nonneg.mpr <| Nat.cast_nonneg da
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝ : decide (Int.mul num✝¹ (Int.ofNat db) ≤ Int.mul num✝ (Int.ofNat da)) = true
h : (fun x => ↑x) (Int.mul num✝¹ (Int.ofNat db)) ≤ (fun x => ↑x) (Int.mul num✝ (Int.ofNat da))
⊢ ↑num✝¹ * ⅟↑da ≤ ↑num✝ * ⅟↑db

tactic: have hb : 0 ≤ ⅟(db : α) := invOf_nonneg.mpr <| Nat.cast_nonneg db
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝ : decide (Int.mul num✝¹ (Int.ofNat db) ≤ Int.mul num✝ (Int.ofNat da)) = true
h : (fun x => ↑x) (Int.mul num✝¹ (Int.ofNat db)) ≤ (fun x => ↑x) (Int.mul num✝ (Int.ofNat da))
ha : 0 ≤ ⅟↑da
⊢ ↑num✝¹ * ⅟↑da ≤ ↑num✝ * ⅟↑db

tactic: rw [← mul_assoc, Int.commute_cast] at h
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝¹ : decide (Int.mul num✝¹ (Int.ofNat db) ≤ Int.mul num✝ (Int.ofNat da)) = true
h✝ : (fun x => ↑x) (Int.mul num✝¹ (Int.ofNat db)) ≤ (fun x => ↑x) (Int.mul num✝ (Int.ofNat da))
ha : 0 ≤ ⅟↑da
hb : 0 ≤ ⅟↑db
h :
  ⅟↑db * ((fun x => ↑x) (Int.mul num✝¹ (Int.ofNat db)) * ⅟↑da) ≤
    ⅟↑db * ((fun x => ↑x) (Int.mul num✝ (Int.ofNat da)) * ⅟↑da)
⊢ ↑num✝¹ * ⅟↑da ≤ ↑num✝ * ⅟↑db

tactic: simp at h
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝¹ : decide (Int.mul num✝¹ (Int.ofNat db) ≤ Int.mul num✝ (Int.ofNat da)) = true
h✝ : (fun x => ↑x) (Int.mul num✝¹ (Int.ofNat db)) ≤ (fun x => ↑x) (Int.mul num✝ (Int.ofNat da))
ha : 0 ≤ ⅟↑da
hb : 0 ≤ ⅟↑db
h : ↑(Int.mul num✝¹ (Int.ofNat db)) * ⅟↑db * ⅟↑da ≤ ⅟↑db * ((fun x => ↑x) (Int.mul num✝ (Int.ofNat da)) * ⅟↑da)
⊢ ↑num✝¹ * ⅟↑da ≤ ↑num✝ * ⅟↑db

tactic: rwa [Int.commute_cast] at h
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
num✝¹ num✝ : ℤ
da db : ℕ
inv✝¹ : Invertible ↑da
inv✝ : Invertible ↑db
h✝¹ : decide (Int.mul num✝¹ (Int.ofNat db) ≤ Int.mul num✝ (Int.ofNat da)) = true
h✝ : (fun x => ↑x) (Int.mul num✝¹ (Int.ofNat db)) ≤ (fun x => ↑x) (Int.mul num✝ (Int.ofNat da))
ha : 0 ≤ ⅟↑da
hb : 0 ≤ ⅟↑db
h : ↑num✝¹ * ⅟↑da ≤ ⅟↑db * ↑num✝
⊢ ↑num✝¹ * ⅟↑da ≤ ↑num✝ * ⅟↑db
Theorem: Polynomial.trailingDegree_mul'
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: have hp : p ≠ 0 := fun hp => h (by rw [hp, trailingCoeff_zero, zero_mul])
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: have hq : q ≠ 0 := fun hq => h (by rw [hq, trailingCoeff_zero, mul_zero])
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
hp : p ≠ 0
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: refine' le_antisymm _ le_trailingDegree_mul
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ trailingDegree (p * q) = trailingDegree p + trailingDegree q

tactic: rw [trailingDegree_eq_natTrailingDegree hp, trailingDegree_eq_natTrailingDegree hq, ←
  ENat.coe_add]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ trailingDegree (p * q) ≤ trailingDegree p + trailingDegree q

tactic: apply le_trailingDegree_of_ne_zero
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ trailingDegree (p * q) ≤ ↑(natTrailingDegree p + natTrailingDegree q)

tactic: rwa [coeff_mul_natTrailingDegree_add_natTrailingDegree]
state_before: case h
R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
hp : p ≠ 0
hq : q ≠ 0
⊢ coeff (p * q) (natTrailingDegree p + natTrailingDegree q) ≠ 0

tactic: rw [hp, trailingCoeff_zero, zero_mul]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
hp : p = 0
⊢ trailingCoeff p * trailingCoeff q = 0

tactic: rw [hq, trailingCoeff_zero, mul_zero]
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : trailingCoeff p * trailingCoeff q ≠ 0
hp : p ≠ 0
hq : q = 0
⊢ trailingCoeff p * trailingCoeff q = 0