ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: IsAdjoinRoot.aequiv_self
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
⊢ h.aequiv h = AlgEquiv.refl
state_after: case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
a : S
⊢ (h.aequiv h) a = AlgEquiv.refl a
tactic: ext a
state_before: case h
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
a : S
⊢ (h.aequiv h) a = AlgEquiv.refl a
state_after: no goals
tactic: exact h.lift_self_apply a
Theorem: exists_associated_pow_of_mul_eq_pow'
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : IsBezout R
a b c : R
hab : IsCoprime a b
k : ℕ
h : a * b = c ^ k
⊢ ∃ d, Associated (d ^ k) a
state_after: no goals
tactic: classical
  letI := IsBezout.toGCDDomain R
  exact exists_associated_pow_of_mul_eq_pow ((gcd_isUnit_iff _ _).mpr hab) h
Theorem: SimpleGraph.Walk.notNilRec_cons
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
motive : {u w : V} → (p : G.Walk u w) → ¬p.Nil → Sort u_1
cons : {u v w : V} → (h : G.Adj u v) → (q : G.Walk v w) → motive (SimpleGraph.Walk.cons h q) ⋯
h' : G.Adj u v
q' : G.Walk v w
⊢ notNilRec (fun {u v w} => cons) (SimpleGraph.Walk.cons h' q') ⋯ = cons h' q'
state_after: no goals
tactic: rfl
Theorem: Ordinal.typein_one_out
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
x : (Quotient.out 1).α
⊢ typein (fun x x_1 => x < x_1) x = 0
state_after: no goals
tactic: rw [one_out_eq x, typein_enum]
Theorem: CategoryTheory.classifier_isSheaf
File: Mathlib/CategoryTheory/Sites/Closed.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
⊢ Presieve.IsSheaf J₁ (Functor.closedSieves J₁)
state_after: C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ J₁.sieves X
⊢ Presieve.IsSheafFor (Functor.closedSieves J₁) S.arrows
tactic: intro X S hS
state_before: C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ J₁.sieves X
⊢ Presieve.IsSheafFor (Functor.closedSieves J₁) S.arrows
state_after: C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ J₁.sieves X
⊢ Presieve.IsSeparatedFor (Functor.closedSieves J₁) S.arrows ∧
    ∀ (x : Presieve.FamilyOfElements (Functor.closedSieves J₁) S.arrows), x.Compatible → ∃ t, x.IsAmalgamation t
tactic: rw [← Presieve.isSeparatedFor_and_exists_isAmalgamation_iff_isSheafFor]
state_before: C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ J₁.sieves X
⊢ Presieve.IsSeparatedFor (Functor.closedSieves J₁) S.arrows ∧
    ∀ (x : Presieve.FamilyOfElements (Functor.closedSieves J₁) S.arrows), x.Compatible → ∃ t, x.IsAmalgamation t
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ J₁.sieves X
⊢ Presieve.IsSeparatedFor (Functor.closedSieves J₁) S.arrows

case refine_2
C : Type u
inst✝ : Category.{v, u} C
J₁ J₂ : GrothendieckTopology C
X : C
S : Sieve X
hS : S ∈ J₁.sieves X
⊢ ∀ (x : Presieve.FamilyOfElements (Functor.closedSieves J₁) S.arrows), x.Compatible → ∃ t, x.IsAmalgamation t
tactic: refine ⟨?_, ?_⟩
Theorem: Finset.weightedVSubOfPoint_vadd_eq_of_sum_eq_one
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i ∈ s, w i = 1
b₁ b₂ : P
⊢ (s.weightedVSubOfPoint p b₁) w +ᵥ b₁ = (s.weightedVSubOfPoint p b₂) w +ᵥ b₂
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i ∈ s, w i = 1
b₁ b₂ : P
⊢ b₁ -ᵥ b₂ + ∑ x ∈ s, (w x • (p x -ᵥ b₁) - w x • (p x -ᵥ b₂)) = 0
tactic: erw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply, ← @vsub_eq_zero_iff_eq V,
    vadd_vsub_assoc, vsub_vadd_eq_vsub_sub, ← add_sub_assoc, add_comm, add_sub_assoc, ←
    sum_sub_distrib]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i ∈ s, w i = 1
b₁ b₂ : P
⊢ b₁ -ᵥ b₂ + ∑ x ∈ s, w x • (b₂ -ᵥ b₁) = 0
state_after: no goals
tactic: rw [← sum_smul, h, one_smul, vsub_add_vsub_cancel, vsub_self]
Theorem: CategoryTheory.Comma.preLeft_map_right
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁷ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁶ : Category.{v₂, u₂} B
T : Type u₃
inst✝⁵ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝⁴ : Category.{?u.129256, u_1} A'
inst✝³ : Category.{?u.129260, u_2} B'
inst✝² : Category.{?u.129264, u_3} T'
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
F : C ⥤ A
L : A ⥤ T
R : B ⥤ T
X✝ Y✝ : Comma (F ⋙ L) R
f : X✝ ⟶ Y✝
⊢ L.map (F.map f.left) ≫ ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) Y✝).hom =
    ((fun X => { left := F.obj X.left, right := X.right, hom := X.hom }) X✝).hom ≫ R.map f.right
state_after: no goals
tactic: simpa using f.w
Theorem: MeasureTheory.Measure.restrict_restrict₀
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 α
hs : NullMeasurableSet s (μ.restrict t)
u : Set α
hu : MeasurableSet u
⊢ ((μ.restrict t).restrict s) u = (μ.restrict (s ∩ t)) u
state_after: no goals
tactic: simp only [Set.inter_assoc, restrict_apply hu,
      restrict_apply₀ (hu.nullMeasurableSet.inter hs)]
Theorem: LinearMap.isCoatom_ker_of_surjective
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
hf : Function.Surjective ⇑f
⊢ IsCoatom (ker f)
state_after: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
hf : Function.Surjective ⇑f
⊢ IsSimpleModule R (M ⧸ ker f)
tactic: rw [← isSimpleModule_iff_isCoatom]
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁶ : Ring R
inst✝⁵ : Ring S
M : Type u_4
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
m : Submodule R M
N : Type u_5
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : IsSimpleModule R N
f : M →ₗ[R] N
hf : Function.Surjective ⇑f
⊢ IsSimpleModule R (M ⧸ ker f)
state_after: no goals
tactic: exact IsSimpleModule.congr (f.quotKerEquivOfSurjective hf)
Theorem: YoungDiagram.transposeOrderIso_apply
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: x✝ : YoungDiagram
⊢ x✝.transpose.transpose = x✝
state_after: no goals
tactic: simp
state_before: x✝ : YoungDiagram
⊢ x✝.transpose.transpose = x✝
state_after: no goals
tactic: simp
state_before: ⊢ ∀ {a b : YoungDiagram},
    { toFun := transpose, invFun := transpose, left_inv := ⋯, right_inv := ⋯ } a ≤
        { toFun := transpose, invFun := transpose, left_inv := ⋯, right_inv := ⋯ } b ↔
      a ≤ b
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Equivalence.unop_counitIso
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
      (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X) =
    𝟙 (e.functor.unop.obj X)
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ (e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
        (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X)).op =
    (𝟙 (e.functor.unop.obj X)).op
tactic: apply Quiver.Hom.op_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ (e.functor.unop.map ((NatIso.unop e.unitIso).symm.hom.app X) ≫
        (NatIso.unop e.counitIso).symm.hom.app (e.functor.unop.obj X)).op =
    (𝟙 (e.functor.unop.obj X)).op
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.counitIso.inv.app (e.functor.obj (Opposite.op X)) ≫ e.functor.map (e.unitIso.inv.app (Opposite.op X)) =
    𝟙 (e.functor.obj (Opposite.op X))
tactic: dsimp
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : Cᵒᵖ ≌ Dᵒᵖ
X : C
⊢ e.counitIso.inv.app (e.functor.obj (Opposite.op X)) ≫ e.functor.map (e.unitIso.inv.app (Opposite.op X)) =
    𝟙 (e.functor.obj (Opposite.op X))
state_after: no goals
tactic: simp
Theorem: Finset.pairwiseDisjoint_range_singleton
File: Mathlib/Data/Finset/Pairwise.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
ι' : Type u_3
⊢ (Set.range singleton).PairwiseDisjoint id
state_after: case intro.intro
α : Type u_1
ι : Type u_2
ι' : Type u_3
a b : α
h : {a} ≠ {b}
⊢ (Disjoint on id) {a} {b}
tactic: rintro _ ⟨a, rfl⟩ _ ⟨b, rfl⟩ h
state_before: case intro.intro
α : Type u_1
ι : Type u_2
ι' : Type u_3
a b : α
h : {a} ≠ {b}
⊢ (Disjoint on id) {a} {b}
state_after: no goals
tactic: exact disjoint_singleton.2 (ne_of_apply_ne _ h)
Theorem: Finsupp.prod_embDomain
File: Mathlib/Algebra/BigOperators/Finsupp.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝¹ : Zero M
inst✝ : CommMonoid N
v : α →₀ M
f : α ↪ β
g : β → M → N
⊢ (embDomain f v).prod g = v.prod fun a b => g (f a) b
state_after: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝¹ : Zero M
inst✝ : CommMonoid N
v : α →₀ M
f : α ↪ β
g : β → M → N
⊢ ∏ x ∈ v.support, g (f x) ((embDomain f v) (f x)) = ∏ a ∈ v.support, g (f a) (v a)
tactic: rw [prod, prod, support_embDomain, Finset.prod_map]
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁴ : AddCommMonoid A
inst✝³ : AddCommMonoid B
inst✝² : AddCommMonoid C
t : ι → A → C
h0 : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H : Type u_13
R : Type u_14
S : Type u_15
inst✝¹ : Zero M
inst✝ : CommMonoid N
v : α →₀ M
f : α ↪ β
g : β → M → N
⊢ ∏ x ∈ v.support, g (f x) ((embDomain f v) (f x)) = ∏ a ∈ v.support, g (f a) (v a)
state_after: no goals
tactic: simp_rw [embDomain_apply]
Theorem: CategoryTheory.Square.map_X₃
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
sq : Square C
F : C ⥤ D
⊢ F.map sq.f₁₂ ≫ F.map sq.f₂₄ = F.map sq.f₁₃ ≫ F.map sq.f₃₄
state_after: no goals
tactic: simpa using F.congr_map sq.fac
Theorem: Comon_.Comon_ToMon_OpOp_obj'_one
File: Mathlib/CategoryTheory/Monoidal/Comon_.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ A.counit.op ▷ op A.X ≫ A.comul.op = (λ_ (op A.X)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ (λ_ A.X).inv.op = (λ_ (op A.X)).hom
tactic: rw [← op_whiskerRight, ← op_comp, counit_comul]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ (λ_ A.X).inv.op = (λ_ (op A.X)).hom
state_after: no goals
tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ op A.X ◁ A.counit.op ≫ A.comul.op = (ρ_ (op A.X)).hom
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ (ρ_ A.X).inv.op = (ρ_ (op A.X)).hom
tactic: rw [← op_whiskerLeft, ← op_comp, comul_counit]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ (ρ_ A.X).inv.op = (ρ_ (op A.X)).hom
state_after: no goals
tactic: rfl
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ A.comul.op ▷ op A.X ≫ A.comul.op = (α_ (op A.X) (op A.X) (op A.X)).hom ≫ op A.X ◁ A.comul.op ≫ A.comul.op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ (α_ A.X A.X A.X).inv.op ≫ (A.X ◁ A.comul).op ≫ A.comul.op = (α_ A.X A.X A.X).inv.op ≫ (A.comul ≫ A.X ◁ A.comul).op
tactic: rw [← op_inv_associator, ← op_whiskerRight, ← op_comp, ← op_whiskerLeft, ← op_comp,
      comul_assoc_flip, op_comp, op_comp_assoc]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
M A : Comon_ C
⊢ (α_ A.X A.X A.X).inv.op ≫ (A.X ◁ A.comul).op ≫ A.comul.op = (α_ A.X A.X A.X).inv.op ≫ (A.comul ≫ A.X ◁ A.comul).op
state_after: no goals
tactic: rfl
Theorem: Isometry.diam_range
File: Mathlib/Topology/MetricSpace/Isometry.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
⊢ Metric.diam (range f) = Metric.diam univ
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
⊢ Metric.diam (f '' univ) = Metric.diam univ
tactic: rw [← image_univ]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
f : α → β
hf : Isometry f
⊢ Metric.diam (f '' univ) = Metric.diam univ
state_after: no goals
tactic: exact hf.diam_image univ
Theorem: ProbabilityTheory.IsMeasurableRatCDF.stieltjesFunctionAux_eq
File: Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℚ
⊢ stieltjesFunctionAux f a ↑r = f a r
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℚ
⊢ ⨅ q, f a ↑q = ⨅ r_1, f a ↑r_1
tactic: rw [← hf.iInf_rat_gt_eq a r, IsMeasurableRatCDF.stieltjesFunctionAux]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℚ
⊢ ⨅ q, f a ↑q = ⨅ r_1, f a ↑r_1
state_after: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℚ
⊢ { q' // ↑r < ↑q' } ≃ ↑(Ioi r)

case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
inst✝ : MeasurableSpace α
f : α → ℚ → ℝ
hf : IsMeasurableRatCDF f
a : α
r : ℚ
⊢ ∀ (x : { q' // ↑r < ↑q' }), f a ↑(?refine_1 x) = f a ↑x
tactic: refine Equiv.iInf_congr ?_ ?_
Theorem: MeasurableSet.image_of_continuousOn_injOn
File: Mathlib/MeasureTheory/Constructions/Polish/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
ι : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
tβ : TopologicalSpace β
inst✝⁶ : T2Space β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace α
s : Set γ
f : γ → β
inst✝³ : OpensMeasurableSpace β
tγ : TopologicalSpace γ
inst✝² : PolishSpace γ
inst✝¹ : MeasurableSpace γ
inst✝ : BorelSpace γ
hs : MeasurableSet s
f_cont : ContinuousOn f s
f_inj : InjOn f s
⊢ MeasurableSet (f '' s)
state_after: case intro.intro.intro.intro
α✝ : Type u_1
ι : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
tβ : TopologicalSpace β
inst✝⁶ : T2Space β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace α
s : Set γ
f : γ → β
inst✝³ : OpensMeasurableSpace β
tγ : TopologicalSpace γ
inst✝² : PolishSpace γ
inst✝¹ : MeasurableSpace γ
inst✝ : BorelSpace γ
hs : MeasurableSet s
f_cont : ContinuousOn f s
f_inj : InjOn f s
t' : TopologicalSpace γ
t't : t' ≤ tγ
t'_polish : PolishSpace γ
s_closed : IsClosed s
right✝ : IsOpen s
⊢ MeasurableSet (f '' s)
tactic: obtain ⟨t', t't, t'_polish, s_closed, _⟩ :
      ∃ t' : TopologicalSpace γ, t' ≤ tγ ∧ @PolishSpace γ t' ∧ IsClosed[t'] s ∧ IsOpen[t'] s :=
    hs.isClopenable
state_before: case intro.intro.intro.intro
α✝ : Type u_1
ι : Type u_2
γ : Type u_3
α : Type u_4
β : Type u_5
tβ : TopologicalSpace β
inst✝⁶ : T2Space β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace α
s : Set γ
f : γ → β
inst✝³ : OpensMeasurableSpace β
tγ : TopologicalSpace γ
inst✝² : PolishSpace γ
inst✝¹ : MeasurableSpace γ
inst✝ : BorelSpace γ
hs : MeasurableSet s
f_cont : ContinuousOn f s
f_inj : InjOn f s
t' : TopologicalSpace γ
t't : t' ≤ tγ
t'_polish : PolishSpace γ
s_closed : IsClosed s
right✝ : IsOpen s
⊢ MeasurableSet (f '' s)
state_after: no goals
tactic: exact
    @IsClosed.measurableSet_image_of_continuousOn_injOn γ t' t'_polish β _ _ _ _ s s_closed f
      (f_cont.mono_dom t't) f_inj
Theorem: Fin.prod_univ_five
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ ∏ i : Fin 5, f i = f 0 * f 1 * f 2 * f 3 * f 4
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (last 4) = f 0 * f 1 * f 2 * f 3 * f 4
tactic: rw [prod_univ_castSucc, prod_univ_four]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 5 → β
⊢ f (castSucc 0) * f (castSucc 1) * f (castSucc 2) * f (castSucc 3) * f (last 4) = f 0 * f 1 * f 2 * f 3 * f 4
state_after: no goals
tactic: rfl
Theorem: TopologicalSemiring.continuousNeg_of_mul
File: Mathlib/Topology/Algebra/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝² : TopologicalSpace α
inst✝¹ : NonAssocRing α
inst✝ : ContinuousMul α
⊢ Continuous fun a => -a
state_after: no goals
tactic: simpa using (continuous_const.mul continuous_id : Continuous fun x : α => -1 * x)
Theorem: Filter.inf_prod
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
f₁ f₂ : Filter α
⊢ (f₁ ⊓ f₂) ×ˢ g = f₁ ×ˢ g ⊓ f₂ ×ˢ g
state_after: no goals
tactic: rw [prod_inf_prod, inf_idem]
Theorem: AlgebraicGeometry.RingedSpace.basicOpen_pow
File: Mathlib/Geometry/RingedSpace/Basic.lean

Proof steps:
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj (op U))
n : ℕ
h : 0 < n
⊢ X.basicOpen (f ^ n) = X.basicOpen f
state_after: case intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj (op U))
k : ℕ
h : 0 < k + Nat.succ 0
⊢ X.basicOpen (f ^ (k + Nat.succ 0)) = X.basicOpen f
tactic: obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le' h
state_before: case intro
X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
f : ↑(X.presheaf.obj (op U))
k : ℕ
h : 0 < k + Nat.succ 0
⊢ X.basicOpen (f ^ (k + Nat.succ 0)) = X.basicOpen f
state_after: no goals
tactic: induction k with
  | zero => simp
  | succ n hn => rw [pow_add]; simp_all
Theorem: iterateFrobenius_zero_apply
File: Mathlib/Algebra/CharP/ExpChar.lean

Proof steps:
state_before: R : Type u
inst✝³ : CommSemiring R
S : Type u_1
inst✝² : CommSemiring S
f : R →* S
g : R →+* S
p m n : ℕ
inst✝¹ : ExpChar R p
inst✝ : ExpChar S p
x y : R
⊢ (iterateFrobenius R p 0) x = x
state_after: no goals
tactic: rw [iterateFrobenius_def, pow_zero, pow_one]
Theorem: CategoryTheory.shiftFunctorAdd_add_zero_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (𝟭 C).obj ((shiftFunctor C a).obj X) = (shiftFunctor C (a + 0)).obj X
state_after: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctor C a).obj X = (shiftFunctor C (a + 0)).obj X
tactic: dsimp
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctor C a).obj X = (shiftFunctor C (a + 0)).obj X
state_after: no goals
tactic: rw [add_zero]
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddMonoid A
inst✝ : HasShift C A
a : A
X : C
⊢ (shiftFunctorAdd C a 0).inv.app X = (shiftFunctorZero C A).hom.app ((shiftFunctor C a).obj X) ≫ eqToHom ⋯
state_after: no goals
tactic: simp [← shiftFunctorAdd'_add_zero_inv_app, shiftFunctorAdd']
Theorem: SeparationQuotient.uniformContinuous_dom₂
File: Mathlib/Topology/UniformSpace/Separation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : SeparationQuotient α × SeparationQuotient β → γ
⊢ UniformContinuous f ↔ UniformContinuous fun p => f (mk p.1, mk p.2)
state_after: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : SeparationQuotient α × SeparationQuotient β → γ
⊢ Tendsto
      (((fun x => (f x.1, f x.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ∘ fun p =>
        (Prod.map mk mk p.1, Prod.map mk mk p.2))
      (𝓤 α ×ˢ 𝓤 β) (𝓤 γ) ↔
    Tendsto ((fun x => (f (mk x.1.1, mk x.1.2), f (mk x.2.1, mk x.2.2))) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2))
      (𝓤 α ×ˢ 𝓤 β) (𝓤 γ)
tactic: simp only [UniformContinuous, uniformity_prod_eq_prod, uniformity_eq, prod_map_map_eq,
    tendsto_map'_iff]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : SeparationQuotient α × SeparationQuotient β → γ
⊢ Tendsto
      (((fun x => (f x.1, f x.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ∘ fun p =>
        (Prod.map mk mk p.1, Prod.map mk mk p.2))
      (𝓤 α ×ˢ 𝓤 β) (𝓤 γ) ↔
    Tendsto ((fun x => (f (mk x.1.1, mk x.1.2), f (mk x.2.1, mk x.2.2))) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2))
      (𝓤 α ×ˢ 𝓤 β) (𝓤 γ)
state_after: no goals
tactic: rfl