1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Prod.fst_eq_or_snd_eq_of_wcovBy
File: Mathlib/Order/Cover.lean

tactic: refine fun h => of_not_not fun hab => ?_
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ x ⩿ y → x.1 = y.1 ∨ x.2 = y.2
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : x ⩿ y
hab : ¬(x.1 = y.1 ∨ x.2 = y.2)
⊢ False

tactic: push_neg at hab
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : x ⩿ y
hab : ¬(x.1 = y.1 ∨ x.2 = y.2)
⊢ False
state_after: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : x ⩿ y
hab : x.1 ≠ y.1 ∧ x.2 ≠ y.2
⊢ False

tactic: exact
  h.2 (mk_lt_mk.2 <| Or.inl ⟨hab.1.lt_of_le h.1.1, le_rfl⟩)
    (mk_lt_mk.2 <| Or.inr ⟨le_rfl, hab.2.lt_of_le h.1.2⟩)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : x ⩿ y
hab : x.1 ≠ y.1 ∧ x.2 ≠ y.2
⊢ False
state_after: no goals
Theorem: IsSubmonoid.list_prod_mem
File: Mathlib/Deprecated/Submonoid.lean

tactic: simpa
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
hs : IsSubmonoid s
a : M
l : List M
h : ∀ x ∈ a :: l, x ∈ s
this : a * l.prod ∈ s
⊢ (a :: l).prod ∈ s
state_after: no goals

tactic: simpa using h
state_before: M : Type u_1
inst✝¹ : Monoid M
s : Set M
A : Type u_2
inst✝ : AddMonoid A
t : Set A
hs : IsSubmonoid s
a : M
l : List M
h : ∀ x ∈ a :: l, x ∈ s
⊢ a ∈ s ∧ ∀ x ∈ l, x ∈ s
state_after: no goals
Theorem: Finset.attach_image_val
File: Mathlib/Data/Finset/Image.lean

tactic: rw [image_val, attach_val, Multiset.attach_map_val, dedup_eq_self]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq β
f g : α → β
s✝ : Finset α
t : Finset β
a : α
b c : β
inst✝ : DecidableEq α
s : Finset α
⊢ (image Subtype.val s.attach).val = s.val
state_after: no goals
Theorem: TopCat.Presheaf.stalkPushforward_germ
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: simp [germ, stalkPushforward]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
U : Opens ↑Y
x : ↥((Opens.map f).obj U)
⊢ (f _* F).germ ⟨f ↑x, ⋯⟩ ≫ stalkPushforward C f F ↑x = F.germ x
state_after: no goals
Theorem: List.foldr_concat
File: Mathlib/Data/List/Basic.lean

tactic: simp only [List.foldr_append, List.foldr]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β → β
b : β
x : α
xs : List α
⊢ foldr f b (xs ++ [x]) = foldr f (f x b) xs
state_after: no goals
Theorem: AlgHom.card
File: Mathlib/FieldTheory/PrimitiveElement.lean

tactic: convert (AlgHom.card_of_powerBasis (L := K) (Field.powerBasisOfFiniteOfSeparable F E)
  (IsSeparable.separable _ _) (IsAlgClosed.splits_codomain _)).trans (PowerBasis.finrank _).symm
state_before: F : Type u_1
E : Type u_2
inst✝⁷ : Field F
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
inst✝⁴ : FiniteDimensional F E
inst✝³ : IsSeparable F E
K : Type u_3
inst✝² : Field K
inst✝¹ : IsAlgClosed K
inst✝ : Algebra F K
⊢ Fintype.card (E →ₐ[F] K) = finrank F E
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.map_eq_of_iso
File: Mathlib/CategoryTheory/MorphismProperty/Basic.lean

tactic: revert F G e
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty C
F G : C ⥤ D
e : F ≅ G
⊢ P.map F = P.map G
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty C
⊢ ∀ {F G : C ⥤ D}, (F ≅ G) → P.map F = P.map G

tactic: suffices ∀ {F G : C ⥤ D} (_ : F ≅ G), P.map F ≤ P.map G from
  fun F G e => le_antisymm (this e) (this e.symm)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty C
⊢ ∀ {F G : C ⥤ D}, (F ≅ G) → P.map F = P.map G
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty C
⊢ ∀ {F G : C ⥤ D}, (F ≅ G) → P.map F ≤ P.map G

tactic: intro F G e X Y f ⟨X', Y', f', hf', ⟨e'⟩⟩
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty C
⊢ ∀ {F G : C ⥤ D}, (F ≅ G) → P.map F ≤ P.map G
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty C
F G : C ⥤ D
e : F ≅ G
X Y : D
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
hf' : P f'
e' : Arrow.mk (F.map f') ≅ Arrow.mk f
⊢ P.map G f

tactic: exact ⟨X', Y', f', hf', ⟨((Functor.mapArrowFunctor _ _).mapIso e.symm).app (Arrow.mk f') ≪≫ e'⟩⟩
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u_1
inst✝ : Category.{u_2, u_1} D
P : MorphismProperty C
F G : C ⥤ D
e : F ≅ G
X Y : D
f : X ⟶ Y
X' Y' : C
f' : X' ⟶ Y'
hf' : P f'
e' : Arrow.mk (F.map f') ≅ Arrow.mk f
⊢ P.map G f
state_after: no goals
Theorem: Filter.map_pure_prod
File: Mathlib/Order/Filter/Prod.lean

tactic: rw [Filter.pure_prod]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : α → β → γ
a : α
B : Filter β
⊢ map (Function.uncurry f) (pure a ×ˢ B) = map (f a) B
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : α → β → γ
a : α
B : Filter β
⊢ map (Function.uncurry f) (map (Prod.mk a) B) = map (f a) B

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : α → β → γ
a : α
B : Filter β
⊢ map (Function.uncurry f) (map (Prod.mk a) B) = map (f a) B
state_after: no goals
Theorem: MeasureTheory.snorm'_exponent_zero
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: rw [snorm', div_zero, ENNReal.rpow_zero]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
⊢ snorm' f 0 μ = 1
state_after: no goals
Theorem: CategoryTheory.NonPreadditiveAbelian.add_zero
File: Mathlib/CategoryTheory/Abelian/NonPreadditive.lean

tactic: rw [add_def, neg_def, sub_self, sub_zero]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : NonPreadditiveAbelian C
X Y : C
a : X ⟶ Y
⊢ a + 0 = a
state_after: no goals
Theorem: Filter.Eventually.choice
File: Mathlib/Order/Filter/Basic.lean

tactic: haveI : Nonempty β := let ⟨_, hx⟩ := h.exists; hx.nonempty
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : l.NeBot
h : ∀ᶠ (x : α) in l, ∃ y, r x y
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : l.NeBot
h : ∀ᶠ (x : α) in l, ∃ y, r x y
this : Nonempty β
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)

tactic: choose! f hf using fun x (hx : ∃ y, r x y) => hx
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : l.NeBot
h : ∀ᶠ (x : α) in l, ∃ y, r x y
this : Nonempty β
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : l.NeBot
h : ∀ᶠ (x : α) in l, ∃ y, r x y
this : Nonempty β
f : α → β
hf : ∀ (x : α), (∃ y, r x y) → r x (f x)
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)

tactic: exact ⟨f, h.mono hf⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
r : α → β → Prop
l : Filter α
inst✝ : l.NeBot
h : ∀ᶠ (x : α) in l, ∃ y, r x y
this : Nonempty β
f : α → β
hf : ∀ (x : α), (∃ y, r x y) → r x (f x)
⊢ ∃ f, ∀ᶠ (x : α) in l, r x (f x)
state_after: no goals
Theorem: Polynomial.ext_iff
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rcases p with ⟨f : ℕ →₀ R⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ p q : R[X]
⊢ p = q ↔ ∀ (n : ℕ), p.coeff n = q.coeff n
state_after: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q✝ q : R[X]
f : ℕ →₀ R
⊢ { toFinsupp := f } = q ↔ ∀ (n : ℕ), { toFinsupp := f }.coeff n = q.coeff n

tactic: rcases q with ⟨g : ℕ →₀ R⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q✝ q : R[X]
f : ℕ →₀ R
⊢ { toFinsupp := f } = q ↔ ∀ (n : ℕ), { toFinsupp := f }.coeff n = q.coeff n
state_after: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
f g : ℕ →₀ R
⊢ { toFinsupp := f } = { toFinsupp := g } ↔ ∀ (n : ℕ), { toFinsupp := f }.coeff n = { toFinsupp := g }.coeff n

tactic: simpa [coeff] using DFunLike.ext_iff (f := f) (g := g)
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
f g : ℕ →₀ R
⊢ { toFinsupp := f } = { toFinsupp := g } ↔ ∀ (n : ℕ), { toFinsupp := f }.coeff n = { toFinsupp := g }.coeff n
state_after: no goals
Theorem: Sum.getRight_eq_getRight?
File: Mathlib/Data/Sum/Basic.lean

tactic: simp [← getRight?_eq_some_iff]
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
h₁ : x.isRight = true
h₂ : x.getRight?.isSome = true
⊢ x.getRight h₁ = x.getRight?.get h₂
state_after: no goals
Theorem: Complex.frontier_setOf_im_le
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [frontier_Iic] using frontier_preimage_im (Iic a)
state_before: a : ℝ
⊢ frontier {z | z.im ≤ a} = {z | z.im = a}
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.universally_le
File: Mathlib/CategoryTheory/MorphismProperty/Limits.lean

tactic: intro X Y f hf
state_before: C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
⊢ P.universally ≤ P
state_after: C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
X Y : C
f : X ⟶ Y
hf : P.universally f
⊢ P f

tactic: exact hf (𝟙 _) (𝟙 _) _ (IsPullback.of_vert_isIso ⟨by rw [Category.comp_id, Category.id_comp]⟩)
state_before: C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
X Y : C
f : X ⟶ Y
hf : P.universally f
⊢ P f
state_after: no goals

tactic: rw [Category.comp_id, Category.id_comp]
state_before: C : Type u
inst✝ : Category.{v, u} C
P : MorphismProperty C
X Y : C
f : X ⟶ Y
hf : P.universally f
⊢ f ≫ 𝟙 Y = 𝟙 X ≫ f
state_after: no goals
Theorem: Fin.lt_succ_castPred
File: Mathlib/Data/Fin/Basic.lean

tactic: rw [lt_succ_castPred_iff, le_def]
state_before: n m : ℕ
a : Fin (n + 1)
ha : a ≠ last n
⊢ a < (a.castPred ha).succ
state_after: no goals
Theorem: Geometry.SimplicialComplex.mem_space_iff
File: Mathlib/Analysis/Convex/SimplicialComplex/Basic.lean

tactic: simp [space]
state_before: 𝕜 : Type u_1
E : Type u_2
ι : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
K : SimplicialComplex 𝕜 E
s t : Finset E
x : E
⊢ x ∈ K.space ↔ ∃ s ∈ K.faces, x ∈ (convexHull 𝕜) ↑s
state_after: no goals
Theorem: Matrix.lieConj_symm_apply
File: Mathlib/Algebra/Lie/Matrix.lean

tactic: simp [LinearEquiv.symm_conj_apply, Matrix.lieConj, LinearMap.toMatrix'_comp,
  LinearMap.toMatrix'_toLin']
state_before: R : Type u
inst✝² : CommRing R
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
P A : Matrix n n R
h : Invertible P
⊢ (P.lieConj h).symm A = P⁻¹ * A * P
state_after: no goals
Theorem: Polynomial.card_roots_sub_C
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: rw [sub_eq_add_neg, ← C_neg]
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
a : R
hp0 : 0 < p.degree
⊢ (p - C a).degree = p.degree
state_after: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
a : R
hp0 : 0 < p.degree
⊢ (p + C (-a)).degree = p.degree

tactic: exact degree_add_C hp0
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
a : R
hp0 : 0 < p.degree
⊢ (p + C (-a)).degree = p.degree
state_after: no goals
Theorem: ArithmeticFunction.sigma_one_apply
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: simp [sigma_apply]
state_before: R : Type u_1
n : ℕ
⊢ (σ 1) n = ∑ d ∈ n.divisors, d
state_after: no goals
Theorem: HurwitzZeta.hurwitzZetaOdd_neg_two_mul_nat_sub_one
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

tactic: rw [hurwitzZetaOdd, Gammaℝ_eq_zero_iff.mpr ⟨n, by rw [neg_mul, sub_add_cancel]⟩, div_zero]
state_before: a : UnitAddCircle
n : ℕ
⊢ hurwitzZetaOdd a (-2 * ↑n - 1) = 0
state_after: no goals

tactic: rw [neg_mul, sub_add_cancel]
state_before: a : UnitAddCircle
n : ℕ
⊢ -2 * ↑n - 1 + 1 = -(2 * ↑n)
state_after: no goals
Theorem: ONote.fastGrowing_succ
File: Mathlib/SetTheory/Ordinal/Notation.lean

tactic: rw [fastGrowing_def h]
state_before: o a : ONote
h : o.fundamentalSequence = Sum.inl (some a)
⊢ o.fastGrowing = fun i => a.fastGrowing^[i] i
state_after: no goals
Theorem: exists_dist_eq
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: use a • x + b • z
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z✝ : E
δ ε : ℝ
x z : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ ∃ y, dist x y = b * dist x z ∧ dist y z = a * dist x z
state_after: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z✝ : E
δ ε : ℝ
x z : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ dist x (a • x + b • z) = b * dist x z ∧ dist (a • x + b • z) z = a * dist x z

tactic: nth_rw 1 [← one_smul ℝ x]
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z✝ : E
δ ε : ℝ
x z : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ dist x (a • x + b • z) = b * dist x z ∧ dist (a • x + b • z) z = a * dist x z
state_after: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z✝ : E
δ ε : ℝ
x z : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ dist (1 • x) (a • x + b • z) = b * dist x z ∧ dist (a • x + b • z) z = a * dist x z

tactic: nth_rw 4 [← one_smul ℝ z]
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z✝ : E
δ ε : ℝ
x z : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ dist (1 • x) (a • x + b • z) = b * dist x z ∧ dist (a • x + b • z) z = a * dist x z
state_after: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z✝ : E
δ ε : ℝ
x z : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ dist (1 • x) (a • x + b • z) = b * dist x z ∧ dist (a • x + b • z) (1 • z) = a * dist x z

tactic: simp [dist_eq_norm, ← hab, add_smul, ← smul_sub, norm_smul_of_nonneg, ha, hb]
state_before: case h
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x✝ y z✝ : E
δ ε : ℝ
x z : E
a b : ℝ
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ dist (1 • x) (a • x + b • z) = b * dist x z ∧ dist (a • x + b • z) (1 • z) = a * dist x z
state_after: no goals
Theorem: Filter.exists_seq_tendsto
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: obtain ⟨B, h⟩ := f.exists_antitone_basis
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : Filter α
inst✝¹ : f.IsCountablyGenerated
inst✝ : f.NeBot
⊢ ∃ x, Tendsto x atTop f
state_after: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : Filter α
inst✝¹ : f.IsCountablyGenerated
inst✝ : f.NeBot
B : ℕ → Set α
h : f.HasAntitoneBasis B
⊢ ∃ x, Tendsto x atTop f

tactic: choose x hx using fun n => Filter.nonempty_of_mem (h.mem n)
state_before: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : Filter α
inst✝¹ : f.IsCountablyGenerated
inst✝ : f.NeBot
B : ℕ → Set α
h : f.HasAntitoneBasis B
⊢ ∃ x, Tendsto x atTop f
state_after: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : Filter α
inst✝¹ : f.IsCountablyGenerated
inst✝ : f.NeBot
B : ℕ → Set α
h : f.HasAntitoneBasis B
x : ℕ → α
hx : ∀ (n : ℕ), x n ∈ B n
⊢ ∃ x, Tendsto x atTop f

tactic: exact ⟨x, h.tendsto hx⟩
state_before: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f : Filter α
inst✝¹ : f.IsCountablyGenerated
inst✝ : f.NeBot
B : ℕ → Set α
h : f.HasAntitoneBasis B
x : ℕ → α
hx : ∀ (n : ℕ), x n ∈ B n
⊢ ∃ x, Tendsto x atTop f
state_after: no goals
Theorem: Ideal.radical_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: refine le_antisymm ?_ fun r ⟨⟨m, hrm⟩, ⟨n, hrn⟩⟩ =>
  ⟨m + n, (pow_add r m n).symm ▸ mul_mem_mul hrm hrn⟩
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ (I * J).radical = I.radical ⊓ J.radical
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ (I * J).radical ≤ I.radical ⊓ J.radical

tactic: have := radical_mono <| @mul_le_inf _ _ I J
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ (I ⊓ J).radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical

tactic: simp_rw [radical_inf I J] at this
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ (I ⊓ J).radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ I.radical ⊓ J.radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical

tactic: assumption
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
this : (I * J).radical ≤ I.radical ⊓ J.radical
⊢ (I * J).radical ≤ I.radical ⊓ J.radical
state_after: no goals
Theorem: SemiNormedGrp.explicitCokernelπ_desc_apply
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

tactic: rw [explicitCokernelπ_desc]
state_before: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
cond : f ≫ g = 0
x : ↑Y
⊢ (explicitCokernelπ f ≫ explicitCokernelDesc cond) x = g x
state_after: no goals
Theorem: Homeomorph.isClosed_preimage
File: Mathlib/Topology/Homeomorph.lean

tactic: simp only [← isOpen_compl_iff, ← preimage_compl, isOpen_preimage]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
s : Set Y
⊢ IsClosed (⇑h ⁻¹' s) ↔ IsClosed s
state_after: no goals
Theorem: Finset.ne_insert_of_not_mem
File: Mathlib/Data/Finset/Basic.lean

tactic: contrapose! h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
h : a ∉ s
⊢ s ≠ insert a t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
h : s = insert a t
⊢ a ∈ s

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
h : s = insert a t
⊢ a ∈ s
state_after: no goals
Theorem: Odd.pos
File: Mathlib/Algebra/Order/Ring/Canonical.lean

tactic: rintro ⟨k, rfl⟩
state_before: α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
a b c d : α
inst✝ : Nontrivial α
⊢ Odd a → 0 < a
state_after: case intro
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
b c d : α
inst✝ : Nontrivial α
k : α
⊢ 0 < 2 * k + 1

tactic: simp [pos_iff_ne_zero]
state_before: case intro
α : Type u
β : Type u_1
inst✝¹ : CanonicallyOrderedCommSemiring α
b c d : α
inst✝ : Nontrivial α
k : α
⊢ 0 < 2 * k + 1
state_after: no goals
Theorem: TrivSqZeroExt.map_inr
File: Mathlib/Algebra/TrivSqZeroExt.lean

tactic: rw [map, liftEquivOfComm_apply, lift_apply_inr, LinearMap.comp_apply, inrHom_apply]
state_before: S : Type u_1
R R' : Type u
M : Type v
inst✝²⁶ : CommSemiring S
inst✝²⁵ : Semiring R
inst✝²⁴ : CommSemiring R'
inst✝²³ : AddCommMonoid M
inst✝²² : Algebra S R
inst✝²¹ : Algebra S R'
inst✝²⁰ : Module S M
inst✝¹⁹ : Module R M
inst✝¹⁸ : Module Rᵐᵒᵖ M
inst✝¹⁷ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁶ : IsScalarTower S R M
inst✝¹⁵ : IsScalarTower S Rᵐᵒᵖ M
inst✝¹⁴ : Module R' M
inst✝¹³ : Module R'ᵐᵒᵖ M
inst✝¹² : IsCentralScalar R' M
inst✝¹¹ : IsScalarTower S R' M
A : Type u_2
inst✝¹⁰ : Semiring A
inst✝⁹ : Algebra S A
inst✝⁸ : Algebra R' A
N : Type u_3
P : Type u_4
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R' N
inst✝⁵ : Module R'ᵐᵒᵖ N
inst✝⁴ : IsCentralScalar R' N
inst✝³ : AddCommMonoid P
inst✝² : Module R' P
inst✝¹ : Module R'ᵐᵒᵖ P
inst✝ : IsCentralScalar R' P
f : M →ₗ[R'] N
x : M
⊢ (map f) (inr x) = inr (f x)
state_after: no goals
Theorem: List.map₂Right_nil_left
File: Mathlib/Data/List/Basic.lean

tactic: cases bs <;> rfl
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : Option α → β → γ
a : α
as : List α
b : β
bs : List β
⊢ map₂Right f [] bs = map (f none) bs
state_after: no goals
Theorem: CharTwo.add_self_eq_zero
File: Mathlib/Algebra/CharP/Two.lean

tactic: rw [← two_smul R x, two_eq_zero, zero_smul]
state_before: R : Type u_1
ι : Type u_2
inst✝¹ : Semiring R
inst✝ : CharP R 2
x : R
⊢ x + x = 0
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.tensor_dite
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: split_ifs <;> rfl
state_before: C✝ : Type u
𝒞 : Category.{v, u} C✝
inst✝³ : MonoidalCategory C✝
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
U V W✝ X✝ Y✝ Z✝ : C
P : Prop
inst✝ : Decidable P
W X Y Z : C
f : W ⟶ X
g : P → (Y ⟶ Z)
g' : ¬P → (Y ⟶ Z)
⊢ (f ⊗ if h : P then g h else g' h) = if h : P then f ⊗ g h else f ⊗ g' h
state_after: no goals
Theorem: multipliable_int_iff_multipliable_nat_and_neg
File: Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean

tactic: refine ⟨fun p ↦ ⟨?_, ?_⟩, fun ⟨hf₁, hf₂⟩ ↦ Multipliable.of_nat_of_neg hf₁ hf₂⟩ <;>
apply p.comp_injective
state_before: M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
⊢ Multipliable f ↔ (Multipliable fun n => f ↑n) ∧ Multipliable fun n => f (-↑n)
state_after: case refine_1
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective Nat.cast

case refine_2
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective fun n => -↑n

tactic: exacts [Nat.cast_injective, neg_injective.comp Nat.cast_injective]
state_before: case refine_1
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective Nat.cast

case refine_2
M : Type u_1
inst✝⁵ : CommMonoid M
inst✝⁴ : TopologicalSpace M
m m' : M
G : Type u_2
inst✝³ : CommGroup G
g g' : G
inst✝² : UniformSpace G
inst✝¹ : UniformGroup G
inst✝ : CompleteSpace G
f : ℤ → G
p : Multipliable f
⊢ Injective fun n => -↑n
state_after: no goals
Theorem: isSquare_iff_exists_sq
File: Mathlib/Algebra/Group/Even.lean

tactic: simp [IsSquare, pow_two]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : Monoid α
n : ℕ
a m : α
⊢ IsSquare m ↔ ∃ c, m = c ^ 2
state_after: no goals
Theorem: Vector.mapAccumr_map
File: Mathlib/Data/Vector/MapLemmas.lean

tactic: induction xs using Vector.revInductionOn generalizing s <;> simp_all
state_before: α : Type u_3
n : ℕ
β : Type u_2
σ₁ : Type
γ : Type u_1
σ₂ : Type ?u.2910
xs : Vector α n
f₁ : β → σ₁ → σ₁ × γ
f₂✝ : α → σ₂ → σ₂ × β
s : σ₁
f₂ : α → β
⊢ mapAccumr f₁ (map f₂ xs) s = mapAccumr (fun x s => f₁ (f₂ x) s) xs s
state_after: no goals