ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.le_sup_iff
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
a : α
ha : ⊥ < a
⊢ a ≤ s.sup f ↔ ∃ b ∈ s, a ≤ f b
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
a : α
ha : ⊥ < a
⊢ a ≤ s.sup f → ∃ b ∈ s, a ≤ f b

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : LinearOrder α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
a : α
ha : ⊥ < a
⊢ (∃ b ∈ s, a ≤ f b) → a ≤ s.sup f
tactic: apply Iff.intro
Theorem: MeasureTheory.Measure.restrict_eq_zero
File: Mathlib/MeasureTheory/Measure/Restrict.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
⊢ μ.restrict s = 0 ↔ μ s = 0
state_after: no goals
tactic: rw [← measure_univ_eq_zero, restrict_apply_univ]
Theorem: CompleteLat.Iso.mk_inv_toFun
File: Mathlib/Order/Category/CompleteLat.lean

Proof steps:
state_before: α β : CompleteLat
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ } ≫ { toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ } = 𝟙 α
state_after: case w
α β : CompleteLat
e : ↑α ≃o ↑β
x✝ : (forget CompleteLat).obj α
⊢ ({ toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ } ≫ { toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ }) x✝ = (𝟙 α) x✝
tactic: ext
state_before: case w
α β : CompleteLat
e : ↑α ≃o ↑β
x✝ : (forget CompleteLat).obj α
⊢ ({ toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ } ≫ { toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ }) x✝ = (𝟙 α) x✝
state_after: no goals
tactic: exact e.symm_apply_apply _
state_before: α β : CompleteLat
e : ↑α ≃o ↑β
⊢ { toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ } ≫ { toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ } = 𝟙 β
state_after: case w
α β : CompleteLat
e : ↑α ≃o ↑β
x✝ : (forget CompleteLat).obj β
⊢ ({ toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ } ≫ { toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ }) x✝ = (𝟙 β) x✝
tactic: ext
state_before: case w
α β : CompleteLat
e : ↑α ≃o ↑β
x✝ : (forget CompleteLat).obj β
⊢ ({ toFun := ⇑e.symm, map_sInf' := ⋯, map_sSup' := ⋯ } ≫ { toFun := ⇑e, map_sInf' := ⋯, map_sSup' := ⋯ }) x✝ = (𝟙 β) x✝
state_after: no goals
tactic: exact e.apply_symm_apply _
Theorem: Nat.count_add'
File: Mathlib/Data/Nat/Count.lean

Proof steps:
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ count p (a + b) = count (fun k => p (k + b)) a + count p b
state_after: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ count (fun k => p (b + k)) a + count p b = count (fun k => p (k + b)) a + count p b
tactic: rw [add_comm, count_add, add_comm]
state_before: p : ℕ → Prop
inst✝ : DecidablePred p
a b : ℕ
⊢ count (fun k => p (b + k)) a + count p b = count (fun k => p (k + b)) a + count p b
state_after: no goals
tactic: simp_rw [add_comm b]
Theorem: MeasureTheory.setToFun_congr_left'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → T s = T' s
f : α → E
⊢ setToFun μ T hT f = setToFun μ T' hT' f
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → T s = T' s
f : α → E
hf : Integrable f μ
⊢ setToFun μ T hT f = setToFun μ T' hT' f

case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
h : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → T s = T' s
f : α → E
hf : ¬Integrable f μ
⊢ setToFun μ T hT f = setToFun μ T' hT' f
tactic: by_cases hf : Integrable f μ
Theorem: DilationEquiv.map_cobounded
File: Mathlib/Topology/MetricSpace/DilationEquiv.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
F : Type u_3
inst✝³ : PseudoMetricSpace X
inst✝² : PseudoMetricSpace Y
inst✝¹ : EquivLike F X Y
inst✝ : DilationEquivClass F X Y
e : F
⊢ map (⇑e) (cobounded X) = cobounded Y
state_after: no goals
tactic: rw [← Dilation.comap_cobounded e, map_comap_of_surjective (EquivLike.surjective e)]
Theorem: Multiset.sections_add
File: Mathlib/Data/Multiset/Sections.lean

Proof steps:
state_before: α : Type u_1
s t : Multiset (Multiset α)
⊢ (0 + t).Sections = (Sections 0).bind fun m => map (fun x => m + x) t.Sections
state_after: no goals
tactic: simp
state_before: α : Type u_1
s✝ t : Multiset (Multiset α)
a : Multiset α
s : Multiset (Multiset α)
ih : (s + t).Sections = s.Sections.bind fun m => map (fun x => m + x) t.Sections
⊢ (a ::ₘ s + t).Sections = (a ::ₘ s).Sections.bind fun m => map (fun x => m + x) t.Sections
state_after: no goals
tactic: simp [ih, bind_assoc, map_bind, bind_map]
Theorem: CategoryTheory.Abelian.Ext.neg_comp
File: Mathlib/Algebra/Homology/DerivedCategory/Ext.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n : ℕ
α : Ext X Y n
m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
⊢ (-α).comp β h = -α.comp β h
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n : ℕ
α : Ext X Y n
m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ (-α).comp β h = -α.comp β h
tactic: letI := HasDerivedCategory.standard C
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n : ℕ
α : Ext X Y n
m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ (-α).comp β h = -α.comp β h
state_after: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n : ℕ
α : Ext X Y n
m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ ((-α).comp β h).hom = (-α.comp β h).hom
tactic: ext
state_before: case h
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Abelian C
inst✝ : HasExt C
X Y Z T : C
n : ℕ
α : Ext X Y n
m : ℕ
β : Ext Y Z m
p : ℕ
h : n + m = p
this : HasDerivedCategory C := HasDerivedCategory.standard C
⊢ ((-α).comp β h).hom = (-α.comp β h).hom
state_after: no goals
tactic: simp [neg_hom']
Theorem: CategoryTheory.MonoidalCategory.rightUnitor_tensor
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
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)).hom = (α_ X Y (𝟙_ C)).hom ≫ X ◁ (ρ_ Y).hom
state_after: no goals
tactic: simp
Theorem: AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq_zero
File: Mathlib/AlgebraicTopology/DoldKan/Faces.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
hqn : n < q
⊢ φ ≫ (Hσ q).f (n + 1) = 0
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
hqn : n < q
⊢ φ ≫
      ((AlternatingFaceMapComplex.obj X).d (n + 1) n ≫ hσ' q n (n + 1) ⋯ +
        hσ' q (n + 1) (n + 2) ⋯ ≫ (AlternatingFaceMapComplex.obj X).d (n + 2) (n + 1)) =
    0
tactic: simp only [Hσ, Homotopy.nullHomotopicMap'_f (c_mk (n + 2) (n + 1) rfl) (c_mk (n + 1) n rfl)]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
hqn : n < q
⊢ φ ≫
      ((AlternatingFaceMapComplex.obj X).d (n + 1) n ≫ hσ' q n (n + 1) ⋯ +
        hσ' q (n + 1) (n + 2) ⋯ ≫ (AlternatingFaceMapComplex.obj X).d (n + 2) (n + 1)) =
    0
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
hqn : n < q
⊢ φ ≫ hσ' q (n + 1) (n + 2) ⋯ ≫ (AlternatingFaceMapComplex.obj X).d (n + 2) (n + 1) = 0
tactic: rw [hσ'_eq_zero hqn (c_mk (n + 1) n rfl), comp_zero, zero_add]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
hqn : n < q
⊢ φ ≫ hσ' q (n + 1) (n + 2) ⋯ ≫ (AlternatingFaceMapComplex.obj X).d (n + 2) (n + 1) = 0
state_after: case pos
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
hqn : n < q
hqn' : n + 1 < q
⊢ φ ≫ hσ' q (n + 1) (n + 2) ⋯ ≫ (AlternatingFaceMapComplex.obj X).d (n + 2) (n + 1) = 0

case neg
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X _[n + 1]
v : HigherFacesVanish q φ
hqn : n < q
hqn' : ¬n + 1 < q
⊢ φ ≫ hσ' q (n + 1) (n + 2) ⋯ ≫ (AlternatingFaceMapComplex.obj X).d (n + 2) (n + 1) = 0
tactic: by_cases hqn' : n + 1 < q
Theorem: cmp_swap
File: Mathlib/Order/Compare.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a b : α
⊢ (cmp a b).swap = cmp b a
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a b : α
⊢ (if (fun x x_1 => x < x_1) a b then lt else if (fun x x_1 => x < x_1) b a then gt else eq).swap =
    if (fun x x_1 => x < x_1) b a then lt else if (fun x x_1 => x < x_1) a b then gt else eq
tactic: unfold cmp cmpUsing
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a b : α
⊢ (if (fun x x_1 => x < x_1) a b then lt else if (fun x x_1 => x < x_1) b a then gt else eq).swap =
    if (fun x x_1 => x < x_1) b a then lt else if (fun x x_1 => x < x_1) a b then gt else eq
state_after: case pos
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a b : α
h : a < b
h₂ : b < a
⊢ False
tactic: by_cases h : a < b <;> by_cases h₂ : b < a <;> simp [h, h₂, Ordering.swap]
state_before: case pos
α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : DecidableRel fun x x_1 => x < x_1
a b : α
h : a < b
h₂ : b < a
⊢ False
state_after: no goals
tactic: exact lt_asymm h h₂
Theorem: Rat.cast_inv_of_ne_zero
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q : ℚ
hq : ↑q.num ≠ 0
⊢ ↑q⁻¹ = (↑q)⁻¹
state_after: no goals
tactic: rw [inv_def', cast_divInt_of_ne_zero _ hq, cast_def, inv_div, Int.cast_natCast]
Theorem: image_circleMap_Ioc
File: Mathlib/MeasureTheory/Integral/CircleIntegral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
c : ℂ
R : ℝ
⊢ circleMap c R '' Ioc 0 (2 * π) = sphere c |R|
state_after: no goals
tactic: rw [← range_circleMap, ← (periodic_circleMap c R).image_Ioc Real.two_pi_pos 0, zero_add]
Theorem: List.headI_add_tail_sum
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
L : List ℕ
⊢ L.headI + L.tail.sum = L.sum
state_after: no goals
tactic: cases L <;> simp
Theorem: gcd_eq_of_dvd_sub_right
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd a b = gcd a c
state_after: case hab
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd a b ∣ c

case hba
α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd a c ∣ b
tactic: apply dvd_antisymm_of_normalize_eq (normalize_gcd _ _) (normalize_gcd _ _) <;>
    rw [dvd_gcd_iff] <;>
    refine ⟨gcd_dvd_left _ _, ?_⟩
Theorem: Pi.exists_compact_superset_iff
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : Set ((i : ι) → X i)
⊢ (∃ K, IsCompact K ∧ s ⊆ K) ↔ ∀ (i : ι), ∃ Ki, IsCompact Ki ∧ s ⊆ eval i ⁻¹' Ki
state_after: case mp
X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : Set ((i : ι) → X i)
⊢ (∃ K, IsCompact K ∧ s ⊆ K) → ∀ (i : ι), ∃ Ki, IsCompact Ki ∧ s ⊆ eval i ⁻¹' Ki

case mpr
X✝ : Type u
Y : Type v
ι : Type u_1
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
s✝ t : Set X✝
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
s : Set ((i : ι) → X i)
⊢ (∀ (i : ι), ∃ Ki, IsCompact Ki ∧ s ⊆ eval i ⁻¹' Ki) → ∃ K, IsCompact K ∧ s ⊆ K
tactic: constructor
Theorem: AlgEquiv.toAlgebraIso_hom
File: Mathlib/Algebra/Category/AlgebraCat/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
g₁ : Ring X₁
g₂ : Ring X₂
m₁ : Algebra R X₁
m₂ : Algebra R X₂
e : X₁ ≃ₐ[R] X₂
⊢ ↑e ≫ ↑e.symm = 𝟙 (AlgebraCat.of R X₁)
state_after: case w
R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
g₁ : Ring X₁
g₂ : Ring X₂
m₁ : Algebra R X₁
m₂ : Algebra R X₂
e : X₁ ≃ₐ[R] X₂
x : (forget (AlgebraCat R)).obj (AlgebraCat.of R X₁)
⊢ (↑e ≫ ↑e.symm) x = (𝟙 (AlgebraCat.of R X₁)) x
tactic: ext x
state_before: case w
R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
g₁ : Ring X₁
g₂ : Ring X₂
m₁ : Algebra R X₁
m₂ : Algebra R X₂
e : X₁ ≃ₐ[R] X₂
x : (forget (AlgebraCat R)).obj (AlgebraCat.of R X₁)
⊢ (↑e ≫ ↑e.symm) x = (𝟙 (AlgebraCat.of R X₁)) x
state_after: no goals
tactic: exact e.left_inv x
state_before: R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
g₁ : Ring X₁
g₂ : Ring X₂
m₁ : Algebra R X₁
m₂ : Algebra R X₂
e : X₁ ≃ₐ[R] X₂
⊢ ↑e.symm ≫ ↑e = 𝟙 (AlgebraCat.of R X₂)
state_after: case w
R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
g₁ : Ring X₁
g₂ : Ring X₂
m₁ : Algebra R X₁
m₂ : Algebra R X₂
e : X₁ ≃ₐ[R] X₂
x : (forget (AlgebraCat R)).obj (AlgebraCat.of R X₂)
⊢ (↑e.symm ≫ ↑e) x = (𝟙 (AlgebraCat.of R X₂)) x
tactic: ext x
state_before: case w
R : Type u
inst✝ : CommRing R
X₁ X₂ : Type u
g₁ : Ring X₁
g₂ : Ring X₂
m₁ : Algebra R X₁
m₂ : Algebra R X₂
e : X₁ ≃ₐ[R] X₂
x : (forget (AlgebraCat R)).obj (AlgebraCat.of R X₂)
⊢ (↑e.symm ≫ ↑e) x = (𝟙 (AlgebraCat.of R X₂)) x
state_after: no goals
tactic: exact e.right_inv x
Theorem: CochainComplex.mappingCone.id_X
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{?u.81828, u_1} C
inst✝³ : Category.{?u.81832, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + 1 = q
⊢ q + -1 = p
state_after: no goals
tactic: omega
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{?u.81832, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
p q : ℤ
hpq : p + 1 = q
⊢ (↑(fst φ)).v p q hpq ≫ (inl φ).v q p ⋯ + (snd φ).v p p ⋯ ≫ (inr φ).f p = 𝟙 ((mappingCone φ).X p)
state_after: no goals
tactic: simpa only [Cochain.add_v, Cochain.comp_zero_cochain_v, Cochain.ofHom_v, id_f,
    Cochain.comp_v _ _ (add_neg_self 1) p q p hpq (by omega)]
    using Cochain.congr_v (id φ) p p (add_zero p)
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₂₀_iff'
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₂ c) (in₀ a) → ∃ x ∈ t, x.2.2 = c ∧ x.1 = a
state_after: case in₂₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
b✝ : β
a✝ : (a, b✝, c) ∈ t
⊢ ∃ x ∈ t, x.2.2 = c ∧ x.1 = a
tactic: rintro ⟨⟩
state_before: case in₂₀
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
b✝ : β
a✝ : (a, b✝, c) ∈ t
⊢ ∃ x ∈ t, x.2.2 = c ∧ x.1 = a
state_after: no goals
tactic: exact ⟨_, ‹_›, by simp⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (∃ x ∈ t, x.2.2 = c ∧ x.1 = a) → (graph t).Adj (in₂ c) (in₀ a)
state_after: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₂ (a, b, c).2.2) (in₀ (a, b, c).1)
tactic: rintro ⟨⟨a, b, c⟩, h, rfl, rfl⟩
state_before: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₂ (a, b, c).2.2) (in₀ (a, b, c).1)
state_after: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ ((a, b, c).1, ?intro.mk.mk.intro.intro.b, (a, b, c).2.2) ∈ t

case intro.mk.mk.intro.intro.b
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ β
tactic: constructor
state_before: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ ((a, b, c).1, ?intro.mk.mk.intro.intro.b, (a, b, c).2.2) ∈ t

case intro.mk.mk.intro.intro.b
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a' : α
b✝ b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ β
state_after: no goals
tactic: assumption
Theorem: AList.lookupFinsupp_support
File: Mathlib/Data/Finsupp/AList.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ l.lookupFinsupp.support = (filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset
state_after: α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ (filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset =
    (filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset
tactic: dsimp only [lookupFinsupp]
state_before: α : Type u_1
M : Type u_2
inst✝² : Zero M
inst✝¹ : DecidableEq α
inst✝ : DecidableEq M
l : AList fun _x => M
⊢ (filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset =
    (filter (fun x => decide (x.snd ≠ 0)) l.entries).keys.toFinset
state_after: no goals
tactic: congr!
Theorem: PNat.find_eq_iff
File: Mathlib/Data/PNat/Find.lean

Proof steps:
state_before: p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ PNat.find h = m ↔ p m ∧ ∀ n < m, ¬p n
state_after: case mp
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ PNat.find h = m → p m ∧ ∀ n < m, ¬p n

case mpr
p q : ℕ+ → Prop
inst✝¹ : DecidablePred p
inst✝ : DecidablePred q
h : ∃ n, p n
n m : ℕ+
⊢ (p m ∧ ∀ n < m, ¬p n) → PNat.find h = m
tactic: constructor
Theorem: Nat.Partrec.Code.eval_part
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: a : Code × ℕ
⊢ (rfindOpt fun b =>
      evaln (((a, b).2, (a, b).1.1), (a, b).1.2).1.1 (((a, b).2, (a, b).1.1), (a, b).1.2).1.2
        (((a, b).2, (a, b).1.1), (a, b).1.2).2) =
    a.1.eval a.2
state_after: no goals
tactic: simp [eval_eq_rfindOpt]
Theorem: Turing.TM2.stmts₁_self
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: K : Type u_1
inst✝ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
q : Stmt₂
⊢ q ∈ stmts₁ q
state_after: no goals
tactic: cases q <;> simp only [Finset.mem_insert_self, Finset.mem_singleton_self, stmts₁]
Theorem: Set.indicator_indicator
File: Mathlib/Algebra/Group/Indicator.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t✝ : Set α
f✝ g : α → M
a : α
s t : Set α
f : α → M
x : α
⊢ s.mulIndicator (t.mulIndicator f) x = (s ∩ t).mulIndicator f x
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t✝ : Set α
f✝ g : α → M
a : α
s t : Set α
f : α → M
x : α
⊢ (if x ∈ s then if x ∈ t then f x else 1 else 1) = if x ∈ s ∩ t then f x else 1
tactic: simp only [mulIndicator]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
inst✝¹ : One M
inst✝ : One N
s✝ t✝ : Set α
f✝ g : α → M
a : α
s t : Set α
f : α → M
x : α
⊢ (if x ∈ s then if x ∈ t then f x else 1 else 1) = if x ∈ s ∩ t then f x else 1
state_after: no goals
tactic: split_ifs <;> simp_all (config := { contextual := true })
Theorem: List.pwFilter_map
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
β : Type u_2
inst✝ : DecidableRel R
f : β → α
x : β
xs : List β
⊢ pwFilter R (map f (x :: xs)) = map f (pwFilter (fun x y => R (f x) (f y)) (x :: xs))
state_after: no goals
tactic: if h : ∀ b ∈ pwFilter R (map f xs), R (f x) b then
      have h' : ∀ b : β, b ∈ pwFilter (fun x y : β => R (f x) (f y)) xs → R (f x) (f b) :=
        fun b hb => h _ (by rw [pwFilter_map f xs]; apply mem_map_of_mem _ hb)
      rw [map, pwFilter_cons_of_pos h, pwFilter_cons_of_pos h', pwFilter_map f xs, map]
    else
      rw [map, pwFilter_cons_of_neg h, pwFilter_cons_of_neg ?_, pwFilter_map f xs]
      refine fun hh => h fun a ha => ?_
      rw [pwFilter_map f xs, mem_map] at ha
      let ⟨b, hb₀, hb₁⟩ := ha; exact hb₁ ▸ hh _ hb₀
Theorem: Nat.one_div_le_one_div
File: Mathlib/Data/Nat/Cast/Order/Field.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ 1 / (↑m + 1) ≤ 1 / (↑n + 1)
state_after: case refine_1
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ 0 < ↑n + 1

case refine_2
α : Type u_1
inst✝ : LinearOrderedSemifield α
n m : ℕ
h : n ≤ m
⊢ ↑n + 1 ≤ ↑m + 1
tactic: refine one_div_le_one_div_of_le ?_ ?_