tasksource/leandojo huggingface dataset:
Theorem: AbstractCompletion.uniformContinuous_extend
File: Mathlib/Topology/UniformSpace/AbstractCompletion.lean

tactic: by_cases hf : UniformContinuous f
state_before: α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
⊢ UniformContinuous (AbstractCompletion.extend pkg f)

tactic: rw [pkg.extend_def hf]
state_before: case pos
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : UniformContinuous f
⊢ UniformContinuous (AbstractCompletion.extend pkg f)

tactic: exact uniformContinuous_uniformly_extend pkg.uniformInducing pkg.dense hf
state_before: case pos
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : UniformContinuous f
⊢ UniformContinuous (DenseInducing.extend (_ : DenseInducing pkg.coe) f)

tactic: change UniformContinuous (ite _ _ _)
state_before: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous (AbstractCompletion.extend pkg f)

tactic: rw [if_neg hf]
state_before: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous
    (if UniformContinuous f then DenseInducing.extend (_ : DenseInducing pkg.coe) f
    else fun x => f (DenseRange.some (_ : DenseRange pkg.coe) x))

tactic: exact uniformContinuous_of_const fun a b => by congr 1
state_before: case neg
α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
⊢ UniformContinuous fun x => f (DenseRange.some (_ : DenseRange pkg.coe) x)

tactic: congr 1
state_before: α : Type u_1
inst✝² : UniformSpace α
pkg : AbstractCompletion α
β : Type u_2
inst✝¹ : UniformSpace β
f : α → β
inst✝ : CompleteSpace β
hf : ¬UniformContinuous f
a b : pkg.space
⊢ f (DenseRange.some (_ : DenseRange pkg.coe) a) = f (DenseRange.some (_ : DenseRange pkg.coe) b)
Theorem: Multiset.mem_sup_map_support_iff
File: Mathlib/Data/Finsupp/BigOperators.lean

tactic: simpa only [Multiset.quot_mk_to_coe'', Multiset.coe_map, Multiset.sup_coe, List.foldr_map]
using List.mem_foldr_sup_support_iff
state_before: ι : Type u_2
M : Type u_1
inst✝¹ : DecidableEq ι
inst✝ : Zero M
s : Multiset (ι →₀ M)
x : ι
x✝ : List (ι →₀ M)
⊢ x ∈ sup (map Finsupp.support (Quot.mk Setoid.r x✝)) ↔ ∃ f x_1, x ∈ f.support
Theorem: AlgebraicGeometry.StructureSheaf.const_ext
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [mul_comm, Subtype.coe_mk, ← h, mul_comm, Subtype.coe_mk]
state_before: R : Type u
inst✝ : CommRing R
f₁ f₂ g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g₁ ∈ Ideal.primeCompl x.asIdeal
hu₂ : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → g₂ ∈ Ideal.primeCompl x.asIdeal
h : f₁ * g₂ = f₂ * g₁
x : { x // x ∈ U.op.unop }
⊢ ↑{ val := g₁, property := (_ : g₁ ∈ Ideal.primeCompl (↑x).asIdeal) } * f₂ =
    ↑{ val := g₂, property := (_ : g₂ ∈ Ideal.primeCompl (↑x).asIdeal) } * f₁
Theorem: Nat.floor_pos
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [Nat.lt_iff_add_one_le, zero_add, le_floor_iff' Nat.one_ne_zero, cast_one]
state_before: F : Type ?u.31467
α : Type u_1
β : Type ?u.31473
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ 0 < ⌊a⌋₊ ↔ 1 ≤ a
Theorem: MeasureTheory.Measure.add_haar_preimage_linearMap
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

tactic: rw [map_linearMap_add_haar_eq_smul_add_haar μ hf]
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1295525
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f : E →ₗ[ℝ] E
hf : ↑LinearMap.det f ≠ 0
s : Set E
⊢ ↑↑(map (↑f) μ) s = ENNReal.ofReal (abs (↑LinearMap.det f)⁻¹) * ↑↑μ s

tactic: rfl
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type ?u.1295525
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f : E →ₗ[ℝ] E
hf : ↑LinearMap.det f ≠ 0
s : Set E
⊢ ↑↑(ENNReal.ofReal (abs (↑LinearMap.det f)⁻¹) • μ) s = ENNReal.ofReal (abs (↑LinearMap.det f)⁻¹) * ↑↑μ s
Theorem: Function.iterate_fixed
File: Mathlib/Logic/Function/Iterate.lean

tactic: rw [iterate_succ_apply, h, ihn]
state_before: α : Type u
β : Type v
f : α → α
x : α
h : f x = x
n✝ n : ℕ
ihn : (f^[n]) x = x
⊢ (f^[Nat.succ n]) x = x
Theorem: Polynomial.monic_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [Monic, leadingCoeff, natDegree_restriction]
state_before: R : Type u
S : Type ?u.75263
inst✝ : Ring R
p : R[X]
⊢ Monic (restriction p) ↔ Monic p

tactic: rw [← @coeff_restriction _ _ p]
state_before: R : Type u
S : Type ?u.75263
inst✝ : Ring R
p : R[X]
⊢ coeff (restriction p) (natDegree p) = 1 ↔ coeff p (natDegree p) = 1

tactic: exact ⟨fun H => by rw [H, OneMemClass.coe_one], fun H => Subtype.coe_injective H⟩
state_before: R : Type u
S : Type ?u.75263
inst✝ : Ring R
p : R[X]
⊢ coeff (restriction p) (natDegree p) = 1 ↔ ↑(coeff (restriction p) (natDegree p)) = 1

tactic: rw [H, OneMemClass.coe_one]
state_before: R : Type u
S : Type ?u.75263
inst✝ : Ring R
p : R[X]
H : coeff (restriction p) (natDegree p) = 1
⊢ ↑(coeff (restriction p) (natDegree p)) = 1
Theorem: Acc.of_fibration
File: Mathlib/Logic/Relation.lean

tactic: induction' ha with a _ ih
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.13156
δ : Type ?u.13159
rα : α → α → Prop
rβ : β → β → Prop
f : α → β
fib : Fibration rα rβ f
a : α
ha : Acc rα a
⊢ Acc rβ (f a)

tactic: refine' Acc.intro (f a) fun b hr ↦ _
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.13156
δ : Type ?u.13159
rα : α → α → Prop
rβ : β → β → Prop
f : α → β
fib : Fibration rα rβ f
a✝ a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
ih : ∀ (y : α), rα y a → Acc rβ (f y)
⊢ Acc rβ (f a)

tactic: obtain ⟨a', hr', rfl⟩ := fib hr
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.13156
δ : Type ?u.13159
rα : α → α → Prop
rβ : β → β → Prop
f : α → β
fib : Fibration rα rβ f
a✝ a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
ih : ∀ (y : α), rα y a → Acc rβ (f y)
b : β
hr : rβ b (f a)
⊢ Acc rβ b

tactic: exact ih a' hr'
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type ?u.13156
δ : Type ?u.13159
rα : α → α → Prop
rβ : β → β → Prop
f : α → β
fib : Fibration rα rβ f
a✝ a : α
h✝ : ∀ (y : α), rα y a → Acc rα y
ih : ∀ (y : α), rα y a → Acc rβ (f y)
a' : α
hr' : rα a' a
hr : rβ (f a') (f a)
⊢ Acc rβ (f a')
Theorem: Polynomial.coe_normUnit_of_ne_zero
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: have : p.leadingCoeff ≠ 0 := mt leadingCoeff_eq_zero.mp hp
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
⊢ ↑(normUnit p) = ↑C (leadingCoeff p)⁻¹

tactic: simp [CommGroupWithZero.coe_normUnit _ this]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p q : R[X]
hp : p ≠ 0
this : leadingCoeff p ≠ 0
⊢ ↑(normUnit p) = ↑C (leadingCoeff p)⁻¹
Theorem: toIcoDiv_neg
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: suffices toIcoDiv hp a (-b) = -toIocDiv hp (-(a + p)) b by
  rwa [neg_add, ← sub_eq_add_neg, toIocDiv_sub_eq_toIocDiv_add', toIocDiv_add_right] at this
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a (-b) = -(toIocDiv hp (-a) b + 1)

tactic: rw [← neg_eq_iff_eq_neg, eq_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a (-b) = -toIocDiv hp (-(a + p)) b

tactic: apply toIocDiv_eq_of_sub_zsmul_mem_Ioc
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp (-(a + p)) b = -toIcoDiv hp a (-b)

tactic: obtain ⟨hc, ho⟩ := sub_toIcoDiv_zsmul_mem_Ico hp a (-b)
state_before: case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

tactic: rw [← neg_lt_neg_iff, neg_sub' (-b), neg_neg, ← neg_smul] at ho
state_before: case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc : a ≤ -b - toIcoDiv hp a (-b) • p
ho : -b - toIcoDiv hp a (-b) • p < a + p
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

tactic: rw [← neg_le_neg_iff, neg_sub' (-b), neg_neg, ← neg_smul] at hc
state_before: case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc : a ≤ -b - toIcoDiv hp a (-b) • p
ho✝ : -b - toIcoDiv hp a (-b) • p < a + p
ho : -(a + p) < b - -toIcoDiv hp a (-b) • p
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

tactic: refine' ⟨ho, hc.trans_eq _⟩
state_before: case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc✝ : a ≤ -b - toIcoDiv hp a (-b) • p
hc : b - -toIcoDiv hp a (-b) • p ≤ -a
ho✝ : -b - toIcoDiv hp a (-b) • p < a + p
ho : -(a + p) < b - -toIcoDiv hp a (-b) • p
⊢ b - -toIcoDiv hp a (-b) • p ∈ Set.Ioc (-(a + p)) (-(a + p) + p)

tactic: rw [neg_add, neg_add_cancel_right]
state_before: case h.intro
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
hc✝ : a ≤ -b - toIcoDiv hp a (-b) • p
hc : b - -toIcoDiv hp a (-b) • p ≤ -a
ho✝ : -b - toIcoDiv hp a (-b) • p < a + p
ho : -(a + p) < b - -toIcoDiv hp a (-b) • p
⊢ -a = -(a + p) + p

tactic: rwa [neg_add, ← sub_eq_add_neg, toIocDiv_sub_eq_toIocDiv_add', toIocDiv_add_right] at this
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
this : toIcoDiv hp a (-b) = -toIocDiv hp (-(a + p)) b
⊢ toIcoDiv hp a (-b) = -(toIocDiv hp (-a) b + 1)
Theorem: Localization.mk_pow
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: rw [Localization.npow]
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.80130
inst✝¹ : CommMonoid N
P : Type ?u.80136
inst✝ : CommMonoid P
n : ℕ
a : M
b : { x // x ∈ S }
⊢ Localization.npow S n (mk a b) = mk (a ^ n) (b ^ n)

tactic: rfl
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type ?u.80130
inst✝¹ : CommMonoid N
P : Type ?u.80136
inst✝ : CommMonoid P
n : ℕ
a : M
b : { x // x ∈ S }
⊢ Monoid.npow n (mk a b) = mk (a ^ n) (b ^ n)
Theorem: CategoryTheory.Functor.map_conjAut
File: Mathlib/CategoryTheory/Conj.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category C
D : Type u₁
inst✝ : Category D
F✝ F : C ⥤ D
X Y : C
α : X ≅ Y
f : Aut X
⊢ F.mapIso (↑(Iso.conjAut α) f) = ↑(Iso.conjAut (F.mapIso α)) (F.mapIso f)

tactic: simp only [mapIso_hom, Iso.conjAut_hom, F.map_conj]
state_before: case w
C : Type u
inst✝¹ : Category C
D : Type u₁
inst✝ : Category D
F✝ F : C ⥤ D
X Y : C
α : X ≅ Y
f : Aut X
⊢ (F.mapIso (↑(Iso.conjAut α) f)).hom = (↑(Iso.conjAut (F.mapIso α)) (F.mapIso f)).hom
Theorem: MeasureTheory.snorm_exponent_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp [snorm]
state_before: α : Type u_1
E : Type ?u.909869
F : Type u_2
G : Type ?u.909875
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snorm f 0 μ = 0
Theorem: exists_unique_prop
File: Mathlib/Logic/Basic.lean

tactic: simp
state_before: ι : Sort ?u.22665
α : Sort ?u.22670
κ : ι → Sort ?u.22667
p✝ q✝ : α → Prop
p q : Prop
⊢ (∃! x, q) ↔ p ∧ q
Theorem: LinearMap.range_zero
File: Mathlib/LinearAlgebra/Basic.lean

tactic: simpa only [range_eq_map] using Submodule.map_zero _
state_before: R : Type u_1
R₁ : Type ?u.1250249
R₂ : Type u_2
R₃ : Type ?u.1250255
R₄ : Type ?u.1250258
S : Type ?u.1250261
K : Type ?u.1250264
K₂ : Type ?u.1250267
M : Type u_4
M' : Type ?u.1250273
M₁ : Type ?u.1250276
M₂ : Type u_3
M₃ : Type ?u.1250282
M₄ : Type ?u.1250285
N : Type ?u.1250288
N₂ : Type ?u.1250291
ι : Type ?u.1250294
V : Type ?u.1250297
V₂ : Type ?u.1250300
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : Semiring R₃
inst✝⁸ : AddCommMonoid M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁵ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁴ : Module R M
inst✝³ : Module R₂ M₂
inst✝² : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝¹ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type ?u.1250710
sc : SemilinearMapClass F τ₁₂ M M₂
inst✝ : RingHomSurjective τ₁₂
⊢ range 0 = ⊥
Theorem: sdiff_sdiff_right_self
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_sdiff_right, inf_idem, sdiff_self, bot_sup_eq]
state_before: α : Type u
β : Type ?u.29848
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x \ (x \ y) = x ⊓ y
Theorem: Real.toNNReal_inv
File: Mathlib/Data/Real/NNReal.lean

tactic: cases' le_total 0 x with hx hx
state_before: x : ℝ
⊢ toNNReal x⁻¹ = (toNNReal x)⁻¹

tactic: nth_rw 1 [← Real.coe_toNNReal x hx]
state_before: case inl
x : ℝ
hx : 0 ≤ x
⊢ toNNReal x⁻¹ = (toNNReal x)⁻¹

tactic: rw [← NNReal.coe_inv, Real.toNNReal_coe]
state_before: case inl
x : ℝ
hx : 0 ≤ x
⊢ toNNReal (↑(toNNReal x))⁻¹ = (toNNReal x)⁻¹

tactic: rw [toNNReal_eq_zero.mpr hx, inv_zero, toNNReal_eq_zero.mpr (inv_nonpos.mpr hx)]
state_before: case inr
x : ℝ
hx : x ≤ 0
⊢ toNNReal x⁻¹ = (toNNReal x)⁻¹
Theorem: DivisorChain.second_of_chain_is_irreducible
File: Mathlib/RingTheory/ChainOfDivisors.lean

tactic: cases' n with n
state_before: M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
n : ℕ
hn : n ≠ 0
c : Fin (n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
hq : q ≠ 0
⊢ Irreducible (c 1)

tactic: refine' (Associates.isAtom_iff (ne_zero_of_dvd_ne_zero hq (h₂.2 ⟨1, rfl⟩))).mp ⟨_, fun b hb => _⟩
state_before: case succ
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
hq : q ≠ 0
n : ℕ
hn : Nat.succ n ≠ 0
c : Fin (Nat.succ n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
⊢ Irreducible (c 1)

tactic: obtain ⟨⟨i, hi⟩, rfl⟩ := h₂.1 (hb.le.trans (h₂.2 ⟨1, rfl⟩))
state_before: case succ.refine'_2
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
hq : q ≠ 0
n : ℕ
hn : Nat.succ n ≠ 0
c : Fin (Nat.succ n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
b : Associates M
hb : b < c 1
⊢ b = ⊥

tactic: cases i
state_before: case succ.refine'_2.intro.mk
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
hq : q ≠ 0
n : ℕ
hn : Nat.succ n ≠ 0
c : Fin (Nat.succ n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
i : ℕ
hi : i < Nat.succ n + 1
hb : c { val := i, isLt := hi } < c 1
⊢ c { val := i, isLt := hi } = ⊥

tactic: contradiction
state_before: case zero
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
hq : q ≠ 0
hn : Nat.zero ≠ 0
c : Fin (Nat.zero + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
⊢ Irreducible (c 1)

tactic: exact ne_bot_of_gt (h₁ (show (0 : Fin (n + 2)) < 1 from Fin.one_pos))
state_before: case succ.refine'_1
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
hq : q ≠ 0
n : ℕ
hn : Nat.succ n ≠ 0
c : Fin (Nat.succ n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
⊢ c 1 ≠ ⊥

tactic: exact (Associates.isUnit_iff_eq_one _).mp (first_of_chain_isUnit h₁ @h₂)
state_before: case succ.refine'_2.intro.mk.zero
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
hq : q ≠ 0
n : ℕ
hn : Nat.succ n ≠ 0
c : Fin (Nat.succ n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
hi : Nat.zero < Nat.succ n + 1
hb : c { val := Nat.zero, isLt := hi } < c 1
⊢ c { val := Nat.zero, isLt := hi } = ⊥

tactic: simpa [Fin.lt_iff_val_lt_val] using h₁.lt_iff_lt.mp hb
state_before: case succ.refine'_2.intro.mk.succ
M : Type u_1
inst✝ : CancelCommMonoidWithZero M
q : Associates M
hq : q ≠ 0
n : ℕ
hn : Nat.succ n ≠ 0
c : Fin (Nat.succ n + 1) → Associates M
h₁ : StrictMono c
h₂ : ∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i
n✝ : ℕ
hi : Nat.succ n✝ < Nat.succ n + 1
hb : c { val := Nat.succ n✝, isLt := hi } < c 1
⊢ c { val := Nat.succ n✝, isLt := hi } = ⊥
Theorem: TypeVec.fst_diag
File: Mathlib/Data/TypeVec.lean

tactic: funext i
state_before: n : ℕ
α : TypeVec n
⊢ prod.fst ⊚ prod.diag = id

tactic: induction i
state_before: case h
n : ℕ
α : TypeVec n
i : Fin2 n
⊢ (prod.fst ⊚ prod.diag) i = id i

tactic: case fz => rfl
state_before: case h.fz
n n✝ : ℕ
α : TypeVec (succ n✝)
⊢ (prod.fst ⊚ prod.diag) Fin2.fz = id Fin2.fz

case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec n✝}, (prod.fst ⊚ prod.diag) a✝ = id a✝
α : TypeVec (succ n✝)
⊢ (prod.fst ⊚ prod.diag) (Fin2.fs a✝) = id (Fin2.fs a✝)

tactic: case fs _ _ i_ih => apply i_ih
state_before: case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α : TypeVec n✝}, (prod.fst ⊚ prod.diag) a✝ = id a✝
α : TypeVec (succ n✝)
⊢ (prod.fst ⊚ prod.diag) (Fin2.fs a✝) = id (Fin2.fs a✝)

tactic: rfl
state_before: n n✝ : ℕ
α : TypeVec (succ n✝)
⊢ (prod.fst ⊚ prod.diag) Fin2.fz = id Fin2.fz

tactic: apply i_ih
state_before: n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α : TypeVec n✝}, (prod.fst ⊚ prod.diag) a✝ = id a✝
α : TypeVec (succ n✝)
⊢ (prod.fst ⊚ prod.diag) (Fin2.fs a✝) = id (Fin2.fs a✝)
Theorem: Cardinal.succ_aleph0
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [← aleph_zero, ← aleph_succ, Ordinal.succ_zero]
state_before: ⊢ succ ℵ₀ = aleph 1
Theorem: Polynomial.eq_C_content_mul_primPart
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: by_cases h : p = 0
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ p = ↑C (content p) * primPart p

tactic: rw [primPart, if_neg h, ← Classical.choose_spec (C_content_dvd p)]
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : ¬p = 0
⊢ p = ↑C (content p) * primPart p

tactic: simp [h]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
h : p = 0
⊢ p = ↑C (content p) * primPart p
Theorem: multiplicity.finite_pow
File: Mathlib/RingTheory/Multiplicity.lean

tactic: simp [mt isUnit_iff_dvd_one.2 hp.2.1]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p a : α
hp : Prime p
x✝ : Finite p a
⊢ ¬p ^ (0 + 1) ∣ a ^ 0

tactic: rw [_root_.pow_succ]
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p a : α
hp : Prime p
k : ℕ
ha : Finite p a
⊢ Finite p (a ^ (k + 1))

tactic: exact finite_mul hp ha (finite_pow hp ha)
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
p a : α
hp : Prime p
k : ℕ
ha : Finite p a
⊢ Finite p (a * a ^ k)
Theorem: IsCoprime.mul_right_iff
File: Mathlib/RingTheory/Coprime/Basic.lean

tactic: rw [isCoprime_comm, IsCoprime.mul_left_iff, isCoprime_comm, @isCoprime_comm _ _ z]
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
⊢ IsCoprime x (y * z) ↔ IsCoprime x y ∧ IsCoprime x z
Theorem: hasDerivAt_of_hasDerivAt_of_ne'
File: Mathlib/Analysis/Calculus/ExtendDeriv.lean

tactic: rcases eq_or_ne y x with (rfl | hne)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.151621
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f g : ℝ → E
x : ℝ
f_diff : ∀ (y : ℝ), y ≠ x → HasDerivAt f (g y) y
hf : ContinuousAt f x
hg : ContinuousAt g x
y : ℝ
⊢ HasDerivAt f (g y) y

tactic: exact hasDerivAt_of_hasDerivAt_of_ne f_diff hf hg
state_before: case inl
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.151621
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f g : ℝ → E
y : ℝ
f_diff : ∀ (y_1 : ℝ), y_1 ≠ y → HasDerivAt f (g y_1) y_1
hf : ContinuousAt f y
hg : ContinuousAt g y
⊢ HasDerivAt f (g y) y

tactic: exact f_diff y hne
state_before: case inr
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.151621
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f g : ℝ → E
x : ℝ
f_diff : ∀ (y : ℝ), y ≠ x → HasDerivAt f (g y) y
hf : ContinuousAt f x
hg : ContinuousAt g x
y : ℝ
hne : y ≠ x
⊢ HasDerivAt f (g y) y
Theorem: Ordinal.div_pos
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simp [lt_div h]
state_before: α : Type ?u.233480
β : Type ?u.233483
γ : Type ?u.233486
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
b c : Ordinal
h : c ≠ 0
⊢ 0 < b / c ↔ c ≤ b
Theorem: LiouvilleWith.exists_pos
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: rcases h with ⟨C, hC⟩
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
h : LiouvilleWith p x
⊢ ∃ C _h₀, ∃ᶠ (n : ℕ) in atTop, 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p

tactic: refine ⟨max C 1, zero_lt_one.trans_le <| le_max_right _ _, ?_⟩
state_before: case intro
p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ ∃ C _h₀, ∃ᶠ (n : ℕ) in atTop, 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p

tactic: refine ((eventually_ge_atTop 1).and_frequently hC).mono ?_
state_before: case intro
p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ ∃ᶠ (n : ℕ) in atTop, 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < max C 1 / ↑n ^ p

tactic: rintro n ⟨hle, m, hne, hlt⟩
state_before: case intro
p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ ∀ (x_1 : ℕ),
    (1 ≤ x_1 ∧ ∃ m, x ≠ ↑m / ↑x_1 ∧ abs (x - ↑m / ↑x_1) < C / ↑x_1 ^ p) →
      1 ≤ x_1 ∧ ∃ m, x ≠ ↑m / ↑x_1 ∧ abs (x - ↑m / ↑x_1) < max C 1 / ↑x_1 ^ p

tactic: refine ⟨hle, m, hne, hlt.trans_le ?_⟩
state_before: case intro.intro.intro.intro
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
hle : 1 ≤ n
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ 1 ≤ n ∧ ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < max C 1 / ↑n ^ p

tactic: exact div_le_div_of_le (rpow_nonneg_of_nonneg n.cast_nonneg _) (le_max_left _ _)
state_before: case intro.intro.intro.intro
p q x y : ℝ
r : ℚ
m✝ : ℤ
n✝ : ℕ
C : ℝ
hC : ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ abs (x - ↑m / ↑n) < C / ↑n ^ p
n : ℕ
hle : 1 ≤ n
m : ℤ
hne : x ≠ ↑m / ↑n
hlt : abs (x - ↑m / ↑n) < C / ↑n ^ p
⊢ C / ↑n ^ p ≤ max C 1 / ↑n ^ p
Theorem: EReal.openEmbedding_coe
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [range_coe_eq_Ioo, isOpen_Ioo]
state_before: α : Type ?u.2194
inst✝ : TopologicalSpace α
⊢ IsOpen (range Real.toEReal)
Theorem: Rack.ad_conj
File: Mathlib/Algebra/Quandle.lean

tactic: rw [eq_mul_inv_iff_mul_eq]
state_before: R✝ : Type ?u.26283
inst✝¹ : Rack R✝
R : Type u_1
inst✝ : Rack R
x y : R
⊢ act' (x ◃ y) = act' x * act' y * (act' x)⁻¹

tactic: ext z
state_before: R✝ : Type ?u.26283
inst✝¹ : Rack R✝
R : Type u_1
inst✝ : Rack R
x y : R
⊢ act' (x ◃ y) * act' x = act' x * act' y

tactic: apply self_distrib.symm
state_before: case H
R✝ : Type ?u.26283
inst✝¹ : Rack R✝
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ ↑(act' (x ◃ y) * act' x) z = ↑(act' x * act' y) z