tasksource/leandojo huggingface dataset:
Theorem: dist_le_of_le_geometric_of_tendsto
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: have := aux_hasSum_of_le_geometric hr hu
state_before: α : Type u_1
β : Type ?u.451019
ι : Type ?u.451022
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
⊢ dist (f n) a ≤ C * r ^ n / (1 - r)

tactic: convert dist_le_tsum_of_dist_le_of_tendsto _ hu ⟨_, this⟩ ha n
state_before: α : Type u_1
β : Type ?u.451019
ι : Type ?u.451022
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ dist (f n) a ≤ C * r ^ n / (1 - r)

tactic: simp only [pow_add, mul_left_comm C, mul_div_right_comm]
state_before: case h.e'_4
α : Type u_1
β : Type ?u.451019
ι : Type ?u.451022
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ C * r ^ n / (1 - r) = ∑' (m : ℕ), C * r ^ (n + m)

tactic: rw [mul_comm]
state_before: case h.e'_4
α : Type u_1
β : Type ?u.451019
ι : Type ?u.451022
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ C / (1 - r) * r ^ n = ∑' (m : ℕ), r ^ n * (C * r ^ m)

tactic: exact (this.mul_left _).tsum_eq.symm
state_before: case h.e'_4
α : Type u_1
β : Type ?u.451019
ι : Type ?u.451022
inst✝ : PseudoMetricSpace α
r C : ℝ
hr : r < 1
f : ℕ → α
hu : ∀ (n : ℕ), dist (f n) (f (n + 1)) ≤ C * r ^ n
a : α
ha : Tendsto f atTop (𝓝 a)
n : ℕ
this : HasSum (fun n => C * r ^ n) (C / (1 - r))
⊢ r ^ n * (C / (1 - r)) = ∑' (m : ℕ), r ^ n * (C * r ^ m)
Theorem: Real.tan_nonneg_of_nonneg_of_le_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp [hxp, tan_eq_sin_div_cos]
state_before: x : ℝ
h0x : 0 ≤ x
hxp✝ : x ≤ π / 2
h✝ : 0 < x
hxp : x = π / 2
⊢ 0 ≤ tan x

tactic: simp [hx0.symm]
state_before: x : ℝ
h0x : 0 ≤ x
hxp : x ≤ π / 2
hx0 : 0 = x
x✝ : x < π / 2 ∨ x = π / 2
⊢ 0 ≤ tan x
Theorem: Interval.coe_inf
File: Mathlib/Order/Interval.lean

tactic: rw [WithBot.none_eq_bot, bot_inf_eq]
state_before: case none
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
t : Interval α
⊢ ↑(none ⊓ t) = ↑none ∩ ↑t

tactic: exact (empty_inter _).symm
state_before: case none
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
t : Interval α
⊢ ↑⊥ = ↑⊥ ∩ ↑t

tactic: rw [WithBot.none_eq_bot, inf_bot_eq]
state_before: case some.none
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : NonemptyInterval α
⊢ ↑(some s ⊓ none) = ↑(some s) ∩ ↑none

tactic: exact (inter_empty _).symm
state_before: case some.none
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : NonemptyInterval α
⊢ ↑⊥ = ↑(some s) ∩ ↑⊥

tactic: refine' (_ : setLike.coe (dite
  (s.toProd.fst ≤ t.toProd.snd ∧ t.toProd.fst ≤ s.toProd.snd)
  _ _) = _).trans Icc_inter_Icc.symm
state_before: case some.some
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : NonemptyInterval α
⊢ ↑(some s ⊓ some t) = ↑(some s) ∩ ↑(some t)

tactic: split_ifs with h
state_before: case some.some
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : NonemptyInterval α
⊢ ↑(if h : s.fst ≤ t.snd ∧ t.fst ≤ s.snd then
        some
          { toProd := (s.fst ⊔ t.fst, s.snd ⊓ t.snd),
            fst_le_snd := (_ : s.fst ⊔ t.fst ≤ (s.fst ⊔ t.fst, s.snd ⊓ t.snd).snd) }
      else ⊥) =
    Icc (s.fst ⊔ t.fst) (s.snd ⊓ t.snd)

tactic: rfl
state_before: case some.some.inl
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : NonemptyInterval α
h : s.fst ≤ t.snd ∧ t.fst ≤ s.snd
⊢ ↑(some
        { toProd := (s.fst ⊔ t.fst, s.snd ⊓ t.snd),
          fst_le_snd := (_ : s.fst ⊔ t.fst ≤ (s.fst ⊔ t.fst, s.snd ⊓ t.snd).snd) }) =
    Icc (s.fst ⊔ t.fst) (s.snd ⊓ t.snd)

tactic: exact (Icc_eq_empty fun H =>
  h ⟨le_sup_left.trans <| H.trans inf_le_right,
  le_sup_right.trans <| H.trans inf_le_left⟩).symm
state_before: case some.some.inr
α : Type u_1
β : Type ?u.38930
γ : Type ?u.38933
δ : Type ?u.38936
ι : Sort ?u.38939
κ : ι → Sort ?u.38944
inst✝¹ : Lattice α
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : NonemptyInterval α
h : ¬(s.fst ≤ t.snd ∧ t.fst ≤ s.snd)
⊢ ↑⊥ = Icc (s.fst ⊔ t.fst) (s.snd ⊓ t.snd)
Theorem: MeasureTheory.FiniteMeasure.tendsto_lintegral_nn_filter_of_le_const
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: refine tendsto_lintegral_filter_of_dominated_convergence (fun _ => c)
  (eventually_of_forall fun i => (ENNReal.continuous_coe.comp (fs i).continuous).measurable) ?_
  (@lintegral_const_lt_top _ _ μ _ _ (@ENNReal.coe_ne_top c)).ne ?_
state_before: Ω : Type u_2
inst✝⁴ : MeasurableSpace Ω
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_1
L : Filter ι
inst✝¹ : IsCountablyGenerated L
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, ↑(fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => ↑(fs i) ω) L (𝓝 (f ω))
⊢ Tendsto (fun i => ∫⁻ (ω : Ω), ↑(↑(fs i) ω) ∂μ) L (𝓝 (∫⁻ (ω : Ω), ↑(f ω) ∂μ))

tactic: simpa only [Function.comp_apply, ENNReal.coe_le_coe] using fs_le_const
state_before: case refine_1
Ω : Type u_2
inst✝⁴ : MeasurableSpace Ω
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_1
L : Filter ι
inst✝¹ : IsCountablyGenerated L
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, ↑(fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => ↑(fs i) ω) L (𝓝 (f ω))
⊢ ∀ᶠ (n : ι) in L, ∀ᵐ (a : Ω) ∂μ, ↑(↑(fs n) a) ≤ (fun x => ↑c) a

tactic: simpa only [Function.comp_apply, ENNReal.tendsto_coe] using fs_lim
state_before: case refine_2
Ω : Type u_2
inst✝⁴ : MeasurableSpace Ω
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_1
L : Filter ι
inst✝¹ : IsCountablyGenerated L
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
fs : ι → Ω →ᵇ ℝ≥0
c : ℝ≥0
fs_le_const : ∀ᶠ (i : ι) in L, ∀ᵐ (ω : Ω) ∂μ, ↑(fs i) ω ≤ c
f : Ω → ℝ≥0
fs_lim : ∀ᵐ (ω : Ω) ∂μ, Tendsto (fun i => ↑(fs i) ω) L (𝓝 (f ω))
⊢ ∀ᵐ (a : Ω) ∂μ, Tendsto (fun n => ↑(↑(fs n) a)) L (𝓝 ↑(f a))
Theorem: finSuccEquiv'_last_apply
File: Mathlib/Logic/Equiv/Fin.lean

tactic: rcases Fin.exists_castSucc_eq.2 h with ⟨i, rfl⟩
state_before: m n : ℕ
i : Fin (n + 1)
h : i ≠ Fin.last n
⊢ ↑(finSuccEquiv' (Fin.last n)) i = some (Fin.castLT i (_ : ↑i < n))

tactic: rw [finSuccEquiv'_last_apply_castSucc]
state_before: case intro
m n : ℕ
i : Fin n
h : ↑Fin.castSucc i ≠ Fin.last n
⊢ ↑(finSuccEquiv' (Fin.last n)) (↑Fin.castSucc i) = some (Fin.castLT (↑Fin.castSucc i) (_ : ↑(↑Fin.castSucc i) < n))

tactic: rfl
state_before: case intro
m n : ℕ
i : Fin n
h : ↑Fin.castSucc i ≠ Fin.last n
⊢ some i = some (Fin.castLT (↑Fin.castSucc i) (_ : ↑(↑Fin.castSucc i) < n))
Theorem: CompositionSeries.chain'_toList
File: Mathlib/Order/JordanHolder.lean

tactic: intro i hi
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ ∀ (i : ℕ) (h : i < List.length (toList s) - 1),
    IsMaximal (List.get (toList s) { val := i, isLt := (_ : i < List.length (toList s)) })
      (List.get (toList s) { val := i + 1, isLt := (_ : Nat.succ i < List.length (toList s)) })

tactic: simp only [toList, List.get_ofFn]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : ℕ
hi : i < List.length (toList s) - 1
⊢ IsMaximal (List.get (toList s) { val := i, isLt := (_ : i < List.length (toList s)) })
    (List.get (toList s) { val := i + 1, isLt := (_ : Nat.succ i < List.length (toList s)) })

tactic: rw [length_toList] at hi
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : ℕ
hi : i < List.length (toList s) - 1
⊢ IsMaximal
    (series s
      (↑(Fin.cast (_ : List.length (List.ofFn s.series) = s.length + 1))
        { val := i, isLt := (_ : i < List.length (toList s)) }))
    (series s
      (↑(Fin.cast (_ : List.length (List.ofFn s.series) = s.length + 1))
        { val := i + 1, isLt := (_ : Nat.succ i < List.length (toList s)) }))

tactic: exact s.step ⟨i, hi⟩
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
i : ℕ
hi✝ : i < List.length (toList s) - 1
hi : i < s.length + 1 - 1
⊢ IsMaximal
    (series s
      (↑(Fin.cast (_ : List.length (List.ofFn s.series) = s.length + 1))
        { val := i, isLt := (_ : i < List.length (toList s)) }))
    (series s
      (↑(Fin.cast (_ : List.length (List.ofFn s.series) = s.length + 1))
        { val := i + 1, isLt := (_ : Nat.succ i < List.length (toList s)) }))
Theorem: LieSubmodule.lie_inf
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [le_inf_iff]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ⊓ ⁅I, N'⁆

tactic: constructor <;>
apply mono_lie_right <;> [exact inf_le_left; exact inf_le_right]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I, N ⊓ N'⁆ ≤ ⁅I, N⁆ ∧ ⁅I, N ⊓ N'⁆ ≤ ⁅I, N'⁆
Theorem: TensorPower.tprod_mul_tprod
File: Mathlib/LinearAlgebra/TensorPower.lean

tactic: dsimp [gMul_def, mulEquiv]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
na nb : ℕ
a : Fin na → M
b : Fin nb → M
⊢ GradedMonoid.GMul.mul (↑(tprod R) a) (↑(tprod R) b) = ↑(tprod R) (Fin.append a b)

tactic: rw [tmulEquiv_apply R M a b]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
na nb : ℕ
a : Fin na → M
b : Fin nb → M
⊢ ↑(reindex R M finSumFinEquiv) (↑(tmulEquiv R M) (↑(tprod R) a ⊗ₜ[R] ↑(tprod R) b)) = ↑(tprod R) (Fin.append a b)

tactic: refine' (reindex_tprod _ _).trans _
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
na nb : ℕ
a : Fin na → M
b : Fin nb → M
⊢ ↑(reindex R M finSumFinEquiv) (⨂ₜ[R] (i : Fin na ⊕ Fin nb), Sum.elim a b i) = ↑(tprod R) (Fin.append a b)

tactic: congr 1
state_before: R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
na nb : ℕ
a : Fin na → M
b : Fin nb → M
⊢ (⨂ₜ[R] (i : Fin (na + nb)), Sum.elim a b (↑finSumFinEquiv.symm i)) = ↑(tprod R) (Fin.append a b)

tactic: dsimp only [Fin.append, finSumFinEquiv, Equiv.coe_fn_symm_mk]
state_before: case h.e_6.h
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
na nb : ℕ
a : Fin na → M
b : Fin nb → M
⊢ (fun i => Sum.elim a b (↑finSumFinEquiv.symm i)) = Fin.append a b

tactic: apply funext
state_before: case h.e_6.h
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
na nb : ℕ
a : Fin na → M
b : Fin nb → M
⊢ (fun i => Sum.elim a b (Fin.addCases Sum.inl Sum.inr i)) = Fin.addCases a b

tactic: apply Fin.addCases <;> simp
state_before: case h.e_6.h.h
R : Type u_1
M : Type u_2
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
na nb : ℕ
a : Fin na → M
b : Fin nb → M
⊢ ∀ (x : Fin (na + nb)), Sum.elim a b (Fin.addCases Sum.inl Sum.inr x) = Fin.addCases a b x
Theorem: Pi.nontrivial_at
File: Mathlib/Logic/Nontrivial.lean

tactic: letI := Classical.decEq (∀ i : I, f i)
state_before: α : Type ?u.4851
β : Type ?u.4854
I : Type u_2
f : I → Type u_1
i' : I
inst : ∀ (i : I), Nonempty (f i)
inst✝ : Nontrivial (f i')
⊢ Nontrivial ((i : I) → f i)

tactic: exact (Function.update_injective (fun i ↦ Classical.choice (inst i)) i').nontrivial
state_before: α : Type ?u.4851
β : Type ?u.4854
I : Type u_2
f : I → Type u_1
i' : I
inst : ∀ (i : I), Nonempty (f i)
inst✝ : Nontrivial (f i')
this : DecidableEq ((i : I) → f i) := Classical.decEq ((i : I) → f i)
⊢ Nontrivial ((i : I) → f i)
Theorem: normUnit_mul_normUnit
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: nontriviality α using Subsingleton.elim a 0
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
⊢ normUnit (a * ↑(normUnit a)) = 1

tactic: obtain rfl | h := eq_or_ne a 0
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
⊢ normUnit (a * ↑(normUnit a)) = 1

tactic: rw [normUnit_zero, zero_mul, normUnit_zero]
state_before: case inl
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
✝ : Nontrivial α
⊢ normUnit (0 * ↑(normUnit 0)) = 1

tactic: rw [normUnit_mul h (Units.ne_zero _), normUnit_coe_units, mul_inv_eq_one]
state_before: case inr
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
a : α
✝ : Nontrivial α
h : a ≠ 0
⊢ normUnit (a * ↑(normUnit a)) = 1
Theorem: Finset.subtype_eq_empty
File: Mathlib/Data/Finset/Image.lean

tactic: simp [ext_iff, Subtype.forall, Subtype.coe_mk]
state_before: α : Type u_1
β : Type ?u.127828
γ : Type ?u.127831
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
⊢ Finset.subtype p s = ∅ ↔ ∀ (x : α), p x → ¬x ∈ s
Theorem: Filter.tendsto_comap'_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [Tendsto, ← map_compose]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.311794
ι : Sort x
m : α → β
f : Filter α
g : Filter β
i : γ → α
h : range i ∈ f
⊢ Tendsto (m ∘ i) (comap i f) g ↔ Tendsto m f g
Theorem: Set.mulIndicator_one
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: simp only [mulSupport_one, empty_disjoint]
state_before: α : Type u_1
β : Type ?u.11546
ι : Type ?u.11549
M : Type u_2
N : Type ?u.11555
inst✝¹ : One M
inst✝ : One N
s✝ t : Set α
f g : α → M
a : α
s : Set α
⊢ Disjoint (mulSupport fun x => 1) s
Theorem: AffineSubspace.Parallel.refl
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: simp
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
s : AffineSubspace k P
⊢ s = map (↑(constVAdd k P 0)) s
Theorem: isCyclic_of_card_pow_eq_one_le
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: rw [card_orderOf_eq_totient_aux₂ hn dvd_rfl]
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → card (filter (fun a => a ^ n = 1) univ) ≤ n
⊢ 0 < card (filter (fun a => orderOf a = Fintype.card α) univ)

tactic: exact totient_pos (Fintype.card_pos_iff.2 ⟨1⟩)
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → card (filter (fun a => a ^ n = 1) univ) ≤ n
⊢ 0 < φ (Fintype.card α)
Theorem: List.takeWhile_takeWhile
File: Mathlib/Data/List/Basic.lean

tactic: induction' l with hd tl IH
state_before: ι : Type ?u.417345
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p✝ : α → Bool
l✝ : List α
p q : α → Bool
l : List α
⊢ takeWhile p (takeWhile q l) = takeWhile (fun a => decide (p a = true ∧ q a = true)) l

tactic: simp [takeWhile]
state_before: case nil
ι : Type ?u.417345
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p✝ : α → Bool
l : List α
p q : α → Bool
⊢ takeWhile p (takeWhile q []) = takeWhile (fun a => decide (p a = true ∧ q a = true)) []

tactic: by_cases hp : p hd <;> by_cases hq : q hd <;> simp [takeWhile, hp, hq, IH]
state_before: case cons
ι : Type ?u.417345
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p✝ : α → Bool
l : List α
p q : α → Bool
hd : α
tl : List α
IH : takeWhile p (takeWhile q tl) = takeWhile (fun a => decide (p a = true ∧ q a = true)) tl
⊢ takeWhile p (takeWhile q (hd :: tl)) = takeWhile (fun a => decide (p a = true ∧ q a = true)) (hd :: tl)
Theorem: Int.lxor_bit
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← bitwise_xor, bitwise_bit]
state_before: a : Bool
m : ℤ
b : Bool
n : ℤ
⊢ lxor' (bit a m) (bit b n) = bit (xor a b) (lxor' m n)
Theorem: Primrec.id
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.22649
σ : Type ?u.22652
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
⊢ ∀ (n : ℕ), encode (decode n) = encode (Option.map id (decode n))
Theorem: BoxIntegral.Box.dist_le_distortion_mul
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: have A : I.lower i - I.upper i < 0 := sub_neg.2 (I.lower_lt_upper i)
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
⊢ dist I.lower I.upper ≤ ↑(distortion I) * (upper I i - lower I i)

tactic: simpa only [← NNReal.coe_le_coe, ← dist_nndist, NNReal.coe_mul, Real.dist_eq, abs_of_neg A,
  neg_sub] using I.nndist_le_distortion_mul i
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
A : lower I i - upper I i < 0
⊢ dist I.lower I.upper ≤ ↑(distortion I) * (upper I i - lower I i)
Theorem: Matrix.rank_one
File: Mathlib/Data/Matrix/Rank.lean

tactic: rw [rank, mulVecLin_one, LinearMap.range_id, finrank_top, finrank_pi]
state_before: l : Type ?u.4278
m : Type ?u.4281
n : Type u_2
o : Type ?u.4287
R : Type u_1
m_fin : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Fintype o
inst✝² : CommRing R
inst✝¹ : StrongRankCondition R
inst✝ : DecidableEq n
⊢ rank 1 = Fintype.card n
Theorem: isCompact_of_finite_subfamily_closed
File: Mathlib/Topology/SubsetProperties.lean

tactic: rw [← disjoint_compl_right_iff_subset, compl_iUnion, disjoint_iff] at hsU
state_before: α : Type u
β : Type v
ι : Type ?u.27539
π : ι → Type ?u.27544
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
h :
  ∀ {ι : Type u} (Z : ι → Set α),
    (∀ (i : ι), IsClosed (Z i)) → (s ∩ ⋂ (i : ι), Z i) = ∅ → ∃ t, (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) = ∅
ι✝ : Type u
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hsU : s ⊆ ⋃ (i : ι✝), U i
⊢ ∃ t, s ⊆ ⋃ (i : ι✝) (_ : i ∈ t), U i

tactic: rcases h (fun i => (U i)ᶜ) (fun i => (hUo _).isClosed_compl) hsU with ⟨t, ht⟩
state_before: α : Type u
β : Type v
ι : Type ?u.27539
π : ι → Type ?u.27544
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t : Set α
h :
  ∀ {ι : Type u} (Z : ι → Set α),
    (∀ (i : ι), IsClosed (Z i)) → (s ∩ ⋂ (i : ι), Z i) = ∅ → ∃ t, (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) = ∅
ι✝ : Type u
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hsU : (s ⊓ ⋂ (i : ι✝), U iᶜ) = ⊥
⊢ ∃ t, s ⊆ ⋃ (i : ι✝) (_ : i ∈ t), U i

tactic: refine ⟨t, ?_⟩
state_before: case intro
α : Type u
β : Type v
ι : Type ?u.27539
π : ι → Type ?u.27544
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t✝ : Set α
h :
  ∀ {ι : Type u} (Z : ι → Set α),
    (∀ (i : ι), IsClosed (Z i)) → (s ∩ ⋂ (i : ι), Z i) = ∅ → ∃ t, (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) = ∅
ι✝ : Type u
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hsU : (s ⊓ ⋂ (i : ι✝), U iᶜ) = ⊥
t : Finset ι✝
ht : (s ∩ ⋂ (i : ι✝) (_ : i ∈ t), U iᶜ) = ∅
⊢ ∃ t, s ⊆ ⋃ (i : ι✝) (_ : i ∈ t), U i

tactic: rwa [← disjoint_compl_right_iff_subset, compl_iUnion₂, disjoint_iff]
state_before: case intro
α : Type u
β : Type v
ι : Type ?u.27539
π : ι → Type ?u.27544
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
s t✝ : Set α
h :
  ∀ {ι : Type u} (Z : ι → Set α),
    (∀ (i : ι), IsClosed (Z i)) → (s ∩ ⋂ (i : ι), Z i) = ∅ → ∃ t, (s ∩ ⋂ (i : ι) (_ : i ∈ t), Z i) = ∅
ι✝ : Type u
U : ι✝ → Set α
hUo : ∀ (i : ι✝), IsOpen (U i)
hsU : (s ⊓ ⋂ (i : ι✝), U iᶜ) = ⊥
t : Finset ι✝
ht : (s ∩ ⋂ (i : ι✝) (_ : i ∈ t), U iᶜ) = ∅
⊢ s ⊆ ⋃ (i : ι✝) (_ : i ∈ t), U i
Theorem: List.inter_reverse
File: Mathlib/Data/List/Lattice.lean

tactic: simp only [List.inter, mem_reverse]
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
xs ys : List α
⊢ List.inter xs (reverse ys) = List.inter xs ys
Theorem: Finset.exists_mem_empty_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [not_mem_empty, false_and_iff, exists_false]
state_before: α : Type u_1
β : Type ?u.438021
γ : Type ?u.438024
p : α → Prop
⊢ (∃ x, x ∈ ∅ ∧ p x) ↔ False
Theorem: Finset.multiplicativeEnergy_eq_zero_iff
File: Mathlib/Combinatorics/Additive/Energy.lean

tactic: simp [← (Nat.zero_le _).not_gt_iff_eq, not_and_or, imp_iff_or_not, or_comm]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ multiplicativeEnergy s t = 0 ↔ s = ∅ ∨ t = ∅
Theorem: quotient_norm_add_le
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rcases And.intro (mk_surjective x) (mk_surjective y) with ⟨⟨x, rfl⟩, ⟨y, rfl⟩⟩
state_before: M : Type u_1
N : Type ?u.346908
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x y : M ⧸ S
⊢ ‖x + y‖ ≤ ‖x‖ + ‖y‖

tactic: simp only [← mk'_apply, ← map_add, quotient_norm_mk_eq, sInf_image']
state_before: case intro.intro.intro
M : Type u_1
N : Type ?u.346908
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x y : M
⊢ ‖↑x + ↑y‖ ≤ ‖↑x‖ + ‖↑y‖

tactic: refine le_ciInf_add_ciInf fun a b ↦ ?_
state_before: case intro.intro.intro
M : Type u_1
N : Type ?u.346908
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x y : M
⊢ (⨅ (a : ↑↑S), ‖x + y + ↑a‖) ≤ (⨅ (a : ↑↑S), ‖x + ↑a‖) + ⨅ (a : ↑↑S), ‖y + ↑a‖

tactic: refine ciInf_le_of_le ⟨0, forall_range_iff.2 fun _ ↦ norm_nonneg _⟩ (a + b) ?_
state_before: case intro.intro.intro
M : Type u_1
N : Type ?u.346908
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x y : M
a b : ↑↑S
⊢ (⨅ (a : ↑↑S), ‖x + y + ↑a‖) ≤ ‖x + ↑a‖ + ‖y + ↑b‖

tactic: exact (congr_arg norm (add_add_add_comm _ _ _ _)).trans_le (norm_add_le _ _)
state_before: case intro.intro.intro
M : Type u_1
N : Type ?u.346908
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x y : M
a b : ↑↑S
⊢ ‖x + y + ↑(a + b)‖ ≤ ‖x + ↑a‖ + ‖y + ↑b‖