1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Set.isCoatom_iff
File: Mathlib/Order/Atoms.lean

tactic: rw [isCompl_compl.isCoatom_iff_isAtom, isAtom_iff]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ IsCoatom s ↔ ∃ x, s = {x}ᶜ
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ (∃ x, sᶜ = {x}) ↔ ∃ x, s = {x}ᶜ

tactic: simp_rw [@eq_comm _ s, compl_eq_comm]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
s : Set α
⊢ (∃ x, sᶜ = {x}) ↔ ∃ x, s = {x}ᶜ
state_after: no goals
Theorem: String.foldl_eq
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simpa using foldlAux_of_valid f [] s.1 [] a
state_before: α : Type u_1
f : α → Char → α
s : String
a : α
⊢ foldl f a s = List.foldl f a s.data
state_after: no goals
Theorem: DirectedOn.sSup_inf_eq
File: Mathlib/Order/CompactlyGenerated/Basic.lean

tactic: simp_rw [inf_comm _ a, h.inf_sSup_eq]
state_before: ι : Sort u_1
α : Type u_2
inst✝² : CompleteLattice α
f : ι → α
inst✝¹ : CompleteLattice α
inst✝ : IsCompactlyGenerated α
a b : α
s : Set α
h : DirectedOn (fun x x_1 => x ≤ x_1) s
⊢ sSup s ⊓ a = ⨆ b ∈ s, b ⊓ a
state_after: no goals
Theorem: Polynomial.map_roots_le
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: classical
exact Multiset.le_iff_count.2 fun b => by
  rw [count_roots]
  apply count_map_roots h
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
⊢ Multiset.map (⇑f) p.roots ≤ (map f p).roots
state_after: no goals

tactic: exact Multiset.le_iff_count.2 fun b => by
  rw [count_roots]
  apply count_map_roots h
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
⊢ Multiset.map (⇑f) p.roots ≤ (map f p).roots
state_after: no goals

tactic: rw [count_roots]
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
b : B
⊢ Multiset.count b (Multiset.map (⇑f) p.roots) ≤ Multiset.count b (map f p).roots
state_after: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
b : B
⊢ Multiset.count b (Multiset.map (⇑f) p.roots) ≤ rootMultiplicity b (map f p)

tactic: apply count_map_roots h
state_before: R : Type u
S : Type v
T : Type w
a b✝ : R
n : ℕ
A : Type u_1
B : Type u_2
inst✝³ : CommRing A
inst✝² : CommRing B
inst✝¹ : IsDomain A
inst✝ : IsDomain B
p : A[X]
f : A →+* B
h : map f p ≠ 0
b : B
⊢ Multiset.count b (Multiset.map (⇑f) p.roots) ≤ rootMultiplicity b (map f p)
state_after: no goals
Theorem: NumberField.InfinitePlace.embedding_mk_eq
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

tactic: rw [@eq_comm _ _ φ, @eq_comm _ _ (ComplexEmbedding.conjugate φ), ← mk_eq_iff, mk_embedding]
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
φ : K →+* ℂ
⊢ (mk φ).embedding = φ ∨ (mk φ).embedding = ComplexEmbedding.conjugate φ
state_after: no goals
Theorem: measurable_const_smul_iff
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [inv_smul_smul] using h.const_smul' c⁻¹
state_before: α✝ : Type u_1
M : Type u_2
β : Type u_3
α : Type u_4
inst✝⁹ : MeasurableSpace M
inst✝⁸ : MeasurableSpace β
inst✝⁷ : Monoid M
inst✝⁶ : MulAction M β
inst✝⁵ : MeasurableSMul M β
inst✝⁴ : MeasurableSpace α
f : α → β
μ : Measure α
G : Type u_5
inst✝³ : Group G
inst✝² : MeasurableSpace G
inst✝¹ : MulAction G β
inst✝ : MeasurableSMul G β
c : G
h : Measurable fun x => c • f x
⊢ Measurable f
state_after: no goals
Theorem: NNRat.num_coe
File: Mathlib/Data/NNRat/Defs.lean

tactic: simp [num, abs_of_nonneg, Rat.num_nonneg, q.2]
state_before: p q✝ q : ℚ≥0
⊢ (↑q).num = ↑q.num
state_after: no goals
Theorem: CategoryTheory.oppositeShiftFunctorZero_hom_app
File: Mathlib/CategoryTheory/Shift/Opposite.lean

tactic: rw [← cancel_mono ((shiftFunctorZero (OppositeShift C A) A).inv.app X),
  Iso.hom_inv_id_app, oppositeShiftFunctorZero_inv_app, ← op_comp,
  Iso.hom_inv_id_app, op_id]
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
⊢ (shiftFunctorZero (OppositeShift C A) A).hom.app X = ((shiftFunctorZero C A).inv.app X.unop).op
state_after: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
⊢ 𝟙 ((shiftFunctor (OppositeShift C A) 0).obj X) = 𝟙 { unop := (shiftFunctor C 0).obj X.unop }

tactic: rfl
state_before: C : Type u_1
inst✝² : Category.{u_3, u_1} C
A : Type u_2
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
X : OppositeShift C A
⊢ 𝟙 ((shiftFunctor (OppositeShift C A) 0).obj X) = 𝟙 { unop := (shiftFunctor C 0).obj X.unop }
state_after: no goals
Theorem: SetTheory.PGame.add_moveRight_inl
File: Mathlib/SetTheory/Game/PGame.lean

tactic: cases x
state_before: xl xr : Type u
x y : PGame
i : x.RightMoves
⊢ (x + y).moveRight (toRightMovesAdd (Sum.inl i)) = x.moveRight i + y
state_after: case mk
xl xr : Type u
y : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveRight (toRightMovesAdd (Sum.inl i)) = (mk α✝ β✝ a✝¹ a✝).moveRight i + y

tactic: cases y
state_before: case mk
xl xr : Type u
y : PGame
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝ β✝ a✝¹ a✝ + y).moveRight (toRightMovesAdd (Sum.inl i)) = (mk α✝ β✝ a✝¹ a✝).moveRight i + y
state_after: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesAdd (Sum.inl i)) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i + mk α✝ β✝ a✝¹ a✝

tactic: rfl
state_before: case mk.mk
xl xr : Type u
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝¹ β✝¹ a✝³ a✝² + mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesAdd (Sum.inl i)) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i + mk α✝ β✝ a✝¹ a✝
state_after: no goals
Theorem: SimpleGraph.pathGraph_two_eq_top
File: Mathlib/Combinatorics/SimpleGraph/Hasse.lean

tactic: ext u v
state_before: α : Type u_1
β : Type u_2
⊢ pathGraph 2 = ⊤
state_after: case Adj.h.h.a
α : Type u_1
β : Type u_2
u v : Fin 2
⊢ (pathGraph 2).Adj u v ↔ ⊤.Adj u v

tactic: fin_cases u <;> fin_cases v <;> simp [pathGraph, ← Fin.coe_covBy_iff, Nat.covBy_iff_succ_eq]
state_before: case Adj.h.h.a
α : Type u_1
β : Type u_2
u v : Fin 2
⊢ (pathGraph 2).Adj u v ↔ ⊤.Adj u v
state_after: no goals
Theorem: IsCyclic.card_orderOf_eq_totient
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: classical apply card_orderOf_eq_totient_aux₂ (fun n => IsCyclic.card_pow_eq_one_le) hd
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
d : ℕ
hd : d ∣ Fintype.card α
⊢ (filter (fun a => orderOf a = d) univ).card = φ d
state_after: no goals

tactic: apply card_orderOf_eq_totient_aux₂ (fun n => IsCyclic.card_pow_eq_one_le) hd
state_before: α : Type u
a : α
inst✝² : Group α
inst✝¹ : IsCyclic α
inst✝ : Fintype α
d : ℕ
hd : d ∣ Fintype.card α
⊢ (filter (fun a => orderOf a = d) univ).card = φ d
state_after: no goals
Theorem: UpperHalfPlane.subset_verticalStrip_of_isCompact
File: Mathlib/Analysis/Complex/UpperHalfPlane/Topology.lean

tactic: rcases K.eq_empty_or_nonempty with rfl | hne
state_before: K : Set ℍ
hK : IsCompact K
⊢ ∃ A B, 0 < B ∧ K ⊆ verticalStrip A B
state_after: case inl
hK : IsCompact ∅
⊢ ∃ A B, 0 < B ∧ ∅ ⊆ verticalStrip A B

case inr
K : Set ℍ
hK : IsCompact K
hne : K.Nonempty
⊢ ∃ A B, 0 < B ∧ K ⊆ verticalStrip A B

tactic: obtain ⟨u, _, hu⟩ := hK.exists_isMaxOn hne (_root_.continuous_abs.comp continuous_re).continuousOn
state_before: case inr
K : Set ℍ
hK : IsCompact K
hne : K.Nonempty
⊢ ∃ A B, 0 < B ∧ K ⊆ verticalStrip A B
state_after: case inr.intro.intro
K : Set ℍ
hK : IsCompact K
hne : K.Nonempty
u : ℍ
left✝ : u ∈ K
hu : IsMaxOn (_root_.abs ∘ re) K u
⊢ ∃ A B, 0 < B ∧ K ⊆ verticalStrip A B

tactic: obtain ⟨v, _, hv⟩ := hK.exists_isMinOn hne continuous_im.continuousOn
state_before: case inr.intro.intro
K : Set ℍ
hK : IsCompact K
hne : K.Nonempty
u : ℍ
left✝ : u ∈ K
hu : IsMaxOn (_root_.abs ∘ re) K u
⊢ ∃ A B, 0 < B ∧ K ⊆ verticalStrip A B
state_after: case inr.intro.intro.intro.intro
K : Set ℍ
hK : IsCompact K
hne : K.Nonempty
u : ℍ
left✝¹ : u ∈ K
hu : IsMaxOn (_root_.abs ∘ re) K u
v : ℍ
left✝ : v ∈ K
hv : IsMinOn im K v
⊢ ∃ A B, 0 < B ∧ K ⊆ verticalStrip A B

tactic: exact ⟨|re u|, im v, v.im_pos, fun k hk ↦ ⟨isMaxOn_iff.mp hu _ hk, isMinOn_iff.mp hv _ hk⟩⟩
state_before: case inr.intro.intro.intro.intro
K : Set ℍ
hK : IsCompact K
hne : K.Nonempty
u : ℍ
left✝¹ : u ∈ K
hu : IsMaxOn (_root_.abs ∘ re) K u
v : ℍ
left✝ : v ∈ K
hv : IsMinOn im K v
⊢ ∃ A B, 0 < B ∧ K ⊆ verticalStrip A B
state_after: no goals

tactic: exact ⟨1, 1, Real.zero_lt_one, empty_subset _⟩
state_before: case inl
hK : IsCompact ∅
⊢ ∃ A B, 0 < B ∧ ∅ ⊆ verticalStrip A B
state_after: no goals
Theorem: List.head_cons_tail
File: Mathlib/Data/List/Basic.lean

tactic: cases x <;> simp at h ⊢
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x : List α
h : x ≠ []
⊢ x.head h :: x.tail = x
state_after: no goals
Theorem: Cardinal.cantorFunctionAux_true
File: Mathlib/Data/Real/Cardinality.lean

tactic: simp [cantorFunctionAux, h]
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h : f n = true
⊢ cantorFunctionAux c f n = c ^ n
state_after: no goals
Theorem: Submodule.torsionBySet_isInternal
File: Mathlib/Algebra/Module/Torsion.lean

tactic: apply (iSup_subtype'' ↑S fun i => torsionBySet R M <| p i).trans
state_before: R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : DecidableEq ι
S : Finset ι
p : ι → Ideal R
hp : (↑S).Pairwise fun i j => p i ⊔ p j = ⊤
hM : Module.IsTorsionBySet R M ↑(⨅ i ∈ S, p i)
⊢ ⨆ i, torsionBySet R M ↑(p ↑i) = ⊤
state_after: R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : DecidableEq ι
S : Finset ι
p : ι → Ideal R
hp : (↑S).Pairwise fun i j => p i ⊔ p j = ⊤
hM : Module.IsTorsionBySet R M ↑(⨅ i ∈ S, p i)
⊢ ⨆ t ∈ ↑S, torsionBySet R M ↑(p t) = ⊤

tactic: apply (iSup_torsionBySet_ideal_eq_torsionBySet_iInf hp).trans <|
  (Module.isTorsionBySet_iff_torsionBySet_eq_top _).mp hM
state_before: R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι : Type u_3
inst✝ : DecidableEq ι
S : Finset ι
p : ι → Ideal R
hp : (↑S).Pairwise fun i j => p i ⊔ p j = ⊤
hM : Module.IsTorsionBySet R M ↑(⨅ i ∈ S, p i)
⊢ ⨆ t ∈ ↑S, torsionBySet R M ↑(p t) = ⊤
state_after: no goals
Theorem: Set.pi_univ_Ici
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: simp [Pi.le_def]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Preorder (α i)
x y✝ y : (i : ι) → α i
⊢ (y ∈ univ.pi fun i => Ici (x i)) ↔ y ∈ Ici x
state_after: no goals
Theorem: finprod_mem_inter_mulSupport_eq
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_inter_mulSupport, h, finprod_mem_inter_mulSupport]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s t : Set α
h : s ∩ mulSupport f = t ∩ mulSupport f
⊢ ∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ᶠ (i : α) (_ : i ∈ t), f i
state_after: no goals
Theorem: Option.card_toFinset
File: Mathlib/Data/Finset/Option.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type u_2
o : Option α
⊢ o.toFinset.card = o.elim 0 1
state_after: no goals
Theorem: WCovBy.pred_le
File: Mathlib/Order/SuccPred/Basic.lean

tactic: obtain h | rfl := h.covBy_or_eq
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
h : a ⩿ b
⊢ pred b ≤ a
state_after: case inl
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
h✝ : a ⩿ b
h : a ⋖ b
⊢ pred b ≤ a

case inr
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a : α
h : a ⩿ a
⊢ pred a ≤ a

tactic: exact (CovBy.pred_eq h).le
state_before: case inl
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a b : α
h✝ : a ⩿ b
h : a ⋖ b
⊢ pred b ≤ a
state_after: no goals

tactic: exact pred_le _
state_before: case inr
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PredOrder α
a : α
h : a ⩿ a
⊢ pred a ≤ a
state_after: no goals
Theorem: Set.Finite.eventuallyLE_iUnion
File: Mathlib/Order/Filter/Basic.lean

tactic: have := hs.to_subtype
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
l : Filter α
ι : Type u_2
s : Set ι
hs : s.Finite
f g : ι → Set α
hle : ∀ i ∈ s, f i ≤ᶠ[l] g i
⊢ ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
l : Filter α
ι : Type u_2
s : Set ι
hs : s.Finite
f g : ι → Set α
hle : ∀ i ∈ s, f i ≤ᶠ[l] g i
this : Finite ↑s
⊢ ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i

tactic: rw [biUnion_eq_iUnion, biUnion_eq_iUnion]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
l : Filter α
ι : Type u_2
s : Set ι
hs : s.Finite
f g : ι → Set α
hle : ∀ i ∈ s, f i ≤ᶠ[l] g i
this : Finite ↑s
⊢ ⋃ i ∈ s, f i ≤ᶠ[l] ⋃ i ∈ s, g i
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
l : Filter α
ι : Type u_2
s : Set ι
hs : s.Finite
f g : ι → Set α
hle : ∀ i ∈ s, f i ≤ᶠ[l] g i
this : Finite ↑s
⊢ ⋃ x, f ↑x ≤ᶠ[l] ⋃ x, g ↑x

tactic: exact .iUnion fun i ↦ hle i.1 i.2
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι✝ : Sort x
l : Filter α
ι : Type u_2
s : Set ι
hs : s.Finite
f g : ι → Set α
hle : ∀ i ∈ s, f i ≤ᶠ[l] g i
this : Finite ↑s
⊢ ⋃ x, f ↑x ≤ᶠ[l] ⋃ x, g ↑x
state_after: no goals
Theorem: nhdsSet_Ico
File: Mathlib/Topology/Order/NhdsSet.lean

tactic: rw [← Ioo_insert_left h, nhdsSet_insert, nhdsSet_Ioo]
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
a b c d : α
h : a < b
⊢ 𝓝ˢ (Ico a b) = 𝓝 a ⊔ 𝓟 (Ioo a b)
state_after: no goals
Theorem: EisensteinSeries.r1_pos
File: Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean

tactic: dsimp only [r1]
state_before: z : ℍ
⊢ 0 < r1 z
state_after: z : ℍ
⊢ 0 < z.im ^ 2 / (z.re ^ 2 + z.im ^ 2)

tactic: positivity
state_before: z : ℍ
⊢ 0 < z.im ^ 2 / (z.re ^ 2 + z.im ^ 2)
state_after: no goals
Theorem: CategoryTheory.Limits.kernelIsoOfEq_inv_comp_ι
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: cases h
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
⊢ (kernelIsoOfEq h).inv ≫ kernel.ι f = kernel.ι g
state_after: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯).inv ≫ kernel.ι f = kernel.ι f

tactic: simp
state_before: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
f : X ⟶ Y
inst✝¹ inst✝ : HasKernel f
⊢ (kernelIsoOfEq ⋯).inv ≫ kernel.ι f = kernel.ι f
state_after: no goals
Theorem: localCohomology.hasColimitDiagram
File: Mathlib/Algebra/Homology/LocalCohomology.lean

tactic: have : HasColimitsOfShape Dᵒᵖ (AddCommGrpMax.{u, v}) := inferInstance
state_before: R : Type (max u v)
inst✝¹ : CommRing R
D : Type v
inst✝ : SmallCategory D
I : D ⥤ Ideal R
i : ℕ
⊢ HasColimit (diagram I i)
state_after: R : Type (max u v)
inst✝¹ : CommRing R
D : Type v
inst✝ : SmallCategory D
I : D ⥤ Ideal R
i : ℕ
this : HasColimitsOfShape Dᵒᵖ AddCommGrpMax
⊢ HasColimit (diagram I i)

tactic: infer_instance
state_before: R : Type (max u v)
inst✝¹ : CommRing R
D : Type v
inst✝ : SmallCategory D
I : D ⥤ Ideal R
i : ℕ
this : HasColimitsOfShape Dᵒᵖ AddCommGrpMax
⊢ HasColimit (diagram I i)
state_after: no goals
Theorem: Perfection.coeff_pow_p
File: Mathlib/RingTheory/Perfection.lean

tactic: rw [RingHom.map_pow]
state_before: R : Type u₁
inst✝¹ : CommSemiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
f : Ring.Perfection R p
n : ℕ
⊢ (coeff R p (n + 1)) (f ^ p) = (coeff R p n) f
state_after: R : Type u₁
inst✝¹ : CommSemiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
f : Ring.Perfection R p
n : ℕ
⊢ (coeff R p (n + 1)) f ^ p = (coeff R p n) f

tactic: exact f.2 n
state_before: R : Type u₁
inst✝¹ : CommSemiring R
p : ℕ
hp : Fact (Nat.Prime p)
inst✝ : CharP R p
f : Ring.Perfection R p
n : ℕ
⊢ (coeff R p (n + 1)) f ^ p = (coeff R p n) f
state_after: no goals
Theorem: Int.odd_add
File: Mathlib/Algebra/Ring/Int.lean

tactic: rw [odd_iff_not_even, even_add, not_iff, odd_iff_not_even]
state_before: m n : ℤ
⊢ Odd (m + n) ↔ (Odd m ↔ Even n)
state_after: no goals
Theorem: Multiset.Nodup.disjSum
File: Mathlib/Data/Multiset/Sum.lean

tactic: refine ((hs.map inl_injective).add_iff <| ht.map inr_injective).2 fun x hs ht => ?_
state_before: α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x : α ⊕ β
hs : s.Nodup
ht : t.Nodup
⊢ (s.disjSum t).Nodup
state_after: α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x✝ : α ⊕ β
hs✝ : s.Nodup
ht✝ : t.Nodup
x : α ⊕ β
hs : x ∈ Multiset.map inl s
ht : x ∈ Multiset.map inr t
⊢ False

tactic: rw [Multiset.mem_map] at hs ht
state_before: α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x✝ : α ⊕ β
hs✝ : s.Nodup
ht✝ : t.Nodup
x : α ⊕ β
hs : x ∈ Multiset.map inl s
ht : x ∈ Multiset.map inr t
⊢ False
state_after: α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x✝ : α ⊕ β
hs✝ : s.Nodup
ht✝ : t.Nodup
x : α ⊕ β
hs : ∃ a ∈ s, inl a = x
ht : ∃ a ∈ t, inr a = x
⊢ False

tactic: obtain ⟨a, _, rfl⟩ := hs
state_before: α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a : α
b : β
x✝ : α ⊕ β
hs✝ : s.Nodup
ht✝ : t.Nodup
x : α ⊕ β
hs : ∃ a ∈ s, inl a = x
ht : ∃ a ∈ t, inr a = x
⊢ False
state_after: case intro.intro
α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a✝ : α
b : β
x : α ⊕ β
hs : s.Nodup
ht✝ : t.Nodup
a : α
left✝ : a ∈ s
ht : ∃ a_1 ∈ t, inr a_1 = inl a
⊢ False

tactic: obtain ⟨b, _, h⟩ := ht
state_before: case intro.intro
α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a✝ : α
b : β
x : α ⊕ β
hs : s.Nodup
ht✝ : t.Nodup
a : α
left✝ : a ∈ s
ht : ∃ a_1 ∈ t, inr a_1 = inl a
⊢ False
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a✝ : α
b✝ : β
x : α ⊕ β
hs : s.Nodup
ht : t.Nodup
a : α
left✝¹ : a ∈ s
b : β
left✝ : b ∈ t
h : inr b = inl a
⊢ False

tactic: exact inr_ne_inl h
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
s₁ s₂ : Multiset α
t₁ t₂ : Multiset β
a✝ : α
b✝ : β
x : α ⊕ β
hs : s.Nodup
ht : t.Nodup
a : α
left✝¹ : a ∈ s
b : β
left✝ : b ∈ t
h : inr b = inl a
⊢ False
state_after: no goals
Theorem: Cardinal.toENatAux_eq_nat
File: Mathlib/SetTheory/Cardinal/ENat.lean

tactic: simp only [le_antisymm_iff, toENatAux_le_nat, ← toENatAux_gc _, ofENat_nat]
state_before: x : Cardinal.{u_1}
n : ℕ
⊢ x.toENatAux = ↑n ↔ x = ↑n
state_after: no goals
Theorem: CategoryTheory.IsPullback.of_isBilimit
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: convert IsPullback.of_is_product' h.isLimit HasZeroObject.zeroIsTerminal
  <;> apply Subsingleton.elim
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
P X Y Z : C
fst : P ⟶ X
snd : P ⟶ Y
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
b : BinaryBicone X Y
h : b.IsBilimit
⊢ IsPullback b.fst b.snd 0 0
state_after: no goals
Theorem: Algebra.discr_of_matrix_mulVec
File: Mathlib/RingTheory/Discriminant.lean

tactic: rw [discr_def, traceMatrix_of_matrix_mulVec, det_mul, det_mul, det_transpose, mul_comm, ←
  mul_assoc, discr_def, pow_two]
state_before: A : Type u
B : Type v
C : Type z
ι : Type w
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : CommRing C
inst✝³ : Algebra A C
ι' : Type u_1
inst✝² : Fintype ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι'
b : ι → B
P : Matrix ι ι A
⊢ discr A (P.map ⇑(algebraMap A B) *ᵥ b) = P.det ^ 2 * discr A b
state_after: no goals
Theorem: Subgroup.card_eq_iff_eq_top
File: Mathlib/Algebra/Group/Subgroup/Finite.lean

tactic: simpa only [h] using card_top
state_before: G : Type u_1
inst✝² : Group G
A : Type u_2
inst✝¹ : AddGroup A
H K : Subgroup G
inst✝ : Finite ↥H
h : H = ⊤
⊢ Nat.card ↥H = Nat.card G
state_after: no goals
Theorem: SetTheory.PGame.powHalf_le_one
File: Mathlib/SetTheory/Surreal/Dyadic.lean

tactic: induction' n with n hn
state_before: n : ℕ
⊢ powHalf n ≤ 1
state_after: case zero

⊢ powHalf 0 ≤ 1

case succ
n : ℕ
hn : powHalf n ≤ 1
⊢ powHalf (n + 1) ≤ 1

tactic: exact le_rfl
state_before: case zero

⊢ powHalf 0 ≤ 1
state_after: no goals

tactic: exact (powHalf_succ_le_powHalf n).trans hn
state_before: case succ
n : ℕ
hn : powHalf n ≤ 1
⊢ powHalf (n + 1) ≤ 1
state_after: no goals
Theorem: Sum.Lex.Ioc_inr_inr
File: Mathlib/Data/Sum/Interval.lean

tactic: rw [← Finset.map_map]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioc (inrₗ b₁) (inrₗ b₂) = map (Embedding.inr.trans toLex.toEmbedding) (Ioc b₁ b₂)
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioc (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ioc b₁ b₂))

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : Preorder α
inst✝⁴ : Preorder β
inst✝³ : OrderTop α
inst✝² : OrderBot β
inst✝¹ : LocallyFiniteOrder α
inst✝ : LocallyFiniteOrder β
a a₁ a₂ : α
b b₁ b₂ : β
⊢ Ioc (inrₗ b₁) (inrₗ b₂) = map toLex.toEmbedding (map Embedding.inr (Ioc b₁ b₂))
state_after: no goals
Theorem: List.Forall₂.imp
File: Mathlib/Data/List/Forall2.lean

tactic: induction h <;> constructor <;> solve_by_elim
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
H : ∀ (a : α) (b : β), R a b → S a b
l₁ : List α
l₂ : List β
h : Forall₂ R l₁ l₂
⊢ Forall₂ S l₁ l₂
state_after: no goals
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.exact_iff
File: Mathlib/Algebra/Homology/ShortComplex/Exact.lean

tactic: rw [S.exact_iff_isZero_homology]
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.2089, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
h : S.LeftHomologyData
⊢ S.Exact ↔ IsZero h.H
state_after: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.2089, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
h : S.LeftHomologyData
⊢ IsZero S.homology ↔ IsZero h.H

tactic: exact Iso.isZero_iff h.homologyIso
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.2089, u_2} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
inst✝ : S.HasHomology
h : S.LeftHomologyData
⊢ IsZero S.homology ↔ IsZero h.H
state_after: no goals
Theorem: Metric.ball_eq_empty
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: rw [← not_nonempty_iff_eq_empty, nonempty_ball, not_lt]
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ ball x ε = ∅ ↔ ε ≤ 0
state_after: no goals