1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.cons_vecMulVec
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext i
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin m → α
w : n' → α
⊢ vecMulVec (vecCons x v) w = vecCons (x • w) (vecMulVec v w)
state_after: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin m → α
w : n' → α
i : Fin m.succ
j✝ : n'
⊢ vecMulVec (vecCons x v) w i j✝ = vecCons (x • w) (vecMulVec v w) i j✝

tactic: refine Fin.cases ?_ ?_ i <;> simp [vecMulVec]
state_before: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin m → α
w : n' → α
i : Fin m.succ
j✝ : n'
⊢ vecMulVec (vecCons x v) w i j✝ = vecCons (x • w) (vecMulVec v w) i j✝
state_after: no goals
Theorem: Int.natAbs_euclideanDomain_gcd
File: Mathlib/RingTheory/Int/Basic.lean

tactic: apply Nat.dvd_antisymm <;> rw [← Int.natCast_dvd_natCast]
state_before: a b : ℤ
⊢ (EuclideanDomain.gcd a b).natAbs = a.gcd b
state_after: case a
a b : ℤ
⊢ ↑(EuclideanDomain.gcd a b).natAbs ∣ ↑(a.gcd b)

case a
a b : ℤ
⊢ ↑(a.gcd b) ∣ ↑(EuclideanDomain.gcd a b).natAbs

tactic: rw [Int.natAbs_dvd]
state_before: case a
a b : ℤ
⊢ ↑(EuclideanDomain.gcd a b).natAbs ∣ ↑(a.gcd b)
state_after: case a
a b : ℤ
⊢ EuclideanDomain.gcd a b ∣ ↑(a.gcd b)

tactic: exact Int.dvd_gcd (EuclideanDomain.gcd_dvd_left _ _) (EuclideanDomain.gcd_dvd_right _ _)
state_before: case a
a b : ℤ
⊢ EuclideanDomain.gcd a b ∣ ↑(a.gcd b)
state_after: no goals

tactic: rw [Int.dvd_natAbs]
state_before: case a
a b : ℤ
⊢ ↑(a.gcd b) ∣ ↑(EuclideanDomain.gcd a b).natAbs
state_after: case a
a b : ℤ
⊢ ↑(a.gcd b) ∣ EuclideanDomain.gcd a b

tactic: exact EuclideanDomain.dvd_gcd Int.gcd_dvd_left Int.gcd_dvd_right
state_before: case a
a b : ℤ
⊢ ↑(a.gcd b) ∣ EuclideanDomain.gcd a b
state_after: no goals
Theorem: List.indexOf_append_of_not_mem
File: Mathlib/Data/List/Basic.lean

tactic: induction' l₁ with d₁ t₁ ih
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h : ¬a ∈ l₁
⊢ indexOf a (l₁ ++ l₂) = l₁.length + indexOf a l₂
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h : ¬a ∈ []
⊢ indexOf a ([] ++ l₂) = [].length + indexOf a l₂

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : ¬a ∈ t₁ → indexOf a (t₁ ++ l₂) = t₁.length + indexOf a l₂
h : ¬a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: t₁ ++ l₂) = (d₁ :: t₁).length + indexOf a l₂

tactic: rw [List.cons_append, indexOf_cons_ne _ (ne_of_not_mem_cons h).symm, List.length,
  ih (not_mem_of_not_mem_cons h), Nat.succ_add]
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a d₁ : α
t₁ : List α
ih : ¬a ∈ t₁ → indexOf a (t₁ ++ l₂) = t₁.length + indexOf a l₂
h : ¬a ∈ d₁ :: t₁
⊢ indexOf a (d₁ :: t₁ ++ l₂) = (d₁ :: t₁).length + indexOf a l₂
state_after: no goals

tactic: rw [List.nil_append, List.length, Nat.zero_add]
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
h : ¬a ∈ []
⊢ indexOf a ([] ++ l₂) = [].length + indexOf a l₂
state_after: no goals
Theorem: Finset.card_subtype
File: Mathlib/Data/Finset/Card.lean

tactic: simp [Finset.subtype]
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s✝ t u : Finset α
f : α → β
n : ℕ
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
⊢ (Finset.subtype p s).card = (filter p s).card
state_after: no goals
Theorem: CategoryTheory.eqToHom_app
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: subst h
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : C ⥤ D
h : F = G
X : C
⊢ (eqToHom h).app X = eqToHom ⋯
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X : C
⊢ (eqToHom ⋯).app X = eqToHom ⋯

tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X : C
⊢ (eqToHom ⋯).app X = eqToHom ⋯
state_after: no goals
Theorem: connectedComponentIn_subset
File: Mathlib/Topology/Connected/Basic.lean

tactic: rw [connectedComponentIn]
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v F : Set α
x : α
⊢ connectedComponentIn F x ⊆ F
state_after: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v F : Set α
x : α
⊢ (if h : x ∈ F then Subtype.val '' connectedComponent ⟨x, h⟩ else ∅) ⊆ F

tactic: split_ifs <;> simp
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v F : Set α
x : α
⊢ (if h : x ∈ F then Subtype.val '' connectedComponent ⟨x, h⟩ else ∅) ⊆ F
state_after: no goals
Theorem: CategoryTheory.Limits.factorThruImageSubobject_comp_self
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: ext
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W : C
k : W ⟶ X
h : (imageSubobject f).Factors (k ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ f) h = k ≫ factorThruImageSubobject f
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W : C
k : W ⟶ X
h : (imageSubobject f).Factors (k ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ f) h ≫ (imageSubobject f).arrow =
    (k ≫ factorThruImageSubobject f) ≫ (imageSubobject f).arrow

tactic: simp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f : X ⟶ Y
inst✝ : HasImage f
W : C
k : W ⟶ X
h : (imageSubobject f).Factors (k ≫ f)
⊢ (imageSubobject f).factorThru (k ≫ f) h ≫ (imageSubobject f).arrow =
    (k ≫ factorThruImageSubobject f) ≫ (imageSubobject f).arrow
state_after: no goals
Theorem: IsOpenMap.id
File: Mathlib/Topology/Maps.lean

tactic: rwa [image_id]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
ι : Type u_4
f : X → Y
g : Y → Z
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
s : Set X
hs : IsOpen s
⊢ IsOpen (id '' s)
state_after: no goals
Theorem: SimpleGraph.Subgraph.neighborSet_iSup
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [iSup]
state_before: ι : Sort u_1
V : Type u
W : Type v
G : SimpleGraph V
G₁ G₂ : G.Subgraph
a b : V
f : ι → G.Subgraph
v : V
⊢ (⨆ i, f i).neighborSet v = ⋃ i, (f i).neighborSet v
state_after: no goals
Theorem: CategoryTheory.OplaxNatTrans.Modification.whiskerLeft_naturality
File: Mathlib/CategoryTheory/Bicategory/NaturalTransformation.lean

tactic: simp_rw [← whiskerLeft_comp, naturality]
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G : OplaxFunctor B C
η θ ι : F ⟶ G
Γ : Modification η θ
a b c : B
a' : C
f : a' ⟶ (↑F.toPrelaxFunctor).obj b
g : b ⟶ c
⊢ f ◁ (↑F.toPrelaxFunctor).map g ◁ Γ.app c ≫ f ◁ θ.naturality g =
    f ◁ η.naturality g ≫ f ◁ Γ.app b ▷ (↑G.toPrelaxFunctor).map g
state_after: no goals
Theorem: Module.finite_iff_of_rank_eq_nsmul
File: Mathlib/LinearAlgebra/Dimension/Free.lean

tactic: simp only [← rank_lt_alpeh0_iff, hVW, nsmul_lt_aleph0_iff_of_ne_zero hn]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
inst✝¹³ : Ring R
inst✝¹² : StrongRankCondition R
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : Module R M
inst✝⁹ : Free R M
inst✝⁸ : AddCommGroup M'
inst✝⁷ : Module R M'
inst✝⁶ : Free R M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M₁
inst✝³ : Free R M₁
W : Type v
inst✝² : AddCommGroup W
inst✝¹ : Module R W
inst✝ : Free R W
n : ℕ
hn : n ≠ 0
hVW : Module.rank R M = n • Module.rank R W
⊢ Finite R M ↔ Finite R W
state_after: no goals
Theorem: Orientation.kahler_rightAngleRotation_left
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

tactic: simp only [o.areaForm_rightAngleRotation_left, o.inner_rightAngleRotation_left,
  o.kahler_apply_apply, Complex.ofReal_neg, Complex.real_smul]
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ (o.kahler (o.rightAngleRotation x)) y = -Complex.I * (o.kahler x) y
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ↑((o.areaForm x) y) + -↑⟪x, y⟫_ℝ * Complex.I = -Complex.I * (↑⟪x, y⟫_ℝ + ↑((o.areaForm x) y) * Complex.I)

tactic: linear_combination ω x y * Complex.I_sq
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ ↑((o.areaForm x) y) + -↑⟪x, y⟫_ℝ * Complex.I = -Complex.I * (↑⟪x, y⟫_ℝ + ↑((o.areaForm x) y) * Complex.I)
state_after: no goals
Theorem: SimpleGraph.Walk.length_tail_add_one
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← length_cons, cons_tail_eq]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w x y : V
p : G.Walk x y
hp : ¬p.Nil
⊢ (p.tail hp).length + 1 = p.length
state_after: no goals
Theorem: Finsupp.support_subtypeDomain
File: Mathlib/Data/Finsupp/Basic.lean

tactic: rw [Subsingleton.elim D] <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
p : α → Prop
D : DecidablePred p
f : α →₀ M
⊢ (subtypeDomain p f).support = Finset.subtype p f.support
state_after: no goals
Theorem: HomologicalComplex.cylinder.ι₁_desc
File: Mathlib/Algebra/Homology/HomotopyCofiber.lean

tactic: simp [ι₁, desc]
state_before: C : Type u_1
inst✝⁵ : Category.{u_3, u_1} C
inst✝⁴ : Preadditive C
ι : Type u_2
c : ComplexShape ι
F G K : HomologicalComplex C c
φ : F ⟶ G
inst✝³ : HasHomotopyCofiber φ
inst✝² : DecidableRel c.Rel
inst✝¹ : ∀ (i : ι), HasBinaryBiproduct (K.X i) (K.X i)
inst✝ : HasHomotopyCofiber (biprod.lift (𝟙 K) (-𝟙 K))
φ₀ φ₁ : K ⟶ F
h : Homotopy φ₀ φ₁
⊢ ι₁ K ≫ desc φ₀ φ₁ h = φ₁
state_after: no goals
Theorem: Set.image2_union_left
File: Mathlib/Data/Set/NAry.lean

tactic: simp_rw [← image_prod, union_prod, image_union]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
⊢ image2 f (s ∪ s') t = image2 f s t ∪ image2 f s' t
state_after: no goals
Theorem: SubMulAction.smul_of_tower_mem
File: Mathlib/GroupTheory/GroupAction/SubMulAction.lean

tactic: rw [← one_smul R x, ← smul_assoc]
state_before: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : SMul S R
inst✝¹ : SMul S M
inst✝ : IsScalarTower S R M
p : SubMulAction R M
s : S
x : M
h : x ∈ p
⊢ s • x ∈ p
state_after: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : SMul S R
inst✝¹ : SMul S M
inst✝ : IsScalarTower S R M
p : SubMulAction R M
s : S
x : M
h : x ∈ p
⊢ (s • 1) • x ∈ p

tactic: exact p.smul_mem _ h
state_before: S : Type u'
T : Type u''
R : Type u
M : Type v
inst✝⁴ : Monoid R
inst✝³ : MulAction R M
inst✝² : SMul S R
inst✝¹ : SMul S M
inst✝ : IsScalarTower S R M
p : SubMulAction R M
s : S
x : M
h : x ∈ p
⊢ (s • 1) • x ∈ p
state_after: no goals
Theorem: Nontrivial.of_not_isCyclic
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: contrapose! nc
state_before: α : Type u
a : α
inst✝ : Group α
nc : ¬IsCyclic α
⊢ Nontrivial α
state_after: α : Type u
a : α
inst✝ : Group α
nc : ¬Nontrivial α
⊢ IsCyclic α

tactic: exact @isCyclic_of_subsingleton _ _ (not_nontrivial_iff_subsingleton.mp nc)
state_before: α : Type u
a : α
inst✝ : Group α
nc : ¬Nontrivial α
⊢ IsCyclic α
state_after: no goals
Theorem: Lagrange.nodal_erase_eq_nodal_div
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [nodal_eq_mul_nodal_erase hi, mul_div_cancel_left₀]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i : ι
hi : i ∈ s
⊢ nodal (s.erase i) v = nodal s v / (X - C (v i))
state_after: case ha
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i : ι
hi : i ∈ s
⊢ X - C (v i) ≠ 0

tactic: exact X_sub_C_ne_zero _
state_before: case ha
F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i : ι
hi : i ∈ s
⊢ X - C (v i) ≠ 0
state_after: no goals
Theorem: Polynomial.taylor_coeff_zero
File: Mathlib/Algebra/Polynomial/Taylor.lean

tactic: rw [taylor_coeff, hasseDeriv_zero, LinearMap.id_apply]
state_before: R : Type u_1
inst✝ : Semiring R
r : R
f : R[X]
⊢ ((taylor r) f).coeff 0 = eval r f
state_after: no goals
Theorem: List.cons_merge_cons
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simp only [merge, merge.loop, cond]
state_before: α : Type u_1
s : α → α → Bool
a b : α
l r : List α
⊢ merge s (a :: l) (b :: r) = if s a b = true then a :: merge s l (b :: r) else b :: merge s (a :: l) r
state_after: α : Type u_1
s : α → α → Bool
a b : α
l r : List α
⊢ (match s a b with
    | true => merge.loop s l (b :: r) [a]
    | false => merge.loop s (a :: l) r [b]) =
    if s a b = true then a :: merge.loop s l (b :: r) [] else b :: merge.loop s (a :: l) r []

tactic: split <;> (next hs => rw [hs, merge_loop]; rfl)
state_before: α : Type u_1
s : α → α → Bool
a b : α
l r : List α
⊢ (match s a b with
    | true => merge.loop s l (b :: r) [a]
    | false => merge.loop s (a :: l) r [b]) =
    if s a b = true then a :: merge.loop s l (b :: r) [] else b :: merge.loop s (a :: l) r []
state_after: no goals

tactic: next hs => rw [hs, merge_loop]; rfl
state_before: case h_2
α : Type u_1
s : α → α → Bool
a b : α
l r : List α
c✝ : Bool
heq✝ : s a b = false
⊢ merge.loop s (a :: l) r [b] =
    if s a b = true then a :: merge.loop s l (b :: r) [] else b :: merge.loop s (a :: l) r []
state_after: no goals

tactic: rw [hs, merge_loop]
state_before: α : Type u_1
s : α → α → Bool
a b : α
l r : List α
c✝ : Bool
hs : s a b = false
⊢ merge.loop s (a :: l) r [b] =
    if s a b = true then a :: merge.loop s l (b :: r) [] else b :: merge.loop s (a :: l) r []
state_after: α : Type u_1
s : α → α → Bool
a b : α
l r : List α
c✝ : Bool
hs : s a b = false
⊢ [b].reverseAux (merge s (a :: l) r) =
    if false = true then a :: merge.loop s l (b :: r) [] else b :: merge.loop s (a :: l) r []

tactic: rfl
state_before: α : Type u_1
s : α → α → Bool
a b : α
l r : List α
c✝ : Bool
hs : s a b = false
⊢ [b].reverseAux (merge s (a :: l) r) =
    if false = true then a :: merge.loop s l (b :: r) [] else b :: merge.loop s (a :: l) r []
state_after: no goals
Theorem: sub_one_mul
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [sub_mul, one_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : NonAssocRing α
a b : α
⊢ (a - 1) * b = a * b - b
state_after: no goals
Theorem: antivary_inv
File: Mathlib/Algebra/Order/Monovary.lean

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ Antivary f⁻¹ g⁻¹ ↔ Antivary f g
state_after: no goals
Theorem: Finsupp.support_zipWith
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [Subsingleton.elim D] <;> exact support_onFinset_subset
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
inst✝¹ : Zero N
inst✝ : Zero P
D : DecidableEq α
f : M → N → P
hf : f 0 0 = 0
g₁ : α →₀ M
g₂ : α →₀ N
⊢ (zipWith f hf g₁ g₂).support ⊆ g₁.support ∪ g₂.support
state_after: no goals
Theorem: Part.assert_neg
File: Mathlib/Data/Part.lean

tactic: dsimp [assert, none]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ assert p f = none
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ { Dom := ∃ (h : p), (f h).Dom, get := fun ha => (f ⋯).get ⋯ } =
    { Dom := False, get := fun t => False.rec (fun x => α) t }

tactic: congr
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ { Dom := ∃ (h : p), (f h).Dom, get := fun ha => (f ⋯).get ⋯ } =
    { Dom := False, get := fun t => False.rec (fun x => α) t }
state_after: case h.e_2
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ (∃ (h : p), (f h).Dom) = False

case h.e_3
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ HEq (fun ha => (f ⋯).get ⋯) fun t => False.rec (fun x => α) t

tactic: simp only [h, not_false_iff, exists_prop_of_false]
state_before: case h.e_2
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ (∃ (h : p), (f h).Dom) = False
state_after: no goals

tactic: apply Function.hfunext
state_before: case h.e_3
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ HEq (fun ha => (f ⋯).get ⋯) fun t => False.rec (fun x => α) t
state_after: case h.e_3.hα
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ (∃ (h : p), (f h).Dom) = False

case h.e_3.h
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ ∀ (a : ∃ (h : p), (f h).Dom) (a' : False), HEq a a' → HEq ((f ⋯).get ⋯) (False.rec (fun x => α) a')

tactic: simp at *
state_before: case h.e_3.h
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ ∀ (a : ∃ (h : p), (f h).Dom) (a' : False), HEq a a' → HEq ((f ⋯).get ⋯) (False.rec (fun x => α) a')
state_after: no goals

tactic: simp only [h, not_false_iff, exists_prop_of_false]
state_before: case h.e_3.hα
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
f : p → Part α
h : ¬p
⊢ (∃ (h : p), (f h).Dom) = False
state_after: no goals
Theorem: Filter.le_cofinite_iff_compl_singleton_mem
File: Mathlib/Order/Filter/Cofinite.lean

tactic: refine ⟨fun h x => h (finite_singleton x).compl_mem_cofinite, fun h s (hs : sᶜ.Finite) => ?_⟩
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
⊢ l ≤ cofinite ↔ ∀ (x : α), {x}ᶜ ∈ l
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
h : ∀ (x : α), {x}ᶜ ∈ l
s : Set α
hs : sᶜ.Finite
⊢ s ∈ l

tactic: rw [← compl_compl s, ← biUnion_of_singleton sᶜ, compl_iUnion₂, Filter.biInter_mem hs]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
h : ∀ (x : α), {x}ᶜ ∈ l
s : Set α
hs : sᶜ.Finite
⊢ s ∈ l
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
h : ∀ (x : α), {x}ᶜ ∈ l
s : Set α
hs : sᶜ.Finite
⊢ ∀ i ∈ sᶜ, {i}ᶜ ∈ l

tactic: exact fun x _ => h x
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
l : Filter α
h : ∀ (x : α), {x}ᶜ ∈ l
s : Set α
hs : sᶜ.Finite
⊢ ∀ i ∈ sᶜ, {i}ᶜ ∈ l
state_after: no goals
Theorem: CategoryTheory.Subobject.eq_mk_of_comm
File: Mathlib/CategoryTheory/Subobject/Basic.lean

tactic: simp [w]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
B A : C
X : Subobject B
f : A ⟶ B
inst✝ : Mono f
i : underlying.obj X ≅ A
w : i.hom ≫ f = X.arrow
⊢ (i ≪≫ (underlyingIso f).symm).hom ≫ (mk f).arrow = X.arrow
state_after: no goals
Theorem: List.length_split_le
File: Mathlib/Data/List/Sort.lean

tactic: cases' e : split l with l₁ l₂
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
state_after: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length

tactic: injection (split_cons_of_eq _ e).symm.trans h
state_before: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
state_after: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
fst_eq✝ : a :: l₂ = l₁'
snd_eq✝ : l₁ = l₂'
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length

tactic: substs l₁' l₂'
state_before: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁' l₂' : List α
h : (a :: l).split = (l₁', l₂')
l₁ l₂ : List α
e : l.split = (l₁, l₂)
fst_eq✝ : a :: l₂ = l₁'
snd_eq✝ : l₁ = l₂'
⊢ l₁'.length ≤ (a :: l).length ∧ l₂'.length ≤ (a :: l).length
state_after: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length

tactic: cases' length_split_le e with h₁ h₂
state_before: case mk
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length
state_after: case mk.intro
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
h₁ : l₁.length ≤ l.length
h₂ : l₂.length ≤ l.length
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length

tactic: exact ⟨Nat.succ_le_succ h₂, Nat.le_succ_of_le h₁⟩
state_before: case mk.intro
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a : α
l l₁ l₂ : List α
e : l.split = (l₁, l₂)
h : (a :: l).split = (a :: l₂, l₁)
h₁ : l₁.length ≤ l.length
h₂ : l₂.length ≤ l.length
⊢ (a :: l₂).length ≤ (a :: l).length ∧ l₁.length ≤ (a :: l).length
state_after: no goals
Theorem: Function.Involutive.iterate_even
File: Mathlib/Algebra/Ring/Parity.lean

tactic: obtain ⟨m, rfl⟩ := hn
state_before: F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
α : Type u_5
f : α → α
n : ℕ
hf : Involutive f
hn : Even n
⊢ f^[n] = id
state_after: case intro
F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
α : Type u_5
f : α → α
hf : Involutive f
m : ℕ
⊢ f^[m + m] = id

tactic: rw [← two_mul, hf.iterate_two_mul]
state_before: case intro
F : Type u_1
α✝ : Type u_2
β : Type u_3
R : Type u_4
α : Type u_5
f : α → α
hf : Involutive f
m : ℕ
⊢ f^[m + m] = id
state_after: no goals