ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.lintegral_iInf_ae
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
n : ℕ
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
⊢ f n a ≤ f 0 a
state_after: case zero
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
⊢ f 0 a ≤ f 0 a

case succ
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : ℕ → α → ℝ≥0∞
h_meas : ∀ (n : ℕ), Measurable (f n)
h_mono✝ : ∀ (n : ℕ), f n.succ ≤ᶠ[ae μ] f n
h_fin : ∫⁻ (a : α), f 0 a ∂μ ≠ ⊤
fn_le_f0 : ∫⁻ (a : α), ⨅ n, f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
fn_le_f0' : ⨅ n, ∫⁻ (a : α), f n a ∂μ ≤ ∫⁻ (a : α), f 0 a ∂μ
h_mono : ∀ᵐ (a : α) ∂μ, ∀ (n : ℕ), f n.succ a ≤ f n a
a : α
h : ∀ (n : ℕ), f n.succ a ≤ f n a
n : ℕ
ih : f n a ≤ f 0 a
⊢ f (n + 1) a ≤ f 0 a
tactic: induction' n with n ih
Theorem: List.headI_add_tail_sum_of_ne_nil
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l✝ l₁ l₂ : List M
a : M
inst✝ : Inhabited M
l : List M
h : l ≠ []
⊢ l.headI * l.tail.prod = l.prod
state_after: no goals
tactic: cases l <;> [contradiction; simp]
Theorem: List.Perm.bagInter_right
File: Mathlib/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ t : List α
h : l₁ ~ l₂
⊢ l₁.bagInter t ~ l₂.bagInter t
state_after: case nil
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ t : List α
⊢ [].bagInter t ~ [].bagInter t

case cons
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ : List α
x : α
l₁✝ l₂✝ : List α
a✝ : l₁✝ ~ l₂✝
a_ih✝ : ∀ (t : List α), l₁✝.bagInter t ~ l₂✝.bagInter t
t : List α
⊢ (x :: l₁✝).bagInter t ~ (x :: l₂✝).bagInter t

case swap
α : Type u_1
β : Type u_2
l l₁✝ l₂✝ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ : List α
x y : α
l✝ t : List α
⊢ (y :: x :: l✝).bagInter t ~ (x :: y :: l✝).bagInter t

case trans
α : Type u_1
β : Type u_2
l l₁✝¹ l₂✝¹ : List α
a : α
inst✝ : DecidableEq α
l₁ l₂ l₁✝ l₂✝ l₃✝ : List α
a✝¹ : l₁✝ ~ l₂✝
a✝ : l₂✝ ~ l₃✝
ih_1 : ∀ (t : List α), l₁✝.bagInter t ~ l₂✝.bagInter t
ih_2 : ∀ (t : List α), l₂✝.bagInter t ~ l₃✝.bagInter t
t : List α
⊢ l₁✝.bagInter t ~ l₃✝.bagInter t
tactic: induction' h with x _ _ _ _ x y _ _ _ _ _ _ ih_1 ih_2 generalizing t
Theorem: TypeVec.dropFun_of_subtype
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
⊢ dropFun (ofSubtype p) = ofSubtype (dropFun p)
state_after: case a.h
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
i : Fin2 n
x✝ : (Subtype_ p).drop i
⊢ dropFun (ofSubtype p) i x✝ = ofSubtype (dropFun p) i x✝
tactic: ext i : 2
state_before: case a.h
n : ℕ
α : TypeVec.{u_1} (n + 1)
p : α ⟹ repeat (n + 1) Prop
i : Fin2 n
x✝ : (Subtype_ p).drop i
⊢ dropFun (ofSubtype p) i x✝ = ofSubtype (dropFun p) i x✝
state_after: no goals
tactic: induction i <;> simp [dropFun, *] <;> rfl
Theorem: Polynomial.natDegree_prod'
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
h : ∏ i ∈ s, (f i).leadingCoeff ≠ 0
⊢ (∏ i ∈ s, f i).natDegree = ∑ i ∈ s, (f i).natDegree
state_after: no goals
tactic: simpa using natDegree_multiset_prod' (s.1.map f) (by simpa using h)
Theorem: Set.mem_ordConnectedComponent_comm
File: Mathlib/Order/Interval/Set/OrdConnectedComponent.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x y z : α
⊢ y ∈ s.ordConnectedComponent x ↔ x ∈ s.ordConnectedComponent y
state_after: no goals
tactic: rw [mem_ordConnectedComponent, mem_ordConnectedComponent, uIcc_comm]
Theorem: CategoryTheory.tensorLeftHomEquiv_tensor
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X X' Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⟶ Y ⊗ Z
g : X' ⟶ Z'
⊢ (tensorLeftHomEquiv (X ⊗ X') Y Y' (Z ⊗ Z')).symm ((f ⊗ g) ≫ (α_ Y Z Z').hom) =
    (α_ Y' X X').inv ≫ ((tensorLeftHomEquiv X Y Y' Z).symm f ⊗ g)
state_after: no goals
tactic: simp [tensorLeftHomEquiv, tensorHom_def']
Theorem: ONote.NF.of_dvd_omega
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: e : ONote
n : ℕ+
a : ONote
h : (e.oadd n a).NF
⊢ ω ∣ (e.oadd n a).repr → e.repr ≠ 0 ∧ ω ∣ a.repr
state_after: no goals
tactic: (rw [← opow_one ω, ← one_le_iff_ne_zero]; exact h.of_dvd_omega_opow)
Theorem: AlgebraicGeometry.IsLocalAtSource.of_iSup_eq_top
File: Mathlib/AlgebraicGeometry/Morphisms/Basic.lean

Proof steps:
state_before: P : MorphismProperty Scheme
inst✝¹ : IsLocalAtSource P
X Y U✝ V : Scheme
f : X ⟶ Y
g : U✝ ⟶ Y
inst✝ : IsOpenImmersion g
𝒰 : X.OpenCover
ι : Sort u_1
U : ι → X.Opens
hU : iSup U = ⊤
H : ∀ (i : ι), P ((U i).ι ≫ f)
⊢ P f
state_after: P : MorphismProperty Scheme
inst✝¹ : IsLocalAtSource P
X Y U✝ V : Scheme
f : X ⟶ Y
g : U✝ ⟶ Y
inst✝ : IsOpenImmersion g
𝒰 : X.OpenCover
ι : Sort u_1
U : ι → X.Opens
hU : iSup U = ⊤
H : ∀ (i : ι), P ((U i).ι ≫ f)
i : (X.openCoverOfISupEqTop Subtype.val ⋯).J
⊢ P ((X.openCoverOfISupEqTop Subtype.val ⋯).map i ≫ f)
tactic: refine (iff_of_openCover' f
    (X.openCoverOfISupEqTop (s := Set.range U) Subtype.val (by ext; simp [← hU]))).mpr fun i ↦ ?_
state_before: P : MorphismProperty Scheme
inst✝¹ : IsLocalAtSource P
X Y U✝ V : Scheme
f : X ⟶ Y
g : U✝ ⟶ Y
inst✝ : IsOpenImmersion g
𝒰 : X.OpenCover
ι : Sort u_1
U : ι → X.Opens
hU : iSup U = ⊤
H : ∀ (i : ι), P ((U i).ι ≫ f)
i : (X.openCoverOfISupEqTop Subtype.val ⋯).J
⊢ P ((X.openCoverOfISupEqTop Subtype.val ⋯).map i ≫ f)
state_after: case mk.intro
P : MorphismProperty Scheme
inst✝¹ : IsLocalAtSource P
X Y U✝ V : Scheme
f : X ⟶ Y
g : U✝ ⟶ Y
inst✝ : IsOpenImmersion g
𝒰 : X.OpenCover
ι : Sort u_1
U : ι → X.Opens
hU : iSup U = ⊤
H : ∀ (i : ι), P ((U i).ι ≫ f)
i : ι
⊢ P ((X.openCoverOfISupEqTop Subtype.val ⋯).map ⟨U i, ⋯⟩ ≫ f)
tactic: obtain ⟨_, i, rfl⟩ := i
state_before: case mk.intro
P : MorphismProperty Scheme
inst✝¹ : IsLocalAtSource P
X Y U✝ V : Scheme
f : X ⟶ Y
g : U✝ ⟶ Y
inst✝ : IsOpenImmersion g
𝒰 : X.OpenCover
ι : Sort u_1
U : ι → X.Opens
hU : iSup U = ⊤
H : ∀ (i : ι), P ((U i).ι ≫ f)
i : ι
⊢ P ((X.openCoverOfISupEqTop Subtype.val ⋯).map ⟨U i, ⋯⟩ ≫ f)
state_after: no goals
tactic: exact H i
Theorem: hyperoperation_ge_four_zero
File: Mathlib/Data/Nat/Hyperoperation.lean

Proof steps:
state_before: n k : ℕ
⊢ hyperoperation (n + 4) 0 k = if Even k then 1 else 0
state_after: case zero
n : ℕ
⊢ hyperoperation (n + 4) 0 0 = if Even 0 then 1 else 0

case succ
n kk : ℕ
kih : hyperoperation (n + 4) 0 kk = if Even kk then 1 else 0
⊢ hyperoperation (n + 4) 0 (kk + 1) = if Even (kk + 1) then 1 else 0
tactic: induction' k with kk kih
Theorem: SimpleGraph.Subgraph.IsMatching.even_card
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

Proof steps:
state_before: V : Type u_1
G G' : SimpleGraph V
M M' : G.Subgraph
v w : V
inst✝ : Fintype ↑M.verts
h : M.IsMatching
⊢ Even M.verts.toFinset.card
state_after: no goals
tactic: classical
  rw [isMatching_iff_forall_degree] at h
  use M.coe.edgeFinset.card
  rw [← two_mul, ← M.coe.sum_degrees_eq_twice_card_edges]
  -- Porting note: `SimpleGraph.Subgraph.coe_degree` does not trigger because it uses
  -- instance arguments instead of implicit arguments for the first `Fintype` argument.
  -- Using a `convert_to` to swap out the `Fintype` instance to the "right" one.
  convert_to _ = Finset.sum Finset.univ fun v => SimpleGraph.degree (Subgraph.coe M) v using 3
  simp [h, Finset.card_univ]
Theorem: Order.le_succ_iterate
File: Mathlib/Order/SuccPred/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
k : ℕ
x : α
⊢ x ≤ succ^[k] x
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
k : ℕ
x : α
⊢ id^[k] x ≤ succ^[k] x
tactic: conv_lhs => rw [(by simp only [Function.iterate_id, id] : x = id^[k] x)]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
k : ℕ
x : α
⊢ id^[k] x ≤ succ^[k] x
state_after: no goals
tactic: exact Monotone.le_iterate_of_le succ_mono le_succ k x
Theorem: SetTheory.PGame.lt_or_equiv_or_gt_or_fuzzy
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl xr : Type u
x y : PGame
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
state_after: case inl.inl
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

case inl.inr
xl xr : Type u
x y : PGame
h₁ : x ≤ y
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

case inr.inl
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : y ≤ x
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y

case inr.inr
xl xr : Type u
x y : PGame
h₁ : y ⧏ x
h₂ : x ⧏ y
⊢ x < y ∨ x ≈ y ∨ y < x ∨ x ‖ y
tactic: cases' le_or_gf x y with h₁ h₁ <;> cases' le_or_gf y x with h₂ h₂
Theorem: LieAlgebra.toEnd_pow_apply_mem
File: Mathlib/Algebra/Lie/Weights/Cartan.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : ↥H → R
x : L
m : M
hx : x ∈ rootSpace H χ₁
hm : m ∈ weightSpace M χ₂
n : ℕ
⊢ ((toEnd R L M) x ^ n) m ∈ weightSpace M (n • χ₁ + χ₂)
state_after: no goals
tactic: induction n with
  | zero => simpa using hm
  | succ n IH =>
    simp only [pow_succ', LinearMap.mul_apply, toEnd_apply_apply,
      Nat.cast_add, Nat.cast_one, rootSpace]
    convert lie_mem_weightSpace_of_mem_weightSpace hx IH using 2
    rw [succ_nsmul, ← add_assoc, add_comm (n • _)]
Theorem: ZMod.val_add_of_lt
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
a b : ZMod n
h : a.val + b.val < n
⊢ (a + b).val = a.val + b.val
state_after: m n✝ n : ℕ
a b : ZMod n
h : a.val + b.val < n
this : NeZero n
⊢ (a + b).val = a.val + b.val
tactic: have : NeZero n := by constructor; rintro rfl; simp at h
state_before: m n✝ n : ℕ
a b : ZMod n
h : a.val + b.val < n
this : NeZero n
⊢ (a + b).val = a.val + b.val
state_after: no goals
tactic: rw [ZMod.val_add, Nat.mod_eq_of_lt h]
Theorem: Ring.smeval_ascPochhammer_neg_add
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n : ℕ
⊢ (ascPochhammer ℕ (n + 0 + 1)).smeval (-↑n) = 0
state_after: no goals
tactic: rw [add_zero, smeval_ascPochhammer_succ_neg]
state_before: R : Type u_1
inst✝² : NonAssocRing R
inst✝¹ : Pow R ℕ
inst✝ : BinomialRing R
n k : ℕ
⊢ (ascPochhammer ℕ (n + (k + 1) + 1)).smeval (-↑n) = 0
state_after: no goals
tactic: rw [ascPochhammer_succ_right, smeval_mul, ← add_assoc, smeval_ascPochhammer_neg_add n k,
      zero_mul]
Theorem: Set.ite_right
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s.ite t s = t ∩ s
state_after: no goals
tactic: simp [Set.ite]
Theorem: Filter.HasBasis.eq_of_same_basis
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p s
⊢ l = l'
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p s
t : Set α
⊢ t ∈ l ↔ t ∈ l'
tactic: ext t
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t✝ : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
hl : l.HasBasis p s
hl' : l'.HasBasis p s
t : Set α
⊢ t ∈ l ↔ t ∈ l'
state_after: no goals
tactic: rw [hl.mem_iff, hl'.mem_iff]
Theorem: IntermediateField.exists_finset_of_mem_iSup
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : F⟮x⟯ ≤ ⨆ i, f i → ∃ s, F⟮x⟯ ≤ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
tactic: have := (adjoin_simple_isCompactElement x).exists_finset_of_le_iSup (IntermediateField F E) f
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : F⟮x⟯ ≤ ⨆ i, f i → ∃ s, F⟮x⟯ ≤ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : x ∈ ⨆ i, f i → ∃ s, x ∈ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
tactic: simp only [adjoin_simple_le_iff] at this
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S : Set E
α : E
ι : Type u_3
f : ι → IntermediateField F E
x : E
hx : x ∈ ⨆ i, f i
this : x ∈ ⨆ i, f i → ∃ s, x ∈ ⨆ i ∈ s, f i
⊢ ∃ s, x ∈ ⨆ i ∈ s, f i
state_after: no goals
tactic: exact this hx
Theorem: Set.projIcc_val
File: Mathlib/Order/Interval/Set/ProjIcc.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x✝ : α
x : ↑(Icc a b)
⊢ projIcc a b h ↑x = x
state_after: case mk
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x val✝ : α
property✝ : val✝ ∈ Icc a b
⊢ projIcc a b h ↑⟨val✝, property✝⟩ = ⟨val✝, property✝⟩
tactic: cases x
state_before: case mk
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a b : α
h : a ≤ b
x val✝ : α
property✝ : val✝ ∈ Icc a b
⊢ projIcc a b h ↑⟨val✝, property✝⟩ = ⟨val✝, property✝⟩
state_after: no goals
tactic: apply projIcc_of_mem
Theorem: CategoryTheory.Subobject.factors_left_of_factors_add
File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

Proof steps:
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) ≫ (representative.obj P).arrow = f
state_after: no goals
tactic: simp
Theorem: Fin.castAdd_inj
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a b : Fin m
⊢ castAdd n a = castAdd n b ↔ a = b
state_after: no goals
tactic: simp [Fin.ext_iff]
Theorem: SimpleGraph.Walk.cons_copy
File: Mathlib/Combinatorics/SimpleGraph/Walk.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v w v' w' : V
h : G.Adj u v
p : G.Walk v' w'
hv : v' = v
hw : w' = w
⊢ cons h (p.copy hv hw) = (cons ⋯ p).copy ⋯ hw
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v' w' : V
p : G.Walk v' w'
h : G.Adj u v'
⊢ cons h (p.copy ⋯ ⋯) = (cons ⋯ p).copy ⋯ ⋯
tactic: subst_vars
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v' w' : V
p : G.Walk v' w'
h : G.Adj u v'
⊢ cons h (p.copy ⋯ ⋯) = (cons ⋯ p).copy ⋯ ⋯
state_after: no goals
tactic: rfl
Theorem: Pi.card_Ioc
File: Mathlib/Data/Pi/Interval.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝⁴ : Fintype ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → DecidableEq (α i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : (i : ι) → LocallyFiniteOrder (α i)
a b : (i : ι) → α i
⊢ (Ioc a b).card = ∏ i : ι, (Icc (a i) (b i)).card - 1
state_after: no goals
tactic: rw [card_Ioc_eq_card_Icc_sub_one, card_Icc]
Theorem: Multiset.mem_nsmul_of_ne_zero
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
a : α
s : Multiset α
n : ℕ
h0 : n ≠ 0
⊢ a ∈ n • s ↔ a ∈ s
state_after: no goals
tactic: simp [*]
Theorem: Algebra.IsSeparable.of_algHom
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: F : Type u_1
K : Type u_2
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_4
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : Algebra.IsSeparable F E'
⊢ Algebra.IsSeparable F E
state_after: F : Type u_1
K : Type u_2
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_4
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : Algebra.IsSeparable F E'
this : Algebra E E' := f.toAlgebra
⊢ Algebra.IsSeparable F E
tactic: letI : Algebra E E' := RingHom.toAlgebra f.toRingHom
state_before: F : Type u_1
K : Type u_2
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_4
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : Algebra.IsSeparable F E'
this : Algebra E E' := f.toAlgebra
⊢ Algebra.IsSeparable F E
state_after: F : Type u_1
K : Type u_2
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_4
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : Algebra.IsSeparable F E'
this✝ : Algebra E E' := f.toAlgebra
this : IsScalarTower F E E'
⊢ Algebra.IsSeparable F E
tactic: haveI : IsScalarTower F E E' := IsScalarTower.of_algebraMap_eq fun x => (f.commutes x).symm
state_before: F : Type u_1
K : Type u_2
E : Type u_3
inst✝⁹ : Field F
inst✝⁸ : Field K
inst✝⁷ : Field E
inst✝⁶ : Algebra F K
inst✝⁵ : Algebra F E
inst✝⁴ : Algebra K E
inst✝³ : IsScalarTower F K E
E' : Type u_4
inst✝² : Field E'
inst✝¹ : Algebra F E'
f : E →ₐ[F] E'
inst✝ : Algebra.IsSeparable F E'
this✝ : Algebra E E' := f.toAlgebra
this : IsScalarTower F E E'
⊢ Algebra.IsSeparable F E
state_after: no goals
tactic: exact Algebra.isSeparable_tower_bot_of_isSeparable F E E'
Theorem: himp_triangle
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ (a ⇨ b) ⊓ (b ⇨ c) ≤ a ⇨ c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ (a ⇨ b) ⊓ a ≤ (b ⇨ c) ⇨ c
tactic: rw [le_himp_iff, inf_right_comm, ← le_himp_iff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : GeneralizedHeytingAlgebra α
a✝ b✝ c✝ d a b c : α
⊢ (a ⇨ b) ⊓ a ≤ (b ⇨ c) ⇨ c
state_after: no goals
tactic: exact himp_inf_le.trans le_himp_himp
Theorem: Matrix.isNilpotent_trace_of_isNilpotent
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
⊢ IsNilpotent M.trace
state_after: case inl
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : IsEmpty n
⊢ IsNilpotent M.trace

case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent M.trace
tactic: cases isEmpty_or_nonempty n
state_before: case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent M.trace
state_after: case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent (M.charpolyRev.coeff 1)
tactic: suffices IsNilpotent (coeff (charpolyRev M) 1) by simpa using this
state_before: case inr
R : Type u
inst✝⁴ : CommRing R
n G : Type v
inst✝³ : DecidableEq n
inst✝² : Fintype n
α β : Type v
inst✝¹ : DecidableEq α
M : Matrix n n R
p : ℕ
inst✝ : Fact (Nat.Prime p)
hM : IsNilpotent M
h✝ : Nonempty n
⊢ IsNilpotent (M.charpolyRev.coeff 1)
state_after: no goals
tactic: exact (isUnit_iff_coeff_isUnit_isNilpotent.mp (isUnit_charpolyRev_of_isNilpotent hM)).2
    _ one_ne_zero
Theorem: MvPolynomial.IsWeightedHomogeneous.inj_right
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
w : σ → M
hφ : φ ≠ 0
hm : IsWeightedHomogeneous w φ m
hn : IsWeightedHomogeneous w φ n
⊢ m = n
state_after: case intro
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
w : σ → M
hφ : φ ≠ 0
hm : IsWeightedHomogeneous w φ m
hn : IsWeightedHomogeneous w φ n
d : σ →₀ ℕ
hd : coeff d φ ≠ 0
⊢ m = n
tactic: obtain ⟨d, hd⟩ : ∃ d, coeff d φ ≠ 0 := exists_coeff_ne_zero hφ
state_before: case intro
R : Type u_1
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_3
inst✝ : AddCommMonoid M
φ ψ : MvPolynomial σ R
m n : M
w : σ → M
hφ : φ ≠ 0
hm : IsWeightedHomogeneous w φ m
hn : IsWeightedHomogeneous w φ n
d : σ →₀ ℕ
hd : coeff d φ ≠ 0
⊢ m = n
state_after: no goals
tactic: rw [← hm hd, ← hn hd]
Theorem: IsCompact.add
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact (s * t)
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact ((fun x => x.1 * x.2) '' s ×ˢ t)
tactic: rw [← image_mul_prod]
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace M
inst✝¹ : Monoid M
inst✝ : ContinuousMul M
s t : Set M
hs : IsCompact s
ht : IsCompact t
⊢ IsCompact ((fun x => x.1 * x.2) '' s ×ˢ t)
state_after: no goals
tactic: exact (hs.prod ht).image continuous_mul