tasksource/leandojo huggingface dataset:
Theorem: not_summable_of_ratio_test_tendsto_gt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: have key : ∀ᶠ n in atTop, ‖f n‖ ≠ 0 := by
  filter_upwards [eventually_ge_of_tendsto_gt hl h]with _ hn hc
  rw [hc, _root_.div_zero] at hn
  linarith
state_before: α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
⊢ ¬Summable f

tactic: rcases exists_between hl with ⟨r, hr₀, hr₁⟩
state_before: α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
key : ∀ᶠ (n : ℕ) in atTop, ‖f n‖ ≠ 0
⊢ ¬Summable f

tactic: refine' not_summable_of_ratio_norm_eventually_ge hr₀ key.frequently _
state_before: case intro.intro
α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
key : ∀ᶠ (n : ℕ) in atTop, ‖f n‖ ≠ 0
r : ℝ
hr₀ : 1 < r
hr₁ : r < l
⊢ ¬Summable f

tactic: filter_upwards [eventually_ge_of_tendsto_gt hr₁ h, key]with _ _ h₁
state_before: case intro.intro
α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
key : ∀ᶠ (n : ℕ) in atTop, ‖f n‖ ≠ 0
r : ℝ
hr₀ : 1 < r
hr₁ : r < l
⊢ ∀ᶠ (n : ℕ) in atTop, r * ‖f n‖ ≤ ‖f (n + 1)‖

tactic: rwa [← le_div_iff (lt_of_le_of_ne (norm_nonneg _) h₁.symm)]
state_before: case h
α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
key : ∀ᶠ (n : ℕ) in atTop, ‖f n‖ ≠ 0
r : ℝ
hr₀ : 1 < r
hr₁ : r < l
a✝¹ : ℕ
a✝ : r ≤ ‖f (a✝¹ + 1)‖ / ‖f a✝¹‖
h₁ : ‖f a✝¹‖ ≠ 0
⊢ r * ‖f a✝¹‖ ≤ ‖f (a✝¹ + 1)‖

tactic: filter_upwards [eventually_ge_of_tendsto_gt hl h]with _ hn hc
state_before: α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
⊢ ∀ᶠ (n : ℕ) in atTop, ‖f n‖ ≠ 0

tactic: rw [hc, _root_.div_zero] at hn
state_before: case h
α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
a✝ : ℕ
hn : 1 ≤ ‖f (a✝ + 1)‖ / ‖f a✝‖
hc : ‖f a✝‖ = 0
⊢ False

tactic: linarith
state_before: case h
α✝ : Type ?u.1387057
β : Type ?u.1387060
ι : Type ?u.1387063
α : Type u_1
inst✝ : SeminormedAddCommGroup α
f : ℕ → α
l : ℝ
hl : 1 < l
h : Tendsto (fun n => ‖f (n + 1)‖ / ‖f n‖) atTop (𝓝 l)
a✝ : ℕ
hn : 1 ≤ 0
hc : ‖f a✝‖ = 0
⊢ False
Theorem: SimpleGraph.ComponentCompl.subset_hom
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: rintro c ⟨cL, rfl⟩
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : ComponentCompl G L
h : K ⊆ L
⊢ ↑C ⊆ ↑(hom h C)

tactic: exact ⟨fun h' => cL (h h'), rfl⟩
state_before: case intro
V : Type u
G : SimpleGraph V
K L L' M : Set V
h : K ⊆ L
c : V
cL : ¬c ∈ L
⊢ c ∈ ↑(hom h (componentComplMk G cL))
Theorem: Real.tendsto_log_nhdsWithin_zero
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [← show _ = log from funext log_abs]
state_before: x y : ℝ
⊢ Tendsto log (𝓝[{0}ᶜ] 0) atBot

tactic: refine' Tendsto.comp (g := log) _ tendsto_abs_nhdsWithin_zero
state_before: x y : ℝ
⊢ Tendsto (fun x => log (abs x)) (𝓝[{0}ᶜ] 0) atBot

tactic: simpa [← tendsto_comp_exp_atBot] using tendsto_id
state_before: x y : ℝ
⊢ Tendsto log (𝓝[Ioi 0] 0) atBot
Theorem: Computation.LiftRelAux.ret_right
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← LiftRelAux.swap, LiftRelAux.ret_left]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
C : Computation α → Computation β → Prop
b : β
ca : Computation α
⊢ LiftRelAux R C (destruct ca) (Sum.inl b) ↔ ∃ a, a ∈ ca ∧ R a b
Theorem: Polynomial.splits_of_map_degree_eq_one
File: Mathlib/Data/Polynomial/Splits.lean

tactic: have := congr_arg degree hp
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : degree (map i f) = 1
g✝ : L[X]
hg : Irreducible g✝
x✝ : g✝ ∣ map i f
p : L[X]
hp : map i f = g✝ * p
⊢ degree g✝ = 1

tactic: simp [Nat.WithBot.add_eq_one_iff, hf, @eq_comm (WithBot ℕ) 1,
    mt isUnit_iff_degree_eq_zero.2 hg.1] at this
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : degree (map i f) = 1
g✝ : L[X]
hg : Irreducible g✝
x✝ : g✝ ∣ map i f
p : L[X]
hp : map i f = g✝ * p
this : degree (map i f) = degree (g✝ * p)
⊢ degree g✝ = 1

tactic: tauto
state_before: F : Type u
K : Type v
L : Type w
inst✝² : CommRing K
inst✝¹ : Field L
inst✝ : Field F
i : K →+* L
f : K[X]
hf : degree (map i f) = 1
g✝ : L[X]
hg : Irreducible g✝
x✝ : g✝ ∣ map i f
p : L[X]
hp : map i f = g✝ * p
this : degree g✝ = 1 ∧ degree p = 0
⊢ degree g✝ = 1
Theorem: padicValNat_self
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [padicValNat_def (@Fact.out p.Prime).pos]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ padicValNat p p = 1

tactic: simp
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
⊢ Part.get (multiplicity p p) (_ : multiplicity.Finite p p) = 1
Theorem: Polynomial.eval₂_comp
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [comp, p.as_sum_range]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q : R[X]
x✝ : R
inst✝ : CommSemiring S
f : R →+* S
x : S
⊢ eval₂ f x (comp p q) = eval₂ f (eval₂ f x q) p

tactic: simp [eval₂_finset_sum, eval₂_pow]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q : R[X]
x✝ : R
inst✝ : CommSemiring S
f : R →+* S
x : S
⊢ eval₂ f x (eval₂ C q (∑ i in range (natDegree p + 1), ↑(monomial i) (coeff p i))) =
    eval₂ f (eval₂ f x q) (∑ i in range (natDegree p + 1), ↑(monomial i) (coeff p i))
Theorem: Setoid.eqv_classes_of_disjoint_union
File: Mathlib/Data/Setoid/Partition.lean

tactic: rw [hu]
state_before: α : Type u_1
c : Set (Set α)
hu : ⋃₀ c = Set.univ
H : Set.PairwiseDisjoint c id
a : α
⊢ a ∈ ⋃₀ c

tactic: exact Set.mem_univ a
state_before: α : Type u_1
c : Set (Set α)
hu : ⋃₀ c = Set.univ
H : Set.PairwiseDisjoint c id
a : α
⊢ a ∈ Set.univ
Theorem: natCast_mem
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: induction n <;> simp [zero_mem, add_mem, one_mem, *]
state_before: S : Type u_1
R : Type u_2
inst✝² : AddMonoidWithOne R
inst✝¹ : SetLike S R
s : S
inst✝ : AddSubmonoidWithOneClass S R
n : ℕ
⊢ ↑n ∈ s
Theorem: Finsupp.mapDomain_support
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [Finset.biUnion_singleton]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.187796
ι : Type ?u.187799
M : Type u_3
M' : Type ?u.187805
N : Type ?u.187808
P : Type ?u.187811
G : Type ?u.187814
H : Type ?u.187817
R : Type ?u.187820
S : Type ?u.187823
inst✝¹ : AddCommMonoid M
v v₁ v₂ : α →₀ M
inst✝ : DecidableEq β
f : α → β
s : α →₀ M
⊢ (Finset.biUnion s.support fun a => {f a}) ⊆ image f s.support
Theorem: Equiv.Perm.cycleType_eq'
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

tactic: rw [cycleType_def]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
s : Finset (Perm α)
h1 : ∀ (f : Perm α), f ∈ s → IsCycle f
h2 : Set.Pairwise (↑s) Disjoint
h0 : Finset.noncommProd s id (_ : Set.Pairwise ↑s fun a b => Commute (id a) (id b)) = σ
⊢ cycleType σ = map (Finset.card ∘ support) s.val

tactic: congr
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
s : Finset (Perm α)
h1 : ∀ (f : Perm α), f ∈ s → IsCycle f
h2 : Set.Pairwise (↑s) Disjoint
h0 : Finset.noncommProd s id (_ : Set.Pairwise ↑s fun a b => Commute (id a) (id b)) = σ
⊢ map (Finset.card ∘ support) (cycleFactorsFinset σ).val = map (Finset.card ∘ support) s.val

tactic: rw [cycleFactorsFinset_eq_finset]
state_before: case e_s.e_self
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
s : Finset (Perm α)
h1 : ∀ (f : Perm α), f ∈ s → IsCycle f
h2 : Set.Pairwise (↑s) Disjoint
h0 : Finset.noncommProd s id (_ : Set.Pairwise ↑s fun a b => Commute (id a) (id b)) = σ
⊢ cycleFactorsFinset σ = s

tactic: exact ⟨h1, h2, h0⟩
state_before: case e_s.e_self
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
σ : Perm α
s : Finset (Perm α)
h1 : ∀ (f : Perm α), f ∈ s → IsCycle f
h2 : Set.Pairwise (↑s) Disjoint
h0 : Finset.noncommProd s id (_ : Set.Pairwise ↑s fun a b => Commute (id a) (id b)) = σ
⊢ (∀ (f : Perm α), f ∈ s → IsCycle f) ∧
    ∃ h, Finset.noncommProd s id (_ : Set.Pairwise ↑s fun a b => Commute (id a) (id b)) = σ
Theorem: iUnion_Icc_add_int_cast
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simpa only [zsmul_one, Int.cast_add, Int.cast_one, ← add_assoc] using
  iUnion_Icc_add_zsmul zero_lt_one a
state_before: α : Type u_1
inst✝¹ : LinearOrderedRing α
inst✝ : Archimedean α
a : α
⊢ (⋃ (n : ℤ), Icc (a + ↑n) (a + ↑n + 1)) = univ
Theorem: HahnSeries.single_mul_single
File: Mathlib/RingTheory/HahnSeries.lean

tactic: ext x
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
⊢ ↑(single a) r * ↑(single b) s = ↑(single (a + b)) (r * s)

tactic: by_cases h : x = a + b
state_before: case coeff.h
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
x : Γ
⊢ coeff (↑(single a) r * ↑(single b) s) x = coeff (↑(single (a + b)) (r * s)) x

tactic: rw [h, mul_single_coeff_add]
state_before: case pos
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
x : Γ
h : x = a + b
⊢ coeff (↑(single a) r * ↑(single b) s) x = coeff (↑(single (a + b)) (r * s)) x

tactic: simp
state_before: case pos
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
x : Γ
h : x = a + b
⊢ coeff (↑(single a) r) a * s = coeff (↑(single (a + b)) (r * s)) (a + b)

tactic: rw [single_coeff_of_ne h, mul_coeff, sum_eq_zero]
state_before: case neg
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
x : Γ
h : ¬x = a + b
⊢ coeff (↑(single a) r * ↑(single b) s) x = coeff (↑(single (a + b)) (r * s)) x

tactic: simp_rw [mem_addAntidiagonal]
state_before: case neg
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
x : Γ
h : ¬x = a + b
⊢ ∀ (x_1 : Γ × Γ),
    x_1 ∈ addAntidiagonal (_ : Set.IsPwo (support (↑(single a) r))) (_ : Set.IsPwo (support (↑(single b) s))) x →
      coeff (↑(single a) r) x_1.fst * coeff (↑(single b) s) x_1.snd = 0

tactic: rintro ⟨y, z⟩ ⟨hy, hz, rfl⟩
state_before: case neg
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
x : Γ
h : ¬x = a + b
⊢ ∀ (x_1 : Γ × Γ),
    x_1.fst ∈ support (↑(single a) r) ∧ x_1.snd ∈ support (↑(single b) s) ∧ x_1.fst + x_1.snd = x →
      coeff (↑(single a) r) x_1.fst * coeff (↑(single b) s) x_1.snd = 0

tactic: rw [eq_of_mem_support_single hy, eq_of_mem_support_single hz] at h
state_before: case neg.mk.intro.intro
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
y z : Γ
hy : (y, z).fst ∈ support (↑(single a) r)
hz : (y, z).snd ∈ support (↑(single b) s)
h : ¬(y, z).fst + (y, z).snd = a + b
⊢ coeff (↑(single a) r) (y, z).fst * coeff (↑(single b) s) (y, z).snd = 0

tactic: exact (h rfl).elim
state_before: case neg.mk.intro.intro
Γ : Type u_1
R : Type u_2
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : NonUnitalNonAssocSemiring R
a b : Γ
r s : R
y z : Γ
hy : (y, z).fst ∈ support (↑(single a) r)
hz : (y, z).snd ∈ support (↑(single b) s)
h : ¬a + b = a + b
⊢ coeff (↑(single a) r) (y, z).fst * coeff (↑(single b) s) (y, z).snd = 0
Theorem: Cycle.chain_map
File: Mathlib/Data/List/Cycle.lean

tactic: cases' l with a l
state_before: α : Type u_2
β : Type u_1
r : α → α → Prop
f : β → α
s : Cycle β
l : List β
⊢ Chain r (map f (Quotient.mk'' l)) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' l)

tactic: rfl
state_before: case nil
α : Type u_2
β : Type u_1
r : α → α → Prop
f : β → α
s : Cycle β
⊢ Chain r (map f (Quotient.mk'' [])) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' [])

case cons
α : Type u_2
β : Type u_1
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ Chain r (map f (Quotient.mk'' (a :: l))) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' (a :: l))

tactic: dsimp only [Chain, ← mk''_eq_coe, Quotient.liftOn'_mk'', Cycle.map, Quotient.map', Quot.map,
  Quotient.mk'', Quotient.liftOn', Quotient.liftOn, Quot.liftOn_mk, List.map]
state_before: case cons
α : Type u_2
β : Type u_1
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ Chain r (map f (Quotient.mk'' (a :: l))) ↔ Chain (fun a b => r (f a) (f b)) (Quotient.mk'' (a :: l))

tactic: rw [← concat_eq_append, ← List.map_concat, List.chain_map f]
state_before: case cons
α : Type u_2
β : Type u_1
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ List.Chain r (f a) (List.map f l ++ [f a]) ↔ List.Chain (fun a b => r (f a) (f b)) a (l ++ [a])

tactic: simp
state_before: case cons
α : Type u_2
β : Type u_1
r : α → α → Prop
f : β → α
s : Cycle β
a : β
l : List β
⊢ List.Chain (fun a b => r (f a) (f b)) a (concat l a) ↔ List.Chain (fun a b => r (f a) (f b)) a (l ++ [a])
Theorem: Finset.card_image₂_singleton_right
File: Mathlib/Data/Finset/NAry.lean

tactic: rw [image₂_singleton_right, card_image_of_injective _ hf]
state_before: α : Type u_1
α' : Type ?u.51463
β : Type u_3
β' : Type ?u.51469
γ : Type u_2
γ' : Type ?u.51475
δ : Type ?u.51478
δ' : Type ?u.51481
ε : Type ?u.51484
ε' : Type ?u.51487
ζ : Type ?u.51490
ζ' : Type ?u.51493
ν : Type ?u.51496
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
hf : Injective fun a => f a b
⊢ card (image₂ f s {b}) = card s
Theorem: continuousWithinAt_inter
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp [ContinuousWithinAt, nhdsWithin_restrict' s h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.321718
δ : Type ?u.321721
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s t : Set α
x : α
h : t ∈ 𝓝 x
⊢ ContinuousWithinAt f (s ∩ t) x ↔ ContinuousWithinAt f s x
Theorem: SimpleGraph.CliqueFree.mono
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: intro hG s hs
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : m ≤ n
⊢ CliqueFree G m → CliqueFree G n

tactic: obtain ⟨t, hts, ht⟩ := s.exists_smaller_set _ (h.trans hs.card_eq.ge)
state_before: α : Type u_1
G H : SimpleGraph α
m n : ℕ
s✝ : Finset α
h : m ≤ n
hG : CliqueFree G m
s : Finset α
hs : IsNClique G n s
⊢ False

tactic: exact hG _ ⟨hs.clique.subset hts, ht⟩
state_before: case intro.intro
α : Type u_1
G H : SimpleGraph α
m n : ℕ
s✝ : Finset α
h : m ≤ n
hG : CliqueFree G m
s : Finset α
hs : IsNClique G n s
t : Finset α
hts : t ⊆ s
ht : Finset.card t = m
⊢ False
Theorem: closedEmbedding_of_spaced_out
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rcases @DiscreteTopology.eq_bot α _ _ with rfl
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁵ : UniformSpace α✝
inst✝⁴ : UniformSpace β
inst✝³ : UniformSpace γ
α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : DiscreteTopology α
inst✝ : SeparatedSpace β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => ¬(f x, f y) ∈ s
⊢ ClosedEmbedding f

tactic: let _ : UniformSpace α := ⊥
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : SeparatedSpace β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => ¬(f x, f y) ∈ s
inst✝ : DiscreteTopology α
⊢ ClosedEmbedding f

tactic: exact
  { (uniformEmbedding_of_spaced_out hs hf).embedding with
    closed_range := isClosed_range_of_spaced_out hs hf }
state_before: α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : SeparatedSpace β
f : α → β
s : Set (β × β)
hs : s ∈ 𝓤 β
hf : Pairwise fun x y => ¬(f x, f y) ∈ s
inst✝ : DiscreteTopology α
x✝ : UniformSpace α := ⊥
⊢ ClosedEmbedding f
Theorem: PartENat.toWithTop_zero'
File: Mathlib/Data/Nat/PartENat.lean

tactic: convert toWithTop_zero
state_before: h : Decidable 0.Dom
⊢ toWithTop 0 = 0
Theorem: SimpleGraph.dart_edge_eq_iff
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: rintro ⟨p, hp⟩ ⟨q, hq⟩
state_before: ι : Sort ?u.97949
𝕜 : Type ?u.97952
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
⊢ ∀ (d₁ d₂ : Dart G), Dart.edge d₁ = Dart.edge d₂ ↔ d₁ = d₂ ∨ d₁ = Dart.symm d₂

tactic: simp [Sym2.mk''_eq_mk''_iff, -Quotient.eq]
state_before: case mk.mk
ι : Sort ?u.97949
𝕜 : Type ?u.97952
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
p : V × V
hp : Adj G p.fst p.snd
q : V × V
hq : Adj G q.fst q.snd
⊢ Dart.edge { toProd := p, is_adj := hp } = Dart.edge { toProd := q, is_adj := hq } ↔
    { toProd := p, is_adj := hp } = { toProd := q, is_adj := hq } ∨
      { toProd := p, is_adj := hp } = Dart.symm { toProd := q, is_adj := hq }
Theorem: le_one_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using le_inv ha hb
state_before: ι : Type ?u.79768
α : Type u_1
β : Type ?u.79774
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ a ≤ 1 / b ↔ b ≤ 1 / a
Theorem: PrimeMultiset.prod_ofPNatMultiset
File: Mathlib/Data/PNat/Factors.lean

tactic: dsimp [prod]
state_before: v : Multiset ℕ+
h : ∀ (p : ℕ+), p ∈ v → PNat.Prime p
⊢ prod (ofPNatMultiset v h) = Multiset.prod v

tactic: rw [to_ofPNatMultiset]
state_before: v : Multiset ℕ+
h : ∀ (p : ℕ+), p ∈ v → PNat.Prime p
⊢ Multiset.prod (toPNatMultiset (ofPNatMultiset v h)) = Multiset.prod v
Theorem: ENNReal.coe_essSup
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: simp [essSup, limsup, limsSup, eventually_map, ENNReal.forall_ennreal]
state_before: α : Type u_1
β : Type ?u.5738175
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
f✝ : α → ℝ≥0∞
f : α → ℝ≥0
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) f
r : ℝ≥0∞
⊢ (r ≤
      ⨅ (a : ℝ≥0) (_ : a ∈ fun x => sets (map f (Measure.ae μ)) {x_1 | (fun x_2 => (fun x x_3 => x ≤ x_3) x_2 x) x_1}),
        ↑a) ↔
    r ≤ essSup (fun x => ↑(f x)) μ

tactic: rfl
state_before: α : Type u_1
β : Type ?u.5738175
m : MeasurableSpace α
μ ν : MeasureTheory.Measure α
f✝ : α → ℝ≥0∞
f : α → ℝ≥0
hf : IsBoundedUnder (fun x x_1 => x ≤ x_1) (Measure.ae μ) f
r : ℝ≥0∞
⊢ (∀ (i : ℝ≥0), (i ∈ fun x => sets (map f (Measure.ae μ)) {x_1 | x_1 ≤ x}) → r ≤ ↑i) ↔
    ∀ (r_1 : ℝ≥0), (∀ᵐ (a : α) ∂μ, f a ≤ r_1) → r ≤ ↑r_1
Theorem: summable_geometric_iff_norm_lt_1
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: refine' ⟨fun h ↦ _, summable_geometric_of_norm_lt_1⟩
state_before: α : Type ?u.147129
β : Type ?u.147132
ι : Type ?u.147135
K : Type u_1
inst✝ : NormedField K
ξ : K
⊢ (Summable fun n => ξ ^ n) ↔ ‖ξ‖ < 1

tactic: obtain ⟨k : ℕ, hk : dist (ξ ^ k) 0 < 1⟩ :=
  (h.tendsto_cofinite_zero.eventually (ball_mem_nhds _ zero_lt_one)).exists
state_before: α : Type ?u.147129
β : Type ?u.147132
ι : Type ?u.147135
K : Type u_1
inst✝ : NormedField K
ξ : K
h : Summable fun n => ξ ^ n
⊢ ‖ξ‖ < 1

tactic: simp only [norm_pow, dist_zero_right] at hk
state_before: case intro
α : Type ?u.147129
β : Type ?u.147132
ι : Type ?u.147135
K : Type u_1
inst✝ : NormedField K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : dist (ξ ^ k) 0 < 1
⊢ ‖ξ‖ < 1

tactic: rw [← one_pow k] at hk
state_before: case intro
α : Type ?u.147129
β : Type ?u.147132
ι : Type ?u.147135
K : Type u_1
inst✝ : NormedField K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : ‖ξ‖ ^ k < 1
⊢ ‖ξ‖ < 1

tactic: exact lt_of_pow_lt_pow _ zero_le_one hk
state_before: case intro
α : Type ?u.147129
β : Type ?u.147132
ι : Type ?u.147135
K : Type u_1
inst✝ : NormedField K
ξ : K
h : Summable fun n => ξ ^ n
k : ℕ
hk : ‖ξ‖ ^ k < 1 ^ k
⊢ ‖ξ‖ < 1
Theorem: MeasureTheory.L1.dist_def
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [Lp.dist_def, snorm, snorm']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1291582
δ : Type ?u.1291585
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : { x // x ∈ Lp β 1 }
⊢ dist f g = ENNReal.toReal (∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ)

tactic: simp [edist_eq_coe_nnnorm_sub]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.1291582
δ : Type ?u.1291585
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g : { x // x ∈ Lp β 1 }
⊢ ENNReal.toReal (∫⁻ (a : α), ↑‖↑↑f a - ↑↑g a‖₊ ∂μ) = ENNReal.toReal (∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ)
Theorem: LocallyConstant.exists_eq_const
File: Mathlib/Topology/LocallyConstant/Basic.lean

tactic: rcases Classical.em (Nonempty X) with (⟨⟨x⟩⟩ | hX)
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.24519
α : Type ?u.24522
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : LocallyConstant X Y
⊢ ∃ y, f = const X y

tactic: exact ⟨f x, f.eq_const x⟩
state_before: case inl.intro
X : Type u_1
Y : Type u_2
Z : Type ?u.24519
α : Type ?u.24522
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : LocallyConstant X Y
x : X
⊢ ∃ y, f = const X y

tactic: exact ⟨Classical.arbitrary Y, ext fun x => (hX ⟨x⟩).elim⟩
state_before: case inr
X : Type u_1
Y : Type u_2
Z : Type ?u.24519
α : Type ?u.24522
inst✝² : TopologicalSpace X
inst✝¹ : PreconnectedSpace X
inst✝ : Nonempty Y
f : LocallyConstant X Y
hX : ¬Nonempty X
⊢ ∃ y, f = const X y
Theorem: dite_eq_right_iff
File: Mathlib/Logic/Basic.lean

tactic: by_cases P <;> simp [*, forall_prop_of_true, forall_prop_of_false]
state_before: α : Sort u_1
β : Sort ?u.34692
σ : α → Sort ?u.34688
f : α → β
P Q : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (dite P A fun x => b) = b ↔ ∀ (h : P), A h = b
Theorem: Matrix.det_isEmpty
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: simp [det_apply]
state_before: m : Type ?u.172043
n : Type u_1
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
R : Type v
inst✝¹ : CommRing R
inst✝ : IsEmpty n
A : Matrix n n R
⊢ det A = 1
Theorem: TypeVec.Arrow.ext
File: Mathlib/Data/TypeVec.lean

tactic: intro h
state_before: n : ℕ
α : TypeVec n
β : TypeVec n
f g : α ⟹ β
⊢ (∀ (i : Fin2 n), f i = g i) → f = g

tactic: funext i
state_before: n : ℕ
α : TypeVec n
β : TypeVec n
f g : α ⟹ β
h : ∀ (i : Fin2 n), f i = g i
⊢ f = g

tactic: apply h
state_before: case h
n : ℕ
α : TypeVec n
β : TypeVec n
f g : α ⟹ β
h : ∀ (i : Fin2 n), f i = g i
i : Fin2 n
⊢ f i = g i