tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.Measure.add_haar_closedBall_mul
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: have : closedBall (0 : E) (r * s) = r • closedBall (0 : E) s := by
  simp [smul_closedBall r (0 : E) hs, abs_of_nonneg hr]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1994959
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
⊢ ↑↑μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * ↑↑μ (closedBall 0 s)

tactic: simp only [this, add_haar_smul, abs_of_nonneg hr, add_haar_closedBall_center, abs_pow]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1994959
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
this : closedBall 0 (r * s) = r • closedBall 0 s
⊢ ↑↑μ (closedBall x (r * s)) = ENNReal.ofReal (r ^ finrank ℝ E) * ↑↑μ (closedBall 0 s)

tactic: simp [smul_closedBall r (0 : E) hs, abs_of_nonneg hr]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1994959
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s✝ : Set E
x : E
r : ℝ
hr : 0 ≤ r
s : ℝ
hs : 0 ≤ s
⊢ closedBall 0 (r * s) = r • closedBall 0 s
Theorem: ContractingWith.edist_le_of_fixedPoint
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: simpa only [hy.eq, edist_self, add_zero] using hf.edist_inequality h
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
hy : IsFixedPt f y
⊢ edist x y ≤ edist x (f x) / (1 - ↑K)
Theorem: FirstOrder.Language.BoundedFormula.isPrenex_toPrenexImp
File: Mathlib/ModelTheory/Syntax.lean

tactic: induction' hφ with _ _ hφ _ _ _ ih1 _ _ _ ih2
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.138402
P : Type ?u.138405
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.138433
n l : ℕ
φ✝ ψ✝ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ ψ : BoundedFormula L α n
hφ : IsPrenex φ
hψ : IsPrenex ψ
⊢ IsPrenex (toPrenexImp φ ψ)

tactic: rw [hφ.toPrenexImp]
state_before: case of_isQF
L : Language
L' : Language
M : Type w
N : Type ?u.138402
P : Type ?u.138405
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.138433
n l : ℕ
φ✝¹ ψ✝¹ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ ψ✝ : BoundedFormula L α n
hψ✝ : IsPrenex ψ✝
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hφ : IsQF φ✝
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ IsPrenex (toPrenexImp φ✝ ψ)

tactic: exact isPrenex_toPrenexImpRight hφ hψ
state_before: case of_isQF
L : Language
L' : Language
M : Type w
N : Type ?u.138402
P : Type ?u.138405
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.138433
n l : ℕ
φ✝¹ ψ✝¹ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ ψ✝ : BoundedFormula L α n
hψ✝ : IsPrenex ψ✝
n✝ : ℕ
φ✝ : BoundedFormula L α n✝
hφ : IsQF φ✝
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ IsPrenex (toPrenexImpRight φ✝ ψ)

tactic: exact (ih1 hψ.liftAt).ex
state_before: case all
L : Language
L' : Language
M : Type w
N : Type ?u.138402
P : Type ?u.138405
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.138433
n l : ℕ
φ✝¹ ψ✝¹ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ ψ✝ : BoundedFormula L α n
hψ✝ : IsPrenex ψ✝
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
h✝ : IsPrenex φ✝
ih1 : ∀ {ψ : BoundedFormula L α (n✝ + 1)}, IsPrenex ψ → IsPrenex (toPrenexImp φ✝ ψ)
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ IsPrenex (toPrenexImp (all φ✝) ψ)

tactic: exact (ih2 hψ.liftAt).all
state_before: case ex
L : Language
L' : Language
M : Type w
N : Type ?u.138402
P : Type ?u.138405
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.138433
n l : ℕ
φ✝¹ ψ✝¹ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
φ ψ✝ : BoundedFormula L α n
hψ✝ : IsPrenex ψ✝
n✝ : ℕ
φ✝ : BoundedFormula L α (n✝ + 1)
h✝ : IsPrenex φ✝
ih2 : ∀ {ψ : BoundedFormula L α (n✝ + 1)}, IsPrenex ψ → IsPrenex (toPrenexImp φ✝ ψ)
ψ : BoundedFormula L α n✝
hψ : IsPrenex ψ
⊢ IsPrenex (toPrenexImp (BoundedFormula.ex φ✝) ψ)
Theorem: MeasureTheory.SignedMeasure.someExistsOneDivLT_measurableSet
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: by_cases hi : ¬s ≤[i] 0
state_before: α : Type u_1
β : Type ?u.7479
inst✝³ : MeasurableSpace α
M : Type ?u.7485
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
⊢ MeasurableSet (MeasureTheory.SignedMeasure.someExistsOneDivLT s i)

tactic: exact
  let ⟨_, h, _⟩ := someExistsOneDivLT_spec hi
  h
state_before: case pos
α : Type u_1
β : Type ?u.7479
inst✝³ : MeasurableSpace α
M : Type ?u.7485
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬restrict s i ≤ restrict 0 i
⊢ MeasurableSet (MeasureTheory.SignedMeasure.someExistsOneDivLT s i)

tactic: rw [someExistsOneDivLT, dif_neg hi]
state_before: case neg
α : Type u_1
β : Type ?u.7479
inst✝³ : MeasurableSpace α
M : Type ?u.7485
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬¬restrict s i ≤ restrict 0 i
⊢ MeasurableSet (MeasureTheory.SignedMeasure.someExistsOneDivLT s i)

tactic: exact MeasurableSet.empty
state_before: case neg
α : Type u_1
β : Type ?u.7479
inst✝³ : MeasurableSpace α
M : Type ?u.7485
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
hi : ¬¬restrict s i ≤ restrict 0 i
⊢ MeasurableSet ∅
Theorem: CircleDeg1Lift.translationNumber_one
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp [tendsto_const_nhds]
state_before: f g : CircleDeg1Lift
⊢ Tendsto (fun n => (↑1^[n]) 0 / ↑n) atTop (𝓝 0)
Theorem: Nat.perm_factors_mul
File: Mathlib/Data/Nat/Factors.lean

tactic: refine' (factors_unique _ _).symm
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ factors (a * b) ~ factors a ++ factors b

tactic: rw [List.prod_append, prod_factors ha, prod_factors hb]
state_before: case refine'_1
a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ prod (factors a ++ factors b) = a * b

tactic: intro p hp
state_before: case refine'_2
a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
⊢ ∀ (p : ℕ), p ∈ factors a ++ factors b → Prime p

tactic: rw [List.mem_append] at hp
state_before: case refine'_2
a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
hp : p ∈ factors a ++ factors b
⊢ Prime p

tactic: cases' hp with hp' hp' <;> exact prime_of_mem_factors hp'
state_before: case refine'_2
a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
p : ℕ
hp : p ∈ factors a ∨ p ∈ factors b
⊢ Prime p
Theorem: FreeProduct.Word.prod_smul
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: induction m using FreeProduct.induction_on with
| h_one =>
  intro
  rw [one_smul, one_mul]
| h_of _ =>
  intros
  rw [of_smul_def, prod_rcons, of.map_mul, mul_assoc, ← prod_rcons, ← equivPair_symm,
    Equiv.symm_apply_apply]
| h_mul x y hx hy =>
  intro w
  rw [mul_smul, hx, hy, mul_assoc]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type ?u.466820
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
m : FreeProduct M
⊢ ∀ (w : Word M), prod (m • w) = m * prod w

tactic: intro
state_before: case h_one
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type ?u.466820
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
⊢ ∀ (w : Word M), prod (1 • w) = 1 * prod w

tactic: rw [one_smul, one_mul]
state_before: case h_one
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type ?u.466820
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
w✝ : Word M
⊢ prod (1 • w✝) = 1 * prod w✝

tactic: intros
state_before: case h_of
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type ?u.466820
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i✝ : ι
m✝ : M i✝
⊢ ∀ (w : Word M), prod (↑of m✝ • w) = ↑of m✝ * prod w

tactic: rw [of_smul_def, prod_rcons, of.map_mul, mul_assoc, ← prod_rcons, ← equivPair_symm,
  Equiv.symm_apply_apply]
state_before: case h_of
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type ?u.466820
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
i✝ : ι
m✝ : M i✝
w✝ : Word M
⊢ prod (↑of m✝ • w✝) = ↑of m✝ * prod w✝

tactic: intro w
state_before: case h_mul
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type ?u.466820
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
x y : FreeProduct M
hx : ∀ (w : Word M), prod (x • w) = x * prod w
hy : ∀ (w : Word M), prod (y • w) = y * prod w
⊢ ∀ (w : Word M), prod ((x * y) • w) = x * y * prod w

tactic: rw [mul_smul, hx, hy, mul_assoc]
state_before: case h_mul
ι : Type u_1
M : ι → Type u_2
inst✝³ : (i : ι) → Monoid (M i)
N : Type ?u.466820
inst✝² : Monoid N
inst✝¹ : (i : ι) → DecidableEq (M i)
inst✝ : DecidableEq ι
x y : FreeProduct M
hx : ∀ (w : Word M), prod (x • w) = x * prod w
hy : ∀ (w : Word M), prod (y • w) = y * prod w
w : Word M
⊢ prod ((x * y) • w) = x * y * prod w
Theorem: Function.Commute.iterate_pos_le_iff_map_le
File: Mathlib/Order/Iterate.lean

tactic: simpa only [not_lt] using not_congr (h.symm.iterate_pos_lt_iff_map_lt' hg hf hn)
state_before: α : Type u_1
inst✝ : LinearOrder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : StrictMono g
x : α
n : ℕ
hn : 0 < n
⊢ (f^[n]) x ≤ (g^[n]) x ↔ f x ≤ g x
Theorem: Real.inner_le_Lp_mul_Lq
File: Mathlib/Analysis/MeanInequalities.lean

tactic: have :=
  NNReal.coe_le_coe.2
    (NNReal.inner_le_Lp_mul_Lq s (fun i => ⟨_, abs_nonneg (f i)⟩) (fun i => ⟨_, abs_nonneg (g i)⟩)
      hpq)
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
⊢ ∑ i in s, f i * g i ≤ (∑ i in s, abs (f i) ^ p) ^ (1 / p) * (∑ i in s, abs (g i) ^ q) ^ (1 / q)

tactic: push_cast at this
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
this :
  ↑(∑ i in s,
        (fun i => { val := abs (f i), property := (_ : 0 ≤ abs (f i)) }) i *
          (fun i => { val := abs (g i), property := (_ : 0 ≤ abs (g i)) }) i) ≤
    ↑((∑ i in s, (fun i => { val := abs (f i), property := (_ : 0 ≤ abs (f i)) }) i ^ p) ^ (1 / p) *
        (∑ i in s, (fun i => { val := abs (g i), property := (_ : 0 ≤ abs (g i)) }) i ^ q) ^ (1 / q))
⊢ ∑ i in s, f i * g i ≤ (∑ i in s, abs (f i) ^ p) ^ (1 / p) * (∑ i in s, abs (g i) ^ q) ^ (1 / q)

tactic: refine' le_trans (sum_le_sum fun i _ => _) this
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
this : ∑ x in s, abs (f x) * abs (g x) ≤ (∑ x in s, abs (f x) ^ p) ^ (1 / p) * (∑ x in s, abs (g x) ^ q) ^ (1 / q)
⊢ ∑ i in s, f i * g i ≤ (∑ i in s, abs (f i) ^ p) ^ (1 / p) * (∑ i in s, abs (g i) ^ q) ^ (1 / q)

tactic: simp only [← abs_mul, le_abs_self]
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ
p q : ℝ
hpq : IsConjugateExponent p q
this : ∑ x in s, abs (f x) * abs (g x) ≤ (∑ x in s, abs (f x) ^ p) ^ (1 / p) * (∑ x in s, abs (g x) ^ q) ^ (1 / q)
i : ι
x✝ : i ∈ s
⊢ f i * g i ≤ abs (f i) * abs (g i)
Theorem: Finset.univ_eq_empty_iff
File: Mathlib/Data/Fintype/Basic.lean

tactic: rw [← not_nonempty_iff, ← univ_nonempty_iff, not_nonempty_iff_eq_empty]
state_before: α : Type u_1
β : Type ?u.2002
γ : Type ?u.2005
inst✝ : Fintype α
s t : Finset α
⊢ univ = ∅ ↔ IsEmpty α
Theorem: inv_le_div_iff_le_mul'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [inv_le_div_iff_le_mul, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a⁻¹ ≤ b / c ↔ c ≤ a * b
Theorem: ENNReal.hasSum_lt
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: by_cases hsg : sg = ⊤
state_before: α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
f g : α → ℝ≥0∞
sf sg : ℝ≥0∞
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hsf : sf ≠ ⊤
hf : HasSum f sf
hg : HasSum g sg
⊢ sf < sg

tactic: exact hsg.symm ▸ lt_of_le_of_ne le_top hsf
state_before: case pos
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
f g : α → ℝ≥0∞
sf sg : ℝ≥0∞
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hsf : sf ≠ ⊤
hf : HasSum f sf
hg : HasSum g sg
hsg : sg = ⊤
⊢ sf < sg

tactic: have hg' : ∀ x, g x ≠ ⊤ := ENNReal.ne_top_of_tsum_ne_top (hg.tsum_eq.symm ▸ hsg)
state_before: case neg
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
f g : α → ℝ≥0∞
sf sg : ℝ≥0∞
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hsf : sf ≠ ⊤
hf : HasSum f sf
hg : HasSum g sg
hsg : ¬sg = ⊤
⊢ sf < sg

tactic: lift f to α → ℝ≥0 using fun x =>
  ne_of_lt (lt_of_le_of_lt (h x) <| lt_of_le_of_ne le_top (hg' x))
state_before: case neg
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
f g : α → ℝ≥0∞
sf sg : ℝ≥0∞
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hsf : sf ≠ ⊤
hf : HasSum f sf
hg : HasSum g sg
hsg : ¬sg = ⊤
hg' : ∀ (x : α), g x ≠ ⊤
⊢ sf < sg

tactic: lift g to α → ℝ≥0 using hg'
state_before: case neg.intro
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
g : α → ℝ≥0∞
sf sg : ℝ≥0∞
i : α
hsf : sf ≠ ⊤
hg : HasSum g sg
hsg : ¬sg = ⊤
hg' : ∀ (x : α), g x ≠ ⊤
f : α → ℝ≥0
h : ∀ (a : α), (fun i => ↑(f i)) a ≤ g a
hi : (fun i => ↑(f i)) i < g i
hf : HasSum (fun i => ↑(f i)) sf
⊢ sf < sg

tactic: lift sf to ℝ≥0 using hsf
state_before: case neg.intro.intro
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
sf sg : ℝ≥0∞
i : α
hsf : sf ≠ ⊤
hsg : ¬sg = ⊤
f : α → ℝ≥0
hf : HasSum (fun i => ↑(f i)) sf
g : α → ℝ≥0
hg : HasSum (fun i => ↑(g i)) sg
h : ∀ (a : α), (fun i => ↑(f i)) a ≤ (fun i => ↑(g i)) a
hi : (fun i => ↑(f i)) i < (fun i => ↑(g i)) i
⊢ sf < sg

tactic: lift sg to ℝ≥0 using hsg
state_before: case neg.intro.intro.intro
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
sg : ℝ≥0∞
i : α
hsg : ¬sg = ⊤
f g : α → ℝ≥0
hg : HasSum (fun i => ↑(g i)) sg
h : ∀ (a : α), (fun i => ↑(f i)) a ≤ (fun i => ↑(g i)) a
hi : (fun i => ↑(f i)) i < (fun i => ↑(g i)) i
sf : ℝ≥0
hf : HasSum (fun i => ↑(f i)) ↑sf
⊢ ↑sf < sg

tactic: simp only [coe_le_coe, coe_lt_coe] at h hi⊢
state_before: case neg.intro.intro.intro.intro
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
i : α
f g : α → ℝ≥0
h : ∀ (a : α), (fun i => ↑(f i)) a ≤ (fun i => ↑(g i)) a
hi : (fun i => ↑(f i)) i < (fun i => ↑(g i)) i
sf : ℝ≥0
hf : HasSum (fun i => ↑(f i)) ↑sf
sg : ℝ≥0
hg : HasSum (fun i => ↑(g i)) ↑sg
⊢ ↑sf < ↑sg

tactic: exact NNReal.hasSum_lt h hi (ENNReal.hasSum_coe.1 hf) (ENNReal.hasSum_coe.1 hg)
state_before: case neg.intro.intro.intro.intro
α : Type u_1
β : Type ?u.336123
γ : Type ?u.336126
i : α
f g : α → ℝ≥0
sf : ℝ≥0
hf : HasSum (fun i => ↑(f i)) ↑sf
sg : ℝ≥0
hg : HasSum (fun i => ↑(g i)) ↑sg
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
⊢ sf < sg
Theorem: Finset.prod_sigma
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp_rw [← disjiUnion_map_sigma_mk, prod_disjiUnion, prod_map, Function.Embedding.sigmaMk_apply]
state_before: ι : Type ?u.312096
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
σ : α → Type u_1
s : Finset α
t : (a : α) → Finset (σ a)
f : Sigma σ → β
⊢ ∏ x in Finset.sigma s t, f x = ∏ a in s, ∏ s in t a, f { fst := a, snd := s }
Theorem: EulerSine.antideriv_cos_comp_const_mul
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean

tactic: have a : HasDerivAt (fun y : ℂ => y * (2 * z)) _ x := hasDerivAt_mul_const _
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
⊢ HasDerivAt (fun y => Complex.sin (2 * z * ↑y) / (2 * z)) (Complex.cos (2 * z * ↑x)) x

tactic: have b : HasDerivAt (fun y : ℂ => Complex.sin (y * (2 * z))) _ x :=
  HasDerivAt.comp (x : ℂ) (Complex.hasDerivAt_sin (x * (2 * z))) a
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
⊢ HasDerivAt (fun y => Complex.sin (2 * z * ↑y) / (2 * z)) (Complex.cos (2 * z * ↑x)) x

tactic: have c := b.comp_ofReal.div_const (2 * z)
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.sin (y * (2 * z))) (Complex.cos (↑x * (2 * z)) * (2 * z)) ↑x
⊢ HasDerivAt (fun y => Complex.sin (2 * z * ↑y) / (2 * z)) (Complex.cos (2 * z * ↑x)) x

tactic: field_simp at c
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.sin (y * (2 * z))) (Complex.cos (↑x * (2 * z)) * (2 * z)) ↑x
c : HasDerivAt (fun x => Complex.sin (↑x * (2 * z)) / (2 * z)) (Complex.cos (↑x * (2 * z)) * (2 * z) / (2 * z)) x
⊢ HasDerivAt (fun y => Complex.sin (2 * z * ↑y) / (2 * z)) (Complex.cos (2 * z * ↑x)) x

tactic: simp only [fun y => mul_comm y (2 * z)] at c
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.sin (y * (2 * z))) (Complex.cos (↑x * (2 * z)) * (2 * z)) ↑x
c : HasDerivAt (fun x => Complex.sin (↑x * (2 * z)) / (2 * z)) (Complex.cos (↑x * (2 * z))) x
⊢ HasDerivAt (fun y => Complex.sin (2 * z * ↑y) / (2 * z)) (Complex.cos (2 * z * ↑x)) x

tactic: exact c
state_before: z : ℂ
n : ℕ
hz : z ≠ 0
x : ℝ
a : HasDerivAt (fun y => y * (2 * z)) (2 * z) ↑x
b : HasDerivAt (fun y => Complex.sin (y * (2 * z))) (Complex.cos (↑x * (2 * z)) * (2 * z)) ↑x
c : HasDerivAt (fun x => Complex.sin (2 * z * ↑x) / (2 * z)) (Complex.cos (2 * z * ↑x)) x
⊢ HasDerivAt (fun y => Complex.sin (2 * z * ↑y) / (2 * z)) (Complex.cos (2 * z * ↑x)) x
Theorem: UniqueFactorizationMonoid.factors_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [zero_smul, pow_zero, factors_one, Multiset.rel_zero_right]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
n : ℕ
⊢ Multiset.Rel Associated (factors (x ^ 0)) (0 • factors x)

tactic: by_cases h0 : x = 0
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
n✝ n : ℕ
⊢ Multiset.Rel Associated (factors (x ^ (n + 1))) ((n + 1) • factors x)

tactic: simp [h0, zero_pow n.succ_pos, smul_zero]
state_before: case pos
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
n✝ n : ℕ
h0 : x = 0
⊢ Multiset.Rel Associated (factors (x ^ (n + 1))) ((n + 1) • factors x)

tactic: rw [pow_succ, succ_nsmul]
state_before: case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
n✝ n : ℕ
h0 : ¬x = 0
⊢ Multiset.Rel Associated (factors (x ^ (n + 1))) ((n + 1) • factors x)

tactic: refine' Multiset.Rel.trans _ (factors_mul h0 (pow_ne_zero n h0)) _
state_before: case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
n✝ n : ℕ
h0 : ¬x = 0
⊢ Multiset.Rel Associated (factors (x * x ^ n)) (factors x + n • factors x)

tactic: refine' Multiset.Rel.add _ <| factors_pow n
state_before: case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
n✝ n : ℕ
h0 : ¬x = 0
⊢ Multiset.Rel Associated (factors x + factors (x ^ n)) (factors x + n • factors x)

tactic: exact Multiset.rel_refl_of_refl_on fun y _ => Associated.refl _
state_before: case neg
α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : DecidableEq α
inst✝ : UniqueFactorizationMonoid α
x : α
n✝ n : ℕ
h0 : ¬x = 0
⊢ Multiset.Rel Associated (factors x) (factors x)
Theorem: Dfinsupp.single_add
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: by_cases h : i = i'
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
b₁ b₂ : β i
i' : ι
⊢ ↑(single i (b₁ + b₂)) i' = ↑(single i b₁ + single i b₂) i'

tactic: subst h
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
b₁ b₂ : β i
i' : ι
h : i = i'
⊢ ↑(single i (b₁ + b₂)) i' = ↑(single i b₁ + single i b₂) i'

tactic: simp only [add_apply, single_eq_same]
state_before: case pos
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
b₁ b₂ : β i
⊢ ↑(single i (b₁ + b₂)) i = ↑(single i b₁ + single i b₂) i

tactic: simp only [add_apply, single_eq_of_ne h, zero_add]
state_before: case neg
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝ : (i : ι) → AddZeroClass (β i)
i : ι
b₁ b₂ : β i
i' : ι
h : ¬i = i'
⊢ ↑(single i (b₁ + b₂)) i' = ↑(single i b₁ + single i b₂) i'
Theorem: Zsqrtd.nonneg_mul_lem
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: have : (⟨x, y⟩ * a : ℤ√d) = (x : ℤ√d) * a + sqrtd * ((y : ℤ√d) * a) := by
  rw [decompose, right_distrib, mul_assoc, Int.cast_ofNat, Int.cast_ofNat]
state_before: d x y : ℕ
a : ℤ√↑d
ha : Nonneg a
⊢ Nonneg ({ re := ↑x, im := ↑y } * a)

tactic: rw [this]
state_before: d x y : ℕ
a : ℤ√↑d
ha : Nonneg a
this : { re := ↑x, im := ↑y } * a = ↑x * a + sqrtd * (↑y * a)
⊢ Nonneg ({ re := ↑x, im := ↑y } * a)

tactic: exact (nonneg_smul ha).add (nonneg_muld <| nonneg_smul ha)
state_before: d x y : ℕ
a : ℤ√↑d
ha : Nonneg a
this : { re := ↑x, im := ↑y } * a = ↑x * a + sqrtd * (↑y * a)
⊢ Nonneg (↑x * a + sqrtd * (↑y * a))

tactic: rw [decompose, right_distrib, mul_assoc, Int.cast_ofNat, Int.cast_ofNat]
state_before: d x y : ℕ
a : ℤ√↑d
ha : Nonneg a
⊢ { re := ↑x, im := ↑y } * a = ↑x * a + sqrtd * (↑y * a)
Theorem: Monoid.lcm_orderOf_dvd_exponent
File: Mathlib/GroupTheory/Exponent.lean

tactic: apply Finset.lcm_dvd
state_before: G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ Finset.lcm Finset.univ orderOf ∣ exponent G

tactic: intro g _
state_before: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
⊢ ∀ (b : G), b ∈ Finset.univ → orderOf b ∣ exponent G

tactic: exact order_dvd_exponent g
state_before: case a
G : Type u
inst✝¹ : Monoid G
inst✝ : Fintype G
g : G
a✝ : g ∈ Finset.univ
⊢ orderOf g ∣ exponent G
Theorem: IsCountablySpanning.prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rcases hC, hD with ⟨⟨s, h1s, h2s⟩, t, h1t, h2t⟩
state_before: α : Type u_1
α' : Type ?u.552
β : Type u_2
β' : Type ?u.558
γ : Type ?u.561
E : Type ?u.564
C : Set (Set α)
D : Set (Set β)
hC : IsCountablySpanning C
hD : IsCountablySpanning D
⊢ IsCountablySpanning (image2 (fun x x_1 => x ×ˢ x_1) C D)

tactic: refine' ⟨fun n => s n.unpair.1 ×ˢ t n.unpair.2, fun n => mem_image2_of_mem (h1s _) (h1t _), _⟩
state_before: case intro.intro.intro.intro
α : Type u_1
α' : Type ?u.552
β : Type u_2
β' : Type ?u.558
γ : Type ?u.561
E : Type ?u.564
C : Set (Set α)
D : Set (Set β)
s : ℕ → Set α
h1s : ∀ (n : ℕ), s n ∈ C
h2s : (⋃ (n : ℕ), s n) = univ
t : ℕ → Set β
h1t : ∀ (n : ℕ), t n ∈ D
h2t : (⋃ (n : ℕ), t n) = univ
⊢ IsCountablySpanning (image2 (fun x x_1 => x ×ˢ x_1) C D)

tactic: rw [iUnion_unpair_prod, h2s, h2t, univ_prod_univ]
state_before: case intro.intro.intro.intro
α : Type u_1
α' : Type ?u.552
β : Type u_2
β' : Type ?u.558
γ : Type ?u.561
E : Type ?u.564
C : Set (Set α)
D : Set (Set β)
s : ℕ → Set α
h1s : ∀ (n : ℕ), s n ∈ C
h2s : (⋃ (n : ℕ), s n) = univ
t : ℕ → Set β
h1t : ∀ (n : ℕ), t n ∈ D
h2t : (⋃ (n : ℕ), t n) = univ
⊢ (⋃ (n : ℕ), (fun n => s (Nat.unpair n).fst ×ˢ t (Nat.unpair n).snd) n) = univ