1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: QPF.Fix.rec_unique
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: ext x
state_before: F : Type u → Type u
q : QPF F
α : Type u
g : F α → α
h : Fix F → α
hyp : ∀ (x : F (Fix F)), h (mk x) = g (h <$> x)
⊢ rec g = h
state_after: case h
F : Type u → Type u
q : QPF F
α : Type u
g : F α → α
h : Fix F → α
hyp : ∀ (x : F (Fix F)), h (mk x) = g (h <$> x)
x : Fix F
⊢ rec g x = h x

tactic: apply Fix.ind_rec
state_before: case h
F : Type u → Type u
q : QPF F
α : Type u
g : F α → α
h : Fix F → α
hyp : ∀ (x : F (Fix F)), h (mk x) = g (h <$> x)
x : Fix F
⊢ rec g x = h x
state_after: case h.h
F : Type u → Type u
q : QPF F
α : Type u
g : F α → α
h : Fix F → α
hyp : ∀ (x : F (Fix F)), h (mk x) = g (h <$> x)
x : Fix F
⊢ ∀ (x : F (Fix F)), rec g <$> x = h <$> x → rec g (mk x) = h (mk x)

tactic: intro x hyp'
state_before: case h.h
F : Type u → Type u
q : QPF F
α : Type u
g : F α → α
h : Fix F → α
hyp : ∀ (x : F (Fix F)), h (mk x) = g (h <$> x)
x : Fix F
⊢ ∀ (x : F (Fix F)), rec g <$> x = h <$> x → rec g (mk x) = h (mk x)
state_after: case h.h
F : Type u → Type u
q : QPF F
α : Type u
g : F α → α
h : Fix F → α
hyp : ∀ (x : F (Fix F)), h (mk x) = g (h <$> x)
x✝ : Fix F
x : F (Fix F)
hyp' : rec g <$> x = h <$> x
⊢ rec g (mk x) = h (mk x)

tactic: rw [hyp, ← hyp', Fix.rec_eq]
state_before: case h.h
F : Type u → Type u
q : QPF F
α : Type u
g : F α → α
h : Fix F → α
hyp : ∀ (x : F (Fix F)), h (mk x) = g (h <$> x)
x✝ : Fix F
x : F (Fix F)
hyp' : rec g <$> x = h <$> x
⊢ rec g (mk x) = h (mk x)
state_after: no goals
Theorem: Set.InjOn.exists_subset_injOn_subset_range_eq
File: Mathlib/Data/Set/Function.lean

tactic: obtain ⟨u, hru, hus, h⟩ := hinj.bijOn_image.exists_extend_of_subset hrs
  (image_subset f hrs) Subset.rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
r : Set α
hinj : InjOn f r
hrs : r ⊆ s
⊢ ∃ u, r ⊆ u ∧ u ⊆ s ∧ f '' u = f '' s ∧ InjOn f u
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
r : Set α
hinj : InjOn f r
hrs : r ⊆ s
u : Set α
hru : r ⊆ u
hus : u ⊆ s
h : BijOn f u (f '' s)
⊢ ∃ u, r ⊆ u ∧ u ⊆ s ∧ f '' u = f '' s ∧ InjOn f u

tactic: exact ⟨u, hru, hus, h.image_eq, h.injOn⟩
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t : Set β
f : α → β
r : Set α
hinj : InjOn f r
hrs : r ⊆ s
u : Set α
hru : r ⊆ u
hus : u ⊆ s
h : BijOn f u (f '' s)
⊢ ∃ u, r ⊆ u ∧ u ⊆ s ∧ f '' u = f '' s ∧ InjOn f u
state_after: no goals
Theorem: SimpleGraph.dist_eq_one_iff_adj
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

tactic: refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩
state_before: V : Type u_1
G : SimpleGraph V
u v : V
⊢ G.dist u v = 1 ↔ G.Adj u v
state_after: case refine_1
V : Type u_1
G : SimpleGraph V
u v : V
h : G.dist u v = 1
⊢ G.Adj u v

case refine_2
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Adj u v
⊢ G.dist u v = 1

tactic: let ⟨w, hw⟩ := exists_walk_of_dist_ne_zero <| ne_zero_of_eq_one h
state_before: case refine_1
V : Type u_1
G : SimpleGraph V
u v : V
h : G.dist u v = 1
⊢ G.Adj u v
state_after: case refine_1
V : Type u_1
G : SimpleGraph V
u v : V
h : G.dist u v = 1
w : G.Walk u v
hw : w.length = G.dist u v
⊢ G.Adj u v

tactic: exact w.adj_of_length_eq_one <| h ▸ hw
state_before: case refine_1
V : Type u_1
G : SimpleGraph V
u v : V
h : G.dist u v = 1
w : G.Walk u v
hw : w.length = G.dist u v
⊢ G.Adj u v
state_after: no goals

tactic: have : h.toWalk.length = 1 := Walk.length_cons _ _
state_before: case refine_2
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Adj u v
⊢ G.dist u v = 1
state_after: case refine_2
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Adj u v
this : h.toWalk.length = 1
⊢ G.dist u v = 1

tactic: exact ge_antisymm (h.reachable.pos_dist_of_ne h.ne) (this ▸ dist_le _)
state_before: case refine_2
V : Type u_1
G : SimpleGraph V
u v : V
h : G.Adj u v
this : h.toWalk.length = 1
⊢ G.dist u v = 1
state_after: no goals
Theorem: compare_le_iff_le
File: Mathlib/Init/Order/Defs.lean

tactic: cases h : compare a b <;> simp
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ compare a b ≠ Ordering.gt ↔ a ≤ b
state_after: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.lt
⊢ a ≤ b

case eq
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.eq
⊢ a ≤ b

case gt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.gt
⊢ b < a

tactic: exact le_of_lt <| compare_lt_iff_lt.1 h
state_before: case lt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.lt
⊢ a ≤ b
state_after: no goals

tactic: exact le_of_eq <| compare_eq_iff_eq.1 h
state_before: case eq
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.eq
⊢ a ≤ b
state_after: no goals

tactic: exact compare_gt_iff_gt.1 h
state_before: case gt
α : Type u
inst✝ : LinearOrder α
a b : α
h : compare a b = Ordering.gt
⊢ b < a
state_after: no goals
Theorem: Function.Injective.list_map
File: Mathlib/Data/List/Basic.lean

tactic: injection hxy with hxy hxys
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Injective f
x : α
xs : List α
y : α
ys : List α
hxy : map f (x :: xs) = map f (y :: ys)
⊢ x :: xs = y :: ys
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Injective f
x : α
xs : List α
y : α
ys : List α
hxy : f x = f y
hxys : map f xs = map f ys
⊢ x :: xs = y :: ys

tactic: rw [h hxy, h.list_map hxys]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Injective f
x : α
xs : List α
y : α
ys : List α
hxy : f x = f y
hxys : map f xs = map f ys
⊢ x :: xs = y :: ys
state_after: no goals
Theorem: Representation.asModuleEquiv_symm_map_smul
File: Mathlib/RepresentationTheory/Basic.lean

tactic: apply_fun ρ.asModuleEquiv
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
r : k
x : V
⊢ ρ.asModuleEquiv.symm (r • x) = (algebraMap k (MonoidAlgebra k G)) r • ρ.asModuleEquiv.symm x
state_after: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
r : k
x : V
⊢ ρ.asModuleEquiv (ρ.asModuleEquiv.symm (r • x)) =
    ρ.asModuleEquiv ((algebraMap k (MonoidAlgebra k G)) r • ρ.asModuleEquiv.symm x)

tactic: simp
state_before: k : Type u_1
G : Type u_2
V : Type u_3
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
r : k
x : V
⊢ ρ.asModuleEquiv (ρ.asModuleEquiv.symm (r • x)) =
    ρ.asModuleEquiv ((algebraMap k (MonoidAlgebra k G)) r • ρ.asModuleEquiv.symm x)
state_after: no goals
Theorem: CategoryTheory.Presheaf.isSheaf_iff_isLimit_coverage
File: Mathlib/CategoryTheory/Sites/Coverage.lean

tactic: simp only [Presheaf.IsSheaf, Presieve.isSheaf_coverage, isLimit_iff_isSheafFor,
  ← Presieve.isSheafFor_iff_generate]
state_before: C : Type u_1
D : Type u_4
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{u_3, u_4} D
K : Coverage C
P : Cᵒᵖ ⥤ D
⊢ IsSheaf (toGrothendieck C K) P ↔
    ∀ ⦃X : C⦄, ∀ R ∈ K.covering X, Nonempty (IsLimit (P.mapCone (Sieve.generate R).arrows.cocone.op))
state_after: C : Type u_1
D : Type u_4
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{u_3, u_4} D
K : Coverage C
P : Cᵒᵖ ⥤ D
⊢ (∀ (E : D) {X : C}, ∀ R ∈ K.covering X, Presieve.IsSheafFor (P ⋙ coyoneda.obj { unop := E }) R) ↔
    ∀ ⦃X : C⦄, ∀ R ∈ K.covering X, ∀ (E : Dᵒᵖ), Presieve.IsSheafFor (P ⋙ coyoneda.obj E) R

tactic: aesop
state_before: C : Type u_1
D : Type u_4
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Category.{u_3, u_4} D
K : Coverage C
P : Cᵒᵖ ⥤ D
⊢ (∀ (E : D) {X : C}, ∀ R ∈ K.covering X, Presieve.IsSheafFor (P ⋙ coyoneda.obj { unop := E }) R) ↔
    ∀ ⦃X : C⦄, ∀ R ∈ K.covering X, ∀ (E : Dᵒᵖ), Presieve.IsSheafFor (P ⋙ coyoneda.obj E) R
state_after: no goals
Theorem: Finset.powersetCard_self
File: Mathlib/Data/Finset/Powerset.lean

tactic: ext
state_before: α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s : Finset α
⊢ powersetCard s.card s = {s}
state_after: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetCard s.card s ↔ a✝ ∈ {s}

tactic: rw [mem_powersetCard, mem_singleton]
state_before: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ ∈ powersetCard s.card s ↔ a✝ ∈ {s}
state_after: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝.card = s.card ↔ a✝ = s

tactic: constructor
state_before: case a
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝.card = s.card ↔ a✝ = s
state_after: case a.mp
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝.card = s.card → a✝ = s

case a.mpr
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ = s → a✝ ⊆ s ∧ a✝.card = s.card

tactic: exact fun ⟨hs, hc⟩ => eq_of_subset_of_card_le hs hc.ge
state_before: case a.mp
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ ⊆ s ∧ a✝.card = s.card → a✝ = s
state_after: no goals

tactic: rintro rfl
state_before: case a.mpr
α : Type u_1
s✝¹ t✝ : Finset α
n : ?m.28114
s✝ t s a✝ : Finset α
⊢ a✝ = s → a✝ ⊆ s ∧ a✝.card = s.card
state_after: case a.mpr
α : Type u_1
s✝ t✝ : Finset α
n : ?m.28114
s t a✝ : Finset α
⊢ a✝ ⊆ a✝ ∧ a✝.card = a✝.card

tactic: simp
state_before: case a.mpr
α : Type u_1
s✝ t✝ : Finset α
n : ?m.28114
s t a✝ : Finset α
⊢ a✝ ⊆ a✝ ∧ a✝.card = a✝.card
state_after: no goals
Theorem: ZFSet.toSet_pair
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [pair]
state_before: x y : ZFSet
⊢ (x.pair y).toSet = {{x}, {x, y}}
state_after: no goals
Theorem: Finsupp.neLocus_sub_right
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: simpa only [sub_eq_add_neg] using neLocus_add_right _ _ _
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : AddGroup N
f f₁ f₂ g g₁ g₂ : α →₀ N
⊢ (f₁ - g).neLocus (f₂ - g) = f₁.neLocus f₂
state_after: no goals
Theorem: Rel.interedges_empty_left
File: Mathlib/Combinatorics/SimpleGraph/Density.lean

tactic: rw [interedges, Finset.empty_product, filter_empty]
state_before: 𝕜 : Type u_1
ι : Type u_2
κ : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : LinearOrderedField 𝕜
r : α → β → Prop
inst✝ : (a : α) → DecidablePred (r a)
s s₁ s₂ : Finset α
t✝ t₁ t₂ : Finset β
a : α
b : β
δ : 𝕜
t : Finset β
⊢ interedges r ∅ t = ∅
state_after: no goals
Theorem: Finset.coe_symmDiff
File: Mathlib/Data/Finset/Basic.lean

tactic: simp [mem_symmDiff, Set.mem_symmDiff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
a b x : α
⊢ x ∈ ↑(s ∆ t) ↔ x ∈ ↑s ∆ ↑t
state_after: no goals
Theorem: LocalizedModule.induction_on₂
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rintro ⟨⟨m, s⟩⟩ ⟨⟨m', s'⟩⟩
state_before: R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : ↥S), β (mk m s) (mk m' s')
⊢ ∀ (x y : LocalizedModule S M), β x y
state_after: case mk.mk.mk.mk
R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : ↥S), β (mk m s) (mk m' s')
x✝ : LocalizedModule S M
m : M
s : ↥S
y✝ : LocalizedModule S M
m' : M
s' : ↥S
⊢ β (Quot.mk Setoid.r (m, s)) (Quot.mk Setoid.r (m', s'))

tactic: exact h m m' s s'
state_before: case mk.mk.mk.mk
R : Type u
inst✝⁵ : CommSemiring R
S : Submonoid R
M : Type v
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
T : Type u_1
inst✝² : CommSemiring T
inst✝¹ : Algebra R T
inst✝ : IsLocalization S T
β : LocalizedModule S M → LocalizedModule S M → Prop
h : ∀ (m m' : M) (s s' : ↥S), β (mk m s) (mk m' s')
x✝ : LocalizedModule S M
m : M
s : ↥S
y✝ : LocalizedModule S M
m' : M
s' : ↥S
⊢ β (Quot.mk Setoid.r (m, s)) (Quot.mk Setoid.r (m', s'))
state_after: no goals
Theorem: Nat.one_lt_bit1
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: contradiction
state_before: h : 0 ≠ 0
⊢ 1 < bit1 0
state_after: no goals

tactic: rw [Nat.bit1_succ_eq]
state_before: n : ℕ
_h : n.succ ≠ 0
⊢ 1 < bit1 n.succ
state_after: n : ℕ
_h : n.succ ≠ 0
⊢ 1 < (bit1 n).succ.succ

tactic: apply succ_lt_succ
state_before: n : ℕ
_h : n.succ ≠ 0
⊢ 1 < (bit1 n).succ.succ
state_after: case a
n : ℕ
_h : n.succ ≠ 0
⊢ 0 < bit1 n + 1

tactic: apply zero_lt_succ
state_before: case a
n : ℕ
_h : n.succ ≠ 0
⊢ 0 < bit1 n + 1
state_after: no goals
Theorem: Mathlib.Meta.NormNum.intPow_negOfNat_bit0
File: Mathlib/Tactic/NormNum/Pow.lean

tactic: rw [← hb, Int.negOfNat_eq, Int.pow_eq, pow_mul, neg_pow_two, ← pow_mul, two_mul, pow_add, ← hc,
  ← h1]
state_before: a b' : ℕ
c' b c : ℕ
h1 : a.pow b' = c'
hb : 2 * b' = b
hc : c' * c' = c
⊢ (Int.negOfNat a).pow b = Int.ofNat c
state_after: a b' : ℕ
c' b c : ℕ
h1 : a.pow b' = c'
hb : 2 * b' = b
hc : c' * c' = c
⊢ Int.ofNat a ^ b' * Int.ofNat a ^ b' = Int.ofNat (a.pow b' * a.pow b')

tactic: simp
state_before: a b' : ℕ
c' b c : ℕ
h1 : a.pow b' = c'
hb : 2 * b' = b
hc : c' * c' = c
⊢ Int.ofNat a ^ b' * Int.ofNat a ^ b' = Int.ofNat (a.pow b' * a.pow b')
state_after: no goals
Theorem: List.concat_eq_reverse_cons
File: Mathlib/Data/List/Basic.lean

tactic: simp only [concat_eq_append, reverse_cons, reverse_reverse]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
⊢ l.concat a = (a :: l.reverse).reverse
state_after: no goals
Theorem: Set.Finite.union
File: Mathlib/Data/Set/Finite.lean

tactic: rw [Set.Finite] at hs ht
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
hs : s.Finite
ht : t.Finite
⊢ (s ∪ t).Finite
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
hs : Finite ↑s
ht : Finite ↑t
⊢ (s ∪ t).Finite

tactic: apply toFinite
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s t : Set α
hs : Finite ↑s
ht : Finite ↑t
⊢ (s ∪ t).Finite
state_after: no goals
Theorem: CategoryTheory.Subobject.factorThru_add_sub_factorThru_right
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : P.Factors (f + g)
wg : P.Factors g
⊢ P.factorThru (f + g) w - P.factorThru g wg = P.factorThru f ⋯
state_after: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : P.Factors (f + g)
wg : P.Factors g
⊢ (P.factorThru (f + g) w - P.factorThru g wg) ≫ P.arrow = P.factorThru f ⋯ ≫ P.arrow

tactic: simp
state_before: case h
C : Type u₁
inst✝² : Category.{v₁, u₁} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Preadditive C
X Y : C
P : Subobject Y
f g : X ⟶ Y
w : P.Factors (f + g)
wg : P.Factors g
⊢ (P.factorThru (f + g) w - P.factorThru g wg) ≫ P.arrow = P.factorThru f ⋯ ≫ P.arrow
state_after: no goals
Theorem: CoxeterSystem.exists_word_with_prod
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: rcases cs.wordProd_surjective w with ⟨ω, rfl⟩
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ n ω, ω.length = n ∧ cs.wordProd ω = w
state_after: case intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ ∃ n ω_1, ω_1.length = n ∧ cs.wordProd ω_1 = cs.wordProd ω

tactic: use ω.length, ω
state_before: case intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
⊢ ∃ n ω_1, ω_1.length = n ∧ cs.wordProd ω_1 = cs.wordProd ω
state_after: no goals
Theorem: Complex.rank_real_complex'
File: Mathlib/Data/Complex/FiniteDimensional.lean

tactic: rw [← finrank_eq_rank, finrank_real_complex, Cardinal.lift_natCast, Nat.cast_ofNat]
state_before: ⊢ Cardinal.lift.{u, 0} (Module.rank ℝ ℂ) = 2
state_after: no goals
Theorem: PNat.factorMultiset_le_iff'
File: Mathlib/Data/PNat/Factors.lean

tactic: let h := @factorMultiset_le_iff m v.prod
state_before: m : ℕ+
v : PrimeMultiset
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
state_after: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v.prod.factorMultiset ↔ m ∣ v.prod := factorMultiset_le_iff
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod

tactic: rw [v.factorMultiset_prod] at h
state_before: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v.prod.factorMultiset ↔ m ∣ v.prod := factorMultiset_le_iff
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
state_after: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v ↔ m ∣ v.prod
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod

tactic: exact h
state_before: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v ↔ m ∣ v.prod
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
state_after: no goals
Theorem: CochainComplex.mappingCone.inl_snd
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

tactic: ext p q hpq
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
⊢ (inl φ).comp (snd φ) ⋯ = 0
state_after: case h
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + -1 = q
⊢ ((inl φ).comp (snd φ) ⋯).v p q hpq = Cochain.v 0 p q hpq

tactic: simp [Cochain.comp_v _ _ (add_zero (-1)) p q q (by omega) (by omega)]
state_before: case h
C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + -1 = q
⊢ ((inl φ).comp (snd φ) ⋯).v p q hpq = Cochain.v 0 p q hpq
state_after: no goals

tactic: omega
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + -1 = q
⊢ p + -1 = q
state_after: no goals

tactic: omega
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + -1 = q
⊢ q + 0 = q
state_after: no goals
Theorem: Multiset.id_traverse
File: Mathlib/Data/Multiset/Functor.lean

tactic: refine Quotient.inductionOn x ?_
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
⊢ traverse pure x = x
state_after: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
⊢ ∀ (a : List α), traverse pure ⟦a⟧ = ⟦a⟧

tactic: intro
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
⊢ ∀ (a : List α), traverse pure ⟦a⟧ = ⟦a⟧
state_after: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
a✝ : List α
⊢ traverse pure ⟦a✝⟧ = ⟦a✝⟧

tactic: simp [traverse, Coe.coe]
state_before: F : Type u → Type u
inst✝¹ : Applicative F
inst✝ : CommApplicative F
α' β' : Type u
f : α' → F β'
α : Type u_1
x : Multiset α
a✝ : List α
⊢ traverse pure ⟦a✝⟧ = ⟦a✝⟧
state_after: no goals
Theorem: Grp.SurjectiveOfEpiAuxs.g_apply_fromCoset
File: Mathlib/Algebra/Category/Grp/EpiMono.lean

tactic: obtain ⟨z, hz⟩ := y.2
state_before: A B : Grp
f : A ⟶ B
x : ↑B
y : ↑(Set.range fun x => x • ↑(MonoidHom.range f))
⊢ x • ↑y ∈ Set.range fun x => x • ↑(MonoidHom.range f)
state_after: case intro
A B : Grp
f : A ⟶ B
x : ↑B
y : ↑(Set.range fun x => x • ↑(MonoidHom.range f))
z : ↑B
hz : (fun x => x • ↑(MonoidHom.range f)) z = ↑y
⊢ x • ↑y ∈ Set.range fun x => x • ↑(MonoidHom.range f)

tactic: exact ⟨x * z, by simp [← hz, smul_smul]⟩
state_before: case intro
A B : Grp
f : A ⟶ B
x : ↑B
y : ↑(Set.range fun x => x • ↑(MonoidHom.range f))
z : ↑B
hz : (fun x => x • ↑(MonoidHom.range f)) z = ↑y
⊢ x • ↑y ∈ Set.range fun x => x • ↑(MonoidHom.range f)
state_after: no goals

tactic: simp [← hz, smul_smul]
state_before: A B : Grp
f : A ⟶ B
x : ↑B
y : ↑(Set.range fun x => x • ↑(MonoidHom.range f))
z : ↑B
hz : (fun x => x • ↑(MonoidHom.range f)) z = ↑y
⊢ (fun x => x • ↑(MonoidHom.range f)) (x * z) = x • ↑y
state_after: no goals
Theorem: SimpleGraph.Subgraph.edgeSet_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
⊢ (⨆ i, f i).edgeSet = ⋃ i, (f i).edgeSet
state_after: no goals
Theorem: CategoryTheory.CostructuredArrow.homMk'_comp
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ mk (S.map (g' ≫ g) ≫ f.hom) = mk (S.map g' ≫ (mk (S.map g ≫ f.hom)).hom)
state_after: no goals

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ f.homMk' (g' ≫ g) = eqToHom ⋯ ≫ (mk (S.map g ≫ f.hom)).homMk' g' ≫ f.homMk' g
state_after: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ (f.homMk' (g' ≫ g)).left = (eqToHom ⋯ ≫ (mk (S.map g ≫ f.hom)).homMk' g' ≫ f.homMk' g).left

tactic: simp [eqToHom_left]
state_before: case h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' Y'' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
g' : Y'' ⟶ Y'
⊢ (f.homMk' (g' ≫ g)).left = (eqToHom ⋯ ≫ (mk (S.map g ≫ f.hom)).homMk' g' ≫ f.homMk' g).left
state_after: no goals
Theorem: List.prod_le_prod'
File: Mathlib/Algebra/Order/BigOperators/Group/List.lean

tactic: simpa
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝³ : Monoid M
inst✝² : Preorder M
inst✝¹ : CovariantClass M M (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
l : List ι
f g : ι → M
h : ∀ i ∈ l, f i ≤ g i
⊢ Forall₂ (fun x x_1 => x ≤ x_1) (map f l) (map g l)
state_after: no goals
Theorem: mul_invOf_eq_iff_eq_mul_right
File: Mathlib/Algebra/Group/Invertible/Defs.lean

tactic: rw [← mul_right_inj_of_invertible (c := c), mul_invOf_mul_self_cancel]
state_before: α : Type u
inst✝¹ : Monoid α
a b c : α
inst✝ : Invertible c
⊢ a * ⅟c = b ↔ a = b * c
state_after: no goals
Theorem: SimpleGraph.Walk.IsPath.tail
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [Walk.isPath_def] at hp ⊢
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 u v
hp : p.IsPath
hp' : ¬p.Nil
⊢ (p.tail hp').IsPath
state_after: 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 u v
hp : p.support.Nodup
hp' : ¬p.Nil
⊢ (p.tail hp').support.Nodup

tactic: rw [← cons_support_tail _ hp', List.nodup_cons] at hp
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 u v
hp : p.support.Nodup
hp' : ¬p.Nil
⊢ (p.tail hp').support.Nodup
state_after: 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 u v
hp' : ¬p.Nil
hp : u ∉ (p.tail hp').support ∧ (p.tail hp').support.Nodup
⊢ (p.tail hp').support.Nodup

tactic: exact hp.2
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 u v
hp' : ¬p.Nil
hp : u ∉ (p.tail hp').support ∧ (p.tail hp').support.Nodup
⊢ (p.tail hp').support.Nodup
state_after: no goals