tasksource/leandojo huggingface dataset:
Theorem: Ideal.mul_bot
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp
state_before: R : Type u
ι : Type ?u.284117
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ I * ⊥ = ⊥
Theorem: Submonoid.LocalizationMap.mk'_mul_cancel_right
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [← mul_mk'_one_eq_mk', f.toMap.map_mul, mul_assoc, mul_mk'_one_eq_mk', mk'_self', mul_one]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type ?u.946305
inst✝ : CommMonoid P
f : LocalizationMap S N
x : M
y : { x // x ∈ S }
⊢ mk' f (x * ↑y) y = ↑(toMap f) x
Theorem: Finset.sum_weightedVSubVSubWeights
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp_rw [weightedVSubVSubWeights, Pi.sub_apply, sum_sub_distrib]
state_before: k : Type u_2
V : Type ?u.425950
P : Type ?u.425953
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.426609
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
hi : i ∈ s
hj : j ∈ s
⊢ ∑ t in s, weightedVSubVSubWeights k i j t = 0

tactic: simp [hi, hj]
state_before: k : Type u_2
V : Type ?u.425950
P : Type ?u.425953
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_1
s : Finset ι
ι₂ : Type ?u.426609
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
hi : i ∈ s
hj : j ∈ s
⊢ ∑ x in s, affineCombinationSingleWeights k i x - ∑ x in s, affineCombinationSingleWeights k j x = 0
Theorem: Ordinal.sup_typein_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← succ_eq_succ_iff, h]
state_before: case inr
α : Type ?u.345179
β : Type ?u.345182
γ : Type ?u.345185
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : succ (sup (typein fun x x_1 => x < x_1)) = lsub (typein fun x x_1 => x < x_1)
⊢ sup (typein fun x x_1 => x < x_1) = o

tactic: apply lsub_typein
state_before: case inr
α : Type ?u.345179
β : Type ?u.345182
γ : Type ?u.345185
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : succ (sup (typein fun x x_1 => x < x_1)) = lsub (typein fun x x_1 => x < x_1)
⊢ lsub (typein fun x x_1 => x < x_1) = succ o

tactic: rw [sup_eq_lsub_iff_succ] at h
state_before: case inl
α : Type ?u.345179
β : Type ?u.345182
γ : Type ?u.345185
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : sup (typein fun x x_1 => x < x_1) = lsub (typein fun x x_1 => x < x_1)
⊢ sup (typein fun x x_1 => x < x_1) = o

tactic: simp only [lsub_typein] at h
state_before: case inl
α : Type ?u.345179
β : Type ?u.345182
γ : Type ?u.345185
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : ∀ (a : Ordinal), a < lsub (typein fun x x_1 => x < x_1) → succ a < lsub (typein fun x x_1 => x < x_1)
⊢ sup (typein fun x x_1 => x < x_1) = o

tactic: exact (h o (lt_succ o)).false.elim
state_before: case inl
α : Type ?u.345179
β : Type ?u.345182
γ : Type ?u.345185
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : ∀ (a : Ordinal), a < succ o → succ a < succ o
⊢ sup (typein fun x x_1 => x < x_1) = o
Theorem: FreeGroup.map.id
File: Mathlib/GroupTheory/FreeGroup.lean

tactic: rcases x with ⟨L⟩
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
⊢ ↑(map _root_.id) x = x

tactic: simp [List.map_id']
state_before: case mk
α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
β : Type v
f : α → β
x✝ y x : FreeGroup α
L : List (α × Bool)
⊢ ↑(map _root_.id) (Quot.mk Red.Step L) = Quot.mk Red.Step L
Theorem: TopologicalSpace.IsSeparable.closure
File: Mathlib/Topology/Bases.lean

tactic: rcases hs with ⟨c, c_count, hs⟩
state_before: α : Type u
t : TopologicalSpace α
s : Set α
hs : IsSeparable s
⊢ IsSeparable (_root_.closure s)

tactic: exact ⟨c, c_count, by simpa using closure_mono hs⟩
state_before: case intro.intro
α : Type u
t : TopologicalSpace α
s c : Set α
c_count : Set.Countable c
hs : s ⊆ _root_.closure c
⊢ IsSeparable (_root_.closure s)

tactic: simpa using closure_mono hs
state_before: α : Type u
t : TopologicalSpace α
s c : Set α
c_count : Set.Countable c
hs : s ⊆ _root_.closure c
⊢ _root_.closure s ⊆ _root_.closure c
Theorem: Besicovitch.exists_disjoint_closedBall_covering_ae_aux
File: Mathlib/MeasureTheory/Covering/Besicovitch.lean

tactic: rcases exists_absolutelyContinuous_isFiniteMeasure μ with ⟨ν, hν, hμν⟩
state_before: α : Type u_1
inst✝⁵ : MetricSpace α
β : Type u
inst✝⁴ : SecondCountableTopology α
inst✝³ : MeasurableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : HasBesicovitchCovering α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f : α → Set ℝ
s : Set α
hf : ∀ (x : α), x ∈ s → ∀ (δ : ℝ), δ > 0 → Set.Nonempty (f x ∩ Ioo 0 δ)
⊢ ∃ t,
    Set.Countable t ∧
      (∀ (p : α × ℝ), p ∈ t → p.fst ∈ s) ∧
        (∀ (p : α × ℝ), p ∈ t → p.snd ∈ f p.fst) ∧
          ↑↑μ (s \ ⋃ (p : α × ℝ) (_ : p ∈ t), closedBall p.fst p.snd) = 0 ∧
            PairwiseDisjoint t fun p => closedBall p.fst p.snd

tactic: rcases exists_disjoint_closedBall_covering_ae_of_finiteMeasure_aux ν f s hf with
  ⟨t, t_count, ts, tr, tν, tdisj⟩
state_before: case intro.intro
α : Type u_1
inst✝⁵ : MetricSpace α
β : Type u
inst✝⁴ : SecondCountableTopology α
inst✝³ : MeasurableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : HasBesicovitchCovering α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f : α → Set ℝ
s : Set α
hf : ∀ (x : α), x ∈ s → ∀ (δ : ℝ), δ > 0 → Set.Nonempty (f x ∩ Ioo 0 δ)
ν : MeasureTheory.Measure α
hν : IsFiniteMeasure ν
hμν : μ ≪ ν
⊢ ∃ t,
    Set.Countable t ∧
      (∀ (p : α × ℝ), p ∈ t → p.fst ∈ s) ∧
        (∀ (p : α × ℝ), p ∈ t → p.snd ∈ f p.fst) ∧
          ↑↑μ (s \ ⋃ (p : α × ℝ) (_ : p ∈ t), closedBall p.fst p.snd) = 0 ∧
            PairwiseDisjoint t fun p => closedBall p.fst p.snd

tactic: exact ⟨t, t_count, ts, tr, hμν tν, tdisj⟩
state_before: case intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝⁵ : MetricSpace α
β : Type u
inst✝⁴ : SecondCountableTopology α
inst✝³ : MeasurableSpace α
inst✝² : OpensMeasurableSpace α
inst✝¹ : HasBesicovitchCovering α
μ : MeasureTheory.Measure α
inst✝ : SigmaFinite μ
f : α → Set ℝ
s : Set α
hf : ∀ (x : α), x ∈ s → ∀ (δ : ℝ), δ > 0 → Set.Nonempty (f x ∩ Ioo 0 δ)
ν : MeasureTheory.Measure α
hν : IsFiniteMeasure ν
hμν : μ ≪ ν
t : Set (α × ℝ)
t_count : Set.Countable t
ts : ∀ (p : α × ℝ), p ∈ t → p.fst ∈ s
tr : ∀ (p : α × ℝ), p ∈ t → p.snd ∈ f p.fst
tν : ↑↑ν (s \ ⋃ (p : α × ℝ) (_ : p ∈ t), closedBall p.fst p.snd) = 0
tdisj : PairwiseDisjoint t fun p => closedBall p.fst p.snd
⊢ ∃ t,
    Set.Countable t ∧
      (∀ (p : α × ℝ), p ∈ t → p.fst ∈ s) ∧
        (∀ (p : α × ℝ), p ∈ t → p.snd ∈ f p.fst) ∧
          ↑↑μ (s \ ⋃ (p : α × ℝ) (_ : p ∈ t), closedBall p.fst p.snd) = 0 ∧
            PairwiseDisjoint t fun p => closedBall p.fst p.snd
Theorem: Cardinal.le_mk_iff_exists_subset
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [le_mk_iff_exists_set, ← Subtype.exists_set_subtype]
state_before: α✝ β : Type u
c : Cardinal
α : Type u
s : Set α
⊢ c ≤ (#↑s) ↔ ∃ p, p ⊆ s ∧ (#↑p) = c

tactic: apply exists_congr
state_before: α✝ β : Type u
c : Cardinal
α : Type u
s : Set α
⊢ (∃ p, (#↑p) = c) ↔ ∃ s_1, (#↑(Subtype.val '' s_1)) = c

tactic: intro t
state_before: case h
α✝ β : Type u
c : Cardinal
α : Type u
s : Set α
⊢ ∀ (a : Set ↑s), (#↑a) = c ↔ (#↑(Subtype.val '' a)) = c

tactic: rw [mk_image_eq]
state_before: case h
α✝ β : Type u
c : Cardinal
α : Type u
s : Set α
t : Set ↑s
⊢ (#↑t) = c ↔ (#↑(Subtype.val '' t)) = c

tactic: apply Subtype.val_injective
state_before: case h
α✝ β : Type u
c : Cardinal
α : Type u
s : Set α
t : Set ↑s
⊢ Injective Subtype.val
Theorem: CauSeq.const_lt
File: Mathlib/Data/Real/CauSeq.lean

tactic: rw [← const_sub, const_pos, sub_pos]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
x y : α
⊢ Pos (const y - const x) ↔ x < y
Theorem: CategoryTheory.unitCompPartialBijective_symm_natural
File: Mathlib/CategoryTheory/Adjunction/Reflective.lean

tactic: simp
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝³ : Category C
inst✝² : Category D
inst✝¹ : Category E
i : D ⥤ C
inst✝ : Reflective i
A B B' : C
h : B ⟶ B'
hB : B ∈ Functor.essImage i
hB' : B' ∈ Functor.essImage i
f : i.obj ((leftAdjoint i).obj A) ⟶ B
⊢ ↑(unitCompPartialBijective A hB').symm (f ≫ h) = ↑(unitCompPartialBijective A hB).symm f ≫ h
Theorem: Equiv.Perm.closure_prime_cycle_swap
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: obtain ⟨x, y, h4, h5⟩ := h3
state_before: ι : Type ?u.3022349
α : Type u_1
β : Type ?u.3022355
inst✝² : DecidableEq α
inst✝¹ : Finite β
inst✝ : Fintype α
σ τ : Perm α
h0 : Nat.Prime (Fintype.card α)
h1 : IsCycle σ
h2 : support σ = univ
h3 : IsSwap τ
⊢ closure {σ, τ} = ⊤

tactic: obtain ⟨i, hi⟩ :=
  h1.exists_pow_eq (mem_support.mp ((Finset.ext_iff.mp h2 x).mpr (Finset.mem_univ x)))
    (mem_support.mp ((Finset.ext_iff.mp h2 y).mpr (Finset.mem_univ y)))
state_before: case intro.intro.intro
ι : Type ?u.3022349
α : Type u_1
β : Type ?u.3022355
inst✝² : DecidableEq α
inst✝¹ : Finite β
inst✝ : Fintype α
σ τ : Perm α
h0 : Nat.Prime (Fintype.card α)
h1 : IsCycle σ
h2 : support σ = univ
x y : α
h4 : x ≠ y
h5 : τ = swap x y
⊢ closure {σ, τ} = ⊤

tactic: rw [h5, ← hi]
state_before: case intro.intro.intro.intro
ι : Type ?u.3022349
α : Type u_1
β : Type ?u.3022355
inst✝² : DecidableEq α
inst✝¹ : Finite β
inst✝ : Fintype α
σ τ : Perm α
h0 : Nat.Prime (Fintype.card α)
h1 : IsCycle σ
h2 : support σ = univ
x y : α
h4 : x ≠ y
h5 : τ = swap x y
i : ℕ
hi : ↑(σ ^ i) x = y
⊢ closure {σ, τ} = ⊤

tactic: refine'
  closure_cycle_coprime_swap (Nat.coprime.symm (h0.coprime_iff_not_dvd.mpr fun h => h4 _)) h1 h2 x
state_before: case intro.intro.intro.intro
ι : Type ?u.3022349
α : Type u_1
β : Type ?u.3022355
inst✝² : DecidableEq α
inst✝¹ : Finite β
inst✝ : Fintype α
σ τ : Perm α
h0 : Nat.Prime (Fintype.card α)
h1 : IsCycle σ
h2 : support σ = univ
x y : α
h4 : x ≠ y
h5 : τ = swap x y
i : ℕ
hi : ↑(σ ^ i) x = y
⊢ closure {σ, swap x (↑(σ ^ i) x)} = ⊤

tactic: cases' h with m hm
state_before: case intro.intro.intro.intro
ι : Type ?u.3022349
α : Type u_1
β : Type ?u.3022355
inst✝² : DecidableEq α
inst✝¹ : Finite β
inst✝ : Fintype α
σ τ : Perm α
h0 : Nat.Prime (Fintype.card α)
h1 : IsCycle σ
h2 : support σ = univ
x y : α
h4 : x ≠ y
h5 : τ = swap x y
i : ℕ
hi : ↑(σ ^ i) x = y
h : Fintype.card α ∣ i
⊢ x = y

tactic: rwa [hm, pow_mul, ← Finset.card_univ, ← h2, ← h1.orderOf, pow_orderOf_eq_one, one_pow,
  one_apply] at hi
state_before: case intro.intro.intro.intro.intro
ι : Type ?u.3022349
α : Type u_1
β : Type ?u.3022355
inst✝² : DecidableEq α
inst✝¹ : Finite β
inst✝ : Fintype α
σ τ : Perm α
h0 : Nat.Prime (Fintype.card α)
h1 : IsCycle σ
h2 : support σ = univ
x y : α
h4 : x ≠ y
h5 : τ = swap x y
i : ℕ
hi : ↑(σ ^ i) x = y
m : ℕ
hm : i = Fintype.card α * m
⊢ x = y
Theorem: Lagrange.degree_basisDivisor_self
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [basisDivisor_self, degree_zero]
state_before: F : Type u_1
inst✝ : Field F
x y : F
⊢ degree (basisDivisor x x) = ⊥
Theorem: Multiset.Ico_filter_le_of_left_le
File: Mathlib/Data/Multiset/LocallyFinite.lean

tactic: rw [Ico, ← Finset.filter_val, Finset.Ico_filter_le_of_left_le hac]
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred ((fun x x_1 => x ≤ x_1) c)
hac : a ≤ c
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico c b

tactic: rfl
state_before: α : Type u_1
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidablePred ((fun x x_1 => x ≤ x_1) c)
hac : a ≤ c
⊢ (Finset.Ico c b).val = Ico c b
Theorem: Nat.div_div_self
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: rcases h with ⟨_, rfl⟩
state_before: m n k l : ℕ
h : n ∣ m
hm : m ≠ 0
⊢ m / (m / n) = n

tactic: rw [mul_ne_zero_iff] at hm
state_before: case intro
n k l w✝ : ℕ
hm : n * w✝ ≠ 0
⊢ n * w✝ / (n * w✝ / n) = n

tactic: rw [mul_div_right _ (Nat.pos_of_ne_zero hm.1), mul_div_left _ (Nat.pos_of_ne_zero hm.2)]
state_before: case intro
n k l w✝ : ℕ
hm : n ≠ 0 ∧ w✝ ≠ 0
⊢ n * w✝ / (n * w✝ / n) = n
Theorem: Turing.ListBlank.map_cons
File: Mathlib/Computability/TuringMachine.lean

tactic: refine' (ListBlank.cons_head_tail _).symm.trans _
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
a : Γ
⊢ map f (cons a l) = cons (PointedMap.f f a) (map f l)

tactic: simp only [ListBlank.head_map, ListBlank.head_cons, ListBlank.tail_map, ListBlank.tail_cons]
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
f : PointedMap Γ Γ'
l : ListBlank Γ
a : Γ
⊢ cons (head (map f (cons a l))) (tail (map f (cons a l))) = cons (PointedMap.f f a) (map f l)
Theorem: dist_partial_sum_le_of_le_geometric
File: Mathlib/Analysis/SpecificLimits/Normed.lean

tactic: rw [sum_range_succ, dist_eq_norm, ← norm_neg, neg_sub, add_sub_cancel']
state_before: α : Type u_1
β : Type ?u.580401
ι : Type ?u.580404
inst✝ : SeminormedAddCommGroup α
r C : ℝ
f : ℕ → α
hf : ∀ (n : ℕ), ‖f n‖ ≤ C * r ^ n
n : ℕ
⊢ dist (∑ i in Finset.range n, f i) (∑ i in Finset.range (n + 1), f i) ≤ C * r ^ n

tactic: exact hf n
state_before: α : Type u_1
β : Type ?u.580401
ι : Type ?u.580404
inst✝ : SeminormedAddCommGroup α
r C : ℝ
f : ℕ → α
hf : ∀ (n : ℕ), ‖f n‖ ≤ C * r ^ n
n : ℕ
⊢ ‖f n‖ ≤ C * r ^ n
Theorem: Polynomial.natDegree_mul_C
File: Mathlib/Data/Polynomial/Degree/Lemmas.lean

tactic: simp only [natDegree, degree_mul_C a0]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝¹ : Semiring R
inst✝ : NoZeroDivisors R
p q : R[X]
a0 : a ≠ 0
⊢ natDegree (p * ↑C a) = natDegree p
Theorem: Matrix.IsHermitian.fromBlocks
File: Mathlib/LinearAlgebra/Matrix/Hermitian.lean

tactic: have hCB : Cᴴ = B := by rw [← hBC, conjTranspose_conjTranspose]
state_before: α : Type u_2
β : Type ?u.5694
m : Type u_1
n : Type u_3
A✝ : Matrix n n α
inst✝ : InvolutiveStar α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsHermitian A
hBC : Bᴴ = C
hD : IsHermitian D
⊢ IsHermitian (Matrix.fromBlocks A B C D)

tactic: unfold Matrix.IsHermitian
state_before: α : Type u_2
β : Type ?u.5694
m : Type u_1
n : Type u_3
A✝ : Matrix n n α
inst✝ : InvolutiveStar α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsHermitian A
hBC : Bᴴ = C
hD : IsHermitian D
hCB : Cᴴ = B
⊢ IsHermitian (Matrix.fromBlocks A B C D)

tactic: rw [fromBlocks_conjTranspose, hBC, hCB, hA, hD]
state_before: α : Type u_2
β : Type ?u.5694
m : Type u_1
n : Type u_3
A✝ : Matrix n n α
inst✝ : InvolutiveStar α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsHermitian A
hBC : Bᴴ = C
hD : IsHermitian D
hCB : Cᴴ = B
⊢ (Matrix.fromBlocks A B C D)ᴴ = Matrix.fromBlocks A B C D

tactic: rw [← hBC, conjTranspose_conjTranspose]
state_before: α : Type u_2
β : Type ?u.5694
m : Type u_1
n : Type u_3
A✝ : Matrix n n α
inst✝ : InvolutiveStar α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
hA : IsHermitian A
hBC : Bᴴ = C
hD : IsHermitian D
⊢ Cᴴ = B
Theorem: CategoryTheory.Limits.biprod.lift_desc
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: simp [biprod.lift_eq, biprod.desc_eq]
state_before: C : Type u
inst✝³ : Category C
inst✝² : Preadditive C
J : Type
inst✝¹ : Fintype J
X Y : C
inst✝ : HasBinaryBiproduct X Y
T U : C
f : T ⟶ X
g : T ⟶ Y
h : X ⟶ U
i : Y ⟶ U
⊢ lift f g ≫ desc h i = f ≫ h + g ≫ i
Theorem: Polynomial.degree_lt_iff_coeff_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: refine'
  ⟨fun hf m hm => coeff_eq_zero_of_degree_lt (lt_of_lt_of_le hf (WithBot.coe_le_coe.2 hm)), _⟩
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.703639
f : R[X]
n : ℕ
⊢ degree f < ↑n ↔ ∀ (m : ℕ), n ≤ m → coeff f m = 0

tactic: simp only [degree, Finset.sup_lt_iff (WithBot.bot_lt_coe n), mem_support_iff, WithBot.some_eq_coe,
  WithBot.coe_lt_coe, ← @not_le ℕ, max_eq_sup_coe, Nat.cast_withBot]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.703639
f : R[X]
n : ℕ
⊢ (∀ (m : ℕ), n ≤ m → coeff f m = 0) → degree f < ↑n

tactic: exact fun h m => mt (h m)
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.703639
f : R[X]
n : ℕ
⊢ (∀ (m : ℕ), n ≤ m → coeff f m = 0) → ∀ (b : ℕ), coeff f b ≠ 0 → ¬n ≤ b
Theorem: WithBot.wellFounded_gt
File: Mathlib/Order/WithBot.lean

tactic: revert this
state_before: α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : WithBot α
this : Acc (fun x x_1 => x < x_1) (↑WithBot.toDual a)
⊢ Acc (fun x x_1 => x > x_1) a

tactic: generalize ha : WithBot.toDual a = b
state_before: α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : WithBot α
⊢ Acc (fun x x_1 => x < x_1) (↑WithBot.toDual a) → Acc (fun x x_1 => x > x_1) a

tactic: intro ac
state_before: α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : WithBot α
b : WithTop αᵒᵈ
ha : ↑WithBot.toDual a = b
⊢ Acc (fun x x_1 => x < x_1) b → Acc (fun x x_1 => x > x_1) a

tactic: dsimp at ac
state_before: α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : WithBot α
b : WithTop αᵒᵈ
ha : ↑WithBot.toDual a = b
ac : Acc (fun x x_1 => x < x_1) b
⊢ Acc (fun x x_1 => x > x_1) a

tactic: induction' ac with _ H IH generalizing a
state_before: α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : WithBot α
b : WithTop αᵒᵈ
ha : ↑WithBot.toDual a = b
ac : Acc (fun x x_1 => x < x_1) b
⊢ Acc (fun x x_1 => x > x_1) a

tactic: subst ha
state_before: case intro
α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a✝ : WithBot α
b : WithTop αᵒᵈ
ha✝ : ↑WithBot.toDual a✝ = b
x✝ : WithTop αᵒᵈ
H : ∀ (y : WithTop αᵒᵈ), y < x✝ → Acc (fun x x_1 => x < x_1) y
IH : ∀ (y : WithTop αᵒᵈ), y < x✝ → ∀ (a : WithBot α), ↑WithBot.toDual a = y → Acc (fun x x_1 => x > x_1) a
a : WithBot α
ha : ↑WithBot.toDual a = x✝
⊢ Acc (fun x x_1 => x > x_1) a

tactic: exact ⟨_, fun a' h => IH (WithBot.toDual a') (toDual_lt_toDual.mpr h) _ rfl⟩
state_before: case intro
α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a✝ : WithBot α
b : WithTop αᵒᵈ
ha : ↑WithBot.toDual a✝ = b
a : WithBot α
H : ∀ (y : WithTop αᵒᵈ), y < ↑WithBot.toDual a → Acc (fun x x_1 => x < x_1) y
IH :
  ∀ (y : WithTop αᵒᵈ), y < ↑WithBot.toDual a → ∀ (a : WithBot α), ↑WithBot.toDual a = y → Acc (fun x x_1 => x > x_1) a
⊢ Acc (fun x x_1 => x > x_1) a

tactic: convert h using 1
state_before: α : Type u_1
β : Type ?u.121527
γ : Type ?u.121530
δ : Type ?u.121533
inst✝ : Preorder α
h : WellFounded fun x x_1 => x > x_1
a : WithBot α
⊢ WellFounded fun x x_1 => x < x_1
Theorem: Metric.cthickening_eq_iInter_thickening
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: apply cthickening_eq_iInter_thickening' δ_nn (Ioi δ) rfl.subset
state_before: ι : Sort ?u.142608
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ cthickening δ E = ⋂ (ε : ℝ) (_ : δ < ε), thickening ε E

tactic: simp_rw [inter_eq_right_iff_subset.mpr Ioc_subset_Ioi_self]
state_before: case hs
ι : Sort ?u.142608
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → Set.Nonempty (Ioi δ ∩ Ioc δ ε)

tactic: exact fun _ hε => nonempty_Ioc.mpr hε
state_before: case hs
ι : Sort ?u.142608
α : Type u
β : Type v
inst✝ : PseudoEMetricSpace α
δ✝ ε : ℝ
s t : Set α
x : α
δ : ℝ
δ_nn : 0 ≤ δ
E : Set α
⊢ ∀ (ε : ℝ), δ < ε → Set.Nonempty (Ioc δ ε)
Theorem: Equiv.Perm.cycleOf_inv
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rw [inv_eq_iff_eq, cycleOf_apply, cycleOf_apply]
state_before: ι : Type ?u.2113579
α : Type u_1
β : Type ?u.2113585
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y✝ : α
f : Perm α
x y : α
⊢ ↑(cycleOf f x)⁻¹ y = ↑(cycleOf f⁻¹ x) y

tactic: split_ifs <;> simp_all [sameCycle_inv, sameCycle_inv_apply_right]
state_before: ι : Type ?u.2113579
α : Type u_1
β : Type ?u.2113585
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y✝ : α
f : Perm α
x y : α
⊢ y =
    if SameCycle f x (if SameCycle f⁻¹ x y then ↑f⁻¹ y else y) then ↑f (if SameCycle f⁻¹ x y then ↑f⁻¹ y else y)
    else if SameCycle f⁻¹ x y then ↑f⁻¹ y else y
Theorem: CategoryTheory.typesGrothendieckTopology_eq_canonical
File: Mathlib/CategoryTheory/Sites/Types.lean

tactic: refine' le_antisymm subcanonical_typesGrothendieckTopology (sInf_le _)
state_before: ⊢ typesGrothendieckTopology = Sheaf.canonicalTopology (Type u)

tactic: refine' ⟨yoneda.obj (ULift Bool), ⟨_, rfl⟩, GrothendieckTopology.ext _⟩
state_before: ⊢ typesGrothendieckTopology ∈ Sheaf.finestTopologySingle '' Set.range yoneda.toPrefunctor.obj

tactic: funext α
state_before: ⊢ (Sheaf.finestTopologySingle (yoneda.obj (ULift Bool))).sieves = typesGrothendieckTopology.sieves

tactic: ext S
state_before: case h
α : Type u
⊢ GrothendieckTopology.sieves (Sheaf.finestTopologySingle (yoneda.obj (ULift Bool))) α =
    GrothendieckTopology.sieves typesGrothendieckTopology α

tactic: refine' ⟨fun hs x => _, fun hs β f => isSheaf_yoneda' _ fun y => hs _⟩
state_before: case h.h
α : Type u
S : Sieve α
⊢ S ∈ GrothendieckTopology.sieves (Sheaf.finestTopologySingle (yoneda.obj (ULift Bool))) α ↔
    S ∈ GrothendieckTopology.sieves typesGrothendieckTopology α

tactic: by_contra hsx
state_before: case h.h
α : Type u
S : Sieve α
hs : S ∈ GrothendieckTopology.sieves (Sheaf.finestTopologySingle (yoneda.obj (ULift Bool))) α
x : α
⊢ S.arrows fun x_1 => x

tactic: have : (fun _ => ULift.up true) = fun _ => ULift.up false :=
  (hs PUnit fun _ => x).isSeparatedFor.ext
    fun β f hf => funext fun y => hsx.elim <| S.2 hf fun _ => y
state_before: case h.h
α : Type u
S : Sieve α
hs : S ∈ GrothendieckTopology.sieves (Sheaf.finestTopologySingle (yoneda.obj (ULift Bool))) α
x : α
hsx : ¬S.arrows fun x_1 => x
⊢ False

tactic: simp at this
state_before: case h.h
α : Type u
S : Sieve α
hs : S ∈ GrothendieckTopology.sieves (Sheaf.finestTopologySingle (yoneda.obj (ULift Bool))) α
x : α
hsx : ¬S.arrows fun x_1 => x
this : (fun x => { down := true }) = fun x => { down := false }
⊢ False
Theorem: Cycle.Chain.eq_nil_of_irrefl
File: Mathlib/Data/List/Cycle.lean

tactic: induction' s using Cycle.induction_on with a l _ h
state_before: α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsIrrefl α r
h : Chain r s
⊢ s = Cycle.nil

tactic: rfl
state_before: case H0
α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsIrrefl α r
h✝ : Chain r s
h : Chain r Cycle.nil
⊢ Cycle.nil = Cycle.nil

tactic: have ha := mem_cons_self a l
state_before: case HI
α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsIrrefl α r
h✝ : Chain r s
a : α
l : List α
a✝ : Chain r ↑l → ↑l = Cycle.nil
h : Chain r ↑(a :: l)
⊢ ↑(a :: l) = Cycle.nil

tactic: exact (irrefl_of r a <| chain_iff_pairwise.1 h a ha a ha).elim
state_before: case HI
α : Type u_1
r : α → α → Prop
s : Cycle α
inst✝¹ : IsTrans α r
inst✝ : IsIrrefl α r
h✝ : Chain r s
a : α
l : List α
a✝ : Chain r ↑l → ↑l = Cycle.nil
h : Chain r ↑(a :: l)
ha : a ∈ a :: l
⊢ ↑(a :: l) = Cycle.nil