tasksource/leandojo huggingface dataset:
Theorem: openEmbedding_iff_openEmbedding_of_iSup_eq_top
File: Mathlib/Topology/LocalAtTarget.lean

tactic: simp_rw [openEmbedding_iff]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set β
ι : Type ?u.45890
U : ι → Opens β
hU : iSup U = ⊤
h : Continuous f
⊢ OpenEmbedding f ↔ ∀ (i : ι), OpenEmbedding (restrictPreimage (U i).carrier f)

tactic: rw [forall_and]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set β
ι : Type ?u.45890
U : ι → Opens β
hU : iSup U = ⊤
h : Continuous f
⊢ Embedding f ∧ IsOpen (range f) ↔
    ∀ (i : ι), Embedding (restrictPreimage (U i).carrier f) ∧ IsOpen (range (restrictPreimage (U i).carrier f))

tactic: apply and_congr
state_before: α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set β
ι : Type ?u.45890
U : ι → Opens β
hU : iSup U = ⊤
h : Continuous f
⊢ Embedding f ∧ IsOpen (range f) ↔
    (∀ (x : ι), Embedding (restrictPreimage (U x).carrier f)) ∧
      ∀ (x : ι), IsOpen (range (restrictPreimage (U x).carrier f))

tactic: apply embedding_iff_embedding_of_iSup_eq_top <;> assumption
state_before: case h₁
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set β
ι : Type ?u.45890
U : ι → Opens β
hU : iSup U = ⊤
h : Continuous f
⊢ Embedding f ↔ ∀ (x : ι), Embedding (restrictPreimage (U x).carrier f)

tactic: simp_rw [Set.range_restrictPreimage]
state_before: case h₂
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set β
ι : Type ?u.45890
U : ι → Opens β
hU : iSup U = ⊤
h : Continuous f
⊢ IsOpen (range f) ↔ ∀ (x : ι), IsOpen (range (restrictPreimage (U x).carrier f))

tactic: apply isOpen_iff_coe_preimage_of_iSup_eq_top hU
state_before: case h₂
α : Type u_1
β : Type u_2
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
f : α → β
s : Set β
ι : Type ?u.45890
U : ι → Opens β
hU : iSup U = ⊤
h : Continuous f
⊢ IsOpen (range f) ↔ ∀ (x : ι), IsOpen (Subtype.val ⁻¹' range f)
Theorem: Pmf.toPmf_eq_iff_toMeasure_eq
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: rw [← toMeasure_inj, Measure.toPmf_toMeasure]
state_before: α : Type u_1
β : Type ?u.350230
γ : Type ?u.350233
inst✝⁴ : Countable α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSingletonClass α
p : Pmf α
μ✝ : MeasureTheory.Measure α
inst✝¹ : IsProbabilityMeasure μ✝
μ : MeasureTheory.Measure α
inst✝ : IsProbabilityMeasure μ
⊢ Measure.toPmf μ = p ↔ μ = toMeasure p
Theorem: Finset.nonempty_Ioc
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
state_before: ι : Type ?u.562
α : Type u_1
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Finset.Nonempty (Ioc a b) ↔ a < b
Theorem: Finset.disjUnion_eq_union
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.139917
γ : Type ?u.139920
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b : α
s t : Finset α
h : _root_.Disjoint s t
a : α
⊢ a ∈ disjUnion s t h ↔ a ∈ s ∪ t
Theorem: ENNReal.toReal_smul
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [ENNReal.smul_def, smul_eq_mul, toReal_mul, coe_toReal]
state_before: α : Type ?u.828266
β : Type ?u.828269
a b c d : ℝ≥0∞
r✝ p q r : ℝ≥0
s : ℝ≥0∞
⊢ ENNReal.toReal (r • s) = r • ENNReal.toReal s

tactic: rfl
state_before: α : Type ?u.828266
β : Type ?u.828269
a b c d : ℝ≥0∞
r✝ p q r : ℝ≥0
s : ℝ≥0∞
⊢ ↑r * ENNReal.toReal s = r • ENNReal.toReal s
Theorem: List.getLast_cons
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> intros
state_before: ι : Type ?u.29930
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
l : List α
⊢ ∀ (h : l ≠ []), getLast (a :: l) (_ : a :: l ≠ []) = getLast l h

tactic: contradiction
state_before: case nil
ι : Type ?u.29930
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
h✝ : [] ≠ []
⊢ getLast [a] (_ : [a] ≠ []) = getLast [] h✝

case cons
ι : Type ?u.29930
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (h : tail✝ ≠ []), getLast (a :: tail✝) (_ : a :: tail✝ ≠ []) = getLast tail✝ h
h✝ : head✝ :: tail✝ ≠ []
⊢ getLast (a :: head✝ :: tail✝) (_ : a :: head✝ :: tail✝ ≠ []) = getLast (head✝ :: tail✝) h✝

tactic: rfl
state_before: case cons
ι : Type ?u.29930
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (h : tail✝ ≠ []), getLast (a :: tail✝) (_ : a :: tail✝ ≠ []) = getLast tail✝ h
h✝ : head✝ :: tail✝ ≠ []
⊢ getLast (a :: head✝ :: tail✝) (_ : a :: head✝ :: tail✝ ≠ []) = getLast (head✝ :: tail✝) h✝
Theorem: Cardinal.alephIdx_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [← not_lt, ← not_lt, alephIdx_lt]
state_before: a b : Cardinal
⊢ alephIdx a ≤ alephIdx b ↔ a ≤ b
Theorem: Nat.add_pred_div_lt
File: Mathlib/Data/Nat/Log.lean

tactic: rw [div_lt_iff_lt_mul (zero_lt_one.trans hb), ← succ_le_iff, ← pred_eq_sub_one,
  succ_pred_eq_of_pos (add_pos (zero_lt_one.trans hn) (zero_lt_one.trans hb))]
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ (n + b - 1) / b < n

tactic: exact add_le_mul hn hb
state_before: b n : ℕ
hb : 1 < b
hn : 2 ≤ n
⊢ n + b ≤ n * b
Theorem: ZNum.of_int_cast
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← cast_to_int, to_of_int]
state_before: α : Type u_1
inst✝ : AddGroupWithOne α
n : ℤ
⊢ ↑↑n = ↑n
Theorem: Primrec.sum_casesOn
File: Mathlib/Computability/Primrec.lean

tactic: cases' f a with b c <;> simp [Nat.div2_val, encodek]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
σ : Type u_4
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → β ⊕ γ
g : α → β → σ
h : α → γ → σ
hf : Primrec f
hg : Primrec₂ g
hh : Primrec₂ h
a : α
⊢ (bif Nat.bodd (encode (f a)) then Option.map (h a) (decode (Nat.div2 (encode (f a))))
    else Option.map (g a) (decode (Nat.div2 (encode (f a))))) =
    some (Sum.casesOn (f a) (g a) (h a))
Theorem: BoxIntegral.Prepartition.restrict_split
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: refine' ((isPartitionSplit J i x).restrict h).eq_of_boxes_subset _
state_before: ι : Type u_1
M : Type ?u.38714
n : ℕ
I J : Box ι
i✝ : ι
x✝ : ℝ
h : I ≤ J
i : ι
x : ℝ
⊢ restrict (split J i x) I = split I i x

tactic: simp only [Finset.subset_iff, mem_boxes, mem_restrict', exists_prop, mem_split_iff']
state_before: ι : Type u_1
M : Type ?u.38714
n : ℕ
I J : Box ι
i✝ : ι
x✝ : ℝ
h : I ≤ J
i : ι
x : ℝ
⊢ (restrict (split J i x) I).boxes ⊆ (split I i x).boxes

tactic: have : ∀ s, (I ∩ s : Set (ι → ℝ)) ⊆ J := fun s => (inter_subset_left _ _).trans h
state_before: ι : Type u_1
M : Type ?u.38714
n : ℕ
I J : Box ι
i✝ : ι
x✝ : ℝ
h : I ≤ J
i : ι
x : ℝ
⊢ ∀ ⦃x_1 : Box ι⦄,
    (∃ J', (↑J' = ↑J ∩ {y | y i ≤ x} ∨ ↑J' = ↑J ∩ {y | x < y i}) ∧ ↑x_1 = ↑I ∩ ↑J') →
      ↑x_1 = ↑I ∩ {y | y i ≤ x} ∨ ↑x_1 = ↑I ∩ {y | x < y i}

tactic: rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left; right] <;>
  simp [H₁, H₂, inter_left_comm (I : Set (ι → ℝ)), this]
state_before: ι : Type u_1
M : Type ?u.38714
n : ℕ
I J : Box ι
i✝ : ι
x✝ : ℝ
h : I ≤ J
i : ι
x : ℝ
this : ∀ (s : Set (ι → ℝ)), ↑I ∩ s ⊆ ↑J
⊢ ∀ ⦃x_1 : Box ι⦄,
    (∃ J', (↑J' = ↑J ∩ {y | y i ≤ x} ∨ ↑J' = ↑J ∩ {y | x < y i}) ∧ ↑x_1 = ↑I ∩ ↑J') →
      ↑x_1 = ↑I ∩ {y | y i ≤ x} ∨ ↑x_1 = ↑I ∩ {y | x < y i}
Theorem: map_inv₀
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

tactic: by_cases h : a = 0
state_before: α : Type ?u.17885
M₀ : Type ?u.17888
G₀ : Type u_2
M₀' : Type ?u.17894
G₀' : Type u_1
F : Type u_3
F' : Type ?u.17903
inst✝³ : MonoidWithZero M₀
inst✝² : GroupWithZero G₀
inst✝¹ : GroupWithZero G₀'
inst✝ : MonoidWithZeroHomClass F G₀ G₀'
f : F
a b : G₀
⊢ ↑f a⁻¹ = (↑f a)⁻¹

tactic: simp [h, map_zero f]
state_before: case pos
α : Type ?u.17885
M₀ : Type ?u.17888
G₀ : Type u_2
M₀' : Type ?u.17894
G₀' : Type u_1
F : Type u_3
F' : Type ?u.17903
inst✝³ : MonoidWithZero M₀
inst✝² : GroupWithZero G₀
inst✝¹ : GroupWithZero G₀'
inst✝ : MonoidWithZeroHomClass F G₀ G₀'
f : F
a b : G₀
h : a = 0
⊢ ↑f a⁻¹ = (↑f a)⁻¹

tactic: apply eq_inv_of_mul_eq_one_left
state_before: case neg
α : Type ?u.17885
M₀ : Type ?u.17888
G₀ : Type u_2
M₀' : Type ?u.17894
G₀' : Type u_1
F : Type u_3
F' : Type ?u.17903
inst✝³ : MonoidWithZero M₀
inst✝² : GroupWithZero G₀
inst✝¹ : GroupWithZero G₀'
inst✝ : MonoidWithZeroHomClass F G₀ G₀'
f : F
a b : G₀
h : ¬a = 0
⊢ ↑f a⁻¹ = (↑f a)⁻¹

tactic: rw [← map_mul, inv_mul_cancel h, map_one]
state_before: case neg.h
α : Type ?u.17885
M₀ : Type ?u.17888
G₀ : Type u_2
M₀' : Type ?u.17894
G₀' : Type u_1
F : Type u_3
F' : Type ?u.17903
inst✝³ : MonoidWithZero M₀
inst✝² : GroupWithZero G₀
inst✝¹ : GroupWithZero G₀'
inst✝ : MonoidWithZeroHomClass F G₀ G₀'
f : F
a b : G₀
h : ¬a = 0
⊢ ↑f a⁻¹ * ↑f a = 1
Theorem: forall_eq_or_imp
File: Std/Logic.lean

tactic: simp only [or_imp, forall_and, forall_eq]
state_before: α : Sort u_1
p q : α → Prop
b : Prop
a' : α
⊢ (∀ (a : α), a = a' ∨ q a → p a) ↔ p a' ∧ ∀ (a : α), q a → p a
Theorem: Nonneg.toNonneg_of_nonneg
File: Mathlib/Algebra/Order/Nonneg/Ring.lean

tactic: simp [toNonneg, h]
state_before: α : Type u_1
inst✝¹ : Zero α
inst✝ : LinearOrder α
a : α
h : 0 ≤ a
⊢ toNonneg a = { val := a, property := h }
Theorem: Filter.unbounded_of_tendsto_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rintro ⟨M, hM⟩
state_before: ι : Type ?u.350259
ι' : Type ?u.350262
α : Type u_1
β : Type u_2
γ : Type ?u.350271
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
⊢ ¬BddAbove (range f)

tactic: cases' mem_atTop_sets.mp (h <| Ioi_mem_atTop M) with a ha
state_before: case intro
ι : Type ?u.350259
ι' : Type ?u.350262
α : Type u_1
β : Type u_2
γ : Type ?u.350271
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
⊢ False

tactic: apply lt_irrefl M
state_before: case intro.intro
ι : Type ?u.350259
ι' : Type ?u.350262
α : Type u_1
β : Type u_2
γ : Type ?u.350271
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ (b : α), b ≥ a → b ∈ f ⁻¹' Ioi M
⊢ False

tactic: calc
  M < f a := ha a le_rfl
  _ ≤ M := hM (Set.mem_range_self a)
state_before: case intro.intro
ι : Type ?u.350259
ι' : Type ?u.350262
α : Type u_1
β : Type u_2
γ : Type ?u.350271
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ (b : α), b ≥ a → b ∈ f ⁻¹' Ioi M
⊢ M < M
Theorem: Set.Ioc_union_Ioc
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: cases' le_total a b with hab hab <;> cases' le_total c d with hcd hcd <;> simp [hab, hcd] at h₁ h₂
state_before: α : Type u_1
β : Type ?u.134545
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : min a b ≤ max c d
h₂ : min c d ≤ max a b
⊢ Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d)

tactic: all_goals simp [*]
state_before: case inl.inr
α : Type u_1
β : Type ?u.134545
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : d ≤ c
h₁ : a ≤ c
h₂ : d ≤ b
⊢ Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d)

case inr.inl
α : Type u_1
β : Type ?u.134545
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : c ≤ d
h₁ : b ≤ d
h₂ : c ≤ a
⊢ Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d)

case inr.inr
α : Type u_1
β : Type ?u.134545
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : d ≤ c
h₁ : b ≤ c
h₂ : d ≤ a
⊢ Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d)

tactic: exact Ioc_union_Ioc' h₂ h₁
state_before: case inl.inl
α : Type u_1
β : Type ?u.134545
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : a ≤ b
hcd : c ≤ d
h₁ : a ≤ d
h₂ : c ≤ b
⊢ Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d)

tactic: simp [*]
state_before: case inr.inr
α : Type u_1
β : Type ?u.134545
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hab : b ≤ a
hcd : d ≤ c
h₁ : b ≤ c
h₂ : d ≤ a
⊢ Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d)
Theorem: Filter.CompleteLatticeHom.apply_limsup_iterate
File: Mathlib/Order/LiminfLimsup.lean

tactic: rw [limsup_eq_iInf_iSup_of_nat', map_iInf]
state_before: α : Type u_1
β : Type ?u.123164
γ : Type ?u.123167
ι : Type ?u.123170
inst✝ : CompleteLattice α
f : CompleteLatticeHom α α
a : α
⊢ ↑f (limsup (fun n => (↑f^[n]) a) atTop) = limsup (fun n => (↑f^[n]) a) atTop

tactic: simp_rw [_root_.map_iSup, ← Function.comp_apply (f := f), ← Function.iterate_succ' f,
  ← Nat.add_succ]
state_before: α : Type u_1
β : Type ?u.123164
γ : Type ?u.123167
ι : Type ?u.123170
inst✝ : CompleteLattice α
f : CompleteLatticeHom α α
a : α
⊢ (⨅ (i : ℕ), ↑f (⨆ (i_1 : ℕ), (↑f^[i_1 + i]) a)) = ⨅ (n : ℕ), ⨆ (i : ℕ), (↑f^[i + n]) a

tactic: simp only [not_lt, le_zero_iff, iInf_iInf_eq_left, add_zero, iInf_nat_gt_zero_eq, left_eq_inf]
state_before: α : Type u_1
β : Type ?u.123164
γ : Type ?u.123167
ι : Type ?u.123170
inst✝ : CompleteLattice α
f : CompleteLatticeHom α α
a : α
⊢ (⨅ (i : ℕ), ⨆ (i_1 : ℕ), (↑f^[i_1 + Nat.succ i]) a) =
    (⨅ (i : ℕ) (_ : (fun x x_1 => x < x_1) 0 i), ⨆ (i_1 : ℕ), (↑f^[i_1 + i]) a) ⊓
      ⨅ (i : ℕ) (_ : ¬(fun x x_1 => x < x_1) 0 i), ⨆ (i_1 : ℕ), (↑f^[i_1 + i]) a

tactic: refine' (iInf_le (fun i => ⨆ j, (f^[j + (i + 1)]) a) 0).trans _
state_before: α : Type u_1
β : Type ?u.123164
γ : Type ?u.123167
ι : Type ?u.123170
inst✝ : CompleteLattice α
f : CompleteLatticeHom α α
a : α
⊢ (⨅ (i : ℕ), ⨆ (i_1 : ℕ), (↑f^[i_1 + Nat.succ i]) a) ≤ ⨆ (i : ℕ), (↑f^[i]) a

tactic: simp only [zero_add, Function.comp_apply, iSup_le_iff]
state_before: α : Type u_1
β : Type ?u.123164
γ : Type ?u.123167
ι : Type ?u.123170
inst✝ : CompleteLattice α
f : CompleteLatticeHom α α
a : α
⊢ (⨆ (j : ℕ), (↑f^[j + (0 + 1)]) a) ≤ ⨆ (i : ℕ), (↑f^[i]) a

tactic: exact fun i => le_iSup (fun i => (f^[i]) a) (i + 1)
state_before: α : Type u_1
β : Type ?u.123164
γ : Type ?u.123167
ι : Type ?u.123170
inst✝ : CompleteLattice α
f : CompleteLatticeHom α α
a : α
⊢ ∀ (i : ℕ), (↑f^[i + 1]) a ≤ ⨆ (i : ℕ), (↑f^[i]) a
Theorem: Embedding.t5Space
File: Mathlib/Topology/Separation.lean

tactic: haveI := he.t1Space
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T5Space β
e : α → β
he : _root_.Embedding e
⊢ T5Space α

tactic: refine' ⟨fun s t hd₁ hd₂ => _⟩
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T5Space β
e : α → β
he : _root_.Embedding e
this : T1Space α
⊢ T5Space α

tactic: simp only [he.toInducing.nhdsSet_eq_comap]
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T5Space β
e : α → β
he : _root_.Embedding e
this : T1Space α
s t : Set α
hd₁ : Disjoint (closure s) t
hd₂ : Disjoint s (closure t)
⊢ Disjoint (𝓝ˢ s) (𝓝ˢ t)

tactic: refine disjoint_comap (completely_normal ?_ ?_)
state_before: α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T5Space β
e : α → β
he : _root_.Embedding e
this : T1Space α
s t : Set α
hd₁ : Disjoint (closure s) t
hd₂ : Disjoint s (closure t)
⊢ Disjoint (comap e (𝓝ˢ (e '' s))) (comap e (𝓝ˢ (e '' t)))

tactic: rwa [← subset_compl_iff_disjoint_left, image_subset_iff, preimage_compl,
  ← he.closure_eq_preimage_closure_image, subset_compl_iff_disjoint_left]
state_before: case refine_1
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T5Space β
e : α → β
he : _root_.Embedding e
this : T1Space α
s t : Set α
hd₁ : Disjoint (closure s) t
hd₂ : Disjoint s (closure t)
⊢ Disjoint (closure (e '' s)) (e '' t)

tactic: rwa [← subset_compl_iff_disjoint_right, image_subset_iff, preimage_compl,
  ← he.closure_eq_preimage_closure_image, subset_compl_iff_disjoint_right]
state_before: case refine_2
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalSpace β
inst✝ : T5Space β
e : α → β
he : _root_.Embedding e
this : T1Space α
s t : Set α
hd₁ : Disjoint (closure s) t
hd₂ : Disjoint s (closure t)
⊢ Disjoint (e '' s) (closure (e '' t))
Theorem: Set.inter_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [inter_iUnion]
state_before: α : Type u_1
β : Type ?u.115953
γ : Type ?u.115956
ι : Sort u_2
ι' : Sort ?u.115962
ι₂ : Sort ?u.115965
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.115975
κ₂ : ι → Sort ?u.115980
κ' : ι' → Sort ?u.115985
s : Set α
t : (i : ι) → κ i → Set α
⊢ (s ∩ ⋃ (i : ι) (j : κ i), t i j) = ⋃ (i : ι) (j : κ i), s ∩ t i j
Theorem: Finsupp.support_update_zero
File: Mathlib/Data/Finsupp/Defs.lean

tactic: classical
simp only [update, ite_true, mem_support_iff, ne_eq, not_not]
congr; apply Subsingleton.elim
state_before: α : Type u_1
β : Type ?u.154510
γ : Type ?u.154513
ι : Type ?u.154516
M : Type u_2
M' : Type ?u.154522
N : Type ?u.154525
P : Type ?u.154528
G : Type ?u.154531
H : Type ?u.154534
R : Type ?u.154537
S : Type ?u.154540
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ (update f a 0).support = erase f.support a

tactic: simp only [update, ite_true, mem_support_iff, ne_eq, not_not]
state_before: α : Type u_1
β : Type ?u.154510
γ : Type ?u.154513
ι : Type ?u.154516
M : Type u_2
M' : Type ?u.154522
N : Type ?u.154525
P : Type ?u.154528
G : Type ?u.154531
H : Type ?u.154534
R : Type ?u.154537
S : Type ?u.154540
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ (update f a 0).support = erase f.support a

tactic: congr
state_before: α : Type u_1
β : Type ?u.154510
γ : Type ?u.154513
ι : Type ?u.154516
M : Type u_2
M' : Type ?u.154522
N : Type ?u.154525
P : Type ?u.154528
G : Type ?u.154531
H : Type ?u.154534
R : Type ?u.154537
S : Type ?u.154540
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ erase f.support a = erase f.support a

tactic: apply Subsingleton.elim
state_before: case h.e_2.h
α : Type u_1
β : Type ?u.154510
γ : Type ?u.154513
ι : Type ?u.154516
M : Type u_2
M' : Type ?u.154522
N : Type ?u.154525
P : Type ?u.154528
G : Type ?u.154531
H : Type ?u.154534
R : Type ?u.154537
S : Type ?u.154540
inst✝¹ : Zero M
f : α →₀ M
a : α
b : M
i : α
inst✝ : DecidableEq α
⊢ (fun a b => Classical.decEq α a b) = fun a b => inst✝ a b
Theorem: Finset.two_lt_card_iff
File: Mathlib/Data/Finset/Card.lean

tactic: refine' ⟨fun h => _, _⟩
state_before: α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
⊢ 2 < card s ↔ ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c

tactic: obtain ⟨c, hc⟩ := card_pos.mp (pos_of_gt h)
state_before: case refine'_1
α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
h : 2 < card s
⊢ ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c

tactic: have : 1 < (s.erase c).card := by rwa [← add_lt_add_iff_right 1, card_erase_add_one hc]
state_before: case refine'_1.intro
α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
h : 2 < card s
c : α
hc : c ∈ s
⊢ ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c

tactic: obtain ⟨a, b, ha, hb, hab⟩ := one_lt_card_iff.mp this
state_before: case refine'_1.intro
α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
h : 2 < card s
c : α
hc : c ∈ s
this : 1 < card (erase s c)
⊢ ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c

tactic: exact
  ⟨a, b, c, mem_of_mem_erase ha, mem_of_mem_erase hb, hc, hab, ne_of_mem_erase ha,
    ne_of_mem_erase hb⟩
state_before: case refine'_1.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
h : 2 < card s
c : α
hc : c ∈ s
this : 1 < card (erase s c)
a b : α
ha : a ∈ erase s c
hb : b ∈ erase s c
hab : a ≠ b
⊢ ∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c

tactic: rwa [← add_lt_add_iff_right 1, card_erase_add_one hc]
state_before: α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
h : 2 < card s
c : α
hc : c ∈ s
⊢ 1 < card (erase s c)

tactic: rintro ⟨a, b, c, ha, hb, hc, hab, hac, hbc⟩
state_before: case refine'_2
α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
⊢ (∃ a b c, a ∈ s ∧ b ∈ s ∧ c ∈ s ∧ a ≠ b ∧ a ≠ c ∧ b ≠ c) → 2 < card s

tactic: rw [← card_erase_add_one hc, ← card_erase_add_one (mem_erase_of_ne_of_mem hbc hb), ←
  card_erase_add_one (mem_erase_of_ne_of_mem hab (mem_erase_of_ne_of_mem hac ha))]
state_before: case refine'_2.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ 2 < card s

tactic: apply Nat.le_add_left
state_before: case refine'_2.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.56033
s t : Finset α
f : α → β
n : ℕ
a b c : α
ha : a ∈ s
hb : b ∈ s
hc : c ∈ s
hab : a ≠ b
hac : a ≠ c
hbc : b ≠ c
⊢ 2 < card (erase (erase (erase s c) b) a) + 1 + 1 + 1
Theorem: Set.exists_subtype_range_iff
File: Mathlib/Data/Set/Image.lean

tactic: subst a
state_before: α : Type u_1
β : Type ?u.66669
γ : Type ?u.66672
ι : Sort u_2
ι' : Sort ?u.66678
f : ι → α
s t : Set α
p : ↑(range f) → Prop
x✝ : ∃ a, p a
a : α
i : ι
hi : f i = a
ha : p { val := a, property := (_ : ∃ y, f y = a) }
⊢ ∃ i, p { val := f i, property := (_ : f i ∈ range f) }

tactic: exact ⟨i, ha⟩
state_before: α : Type u_1
β : Type ?u.66669
γ : Type ?u.66672
ι : Sort u_2
ι' : Sort ?u.66678
f : ι → α
s t : Set α
p : ↑(range f) → Prop
x✝ : ∃ a, p a
i : ι
ha : p { val := f i, property := (_ : ∃ y, f y = f i) }
⊢ ∃ i, p { val := f i, property := (_ : f i ∈ range f) }
Theorem: CategoryTheory.Limits.Types.FilteredColimit.eqvGen_quot_rel_of_rel
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: refine' EqvGen.trans _ ⟨k, F.map f x.2⟩ _ _ _
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : (j : J) × F.obj j
x✝ : FilteredColimit.Rel F x y
k : J
f : x.fst ⟶ k
g : y.fst ⟶ k
h : F.map f x.snd = F.map g y.snd
⊢ EqvGen (Quot.Rel F) x y

tactic: . exact (EqvGen.rel _ _ ⟨f, rfl⟩)
state_before: case refine'_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : (j : J) × F.obj j
x✝ : FilteredColimit.Rel F x y
k : J
f : x.fst ⟶ k
g : y.fst ⟶ k
h : F.map f x.snd = F.map g y.snd
⊢ EqvGen (Quot.Rel F) x { fst := k, snd := F.map f x.snd }

case refine'_2
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : (j : J) × F.obj j
x✝ : FilteredColimit.Rel F x y
k : J
f : x.fst ⟶ k
g : y.fst ⟶ k
h : F.map f x.snd = F.map g y.snd
⊢ EqvGen (Quot.Rel F) { fst := k, snd := F.map f x.snd } y

tactic: . exact (EqvGen.symm _ _ (EqvGen.rel _ _ ⟨g, h⟩))
state_before: case refine'_2
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : (j : J) × F.obj j
x✝ : FilteredColimit.Rel F x y
k : J
f : x.fst ⟶ k
g : y.fst ⟶ k
h : F.map f x.snd = F.map g y.snd
⊢ EqvGen (Quot.Rel F) { fst := k, snd := F.map f x.snd } y

tactic: exact (EqvGen.rel _ _ ⟨f, rfl⟩)
state_before: case refine'_1
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : (j : J) × F.obj j
x✝ : FilteredColimit.Rel F x y
k : J
f : x.fst ⟶ k
g : y.fst ⟶ k
h : F.map f x.snd = F.map g y.snd
⊢ EqvGen (Quot.Rel F) x { fst := k, snd := F.map f x.snd }

tactic: exact (EqvGen.symm _ _ (EqvGen.rel _ _ ⟨g, h⟩))
state_before: case refine'_2
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
x y : (j : J) × F.obj j
x✝ : FilteredColimit.Rel F x y
k : J
f : x.fst ⟶ k
g : y.fst ⟶ k
h : F.map f x.snd = F.map g y.snd
⊢ EqvGen (Quot.Rel F) { fst := k, snd := F.map f x.snd } y
Theorem: ENNReal.tendsto_toNNReal
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: lift a to ℝ≥0 using ha
state_before: α : Type ?u.26680
β : Type ?u.26683
γ : Type ?u.26686
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0∞
ha : a ≠ ⊤
⊢ Tendsto ENNReal.toNNReal (𝓝 a) (𝓝 (ENNReal.toNNReal a))

tactic: rw [nhds_coe, tendsto_map'_iff]
state_before: case intro
α : Type ?u.26680
β : Type ?u.26683
γ : Type ?u.26686
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
⊢ Tendsto ENNReal.toNNReal (𝓝 ↑a) (𝓝 (ENNReal.toNNReal ↑a))

tactic: exact tendsto_id
state_before: case intro
α : Type ?u.26680
β : Type ?u.26683
γ : Type ?u.26686
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
a : ℝ≥0
⊢ Tendsto (ENNReal.toNNReal ∘ some) (𝓝 a) (𝓝 (ENNReal.toNNReal ↑a))
Theorem: Real.cos_nonneg_of_mem_Icc
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: linarith [hx.1]
state_before: x : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
⊢ 0 ≤ x + π / 2

tactic: linarith [hx.2]
state_before: x : ℝ
hx : x ∈ Icc (-(π / 2)) (π / 2)
⊢ x + π / 2 ≤ π