tasksource/leandojo huggingface dataset:
Theorem: Equiv.Perm.list_cycles_perm_list_cycles
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: refine'
  (List.perm_ext (nodup_of_pairwise_disjoint_cycles h₁l₁ h₂l₁)
        (nodup_of_pairwise_disjoint_cycles h₁l₂ h₂l₂)).mpr
    fun σ => _
state_before: ι : Type ?u.2673155
α✝ : Type ?u.2673158
β : Type ?u.2673161
inst✝¹ : DecidableEq α✝
α : Type u_1
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : List.prod l₁ = List.prod l₂
h₁l₁ : ∀ (σ : Perm α), σ ∈ l₁ → IsCycle σ
h₁l₂ : ∀ (σ : Perm α), σ ∈ l₂ → IsCycle σ
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
⊢ l₁ ~ l₂

tactic: by_cases hσ : σ.IsCycle
state_before: ι : Type ?u.2673155
α✝ : Type ?u.2673158
β : Type ?u.2673161
inst✝¹ : DecidableEq α✝
α : Type u_1
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : List.prod l₁ = List.prod l₂
h₁l₁ : ∀ (σ : Perm α), σ ∈ l₁ → IsCycle σ
h₁l₂ : ∀ (σ : Perm α), σ ∈ l₂ → IsCycle σ
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
⊢ σ ∈ l₁ ↔ σ ∈ l₂

tactic: obtain _ := not_forall.mp (mt ext hσ.ne_one)
state_before: case pos
ι : Type ?u.2673155
α✝ : Type ?u.2673158
β : Type ?u.2673161
inst✝¹ : DecidableEq α✝
α : Type u_1
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : List.prod l₁ = List.prod l₂
h₁l₁ : ∀ (σ : Perm α), σ ∈ l₁ → IsCycle σ
h₁l₂ : ∀ (σ : Perm α), σ ∈ l₂ → IsCycle σ
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : IsCycle σ
⊢ σ ∈ l₁ ↔ σ ∈ l₂

tactic: rw [mem_list_cycles_iff h₁l₁ h₂l₁, mem_list_cycles_iff h₁l₂ h₂l₂, h₀]
state_before: case pos
ι : Type ?u.2673155
α✝ : Type ?u.2673158
β : Type ?u.2673161
inst✝¹ : DecidableEq α✝
α : Type u_1
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : List.prod l₁ = List.prod l₂
h₁l₁ : ∀ (σ : Perm α), σ ∈ l₁ → IsCycle σ
h₁l₂ : ∀ (σ : Perm α), σ ∈ l₂ → IsCycle σ
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : IsCycle σ
x✝ : ∃ x, ¬↑σ x = ↑1 x
⊢ σ ∈ l₁ ↔ σ ∈ l₂

tactic: exact iff_of_false (mt (h₁l₁ σ) hσ) (mt (h₁l₂ σ) hσ)
state_before: case neg
ι : Type ?u.2673155
α✝ : Type ?u.2673158
β : Type ?u.2673161
inst✝¹ : DecidableEq α✝
α : Type u_1
inst✝ : Finite α
l₁ l₂ : List (Perm α)
h₀ : List.prod l₁ = List.prod l₂
h₁l₁ : ∀ (σ : Perm α), σ ∈ l₁ → IsCycle σ
h₁l₂ : ∀ (σ : Perm α), σ ∈ l₂ → IsCycle σ
h₂l₁ : List.Pairwise Disjoint l₁
h₂l₂ : List.Pairwise Disjoint l₂
σ : Perm α
hσ : ¬IsCycle σ
⊢ σ ∈ l₁ ↔ σ ∈ l₂
Theorem: MeasureTheory.lintegral_norm_eq_lintegral_edist
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [ofReal_norm_eq_coe_nnnorm, edist_eq_coe_nnnorm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.688837
δ : Type ?u.688840
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ (∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ) = ∫⁻ (a : α), edist (f a) 0 ∂μ
Theorem: exists_finite_card_le_of_finite_of_linearIndependent_of_span
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp
state_before: ι : Type u'
ι' : Type ?u.1312198
R : Type ?u.1312201
K : Type u_1
M : Type ?u.1312207
M' : Type ?u.1312210
M'' : Type ?u.1312213
V : Type u
V' : Type ?u.1312218
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
ht : Set.Finite t
hs : LinearIndependent K fun x => ↑x
hst : s ⊆ ↑(span K t)
⊢ s ⊆ ↑(span K ↑(Finite.toFinset ht))

tactic: assumption
state_before: ι : Type u'
ι' : Type ?u.1312198
R : Type ?u.1312201
K : Type u_1
M : Type ?u.1312207
M' : Type ?u.1312210
M'' : Type ?u.1312213
V : Type u
V' : Type ?u.1312218
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
ht : Set.Finite t
hs : LinearIndependent K fun x => ↑x
hst : s ⊆ ↑(span K t)
⊢ s ⊆ ↑(span K t)

tactic: rw [← Eq]
state_before: ι : Type u'
ι' : Type ?u.1312198
R : Type ?u.1312201
K : Type u_1
M : Type ?u.1312207
M' : Type ?u.1312210
M'' : Type ?u.1312213
V : Type u
V' : Type ?u.1312218
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
ht : Set.Finite t
hs : LinearIndependent K fun x => ↑x
hst : s ⊆ ↑(span K t)
this✝ : s ⊆ ↑(span K ↑(Finite.toFinset ht))
u : Finset V
_hust : ↑u ⊆ s ∪ ↑(Finite.toFinset ht)
hsu : s ⊆ ↑u
Eq : Finset.card u = Finset.card (Finite.toFinset ht)
this : Set.Finite s
⊢ Finset.card (Finite.toFinset this) ≤ Finset.card (Finite.toFinset ht)

tactic: exact Finset.card_le_of_subset <| Finset.coe_subset.mp <| by simp [hsu]
state_before: ι : Type u'
ι' : Type ?u.1312198
R : Type ?u.1312201
K : Type u_1
M : Type ?u.1312207
M' : Type ?u.1312210
M'' : Type ?u.1312213
V : Type u
V' : Type ?u.1312218
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
ht : Set.Finite t
hs : LinearIndependent K fun x => ↑x
hst : s ⊆ ↑(span K t)
this✝ : s ⊆ ↑(span K ↑(Finite.toFinset ht))
u : Finset V
_hust : ↑u ⊆ s ∪ ↑(Finite.toFinset ht)
hsu : s ⊆ ↑u
Eq : Finset.card u = Finset.card (Finite.toFinset ht)
this : Set.Finite s
⊢ Finset.card (Finite.toFinset this) ≤ Finset.card u

tactic: simp [hsu]
state_before: ι : Type u'
ι' : Type ?u.1312198
R : Type ?u.1312201
K : Type u_1
M : Type ?u.1312207
M' : Type ?u.1312210
M'' : Type ?u.1312213
V : Type u
V' : Type ?u.1312218
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x y z : V
ht : Set.Finite t
hs : LinearIndependent K fun x => ↑x
hst : s ⊆ ↑(span K t)
this✝ : s ⊆ ↑(span K ↑(Finite.toFinset ht))
u : Finset V
_hust : ↑u ⊆ s ∪ ↑(Finite.toFinset ht)
hsu : s ⊆ ↑u
Eq : Finset.card u = Finset.card (Finite.toFinset ht)
this : Set.Finite s
⊢ ↑(Finite.toFinset this) ⊆ ↑u
Theorem: bot_bihimp
File: Mathlib/Order/SymmDiff.lean

tactic: simp [bihimp]
state_before: ι : Type ?u.57742
α : Type u_1
β : Type ?u.57748
π : ι → Type ?u.57753
inst✝ : HeytingAlgebra α
a : α
⊢ ⊥ ⇔ a = aᶜ
Theorem: mul_lt_iff_lt_one_left
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rw [one_mul]
state_before: α : Type u_1
a b c d : α
inst✝⁴ : MulOneClass α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : MulPosStrictMono α
inst✝ : MulPosReflectLT α
b0 : 0 < b
⊢ a * b < b ↔ a * b < 1 * b
Theorem: Set.pairwise_sUnion
File: Mathlib/Data/Set/Pairwise/Lattice.lean

tactic: rw [sUnion_eq_iUnion, pairwise_iUnion h.directed_val, SetCoe.forall]
state_before: α : Type u_1
β : Type ?u.513
γ : Type ?u.516
ι : Type ?u.519
ι' : Type ?u.522
r✝ p q : α → α → Prop
f g : ι → α
s✝ t u : Set α
a b : α
r : α → α → Prop
s : Set (Set α)
h : DirectedOn (fun x x_1 => x ⊆ x_1) s
⊢ Set.Pairwise (⋃₀ s) r ↔ ∀ (a : Set α), a ∈ s → Set.Pairwise a r
Theorem: Associates.finprod_ne_zero
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: rw [Associates.mk_ne_zero, finprod_def]
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.240355
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
⊢ Associates.mk (∏ᶠ (v : HeightOneSpectrum R), maxPowDividing v I) ≠ 0

tactic: split_ifs
state_before: R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.240355
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
⊢ (if h : Set.Finite (mulSupport fun v => maxPowDividing v I) then ∏ i in Finite.toFinset h, maxPowDividing i I
    else 1) ≠
    0

tactic: rw [Finset.prod_ne_zero_iff]
state_before: case inl
R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.240355
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
h✝ : Set.Finite (mulSupport fun v => maxPowDividing v I)
⊢ ∏ v in Finite.toFinset h✝, maxPowDividing v I ≠ 0

tactic: intro v _
state_before: case inl
R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.240355
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
h✝ : Set.Finite (mulSupport fun v => maxPowDividing v I)
⊢ ∀ (a : HeightOneSpectrum R), a ∈ Finite.toFinset h✝ → maxPowDividing a I ≠ 0

tactic: apply pow_ne_zero _ v.ne_bot
state_before: case inl
R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.240355
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v✝ : HeightOneSpectrum R
I : Ideal R
h✝ : Set.Finite (mulSupport fun v => maxPowDividing v I)
v : HeightOneSpectrum R
a✝ : v ∈ Finite.toFinset h✝
⊢ maxPowDividing v I ≠ 0

tactic: exact one_ne_zero
state_before: case inr
R : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
inst✝³ : IsDedekindDomain R
K : Type ?u.240355
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
v : HeightOneSpectrum R
I : Ideal R
h✝ : ¬Set.Finite (mulSupport fun v => maxPowDividing v I)
⊢ 1 ≠ 0
Theorem: partialSups_eq_sup_range
File: Mathlib/Order/PartialSups.lean

tactic: induction' n with n ih
state_before: α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
f : ℕ → α
n : ℕ
⊢ ↑(partialSups f) n = Finset.sup (Finset.range (n + 1)) f

tactic: simp
state_before: case zero
α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
f : ℕ → α
⊢ ↑(partialSups f) Nat.zero = Finset.sup (Finset.range (Nat.zero + 1)) f

tactic: dsimp [partialSups] at ih⊢
state_before: case succ
α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
f : ℕ → α
n : ℕ
ih : ↑(partialSups f) n = Finset.sup (Finset.range (n + 1)) f
⊢ ↑(partialSups f) (Nat.succ n) = Finset.sup (Finset.range (Nat.succ n + 1)) f

tactic: rw [Finset.range_succ, Finset.sup_insert, sup_comm, ih]
state_before: case succ
α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
f : ℕ → α
n : ℕ
ih : Nat.rec (f 0) (fun n a => a ⊔ f (n + 1)) n = Finset.sup (Finset.range (n + 1)) f
⊢ Nat.rec (f 0) (fun n a => a ⊔ f (n + 1)) n ⊔ f (n + 1) = Finset.sup (Finset.range (Nat.succ n + 1)) f
Theorem: Associates.count_mul
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: obtain ⟨a0, nza, ha'⟩ := exists_non_zero_rep ha
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a : Associates α
ha : a ≠ 0
b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
⊢ count p (factors (a * b)) = count p (factors a) + count p (factors b)

tactic: obtain ⟨b0, nzb, hb'⟩ := exists_non_zero_rep hb
state_before: case intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a : Associates α
ha : a ≠ 0
b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
a0 : α
nza : a0 ≠ 0
ha' : Associates.mk a0 = a
⊢ count p (factors (a * b)) = count p (factors a) + count p (factors b)

tactic: rw [factors_mul, ← ha', ← hb', factors_mk a0 nza, factors_mk b0 nzb, ← FactorSet.coe_add, ←
  WithTop.some_eq_coe, ← WithTop.some_eq_coe, ← WithTop.some_eq_coe, count_some hp,
  Multiset.count_add, count_some hp, count_some hp]
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
a : Associates α
ha : a ≠ 0
b : Associates α
hb : b ≠ 0
p : Associates α
hp : Irreducible p
a0 : α
nza : a0 ≠ 0
ha' : Associates.mk a0 = a
b0 : α
nzb : b0 ≠ 0
hb' : Associates.mk b0 = b
⊢ count p (factors (a * b)) = count p (factors a) + count p (factors b)
Theorem: Set.iInter_iInter_eq'
File: Mathlib/Data/Set/Lattice.lean

tactic: simpa using biInter_range
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.210965
ι : Sort u_3
ι' : Sort ?u.210971
ι₂ : Sort ?u.210974
κ : ι → Sort ?u.210979
κ₁ : ι → Sort ?u.210984
κ₂ : ι → Sort ?u.210989
κ' : ι' → Sort ?u.210994
f : ι → α
g : α → Set β
⊢ (⋂ (x : α) (y : ι) (_ : f y = x), g x) = ⋂ (y : ι), g (f y)
Theorem: Finset.disjoint_erase_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: simp_rw [erase_eq, disjoint_sdiff_comm]
state_before: α : Type u_1
β : Type ?u.245796
γ : Type ?u.245799
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
⊢ _root_.Disjoint (erase s a) t ↔ _root_.Disjoint s (erase t a)
Theorem: lt_one_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using lt_inv ha hb
state_before: ι : Type ?u.81079
α : Type u_1
β : Type ?u.81085
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ a < 1 / b ↔ b < 1 / a
Theorem: FreeAbelianGroup.support_neg
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

tactic: simp only [support, AddMonoidHom.map_neg, Finsupp.support_neg]
state_before: X : Type u_1
a : FreeAbelianGroup X
⊢ support (-a) = support a
Theorem: Complex.sin_sub_sin
File: Mathlib/Data/Complex/Exponential.lean

tactic: have s1 := sin_add ((x + y) / 2) ((x - y) / 2)
state_before: x y : ℂ
⊢ sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2)

tactic: have s2 := sin_sub ((x + y) / 2) ((x - y) / 2)
state_before: x y : ℂ
s1 : sin ((x + y) / 2 + (x - y) / 2) = sin ((x + y) / 2) * cos ((x - y) / 2) + cos ((x + y) / 2) * sin ((x - y) / 2)
⊢ sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2)

tactic: rw [div_add_div_same, add_sub, add_right_comm, add_sub_cancel, half_add_self] at s1
state_before: x y : ℂ
s1 : sin ((x + y) / 2 + (x - y) / 2) = sin ((x + y) / 2) * cos ((x - y) / 2) + cos ((x + y) / 2) * sin ((x - y) / 2)
s2 : sin ((x + y) / 2 - (x - y) / 2) = sin ((x + y) / 2) * cos ((x - y) / 2) - cos ((x + y) / 2) * sin ((x - y) / 2)
⊢ sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2)

tactic: rw [div_sub_div_same, ← sub_add, add_sub_cancel', half_add_self] at s2
state_before: x y : ℂ
s1 : sin x = sin ((x + y) / 2) * cos ((x - y) / 2) + cos ((x + y) / 2) * sin ((x - y) / 2)
s2 : sin ((x + y) / 2 - (x - y) / 2) = sin ((x + y) / 2) * cos ((x - y) / 2) - cos ((x + y) / 2) * sin ((x - y) / 2)
⊢ sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2)

tactic: rw [s1, s2]
state_before: x y : ℂ
s1 : sin x = sin ((x + y) / 2) * cos ((x - y) / 2) + cos ((x + y) / 2) * sin ((x - y) / 2)
s2 : sin y = sin ((x + y) / 2) * cos ((x - y) / 2) - cos ((x + y) / 2) * sin ((x - y) / 2)
⊢ sin x - sin y = 2 * sin ((x - y) / 2) * cos ((x + y) / 2)

tactic: ring
state_before: x y : ℂ
s1 : sin x = sin ((x + y) / 2) * cos ((x - y) / 2) + cos ((x + y) / 2) * sin ((x - y) / 2)
s2 : sin y = sin ((x + y) / 2) * cos ((x - y) / 2) - cos ((x + y) / 2) * sin ((x - y) / 2)
⊢ sin ((x + y) / 2) * cos ((x - y) / 2) + cos ((x + y) / 2) * sin ((x - y) / 2) -
      (sin ((x + y) / 2) * cos ((x - y) / 2) - cos ((x + y) / 2) * sin ((x - y) / 2)) =
    2 * sin ((x - y) / 2) * cos ((x + y) / 2)
Theorem: Finset.card_sdiff_add_card
File: Mathlib/Data/Finset/Card.lean

tactic: rw [← card_disjoint_union sdiff_disjoint, sdiff_union_self_eq_union]
state_before: α : Type u_1
β : Type ?u.41772
s t : Finset α
f : α → β
n : ℕ
inst✝ : DecidableEq α
⊢ card (s \ t) + card t = card (s ∪ t)
Theorem: Finset.mem_map_equiv
File: Mathlib/Data/Finset/Image.lean

tactic: rw [mem_map]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3584
f✝ : α ↪ β
s : Finset α
f : α ≃ β
b : β
⊢ b ∈ map (Equiv.toEmbedding f) s ↔ ↑f.symm b ∈ s

tactic: exact
  ⟨by
    rintro ⟨a, H, rfl⟩
    simpa, fun h => ⟨_, h, by simp⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3584
f✝ : α ↪ β
s : Finset α
f : α ≃ β
b : β
⊢ (∃ a, a ∈ s ∧ ↑(Equiv.toEmbedding f) a = b) ↔ ↑f.symm b ∈ s

tactic: rintro ⟨a, H, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3584
f✝ : α ↪ β
s : Finset α
f : α ≃ β
b : β
⊢ (∃ a, a ∈ s ∧ ↑(Equiv.toEmbedding f) a = b) → ↑f.symm b ∈ s

tactic: simpa
state_before: case intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.3584
f✝ : α ↪ β
s : Finset α
f : α ≃ β
a : α
H : a ∈ s
⊢ ↑f.symm (↑(Equiv.toEmbedding f) a) ∈ s

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.3584
f✝ : α ↪ β
s : Finset α
f : α ≃ β
b : β
h : ↑f.symm b ∈ s
⊢ ↑(Equiv.toEmbedding f) (↑f.symm b) = b
Theorem: EMetric.isOpen_iff
File: Mathlib/Topology/MetricSpace/EMetricSpace.lean

tactic: simp [isOpen_iff_nhds, mem_nhds_iff]
state_before: α : Type u
β : Type v
X : Type ?u.209202
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ IsOpen s ↔ ∀ (x : α), x ∈ s → ∃ ε, ε > 0 ∧ ball x ε ⊆ s
Theorem: Polynomial.natDegree_bit1
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: simp [natDegree_bit0]
state_before: R : Type u
S : Type v
ι : Type w
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q r a : R[X]
⊢ max (natDegree (bit0 a)) (natDegree 1) ≤ natDegree a
Theorem: Finite.exists_max
File: Mathlib/Data/Fintype/Lattice.lean

tactic: cases nonempty_fintype α
state_before: α : Type u_1
β : Type u_2
inst✝² : Finite α
inst✝¹ : Nonempty α
inst✝ : LinearOrder β
f : α → β
⊢ ∃ x₀, ∀ (x : α), f x ≤ f x₀

tactic: simpa using exists_max_image univ f univ_nonempty
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : Finite α
inst✝¹ : Nonempty α
inst✝ : LinearOrder β
f : α → β
val✝ : Fintype α
⊢ ∃ x₀, ∀ (x : α), f x ≤ f x₀
Theorem: CategoryTheory.Limits.image.map_id
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: congr
state_before: C : Type u
inst✝⁴ : Category C
f g : Arrow C
inst✝³ : HasImage f.hom
inst✝² : HasImage g.hom
sq : f ⟶ g
inst✝¹ : HasImageMap sq
inst✝ : HasImageMap (𝟙 f)
⊢ (HasImageMap.imageMap (𝟙 f)).map = (imageMapId f).map

tactic: simp only [eq_iff_true_of_subsingleton]
state_before: case e_self
C : Type u
inst✝⁴ : Category C
f g : Arrow C
inst✝³ : HasImage f.hom
inst✝² : HasImage g.hom
sq : f ⟶ g
inst✝¹ : HasImageMap sq
inst✝ : HasImageMap (𝟙 f)
⊢ HasImageMap.imageMap (𝟙 f) = imageMapId f
Theorem: tendsto_int_cast_atTop_iff
File: Mathlib/Order/Filter/Archimedean.lean

tactic: rw [← @Int.comap_cast_atTop R, tendsto_comap_iff]
state_before: α : Type u_2
R : Type u_1
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
f : α → ℤ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atTop ↔ Tendsto f l atTop

tactic: rfl
state_before: α : Type u_2
R : Type u_1
inst✝¹ : StrictOrderedRing R
inst✝ : Archimedean R
f : α → ℤ
l : Filter α
⊢ Tendsto (fun n => ↑(f n)) l atTop ↔ Tendsto (Int.cast ∘ f) l atTop
Theorem: CauSeq.limZero_congr
File: Mathlib/Data/Real/CauSeq.lean

tactic: simpa using add_limZero (Setoid.symm h) l
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
h : f ≈ g
l : LimZero f
⊢ LimZero g

tactic: simpa using add_limZero h l
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
h : f ≈ g
l : LimZero g
⊢ LimZero f
Theorem: Polynomial.eval_smul
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [← smul_one_smul R s p, eval, eval₂_smul, RingHom.id_apply, smul_one_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝³ : Semiring R
p✝ q r : R[X]
x✝ : R
inst✝² : Monoid S
inst✝¹ : DistribMulAction S R
inst✝ : IsScalarTower S R R
s : S
p : R[X]
x : R
⊢ eval x (s • p) = s • eval x p
Theorem: Padic.AddValuation.map_add
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp only [addValuationDef]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
⊢ min (addValuationDef x) (addValuationDef y) ≤ addValuationDef (x + y)

tactic: by_cases hxy : x + y = 0
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤
    if x + y = 0 then ⊤ else ↑(valuation (x + y))

tactic: rw [hxy, if_pos (Eq.refl _)]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : x + y = 0
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤
    if x + y = 0 then ⊤ else ↑(valuation (x + y))

tactic: exact le_top
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : x + y = 0
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤ ⊤

tactic: by_cases hx : x = 0
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤
    if x + y = 0 then ⊤ else ↑(valuation (x + y))

tactic: rw [hx, if_pos (Eq.refl _), min_eq_right, zero_add]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
hx : x = 0
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤
    if x + y = 0 then ⊤ else ↑(valuation (x + y))

tactic: exact le_top
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
hx : x = 0
⊢ (if y = 0 then ⊤ else ↑(valuation y)) ≤ ⊤

tactic: by_cases hy : y = 0
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
hx : ¬x = 0
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤
    if x + y = 0 then ⊤ else ↑(valuation (x + y))

tactic: rw [hy, if_pos (Eq.refl _), min_eq_left, add_zero]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
hx : ¬x = 0
hy : y = 0
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤
    if x + y = 0 then ⊤ else ↑(valuation (x + y))

tactic: exact le_top
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
hx : ¬x = 0
hy : y = 0
⊢ (if x = 0 then ⊤ else ↑(valuation x)) ≤ ⊤

tactic: rw [if_neg hx, if_neg hy, if_neg hxy, ← WithTop.coe_min, WithTop.coe_le_coe]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
hx : ¬x = 0
hy : ¬y = 0
⊢ min (if x = 0 then ⊤ else ↑(valuation x)) (if y = 0 then ⊤ else ↑(valuation y)) ≤
    if x + y = 0 then ⊤ else ↑(valuation (x + y))

tactic: exact valuation_map_add hxy
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hxy : ¬x + y = 0
hx : ¬x = 0
hy : ¬y = 0
⊢ min (valuation x) (valuation y) ≤ valuation (x + y)
Theorem: Real.contDiffOn_log
File: Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean

tactic: suffices : ContDiffOn ℝ ⊤ log ({0}ᶜ)
state_before: x : ℝ
n : ℕ∞
⊢ ContDiffOn ℝ n log ({0}ᶜ)

tactic: exact this.of_le le_top
state_before: x : ℝ
n : ℕ∞
this : ContDiffOn ℝ ⊤ log ({0}ᶜ)
⊢ ContDiffOn ℝ n log ({0}ᶜ)

case this
x : ℝ
n : ℕ∞
⊢ ContDiffOn ℝ ⊤ log ({0}ᶜ)

tactic: refine' (contDiffOn_top_iff_deriv_of_open isOpen_compl_singleton).2 _
state_before: case this
x : ℝ
n : ℕ∞
⊢ ContDiffOn ℝ ⊤ log ({0}ᶜ)

tactic: simp [differentiableOn_log, contDiffOn_inv]
state_before: case this
x : ℝ
n : ℕ∞
⊢ DifferentiableOn ℝ log ({0}ᶜ) ∧ ContDiffOn ℝ ⊤ (deriv log) ({0}ᶜ)
Theorem: Int.zero_fmod
File: Std/Data/Int/DivMod.lean

tactic: cases b <;> rfl
state_before: b : Int
⊢ fmod 0 b = 0