ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Pretriangulated.TriangleOpEquivalence.counitIso_inv_app_hom₂
File: Mathlib/CategoryTheory/Triangulated/Opposite.lean

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

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

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

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ ⊤
⊢ a.toReal < b.toReal ↔ a < b
state_after: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a).toReal < b.toReal ↔ ↑a < b
tactic: lift a to ℝ≥0 using ha
state_before: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a).toReal < b.toReal ↔ ↑a < b
state_after: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a).toReal < (↑b).toReal ↔ ↑a < ↑b
tactic: lift b to ℝ≥0 using hb
state_before: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a).toReal < (↑b).toReal ↔ ↑a < ↑b
state_after: no goals
tactic: norm_cast
Theorem: CategoryTheory.Quotient.lift_unique'
File: Mathlib/CategoryTheory/Quotient.lean

Proof steps:
state_before: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ F₁ = F₂
state_after: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ F₁ = lift r (functor r ⋙ F₂) ?m.14535

C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → (functor r ⋙ F₂).map f₁ = (functor r ⋙ F₂).map f₂
tactic: rw [lift_unique r (functor r ⋙ F₂) _ F₂ rfl]
state_before: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ F₁ = lift r (functor r ⋙ F₂) ?m.14535

C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → (functor r ⋙ F₂).map f₁ = (functor r ⋙ F₂).map f₂
state_after: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → (functor r ⋙ F₂).map f₁ = (functor r ⋙ F₂).map f₂

C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ F₁ = lift r (functor r ⋙ F₂) ?m.14535
tactic: swap
state_before: C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ F₁ = lift r (functor r ⋙ F₂) ⋯
state_after: case hΦ
C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ functor r ⋙ F₁ = functor r ⋙ F₂
tactic: apply lift_unique
state_before: case hΦ
C : Type u_3
inst✝¹ : Category.{u_1, u_3} C
r : HomRel C
D : Type u_4
inst✝ : Category.{u_2, u_4} D
F : C ⥤ D
H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂
F₁ F₂ : Quotient r ⥤ D
h : functor r ⋙ F₁ = functor r ⋙ F₂
⊢ functor r ⋙ F₁ = functor r ⋙ F₂
state_after: no goals
tactic: rw [h]
Theorem: ENNReal.pow_lt_top
File: Mathlib/Data/ENNReal/Operations.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
α : Type u_1
⊢ a < ⊤ → ∀ (n : ℕ), a ^ n < ⊤
state_after: no goals
tactic: simpa only [lt_top_iff_ne_top] using pow_ne_top
Theorem: Finset.coe_zsmul
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s✝ t s : Finset α
n : ℕ
⊢ ↑(s ^ Int.negSucc n) = ↑s ^ Int.negSucc n
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s✝ t s : Finset α
n : ℕ
⊢ (↑(npowRec n.succ s))⁻¹ = ↑s ^ Int.negSucc n
tactic: refine (coe_inv _).trans ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s✝ t s : Finset α
n : ℕ
⊢ (↑(npowRec n.succ s))⁻¹ = ↑s ^ Int.negSucc n
state_after: no goals
tactic: exact congr_arg Inv.inv (coe_pow _ _)
Theorem: Nat.div_eq_sub_mod_div
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m / n = (m - m % n) / n
state_after: case inl
a b c d m k : ℕ
p q : ℕ → Prop
⊢ m / 0 = (m - m % 0) / 0

case inr
a b c d m n k : ℕ
p q : ℕ → Prop
hn : n > 0
⊢ m / n = (m - m % n) / n
tactic: obtain rfl | hn := n.eq_zero_or_pos
Theorem: MvPolynomial.eval₂_map
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
f✝ : R →+* S₁
inst✝ : CommSemiring S₂
f : R →+* S₁
g : σ → S₂
φ : S₁ →+* S₂
p : MvPolynomial σ R
⊢ eval₂ φ g ((map f) p) = eval₂ (φ.comp f) g p
state_after: no goals
tactic: rw [← eval_map, ← eval_map, map_map]
Theorem: hasBasis_coclosedLindelof
File: Mathlib/Topology/Compactness/Lindelof.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ (coclosedLindelof X).HasBasis (fun s => IsClosed s ∧ IsLindelof s) compl
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ (⨅ s, ⨅ (_ : IsClosed s ∧ IsLindelof s), 𝓟 sᶜ).HasBasis (fun s => IsClosed s ∧ IsLindelof s) compl
tactic: simp only [Filter.coclosedLindelof, iInf_and']
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ (⨅ s, ⨅ (_ : IsClosed s ∧ IsLindelof s), 𝓟 sᶜ).HasBasis (fun s => IsClosed s ∧ IsLindelof s) compl
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ ∀ (i : Set X),
    IsClosed i ∧ IsLindelof i →
      ∀ (j : Set X), IsClosed j ∧ IsLindelof j → ∃ k, (IsClosed k ∧ IsLindelof k) ∧ kᶜ ⊆ iᶜ ∧ kᶜ ⊆ jᶜ
tactic: refine hasBasis_biInf_principal' ?_ ⟨∅, isClosed_empty, isLindelof_empty⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ ∀ (i : Set X),
    IsClosed i ∧ IsLindelof i →
      ∀ (j : Set X), IsClosed j ∧ IsLindelof j → ∃ k, (IsClosed k ∧ IsLindelof k) ∧ kᶜ ⊆ iᶜ ∧ kᶜ ⊆ jᶜ
state_after: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t✝ s : Set X
hs₁ : IsClosed s
hs₂ : IsLindelof s
t : Set X
ht₁ : IsClosed t
ht₂ : IsLindelof t
⊢ ∃ k, (IsClosed k ∧ IsLindelof k) ∧ kᶜ ⊆ sᶜ ∧ kᶜ ⊆ tᶜ
tactic: rintro s ⟨hs₁, hs₂⟩ t ⟨ht₁, ht₂⟩
state_before: case intro.intro
X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s✝ t✝ s : Set X
hs₁ : IsClosed s
hs₂ : IsLindelof s
t : Set X
ht₁ : IsClosed t
ht₂ : IsLindelof t
⊢ ∃ k, (IsClosed k ∧ IsLindelof k) ∧ kᶜ ⊆ sᶜ ∧ kᶜ ⊆ tᶜ
state_after: no goals
tactic: exact ⟨s ∪ t, ⟨⟨hs₁.union ht₁, hs₂.union ht₂⟩, compl_subset_compl.2 subset_union_left,
    compl_subset_compl.2 subset_union_right⟩⟩
Theorem: SatisfiesM.imp
File: .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ Subtype.val <$>
      (fun x =>
          match x with
          | ⟨a, h⟩ => ⟨a, ⋯⟩) <$>
        x =
    x✝
state_after: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ (Subtype.val ∘ fun x =>
        match x with
        | ⟨a, h⟩ => ⟨a, ⋯⟩) <$>
      x =
    Subtype.val <$> x
tactic: rw [← h, ← comp_map]
state_before: m : Type u_1 → Type u_2
α : Type u_1
p q : α → Prop
inst✝¹ : Functor m
inst✝ : LawfulFunctor m
x✝ : m α
h✝ : SatisfiesM p x✝
H : ∀ {a : α}, p a → q a
x : m { a // p a }
h : Subtype.val <$> x = x✝
⊢ (Subtype.val ∘ fun x =>
        match x with
        | ⟨a, h⟩ => ⟨a, ⋯⟩) <$>
      x =
    Subtype.val <$> x
state_after: no goals
tactic: rfl
Theorem: isSumSq.add
File: Mathlib/Algebra/Ring/SumsOfSquares.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Mul R
inst✝ : AddMonoid R
S1 S2 : R
p1 : isSumSq S1
p2 : isSumSq S2
⊢ isSumSq (S1 + S2)
state_after: no goals
tactic: induction p1 with
  | zero             => rw [zero_add]; exact p2
  | sq_add a S pS ih => rw [add_assoc]; exact isSumSq.sq_add a (S + S2) ih
Theorem: CategoryTheory.ShortComplex.LeftHomologyMapData.map_φH
File: Mathlib/Algebra/Homology/ShortComplex/PreservesHomology.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{?u.23741, u_1} C
inst✝⁵ : Category.{?u.23745, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
ψ : LeftHomologyMapData φ h₁ h₂
F : C ⥤ D
inst✝² : F.PreservesZeroMorphisms
inst✝¹ : h₁.IsPreservedBy F
inst✝ : h₂.IsPreservedBy F
⊢ F.map ψ.φK ≫ (h₂.map F).i = (h₁.map F).i ≫ (F.mapShortComplex.map φ).τ₂
state_after: no goals
tactic: simpa only [F.map_comp] using F.congr_map ψ.commi
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{?u.23741, u_1} C
inst✝⁵ : Category.{?u.23745, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
ψ : LeftHomologyMapData φ h₁ h₂
F : C ⥤ D
inst✝² : F.PreservesZeroMorphisms
inst✝¹ : h₁.IsPreservedBy F
inst✝ : h₂.IsPreservedBy F
⊢ (h₁.map F).f' ≫ F.map ψ.φK = (F.mapShortComplex.map φ).τ₁ ≫ (h₂.map F).f'
state_after: no goals
tactic: simpa only [LeftHomologyData.map_f', F.map_comp] using F.congr_map ψ.commf'
state_before: C : Type u_1
D : Type u_2
inst✝⁶ : Category.{?u.23741, u_1} C
inst✝⁵ : Category.{?u.23745, u_2} D
inst✝⁴ : HasZeroMorphisms C
inst✝³ : HasZeroMorphisms D
S S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
ψ : LeftHomologyMapData φ h₁ h₂
F : C ⥤ D
inst✝² : F.PreservesZeroMorphisms
inst✝¹ : h₁.IsPreservedBy F
inst✝ : h₂.IsPreservedBy F
⊢ (h₁.map F).π ≫ F.map ψ.φH = F.map ψ.φK ≫ (h₂.map F).π
state_after: no goals
tactic: simpa only [F.map_comp] using F.congr_map ψ.commπ
Theorem: supClosure_prod
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
⊢ supClosure s ×ˢ supClosure t ≤ supClosure (s ×ˢ t)
state_after: case mk.intro.intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
u : Finset α
hu : u.Nonempty
hus : ↑u ⊆ s
v : Finset β
hv : v.Nonempty
hvt : ↑v ⊆ t
⊢ (u.sup' hu id, v.sup' hv id) ∈ supClosure (s ×ˢ t)
tactic: rintro ⟨_, _⟩ ⟨⟨u, hu, hus, rfl⟩, v, hv, hvt, rfl⟩
state_before: case mk.intro.intro.intro.intro.intro.intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
u : Finset α
hu : u.Nonempty
hus : ↑u ⊆ s
v : Finset β
hv : v.Nonempty
hvt : ↑v ⊆ t
⊢ (u.sup' hu id, v.sup' hv id) ∈ supClosure (s ×ˢ t)
state_after: case mk.intro.intro.intro.intro.intro.intro.intro.refine_1
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
u : Finset α
hu : u.Nonempty
hus : ↑u ⊆ s
v : Finset β
hv : v.Nonempty
hvt : ↑v ⊆ t
⊢ ↑(u ×ˢ v) ⊆ s ×ˢ t

case mk.intro.intro.intro.intro.intro.intro.intro.refine_2
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s✝ t✝ : Set α
a b : α
s : Set α
t : Set β
u : Finset α
hu : u.Nonempty
hus : ↑u ⊆ s
v : Finset β
hv : v.Nonempty
hvt : ↑v ⊆ t
⊢ (u ×ˢ v).sup' ⋯ id = (u.sup' hu id, v.sup' hv id)
tactic: refine ⟨u ×ˢ v, hu.product hv, ?_, ?_⟩
Theorem: symmDiff_sdiff_eq_sup
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ (b \ a) = a ⊔ b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ (b \ a) ⊔ b \ a = a ⊔ b
tactic: rw [symmDiff, sdiff_idem]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ (b \ a) ⊔ b \ a = a ⊔ b
state_after: no goals
tactic: exact
    le_antisymm (sup_le_sup sdiff_le sdiff_le)
      (sup_le le_sdiff_sup <| le_sdiff_sup.trans <| sup_le le_sup_right le_sdiff_sup)
Theorem: PNat.coprime_coe
File: Mathlib/Data/PNat/Prime.lean

Proof steps:
state_before: m n : ℕ+
⊢ (↑m).Coprime ↑n ↔ m.Coprime n
state_after: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ m.gcd n = 1
tactic: unfold Nat.Coprime Coprime
state_before: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ m.gcd n = 1
state_after: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ ↑(m.gcd n) = ↑1
tactic: rw [← coe_inj]
state_before: m n : ℕ+
⊢ (↑m).gcd ↑n = 1 ↔ ↑(m.gcd n) = ↑1
state_after: no goals
tactic: simp
Theorem: IsLocalization.smul_toInvSubmonoid
File: Mathlib/RingTheory/Localization/InvSubmonoid.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
m : ↥M
⊢ m • ↑((toInvSubmonoid M S) m) = 1
state_after: case h.e'_2.h.e
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
m : ↥M
⊢ HSMul.hSMul m = HMul.hMul ((algebraMap R S) ↑m)
tactic: convert mul_toInvSubmonoid M S m
state_before: case h.e'_2.h.e
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
m : ↥M
⊢ HSMul.hSMul m = HMul.hMul ((algebraMap R S) ↑m)
state_after: case h.e'_2.h.e.h
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
m : ↥M
x✝ : S
⊢ m • x✝ = (algebraMap R S) ↑m * x✝
tactic: ext
state_before: case h.e'_2.h.e.h
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
m : ↥M
x✝ : S
⊢ m • x✝ = (algebraMap R S) ↑m * x✝
state_after: case h.e'_2.h.e.h
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
m : ↥M
x✝ : S
⊢ m • x✝ = ↑m • x✝
tactic: rw [← Algebra.smul_def]
state_before: case h.e'_2.h.e.h
R : Type u_1
inst✝⁴ : CommRing R
M : Submonoid R
S : Type u_2
inst✝³ : CommRing S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommRing P
inst✝ : IsLocalization M S
m : ↥M
x✝ : S
⊢ m • x✝ = ↑m • x✝
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.Kernel.tendsto_densityProcess_limitProcess
File: Mathlib/Probability/Kernel/Disintegration/Density.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
⊢ ∀ᵐ (x : γ) ∂ν a,
    Tendsto (fun n => κ.densityProcess ν n a x s) atTop
      (𝓝 (Filtration.limitProcess (fun n x => κ.densityProcess ν n a x s) (countableFiltration γ) (ν a) x))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
n : ℕ
⊢ eLpNorm (fun x => κ.densityProcess ν n a x s) 1 (ν a) ≤ ↑((ν a) univ).toNNReal
tactic: refine Submartingale.ae_tendsto_limitProcess (martingale_densityProcess hκν a hs).submartingale
    (R := (ν a univ).toNNReal) (fun n ↦ ?_)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
n : ℕ
⊢ eLpNorm (fun x => κ.densityProcess ν n a x s) 1 (ν a) ≤ ↑((ν a) univ).toNNReal
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
n : ℕ
⊢ (ν a) univ = ↑((ν a) univ).toNNReal
tactic: refine (eLpNorm_densityProcess_le hκν n a s).trans_eq ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
n : ℕ
⊢ (ν a) univ = ↑((ν a) univ).toNNReal
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
n : ℕ
⊢ (ν a) univ ≠ ⊤
tactic: rw [ENNReal.coe_toNNReal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
a : α
s : Set β
hs : MeasurableSet s
n : ℕ
⊢ (ν a) univ ≠ ⊤
state_after: no goals
tactic: exact measure_ne_top _ _
Theorem: RingCat.Colimits.cocone_naturality
File: Mathlib/Algebra/Category/Ring/Colimits.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ RingCat
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ coconeMorphism F j' = coconeMorphism F j
state_after: case w
J : Type v
inst✝ : SmallCategory J
F : J ⥤ RingCat
j j' : J
f : j ⟶ j'
x✝ : (forget RingCat).obj (F.obj j)
⊢ (F.map f ≫ coconeMorphism F j') x✝ = (coconeMorphism F j) x✝
tactic: ext
state_before: case w
J : Type v
inst✝ : SmallCategory J
F : J ⥤ RingCat
j j' : J
f : j ⟶ j'
x✝ : (forget RingCat).obj (F.obj j)
⊢ (F.map f ≫ coconeMorphism F j') x✝ = (coconeMorphism F j) x✝
state_after: case w.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ RingCat
j j' : J
f : j ⟶ j'
x✝ : (forget RingCat).obj (F.obj j)
⊢ Setoid.r (Prequotient.of j' ((F.map f) x✝)) (Prequotient.of j x✝)
tactic: apply Quot.sound
state_before: case w.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ RingCat
j j' : J
f : j ⟶ j'
x✝ : (forget RingCat).obj (F.obj j)
⊢ Setoid.r (Prequotient.of j' ((F.map f) x✝)) (Prequotient.of j x✝)
state_after: no goals
tactic: apply Relation.map
Theorem: Polynomial.coe_eq_zero_iff
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
φ ψ : R[X]
⊢ ↑φ = 0 ↔ φ = 0
state_after: no goals
tactic: rw [← coe_zero, coe_inj]
Theorem: MeasurableSet.map_coe_volume
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
inst✝ : MeasureSpace α
s✝ t s : Set α
hs : MeasurableSet s
⊢ Measure.map Subtype.val volume = volume.restrict s
state_after: no goals
tactic: rw [volume_set_coe_def, (MeasurableEmbedding.subtype_coe hs).map_comap volume, Subtype.range_coe]