ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: norm_sup_le_add
File: Mathlib/Analysis/Normed/Order/Lattice.lean

Proof steps:
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
⊢ ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖
state_after: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖
tactic: have h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_sup_sub_sup_le_add_norm x y 0 0
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖
state_after: no goals
tactic: simpa only [sup_idem, sub_zero] using h
Theorem: Comon_.Comon_ToMon_OpOp_obj
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).one ≫ f.hom.op =
    (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).one
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).one ≫ f.hom.op).unop =
    (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).one.unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).one ≫ f.hom.op).unop =
    (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).one.unop
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).mul ≫ f.hom.op =
    (f.hom.op ⊗ f.hom.op) ≫ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).mul
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).mul ≫ f.hom.op).unop =
    ((f.hom.op ⊗ f.hom.op) ≫ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).mul).unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M X✝ Y✝ : Comon_ C
f : X✝ ⟶ Y✝
⊢ ((unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) Y✝)).mul ≫ f.hom.op).unop =
    ((f.hom.op ⊗ f.hom.op) ≫ (unop ((fun A => op (Comon_ToMon_OpOp_obj' C A)) X✝)).mul).unop
state_after: no goals
tactic: simp [op_tensorHom]
Theorem: Bool.false_eq_true_eq_False
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: ⊢ ¬false = true
state_after: no goals
tactic: decide
Theorem: List.chain_split
File: Mathlib/Data/List/Chain.lean

Proof steps:
state_before: α : Type u
β : Type v
R r : α → α → Prop
l l₁✝ l₂✝ : List α
a✝ b✝ a b : α
l₁ l₂ : List α
⊢ Chain R a (l₁ ++ b :: l₂) ↔ Chain R a (l₁ ++ [b]) ∧ Chain R b l₂
state_after: no goals
tactic: induction' l₁ with x l₁ IH generalizing a <;>
    simp only [*, nil_append, cons_append, Chain.nil, chain_cons, and_true_iff, and_assoc]
Theorem: AddConstMapClass.map_sub_int'
File: Mathlib/Algebra/AddConstMap/Basic.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
H : Type u_3
inst✝³ : FunLike F G H
a : G
b : H
inst✝² : AddGroupWithOne G
inst✝¹ : AddGroup H
inst✝ : AddConstMapClass F G H 1 b
f : F
x : G
n : ℤ
⊢ f (x - ↑n) = f x - n • b
state_after: no goals
tactic: rw [← map_sub_zsmul, zsmul_one]
Theorem: SzemerediRegularity.m_le_card_of_mem_chunk_parts
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Fintype α
inst✝¹ : DecidableEq α
P : Finpartition univ
hP : P.IsEquipartition
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : ℝ
U : Finset α
hU : U ∈ P.parts
V : Finset α
𝒜 : Finset (Finset α)
s : Finset α
hs : s ∈ (chunk hP G ε hU).parts
i : s.card = m + 1
⊢ m ≤ s.card
state_after: no goals
tactic: simp [i]
Theorem: continuousAt_sign_of_neg
File: Mathlib/Topology/Instances/Sign.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ ContinuousAt (⇑SignType.sign) a
state_after: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ (fun x => -1) =ᶠ[nhds a] ⇑SignType.sign
tactic: refine (continuousAt_const : ContinuousAt (fun x => (-1 : SignType)) a).congr ?_
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ (fun x => -1) =ᶠ[nhds a] ⇑SignType.sign
state_after: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ ∃ t, (∀ y ∈ t, -1 = SignType.sign y) ∧ IsOpen t ∧ a ∈ t
tactic: rw [Filter.EventuallyEq, eventually_nhds_iff]
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ ∃ t, (∀ y ∈ t, -1 = SignType.sign y) ∧ IsOpen t ∧ a ∈ t
state_after: no goals
tactic: exact ⟨{ x | x < 0 }, fun x hx => (sign_neg hx).symm, isOpen_gt' 0, h⟩
Theorem: RatFunc.intDegree_mul
File: Mathlib/FieldTheory/RatFunc/Degree.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hx : x ≠ 0
hy : y ≠ 0
⊢ (x * y).intDegree = x.intDegree + y.intDegree
state_after: K : Type u
inst✝ : Field K
x y : RatFunc K
hx : x ≠ 0
hy : y ≠ 0
⊢ ↑(x * y).num.natDegree + (↑x.denom.natDegree + ↑y.denom.natDegree) =
    ↑x.num.natDegree + ↑y.num.natDegree + ↑(x * y).denom.natDegree
tactic: simp only [intDegree, add_sub, sub_add, sub_sub_eq_add_sub, sub_sub, sub_eq_sub_iff_add_eq_add]
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hx : x ≠ 0
hy : y ≠ 0
⊢ ↑(x * y).num.natDegree + (↑x.denom.natDegree + ↑y.denom.natDegree) =
    ↑x.num.natDegree + ↑y.num.natDegree + ↑(x * y).denom.natDegree
state_after: K : Type u
inst✝ : Field K
x y : RatFunc K
hx : x ≠ 0
hy : y ≠ 0
⊢ (x * y).num.natDegree + (x.denom.natDegree + y.denom.natDegree) =
    x.num.natDegree + y.num.natDegree + (x * y).denom.natDegree
tactic: norm_cast
state_before: K : Type u
inst✝ : Field K
x y : RatFunc K
hx : x ≠ 0
hy : y ≠ 0
⊢ (x * y).num.natDegree + (x.denom.natDegree + y.denom.natDegree) =
    x.num.natDegree + y.num.natDegree + (x * y).denom.natDegree
state_after: no goals
tactic: rw [← Polynomial.natDegree_mul x.denom_ne_zero y.denom_ne_zero, ←
    Polynomial.natDegree_mul (RatFunc.num_ne_zero (mul_ne_zero hx hy))
      (mul_ne_zero x.denom_ne_zero y.denom_ne_zero),
    ← Polynomial.natDegree_mul (RatFunc.num_ne_zero hx) (RatFunc.num_ne_zero hy), ←
    Polynomial.natDegree_mul (mul_ne_zero (RatFunc.num_ne_zero hx) (RatFunc.num_ne_zero hy))
      (x * y).denom_ne_zero,
    RatFunc.num_denom_mul]
Theorem: iSup_eq_top
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✝ : CompleteLinearOrder α
f : ι → α
⊢ iSup f = ⊤ ↔ ∀ b < ⊤, ∃ i, b < f i
state_after: no goals
tactic: simp only [← sSup_range, sSup_eq_top, Set.exists_range_iff]
Theorem: IsPreconnected.preperfect_of_nontrivial
File: Mathlib/Topology/Perfect.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h : IsPreconnected U
⊢ Preperfect U
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h : IsPreconnected U
x : α
hx : x ∈ U
⊢ AccPt x (𝓟 U)
tactic: intro x hx
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h : IsPreconnected U
x : α
hx : x ∈ U
⊢ AccPt x (𝓟 U)
state_after: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h :
  ∀ (t t' : Set α),
    IsClosed t → IsClosed t' → U ⊆ t ∪ t' → (U ∩ t).Nonempty → (U ∩ t').Nonempty → (U ∩ (t ∩ t')).Nonempty
x : α
hx : x ∈ U
⊢ AccPt x (𝓟 U)
tactic: rw [isPreconnected_closed_iff] at h
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h :
  ∀ (t t' : Set α),
    IsClosed t → IsClosed t' → U ⊆ t ∪ t' → (U ∩ t).Nonempty → (U ∩ t').Nonempty → (U ∩ (t ∩ t')).Nonempty
x : α
hx : x ∈ U
⊢ AccPt x (𝓟 U)
state_after: case specialize_1
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h :
  ∀ (t t' : Set α),
    IsClosed t → IsClosed t' → U ⊆ t ∪ t' → (U ∩ t).Nonempty → (U ∩ t').Nonempty → (U ∩ (t ∩ t')).Nonempty
x : α
hx : x ∈ U
⊢ U ⊆ {x} ∪ closure (U \ {x})

case specialize_2
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h :
  ∀ (t t' : Set α),
    IsClosed t → IsClosed t' → U ⊆ t ∪ t' → (U ∩ t).Nonempty → (U ∩ t').Nonempty → (U ∩ (t ∩ t')).Nonempty
x : α
hx : x ∈ U
⊢ (U ∩ {x}).Nonempty

case specialize_3
α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
h :
  ∀ (t t' : Set α),
    IsClosed t → IsClosed t' → U ⊆ t ∪ t' → (U ∩ t).Nonempty → (U ∩ t').Nonempty → (U ∩ (t ∩ t')).Nonempty
x : α
hx : x ∈ U
⊢ (U ∩ closure (U \ {x})).Nonempty

α : Type u_1
inst✝¹ : TopologicalSpace α
C : Set α
inst✝ : T1Space α
U : Set α
hu : U.Nontrivial
x : α
hx : x ∈ U
h : (U ∩ ({x} ∩ closure (U \ {x}))).Nonempty
⊢ AccPt x (𝓟 U)
tactic: specialize h {x} (closure (U \ {x})) isClosed_singleton isClosed_closure ?_ ?_ ?_
Theorem: Multiset.card_powerset
File: Mathlib/Data/Multiset/Powerset.lean

Proof steps:
state_before: α : Type u_1
s : Multiset α
⊢ ∀ (a : List α), card (powerset ⟦a⟧) = 2 ^ card ⟦a⟧
state_after: no goals
tactic: simp
Theorem: groupCohomology.oneCocyclesLequivOfIsTrivial_apply_apply
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : ↥(oneCocycles A)
⊢ (fun f => ⟨⇑f, ⋯⟩)
      ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
            map_smul' := ⋯ }.toFun
        f) =
    f
state_after: case a.h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : ↥(oneCocycles A)
x✝ : G
⊢ ↑((fun f => ⟨⇑f, ⋯⟩)
          ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
                map_smul' := ⋯ }.toFun
            f))
      x✝ =
    ↑f x✝
tactic: ext
state_before: case a.h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : ↥(oneCocycles A)
x✝ : G
⊢ ↑((fun f => ⟨⇑f, ⋯⟩)
          ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
                map_smul' := ⋯ }.toFun
            f))
      x✝ =
    ↑f x✝
state_after: no goals
tactic: rfl
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : Additive G →+ CoeSort.coe A
⊢ { toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
          map_smul' := ⋯ }.toFun
      ((fun f => ⟨⇑f, ⋯⟩) f) =
    f
state_after: case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : Additive G →+ CoeSort.coe A
x✝ : Additive G
⊢ ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
            map_smul' := ⋯ }.toFun
        ((fun f => ⟨⇑f, ⋯⟩) f))
      x✝ =
    f x✝
tactic: ext
state_before: case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : Additive G →+ CoeSort.coe A
x✝ : Additive G
⊢ ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
            map_smul' := ⋯ }.toFun
        ((fun f => ⟨⇑f, ⋯⟩) f))
      x✝ =
    f x✝
state_after: no goals
tactic: rfl
Theorem: Equiv.Perm.VectorsProdEqOne.vectorEquiv_symm_apply
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : Vector G n
⊢ v.toList.prod⁻¹ ::ᵥ v ∈ vectorsProdEqOne G (n + 1)
state_after: no goals
tactic: rw [mem_iff, Vector.toList_cons, List.prod_cons, inv_mul_self]
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : ↑(vectorsProdEqOne G (n + 1))
⊢ (↑v).head * (↑v).tail.toList.prod = 1
state_after: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : ↑(vectorsProdEqOne G (n + 1))
⊢ (↑v).toList.prod = 1
tactic: rw [← List.prod_cons, ← Vector.toList_cons, v.1.cons_head_tail]
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
v : ↑(vectorsProdEqOne G (n + 1))
⊢ (↑v).toList.prod = 1
state_after: no goals
tactic: exact v.2
Theorem: FractionalIdeal.count_self
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
⊢ count K v ↑v.asIdeal = 1
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
hv : ↑v.asIdeal ≠ 0
⊢ count K v ↑v.asIdeal = 1
tactic: have hv : (v.asIdeal : FractionalIdeal R⁰ K) ≠ 0 := coeIdeal_ne_zero.mpr v.ne_bot
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
hv : ↑v.asIdeal ≠ 0
⊢ count K v ↑v.asIdeal = 1
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
hv : ↑v.asIdeal ≠ 0
h_self : ↑v.asIdeal = spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑v.asIdeal
⊢ count K v ↑v.asIdeal = 1
tactic: have h_self : (v.asIdeal : FractionalIdeal R⁰ K) =
      spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑v.asIdeal := by
    rw [(algebraMap R K).map_one, inv_one, spanSingleton_one, one_mul]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
hv : ↑v.asIdeal ≠ 0
h_self : ↑v.asIdeal = spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑v.asIdeal
⊢ count K v ↑v.asIdeal = 1
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
hv : ↑v.asIdeal ≠ 0
h_self : ↑v.asIdeal = spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑v.asIdeal
hv_irred : Irreducible (Associates.mk v.asIdeal)
⊢ count K v ↑v.asIdeal = 1
tactic: have hv_irred : Irreducible (Associates.mk v.asIdeal) := by apply v.associates_irreducible
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
hv : ↑v.asIdeal ≠ 0
h_self : ↑v.asIdeal = spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑v.asIdeal
hv_irred : Irreducible (Associates.mk v.asIdeal)
⊢ count K v ↑v.asIdeal = 1
state_after: no goals
tactic: rw [count_well_defined K v hv h_self, Associates.count_self hv_irred, Ideal.span_singleton_one,
    ← Ideal.one_eq_top, Associates.mk_one, Associates.factors_one, Associates.count_zero hv_irred,
    ofNat_zero, sub_zero, ofNat_one]
Theorem: CategoryTheory.OplaxNatTrans.leftUnitor_hom_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η : F ⟶ G
⊢ ∀ {a b : B} (f : a ⟶ b),
    F.map f ◁ ((fun a => λ_ (η.app a)) b).hom ≫ η.naturality f =
      (𝟙 F ≫ η).naturality f ≫ ((fun a => λ_ (η.app a)) a).hom ▷ G.map f
state_after: no goals
tactic: aesop_cat
Theorem: Order.not_isSuccLimit_of_noMax
File: Mathlib/Order/SuccPred/Limit.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : Preorder α
a : α
inst✝³ : SuccOrder α
inst✝² : IsSuccArchimedean α
inst✝¹ : NoMinOrder α
inst✝ : NoMaxOrder α
⊢ ¬IsSuccLimit a
state_after: no goals
tactic: simp
Theorem: gauge_le_of_mem
File: Mathlib/Analysis/Convex/Gauge.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
ha : 0 ≤ a
hx : x ∈ a • s
⊢ gauge s x ≤ a
state_after: case inl
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
ha : 0 ≤ 0
hx : x ∈ 0 • s
⊢ gauge s x ≤ 0

case inr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
x : E
a : ℝ
ha : 0 ≤ a
hx : x ∈ a • s
ha' : 0 < a
⊢ gauge s x ≤ a
tactic: obtain rfl | ha' := ha.eq_or_lt
Theorem: Stream'.WSeq.dropn_congr
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
n : ℕ
⊢ s.drop n ~ʷ t.drop n
state_after: no goals
tactic: induction n <;> simp [*, tail_congr, drop]
Theorem: List.pairwise_of_reflexive_on_dupl_of_forall_ne
File: .lake/packages/batteries/Batteries/Data/List/Pairwise.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
r : α → α → Prop
hr : ∀ (a : α), 1 < count a l → r a a
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ Pairwise r l
state_after: α : Type u_1
inst✝ : DecidableEq α
l : List α
r : α → α → Prop
hr : ∀ (a : α), 1 < count a l → r a a
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b
tactic: apply pairwise_iff_forall_sublist.mpr
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
r : α → α → Prop
hr : ∀ (a : α), 1 < count a l → r a a
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
⊢ ∀ {a b : α}, [a, b] <+ l → r a b
state_after: α : Type u_1
inst✝ : DecidableEq α
l : List α
r : α → α → Prop
hr : ∀ (a : α), 1 < count a l → r a a
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b
tactic: intro a b hab
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
r : α → α → Prop
hr : ∀ (a : α), 1 < count a l → r a a
h : ∀ (a : α), a ∈ l → ∀ (b : α), b ∈ l → a ≠ b → r a b
a b : α
hab : [a, b] <+ l
⊢ r a b
state_after: no goals
tactic: if heq : a = b then
    cases heq; apply hr
    rwa [show [a,a] = replicate 2 a from rfl, ← le_count_iff_replicate_sublist] at hab
  else
    apply h <;> try (apply hab.subset; simp)
    exact heq
Theorem: Filter.isUnit_iff
File: Mathlib/Order/Filter/Pointwise.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✝ : DivisionMonoid α
f g : Filter α
⊢ IsUnit f ↔ ∃ a, f = pure a ∧ IsUnit a
state_after: case mp
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : DivisionMonoid α
f g : Filter α
⊢ IsUnit f → ∃ a, f = pure a ∧ IsUnit a

case mpr
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : DivisionMonoid α
f g : Filter α
⊢ (∃ a, f = pure a ∧ IsUnit a) → IsUnit f
tactic: constructor
Theorem: MeasureTheory.ae_eq_univ_iff_measure_eq
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s μ
⊢ s =ᶠ[ae μ] univ ↔ μ s = μ univ
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s μ
h : μ s = μ univ
⊢ s =ᶠ[ae μ] univ
tactic: refine ⟨measure_congr, fun h => ?_⟩
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s μ
h : μ s = μ univ
⊢ s =ᶠ[ae μ] univ
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t✝ : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s μ
h : μ s = μ univ
t : Set α
ht₁ : MeasurableSet t
ht₂ : t =ᶠ[ae μ] s
⊢ s =ᶠ[ae μ] univ
tactic: obtain ⟨t, -, ht₁, ht₂⟩ := hs.exists_measurable_subset_ae_eq
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t✝ : Set α
inst✝ : IsFiniteMeasure μ
hs : NullMeasurableSet s μ
h : μ s = μ univ
t : Set α
ht₁ : MeasurableSet t
ht₂ : t =ᶠ[ae μ] s
⊢ s =ᶠ[ae μ] univ
state_after: no goals
tactic: exact
    ht₂.symm.trans
      (ae_eq_of_subset_of_measure_ge (subset_univ t) (Eq.le ((measure_congr ht₂).trans h).symm) ht₁
        (measure_ne_top μ univ))
Theorem: LiouvilleWith.sub_int_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

Proof steps:
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
⊢ LiouvilleWith p (x - ↑m) ↔ LiouvilleWith p x
state_after: no goals
tactic: rw [← Rat.cast_intCast, sub_rat_iff]
Theorem: ArithmeticFunction.convolution_vonMangoldt_zeta
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: ⊢ ((fun n => ↑(Λ n)) ⍟ fun n => ↑(ζ n)) = fun n => Complex.log ↑n
state_after: case h
n : ℕ
⊢ ((fun n => ↑(Λ n)) ⍟ fun n => ↑(ζ n)) n = Complex.log ↑n
tactic: ext n
Theorem: Nat.bitwise_eq_binaryRec
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: f : Bool → Bool → Bool
⊢ bitwise f =
    binaryRec (fun n => bif f false true then n else 0) fun a m Ia =>
      binaryRec (bif f true false then bit a m else 0) fun b n x => bit (f a b) (Ia n)
state_after: case h.h
f : Bool → Bool → Bool
x y : ℕ
⊢ bitwise f x y =
    binaryRec (fun n => bif f false true then n else 0)
      (fun a m Ia => binaryRec (bif f true false then bit a m else 0) fun b n x => bit (f a b) (Ia n)) x y
tactic: funext x y
state_before: case h.h
f : Bool → Bool → Bool
x y : ℕ
⊢ bitwise f x y =
    binaryRec (fun n => bif f false true then n else 0)
      (fun a m Ia => binaryRec (bif f true false then bit a m else 0) fun b n x => bit (f a b) (Ia n)) x y
state_after: no goals
tactic: induction x using binaryRec' generalizing y with
  | z => simp only [bitwise_zero_left, binaryRec_zero, Bool.cond_eq_ite]
  | f xb x hxb ih =>
    rw [← bit_ne_zero_iff] at hxb
    simp_rw [binaryRec_of_ne_zero _ _ hxb, bodd_bit, div2_bit, eq_rec_constant]
    induction y using binaryRec' with
    | z => simp only [bitwise_zero_right, binaryRec_zero, Bool.cond_eq_ite]
    | f yb y hyb =>
      rw [← bit_ne_zero_iff] at hyb
      simp_rw [binaryRec_of_ne_zero _ _ hyb, bitwise_of_ne_zero hxb hyb, bodd_bit, ← div2_val,
        div2_bit, eq_rec_constant, ih]
Theorem: CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : X ⟶ Y
inst✝¹ : HasPushout f g
inst✝ : HasPullback f.op g.op
⊢ (PullbackCone.unop (limit.cone (cospan f.op g.op))).ι.app WalkingSpan.right = (pullback.snd f.op g.op).unop
state_after: no goals
tactic: simp