tasksource/leandojo huggingface dataset:
Theorem: ContinuousLinearMap.op_norm_le_bound'
File: Mathlib/Analysis/NormedSpace/OperatorNorm.lean

tactic: simp only [h, MulZeroClass.mul_zero, norm_image_of_norm_zero f f.2 h, le_refl]
state_before: 𝕜 : Type u_1
𝕜₂ : Type u_2
𝕜₃ : Type ?u.267674
E : Type u_3
Eₗ : Type ?u.267680
F : Type u_4
Fₗ : Type ?u.267686
G : Type ?u.267689
Gₗ : Type ?u.267692
𝓕 : Type ?u.267695
inst✝¹⁵ : SeminormedAddCommGroup E
inst✝¹⁴ : SeminormedAddCommGroup Eₗ
inst✝¹³ : SeminormedAddCommGroup F
inst✝¹² : SeminormedAddCommGroup Fₗ
inst✝¹¹ : SeminormedAddCommGroup G
inst✝¹⁰ : SeminormedAddCommGroup Gₗ
inst✝⁹ : NontriviallyNormedField 𝕜
inst✝⁸ : NontriviallyNormedField 𝕜₂
inst✝⁷ : NontriviallyNormedField 𝕜₃
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜 Eₗ
inst✝⁴ : NormedSpace 𝕜₂ F
inst✝³ : NormedSpace 𝕜 Fₗ
inst✝² : NormedSpace 𝕜₃ G
inst✝¹ : NormedSpace 𝕜 Gₗ
σ₁₂ : 𝕜 →+* 𝕜₂
σ₂₃ : 𝕜₂ →+* 𝕜₃
σ₁₃ : 𝕜 →+* 𝕜₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
f : E →SL[σ₁₂] F
M : ℝ
hMp : 0 ≤ M
hM : ∀ (x : E), ‖x‖ ≠ 0 → ‖↑f x‖ ≤ M * ‖x‖
x : E
h : ‖x‖ = 0
⊢ ‖↑f x‖ ≤ M * ‖x‖
Theorem: Cycle.isCycle_formPerm
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

tactic: induction s using Quot.inductionOn
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s' s : Cycle α
h : Nodup s
hn : Nontrivial s
⊢ IsCycle (formPerm s h)

tactic: exact List.isCycle_formPerm h (length_nontrivial hn)
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
hn : Nontrivial (Quot.mk Setoid.r a✝)
⊢ IsCycle (formPerm (Quot.mk Setoid.r a✝) h)
Theorem: Equiv.Perm.signBijAux_surj
File: Mathlib/GroupTheory/Perm/Sign.lean

tactic: dsimp [signBijAux]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ↑f⁻¹ a₂ < ↑f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } = signBijAux f { fst := ↑f⁻¹ a₁, snd := ↑f⁻¹ a₂ }

tactic: rw [apply_inv_self, apply_inv_self, if_pos (mem_finPairsLT.1 ha)]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ↑f⁻¹ a₂ < ↑f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } =
    if ↑f (↑f⁻¹ a₂) < ↑f (↑f⁻¹ a₁) then { fst := ↑f (↑f⁻¹ a₁), snd := ↑f (↑f⁻¹ a₂) }
    else { fst := ↑f (↑f⁻¹ a₂), snd := ↑f (↑f⁻¹ a₁) }

tactic: simp [mem_finPairsLT, f⁻¹.injective h, lt_irrefl] at ha
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ¬↑f⁻¹ a₂ < ↑f⁻¹ a₁
h : ↑f⁻¹ a₁ = ↑f⁻¹ a₂
⊢ False

tactic: dsimp [signBijAux]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ¬↑f⁻¹ a₂ < ↑f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } = signBijAux f { fst := ↑f⁻¹ a₂, snd := ↑f⁻¹ a₁ }

tactic: rw [apply_inv_self, apply_inv_self, if_neg (mem_finPairsLT.1 ha).le.not_lt]
state_before: α : Type u
β : Type v
inst✝ : DecidableEq α
n : ℕ
f : Perm (Fin n)
x✝ : (_ : Fin n) × Fin n
a₁ a₂ : Fin n
ha : { fst := a₁, snd := a₂ } ∈ finPairsLT n
hxa : ¬↑f⁻¹ a₂ < ↑f⁻¹ a₁
⊢ { fst := a₁, snd := a₂ } =
    if ↑f (↑f⁻¹ a₁) < ↑f (↑f⁻¹ a₂) then { fst := ↑f (↑f⁻¹ a₂), snd := ↑f (↑f⁻¹ a₁) }
    else { fst := ↑f (↑f⁻¹ a₁), snd := ↑f (↑f⁻¹ a₂) }
Theorem: ADEInequality.sumInv_pqr
File: Mathlib/NumberTheory/ADEInequality.lean

tactic: simp only [sumInv, add_zero, insert_eq_cons, add_assoc, map_cons, sum_cons,
  map_singleton, sum_singleton]
state_before: p q r : ℕ+
⊢ sumInv {p, q, r} = (↑↑p)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹
Theorem: exists_quadratic_eq_zero
File: Mathlib/Algebra/QuadraticDiscriminant.lean

tactic: rcases h with ⟨s, hs⟩
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x : K
ha : a ≠ 0
h : ∃ s, discrim a b c = s * s
⊢ ∃ x, a * x * x + b * x + c = 0

tactic: use (-b + s) / (2 * a)
state_before: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x : K
ha : a ≠ 0
s : K
hs : discrim a b c = s * s
⊢ ∃ x, a * x * x + b * x + c = 0

tactic: rw [quadratic_eq_zero_iff ha hs]
state_before: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x : K
ha : a ≠ 0
s : K
hs : discrim a b c = s * s
⊢ a * ((-b + s) / (2 * a)) * ((-b + s) / (2 * a)) + b * ((-b + s) / (2 * a)) + c = 0

tactic: simp
state_before: case intro
K : Type u_1
inst✝¹ : Field K
inst✝ : NeZero 2
a b c x : K
ha : a ≠ 0
s : K
hs : discrim a b c = s * s
⊢ (-b + s) / (2 * a) = (-b + s) / (2 * a) ∨ (-b + s) / (2 * a) = (-b - s) / (2 * a)
Theorem: CategoryTheory.Limits.image.preComp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: dsimp [image.preComp]
state_before: C : Type u
inst✝² : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝¹ : HasImage g
inst✝ : HasImage (f ≫ g)
⊢ preComp f g ≫ ι g = ι (f ≫ g)

tactic: rw [image.lift_fac]
state_before: C : Type u
inst✝² : Category C
X Y : C
f : X ⟶ Y
Z : C
g : Y ⟶ Z
inst✝¹ : HasImage g
inst✝ : HasImage (f ≫ g)
⊢ lift (MonoFactorisation.mk (image g) (ι g) (f ≫ factorThruImage g)) ≫ ι g = ι (f ≫ g)
Theorem: Subgroup.range_mem_leftTransversals
File: Mathlib/GroupTheory/Complement.lean

tactic: rintro ⟨-, q₁, rfl⟩ ⟨-, q₂, rfl⟩ h
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : G ⧸ H → G
hf : ∀ (q : G ⧸ H), ↑(f q) = q
⊢ Function.Injective (Set.restrict (Set.range f) Quotient.mk'')

tactic: exact Subtype.ext $ congr_arg f $ ((hf q₁).symm.trans h).trans (hf q₂)
state_before: case mk.intro.mk.intro
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
f : G ⧸ H → G
hf : ∀ (q : G ⧸ H), ↑(f q) = q
q₁ q₂ : G ⧸ H
h :
  Set.restrict (Set.range f) Quotient.mk'' { val := f q₁, property := (_ : ∃ y, f y = f q₁) } =
    Set.restrict (Set.range f) Quotient.mk'' { val := f q₂, property := (_ : ∃ y, f y = f q₂) }
⊢ { val := f q₁, property := (_ : ∃ y, f y = f q₁) } = { val := f q₂, property := (_ : ∃ y, f y = f q₂) }
Theorem: Complex.tendsto_abs_tan_of_cos_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean

tactic: simp only [tan_eq_sin_div_cos, ← norm_eq_abs, norm_div]
state_before: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => ↑abs (tan x)) (𝓝[{x}ᶜ] x) atTop

tactic: have A : sin x ≠ 0 := fun h => by simpa [*, sq] using sin_sq_add_cos_sq x
state_before: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[{x}ᶜ] x) atTop

tactic: have B : Tendsto cos (𝓝[≠] x) (𝓝[≠] 0) :=
  hx ▸ (hasDerivAt_cos x).tendsto_punctured_nhds (neg_ne_zero.2 A)
state_before: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[{x}ᶜ] x) atTop

tactic: exact continuous_sin.continuousWithinAt.norm.mul_atTop (norm_pos_iff.2 A)
  (tendsto_norm_nhdsWithin_zero.comp B).inv_tendsto_zero
state_before: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
B : Tendsto cos (𝓝[{x}ᶜ] x) (𝓝[{0}ᶜ] 0)
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[{x}ᶜ] x) atTop

tactic: simpa [*, sq] using sin_sq_add_cos_sq x
state_before: x : ℂ
hx : cos x = 0
h : sin x = 0
⊢ False
Theorem: Set.Iio_union_Ico
File: Mathlib/Data/Set/Intervals/Basic.lean

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

tactic: exact Iio_union_Ico' h
state_before: case inl
α : Type u_1
β : Type ?u.97957
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : c ≤ d
h : c ≤ b
⊢ Iio b ∪ Ico c d = Iio (max b d)

tactic: simp [*]
state_before: case inr
α : Type u_1
β : Type ?u.97957
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
hcd : d ≤ c
h : d ≤ b
⊢ Iio b ∪ Ico c d = Iio (max b d)
Theorem: QuotientGroup.map_map
File: Mathlib/GroupTheory/QuotientGroup.lean

tactic: refine' induction_on' x fun x => _
state_before: G : Type u
inst✝⁴ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝³ : Group H
I : Type u_1
inst✝² : Group I
M : Subgroup H
O : Subgroup I
inst✝¹ : Subgroup.Normal M
inst✝ : Subgroup.Normal O
f : G →* H
g : H →* I
hf : N ≤ Subgroup.comap f M
hg : M ≤ Subgroup.comap g O
hgf : optParam (N ≤ Subgroup.comap (MonoidHom.comp g f) O) (_ : N ≤ Subgroup.comap (MonoidHom.comp g f) O)
x : G ⧸ N
⊢ ↑(map M O g hg) (↑(map N M f hf) x) = ↑(map N O (MonoidHom.comp g f) hgf) x

tactic: simp only [map_mk, MonoidHom.comp_apply]
state_before: G : Type u
inst✝⁴ : Group G
N : Subgroup G
nN : Subgroup.Normal N
H : Type v
inst✝³ : Group H
I : Type u_1
inst✝² : Group I
M : Subgroup H
O : Subgroup I
inst✝¹ : Subgroup.Normal M
inst✝ : Subgroup.Normal O
f : G →* H
g : H →* I
hf : N ≤ Subgroup.comap f M
hg : M ≤ Subgroup.comap g O
hgf : optParam (N ≤ Subgroup.comap (MonoidHom.comp g f) O) (_ : N ≤ Subgroup.comap (MonoidHom.comp g f) O)
x✝ : G ⧸ N
x : G
⊢ ↑(map M O g hg) (↑(map N M f hf) ↑x) = ↑(map N O (MonoidHom.comp g f) hgf) ↑x
Theorem: CategoryTheory.epi_iff_exact_zero_right
File: Mathlib/Algebra/Homology/Exact.lean

tactic: have e₁ := h.epi
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B✝ C D : V
f✝ : A✝ ⟶ B✝
g : B✝ ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasEqualizers V
A B : V
f : A ⟶ B
h : Exact f 0
⊢ Epi f

tactic: rw [imageToKernel_zero_right] at e₁
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B✝ C D : V
f✝ : A✝ ⟶ B✝
g : B✝ ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasEqualizers V
A B : V
f : A ⟶ B
h : Exact f 0
e₁ : Epi (imageToKernel f 0 (_ : f ≫ 0 = 0))
⊢ Epi f

tactic: have e₂ : Epi (((imageSubobject f).arrow ≫ inv (kernelSubobject 0).arrow) ≫
      (kernelSubobject 0).arrow) := @epi_comp _ _ _ _ _ _ e₁ _ _
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B✝ C D : V
f✝ : A✝ ⟶ B✝
g : B✝ ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasEqualizers V
A B : V
f : A ⟶ B
h : Exact f 0
e₁ : Epi (Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0)))
⊢ Epi f

tactic: rw [Category.assoc, IsIso.inv_hom_id, Category.comp_id] at e₂
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B✝ C D : V
f✝ : A✝ ⟶ B✝
g : B✝ ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasEqualizers V
A B : V
f : A ⟶ B
h : Exact f 0
e₁ : Epi (Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0)))
e₂ :
  Epi
    ((Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0))) ≫
      Subobject.arrow (kernelSubobject 0))
⊢ Epi f

tactic: rw [← imageSubobject_arrow] at e₂
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B✝ C D : V
f✝ : A✝ ⟶ B✝
g : B✝ ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasEqualizers V
A B : V
f : A ⟶ B
h : Exact f 0
e₁ : Epi (Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0)))
e₂ : Epi (Subobject.arrow (imageSubobject f))
⊢ Epi f

tactic: haveI : Epi (image.ι f) := epi_of_epi (imageSubobjectIso f).hom (image.ι f)
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B✝ C D : V
f✝ : A✝ ⟶ B✝
g : B✝ ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasEqualizers V
A B : V
f : A ⟶ B
h : Exact f 0
e₁ : Epi (Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0)))
e₂ : Epi ((imageSubobjectIso f).hom ≫ image.ι f)
⊢ Epi f

tactic: apply epi_of_epi_image
state_before: V : Type u
inst✝⁴ : Category V
inst✝³ : HasImages V
A✝ B✝ C D : V
f✝ : A✝ ⟶ B✝
g : B✝ ⟶ C
h✝ : C ⟶ D
inst✝² : HasZeroObject V
inst✝¹ : Preadditive V
inst✝ : HasEqualizers V
A B : V
f : A ⟶ B
h : Exact f 0
e₁ : Epi (Subobject.arrow (imageSubobject f) ≫ inv (Subobject.arrow (kernelSubobject 0)))
e₂ : Epi ((imageSubobjectIso f).hom ≫ image.ι f)
this : Epi (image.ι f)
⊢ Epi f
Theorem: FDerivMeasurableAux.a_mono
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: rintro x ⟨r', r'r, hr'⟩
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
⊢ A f L r ε ⊆ A f L r δ

tactic: refine' ⟨r', r'r, fun y hy z hz => (hr' y hy z hz).trans (mul_le_mul_of_nonneg_right h _)⟩
state_before: case intro.intro
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
x : E
r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : E), y ∈ ball x r' → ∀ (z : E), z ∈ ball x r' → ‖f z - f y - ↑L (z - y)‖ ≤ ε * r
⊢ x ∈ A f L r δ

tactic: linarith [mem_ball.1 hy, r'r.2, @dist_nonneg _ _ y x]
state_before: case intro.intro
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
L : E →L[𝕜] F
r ε δ : ℝ
h : ε ≤ δ
x : E
r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : E), y ∈ ball x r' → ∀ (z : E), z ∈ ball x r' → ‖f z - f y - ↑L (z - y)‖ ≤ ε * r
y : E
hy : y ∈ ball x r'
z : E
hz : z ∈ ball x r'
⊢ 0 ≤ r
Theorem: Submodule.sup_toAddSubmonoid
File: Mathlib/LinearAlgebra/Span.lean

tactic: ext x
state_before: R : Type u_2
R₂ : Type ?u.109627
K : Type ?u.109630
M : Type u_1
M₂ : Type ?u.109636
V : Type ?u.109639
S : Type ?u.109642
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
⊢ (p ⊔ p').toAddSubmonoid = p.toAddSubmonoid ⊔ p'.toAddSubmonoid

tactic: rw [mem_toAddSubmonoid, mem_sup, AddSubmonoid.mem_sup]
state_before: case h
R : Type u_2
R₂ : Type ?u.109627
K : Type ?u.109630
M : Type u_1
M₂ : Type ?u.109636
V : Type ?u.109639
S : Type ?u.109642
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝ : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x : M
⊢ x ∈ (p ⊔ p').toAddSubmonoid ↔ x ∈ p.toAddSubmonoid ⊔ p'.toAddSubmonoid

tactic: rfl
state_before: case h
R : Type u_2
R₂ : Type ?u.109627
K : Type ?u.109630
M : Type u_1
M₂ : Type ?u.109636
V : Type ?u.109639
S : Type ?u.109642
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x✝ : M
p p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
x : M
⊢ (∃ y, y ∈ p ∧ ∃ z, z ∈ p' ∧ y + z = x) ↔ ∃ y, y ∈ p.toAddSubmonoid ∧ ∃ z, z ∈ p'.toAddSubmonoid ∧ y + z = x
Theorem: List.pairwise_sublists
File: Mathlib/Data/List/Sublists.lean

tactic: have := (pairwise_reverse.2 H).sublists'
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
l : List α
H : Pairwise R l
⊢ Pairwise (fun l₁ l₂ => Lex R (reverse l₁) (reverse l₂)) (sublists l)

tactic: rwa [sublists'_reverse, pairwise_map] at this
state_before: α : Type u
β : Type v
γ : Type w
R : α → α → Prop
l : List α
H : Pairwise R l
this : Pairwise (Lex (swap fun b a => R a b)) (sublists' (reverse l))
⊢ Pairwise (fun l₁ l₂ => Lex R (reverse l₁) (reverse l₂)) (sublists l)
Theorem: Multiset.Nat.antidiagonal_succ'
File: Mathlib/Data/Multiset/NatAntidiagonal.lean

tactic: rw [antidiagonal, List.Nat.antidiagonal_succ', ← coe_add, add_comm, antidiagonal, coe_map,
  coe_add, List.singleton_append, cons_coe]
state_before: n : ℕ
⊢ antidiagonal (n + 1) = (n + 1, 0) ::ₘ map (Prod.map id Nat.succ) (antidiagonal n)
Theorem: Stream'.bisim_simple
File: Mathlib/Data/Stream/Init.lean

tactic: constructor
state_before: α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : head s₁✝ = head s₂✝
ht₁ : s₁✝ = tail s₁✝
ht₂ : s₂✝ = tail s₂✝
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂
h₁ : head s₁ = head s₂
h₂ : s₁ = tail s₁
h₃ : s₂ = tail s₂
⊢ head s₁ = head s₂ ∧ (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) (tail s₁) (tail s₂)

tactic: exact h₁
state_before: case left
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : head s₁✝ = head s₂✝
ht₁ : s₁✝ = tail s₁✝
ht₂ : s₂✝ = tail s₂✝
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂
h₁ : head s₁ = head s₂
h₂ : s₁ = tail s₁
h₃ : s₂ = tail s₂
⊢ head s₁ = head s₂

case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : head s₁✝ = head s₂✝
ht₁ : s₁✝ = tail s₁✝
ht₂ : s₂✝ = tail s₂✝
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂
h₁ : head s₁ = head s₂
h₂ : s₁ = tail s₁
h₃ : s₂ = tail s₂
⊢ (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) (tail s₁) (tail s₂)

tactic: rw [← h₂, ← h₃]
state_before: case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : head s₁✝ = head s₂✝
ht₁ : s₁✝ = tail s₁✝
ht₂ : s₂✝ = tail s₂✝
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂
h₁ : head s₁ = head s₂
h₂ : s₁ = tail s₁
h₃ : s₂ = tail s₂
⊢ (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) (tail s₁) (tail s₂)

tactic: (repeat' constructor) <;> assumption
state_before: case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : head s₁✝ = head s₂✝
ht₁ : s₁✝ = tail s₁✝
ht₂ : s₂✝ = tail s₂✝
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂
h₁ : head s₁ = head s₂
h₂ : s₁ = tail s₁
h₃ : s₂ = tail s₂
⊢ (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂

tactic: repeat' constructor
state_before: case right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : head s₁✝ = head s₂✝
ht₁ : s₁✝ = tail s₁✝
ht₂ : s₂✝ = tail s₂✝
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂
h₁ : head s₁ = head s₂
h₂ : s₁ = tail s₁
h₃ : s₂ = tail s₂
⊢ (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂

tactic: constructor
state_before: case right.right.right
α : Type u
β : Type v
δ : Type w
s₁✝ s₂✝ : Stream' α
hh : head s₁✝ = head s₂✝
ht₁ : s₁✝ = tail s₁✝
ht₂ : s₂✝ = tail s₂✝
s₁ s₂ : Stream' α
x✝ : (fun s₁ s₂ => head s₁ = head s₂ ∧ s₁ = tail s₁ ∧ s₂ = tail s₂) s₁ s₂
h₁ : head s₁ = head s₂
h₂ : s₁ = tail s₁
h₃ : s₂ = tail s₂
⊢ s₂ = tail s₂
Theorem: MeasureTheory.OuterMeasure.iUnion_null
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: simpa [h] using m.iUnion s
state_before: α : Type u_2
β : Type u_1
R : Type ?u.3292
R' : Type ?u.3295
ms : Set (OuterMeasure α)
m✝ : OuterMeasure α
inst✝ : Countable β
m : OuterMeasure α
s : β → Set α
h : ∀ (i : β), ↑m (s i) = 0
⊢ ↑m (⋃ (i : β), s i) = 0
Theorem: Ordinal.mod_mod_of_dvd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: nth_rw 2 [← div_add_mod a b]
state_before: α : Type ?u.268594
β : Type ?u.268597
γ : Type ?u.268600
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
h : c ∣ b
⊢ a % b % c = a % c

tactic: rcases h with ⟨d, rfl⟩
state_before: α : Type ?u.268594
β : Type ?u.268597
γ : Type ?u.268600
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal
h : c ∣ b
⊢ a % b % c = (b * (a / b) + a % b) % c

tactic: rw [mul_assoc, mul_add_mod_self]
state_before: case intro
α : Type ?u.268594
β : Type ?u.268597
γ : Type ?u.268600
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a c d : Ordinal
⊢ a % (c * d) % c = (c * d * (a / (c * d)) + a % (c * d)) % c
Theorem: Ioo_toDual
File: Mathlib/Order/LocallyFinite.lean

tactic: refine' Eq.trans _ map_refl.symm
state_before: α : Type u_1
β : Type ?u.113900
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
⊢ Ioo (↑toDual a) (↑toDual b) = map (Equiv.toEmbedding toDual) (Ioo b a)

tactic: ext c
state_before: α : Type u_1
β : Type ?u.113900
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
⊢ Ioo (↑toDual a) (↑toDual b) = Ioo b a

tactic: rw [mem_Ioo, mem_Ioo (α := α)]
state_before: case a
α : Type u_1
β : Type ?u.113900
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
c : (fun x => αᵒᵈ) a
⊢ c ∈ Ioo (↑toDual a) (↑toDual b) ↔ c ∈ Ioo b a

tactic: exact and_comm
state_before: case a
α : Type u_1
β : Type ?u.113900
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : LocallyFiniteOrder α
a b : α
c : (fun x => αᵒᵈ) a
⊢ ↑toDual a < c ∧ c < ↑toDual b ↔ b < c ∧ c < a
Theorem: Nat.dvd_iff_prime_pow_dvd_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: n d : ℕ
⊢ d ∣ n ↔ ∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ n

tactic: rcases eq_or_ne d 0 with (rfl | hd)
state_before: case inr
n d : ℕ
hn : n ≠ 0
⊢ d ∣ n ↔ ∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ n

tactic: refine' ⟨fun h p k _ hpkd => dvd_trans hpkd h, _⟩
state_before: case inr.inr
n d : ℕ
hn : n ≠ 0
hd : d ≠ 0
⊢ d ∣ n ↔ ∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ n

tactic: rw [← factorization_prime_le_iff_dvd hd hn]
state_before: case inr.inr
n d : ℕ
hn : n ≠ 0
hd : d ≠ 0
⊢ (∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ n) → d ∣ n

tactic: intro h p pp
state_before: case inr.inr
n d : ℕ
hn : n ≠ 0
hd : d ≠ 0
⊢ (∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ n) → ∀ (p : ℕ), Prime p → ↑(factorization d) p ≤ ↑(factorization n) p

tactic: simp_rw [← pp.pow_dvd_iff_le_factorization hn]
state_before: case inr.inr
n d : ℕ
hn : n ≠ 0
hd : d ≠ 0
h : ∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ n
p : ℕ
pp : Prime p
⊢ ↑(factorization d) p ≤ ↑(factorization n) p

tactic: exact h p _ pp (ord_proj_dvd _ _)
state_before: case inr.inr
n d : ℕ
hn : n ≠ 0
hd : d ≠ 0
h : ∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ n
p : ℕ
pp : Prime p
⊢ p ^ ↑(factorization d) p ∣ n

tactic: simp
state_before: case inl
d : ℕ
⊢ d ∣ 0 ↔ ∀ (p k : ℕ), Prime p → p ^ k ∣ d → p ^ k ∣ 0

tactic: simp only [zero_dvd_iff, hn, false_iff_iff, not_forall]
state_before: case inr.inl
n : ℕ
hn : n ≠ 0
⊢ 0 ∣ n ↔ ∀ (p k : ℕ), Prime p → p ^ k ∣ 0 → p ^ k ∣ n

tactic: exact ⟨2, n, prime_two, dvd_zero _, mt (le_of_dvd hn.bot_lt) (lt_two_pow n).not_le⟩
state_before: case inr.inl
n : ℕ
hn : n ≠ 0
⊢ ∃ x x_1 h x_2, ¬x ^ x_1 ∣ n
Theorem: singleton_mul_closedBall_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ {x} * closedBall 1 δ = closedBall x δ
Theorem: Metric.continuousWithinAt_iff
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [ContinuousWithinAt, tendsto_nhdsWithin_nhds]
state_before: α : Type u
β : Type v
X : Type ?u.101350
ι : Type ?u.101353
inst✝¹ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : PseudoMetricSpace β
f : α → β
a : α
s : Set α
⊢ ContinuousWithinAt f s a ↔ ∀ (ε : ℝ), ε > 0 → ∃ δ, δ > 0 ∧ ∀ {x : α}, x ∈ s → dist x a < δ → dist (f x) (f a) < ε
Theorem: NNReal.tendsto_inverse_atTop_nhds_0_nat
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: rw [← NNReal.tendsto_coe]
state_before: α : Type ?u.1359
β : Type ?u.1362
ι : Type ?u.1365
⊢ Tendsto (fun n => (↑n)⁻¹) atTop (𝓝 0)

tactic: exact _root_.tendsto_inverse_atTop_nhds_0_nat
state_before: α : Type ?u.1359
β : Type ?u.1362
ι : Type ?u.1365
⊢ Tendsto (fun a => ↑(↑a)⁻¹) atTop (𝓝 ↑0)
Theorem: MeasureTheory.AEEqFun.lintegral_coeFn
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← lintegral_mk, mk_coeFn]
state_before: α : Type u_1
β : Type ?u.1574917
γ : Type ?u.1574920
δ : Type ?u.1574923
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α →ₘ[μ] ℝ≥0∞
⊢ (∫⁻ (a : α), ↑f a ∂μ) = lintegral f
Theorem: Real.Angle.cos_coe_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [cos_coe, Real.cos_pi]
state_before: ⊢ cos ↑π = -1
Theorem: TopologicalGroup.t1Space
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: convert isClosedMap_mul_right x _ h
state_before: α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsClosed {1}
x : G
⊢ IsClosed {x}

tactic: simp
state_before: case h.e'_3
α : Type u
β : Type v
G : Type w
H : Type x
inst✝² : TopologicalSpace G
inst✝¹ : Group G
inst✝ : ContinuousMul G
h : IsClosed {1}
x : G
⊢ {x} = (fun x_1 => x_1 * x) '' {1}