ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Polynomial.hasseDeriv_eq_zero_of_lt_natDegree
File: Mathlib/Algebra/Polynomial/HasseDeriv.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
h : p.natDegree < n
⊢ (hasseDeriv n) p = 0
state_after: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
h : p.natDegree < n
⊢ ∑ n_1 ∈ p.support, (monomial (n_1 - n)) (↑(n_1.choose n) * p.coeff n_1) = 0
tactic: rw [hasseDeriv_apply, sum_def]
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
h : p.natDegree < n
⊢ ∑ n_1 ∈ p.support, (monomial (n_1 - n)) (↑(n_1.choose n) * p.coeff n_1) = 0
state_after: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
h : p.natDegree < n
x : ℕ
hx : x ∈ p.support
⊢ (monomial (x - n)) (↑(x.choose n) * p.coeff x) = 0
tactic: refine Finset.sum_eq_zero fun x hx => ?_
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f p : R[X]
n : ℕ
h : p.natDegree < n
x : ℕ
hx : x ∈ p.support
⊢ (monomial (x - n)) (↑(x.choose n) * p.coeff x) = 0
state_after: no goals
tactic: simp [Nat.choose_eq_zero_of_lt ((le_natDegree_of_mem_supp _ hx).trans_lt h)]
Theorem: pow_add_pow_le
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
n m : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hn : n ≠ 0
⊢ x ^ n + y ^ n ≤ (x + y) ^ n
state_after: case intro
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
m : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
k : ℕ
hn : k + 1 ≠ 0
⊢ x ^ (k + 1) + y ^ (k + 1) ≤ (x + y) ^ (k + 1)
tactic: rcases Nat.exists_eq_add_one_of_ne_zero hn with ⟨k, rfl⟩
state_before: case intro
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
m : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
k : ℕ
hn : k + 1 ≠ 0
⊢ x ^ (k + 1) + y ^ (k + 1) ≤ (x + y) ^ (k + 1)
state_after: case intro.zero
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
m : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hn : 0 + 1 ≠ 0
⊢ x ^ (0 + 1) + y ^ (0 + 1) ≤ (x + y) ^ (0 + 1)

case intro.succ
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
m : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
k : ℕ
ih : k + 1 ≠ 0 → x ^ (k + 1) + y ^ (k + 1) ≤ (x + y) ^ (k + 1)
hn : k + 1 + 1 ≠ 0
⊢ x ^ (k + 1 + 1) + y ^ (k + 1 + 1) ≤ (x + y) ^ (k + 1 + 1)
tactic: induction' k with k ih
Theorem: LucasLehmer.sZMod_eq_s
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: p' i : ℕ
⊢ sZMod (p' + 2) i = ↑(s i)
state_after: case zero
p' : ℕ
⊢ sZMod (p' + 2) 0 = ↑(s 0)

case succ
p' i : ℕ
ih : sZMod (p' + 2) i = ↑(s i)
⊢ sZMod (p' + 2) (i + 1) = ↑(s (i + 1))
tactic: induction' i with i ih
Theorem: SSet.Quasicategory.hornFilling
File: Mathlib/AlgebraicTopology/Quasicategory.lean

Proof steps:
state_before: S : SSet
inst✝ : S.Quasicategory
n : ℕ
i : Fin (n + 1)
h0 : 0 < i
hn : i < Fin.last n
σ₀ : Λ[n, i] ⟶ S
⊢ ∃ σ, σ₀ = hornInclusion n i ≫ σ
state_after: no goals
tactic: cases n using Nat.casesAuxOn with
  | zero => simp [Fin.lt_iff_val_lt_val] at hn
  | succ n =>
  cases n using Nat.casesAuxOn with
  | zero =>
    simp only [Fin.lt_iff_val_lt_val, Fin.val_zero, Fin.val_last, zero_add, Nat.lt_one_iff] at h0 hn
    simp [hn] at h0
  | succ n => exact Quasicategory.hornFilling' σ₀ h0 hn
Theorem: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_hom_app_hom₁
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ (inverse C ⋙ functor C).obj T ≅ (𝟭 (Triangle Cᵒᵖ)).obj T
state_after: case refine_1
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₁ ≫ (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₁

case refine_2
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₂ ≫ (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₂

case refine_3
C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
T : Triangle Cᵒᵖ
⊢ ((inverse C ⋙ functor C).obj T).mor₃ ≫ (shiftFunctor Cᵒᵖ 1).map (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁).hom =
    (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃).hom ≫ ((𝟭 (Triangle Cᵒᵖ)).obj T).mor₃
tactic: refine Triangle.isoMk _ _ (Iso.refl _) (Iso.refl _) (Iso.refl _) ?_ ?_ ?_
state_before: C : Type u_1
inst✝¹ : Category.{?u.192952, u_1} C
inst✝ : HasShift C ℤ
⊢ ∀ {X Y : Triangle Cᵒᵖ} (f : X ⟶ Y),
    (inverse C ⋙ functor C).map f ≫
        ((fun T =>
              ((inverse C ⋙ functor C).obj T).isoMk ((𝟭 (Triangle Cᵒᵖ)).obj T)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁) (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃) ⋯ ⋯ ⋯)
            Y).hom =
      ((fun T =>
              ((inverse C ⋙ functor C).obj T).isoMk ((𝟭 (Triangle Cᵒᵖ)).obj T)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₁) (Iso.refl ((inverse C ⋙ functor C).obj T).obj₂)
                (Iso.refl ((inverse C ⋙ functor C).obj T).obj₃) ⋯ ⋯ ⋯)
            X).hom ≫
        (𝟭 (Triangle Cᵒᵖ)).map f
state_after: no goals
tactic: aesop_cat
Theorem: Set.kernImage_preimage_union
File: Mathlib/Data/Set/Lattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
f : α → β
s : Set α
t : Set β
⊢ kernImage f (f ⁻¹' t ∪ s) = t ∪ kernImage f s
state_after: no goals
tactic: rw [union_comm, kernImage_union_preimage, union_comm]
Theorem: Real.sin_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: ⊢ sin (2 * π) = 0
state_after: no goals
tactic: simp [two_mul, sin_add]
Theorem: WeierstrassCurve.Jacobian.Point.toAffine_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hP : W.Nonsingular P
hPz : P z ≠ 0
⊢ toAffine W P = Affine.Point.some ⋯
state_after: no goals
tactic: rw [toAffine, dif_pos ⟨hP, hPz⟩]
Theorem: Set.Iic_union_Icc'
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
⊢ Iic b ∪ Icc c d = Iic (max b d)
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ∈ Iic b ∪ Icc c d ↔ x ∈ Iic (max b d)
tactic: ext1 x
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ∈ Iic b ∪ Icc c d ↔ x ∈ Iic (max b d)
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ≤ b ∨ c ≤ x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d
tactic: simp_rw [mem_union, mem_Iic, mem_Icc, le_max_iff]
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
⊢ x ≤ b ∨ c ≤ x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : c ≤ x
⊢ x ≤ b ∨ c ≤ x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d

case neg
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
x : α
hc : ¬c ≤ x
⊢ x ≤ b ∨ c ≤ x ∧ x ≤ d ↔ x ≤ b ∨ x ≤ d
tactic: by_cases hc : c ≤ x
Theorem: Substring.Valid.isEmpty
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
⊢ x✝.isEmpty = true ↔ x✝.toString = ""
state_after: no goals
tactic: simp [h.isEmpty, h.toString, ext_iff]
Theorem: LinearMap.exists_monic_and_aeval_eq_zero
File: Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean

Proof steps:
state_before: ι : Type u_1
inst✝⁴ : Fintype ι
M : Type u_2
inst✝³ : AddCommGroup M
R : Type u_3
inst✝² : CommRing R
inst✝¹ : Module R M
I : Ideal R
b : ι → M
hb : Submodule.span R (Set.range b) = ⊤
inst✝ : Module.Finite R M
f : Module.End R M
⊢ range f ≤ ⊤ • ⊤
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Pseudofunctor.mapComp_id_left_inv
File: Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean

Proof steps:
state_before: B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : Pseudofunctor B C
a b : B
f : a ⟶ b
⊢ (F.mapComp (𝟙 a) f).inv = (F.mapId a).hom ▷ F.map f ≫ (λ_ (F.map f)).hom ≫ F.map₂ (λ_ f).inv
state_after: no goals
tactic: simp [mapComp_id_left]
Theorem: Int.preimage_Ici
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ Int.cast ⁻¹' Ici a = Ici ⌈a⌉
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ici a ↔ x✝ ∈ Ici ⌈a⌉
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ici a ↔ x✝ ∈ Ici ⌈a⌉
state_after: no goals
tactic: simp [ceil_le]
Theorem: div_mul_eq_div_div_swap
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ a / (b * c) = a / c / b
state_after: no goals
tactic: simp only [mul_assoc, mul_inv_rev, div_eq_mul_inv]
Theorem: Matroid.Indep.basis_of_maximal_subset
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hmax : ∀ ⦃J : Set α⦄, M.Indep J → I ⊆ J → J ⊆ X → J ⊆ I
hX : autoParam (X ⊆ M.E) _auto✝
⊢ M.Basis I X
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hmax : ∀ ⦃J : Set α⦄, M.Indep J → I ⊆ J → J ⊆ X → J ⊆ I
hX : autoParam (X ⊆ M.E) _auto✝
⊢ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J
tactic: rw [basis_iff (by aesop_mat : X ⊆ M.E), and_iff_right hI, and_iff_right hIX]
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
hmax : ∀ ⦃J : Set α⦄, M.Indep J → I ⊆ J → J ⊆ X → J ⊆ I
hX : autoParam (X ⊆ M.E) _auto✝
⊢ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ X → I = J
state_after: no goals
tactic: exact fun J hJ hIJ hJX ↦ hIJ.antisymm (hmax hJ hIJ hJX)
Theorem: Orientation.kahler_ne_zero
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
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
hx : x ≠ 0
hy : y ≠ 0
⊢ (o.kahler x) y ≠ 0
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
hx : x ≠ 0
hy : y ≠ 0
⊢ ¬(x = 0 ∨ y = 0)
tactic: apply mt o.eq_zero_or_eq_zero_of_kahler_eq_zero
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
hx : x ≠ 0
hy : y ≠ 0
⊢ ¬(x = 0 ∨ y = 0)
state_after: no goals
tactic: tauto
Theorem: Orthonormal.equiv_refl
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁸ : _root_.RCLike 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : InnerProductSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
ι : Type u_4
ι' : Type u_5
ι'' : Type u_6
E' : Type u_7
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E'
E'' : Type u_8
inst✝¹ : NormedAddCommGroup E''
inst✝ : InnerProductSpace 𝕜 E''
v : Basis ι 𝕜 E
hv : Orthonormal 𝕜 ⇑v
i : ι
⊢ (hv.equiv hv (Equiv.refl ι)) (v i) = (LinearIsometryEquiv.refl 𝕜 E) (v i)
state_after: no goals
tactic: simp only [Orthonormal.equiv_apply, Equiv.coe_refl, id, LinearIsometryEquiv.coe_refl]
Theorem: Set.Ici.isAtom_iff
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
a b✝ : α
b : ↑(Ici a)
⊢ IsAtom b ↔ a ⋖ ↑b
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
a b✝ : α
b : ↑(Ici a)
⊢ ⊥ ⋖ b ↔ a ⋖ ↑b
tactic: rw [← bot_covBy_iff]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
a b✝ : α
b : ↑(Ici a)
⊢ ⊥ ⋖ b ↔ a ⋖ ↑b
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
a b✝ : α
b : ↑(Ici a)
⊢ (range ⇑(OrderEmbedding.subtype fun c => a ≤ c)).OrdConnected
tactic: refine (Set.OrdConnected.apply_covBy_apply_iff (OrderEmbedding.subtype fun c => a ≤ c) ?_).symm
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝ : PartialOrder α
a b✝ : α
b : ↑(Ici a)
⊢ (range ⇑(OrderEmbedding.subtype fun c => a ≤ c)).OrdConnected
state_after: no goals
tactic: simpa only [OrderEmbedding.subtype_apply, Subtype.range_coe_subtype] using Set.ordConnected_Ici
Theorem: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
s : PullbackCone f g
i j : 𝒰.J
⊢ pullbackFstιToV 𝒰 f g i j ≫ pullback.fst (pullback.fst (𝒰.map j ≫ f) g ≫ 𝒰.map j) (𝒰.map i) =
    pullback.snd (pullback.fst (p1 𝒰 f g) (𝒰.map i)) ((gluing 𝒰 f g).ι j)
state_after: no goals
tactic: simp [pullbackFstιToV, p1]
Theorem: smul_pos_iff_of_pos_left
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁶ : Zero α
inst✝⁵ : Zero β
inst✝⁴ : SMulZeroClass α β
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : PosSMulStrictMono α β
inst✝ : PosSMulReflectLT α β
ha : 0 < a
⊢ 0 < a • b ↔ 0 < b
state_after: no goals
tactic: simpa only [smul_zero] using smul_lt_smul_iff_of_pos_left ha (b₁ := 0) (b₂ := b)
Theorem: CategoryTheory.ShortComplex.homologyι_descOpcycles_eq_zero_of_boundary
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
k : S.X₂ ⟶ A
x : S.X₃ ⟶ A
hx : k = S.g ≫ x
⊢ S.f ≫ k = 0
state_after: no goals
tactic: rw [hx, S.zero_assoc, zero_comp]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
k : S.X₂ ⟶ A
x : S.X₃ ⟶ A
hx : k = S.g ≫ x
⊢ S.homologyι ≫ S.descOpcycles k ⋯ = 0
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
k : S.X₂ ⟶ A
x : S.X₃ ⟶ A
hx : k = S.g ≫ x
⊢ (S.rightHomologyIso.inv ≫ S.rightHomologyι) ≫ S.descOpcycles k ⋯ = 0
tactic: dsimp only [homologyι]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝ : S.HasHomology
k : S.X₂ ⟶ A
x : S.X₃ ⟶ A
hx : k = S.g ≫ x
⊢ (S.rightHomologyIso.inv ≫ S.rightHomologyι) ≫ S.descOpcycles k ⋯ = 0
state_after: no goals
tactic: rw [assoc, S.rightHomologyι_descOpcycles_π_eq_zero_of_boundary k x hx, comp_zero]
Theorem: Matrix.adjugate_pow
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

Proof steps:
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
k : ℕ
⊢ (A ^ k).adjugate = A.adjugate ^ k
state_after: case zero
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
⊢ (A ^ 0).adjugate = A.adjugate ^ 0

case succ
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
k : ℕ
IH : (A ^ k).adjugate = A.adjugate ^ k
⊢ (A ^ (k + 1)).adjugate = A.adjugate ^ (k + 1)
tactic: induction' k with k IH
Theorem: Subgroup.mem_closure_singleton
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
⊢ y ∈ closure {x} ↔ ∃ n, x ^ n = y
state_after: case refine_1
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ x_1 ∈ {x}, ∃ n, x ^ n = x_1

case refine_2
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∃ n, x ^ n = 1

case refine_3
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ (x_1 y : G), (∃ n, x ^ n = x_1) → (∃ n, x ^ n = y) → ∃ n, x ^ n = x_1 * y

case refine_4
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ (x_1 : G), (∃ n, x ^ n = x_1) → ∃ n, x ^ n = x_1⁻¹
tactic: refine
    ⟨fun hy => closure_induction hy ?_ ?_ ?_ ?_, fun ⟨n, hn⟩ =>
      hn ▸ zpow_mem (subset_closure <| mem_singleton x) n⟩
state_before: case refine_4
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
⊢ ∀ (x_1 : G), (∃ n, x ^ n = x_1) → ∃ n, x ^ n = x_1⁻¹
state_after: case refine_4.intro
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
n : ℤ
⊢ ∃ n_1, x ^ n_1 = (x ^ n)⁻¹
tactic: rintro _ ⟨n, rfl⟩
state_before: case refine_4.intro
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H K : Subgroup G
k : Set G
x y : G
hy : y ∈ closure {x}
n : ℤ
⊢ ∃ n_1, x ^ n_1 = (x ^ n)⁻¹
state_after: no goals
tactic: exact ⟨-n, zpow_neg x n⟩
Theorem: CategoryTheory.Functor.shiftIso_hom_app_comp_shiftMap
File: Mathlib/CategoryTheory/Shift/ShiftSequence.lean

Proof steps:
state_before: C : Type u_1
A : Type u_2
inst✝⁶ : Category.{?u.83401, u_1} C
inst✝⁵ : Category.{?u.83405, u_2} A
F : C ⥤ A
M : Type u_3
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence M
X Y : C
m : M
f : X ⟶ (shiftFunctor C m).obj Y
n mn : M
hnm : m + n = mn
a a' a'' : M
ha' : n + a = a'
ha'' : m + a' = a''
⊢ mn + a = a''
state_after: no goals
tactic: rw [← ha'', ← ha', ← hnm, add_assoc]
state_before: C : Type u_1
A : Type u_2
inst✝⁶ : Category.{u_5, u_1} C
inst✝⁵ : Category.{u_6, u_2} A
F : C ⥤ A
M : Type u_3
inst✝⁴ : AddMonoid M
inst✝³ : HasShift C M
G : Type u_4
inst✝² : AddGroup G
inst✝¹ : HasShift C G
inst✝ : F.ShiftSequence M
X Y : C
m : M
f : X ⟶ (shiftFunctor C m).obj Y
n mn : M
hnm : m + n = mn
a a' a'' : M
ha' : n + a = a'
ha'' : m + a' = a''
⊢ (F.shiftIso n a a' ha').hom.app X ≫ F.shiftMap f a' a'' ha'' =
    (F.shift a).map ((shiftFunctor C n).map f) ≫
      (F.shift a).map ((shiftFunctorAdd' C m n mn hnm).inv.app Y) ≫ (F.shiftIso mn a a'' ⋯).hom.app Y
state_after: no goals
tactic: simp only [F.shiftIso_add'_hom_app n m mn hnm a a' a'' ha' ha'' Y,
    ← Functor.map_comp_assoc, Iso.inv_hom_id_app, Functor.map_id,
    id_comp, comp_obj, shiftIso_hom_naturality_assoc, shiftMap]
Theorem: Ordinal.principal_nfp_blsub₂
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
ha : a < nfp (fun o' => o'.blsub₂ o' fun a x b x => op a b) o
hb : b < nfp (fun o' => o'.blsub₂ o' fun a x b x => op a b) o
⊢ op a b < nfp (fun o' => o'.blsub₂ o' fun a x b x => op a b) o
state_after: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
ha : ∃ n, a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
hb : ∃ n, b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
tactic: rw [lt_nfp] at *
state_before: op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
ha : ∃ n, a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
hb : ∃ n, b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
state_after: case intro
op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
hb : ∃ n, b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
m : ℕ
hm : a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
tactic: cases' ha with m hm
state_before: case intro
op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
hb : ∃ n, b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
m : ℕ
hm : a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
state_after: case intro.intro
op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
m : ℕ
hm : a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o
n : ℕ
hn : b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
tactic: cases' hb with n hn
state_before: case intro.intro
op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
m : ℕ
hm : a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o
n : ℕ
hn : b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
state_after: case intro.intro.inl
op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
m : ℕ
hm : a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o
n : ℕ
hn : b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
h : (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o ≤ (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o

case intro.intro.inr
op : Ordinal.{u} → Ordinal.{u} → Ordinal.{u}
o a b : Ordinal.{u}
m : ℕ
hm : a < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o
n : ℕ
hn : b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
h : (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o ≤ (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[m] o
⊢ ∃ n, op a b < (fun o' => o'.blsub₂ o' fun a x b x => op a b)^[n] o
tactic: cases' le_total
    ((fun o' => blsub₂.{u, u, u} o' o' (@fun a _ b _ => op a b))^[m] o)
    ((fun o' => blsub₂.{u, u, u} o' o' (@fun a _ b _ => op a b))^[n] o) with h h
Theorem: IsOpen.union
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (s₁ ∪ s₂)
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (⋃ b, bif b then s₁ else s₂)
tactic: rw [union_eq_iUnion]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
h₁ : IsOpen s₁
h₂ : IsOpen s₂
⊢ IsOpen (⋃ b, bif b then s₁ else s₂)
state_after: no goals
tactic: exact isOpen_iUnion (Bool.forall_bool.2 ⟨h₂, h₁⟩)