1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Metric.isCompact_of_isClosed_isBounded
File: Mathlib/Topology/MetricSpace/Bounded.lean

tactic: rcases eq_empty_or_nonempty s with (rfl | ⟨x, -⟩)
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
s t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : IsBounded s
⊢ IsCompact s
state_after: case inl
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed ∅
hb : IsBounded ∅
⊢ IsCompact ∅

case inr.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ : α
s t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : IsBounded s
x : α
⊢ IsCompact s

tactic: exact isCompact_empty
state_before: case inl
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x : α
t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed ∅
hb : IsBounded ∅
⊢ IsCompact ∅
state_after: no goals

tactic: rcases hb.subset_closedBall x with ⟨r, hr⟩
state_before: case inr.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ : α
s t : Set α
r : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : IsBounded s
x : α
⊢ IsCompact s
state_after: case inr.intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ : α
s t : Set α
r✝ : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : IsBounded s
x : α
r : ℝ
hr : s ⊆ closedBall x r
⊢ IsCompact s

tactic: exact (isCompact_closedBall x r).of_isClosed_subset hc hr
state_before: case inr.intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ : α
s t : Set α
r✝ : ℝ
inst✝ : ProperSpace α
hc : IsClosed s
hb : IsBounded s
x : α
r : ℝ
hr : s ⊆ closedBall x r
⊢ IsCompact s
state_after: no goals
Theorem: LieSubmodule.Quotient.map_mk'_eq_bot_le
File: Mathlib/Algebra/Lie/Quotient.lean

tactic: rw [← LieModuleHom.le_ker_iff_map, mk'_ker]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ map (mk' N) N' = ⊥ ↔ N' ≤ N
state_after: no goals
Theorem: SetTheory.PGame.mul_moveRight_inr
File: Mathlib/SetTheory/Game/Basic.lean

tactic: cases x
state_before: x y : PGame
i : x.RightMoves
j : y.LeftMoves
⊢ (x * y).moveRight (toRightMovesMul (Sum.inr (i, j))) =
    x.moveRight i * y + x * y.moveLeft j - x.moveRight i * y.moveLeft j
state_after: case mk
y : PGame
j : y.LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveRight (toRightMovesMul (Sum.inr (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveRight i * y + mk α✝ β✝ a✝¹ a✝ * y.moveLeft j - (mk α✝ β✝ a✝¹ a✝).moveRight i * y.moveLeft j

tactic: cases y
state_before: case mk
y : PGame
j : y.LeftMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
i : (mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (mk α✝ β✝ a✝¹ a✝ * y).moveRight (toRightMovesMul (Sum.inr (i, j))) =
    (mk α✝ β✝ a✝¹ a✝).moveRight i * y + mk α✝ β✝ a✝¹ a✝ * y.moveLeft j - (mk α✝ β✝ a✝¹ a✝).moveRight i * y.moveLeft j
state_after: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesMul (Sum.inr (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveLeft j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * (mk α✝ β✝ a✝¹ a✝).moveLeft j

tactic: rfl
state_before: case mk.mk
α✝¹ β✝¹ : Type u_1
a✝³ : α✝¹ → PGame
a✝² : β✝¹ → PGame
i : (mk α✝¹ β✝¹ a✝³ a✝²).RightMoves
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
j : (mk α✝ β✝ a✝¹ a✝).LeftMoves
⊢ (mk α✝¹ β✝¹ a✝³ a✝² * mk α✝ β✝ a✝¹ a✝).moveRight (toRightMovesMul (Sum.inr (i, j))) =
    (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * mk α✝ β✝ a✝¹ a✝ + mk α✝¹ β✝¹ a✝³ a✝² * (mk α✝ β✝ a✝¹ a✝).moveLeft j -
      (mk α✝¹ β✝¹ a✝³ a✝²).moveRight i * (mk α✝ β✝ a✝¹ a✝).moveLeft j
state_after: no goals
Theorem: CategoryTheory.Localization.homEquiv_trans
File: Mathlib/CategoryTheory/Localization/HomEquiv.lean

tactic: dsimp only [homEquiv_apply]
state_before: C : Type u_1
C₁ : Type u_2
C₂ : Type u_3
C₃ : Type u_4
D₁ : Type u_5
D₂ : Type u_6
D₃ : Type u_7
inst✝⁹ : Category.{u_9, u_1} C
inst✝⁸ : Category.{?u.43929, u_2} C₁
inst✝⁷ : Category.{?u.43933, u_3} C₂
inst✝⁶ : Category.{?u.43937, u_4} C₃
inst✝⁵ : Category.{u_8, u_5} D₁
inst✝⁴ : Category.{u_11, u_6} D₂
inst✝³ : Category.{u_10, u_7} D₃
W : MorphismProperty C
L₁ : C ⥤ D₁
inst✝² : L₁.IsLocalization W
L₂ : C ⥤ D₂
inst✝¹ : L₂.IsLocalization W
L₃ : C ⥤ D₃
inst✝ : L₃.IsLocalization W
X Y Z : C
f : L₁.obj X ⟶ L₁.obj Y
⊢ (homEquiv W L₂ L₃) ((homEquiv W L₁ L₂) f) = (homEquiv W L₁ L₃) f
state_after: C : Type u_1
C₁ : Type u_2
C₂ : Type u_3
C₃ : Type u_4
D₁ : Type u_5
D₂ : Type u_6
D₃ : Type u_7
inst✝⁹ : Category.{u_9, u_1} C
inst✝⁸ : Category.{?u.43929, u_2} C₁
inst✝⁷ : Category.{?u.43933, u_3} C₂
inst✝⁶ : Category.{?u.43937, u_4} C₃
inst✝⁵ : Category.{u_8, u_5} D₁
inst✝⁴ : Category.{u_11, u_6} D₂
inst✝³ : Category.{u_10, u_7} D₃
W : MorphismProperty C
L₁ : C ⥤ D₁
inst✝² : L₁.IsLocalization W
L₂ : C ⥤ D₂
inst✝¹ : L₂.IsLocalization W
L₃ : C ⥤ D₃
inst✝ : L₃.IsLocalization W
X Y Z : C
f : L₁.obj X ⟶ L₁.obj Y
⊢ (LocalizerMorphism.id W).homMap L₂ L₃ ((LocalizerMorphism.id W).homMap L₁ L₂ f) =
    (LocalizerMorphism.id W).homMap L₁ L₃ f

tactic: apply LocalizerMorphism.homMap_homMap
state_before: C : Type u_1
C₁ : Type u_2
C₂ : Type u_3
C₃ : Type u_4
D₁ : Type u_5
D₂ : Type u_6
D₃ : Type u_7
inst✝⁹ : Category.{u_9, u_1} C
inst✝⁸ : Category.{?u.43929, u_2} C₁
inst✝⁷ : Category.{?u.43933, u_3} C₂
inst✝⁶ : Category.{?u.43937, u_4} C₃
inst✝⁵ : Category.{u_8, u_5} D₁
inst✝⁴ : Category.{u_11, u_6} D₂
inst✝³ : Category.{u_10, u_7} D₃
W : MorphismProperty C
L₁ : C ⥤ D₁
inst✝² : L₁.IsLocalization W
L₂ : C ⥤ D₂
inst✝¹ : L₂.IsLocalization W
L₃ : C ⥤ D₃
inst✝ : L₃.IsLocalization W
X Y Z : C
f : L₁.obj X ⟶ L₁.obj Y
⊢ (LocalizerMorphism.id W).homMap L₂ L₃ ((LocalizerMorphism.id W).homMap L₁ L₂ f) =
    (LocalizerMorphism.id W).homMap L₁ L₃ f
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isRat_ofScientific_of_true
File: Mathlib/Tactic/NormNum/OfScientific.lean

tactic: rwa [← Rat.cast_ofScientific, ← Rat.ofScientific_eq_ofScientific, Rat.ofScientific_true_def]
state_before: α : Type u_1
inst✝ : DivisionRing α
x✝¹ x✝ : ℕ
num✝ : ℤ
denom✝ : ℕ
inv✝ : Invertible ↑denom✝
eq : ↑(mkRat (↑x✝¹) (10 ^ x✝)) = ↑num✝ * ⅟↑denom✝
⊢ OfScientific.ofScientific x✝¹ true x✝ = ↑num✝ * ⅟↑denom✝
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.Heap.realSize_tail?
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

tactic: simp only [Heap.tail?]
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
⊢ tail? le s = some s' → s.realSize = s'.realSize + 1
state_after: α : Type u_1
le : α → α → Bool
s' s : Heap α
⊢ Option.map (fun x => x.snd) (deleteMin le s) = some s' → s.realSize = s'.realSize + 1

tactic: intro eq
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
⊢ Option.map (fun x => x.snd) (deleteMin le s) = some s' → s.realSize = s'.realSize + 1
state_after: α : Type u_1
le : α → α → Bool
s' s : Heap α
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
⊢ s.realSize = s'.realSize + 1

tactic: match eq₂ : s.deleteMin le, eq with
| some (a, tl), rfl => exact realSize_deleteMin eq₂
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
⊢ s.realSize = s'.realSize + 1
state_after: no goals

tactic: exact realSize_deleteMin eq₂
state_before: α : Type u_1
le : α → α → Bool
s' s : Heap α
eq : Option.map (fun x => x.snd) (deleteMin le s) = some s'
a : α
tl : Heap α
eq₂ : deleteMin le s = some (a, tl)
⊢ s.realSize = ((fun x => x.snd) (a, tl)).realSize + 1
state_after: no goals
Theorem: PMF.uniformOfFinset_apply_of_mem
File: Mathlib/Probability/Distributions/Uniform.lean

tactic: simp [ha]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
hs : s.Nonempty
a : α
ha : a ∈ s
⊢ (uniformOfFinset s hs) a = (↑s.card)⁻¹
state_after: no goals
Theorem: Complex.one_div_Gamma_eq_self_mul_one_div_Gamma_add_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/Beta.lean

tactic: rcases ne_or_eq s 0 with (h | rfl)
state_before: s : ℂ
⊢ (Gamma s)⁻¹ = s * (Gamma (s + 1))⁻¹
state_after: case inl
s : ℂ
h : s ≠ 0
⊢ (Gamma s)⁻¹ = s * (Gamma (s + 1))⁻¹

case inr

⊢ (Gamma 0)⁻¹ = 0 * (Gamma (0 + 1))⁻¹

tactic: rw [Gamma_add_one s h, mul_inv, mul_inv_cancel_left₀ h]
state_before: case inl
s : ℂ
h : s ≠ 0
⊢ (Gamma s)⁻¹ = s * (Gamma (s + 1))⁻¹
state_after: no goals

tactic: rw [zero_add, Gamma_zero, inv_zero, zero_mul]
state_before: case inr

⊢ (Gamma 0)⁻¹ = 0 * (Gamma (0 + 1))⁻¹
state_after: no goals
Theorem: summable_of_summable_hasDerivAt
File: Mathlib/Analysis/Calculus/SmoothSeries.lean

tactic: exact summable_of_summable_hasDerivAt_of_isPreconnected hu isOpen_univ isPreconnected_univ
  (fun n x _ => hg n x) (fun n x _ => hg' n x) (mem_univ _) hg0 (mem_univ _)
state_before: α : Type u_1
β : Type u_2
𝕜 : Type u_3
E : Type u_4
F : Type u_5
inst✝⁵ : RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : CompleteSpace F
u : α → ℝ
inst✝ : NormedSpace 𝕜 F
f : α → E → F
f' : α → E → E →L[𝕜] F
g g' : α → 𝕜 → F
v : ℕ → α → ℝ
s : Set E
t : Set 𝕜
x₀ x : E
y₀ y✝ : 𝕜
N : ℕ∞
hu : Summable u
hg : ∀ (n : α) (y : 𝕜), HasDerivAt (g n) (g' n y) y
hg' : ∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n
hg0 : Summable fun n => g n y₀
y : 𝕜
⊢ Summable fun n => g n y
state_after: no goals
Theorem: LinearEquiv.ofBijective_symm_apply_apply
File: Mathlib/Algebra/Module/Submodule/Equiv.lean

tactic: simp [LinearEquiv.symm_apply_eq]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
M : Type u_5
M₁ : Type u_6
M₂ : Type u_7
M₃ : Type u_8
N : Type u_9
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : Semiring R₃
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : AddCommMonoid M₃
module_M : Module R M
module_M₂ : Module R₂ M₂
module_M₃ : Module R₃ M₃
σ₁₂ : R →+* R₂
σ₂₁ : R₂ →+* R
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝² : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
σ₃₂ : R₃ →+* R₂
re₁₂ : RingHomInvPair σ₁₂ σ₂₁
re₂₁ : RingHomInvPair σ₂₁ σ₁₂
re₂₃ : RingHomInvPair σ₂₃ σ₃₂
re₃₂ : RingHomInvPair σ₃₂ σ₂₃
f : M →ₛₗ[σ₁₂] M₂
g : M₂ →ₛₗ[σ₂₁] M
e : M ≃ₛₗ[σ₁₂] M₂
h✝ : M₂ →ₛₗ[σ₂₃] M₃
p q : Submodule R M
inst✝¹ : RingHomInvPair σ₁₂ σ₂₁
inst✝ : RingHomInvPair σ₂₁ σ₁₂
h : Bijective ⇑f
x : M
⊢ (ofBijective f h).symm (f x) = x
state_after: no goals
Theorem: mem_rightCoset_rightCoset
File: Mathlib/GroupTheory/Coset.lean

tactic: rw [← SetLike.mem_coe, ← ha]
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : op a • ↑s = ↑s
⊢ a ∈ s
state_after: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : op a • ↑s = ↑s
⊢ a ∈ op a • ↑s

tactic: exact mem_own_rightCoset s a
state_before: α : Type u_1
inst✝ : Monoid α
s : Submonoid α
a : α
ha : op a • ↑s = ↑s
⊢ a ∈ op a • ↑s
state_after: no goals
Theorem: Coheyting.boundary_top
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, hnot_top, inf_bot_eq]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ ⊤ = ⊥
state_after: no goals
Theorem: Ordinal.lift_is_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [h, ← e, lift_succ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
x✝ : ∃ a, lift.{u, v} o = succ a
a : Ordinal.{max v u}
h : lift.{u, v} o = succ a
b : Ordinal.{v}
e : lift.{u, v} b = a
⊢ lift.{?u.18098, v} o = lift.{?u.18098, v} (succ b)
state_after: no goals

tactic: simp only [h, lift_succ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
x✝ : ∃ a, o = succ a
a : Ordinal.{v}
h : o = succ a
⊢ lift.{u, v} o = succ (lift.{u, v} a)
state_after: no goals
Theorem: CategoryTheory.IsIso.inv_inv
File: Mathlib/CategoryTheory/Iso.lean

tactic: apply inv_eq_of_hom_inv_id
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
inst✝ : IsIso f
⊢ inv (inv f) = f
state_after: case hom_inv_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
inst✝ : IsIso f
⊢ inv f ≫ f = 𝟙 Y

tactic: simp
state_before: case hom_inv_id
C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
inst✝ : IsIso f
⊢ inv f ≫ f = 𝟙 Y
state_after: no goals
Theorem: LieAlgebra.IsKilling.ideal_eq_bot_of_isLieAbelian
File: Mathlib/Algebra/Lie/Killing.lean

tactic: rw [eq_bot_iff, ← killingCompl_top_eq_bot]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : LieAlgebra K L
inst✝⁵ : Module.Free R L
inst✝⁴ : Module.Finite R L
inst✝³ : IsKilling R L
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
I : LieIdeal R L
inst✝ : IsLieAbelian ↥↑I
⊢ I = ⊥
state_after: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : LieAlgebra K L
inst✝⁵ : Module.Free R L
inst✝⁴ : Module.Finite R L
inst✝³ : IsKilling R L
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
I : LieIdeal R L
inst✝ : IsLieAbelian ↥↑I
⊢ I ≤ LieIdeal.killingCompl R L ⊤

tactic: exact I.le_killingCompl_top_of_isLieAbelian
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : Field K
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
inst✝⁶ : LieAlgebra K L
inst✝⁵ : Module.Free R L
inst✝⁴ : Module.Finite R L
inst✝³ : IsKilling R L
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
I : LieIdeal R L
inst✝ : IsLieAbelian ↥↑I
⊢ I ≤ LieIdeal.killingCompl R L ⊤
state_after: no goals
Theorem: Vector.reverse_get_zero
File: Mathlib/Data/Vector/Basic.lean

tactic: rw [← get_zero, last_def, get_eq_get, get_eq_get]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.reverse.head = v.last
state_after: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.reverse.toList.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))

tactic: simp_rw [toList_reverse]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.reverse.toList.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))
state_after: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList.reverse.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))

tactic: rw [List.get_eq_getElem, List.get_eq_getElem, ← Option.some_inj, Fin.cast, Fin.cast,
  ← List.getElem?_eq_getElem, ← List.getElem?_eq_getElem, List.getElem?_reverse]
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList.reverse.get (Fin.cast ⋯ 0) = v.toList.get (Fin.cast ⋯ (Fin.last n))
state_after: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList[v.toList.length - 1 - ↑⟨↑0, ⋯⟩]? = v.toList[↑⟨↑(Fin.last n), ⋯⟩]?

n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ ↑⟨↑0, ⋯⟩ < v.toList.length

tactic: congr
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList[v.toList.length - 1 - ↑⟨↑0, ⋯⟩]? = v.toList[↑⟨↑(Fin.last n), ⋯⟩]?
state_after: case e_a
n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList.length - 1 - ↑⟨↑0, ⋯⟩ = ↑⟨↑(Fin.last n), ⋯⟩

tactic: simp
state_before: case e_a
n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ v.toList.length - 1 - ↑⟨↑0, ⋯⟩ = ↑⟨↑(Fin.last n), ⋯⟩
state_after: no goals

tactic: simp
state_before: n : ℕ
α : Type u_1
v : Vector α (n + 1)
⊢ ↑⟨↑0, ⋯⟩ < v.toList.length
state_after: no goals
Theorem: Rat.divInt_eq_div
File: Mathlib/Data/Rat/Defs.lean

tactic: simp [div_def']
state_before: q a b c : ℚ
n d : ℤ
⊢ n /. d = ↑n / ↑d
state_after: no goals
Theorem: ExteriorAlgebra.liftAlternating_ι
File: Mathlib/LinearAlgebra/ExteriorAlgebra/OfAlternating.lean

tactic: dsimp [liftAlternating]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
⊢ (liftAlternating f) ((ι R) m) = (f 1) ![m]
state_after: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
⊢ (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) f) ((ι R) m) 0) 0 = (f 1) ![m]

tactic: rw [foldl_ι, LinearMap.mk₂_apply, AlternatingMap.curryLeft_apply_apply]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
⊢ (((foldl 0 (LinearMap.mk₂ R (fun m f i => (f (i + 1)).curryLeft m) ⋯ ⋯ ⋯ ⋯) ⋯) f) ((ι R) m) 0) 0 = (f 1) ![m]
state_after: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
⊢ (f (0 + 1)) (Matrix.vecCons m 0) = (f 1) ![m]

tactic: congr
state_before: R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
⊢ (f (0 + 1)) (Matrix.vecCons m 0) = (f 1) ![m]
state_after: case h.e_6.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
⊢ Matrix.vecCons m 0 = ![m]

tactic: rw [Matrix.zero_empty]
state_before: case h.e_6.h
R : Type u_1
M : Type u_2
N : Type u_3
N' : Type u_4
inst✝⁶ : CommRing R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup N'
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R N'
f : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N
m : M
⊢ Matrix.vecCons m 0 = ![m]
state_after: no goals
Theorem: CategoryTheory.Idempotents.Karoubi.decompId_p_toKaroubi
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

tactic: rfl
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : C
⊢ ((toKaroubi C).obj X).decompId_p = 𝟙 { X := ((toKaroubi C).obj X).X, p := 𝟙 ((toKaroubi C).obj X).X, idem := ⋯ }
state_after: no goals
Theorem: Localization.algEquiv_symm_mk
File: Mathlib/RingTheory/Localization/Basic.lean

tactic: rw [mk_eq_mk', algEquiv_symm_mk']
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
x : R
y : ↥M
⊢ (algEquiv M S).symm (mk' S x y) = mk x y
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.triangle_assoc_comp_left_inv
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: simp [← cancel_mono ((ρ_ X).hom ▷ Y)]
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 X Y : C
⊢ X ◁ (λ_ Y).inv ≫ (α_ X (𝟙_ C) Y).inv = (ρ_ X).inv ▷ Y
state_after: no goals
Theorem: Nat.filter_coprime_Ico_eq_totient
File: Mathlib/Data/Nat/Totient.lean

tactic: rw [totient, filter_Ico_card_eq_of_periodic, count_eq_card_filter_range]
state_before: a n : ℕ
⊢ (filter a.Coprime (Ico n (n + a))).card = φ a
state_after: case pp
a n : ℕ
⊢ Function.Periodic a.Coprime a

tactic: exact periodic_coprime a
state_before: case pp
a n : ℕ
⊢ Function.Periodic a.Coprime a
state_after: no goals
Theorem: SimpleGraph.edge_adj
File: Mathlib/Combinatorics/SimpleGraph/Operations.lean

tactic: rw [edge, fromEdgeSet_adj, Set.mem_singleton_iff, Sym2.eq_iff]
state_before: V : Type u_1
inst✝ : DecidableEq V
G : SimpleGraph V
s t v w : V
⊢ (edge s t).Adj v w ↔ (v = s ∧ w = t ∨ v = t ∧ w = s) ∧ v ≠ w
state_after: no goals
Theorem: CategoryTheory.SingleFunctors.shiftIso_add'_hom_app
File: Mathlib/CategoryTheory/Shift/SingleFunctors.lean

tactic: rw [← hnm, ← ha'', ← ha', add_assoc]
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{?u.16705, u_1} C
inst✝⁴ : Category.{?u.16709, u_2} D
inst✝³ : Category.{?u.16713, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
n m mn : A
hnm : m + n = mn
a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ mn + a = a''
state_after: no goals

tactic: simp [F.shiftIso_add' n m mn hnm a a' a'' ha' ha'']
state_before: C : Type u_1
D : Type u_2
E : Type u_3
E' : Type u_4
inst✝⁵ : Category.{u_7, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
inst✝³ : Category.{?u.16713, u_3} E
A : Type u_5
inst✝² : AddMonoid A
inst✝¹ : HasShift D A
inst✝ : HasShift E A
F G H : SingleFunctors C D A
n m mn : A
hnm : m + n = mn
a a' a'' : A
ha' : n + a = a'
ha'' : m + a' = a''
X : C
⊢ (F.shiftIso mn a a'' ⋯).hom.app X =
    (shiftFunctorAdd' D m n mn hnm).hom.app ((F.functor a'').obj X) ≫
      (shiftFunctor D n).map ((F.shiftIso m a' a'' ha'').hom.app X) ≫ (F.shiftIso n a a' ha').hom.app X
state_after: no goals
Theorem: CategoryTheory.ShortComplex.SnakeInput.snd_δ_inr
File: Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean

tactic: simp only [snd_δ_assoc, ← pushout.condition, φ₂, φ₁_L₂_f_assoc, assoc]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
S : SnakeInput C
⊢ pullback.snd ≫ S.δ ≫ pushout.inr = pullback.fst ≫ S.v₁₂.τ₂ ≫ pushout.inl
state_after: no goals
Theorem: Finset.min'_lt_max'_of_card
File: Mathlib/Data/Finset/Lattice.lean

tactic: omega
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
h₂ : 1 < s.card
⊢ 0 < s.card
state_after: no goals

tactic: rcases one_lt_card.1 h₂ with ⟨a, ha, b, hb, hab⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
h₂ : 1 < s.card
⊢ s.min' ⋯ < s.max' ⋯
state_after: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
h₂ : 1 < s.card
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≠ b
⊢ s.min' ⋯ < s.max' ⋯

tactic: exact s.min'_lt_max' ha hb hab
state_before: case intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s : Finset α
H : s.Nonempty
x : α
h₂ : 1 < s.card
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : a ≠ b
⊢ s.min' ⋯ < s.max' ⋯
state_after: no goals
Theorem: Polynomial.leadingCoeff_monomial
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: by_cases ha : a = 0
state_before: R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : R
n : ℕ
⊢ ((monomial n) a).leadingCoeff = a
state_after: case pos
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : R
n : ℕ
ha : a = 0
⊢ ((monomial n) a).leadingCoeff = a

case neg
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : R
n : ℕ
ha : ¬a = 0
⊢ ((monomial n) a).leadingCoeff = a

tactic: simp only [ha, (monomial n).map_zero, leadingCoeff_zero]
state_before: case pos
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : R
n : ℕ
ha : a = 0
⊢ ((monomial n) a).leadingCoeff = a
state_after: no goals

tactic: rw [leadingCoeff, natDegree_monomial, if_neg ha, coeff_monomial]
state_before: case neg
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : R
n : ℕ
ha : ¬a = 0
⊢ ((monomial n) a).leadingCoeff = a
state_after: case neg
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : R
n : ℕ
ha : ¬a = 0
⊢ (if n = n then a else 0) = a

tactic: simp
state_before: case neg
R : Type u
S : Type v
a✝ b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
a : R
n : ℕ
ha : ¬a = 0
⊢ (if n = n then a else 0) = a
state_after: no goals