tasksource/leandojo huggingface dataset:
Theorem: Set.preimage_const_sub_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp_rw [← Icc_min_max, preimage_const_sub_Icc]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => a - x) ⁻¹' [[b, c]] = [[a - b, a - c]]

tactic: simp only [sub_eq_add_neg, min_add_add_left, max_add_add_left, min_neg_neg, max_neg_neg]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ Icc (a - max b c) (a - min b c) = Icc (min (a - b) (a - c)) (max (a - b) (a - c))
Theorem: Fintype.piFinset_singleton
File: Mathlib/Data/Fintype/Pi.lean

tactic: simp only [Function.funext_iff, Fintype.mem_piFinset, mem_singleton]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
δ : α → Type u_2
f x✝ : (a : α) → δ a
⊢ (x✝ ∈ piFinset fun i => {f i}) ↔ x✝ ∈ {f}
Theorem: Fintype.card_compl_set
File: Mathlib/Data/Fintype/Card.lean

tactic: classical rw [← Set.toFinset_card, ← Set.toFinset_card, ← Finset.card_compl, Set.toFinset_compl]
state_before: α : Type u_1
β : Type ?u.9460
γ : Type ?u.9463
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑(sᶜ)
⊢ card ↑(sᶜ) = card α - card ↑s

tactic: rw [← Set.toFinset_card, ← Set.toFinset_card, ← Finset.card_compl, Set.toFinset_compl]
state_before: α : Type u_1
β : Type ?u.9460
γ : Type ?u.9463
inst✝² : Fintype α
s : Set α
inst✝¹ : Fintype ↑s
inst✝ : Fintype ↑(sᶜ)
⊢ card ↑(sᶜ) = card α - card ↑s
Theorem: Nat.factorial_mul_pow_sub_le_factorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: suffices n ! * (n + 1) ^ (m - n) ≤ m ! from by
  apply LE.le.trans _ this
  apply mul_le_mul_left
  apply pow_le_pow_of_le_left (le_succ n)
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
⊢ n ! * n ^ (m - n) ≤ m !

tactic: have := @Nat.factorial_mul_pow_le_factorial n (m - n)
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
⊢ n ! * (n + 1) ^ (m - n) ≤ m !

tactic: simp [hnm] at this
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
this : n ! * succ n ^ (m - n) ≤ (n + (m - n))!
⊢ n ! * (n + 1) ^ (m - n) ≤ m !

tactic: exact this
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
this : n ! * succ n ^ (m - n) ≤ m !
⊢ n ! * (n + 1) ^ (m - n) ≤ m !

tactic: apply LE.le.trans _ this
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
this : n ! * (n + 1) ^ (m - n) ≤ m !
⊢ n ! * n ^ (m - n) ≤ m !

tactic: apply mul_le_mul_left
state_before: m✝ n✝ n m : ℕ
hnm : n ≤ m
this : n ! * (n + 1) ^ (m - n) ≤ m !
⊢ n ! * n ^ (m - n) ≤ n ! * (n + 1) ^ (m - n)

tactic: apply pow_le_pow_of_le_left (le_succ n)
state_before: case h
m✝ n✝ n m : ℕ
hnm : n ≤ m
this : n ! * (n + 1) ^ (m - n) ≤ m !
⊢ n ^ (m - n) ≤ (n + 1) ^ (m - n)
Theorem: Bool.symmDiff_eq_xor
File: Mathlib/Order/SymmDiff.lean

tactic: decide
state_before: ι : Type ?u.16365
α : Type ?u.16368
β : Type ?u.16371
π : ι → Type ?u.16376
⊢ ∀ (p q : Bool), p ∆ q = xor p q
Theorem: tendsto_atBot_ciSup
File: Mathlib/Topology/Algebra/Order/MonotoneConvergence.lean

tactic: convert tendsto_atTop_ciSup h_anti.dual hbdd.dual using 1
state_before: α : Type u_2
β : Type ?u.18385
ι : Type u_1
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : ConditionallyCompleteLattice α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_anti : Antitone f
hbdd : BddAbove (range f)
⊢ Tendsto f atBot (𝓝 (⨆ (i : ι), f i))
Theorem: to_nhds_mono
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [@nhds_eq_uniformity α u₁ a, @nhds_eq_uniformity α u₂ a]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.141492
u₁ u₂ : UniformSpace α
h : u₁ ≤ u₂
a : α
⊢ 𝓝 a ≤ 𝓝 a

tactic: exact lift'_mono h le_rfl
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.141492
u₁ u₂ : UniformSpace α
h : u₁ ≤ u₂
a : α
⊢ Filter.lift' (𝓤 α) (UniformSpace.ball a) ≤ Filter.lift' (𝓤 α) (UniformSpace.ball a)
Theorem: Complex.hasStrictDerivAt_const_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: rcases em (x = 0) with (rfl | hx)
state_before: x y : ℂ
h : x ≠ 0 ∨ y ≠ 0
⊢ HasStrictDerivAt (fun y => x ^ y) (x ^ y * log x) y

tactic: replace h := h.neg_resolve_left rfl
state_before: case inl
y : ℂ
h : 0 ≠ 0 ∨ y ≠ 0
⊢ HasStrictDerivAt (fun y => 0 ^ y) (0 ^ y * log 0) y

tactic: rw [log_zero, MulZeroClass.mul_zero]
state_before: case inl
y : ℂ
h : y ≠ 0
⊢ HasStrictDerivAt (fun y => 0 ^ y) (0 ^ y * log 0) y

tactic: refine' (hasStrictDerivAt_const _ 0).congr_of_eventuallyEq _
state_before: case inl
y : ℂ
h : y ≠ 0
⊢ HasStrictDerivAt (fun y => 0 ^ y) 0 y

tactic: exact (isOpen_ne.eventually_mem h).mono fun y hy => (zero_cpow hy).symm
state_before: case inl
y : ℂ
h : y ≠ 0
⊢ (fun x => 0) =ᶠ[𝓝 y] fun y => 0 ^ y

tactic: simpa only [cpow_def_of_ne_zero hx, mul_one] using
  ((hasStrictDerivAt_id y).const_mul (log x)).cexp
state_before: case inr
x y : ℂ
h : x ≠ 0 ∨ y ≠ 0
hx : ¬x = 0
⊢ HasStrictDerivAt (fun y => x ^ y) (x ^ y * log x) y
Theorem: Filter.exists_seq_forall_of_frequently
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rw [frequently_iff_seq_frequently] at h
state_before: ι✝ : Type ?u.371978
ι' : Type ?u.371981
α : Type ?u.371984
β : Type ?u.371987
γ : Type ?u.371990
ι : Type u_1
l : Filter ι
p : ι → Prop
hl : IsCountablyGenerated l
h : ∃ᶠ (n : ι) in l, p n
⊢ ∃ ns, Tendsto ns atTop l ∧ ∀ (n : ℕ), p (ns n)

tactic: obtain ⟨x, hx_tendsto, hx_freq⟩ := h
state_before: ι✝ : Type ?u.371978
ι' : Type ?u.371981
α : Type ?u.371984
β : Type ?u.371987
γ : Type ?u.371990
ι : Type u_1
l : Filter ι
p : ι → Prop
hl : IsCountablyGenerated l
h : ∃ x, Tendsto x atTop l ∧ ∃ᶠ (n : ℕ) in atTop, p (x n)
⊢ ∃ ns, Tendsto ns atTop l ∧ ∀ (n : ℕ), p (ns n)

tactic: obtain ⟨n_to_n, h_tendsto, h_freq⟩ := subseq_forall_of_frequently hx_tendsto hx_freq
state_before: case intro.intro
ι✝ : Type ?u.371978
ι' : Type ?u.371981
α : Type ?u.371984
β : Type ?u.371987
γ : Type ?u.371990
ι : Type u_1
l : Filter ι
p : ι → Prop
hl : IsCountablyGenerated l
x : ℕ → ι
hx_tendsto : Tendsto x atTop l
hx_freq : ∃ᶠ (n : ℕ) in atTop, p (x n)
⊢ ∃ ns, Tendsto ns atTop l ∧ ∀ (n : ℕ), p (ns n)

tactic: exact ⟨x ∘ n_to_n, h_tendsto, h_freq⟩
state_before: case intro.intro.intro.intro
ι✝ : Type ?u.371978
ι' : Type ?u.371981
α : Type ?u.371984
β : Type ?u.371987
γ : Type ?u.371990
ι : Type u_1
l : Filter ι
p : ι → Prop
hl : IsCountablyGenerated l
x : ℕ → ι
hx_tendsto : Tendsto x atTop l
hx_freq : ∃ᶠ (n : ℕ) in atTop, p (x n)
n_to_n : ℕ → ℕ
h_tendsto : Tendsto (fun n => x (n_to_n n)) atTop l
h_freq : ∀ (n : ℕ), p (x (n_to_n n))
⊢ ∃ ns, Tendsto ns atTop l ∧ ∀ (n : ℕ), p (ns n)
Theorem: Finmap.replace_toFinmap
File: Mathlib/Data/Finmap.lean

tactic: simp [replace]
state_before: α : Type u
β : α → Type v
inst✝ : DecidableEq α
a : α
b : β a
s : AList β
⊢ replace a b ⟦s⟧ = ⟦AList.replace a b s⟧
Theorem: Sum.isLeft_swap
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> rfl
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type ?u.22858
δ : Type ?u.22861
x : α ⊕ β
⊢ isLeft (swap x) = isRight x
Theorem: Filter.blimsup_eq_iInf_biSup_of_nat
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [blimsup_eq_limsup_subtype, Function.comp,
  (atTop_basis.comap ((↑) : { x | p x } → ℕ)).limsup_eq_iInf_iSup, iSup_subtype, iSup_and]
state_before: α : Type u_1
β : Type ?u.113892
γ : Type ?u.113895
ι : Type ?u.113898
inst✝ : CompleteLattice α
p : ℕ → Prop
u : ℕ → α
⊢ blimsup u atTop p = ⨅ (i : ℕ), ⨆ (j : ℕ) (_ : p j ∧ i ≤ j), u j

tactic: simp only [mem_setOf_eq, mem_preimage, mem_Ici, not_le, iInf_pos]
state_before: α : Type u_1
β : Type ?u.113892
γ : Type ?u.113895
ι : Type ?u.113898
inst✝ : CompleteLattice α
p : ℕ → Prop
u : ℕ → α
⊢ (⨅ (i : ℕ) (_ : True),
      ⨆ (i_1 : ℕ) (x : i_1 ∈ {x | p x}) (_ : { val := i_1, property := (_ : i_1 ∈ {x | p x}) } ∈ Subtype.val ⁻¹' Ici i),
        u i_1) =
    ⨅ (i : ℕ), ⨆ (j : ℕ) (_ : p j) (_ : i ≤ j), u j
Theorem: CategoryTheory.MonoidalCategory.triangle_assoc_comp_left_inv
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: apply (cancel_mono ((ρ_ X).hom ⊗ 𝟙 Y)).1
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
⊢ (𝟙 X ⊗ (λ_ Y).inv) ≫ (α_ X (𝟙_ C) Y).inv = (ρ_ X).inv ⊗ 𝟙 Y

tactic: simp only [triangle_assoc_comp_right, assoc]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
⊢ ((𝟙 X ⊗ (λ_ Y).inv) ≫ (α_ X (𝟙_ C) Y).inv) ≫ ((ρ_ X).hom ⊗ 𝟙 Y) = ((ρ_ X).inv ⊗ 𝟙 Y) ≫ ((ρ_ X).hom ⊗ 𝟙 Y)

tactic: rw [← id_tensor_comp, Iso.inv_hom_id, ← comp_tensor_id, Iso.inv_hom_id]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z X Y : C
⊢ (𝟙 X ⊗ (λ_ Y).inv) ≫ (𝟙 X ⊗ (λ_ Y).hom) = ((ρ_ X).inv ⊗ 𝟙 Y) ≫ ((ρ_ X).hom ⊗ 𝟙 Y)
Theorem: LinearMap.trace_one
File: Mathlib/LinearAlgebra/Trace.lean

tactic: have b := Module.Free.chooseBasis R M
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type ?u.389113
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.389655
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
⊢ ↑(trace R M) 1 = ↑(finrank R M)

tactic: rw [trace_eq_matrix_trace R b, toMatrix_one, finrank_eq_card_chooseBasisIndex]
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type ?u.389113
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.389655
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
b : Basis (Module.Free.ChooseBasisIndex R M) R M
⊢ ↑(trace R M) 1 = ↑(finrank R M)

tactic: simp
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Type u_2
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
N : Type ?u.389113
inst✝⁶ : AddCommGroup N
inst✝⁵ : Module R N
ι : Type ?u.389655
inst✝⁴ : Module.Free R M
inst✝³ : Module.Finite R M
inst✝² : Module.Free R N
inst✝¹ : Module.Finite R N
inst✝ : Nontrivial R
b : Basis (Module.Free.ChooseBasisIndex R M) R M
⊢ Matrix.trace 1 = ↑(Fintype.card (Module.Free.ChooseBasisIndex R M))
Theorem: Nat.bit0_eq_bit0
File: Mathlib/Data/Nat/Bits.lean

tactic: subst h
state_before: n✝ m n : ℕ
h : m = n
⊢ bit0 m = bit0 n

tactic: rfl
state_before: n m : ℕ
⊢ bit0 m = bit0 m
Theorem: Finset.Icc_subset_Ico_iff
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_subset, coe_Icc, coe_Ico, Set.Icc_subset_Ico_iff h₁]
state_before: ι : Type ?u.26269
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h₁ : a₁ ≤ b₁
⊢ Icc a₁ b₁ ⊆ Ico a₂ b₂ ↔ a₂ ≤ a₁ ∧ b₁ < b₂
Theorem: Filter.comap_neBot_iff
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [← forall_mem_nonempty_iff_neBot, mem_comap, forall_exists_index, and_imp]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.262344
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ NeBot (comap m f) ↔ ∀ (t : Set β), t ∈ f → ∃ a, m a ∈ t

tactic: exact ⟨fun h t t_in => h (m ⁻¹' t) t t_in Subset.rfl, fun h s t ht hst => (h t ht).imp hst⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.262344
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s : Set α
t : Set β
f : Filter β
m : α → β
⊢ (∀ (s : Set α) (x : Set β), x ∈ f → m ⁻¹' x ⊆ s → Set.Nonempty s) ↔ ∀ (t : Set β), t ∈ f → ∃ a, m a ∈ t
Theorem: List.getLast?_append_cons
File: Mathlib/Data/List/Basic.lean

tactic: rw [cons_append, cons_append, getLast?_cons_cons,
← cons_append, getLast?_append_cons (c :: l₁)]
state_before: ι : Type ?u.40235
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ : List α
b c : α
l₁ : List α
a : α
l₂ : List α
⊢ getLast? (b :: c :: l₁ ++ a :: l₂) = getLast? (a :: l₂)
Theorem: CategoryTheory.mono_iff_injective
File: Mathlib/CategoryTheory/Types.lean

tactic: constructor
state_before: X Y : Type u
f : X ⟶ Y
⊢ Mono f ↔ Function.Injective f

tactic: intro H x x' h
state_before: case mp
X Y : Type u
f : X ⟶ Y
⊢ Mono f → Function.Injective f

tactic: skip
state_before: case mp
X Y : Type u
f : X ⟶ Y
H : Mono f
x x' : X
h : f x = f x'
⊢ x = x'

tactic: rw [← homOfElement_eq_iff] at h⊢
state_before: case mp
X Y : Type u
f : X ⟶ Y
H : Mono f
x x' : X
h : f x = f x'
⊢ x = x'

tactic: exact (cancel_mono f).mp h
state_before: case mp
X Y : Type u
f : X ⟶ Y
H : Mono f
x x' : X
h : homOfElement (f x) = homOfElement (f x')
⊢ homOfElement x = homOfElement x'

tactic: exact fun H => ⟨fun g g' h => H.comp_left h⟩
state_before: case mpr
X Y : Type u
f : X ⟶ Y
⊢ Function.Injective f → Mono f
Theorem: PythagoreanTriple.ne_zero_of_coprime
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: suffices 0 < z * z by
  rintro rfl
  norm_num at this
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
⊢ z ≠ 0

tactic: rw [← h.eq, ← sq, ← sq]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
⊢ 0 < z * z

tactic: have hc' : Int.gcd x y ≠ 0 := by
  rw [hc]
  exact one_ne_zero
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
⊢ 0 < x ^ 2 + y ^ 2

tactic: cases' Int.ne_zero_of_gcd hc' with hxz hyz
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hc' : Int.gcd x y ≠ 0
⊢ 0 < x ^ 2 + y ^ 2

tactic: rintro rfl
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
this : 0 < z * z
⊢ z ≠ 0

tactic: norm_num at this
state_before: x y : ℤ
hc : Int.gcd x y = 1
h : PythagoreanTriple x y 0
this : 0 < 0 * 0
⊢ False

tactic: rw [hc]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
⊢ Int.gcd x y ≠ 0

tactic: exact one_ne_zero
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
⊢ 1 ≠ 0

tactic: apply lt_add_of_pos_of_le (sq_pos_of_ne_zero x hxz) (sq_nonneg y)
state_before: case inl
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hc' : Int.gcd x y ≠ 0
hxz : x ≠ 0
⊢ 0 < x ^ 2 + y ^ 2

tactic: apply lt_add_of_le_of_pos (sq_nonneg x) (sq_pos_of_ne_zero y hyz)
state_before: case inr
x y z : ℤ
h : PythagoreanTriple x y z
hc : Int.gcd x y = 1
hc' : Int.gcd x y ≠ 0
hyz : y ≠ 0
⊢ 0 < x ^ 2 + y ^ 2
Theorem: Matrix.pow_eq_aeval_mod_charpoly
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: rw [← aeval_eq_aeval_mod_charpoly, map_pow, aeval_X]
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M✝ : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n R
k : ℕ
⊢ M ^ k = ↑(aeval M) (X ^ k %ₘ charpoly M)
Theorem: Set.Finite.toFinset_offDiag
File: Mathlib/Data/Set/Finite.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
inst✝ : DecidableEq α
hs : Set.Finite s
⊢ ∀ (a : α × α), a ∈ Finite.toFinset (_ : Set.Finite (offDiag s)) ↔ a ∈ Finset.offDiag (Finite.toFinset hs)
Theorem: Function.Surjective.isArtinianRing
File: Mathlib/RingTheory/Artinian.lean

tactic: rw [isArtinianRing_iff, isArtinian_iff_wellFounded] at H⊢
state_before: R : Type u_1
inst✝² : Ring R
S : Type u_2
inst✝¹ : Ring S
F : Type u_3
inst✝ : RingHomClass F R S
f : F
hf : Surjective ↑f
H : IsArtinianRing R
⊢ IsArtinianRing S

tactic: exact (Ideal.orderEmbeddingOfSurjective f hf).wellFounded H
state_before: R : Type u_1
inst✝² : Ring R
S : Type u_2
inst✝¹ : Ring S
F : Type u_3
inst✝ : RingHomClass F R S
f : F
hf : Surjective ↑f
H : WellFounded fun x x_1 => x < x_1
⊢ WellFounded fun x x_1 => x < x_1
Theorem: lp.norm_neg
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: rcases p.trichotomy with (rfl | rfl | hp)
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
⊢ ‖-f‖ = ‖f‖

tactic: simp only [norm_eq_card_dsupport, coeFn_neg, Pi.neg_apply, ne_eq, neg_eq_zero]
state_before: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E 0 }
⊢ ‖-f‖ = ‖f‖

tactic: cases isEmpty_or_nonempty α
state_before: case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
⊢ ‖-f‖ = ‖f‖

tactic: apply (lp.isLUB_norm (-f)).unique
state_before: case inr.inl.inr
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h✝ : Nonempty α
⊢ ‖-f‖ = ‖f‖

tactic: simpa only [coeFn_neg, Pi.neg_apply, norm_neg] using lp.isLUB_norm f
state_before: case inr.inl.inr
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h✝ : Nonempty α
⊢ IsLUB (Set.range fun i => ‖↑(-f) i‖) ‖f‖

tactic: simp only [lp.eq_zero' f, neg_zero, norm_zero]
state_before: case inr.inl.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h✝ : IsEmpty α
⊢ ‖-f‖ = ‖f‖

tactic: suffices ‖-f‖ ^ p.toReal = ‖f‖ ^ p.toReal by
  exact Real.rpow_left_injOn hp.ne' (norm_nonneg' _) (norm_nonneg' _) this
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
hp : 0 < ENNReal.toReal p
⊢ ‖-f‖ = ‖f‖

tactic: apply (lp.hasSum_norm hp (-f)).unique
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
hp : 0 < ENNReal.toReal p
⊢ ‖-f‖ ^ ENNReal.toReal p = ‖f‖ ^ ENNReal.toReal p

tactic: simpa only [coeFn_neg, Pi.neg_apply, _root_.norm_neg] using lp.hasSum_norm hp f
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
hp : 0 < ENNReal.toReal p
⊢ HasSum (fun i => ‖↑(-f) i‖ ^ ENNReal.toReal p) (‖f‖ ^ ENNReal.toReal p)

tactic: exact Real.rpow_left_injOn hp.ne' (norm_nonneg' _) (norm_nonneg' _) this
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
hp : 0 < ENNReal.toReal p
this : ‖-f‖ ^ ENNReal.toReal p = ‖f‖ ^ ENNReal.toReal p
⊢ ‖-f‖ = ‖f‖
Theorem: Set.disjoint_univ_pi
File: Mathlib/Data/Set/Prod.lean

tactic: simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, univ_pi_eq_empty_iff]
state_before: ι : Type u_2
α : ι → Type u_1
β : ι → Type ?u.127302
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i)
Theorem: FormalMultilinearSeries.continuousOn
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: cases' (zero_le p.radius).eq_or_lt with h h
state_before: 𝕜 : Type u_3
E : Type u_2
F : Type u_1
G : Type ?u.1074397
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
inst✝ : CompleteSpace F
⊢ ContinuousOn (FormalMultilinearSeries.sum p) (EMetric.ball 0 (radius p))

tactic: simp [← h, continuousOn_empty]
state_before: case inl
𝕜 : Type u_3
E : Type u_2
F : Type u_1
G : Type ?u.1074397
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
inst✝ : CompleteSpace F
h : 0 = radius p
⊢ ContinuousOn (FormalMultilinearSeries.sum p) (EMetric.ball 0 (radius p))

tactic: exact (p.hasFPowerSeriesOnBall h).continuousOn
state_before: case inr
𝕜 : Type u_3
E : Type u_2
F : Type u_1
G : Type ?u.1074397
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
inst✝ : CompleteSpace F
h : 0 < radius p
⊢ ContinuousOn (FormalMultilinearSeries.sum p) (EMetric.ball 0 (radius p))
Theorem: measurableSet_pi
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: cases' (pi s t).eq_empty_or_nonempty with h h
state_before: α : Type ?u.235303
β : Type ?u.235306
γ : Type ?u.235309
δ : Type u_1
δ' : Type ?u.235315
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
⊢ MeasurableSet (Set.pi s t) ↔ (∀ (i : δ), i ∈ s → MeasurableSet (t i)) ∨ Set.pi s t = ∅

tactic: simp [h]
state_before: case inl
α : Type ?u.235303
β : Type ?u.235306
γ : Type ?u.235309
δ : Type u_1
δ' : Type ?u.235315
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
h : Set.pi s t = ∅
⊢ MeasurableSet (Set.pi s t) ↔ (∀ (i : δ), i ∈ s → MeasurableSet (t i)) ∨ Set.pi s t = ∅

tactic: simp [measurableSet_pi_of_nonempty hs, h, ← not_nonempty_iff_eq_empty]
state_before: case inr
α : Type ?u.235303
β : Type ?u.235306
γ : Type ?u.235309
δ : Type u_1
δ' : Type ?u.235315
ι : Sort uι
s✝ t✝ u : Set α
π : δ → Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : (a : δ) → MeasurableSpace (π a)
inst✝ : MeasurableSpace γ
s : Set δ
t : (i : δ) → Set (π i)
hs : Set.Countable s
h : Set.Nonempty (Set.pi s t)
⊢ MeasurableSet (Set.pi s t) ↔ (∀ (i : δ), i ∈ s → MeasurableSet (t i)) ∨ Set.pi s t = ∅
Theorem: Real.Angle.toReal_coe_eq_self_add_two_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: convert @toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff θ (-1) using 2 <;> norm_num
state_before: θ : ℝ
⊢ toReal ↑θ = θ + 2 * π ↔ θ ∈ Set.Ioc (-3 * π) (-π)
Theorem: Fin.pred_mk
File: Mathlib/Data/Fin/Basic.lean

tactic: rwa [tsub_lt_iff_right (Nat.succ_le_of_lt <| Nat.pos_of_ne_zero
  (by simpa using Fin.vne_of_ne w))]
state_before: n✝ m n i : ℕ
h : i < n + 1
w : { val := i, isLt := h } ≠ 0
⊢ i - 1 < n

tactic: simpa using Fin.vne_of_ne w
state_before: n✝ m n i : ℕ
h : i < n + 1
w : { val := i, isLt := h } ≠ 0
⊢ i ≠ 0
Theorem: map_nhds_induced_of_surjective
File: Mathlib/Topology/Order.lean

tactic: rw [nhds_induced, map_comap_of_surjective hf]
state_before: α : Type u
β : Type v
γ : Type ?u.44989
f✝ : α → β
ι : Sort ?u.44996
T : TopologicalSpace α
f : β → α
hf : Surjective f
a : β
⊢ map f (𝓝 a) = 𝓝 (f a)
Theorem: List.rtake_eq_reverse_take_reverse
File: Mathlib/Data/List/Rdrop.lean

tactic: rw [rtake]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rtake l n = reverse (take n (reverse l))

tactic: induction' l using List.reverseRecOn with xs x IH generalizing n
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ drop (length l - n) l = reverse (take n (reverse l))

tactic: simp
state_before: case H0
α : Type u_1
p : α → Bool
l : List α
n✝ n : ℕ
⊢ drop (length [] - n) [] = reverse (take n (reverse []))

tactic: cases n
state_before: case H1
α : Type u_1
p : α → Bool
l : List α
n✝ : ℕ
xs : List α
x : α
IH : ∀ (n : ℕ), drop (length xs - n) xs = reverse (take n (reverse xs))
n : ℕ
⊢ drop (length (xs ++ [x]) - n) (xs ++ [x]) = reverse (take n (reverse (xs ++ [x])))

tactic: exact drop_length _
state_before: case H1.zero
α : Type u_1
p : α → Bool
l : List α
n : ℕ
xs : List α
x : α
IH : ∀ (n : ℕ), drop (length xs - n) xs = reverse (take n (reverse xs))
⊢ drop (length (xs ++ [x]) - Nat.zero) (xs ++ [x]) = reverse (take Nat.zero (reverse (xs ++ [x])))

tactic: simp [drop_append_eq_append_drop, IH]
state_before: case H1.succ
α : Type u_1
p : α → Bool
l : List α
n : ℕ
xs : List α
x : α
IH : ∀ (n : ℕ), drop (length xs - n) xs = reverse (take n (reverse xs))
n✝ : ℕ
⊢ drop (length (xs ++ [x]) - Nat.succ n✝) (xs ++ [x]) = reverse (take (Nat.succ n✝) (reverse (xs ++ [x])))