tasksource/leandojo huggingface dataset:
Theorem: LinearMap.rank_comp_le
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: simpa only [Cardinal.lift_id] using lift_rank_comp_le g f
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.1137932
inst✝¹⁰ : Ring K
inst✝⁹ : AddCommGroup V
inst✝⁸ : Module K V
inst✝⁷ : AddCommGroup V₁
inst✝⁶ : Module K V₁
inst✝⁵ : AddCommGroup V'
inst✝⁴ : Module K V'
inst✝³ : AddCommGroup V''
inst✝² : Module K V''
inst✝¹ : AddCommGroup V'₁
inst✝ : Module K V'₁
g : V →ₗ[K] V'
f : V' →ₗ[K] V'₁
⊢ rank (comp f g) ≤ min (rank f) (rank g)
Theorem: DirectSum.list_prod_ofFn_of_eq_dProd
File: Mathlib/Algebra/DirectSum/Ring.lean

tactic: rw [List.ofFn_eq_map, ofList_dProd]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
n : ℕ
fι : Fin n → ι
fA : (a : Fin n) → A (fι a)
⊢ List.prod (List.ofFn fun a => ↑(of A (fι a)) (fA a)) =
    ↑(of A (List.dProdIndex (List.finRange n) fι)) (List.dProd (List.finRange n) fι fA)
Theorem: MeasureTheory.Measure.pi_closedBall
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [closedBall_pi _ hr, pi_pi]
state_before: ι : Type u_2
ι' : Type ?u.3161587
α : ι → Type u_1
inst✝³ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝² : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝¹ : ∀ (i : ι), SigmaFinite (μ i)
inst✝ : (i : ι) → MetricSpace (α i)
x : (i : ι) → α i
r : ℝ
hr : 0 ≤ r
⊢ ↑↑(Measure.pi μ) (Metric.closedBall x r) = ∏ i : ι, ↑↑(μ i) (Metric.closedBall (x i) r)
Theorem: List.length_concat
File: src/lean/Init/Data/List/Basic.lean

tactic: induction as with
| nil => rfl
| cons _ xs ih => simp [concat, ih]
state_before: α : Type u
β : Type v
γ : Type w
as : List α
a : α
⊢ length (concat as a) = length as + 1

tactic: rfl
state_before: case nil
α : Type u
β : Type v
γ : Type w
a : α
⊢ length (concat nil a) = length nil + 1

tactic: simp [concat, ih]
state_before: case cons
α : Type u
β : Type v
γ : Type w
a head✝ : α
xs : List α
ih : length (concat xs a) = length xs + 1
⊢ length (concat (head✝ :: xs) a) = length (head✝ :: xs) + 1
Theorem: MeasureTheory.Conservative.ae_forall_image_mem_imp_frequently_image_mem
File: Mathlib/Dynamics/Ergodic/Conservative.lean

tactic: refine' ae_all_iff.2 fun k => _
state_before: ι : Type ?u.75187
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
⊢ ∀ᵐ (x : α) ∂μ, ∀ (k : ℕ), (f^[k]) x ∈ s → ∃ᶠ (n : ℕ) in atTop, (f^[n]) x ∈ s

tactic: refine' (hf.ae_mem_imp_frequently_image_mem (hf.measurable.iterate k hs)).mono fun x hx hk => _
state_before: ι : Type ?u.75187
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
⊢ ∀ᵐ (a : α) ∂μ, (f^[k]) a ∈ s → ∃ᶠ (n : ℕ) in atTop, (f^[n]) a ∈ s

tactic: rw [← map_add_atTop_eq_nat k, frequently_map]
state_before: ι : Type ?u.75187
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, (f^[n]) x ∈ f^[k] ⁻¹' s
hk : (f^[k]) x ∈ s
⊢ ∃ᶠ (n : ℕ) in atTop, (f^[n]) x ∈ s

tactic: refine' (hx hk).mono fun n hn => _
state_before: ι : Type ?u.75187
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, (f^[n]) x ∈ f^[k] ⁻¹' s
hk : (f^[k]) x ∈ s
⊢ ∃ᶠ (a : ℕ) in atTop, (f^[a + k]) x ∈ s

tactic: rwa [add_comm, iterate_add_apply]
state_before: ι : Type ?u.75187
α : Type u_1
inst✝ : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
hf : Conservative f μ
hs : MeasurableSet s
k : ℕ
x : α
hx : x ∈ f^[k] ⁻¹' s → ∃ᶠ (n : ℕ) in atTop, (f^[n]) x ∈ f^[k] ⁻¹' s
hk : (f^[k]) x ∈ s
n : ℕ
hn : (f^[n]) x ∈ f^[k] ⁻¹' s
⊢ (f^[n + k]) x ∈ s
Theorem: Real.arsinh_neg
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: rw [← exp_eq_exp, exp_arsinh, exp_neg, exp_arsinh]
state_before: x✝ y x : ℝ
⊢ arsinh (-x) = -arsinh x

tactic: apply eq_inv_of_mul_eq_one_left
state_before: x✝ y x : ℝ
⊢ -x + sqrt (1 + (-x) ^ 2) = (x + sqrt (1 + x ^ 2))⁻¹

tactic: rw [neg_sq, neg_add_eq_sub, add_comm x, mul_comm, ← sq_sub_sq, sq_sqrt, add_sub_cancel]
state_before: case h
x✝ y x : ℝ
⊢ (-x + sqrt (1 + (-x) ^ 2)) * (x + sqrt (1 + x ^ 2)) = 1

tactic: exact add_nonneg zero_le_one (sq_nonneg _)
state_before: case h
x✝ y x : ℝ
⊢ 0 ≤ 1 + x ^ 2
Theorem: Part.some_sdiff_some
File: Mathlib/Data/Part.lean

tactic: simp [sdiff_def]
state_before: α : Type u_1
β : Type ?u.103033
γ : Type ?u.103036
inst✝ : SDiff α
a b : α
⊢ some a \ some b = some (a \ b)
Theorem: Submodule.iSup_dualAnnihilator_le_iInf
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [le_dualAnnihilator_iff_le_dualCoannihilator, dualCoannihilator_iSup_eq]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Type u_1
U : ι → Submodule R M
⊢ (⨆ (i : ι), dualAnnihilator (U i)) ≤ dualAnnihilator (⨅ (i : ι), U i)

tactic: apply iInf_mono
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Type u_1
U : ι → Submodule R M
⊢ (⨅ (i : ι), U i) ≤ ⨅ (i : ι), dualCoannihilator (dualAnnihilator (U i))

tactic: exact fun i : ι => le_dualAnnihilator_dualCoannihilator (U i)
state_before: case h
R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
W : Submodule R M
ι : Type u_1
U : ι → Submodule R M
⊢ ∀ (i : ι), U i ≤ dualCoannihilator (dualAnnihilator (U i))
Theorem: MvPolynomial.cardinal_lift_mk_le_max
File: Mathlib/Data/MvPolynomial/Cardinal.lean

tactic: cases subsingleton_or_nontrivial R
state_before: σ✝ : Type u
R✝ : Type v
inst✝¹ : CommSemiring R✝
σ : Type u
R : Type v
inst✝ : CommSemiring R
⊢ (#MvPolynomial σ R) ≤ max (max (lift (#R)) (lift (#σ))) ℵ₀

tactic: cases isEmpty_or_nonempty σ
state_before: case inr
σ✝ : Type u
R✝ : Type v
inst✝¹ : CommSemiring R✝
σ : Type u
R : Type v
inst✝ : CommSemiring R
h✝ : Nontrivial R
⊢ (#MvPolynomial σ R) ≤ max (max (lift (#R)) (lift (#σ))) ℵ₀

tactic: exact (mk_eq_one _).trans_le (le_max_of_le_right one_le_aleph0)
state_before: case inl
σ✝ : Type u
R✝ : Type v
inst✝¹ : CommSemiring R✝
σ : Type u
R : Type v
inst✝ : CommSemiring R
h✝ : Subsingleton R
⊢ (#MvPolynomial σ R) ≤ max (max (lift (#R)) (lift (#σ))) ℵ₀

tactic: exact cardinal_mk_eq_lift.trans_le (le_max_of_le_left <| le_max_left _ _)
state_before: case inr.inl
σ✝ : Type u
R✝ : Type v
inst✝¹ : CommSemiring R✝
σ : Type u
R : Type v
inst✝ : CommSemiring R
h✝¹ : Nontrivial R
h✝ : IsEmpty σ
⊢ (#MvPolynomial σ R) ≤ max (max (lift (#R)) (lift (#σ))) ℵ₀

tactic: exact cardinal_mk_eq_max_lift.le
state_before: case inr.inr
σ✝ : Type u
R✝ : Type v
inst✝¹ : CommSemiring R✝
σ : Type u
R : Type v
inst✝ : CommSemiring R
h✝¹ : Nontrivial R
h✝ : Nonempty σ
⊢ (#MvPolynomial σ R) ≤ max (max (lift (#R)) (lift (#σ))) ℵ₀
Theorem: CancelDenoms.neg_subst
File: Mathlib/Tactic/CancelDenoms.lean

tactic: simp [*]
state_before: α : Type u_1
inst✝ : Ring α
n e t : α
h1 : n * e = t
⊢ n * -e = -t
Theorem: AffineIndependent.of_comp
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: cases' isEmpty_or_nonempty ι with h h
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_6
V₂ : Type u_4
P₂ : Type u_5
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
f : P →ᵃ[k] P₂
hai : AffineIndependent k (↑f ∘ p)
⊢ AffineIndependent k p

tactic: obtain ⟨i⟩ := h
state_before: case inr
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_6
V₂ : Type u_4
P₂ : Type u_5
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
f : P →ᵃ[k] P₂
hai : AffineIndependent k (↑f ∘ p)
h : Nonempty ι
⊢ AffineIndependent k p

tactic: rw [affineIndependent_iff_linearIndependent_vsub k p i]
state_before: case inr.intro
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_6
V₂ : Type u_4
P₂ : Type u_5
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
f : P →ᵃ[k] P₂
hai : AffineIndependent k (↑f ∘ p)
i : ι
⊢ AffineIndependent k p

tactic: simp_rw [affineIndependent_iff_linearIndependent_vsub k (f ∘ p) i, Function.comp_apply, ←
  f.linearMap_vsub] at hai
state_before: case inr.intro
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_6
V₂ : Type u_4
P₂ : Type u_5
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
f : P →ᵃ[k] P₂
hai : AffineIndependent k (↑f ∘ p)
i : ι
⊢ LinearIndependent k fun i_1 => p ↑i_1 -ᵥ p i

tactic: exact LinearIndependent.of_comp f.linear hai
state_before: case inr.intro
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_6
V₂ : Type u_4
P₂ : Type u_5
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
f : P →ᵃ[k] P₂
i : ι
hai : LinearIndependent k fun i_1 => ↑f.linear (p ↑i_1 -ᵥ p i)
⊢ LinearIndependent k fun i_1 => p ↑i_1 -ᵥ p i

tactic: haveI := h
state_before: case inl
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_6
V₂ : Type u_4
P₂ : Type u_5
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
f : P →ᵃ[k] P₂
hai : AffineIndependent k (↑f ∘ p)
h : IsEmpty ι
⊢ AffineIndependent k p

tactic: apply affineIndependent_of_subsingleton
state_before: case inl
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_6
V₂ : Type u_4
P₂ : Type u_5
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
p : ι → P
f : P →ᵃ[k] P₂
hai : AffineIndependent k (↑f ∘ p)
h this : IsEmpty ι
⊢ AffineIndependent k p
Theorem: Int.ne_zero_of_gcd
File: Mathlib/Data/Int/GCD.lean

tactic: contrapose! hc
state_before: x y : ℤ
hc : gcd x y ≠ 0
⊢ x ≠ 0 ∨ y ≠ 0

tactic: rw [hc.left, hc.right, gcd_zero_right, natAbs_zero]
state_before: x y : ℤ
hc : x = 0 ∧ y = 0
⊢ gcd x y = 0
Theorem: Int.neg_pred
File: Mathlib/Data/Int/Basic.lean

tactic: rw [neg_eq_iff_eq_neg.mp (neg_succ (-a)), neg_neg]
state_before: a : ℤ
⊢ -pred a = succ (-a)
Theorem: Nat.ArithmeticFunction.isMultiplicative_moebius
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [IsMultiplicative.iff_ne_zero]
state_before: R : Type ?u.592093
⊢ IsMultiplicative μ

tactic: refine' ⟨by simp, fun {n m} hn hm hnm => _⟩
state_before: R : Type ?u.592093
⊢ ↑μ 1 = 1 ∧ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → coprime m n → ↑μ (m * n) = ↑μ m * ↑μ n

tactic: simp only [moebius, ZeroHom.coe_mk]
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ ↑μ (n * m) = ↑μ n * ↑μ m

tactic: dsimp only [coe_mk, ZeroHom.toFun_eq_coe, Eq.ndrec, ZeroHom.coe_mk]
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ ↑{ toFun := fun n => if Squarefree n then (-1) ^ ↑Ω n else 0,
          map_zero' := (_ : (fun n => if Squarefree n then (-1) ^ ↑Ω n else 0) 0 = 0) }
      (n * m) =
    ↑{ toFun := fun n => if Squarefree n then (-1) ^ ↑Ω n else 0,
            map_zero' := (_ : (fun n => if Squarefree n then (-1) ^ ↑Ω n else 0) 0 = 0) }
        n *
      ↑{ toFun := fun n => if Squarefree n then (-1) ^ ↑Ω n else 0,
            map_zero' := (_ : (fun n => if Squarefree n then (-1) ^ ↑Ω n else 0) 0 = 0) }
        m

tactic: simp only [IsUnit.mul_iff, Nat.isUnit_iff, squarefree_mul hnm, ite_and, mul_ite, ite_mul,
  zero_mul, mul_zero]
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ (if Squarefree (n * m) then (-1) ^ ↑Ω (n * m) else 0) =
    (if Squarefree n then (-1) ^ ↑Ω n else 0) * if Squarefree m then (-1) ^ ↑Ω m else 0

tactic: rw [cardFactors_mul hn hm]
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ (if Squarefree n then if Squarefree m then (-1) ^ ↑Ω (n * m) else 0 else 0) =
    if Squarefree m then if Squarefree n then (-1) ^ ↑Ω n * (-1) ^ ↑Ω m else 0 else 0

tactic: simp only [moebius, ZeroHom.coe_mk, squarefree_mul hnm, ite_and, cardFactors_mul hn hm]
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ (if Squarefree n then if Squarefree m then (-1) ^ (↑Ω n + ↑Ω m) else 0 else 0) =
    if Squarefree m then if Squarefree n then (-1) ^ ↑Ω n * (-1) ^ ↑Ω m else 0 else 0

tactic: simp only [Nat.isUnit_iff, ZeroHom.toFun_eq_coe, IsUnit.mul_iff, mul_ite, ite_mul,
  zero_mul, mul_zero]
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ (if Squarefree n then if Squarefree m then (-1) ^ (↑Ω n + ↑Ω m) else 0 else 0) =
    if Squarefree m then if Squarefree n then (-1) ^ ↑Ω n * (-1) ^ ↑Ω m else 0 else 0

tactic: rw [pow_add, ite_mul_zero_left, ite_mul_zero_right]
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ (if Squarefree n then if Squarefree m then (-1) ^ (↑Ω n + ↑Ω m) else 0 else 0) =
    if Squarefree m then if Squarefree n then (-1) ^ ↑Ω n * (-1) ^ ↑Ω m else 0 else 0

tactic: split_ifs <;>  simp
state_before: R : Type ?u.592093
n m : ℕ
hn : n ≠ 0
hm : m ≠ 0
hnm : coprime n m
⊢ ((if Squarefree m then (-1) ^ ↑Ω n else 0) * if Squarefree n then (-1) ^ ↑Ω m else 0) =
    if Squarefree m then if Squarefree n then (-1) ^ ↑Ω n * (-1) ^ ↑Ω m else 0 else 0

tactic: simp
state_before: R : Type ?u.592093
⊢ ↑μ 1 = 1
Theorem: MeasureTheory.all_ae_ofReal_f_le_bound
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: have F_le_bound := all_ae_ofReal_F_le_bound h_bound
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.736386
δ : Type ?u.736389
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
F : ℕ → α → β
f : α → β
bound : α → ℝ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
⊢ ∀ᵐ (a : α) ∂μ, ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)

tactic: rw [← ae_all_iff] at F_le_bound
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.736386
δ : Type ?u.736389
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
F : ℕ → α → β
f : α → β
bound : α → ℝ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
F_le_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ENNReal.ofReal ‖F n a‖ ≤ ENNReal.ofReal (bound a)
⊢ ∀ᵐ (a : α) ∂μ, ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)

tactic: apply F_le_bound.mp ((all_ae_tendsto_ofReal_norm h_lim).mono _)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.736386
δ : Type ?u.736389
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
F : ℕ → α → β
f : α → β
bound : α → ℝ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
F_le_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), ENNReal.ofReal ‖F i a‖ ≤ ENNReal.ofReal (bound a)
⊢ ∀ᵐ (a : α) ∂μ, ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)

tactic: intro a tendsto_norm F_le_bound
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.736386
δ : Type ?u.736389
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
F : ℕ → α → β
f : α → β
bound : α → ℝ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
F_le_bound : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), ENNReal.ofReal ‖F i a‖ ≤ ENNReal.ofReal (bound a)
⊢ ∀ (x : α),
    Tendsto (fun n => ENNReal.ofReal ‖F n x‖) atTop (𝓝 (ENNReal.ofReal ‖f x‖)) →
      (∀ (i : ℕ), ENNReal.ofReal ‖F i x‖ ≤ ENNReal.ofReal (bound x)) → ENNReal.ofReal ‖f x‖ ≤ ENNReal.ofReal (bound x)

tactic: exact le_of_tendsto' tendsto_norm F_le_bound
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.736386
δ : Type ?u.736389
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
F : ℕ → α → β
f : α → β
bound : α → ℝ
h_bound : ∀ (n : ℕ), ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) atTop (𝓝 (f a))
F_le_bound✝ : ∀ᵐ (a : α) ∂μ, ∀ (i : ℕ), ENNReal.ofReal ‖F i a‖ ≤ ENNReal.ofReal (bound a)
a : α
tendsto_norm : Tendsto (fun n => ENNReal.ofReal ‖F n a‖) atTop (𝓝 (ENNReal.ofReal ‖f a‖))
F_le_bound : ∀ (i : ℕ), ENNReal.ofReal ‖F i a‖ ≤ ENNReal.ofReal (bound a)
⊢ ENNReal.ofReal ‖f a‖ ≤ ENNReal.ofReal (bound a)
Theorem: Polynomial.leadingCoeff_multiset_prod'
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: induction' t using Multiset.induction_on with a t ih
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
h : prod (Multiset.map leadingCoeff t) ≠ 0
⊢ leadingCoeff (prod t) = prod (Multiset.map leadingCoeff t)

tactic: simp only [Multiset.map_cons, Multiset.prod_cons] at h ⊢
state_before: case cons
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t✝ : Multiset R[X]
h✝ : prod (Multiset.map leadingCoeff t✝) ≠ 0
a : R[X]
t : Multiset R[X]
ih : prod (Multiset.map leadingCoeff t) ≠ 0 → leadingCoeff (prod t) = prod (Multiset.map leadingCoeff t)
h : prod (Multiset.map leadingCoeff (a ::ₘ t)) ≠ 0
⊢ leadingCoeff (prod (a ::ₘ t)) = prod (Multiset.map leadingCoeff (a ::ₘ t))

tactic: simp
state_before: case empty
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
h✝ : prod (Multiset.map leadingCoeff t) ≠ 0
h : prod (Multiset.map leadingCoeff 0) ≠ 0
⊢ leadingCoeff (prod 0) = prod (Multiset.map leadingCoeff 0)

tactic: rw [ih]
state_before: case cons
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t✝ : Multiset R[X]
h✝ : prod (Multiset.map leadingCoeff t✝) ≠ 0
a : R[X]
t : Multiset R[X]
ih : prod (Multiset.map leadingCoeff t) ≠ 0 → leadingCoeff (prod t) = prod (Multiset.map leadingCoeff t)
h : leadingCoeff a * prod (Multiset.map leadingCoeff t) ≠ 0
⊢ leadingCoeff a * leadingCoeff (prod t) ≠ 0

tactic: simp [*]
state_before: case cons
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t✝ : Multiset R[X]
h✝ : prod (Multiset.map leadingCoeff t✝) ≠ 0
a : R[X]
t : Multiset R[X]
ih : prod (Multiset.map leadingCoeff t) ≠ 0 → leadingCoeff (prod t) = prod (Multiset.map leadingCoeff t)
h : leadingCoeff a * prod (Multiset.map leadingCoeff t) ≠ 0
⊢ leadingCoeff a * prod (Multiset.map leadingCoeff t) ≠ 0

case cons
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t✝ : Multiset R[X]
h✝ : prod (Multiset.map leadingCoeff t✝) ≠ 0
a : R[X]
t : Multiset R[X]
ih : prod (Multiset.map leadingCoeff t) ≠ 0 → leadingCoeff (prod t) = prod (Multiset.map leadingCoeff t)
h : leadingCoeff a * prod (Multiset.map leadingCoeff t) ≠ 0
⊢ prod (Multiset.map leadingCoeff t) ≠ 0

tactic: apply right_ne_zero_of_mul h
state_before: case cons
R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t✝ : Multiset R[X]
h✝ : prod (Multiset.map leadingCoeff t✝) ≠ 0
a : R[X]
t : Multiset R[X]
ih : prod (Multiset.map leadingCoeff t) ≠ 0 → leadingCoeff (prod t) = prod (Multiset.map leadingCoeff t)
h : leadingCoeff a * prod (Multiset.map leadingCoeff t) ≠ 0
⊢ prod (Multiset.map leadingCoeff t) ≠ 0
Theorem: TypeVec.repeatEq_iff_eq
File: Mathlib/Data/TypeVec.lean

tactic: induction' i with _ _ _ i_ih
state_before: n : ℕ
α : TypeVec n
i : Fin2 n
x y : α i
⊢ ofRepeat (repeatEq α i (prod.mk i x y)) ↔ x = y

tactic: rfl
state_before: case fz
n : ℕ
α✝ : TypeVec n
i : Fin2 n
x✝ y✝ : α✝ i
n✝ : ℕ
α : TypeVec (succ n✝)
x y : α Fin2.fz
⊢ ofRepeat (repeatEq α Fin2.fz (prod.mk Fin2.fz x y)) ↔ x = y

case fs
n : ℕ
α✝ : TypeVec n
i : Fin2 n
x✝ y✝ : α✝ i
n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec n✝} {x y : α a✝}, ofRepeat (repeatEq α a✝ (prod.mk a✝ x y)) ↔ x = y
α : TypeVec (succ n✝)
x y : α (Fin2.fs a✝)
⊢ ofRepeat (repeatEq α (Fin2.fs a✝) (prod.mk (Fin2.fs a✝) x y)) ↔ x = y

tactic: erw [repeatEq, i_ih]
state_before: case fs
n : ℕ
α✝ : TypeVec n
i : Fin2 n
x✝ y✝ : α✝ i
n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec n✝} {x y : α a✝}, ofRepeat (repeatEq α a✝ (prod.mk a✝ x y)) ↔ x = y
α : TypeVec (succ n✝)
x y : α (Fin2.fs a✝)
⊢ ofRepeat (repeatEq α (Fin2.fs a✝) (prod.mk (Fin2.fs a✝) x y)) ↔ x = y
Theorem: Real.inv_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: simp only [← rpow_neg_one, ← rpow_mul hx, mul_comm]
state_before: x y✝ z : ℝ
hx : 0 ≤ x
y : ℝ
⊢ x⁻¹ ^ y = (x ^ y)⁻¹
Theorem: MeasureTheory.Measure.haar.prehaar_mono
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

tactic: simp only [prehaar]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ prehaar (↑K₀) U K₁ ≤ prehaar (↑K₀) U K₂

tactic: rw [div_le_div_right]
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ ↑(index (↑K₁) U) / ↑(index (↑K₀) U) ≤ ↑(index (↑K₂) U) / ↑(index (↑K₀) U)

tactic: exact_mod_cast index_mono K₂.2 h hU
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ ↑(index (↑K₁) U) ≤ ↑(index (↑K₂) U)

G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ 0 < ↑(index (↑K₀) U)

tactic: exact_mod_cast index_pos K₀ hU
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
U : Set G
hU : Set.Nonempty (interior U)
K₁ K₂ : Compacts G
h : ↑K₁ ⊆ K₂.carrier
⊢ 0 < ↑(index (↑K₀) U)
Theorem: Zsqrtd.norm_eq_one_iff'
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: rw [← norm_eq_one_iff, ← Int.coe_nat_inj', Int.natAbs_of_nonneg (norm_nonneg hd z), Int.ofNat_one]
state_before: d✝ d : ℤ
hd : d ≤ 0
z : ℤ√d
⊢ norm z = 1 ↔ IsUnit z
Theorem: Matrix.conjTranspose_inv_natCast_smul
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.1009478
m : Type u_2
n : Type u_3
o : Type ?u.1009487
m' : o → Type ?u.1009492
n' : o → Type ?u.1009497
R : Type u_1
S : Type ?u.1009503
α : Type v
β : Type w
γ : Type ?u.1009510
inst✝³ : DivisionSemiring R
inst✝² : AddCommMonoid α
inst✝¹ : StarAddMonoid α
inst✝ : Module R α
c : ℕ
M : Matrix m n α
⊢ ∀ (i : n) (j : m), ((↑c)⁻¹ • M)ᴴ i j = ((↑c)⁻¹ • Mᴴ) i j
Theorem: List.get_drop'
File: Mathlib/Data/List/Basic.lean

tactic: rw [get_drop]
state_before: ι : Type ?u.213709
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ L : List α
i : ℕ
j : Fin (length (drop i L))
⊢ get (drop i L) j = get L { val := i + ↑j, isLt := (_ : i + ↑j < length L) }
Theorem: Real.dist_le_of_mem_uIcc
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rwa [uIcc_comm]
state_before: α : Type u
β : Type v
X : Type ?u.195692
ι : Type ?u.195695
inst✝ : PseudoMetricSpace α
x y x' y' : ℝ
hx : x ∈ uIcc x' y'
hy : y ∈ uIcc x' y'
⊢ y ∈ uIcc y' x'

tactic: rwa [uIcc_comm]
state_before: α : Type u
β : Type v
X : Type ?u.195692
ι : Type ?u.195695
inst✝ : PseudoMetricSpace α
x y x' y' : ℝ
hx : x ∈ uIcc x' y'
hy : y ∈ uIcc x' y'
⊢ x ∈ uIcc y' x'