ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Dial.tensorHom_F
File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj (X₁.tensorObj Y₁).rel ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tensorObj Y₂).tgt))).obj (X₂.tensorObj Y₂).rel
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₁.rel) ⊓
      (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₁.rel) ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₂.rel) ⊓
      (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₂.rel)
tactic: simp only [tensorObj, Subobject.inf_pullback]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₁.rel) ⊓
      (Subobject.pullback π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₁.rel) ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₁ π₁)).obj X₂.rel) ⊓
      (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)))).obj
        ((Subobject.pullback (prod.map π₂ π₂)).obj Y₂.rel)
state_after: case h₁
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback (π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F)) ≫ prod.map π₁ π₁)).obj X₁.rel ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)) ≫ prod.map π₁ π₁)).obj X₂.rel

case h₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X₁ X₂ Y₁ Y₂ : Dial C
f : X₁ ⟶ X₂
g : Y₁ ⟶ Y₂
⊢ (Subobject.pullback (π(π₁, π(prod.map π₁ π₁ ≫ f.F, prod.map π₂ π₂ ≫ g.F)) ≫ prod.map π₂ π₂)).obj Y₁.rel ≤
    (Subobject.pullback (prod.map (prod.map f.f g.f) (𝟙 (X₂.tgt ⨯ Y₂.tgt)) ≫ prod.map π₂ π₂)).obj Y₂.rel
tactic: apply inf_le_inf <;> rw [← Subobject.pullback_comp, ← Subobject.pullback_comp]
Theorem: smul_unitBall_of_pos
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε r : ℝ
hr : 0 < r
⊢ r • ball 0 1 = ball 0 r
state_after: no goals
tactic: rw [smul_unitBall hr.ne', Real.norm_of_nonneg hr.le]
Theorem: CauSeq.Completion.ofRat_inv
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : β
⊢ const abv x⁻¹ = if h : (const abv x).LimZero then 0 else (const abv x).inv h
state_after: no goals
tactic: split_ifs with h <;>
    [simp only [const_limZero.1 h, GroupWithZero.inv_zero, const_zero]; rfl]
Theorem: Finsupp.embDomain_eq_mapDomain
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
⊢ embDomain f v = mapDomain (⇑f) v
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : β
⊢ (embDomain f v) a = (mapDomain (⇑f) v) a
tactic: ext a
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : β
⊢ (embDomain f v) a = (mapDomain (⇑f) v) a
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : β
h : a ∈ Set.range ⇑f
⊢ (embDomain f v) a = (mapDomain (⇑f) v) a

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddCommMonoid M
v✝ v₁ v₂ : α →₀ M
f : α ↪ β
v : α →₀ M
a : β
h : a ∉ Set.range ⇑f
⊢ (embDomain f v) a = (mapDomain (⇑f) v) a
tactic: by_cases h : a ∈ Set.range f
Theorem: MonCat.Colimits.cocone_naturality
File: Mathlib/Algebra/Category/MonCat/Colimits.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ MonCat
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 ⥤ MonCat
j j' : J
f : j ⟶ j'
x✝ : ↑(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 ⥤ MonCat
j j' : J
f : j ⟶ j'
x✝ : ↑(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 ⥤ MonCat
j j' : J
f : j ⟶ j'
x✝ : ↑(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 ⥤ MonCat
j j' : J
f : j ⟶ j'
x✝ : ↑(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: Ordinal.enum_zero_le
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
h0 : 0 < type r
a : α
⊢ ¬r a (enum r 0 h0)
state_after: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
h0 : 0 < type r
a : α
⊢ 0 ≤ typein r a
tactic: rw [← enum_typein r a, enum_le_enum r]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
h0 : 0 < type r
a : α
⊢ 0 ≤ typein r a
state_after: no goals
tactic: apply Ordinal.zero_le
Theorem: RingHom.toMonoidWithZeroHom_eq_coe
File: Mathlib/Algebra/Ring/Hom/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
x✝¹ : NonAssocSemiring α
x✝ : NonAssocSemiring β
f : α →+* β
⊢ ⇑f.toMonoidWithZeroHom = ⇑f
state_after: no goals
tactic: rfl
Theorem: Set.Finite.toFinset_image2
File: Mathlib/Data/Finset/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝ : DecidableEq γ
s : Set α
t : Set β
f : α → β → γ
hs : s.Finite
ht : t.Finite
hf : optParam (image2 f s t).Finite ⋯
⊢ ↑(Finite.toFinset hf) = ↑(image₂ f hs.toFinset ht.toFinset)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Bicategory.triangle_assoc_comp_left_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ f ◁ (λ_ g).inv ≫ (α_ f (𝟙 b) g).inv = (ρ_ f).inv ▷ g
state_after: no goals
tactic: simp [← cancel_mono ((ρ_ f).hom ▷ g)]
Theorem: WithBot.coe_le_coe
File: Mathlib/Order/WithBot.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
⊢ ↑a ≤ ↑b ↔ a ≤ b
state_after: no goals
tactic: simp [LE.le]
Theorem: Affine.Simplex.orthogonalProjection_circumcenter
File: Mathlib/Geometry/Euclidean/Circumcenter.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P n
fs : Finset (Fin (n + 1))
m : ℕ
h : fs.card = m + 1
⊢ ∃ r, ∀ (i : Fin (m + 1)), dist ((s.face h).points i) s.circumcenter = r
state_after: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P n
fs : Finset (Fin (n + 1))
m : ℕ
h : fs.card = m + 1
⊢ ∀ (i : Fin (m + 1)), dist ((s.face h).points i) s.circumcenter = s.circumradius
tactic: use s.circumradius
state_before: case h
V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
n : ℕ
s : Simplex ℝ P n
fs : Finset (Fin (n + 1))
m : ℕ
h : fs.card = m + 1
⊢ ∀ (i : Fin (m + 1)), dist ((s.face h).points i) s.circumcenter = s.circumradius
state_after: no goals
tactic: simp [face_points]
Theorem: Action.mkIso_inv_hom
File: Mathlib/RepresentationTheory/Action/Basic.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
M N : Action V G
f : M.V ≅ N.V
comm : autoParam (∀ (g : ↑G), M.ρ g ≫ f.hom = f.hom ≫ N.ρ g) _auto✝
g : ↑G
⊢ N.ρ g ≫ f.inv = f.inv ≫ M.ρ g
state_after: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
M N : Action V G
f : M.V ≅ N.V
comm : autoParam (∀ (g : ↑G), M.ρ g ≫ f.hom = f.hom ≫ N.ρ g) _auto✝
g : ↑G
w : (M.ρ g ≫ f.hom) ≫ f.inv = (f.hom ≫ N.ρ g) ≫ f.inv
⊢ N.ρ g ≫ f.inv = f.inv ≫ M.ρ g
tactic: have w := comm g =≫ f.inv
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
M N : Action V G
f : M.V ≅ N.V
comm : autoParam (∀ (g : ↑G), M.ρ g ≫ f.hom = f.hom ≫ N.ρ g) _auto✝
g : ↑G
w : (M.ρ g ≫ f.hom) ≫ f.inv = (f.hom ≫ N.ρ g) ≫ f.inv
⊢ N.ρ g ≫ f.inv = f.inv ≫ M.ρ g
state_after: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
M N : Action V G
f : M.V ≅ N.V
comm : autoParam (∀ (g : ↑G), M.ρ g ≫ f.hom = f.hom ≫ N.ρ g) _auto✝
g : ↑G
w : M.ρ g = f.hom ≫ N.ρ g ≫ f.inv
⊢ N.ρ g ≫ f.inv = f.inv ≫ M.ρ g
tactic: simp at w
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
M N : Action V G
f : M.V ≅ N.V
comm : autoParam (∀ (g : ↑G), M.ρ g ≫ f.hom = f.hom ≫ N.ρ g) _auto✝
g : ↑G
w : M.ρ g = f.hom ≫ N.ρ g ≫ f.inv
⊢ N.ρ g ≫ f.inv = f.inv ≫ M.ρ g
state_after: no goals
tactic: simp [w]
Theorem: Finset.prod_ite_mem
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s t : Finset α
f : α → β
⊢ (∏ i ∈ s, if i ∈ t then f i else 1) = ∏ i ∈ s ∩ t, f i
state_after: no goals
tactic: rw [← Finset.prod_filter, Finset.filter_mem_eq_inter]
Theorem: Algebra.Generators.toComp_val
File: Mathlib/RingTheory/Generators.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝²⁹ : CommRing R
inst✝²⁸ : CommRing S
inst✝²⁷ : Algebra R S
P✝ : Generators R S
R' : Type ?u.405421
S' : Type ?u.405424
inst✝²⁶ : CommRing R'
inst✝²⁵ : CommRing S'
inst✝²⁴ : Algebra R' S'
P' : Generators R' S'
inst✝²³ : Algebra R R'
inst✝²² : Algebra S S'
inst✝²¹ : Algebra R S'
inst✝²⁰ : IsScalarTower R R' S'
inst✝¹⁹ : IsScalarTower R S S'
R'' : Type ?u.407855
S'' : Type ?u.407858
inst✝¹⁸ : CommRing R''
inst✝¹⁷ : CommRing S''
inst✝¹⁶ : Algebra R'' S''
P'' : Generators R'' S''
inst✝¹⁵ : Algebra R R''
inst✝¹⁴ : Algebra S S''
inst✝¹³ : Algebra R S''
inst✝¹² : IsScalarTower R R'' S''
inst✝¹¹ : IsScalarTower R S S''
inst✝¹⁰ : Algebra R' R''
inst✝⁹ : Algebra S' S''
inst✝⁸ : Algebra R' S''
inst✝⁷ : IsScalarTower R' R'' S''
inst✝⁶ : IsScalarTower R' S' S''
inst✝⁵ : IsScalarTower R R' R''
inst✝⁴ : IsScalarTower S S' S''
T : Type ?u.413715
inst✝³ : CommRing T
inst✝² : Algebra R T
inst✝¹ : Algebra S T
inst✝ : IsScalarTower R S T
Q : Generators S T
P : Generators R S
i : P.vars
⊢ (aeval (Q.comp P).val) ((fun i => X (Sum.inr i)) i) = (algebraMap S T) (P.val i)
state_after: no goals
tactic: simp
Theorem: Polynomial.ofFinsupp_eq_zero
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
a : R[ℕ]
⊢ { toFinsupp := a } = 0 ↔ a = 0
state_after: no goals
tactic: rw [← ofFinsupp_zero, ofFinsupp_inj]
Theorem: normalize_coe_units
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
u : αˣ
⊢ normalize ↑u = 1
state_after: no goals
tactic: simp
Theorem: MeasureTheory.eLpNormEssSup_piecewise
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ eLpNormEssSup (s.piecewise f g) μ = max (eLpNormEssSup f (μ.restrict s)) (eLpNormEssSup g (μ.restrict sᶜ))
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ essSup (fun x => ↑‖s.piecewise f g x‖₊) μ = essSup (s.piecewise (fun x => ↑‖f x‖₊) fun x => ↑‖g x‖₊) μ
tactic: simp only [eLpNormEssSup, ← ENNReal.essSup_piecewise hs]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
⊢ essSup (fun x => ↑‖s.piecewise f g x‖₊) μ = essSup (s.piecewise (fun x => ↑‖f x‖₊) fun x => ↑‖g x‖₊) μ
state_after: case e_f.h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
x : α
⊢ ↑‖s.piecewise f g x‖₊ = s.piecewise (fun x => ↑‖f x‖₊) (fun x => ↑‖g x‖₊) x
tactic: congr with x
state_before: case e_f.h
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
s : Set α
f g : α → E
inst✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
x : α
⊢ ↑‖s.piecewise f g x‖₊ = s.piecewise (fun x => ↑‖f x‖₊) (fun x => ↑‖g x‖₊) x
state_after: no goals
tactic: by_cases hx : x ∈ s <;> simp [hx]
Theorem: CstarRing.mul_star_self_ne_zero_iff
File: Mathlib/Analysis/CstarAlgebra/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
α : Type u_3
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ x * x⋆ ≠ 0 ↔ x ≠ 0
state_after: no goals
tactic: simp only [Ne, mul_star_self_eq_zero_iff]
Theorem: CategoryTheory.Functor.postcomp_map_heq
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
H : D ⥤ E
hx : F.obj X = G.obj X
hy : F.obj Y = G.obj Y
hmap : HEq (F.map f) (G.map f)
⊢ HEq ((F ⋙ H).map f) ((G ⋙ H).map f)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
H : D ⥤ E
hx : F.obj X = G.obj X
hy : F.obj Y = G.obj Y
hmap : HEq (F.map f) (G.map f)
⊢ HEq (H.map (F.map f)) (H.map (G.map f))
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F G : C ⥤ D
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
H : D ⥤ E
hx : F.obj X = G.obj X
hy : F.obj Y = G.obj Y
hmap : HEq (F.map f) (G.map f)
⊢ HEq (H.map (F.map f)) (H.map (G.map f))
state_after: no goals
tactic: congr
Theorem: ENNReal.toReal_iInf
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: ι : Sort u_1
f g : ι → ℝ≥0∞
a b c d : ℝ≥0∞
r p q : ℝ≥0
hf : ∀ (i : ι), f i ≠ ⊤
⊢ (iInf f).toReal = ⨅ i, (f i).toReal
state_after: no goals
tactic: simp only [ENNReal.toReal, toNNReal_iInf hf, NNReal.coe_iInf]
Theorem: CategoryTheory.Adjunction.map_restrictFullyFaithful_counit_app
File: Mathlib/CategoryTheory/Adjunction/Restrict.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : D
⊢ iD.map ((adj.restrictFullyFaithful hiC hiD comm1 comm2).counit.app X) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X)
state_after: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : D
⊢ iD.map
      (hiD.preimage
        (comm1.inv.app (R.obj X) ≫
          (adj.homEquiv (iC.obj (R.obj X)) (iD.obj X)).symm
              (𝟙 (iC.obj (R.obj X)) ≫ iC.map (𝟙 (R.obj X)) ≫ comm2.inv.app X) ≫
            𝟙 (iD.obj X))) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X)
tactic: dsimp [restrictFullyFaithful]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
C' : Type u₃
inst✝¹ : Category.{v₃, u₃} C'
D' : Type u₄
inst✝ : Category.{v₄, u₄} D'
iC : C ⥤ C'
iD : D ⥤ D'
L' : C' ⥤ D'
R' : D' ⥤ C'
adj : L' ⊣ R'
hiC : iC.FullyFaithful
hiD : iD.FullyFaithful
L : C ⥤ D
R : D ⥤ C
comm1 : iC ⋙ L' ≅ L ⋙ iD
comm2 : iD ⋙ R' ≅ R ⋙ iC
X : D
⊢ iD.map
      (hiD.preimage
        (comm1.inv.app (R.obj X) ≫
          (adj.homEquiv (iC.obj (R.obj X)) (iD.obj X)).symm
              (𝟙 (iC.obj (R.obj X)) ≫ iC.map (𝟙 (R.obj X)) ≫ comm2.inv.app X) ≫
            𝟙 (iD.obj X))) =
    comm1.inv.app (R.obj X) ≫ L'.map (comm2.inv.app X) ≫ adj.counit.app (iD.obj X)
state_after: no goals
tactic: simp
Theorem: MeasureTheory.integrableOn_univ
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
⊢ IntegrableOn f univ μ ↔ Integrable f μ
state_after: no goals
tactic: rw [IntegrableOn, Measure.restrict_univ]
Theorem: Even.zpow_pos_iff
File: Mathlib/Algebra/Order/Field/Power.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hn : Even n
h : n ≠ 0
⊢ 0 < a ^ n ↔ a ≠ 0
state_after: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
k : ℤ
h : k + k ≠ 0
⊢ 0 < a ^ (k + k) ↔ a ≠ 0
tactic: obtain ⟨k, rfl⟩ := hn
state_before: case intro
α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
k : ℤ
h : k + k ≠ 0
⊢ 0 < a ^ (k + k) ↔ a ≠ 0
state_after: no goals
tactic: rw [zpow_add' (by simp [em']), mul_self_pos, zpow_ne_zero_iff (by simpa using h)]
Theorem: OrthonormalBasis.orientation_adjustToOrientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ (e.adjustToOrientation x).toBasis.orientation = x
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ (e.toBasis.adjustToOrientation x).orientation = x
tactic: rw [e.toBasis_adjustToOrientation]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
⊢ (e.toBasis.adjustToOrientation x).orientation = x
state_after: no goals
tactic: exact e.toBasis.orientation_adjustToOrientation x
Theorem: MeasureTheory.Measure.haar_singleton
File: Mathlib/MeasureTheory/Group/Measure.lean

Proof steps:
state_before: 𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : TopologicalGroup G
inst✝ : BorelSpace G
g : G
⊢ μ {g} = μ {1}
state_after: case h.e'_2.h.e'_6
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : TopologicalGroup G
inst✝ : BorelSpace G
g : G
⊢ {g} = (fun h => g⁻¹ * h) ⁻¹' {1}
tactic: convert measure_preimage_mul μ g⁻¹ _
state_before: case h.e'_2.h.e'_6
𝕜 : Type u_1
G : Type u_2
H : Type u_3
inst✝⁶ : MeasurableSpace G
inst✝⁵ : MeasurableSpace H
inst✝⁴ : Group G
inst✝³ : TopologicalSpace G
μ : Measure G
inst✝² : μ.IsHaarMeasure
inst✝¹ : TopologicalGroup G
inst✝ : BorelSpace G
g : G
⊢ {g} = (fun h => g⁻¹ * h) ⁻¹' {1}
state_after: no goals
tactic: simp only [mul_one, preimage_mul_left_singleton, inv_inv]
Theorem: Nat.Partrec.Code.fixed_point
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: f : Code → Code
hf : Computable f
g : ℕ → ℕ → Part ℕ :=
  fun x y => do
    let b ← (ofNat Code x).eval x
    (ofNat Code b).eval y
this : Partrec₂ g
cg : Code
eg : cg.eval = fun n => (↑(decode n)).bind fun a => Part.map encode ((fun p => g p.1 p.2) a)
⊢ ∀ (a n : ℕ), cg.eval (Nat.pair a n) = Part.map encode (g a n)
state_after: no goals
tactic: simp [eg]
state_before: f : Code → Code
hf : Computable f
g : ℕ → ℕ → Part ℕ :=
  fun x y => do
    let b ← (ofNat Code x).eval x
    (ofNat Code b).eval y
this✝ : Partrec₂ g
cg : Code
eg : cg.eval = fun n => (↑(decode n)).bind fun a => Part.map encode ((fun p => g p.1 p.2) a)
eg' : ∀ (a n : ℕ), cg.eval (Nat.pair a n) = Part.map encode (g a n)
F : ℕ → Code := fun x => f (cg.curry x)
this : Computable F
cF : Code
eF : cF.eval = fun n => (↑(decode n)).bind fun a => Part.map encode (↑F a)
⊢ cF.eval (encode cF) = Part.some (encode (F (encode cF)))
state_after: no goals
tactic: simp [eF]
state_before: f : Code → Code
hf : Computable f
g : ℕ → ℕ → Part ℕ :=
  fun x y => do
    let b ← (ofNat Code x).eval x
    (ofNat Code b).eval y
this✝ : Partrec₂ g
cg : Code
eg : cg.eval = fun n => (↑(decode n)).bind fun a => Part.map encode ((fun p => g p.1 p.2) a)
eg' : ∀ (a n : ℕ), cg.eval (Nat.pair a n) = Part.map encode (g a n)
F : ℕ → Code := fun x => f (cg.curry x)
this : Computable F
cF : Code
eF : cF.eval = fun n => (↑(decode n)).bind fun a => Part.map encode (↑F a)
eF' : cF.eval (encode cF) = Part.some (encode (F (encode cF)))
n : ℕ
⊢ (f (cg.curry (encode cF))).eval n = (cg.curry (encode cF)).eval n
state_after: no goals
tactic: simp [g, eg', eF', Part.map_id']
Theorem: Metric.mem_closure_range_iff
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ
s : Set α
e : β → α
a : α
⊢ a ∈ closure (range e) ↔ ∀ ε > 0, ∃ k, dist a (e k) < ε
state_after: no goals
tactic: simp only [mem_closure_iff, exists_range_iff]