tasksource/leandojo huggingface dataset:
Theorem: Filter.ZeroAtFilter.neg
File: Mathlib/Order/Filter/ZeroAndBoundedAtFilter.lean

tactic: simpa using hf.neg
state_before: α : Type u_2
β : Type u_1
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : ContinuousNeg β
l : Filter α
f : α → β
hf : ZeroAtFilter l f
⊢ ZeroAtFilter l (-f)
Theorem: hasFTaylorSeriesUpTo_succ_iff_right
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simp only [hasFTaylorSeriesUpToOn_succ_iff_right, ← hasFTaylorSeriesUpToOn_univ_iff, mem_univ,
  forall_true_left, hasFDerivWithinAt_univ]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ HasFTaylorSeriesUpTo (↑(n + 1)) f p ↔
    (∀ (x : E), ContinuousMultilinearMap.uncurry0 (p x 0) = f x) ∧
      (∀ (x : E), HasFDerivAt (fun y => p y 0) (ContinuousMultilinearMap.curryLeft (p x 1)) x) ∧
        HasFTaylorSeriesUpTo (↑n) (fun x => ↑(continuousMultilinearCurryFin1 𝕜 E F) (p x 1)) fun x =>
          FormalMultilinearSeries.shift (p x)
Theorem: SimpleGraph.Hom.injective_of_top_hom
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: intro v w h
state_before: ι : Sort ?u.409745
𝕜 : Type ?u.409748
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
f✝ : G →g G'
f : ⊤ →g G'
⊢ Injective ↑f

tactic: contrapose! h
state_before: ι : Sort ?u.409745
𝕜 : Type ?u.409748
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
f✝ : G →g G'
f : ⊤ →g G'
v w : V
h : ↑f v = ↑f w
⊢ v = w

tactic: exact G'.ne_of_adj (map_adj _ ((top_adj _ _).mpr h))
state_before: ι : Sort ?u.409745
𝕜 : Type ?u.409748
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v✝ w✝ : V
e : Sym2 V
f✝ : G →g G'
f : ⊤ →g G'
v w : V
h : v ≠ w
⊢ ↑f v ≠ ↑f w
Theorem: toIcoDiv_neg'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [neg_neg] using toIcoDiv_neg hp (-a) (-b)
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp (-a) b = -(toIocDiv hp a (-b) + 1)
Theorem: summable_of_summable_hasFDerivAt
File: Mathlib/Analysis/Calculus/Series.lean

tactic: let _ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 _
state_before: α : Type u_1
β : Type ?u.39280
𝕜 : Type u_2
E : Type u_3
F : Type u_4
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
v : ℕ → α → ℝ
s : Set E
x₀ x✝ : E
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
⊢ Summable fun n => f n x

tactic: exact summable_of_summable_hasFDerivAt_of_isPreconnected hu isOpen_univ isPreconnected_univ
  (fun n x _ => hf n x) (fun n x _ => hf' n x) (mem_univ _) hf0 (mem_univ _)
state_before: α : Type u_1
β : Type ?u.39280
𝕜 : Type u_2
E : Type u_3
F : Type u_4
inst✝⁵ : IsROrC 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
v : ℕ → α → ℝ
s : Set E
x₀ x✝¹ : E
N : ℕ∞
hu : Summable u
hf : ∀ (n : α) (x : E), HasFDerivAt (f n) (f' n x) x
hf' : ∀ (n : α) (x : E), ‖f' n x‖ ≤ u n
hf0 : Summable fun n => f n x₀
x : E
x✝ : NormedSpace ℝ E := NormedSpace.restrictScalars ℝ 𝕜 E
⊢ Summable fun n => f n x
Theorem: Complex.cosh_three_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: have h1 : x + 2 * x = 3 * x := by ring
state_before: x y : ℂ
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: rw [← h1, cosh_add x (2 * x)]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: simp only [cosh_two_mul, sinh_two_mul]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * cosh (2 * x) + sinh x * sinh (2 * x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: have h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2 := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: rw [h2, sinh_sq]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + (cosh x ^ 2 - 1)) + 2 * cosh x * (cosh x ^ 2 - 1) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: ring
state_before: x y : ℂ
⊢ x + 2 * x = 3 * x

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
Theorem: List.filter_eq_nil
File: Std/Data/List/Lemmas.lean

tactic: simp only [eq_nil_iff_forall_not_mem, mem_filter, not_and]
state_before: α✝ : Type u_1
p : α✝ → Bool
l : List α✝
⊢ filter p l = [] ↔ ∀ (a : α✝), a ∈ l → ¬p a = true
Theorem: Turing.TM2.stmts₁_self
File: Mathlib/Computability/TuringMachine.lean

tactic: cases q <;> simp only [Finset.mem_insert_self, Finset.mem_singleton_self, stmts₁]
state_before: K : Type u_1
inst✝ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
q : Stmt₂
⊢ q ∈ stmts₁ q
Theorem: CategoryTheory.Subobject.pullback_comp
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: induction' x using Quotient.inductionOn' with t
state_before: C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
f : X ⟶ Y
g : Y ⟶ Z
x : Subobject Z
⊢ (pullback (f ≫ g)).obj x = (pullback f).obj ((pullback g).obj x)

tactic: exact Quotient.sound ⟨(MonoOver.pullbackComp _ _).app t⟩
state_before: case h
C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
f : X ⟶ Y
g : Y ⟶ Z
t : MonoOver Z
⊢ (pullback (f ≫ g)).obj (Quotient.mk'' t) = (pullback f).obj ((pullback g).obj (Quotient.mk'' t))
Theorem: Group.conj_mem_conjugatesOfSet
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rcases mem_conjugatesOfSet_iff.1 H with ⟨a, h₁, h₂⟩
state_before: G : Type u_1
G' : Type ?u.436568
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.436577
inst✝ : AddGroup A
s : Set G
x c : G
H : x ∈ conjugatesOfSet s
⊢ c * x * c⁻¹ ∈ conjugatesOfSet s

tactic: exact mem_conjugatesOfSet_iff.2 ⟨a, h₁, h₂.trans (isConj_iff.2 ⟨c, rfl⟩)⟩
state_before: case intro.intro
G : Type u_1
G' : Type ?u.436568
inst✝² : Group G
inst✝¹ : Group G'
A : Type ?u.436577
inst✝ : AddGroup A
s : Set G
x c : G
H : x ∈ conjugatesOfSet s
a : G
h₁ : a ∈ s
h₂ : IsConj a x
⊢ c * x * c⁻¹ ∈ conjugatesOfSet s
Theorem: Mathlib.Meta.NormNum.isInt_ratCast
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: simp
state_before: R : Type u_1
inst✝ : DivisionRing R
n✝ : ℤ
⊢ ↑↑n✝ = ↑n✝
Theorem: ENNReal.iUnion_Ioo_coe_nat
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [← Ioi_inter_Iio, ← inter_iUnion, iUnion_Iio_coe_nat, diff_eq]
state_before: α : Type ?u.134675
β : Type ?u.134678
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ (⋃ (n : ℕ), Ioo a ↑n) = Ioi a \ {⊤}
Theorem: Path.Homotopy.transReflReparamAux_zero
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean

tactic: simp [transReflReparamAux]
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ transReflReparamAux 0 = 0

tactic: norm_num
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ : X
⊢ 2 < 0 → False
Theorem: Matrix.twoBlockTriangular_det
File: Mathlib/LinearAlgebra/Matrix/Block.lean

tactic: rw [det_toBlock M p]
state_before: α : Type ?u.59918
β : Type ?u.59921
m : Type u_1
n : Type ?u.59927
o : Type ?u.59930
m' : α → Type ?u.59935
n' : α → Type ?u.59940
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0
⊢ det M = det (toSquareBlockProp M p) * det (toSquareBlockProp M fun i => ¬p i)

tactic: convert det_fromBlocks_zero₂₁ (toBlock M p p) (toBlock M p fun j => ¬p j)
    (toBlock M (fun j => ¬p j) fun j => ¬p j)
state_before: α : Type ?u.59918
β : Type ?u.59921
m : Type u_1
n : Type ?u.59927
o : Type ?u.59930
m' : α → Type ?u.59935
n' : α → Type ?u.59940
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0
⊢ det
      (fromBlocks (toBlock M p p) (toBlock M p fun j => ¬p j) (toBlock M (fun j => ¬p j) p)
        (toBlock M (fun j => ¬p j) fun j => ¬p j)) =
    det (toSquareBlockProp M p) * det (toSquareBlockProp M fun i => ¬p i)

tactic: ext i j
state_before: case h.e'_2.h.e'_6.h.e'_8
α : Type ?u.59918
β : Type ?u.59921
m : Type u_1
n : Type ?u.59927
o : Type ?u.59930
m' : α → Type ?u.59935
n' : α → Type ?u.59940
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0
⊢ toBlock M (fun j => ¬p j) p = 0

tactic: exact h (↑i) i.2 (↑j) j.2
state_before: case h.e'_2.h.e'_6.h.e'_8.a.h
α : Type ?u.59918
β : Type ?u.59921
m : Type u_1
n : Type ?u.59927
o : Type ?u.59930
m' : α → Type ?u.59935
n' : α → Type ?u.59940
R : Type v
inst✝⁵ : CommRing R
M✝ N : Matrix m m R
b : m → α
inst✝⁴ : DecidableEq m
inst✝³ : Fintype m
inst✝² : DecidableEq n
inst✝¹ : Fintype n
M : Matrix m m R
p : m → Prop
inst✝ : DecidablePred p
h : ∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0
i : { a // ¬p a }
j : { a // p a }
⊢ toBlock M (fun j => ¬p j) p i j = OfNat.ofNat 0 i j
Theorem: WithTop.coe_sInf'
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: obtain ⟨x, hx⟩ := hs
state_before: α : Type u_1
β : Type ?u.2948
γ : Type ?u.2951
ι : Sort ?u.2954
inst✝ : InfSet α
s : Set α
hs : Set.Nonempty s
⊢ ↑(sInf s) = sInf ((fun a => ↑a) '' s)

tactic: change _ = ite _ _ _
state_before: case intro
α : Type u_1
β : Type ?u.2948
γ : Type ?u.2951
ι : Sort ?u.2954
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
⊢ ↑(sInf s) = sInf ((fun a => ↑a) '' s)

tactic: split_ifs with h
state_before: case intro
α : Type u_1
β : Type ?u.2948
γ : Type ?u.2951
ι : Sort ?u.2954
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
⊢ ↑(sInf s) = if (fun a => ↑a) '' s ⊆ {⊤} then ⊤ else ↑(sInf ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)))

tactic: cases h (mem_image_of_mem _ hx)
state_before: case intro.inl
α : Type u_1
β : Type ?u.2948
γ : Type ?u.2951
ι : Sort ?u.2954
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
h : (fun a => ↑a) '' s ⊆ {⊤}
⊢ ↑(sInf s) = ⊤

tactic: rw [preimage_image_eq]
state_before: case intro.inr
α : Type u_1
β : Type ?u.2948
γ : Type ?u.2951
ι : Sort ?u.2954
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
h : ¬(fun a => ↑a) '' s ⊆ {⊤}
⊢ ↑(sInf s) = ↑(sInf ((fun a => ↑a) ⁻¹' ((fun a => ↑a) '' s)))

tactic: exact Option.some_injective _
state_before: case intro.inr.h
α : Type u_1
β : Type ?u.2948
γ : Type ?u.2951
ι : Sort ?u.2954
inst✝ : InfSet α
s : Set α
x : α
hx : x ∈ s
h : ¬(fun a => ↑a) '' s ⊆ {⊤}
⊢ Injective fun a => ↑a
Theorem: ContinuousMultilinearMap.norm_restrictScalars
File: Mathlib/Analysis/NormedSpace/Multilinear.lean

tactic: simp only [norm_def, coe_restrictScalars]
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
n : ℕ
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
Ei : Fin (Nat.succ n) → Type wEi
G : Type wG
G' : Type wG'
inst✝²⁰ : Fintype ι
inst✝¹⁹ : Fintype ι'
inst✝¹⁸ : NontriviallyNormedField 𝕜
inst✝¹⁷ : (i : ι) → NormedAddCommGroup (E i)
inst✝¹⁶ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝¹⁵ : (i : ι) → NormedAddCommGroup (E₁ i)
inst✝¹⁴ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝¹³ : (i : ι') → NormedAddCommGroup (E' i)
inst✝¹² : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝¹¹ : (i : Fin (Nat.succ n)) → NormedAddCommGroup (Ei i)
inst✝¹⁰ : (i : Fin (Nat.succ n)) → NormedSpace 𝕜 (Ei i)
inst✝⁹ : NormedAddCommGroup G
inst✝⁸ : NormedSpace 𝕜 G
inst✝⁷ : NormedAddCommGroup G'
inst✝⁶ : NormedSpace 𝕜 G'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜'
inst✝⁴ : NormedAlgebra 𝕜' 𝕜
inst✝³ : NormedSpace 𝕜' G
inst✝² : IsScalarTower 𝕜' 𝕜 G
inst✝¹ : (i : ι) → NormedSpace 𝕜' (E i)
inst✝ : ∀ (i : ι), IsScalarTower 𝕜' 𝕜 (E i)
⊢ ‖restrictScalars 𝕜' f‖ = ‖f‖
Theorem: Ordinal.cof_ord_le
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: simpa using cof_le_card c.ord
state_before: α : Type ?u.21275
r : α → α → Prop
c : Cardinal
⊢ cof (ord c) ≤ c
Theorem: Finset.pairwiseDisjoint_map_sigmaMk
File: Mathlib/Data/Finset/Sigma.lean

tactic: intro i _ j _ hij
state_before: ι : Type u_1
α : ι → Type u_2
β : Type ?u.7974
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
⊢ Set.PairwiseDisjoint ↑s fun i => map (Embedding.sigmaMk i) (t i)

tactic: rw [Function.onFun, disjoint_left]
state_before: ι : Type u_1
α : ι → Type u_2
β : Type ?u.7974
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ (_root_.Disjoint on fun i => map (Embedding.sigmaMk i) (t i)) i j

tactic: simp_rw [mem_map, Function.Embedding.sigmaMk_apply]
state_before: ι : Type u_1
α : ι → Type u_2
β : Type ?u.7974
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ ∀ ⦃a : (x : ι) × α x⦄, a ∈ map (Embedding.sigmaMk i) (t i) → ¬a ∈ map (Embedding.sigmaMk j) (t j)

tactic: rintro _ ⟨y, _, rfl⟩ ⟨z, _, hz'⟩
state_before: ι : Type u_1
α : ι → Type u_2
β : Type ?u.7974
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
⊢ ∀ ⦃a : (x : ι) × α x⦄,
    (∃ a_1, a_1 ∈ t i ∧ { fst := i, snd := a_1 } = a) → ¬∃ a_2, a_2 ∈ t j ∧ { fst := j, snd := a_2 } = a

tactic: exact hij (congr_arg Sigma.fst hz'.symm)
state_before: case intro.intro.intro.intro
ι : Type u_1
α : ι → Type u_2
β : Type ?u.7974
s s₁ s₂ : Finset ι
t t₁ t₂ : (i : ι) → Finset (α i)
i : ι
a✝¹ : i ∈ ↑s
j : ι
a✝ : j ∈ ↑s
hij : i ≠ j
y : α i
left✝¹ : y ∈ t i
z : α j
left✝ : z ∈ t j
hz' : { fst := j, snd := z } = { fst := i, snd := y }
⊢ False
Theorem: List.ofFn_injective
File: Mathlib/Data/List/OfFn.lean

tactic: rw [ofFn_inj'] at h
state_before: α : Type u
n : ℕ
f g : Fin n → α
h : ofFn f = ofFn g
⊢ HEq f g

tactic: cases h
state_before: α : Type u
n : ℕ
f g : Fin n → α
h : { fst := n, snd := f } = { fst := n, snd := g }
⊢ HEq f g

tactic: rfl
state_before: case refl
α : Type u
n : ℕ
f : Fin n → α
⊢ HEq f f
Theorem: Metric.diam_cthickening_le
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: lift ε to ℝ≥0 using hε
state_before: ι : Sort ?u.123224
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ ε : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
hε : 0 ≤ ε
⊢ diam (cthickening ε s) ≤ diam s + 2 * ε

tactic: refine (toReal_le_add' (ediam_cthickening_le _) ?_ ?_).trans_eq ?_
state_before: case intro
ι : Sort ?u.123224
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
ε : ℝ≥0
⊢ diam (cthickening (↑ε) s) ≤ diam s + 2 * ↑ε

tactic: exact fun h ↦ top_unique <| h ▸ EMetric.diam_mono (self_subset_cthickening _)
state_before: case intro.refine_1
ι : Sort ?u.123224
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
ε : ℝ≥0
⊢ EMetric.diam s = ⊤ → EMetric.diam (cthickening (↑ε) s) = ⊤

tactic: simp [mul_eq_top]
state_before: case intro.refine_2
ι : Sort ?u.123224
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
ε : ℝ≥0
⊢ 2 * ↑ε = ⊤ → EMetric.diam (cthickening (↑ε) s) = ⊤

tactic: simp [diam]
state_before: case intro.refine_3
ι : Sort ?u.123224
α✝ : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α✝
δ : ℝ
s✝ t : Set α✝
x : α✝
α : Type u_1
inst✝ : PseudoMetricSpace α
s : Set α
ε : ℝ≥0
⊢ ENNReal.toReal (EMetric.diam s) + ENNReal.toReal (2 * ↑ε) = diam s + 2 * ↑ε
Theorem: disjoint_sSup_iff
File: Mathlib/Order/CompleteBooleanAlgebra.lean

tactic: simpa only [disjoint_comm] using @sSup_disjoint_iff
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort ?u.11330
inst✝ : Frame α
s✝ t : Set α
a b : α
s : Set α
⊢ Disjoint a (sSup s) ↔ ∀ (b : α), b ∈ s → Disjoint a b
Theorem: Set.PartiallyWellOrderedOn.exists_monotone_subseq
File: Mathlib/Order/WellFoundedSet.lean

tactic: obtain ⟨g, h1 | h2⟩ := exists_increasing_or_nonincreasing_subseq r f
state_before: ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
⊢ ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))

tactic: refine' ⟨g, fun m n hle => _⟩
state_before: case intro.inl
ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
h1 : ∀ (m n : ℕ), m < n → r (f (↑g m)) (f (↑g n))
⊢ ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))

tactic: obtain hlt | rfl := hle.lt_or_eq
state_before: case intro.inl
ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
h1 : ∀ (m n : ℕ), m < n → r (f (↑g m)) (f (↑g n))
m n : ℕ
hle : m ≤ n
⊢ r (f (↑g m)) (f (↑g n))

tactic: exacts [h1 m n hlt, refl_of r _]
state_before: case intro.inl.inl
ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
h1 : ∀ (m n : ℕ), m < n → r (f (↑g m)) (f (↑g n))
m n : ℕ
hle : m ≤ n
hlt : m < n
⊢ r (f (↑g m)) (f (↑g n))

case intro.inl.inr
ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
h1 : ∀ (m n : ℕ), m < n → r (f (↑g m)) (f (↑g n))
m : ℕ
hle : m ≤ m
⊢ r (f (↑g m)) (f (↑g m))

tactic: exfalso
state_before: case intro.inr
ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
h2 : ∀ (m n : ℕ), m < n → ¬r (f (↑g m)) (f (↑g n))
⊢ ∃ g, ∀ (m n : ℕ), m ≤ n → r (f (↑g m)) (f (↑g n))

tactic: obtain ⟨m, n, hlt, hle⟩ := h (f ∘ g) fun n => hf _
state_before: case intro.inr.h
ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
h2 : ∀ (m n : ℕ), m < n → ¬r (f (↑g m)) (f (↑g n))
⊢ False

tactic: exact h2 m n hlt hle
state_before: case intro.inr.h.intro.intro.intro
ι : Type ?u.83266
α : Type u_1
β : Type ?u.83272
r : α → α → Prop
r' : β → β → Prop
f✝ : α → β
s t : Set α
a : α
inst✝¹ : IsRefl α r
inst✝ : IsTrans α r
h : PartiallyWellOrderedOn s r
f : ℕ → α
hf : ∀ (n : ℕ), f n ∈ s
g : ℕ ↪o ℕ
h2 : ∀ (m n : ℕ), m < n → ¬r (f (↑g m)) (f (↑g n))
m n : ℕ
hlt : m < n
hle : r ((f ∘ ↑g) m) ((f ∘ ↑g) n)
⊢ False
Theorem: CategoryTheory.SimplicialObject.δ_comp_δ'
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

tactic: simp [hj, Fin.not_lt_zero] at H
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : ↑Fin.castSucc i < j
hj : j = 0
⊢ False

tactic: dsimp [δ]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : ↑Fin.castSucc i < j
⊢ δ X j ≫ δ X i = δ X (↑Fin.castSucc i) ≫ δ X (Fin.pred j (_ : j = 0 → False))

tactic: simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
state_before: C : Type u
inst✝ : Category C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : ↑Fin.castSucc i < j
⊢ X.map (SimplexCategory.δ j).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ (↑Fin.castSucc i)).op ≫ X.map (SimplexCategory.δ (Fin.pred j (_ : j = 0 → False))).op
Theorem: Real.arsinh_zero
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: simp [arsinh]
state_before: x y : ℝ
⊢ arsinh 0 = 0
Theorem: AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_C
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: rw [AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_apply, aeval_C,
  IsScalarTower.algebraMap_apply R (MvPolynomial ι R), ← Polynomial.C_eq_algebraMap,
  Polynomial.map_C, RingHom.coe_coe, AlgEquiv.commutes]
state_before: ι : Type u_1
ι' : Type ?u.1051657
R : Type u_2
K : Type ?u.1051663
A : Type u_3
A' : Type ?u.1051669
A'' : Type ?u.1051672
V : Type u
V' : Type ?u.1051677
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
hx : AlgebraicIndependent R x
r : R
⊢ ↑(mvPolynomialOptionEquivPolynomialAdjoin hx) (↑C r) =
    ↑Polynomial.C (↑(algebraMap R { x_1 // x_1 ∈ adjoin R (range x) }) r)
Theorem: uniformContinuous_sInf_rng
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: delta UniformContinuous
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.145371
f : α → β
u₁ : UniformSpace α
u₂ : Set (UniformSpace β)
h : ∀ (u : UniformSpace β), u ∈ u₂ → UniformContinuous f
⊢ UniformContinuous f

tactic: rw [sInf_eq_iInf', iInf_uniformity]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.145371
f : α → β
u₁ : UniformSpace α
u₂ : Set (UniformSpace β)
h : ∀ (u : UniformSpace β), u ∈ u₂ → UniformContinuous f
⊢ Tendsto (fun x => (f x.fst, f x.snd)) (𝓤 α) (𝓤 β)

tactic: exact tendsto_iInf.mpr fun ⟨u, hu⟩ => h u hu
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.145371
f : α → β
u₁ : UniformSpace α
u₂ : Set (UniformSpace β)
h : ∀ (u : UniformSpace β), u ∈ u₂ → UniformContinuous f
⊢ Tendsto (fun x => (f x.fst, f x.snd)) (𝓤 α) (⨅ (i : ↑u₂), 𝓤 β)
Theorem: CategoryTheory.Mat_.id_apply_of_ne
File: Mathlib/CategoryTheory/Preadditive/Mat.lean

tactic: simp [id_apply, h]
state_before: C : Type u₁
inst✝¹ : Category C
inst✝ : Preadditive C
M : Mat_ C
i j : M.ι
h : i ≠ j
⊢ 𝟙 M i j = 0