ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.LeftHomologyData.π_comp_homologyIso_inv
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
h : S.LeftHomologyData
⊢ h.π ≫ h.homologyIso.inv = h.cyclesIso.inv ≫ S.homologyπ
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
h : S.LeftHomologyData
⊢ h.π ≫ (S.leftHomologyIso.symm ≪≫ h.leftHomologyIso).inv = h.cyclesIso.inv ≫ S.leftHomologyπ ≫ S.leftHomologyIso.hom
tactic: dsimp only [homologyπ, homologyIso]
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
h : S.LeftHomologyData
⊢ h.π ≫ (S.leftHomologyIso.symm ≪≫ h.leftHomologyIso).inv = h.cyclesIso.inv ≫ S.leftHomologyπ ≫ S.leftHomologyIso.hom
state_after: no goals
tactic: simp only [Iso.trans_inv, Iso.symm_inv, π_comp_leftHomologyIso_inv_assoc]
Theorem: SetTheory.PGame.grundyValue_nim_add_nim
File: Mathlib/SetTheory/Game/Nim.lean

Proof steps:
state_before: n m : ℕ
⊢ (nim ↑n + nim ↑m).grundyValue = ↑(n ^^^ m)
state_after: case h
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
⊢ (nim ↑n + nim ↑m).grundyValue = ↑(n ^^^ m)
tactic: induction' n using Nat.strong_induction_on with n hn generalizing m
state_before: case h
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
⊢ (nim ↑n + nim ↑m).grundyValue = ↑(n ^^^ m)
state_after: case h.h
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
hm : ∀ m_1 < m, (nim ↑n + nim ↑m_1).grundyValue = ↑(n ^^^ m_1)
⊢ (nim ↑n + nim ↑m).grundyValue = ↑(n ^^^ m)
tactic: induction' m using Nat.strong_induction_on with m hm
state_before: case h.h
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
hm : ∀ m_1 < m, (nim ↑n + nim ↑m_1).grundyValue = ↑(n ^^^ m_1)
⊢ (nim ↑n + nim ↑m).grundyValue = ↑(n ^^^ m)
state_after: case h.h
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
hm : ∀ m_1 < m, (nim ↑n + nim ↑m_1).grundyValue = ↑(n ^^^ m_1)
⊢ (mex fun i => ((nim ↑n + nim ↑m).moveLeft i).grundyValue) = ↑(n ^^^ m)
tactic: rw [grundyValue_eq_mex_left]
state_before: case h.h
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
hm : ∀ m_1 < m, (nim ↑n + nim ↑m_1).grundyValue = ↑(n ^^^ m_1)
⊢ (mex fun i => ((nim ↑n + nim ↑m).moveLeft i).grundyValue) = ↑(n ^^^ m)
state_after: case h.h.refine_1
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
hm : ∀ m_1 < m, (nim ↑n + nim ↑m_1).grundyValue = ↑(n ^^^ m_1)
i : (nim ↑n + nim ↑m).LeftMoves
⊢ ((nim ↑n + nim ↑m).moveLeft i).grundyValue ≠ ↑(n ^^^ m)

case h.h.refine_2
n : ℕ
hn : ∀ m < n, ∀ (m_1 : ℕ), (nim ↑m + nim ↑m_1).grundyValue = ↑(m ^^^ m_1)
m : ℕ
hm : ∀ m_1 < m, (nim ↑n + nim ↑m_1).grundyValue = ↑(n ^^^ m_1)
ou : Ordinal.{u}
hu : ou < ↑(n ^^^ m)
⊢ ∃ i, ((nim ↑n + nim ↑m).moveLeft i).grundyValue = ou
tactic: refine (Ordinal.mex_le_of_ne.{u, u} fun i => ?_).antisymm
    (Ordinal.le_mex_of_forall fun ou hu => ?_)
Theorem: affineIndependent_iff_finrank_vectorSpan_eq
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝⁴ : DivisionRing k
inst✝³ : AddCommGroup V
inst✝² : Module k V
inst✝¹ : AffineSpace V P
inst✝ : Fintype ι
p : ι → P
n : ℕ
hc : Fintype.card ι = n + 1
⊢ AffineIndependent k p ↔ finrank k ↥(vectorSpan k (Set.range p)) = n
state_after: no goals
tactic: classical
  have hn : Nonempty ι := by simp [← Fintype.card_pos_iff, hc]
  cases' hn with i₁
  rw [affineIndependent_iff_linearIndependent_vsub _ _ i₁,
    linearIndependent_iff_card_eq_finrank_span, eq_comm,
    vectorSpan_range_eq_span_range_vsub_right_ne k p i₁, Set.finrank]
  rw [← Finset.card_univ] at hc
  rw [Fintype.subtype_card]
  simp [Finset.filter_ne', Finset.card_erase_of_mem, hc]
Theorem: biSup_sup
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
h : ∃ i, p i
⊢ (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
h : ∃ i, p i
this : Nonempty { i // p i }
⊢ (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a
tactic: haveI : Nonempty { i // p i } :=
    let ⟨i, hi⟩ := h
    ⟨⟨i, hi⟩⟩
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
p : ι → Prop
f : (i : ι) → p i → α
a : α
h : ∃ i, p i
this : Nonempty { i // p i }
⊢ (⨆ i, ⨆ (h : p i), f i h) ⊔ a = ⨆ i, ⨆ (h : p i), f i h ⊔ a
state_after: no goals
tactic: rw [iSup_subtype', iSup_subtype', iSup_sup]
Theorem: cfc_nonpos
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁵ : OrderedCommSemiring R
inst✝¹⁴ : StarRing R
inst✝¹³ : StarOrderedRing R
inst✝¹² : MetricSpace R
inst✝¹¹ : TopologicalSemiring R
inst✝¹⁰ : ContinuousStar R
inst✝⁹ : ∀ (α : Type ?u.749705) [inst : TopologicalSpace α], StarOrderedRing C(α, R)
inst✝⁸ : TopologicalSpace A
inst✝⁷ : Ring A
inst✝⁶ : StarRing A
inst✝⁵ : PartialOrder A
inst✝⁴ : StarOrderedRing A
inst✝³ : Algebra R A
inst✝² : StarModule R A
inst✝¹ : ContinuousFunctionalCalculus R p
inst✝ : NonnegSpectrumClass R A
f : R → R
a : A
h : ∀ x ∈ spectrum R a, f x ≤ 0
⊢ cfc f a ≤ 0
state_after: case pos
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁵ : OrderedCommSemiring R
inst✝¹⁴ : StarRing R
inst✝¹³ : StarOrderedRing R
inst✝¹² : MetricSpace R
inst✝¹¹ : TopologicalSemiring R
inst✝¹⁰ : ContinuousStar R
inst✝⁹ : ∀ (α : Type ?u.749705) [inst : TopologicalSpace α], StarOrderedRing C(α, R)
inst✝⁸ : TopologicalSpace A
inst✝⁷ : Ring A
inst✝⁶ : StarRing A
inst✝⁵ : PartialOrder A
inst✝⁴ : StarOrderedRing A
inst✝³ : Algebra R A
inst✝² : StarModule R A
inst✝¹ : ContinuousFunctionalCalculus R p
inst✝ : NonnegSpectrumClass R A
f : R → R
a : A
h : ∀ x ∈ spectrum R a, f x ≤ 0
hf : ContinuousOn f (spectrum R a)
⊢ cfc f a ≤ 0

case neg
R : Type u_1
A : Type u_2
p : A → Prop
inst✝¹⁵ : OrderedCommSemiring R
inst✝¹⁴ : StarRing R
inst✝¹³ : StarOrderedRing R
inst✝¹² : MetricSpace R
inst✝¹¹ : TopologicalSemiring R
inst✝¹⁰ : ContinuousStar R
inst✝⁹ : ∀ (α : Type ?u.749705) [inst : TopologicalSpace α], StarOrderedRing C(α, R)
inst✝⁸ : TopologicalSpace A
inst✝⁷ : Ring A
inst✝⁶ : StarRing A
inst✝⁵ : PartialOrder A
inst✝⁴ : StarOrderedRing A
inst✝³ : Algebra R A
inst✝² : StarModule R A
inst✝¹ : ContinuousFunctionalCalculus R p
inst✝ : NonnegSpectrumClass R A
f : R → R
a : A
h : ∀ x ∈ spectrum R a, f x ≤ 0
hf : ¬ContinuousOn f (spectrum R a)
⊢ cfc f a ≤ 0
tactic: by_cases hf : ContinuousOn f (spectrum R a)
Theorem: CategoryTheory.HasShift.Induced.add_hom_app_obj
File: Mathlib/CategoryTheory/Shift/Induced.lean

Proof steps:
state_before: C : Type u_5
D : Type u_2
inst✝⁵ : Category.{u_4, u_5} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
⊢ (add F s i a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)
state_after: C : Type u_5
D : Type u_2
inst✝⁵ : Category.{u_4, u_5} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
h :
  whiskerLeft F (add F s i a b).hom =
    (i (a + b) ≪≫
        isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
          (shiftFunctor C a).associator (shiftFunctor C b) F ≪≫
            isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
              ((shiftFunctor C a).associator F (s b)).symm ≪≫
                isoWhiskerRight (i a).symm (s b) ≪≫ F.associator (s a) (s b)).hom
⊢ (add F s i a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)
tactic: have h : whiskerLeft F (add F s i a b).hom = _ :=
    ((whiskeringLeft C D D).obj F).map_preimage _
state_before: C : Type u_5
D : Type u_2
inst✝⁵ : Category.{u_4, u_5} C
inst✝⁴ : Category.{u_1, u_2} D
F : C ⥤ D
A : Type u_3
inst✝³ : AddMonoid A
inst✝² : HasShift C A
s : A → D ⥤ D
i : (a : A) → F ⋙ s a ≅ shiftFunctor C a ⋙ F
inst✝¹ : ((whiskeringLeft C D D).obj F).Full
inst✝ : ((whiskeringLeft C D D).obj F).Faithful
a b : A
X : C
h :
  whiskerLeft F (add F s i a b).hom =
    (i (a + b) ≪≫
        isoWhiskerRight (shiftFunctorAdd C a b) F ≪≫
          (shiftFunctor C a).associator (shiftFunctor C b) F ≪≫
            isoWhiskerLeft (shiftFunctor C a) (i b).symm ≪≫
              ((shiftFunctor C a).associator F (s b)).symm ≪≫
                isoWhiskerRight (i a).symm (s b) ≪≫ F.associator (s a) (s b)).hom
⊢ (add F s i a b).hom.app (F.obj X) =
    (i (a + b)).hom.app X ≫
      F.map ((shiftFunctorAdd C a b).hom.app X) ≫ (i b).inv.app ((shiftFunctor C a).obj X) ≫ (s b).map ((i a).inv.app X)
state_after: no goals
tactic: exact (NatTrans.congr_app h X).trans (by simp)
Theorem: List.head?_append
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ s t : List α
x : α
h : x ∈ s.head?
⊢ x ∈ (s ++ t).head?
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ t : List α
x : α
h : x ∈ [].head?
⊢ x ∈ ([] ++ t).head?

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ t : List α
x head✝ : α
tail✝ : List α
h : x ∈ (head✝ :: tail✝).head?
⊢ x ∈ (head✝ :: tail✝ ++ t).head?
tactic: cases s
Theorem: WeierstrassCurve.natDegree_Φ_le
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
n : ℤ
⊢ (W.Φ n).natDegree ≤ n.natAbs ^ 2
state_after: no goals
tactic: induction n using Int.negInduction with
  | nat n => exact (W.natDegree_coeff_Φ_ofNat n).left
  | neg => rwa [Φ_neg, Int.natAbs_neg]
Theorem: compl_sSup
File: Mathlib/Order/CompleteBooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
inst✝ : CompleteBooleanAlgebra α
a b : α
s : Set α
f : ι → α
⊢ (sSup s)ᶜ = ⨅ i ∈ s, iᶜ
state_after: no goals
tactic: simp only [sSup_eq_iSup, compl_iSup]
Theorem: Ideal.sup_pow_eq_top
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
n : ℕ
h : I ⊔ J = ⊤
⊢ I ⊔ J ^ n = ⊤
state_after: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
n : ℕ
h : I ⊔ J = ⊤
⊢ I ⊔ ∏ _x ∈ Finset.range n, J = ⊤
tactic: rw [← Finset.card_range n, ← Finset.prod_const]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
n : ℕ
h : I ⊔ J = ⊤
⊢ I ⊔ ∏ _x ∈ Finset.range n, J = ⊤
state_after: no goals
tactic: exact sup_prod_eq_top fun _ _ => h
Theorem: AffineBasis.toMatrix_row_sum_one
File: Mathlib/LinearAlgebra/AffineSpace/Matrix.lean

Proof steps:
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b : AffineBasis ι k P
ι' : Type u_1
inst✝ : Fintype ι
q : ι' → P
i : ι'
⊢ ∑ j : ι, b.toMatrix q i j = 1
state_after: no goals
tactic: simp
Theorem: Finset.weightedVSub_eq_linear_combination
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι✝ : Type u_4
s✝ : Finset ι✝
ι₂ : Type u_5
s₂ : Finset ι₂
ι : Type u_6
s : Finset ι
w : ι → k
p : ι → V
hw : s.sum w = 0
⊢ (s.weightedVSub p) w = ∑ i ∈ s, w i • p i
state_after: no goals
tactic: simp [s.weightedVSub_apply, vsub_eq_sub, smul_sub, ← Finset.sum_smul, hw]
Theorem: List.exists_of_eraseP
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
b : α
l : List α
a : α
al : a ∈ b :: l
pa : p a = true
pb : p b = true
⊢ b :: l = [] ++ b :: l ∧ eraseP p (b :: l) = [] ++ l
state_after: no goals
tactic: simp [pb]
state_before: α : Type u_1
p : α → Bool
b✝ : α
l : List α
a : α
al✝ : a ∈ b✝ :: l
pa : p a = true
b : α
al : Mem a l
pb : ¬p b = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ b :: l = b :: l₁ ++ c :: l₂
state_after: no goals
tactic: rw [h₃, cons_append]
state_before: α : Type u_1
p : α → Bool
b✝ : α
l : List α
a : α
al✝ : a ∈ b✝ :: l
pa : p a = true
b : α
al : Mem a l
pb : ¬p b = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ eraseP p (b :: l) = b :: l₁ ++ l₂
state_after: no goals
tactic: simp [pb, h₄]
Theorem: Finsupp.single_le_iff
File: Mathlib/Data/Finsupp/Order.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : CanonicallyOrderedAddCommMonoid α
f✝ g : ι →₀ α
i : ι
x : α
f : ι →₀ α
⊢ (∀ i_1 ∈ {i}, (single i x) i_1 ≤ f i_1) ↔ x ≤ f i
state_after: no goals
tactic: simp
Theorem: WType.cardinal_mk_le_max_aleph0_of_finite'
File: Mathlib/Data/W/Cardinal.lean

Proof steps:
state_before: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
⊢ IsEmpty α → #(WType β) ≤ max (lift.{v, u} #α) ℵ₀
state_after: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
h : IsEmpty α
⊢ #(WType β) ≤ max (lift.{v, u} #α) ℵ₀
tactic: intro h
state_before: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
h : IsEmpty α
⊢ #(WType β) ≤ max (lift.{v, u} #α) ℵ₀
state_after: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
h : IsEmpty α
⊢ 0 ≤ max (lift.{v, u} #α) ℵ₀
tactic: rw [Cardinal.mk_eq_zero (WType β)]
state_before: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
h : IsEmpty α
⊢ 0 ≤ max (lift.{v, u} #α) ℵ₀
state_after: no goals
tactic: exact zero_le _
state_before: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
hn : Nonempty α
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
⊢ Order.succ 0 ≤ ⨆ a, m ^ lift.{u, v} #(β a)
state_after: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
hn : Nonempty α
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
⊢ 1 ≤ ⨆ a, m ^ lift.{u, v} #(β a)
tactic: rw [succ_zero]
state_before: α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
hn : Nonempty α
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
⊢ 1 ≤ ⨆ a, m ^ lift.{u, v} #(β a)
state_after: case intro
α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ 1 ≤ ⨆ a, m ^ lift.{u, v} #(β a)
tactic: obtain ⟨a⟩ : Nonempty α := hn
state_before: case intro
α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ 1 ≤ ⨆ a, m ^ lift.{u, v} #(β a)
state_after: case intro
α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ 1 ≤ m ^ lift.{u, v} #(β a)
tactic: refine le_trans ?_ (le_ciSup (bddAbove_range.{_, v} _) a)
state_before: case intro
α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ 1 ≤ m ^ lift.{u, v} #(β a)
state_after: case intro
α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ ?m.3905 ^ 0 ≤ m ^ lift.{u, v} #(β a)

α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ Cardinal.{max u v}
tactic: rw [← power_zero]
state_before: case intro
α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ ?m.3905 ^ 0 ≤ m ^ lift.{u, v} #(β a)

α : Type u
β : α → Type v
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal.{max u v} := max (lift.{v, u} #α) ℵ₀
a : α
⊢ Cardinal.{max u v}
state_after: no goals
tactic: exact
                    power_le_power_left
                      (pos_iff_ne_zero.1 (aleph0_pos.trans_le (le_max_right _ _))) (zero_le _)
Theorem: Succ.rec
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : α
hmn : m ≤ n
⊢ P n
state_after: case intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
hmn : m ≤ succ^[n] m
⊢ P (succ^[n] m)
tactic: obtain ⟨n, rfl⟩ := hmn.exists_succ_iterate
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
hmn : m ≤ succ^[n] m
⊢ P (succ^[n] m)
state_after: case intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
⊢ P (succ^[n] m)
tactic: clear hmn
state_before: case intro
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
⊢ P (succ^[n] m)
state_after: case intro.zero
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
⊢ P (succ^[0] m)

case intro.succ
α : Type u_1
β : Type u_2
inst✝² : Preorder α
inst✝¹ : SuccOrder α
inst✝ : IsSuccArchimedean α
a b : α
P : α → Prop
m : α
h0 : P m
h1 : ∀ (n : α), m ≤ n → P n → P (succ n)
n : ℕ
ih : P (succ^[n] m)
⊢ P (succ^[n + 1] m)
tactic: induction' n with n ih
Theorem: ENat.nat_induction
File: Mathlib/Data/ENat/Basic.lean

Proof steps:
state_before: m n : ℕ∞
P : ℕ∞ → Prop
a : ℕ∞
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑n.succ
htop : (∀ (n : ℕ), P ↑n) → P ⊤
⊢ P a
state_after: m n : ℕ∞
P : ℕ∞ → Prop
a : ℕ∞
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑n.succ
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
⊢ P a
tactic: have A : ∀ n : ℕ, P n := fun n => Nat.recOn n h0 hsuc
state_before: m n : ℕ∞
P : ℕ∞ → Prop
a : ℕ∞
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑n.succ
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
⊢ P a
state_after: case top
m n : ℕ∞
P : ℕ∞ → Prop
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑n.succ
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
⊢ P ⊤

case coe
m n : ℕ∞
P : ℕ∞ → Prop
h0 : P 0
hsuc : ∀ (n : ℕ), P ↑n → P ↑n.succ
htop : (∀ (n : ℕ), P ↑n) → P ⊤
A : ∀ (n : ℕ), P ↑n
a✝ : ℕ
⊢ P ↑a✝
tactic: cases a
Theorem: zpowers_eq_top_of_prime_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
p : ℕ
hp : Fact (Nat.Prime p)
h : Fintype.card G = p
g : G
hg : g ≠ 1
⊢ zpowers g = ⊤
state_after: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
⊢ zpowers g = ⊤
tactic: subst h
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
⊢ zpowers g = ⊤
state_after: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
this : zpowers g = ⊥ ∨ zpowers g = ⊤
⊢ zpowers g = ⊤
tactic: have := (zpowers g).eq_bot_or_eq_top_of_prime_card
state_before: α : Type u
a : α
inst✝¹ : Group α
G : Type u_1
inst✝ : Group G
x✝ : Fintype G
g : G
hg : g ≠ 1
hp : Fact (Nat.Prime (Fintype.card G))
this : zpowers g = ⊥ ∨ zpowers g = ⊤
⊢ zpowers g = ⊤
state_after: no goals
tactic: rwa [zpowers_eq_bot, or_iff_right hg] at this
Theorem: HNNExtension.equiv_symm_eq_conj
File: Mathlib/GroupTheory/HNNExtension.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑(φ.symm b) = t⁻¹ * of ↑b * t
state_after: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑(φ.symm b) = t⁻¹ * (t * of ↑(φ.symm b))
tactic: rw [mul_assoc, of_mul_t]
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
b : ↥B
⊢ of ↑(φ.symm b) = t⁻¹ * (t * of ↑(φ.symm b))
state_after: no goals
tactic: simp
Theorem: Ordinal.le_div
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b c : Ordinal.{u_4}
c0 : c ≠ 0
⊢ a ≤ b / c ↔ c * a ≤ b
state_after: no goals
tactic: induction a using limitRecOn with
  | H₁ => simp only [mul_zero, Ordinal.zero_le]
  | H₂ _ _ => rw [succ_le_iff, lt_div c0]
  | H₃ _ h₁ h₂ =>
    revert h₁ h₂
    simp (config := { contextual := true }) only [mul_le_of_limit, limit_le, iff_self_iff,
      forall_true_iff]
Theorem: ENNReal.inv_zero
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ sInf {b | 1 ≤ 0 * b} = ⊤
state_after: no goals
tactic: simp
Theorem: Order.Frame.MinimalAxioms.inf_iSup_eq
File: Mathlib/Order/CompleteBooleanAlgebra.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
κ : ι → Sort w'
minAx : MinimalAxioms α
s : Set α
a✝ b a : α
f : ι → α
⊢ a ⊓ ⨆ i, f i = ⨆ i, a ⊓ f i
state_after: no goals
tactic: simpa only [inf_comm] using minAx.iSup_inf_eq f a
Theorem: Real.cos_add
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℝ
⊢ ↑(cos (x + y)) = ↑(cos x * cos y - sin x * sin y)
state_after: no goals
tactic: simp [cos_add]
Theorem: Pi.apply_mulSingle
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i✝ : I
inst✝³ : DecidableEq I
inst✝² : (i : I) → One (f i)
inst✝¹ : (i : I) → One (g i)
inst✝ : (i : I) → One (h i)
f' : (i : I) → f i → g i
hf' : ∀ (i : I), f' i 1 = 1
i : I
x : f i
j : I
⊢ f' j (mulSingle i x j) = mulSingle i (f' i x) j
state_after: no goals
tactic: simpa only [Pi.one_apply, hf', mulSingle] using Function.apply_update f' 1 i x j
Theorem: Matrix.conjTranspose_smul_non_comm
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Star R
inst✝² : Star α
inst✝¹ : SMul R α
inst✝ : SMul Rᵐᵒᵖ α
c : R
M : Matrix m n α
h : ∀ (r : R) (a : α), star (r • a) = MulOpposite.op (star r) • star a
⊢ ∀ (i : n) (j : m), (c • M)ᴴ i j = (MulOpposite.op (star c) • Mᴴ) i j
state_after: no goals
tactic: simp [h]