1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: one_lt_tprod
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

tactic: rw [← tprod_one]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ 1 < ∏' (i : ι), g i
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ ∏' (x : ?m.53617), 1 < ∏' (i : ι), g i

ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ Type ?u.53614

tactic: exact tprod_lt_tprod hg hi multipliable_one hsum
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ ∏' (x : ?m.53617), 1 < ∏' (i : ι), g i

ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝³ : OrderedCommGroup α
inst✝² : TopologicalSpace α
inst✝¹ : TopologicalGroup α
inst✝ : OrderClosedTopology α
f g : ι → α
a₁ a₂ : α
i✝ : ι
hsum : Multipliable g
hg : ∀ (i : ι), 1 ≤ g i
i : ι
hi : 1 < g i
⊢ Type ?u.53614
state_after: no goals
Theorem: AlgebraicGeometry.IsAffineOpen.isQuasiSeparated
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean

tactic: rw [isQuasiSeparated_iff_quasiSeparatedSpace]
state_before: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
⊢ IsQuasiSeparated ↑U
state_after: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
⊢ QuasiSeparatedSpace ↑↑U

case hs
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
⊢ IsOpen ↑U

tactic: exacts [@AlgebraicGeometry.quasiSeparatedSpace_of_isAffine _ hU, U.isOpen]
state_before: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
⊢ QuasiSeparatedSpace ↑↑U

case hs
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
⊢ IsOpen ↑U
state_after: no goals
Theorem: FdRep.average_char_eq_finrank_invariants
File: Mathlib/RepresentationTheory/Character.lean

tactic: erw [← (isProj_averageMap V.ρ).trace]
state_before: k : Type u
inst✝³ : Field k
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
inst✝ : Invertible ↑(Fintype.card G)
V : FdRep k G
⊢ ⅟↑(Fintype.card G) • ∑ g : G, V.character g = ↑(finrank k ↥(invariants V.ρ))
state_after: k : Type u
inst✝³ : Field k
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
inst✝ : Invertible ↑(Fintype.card G)
V : FdRep k G
⊢ ⅟↑(Fintype.card G) • ∑ g : G, V.character g = (trace k (CoeSort.coe V)) (averageMap V.ρ)

tactic: simp [character, GroupAlgebra.average, _root_.map_sum]
state_before: k : Type u
inst✝³ : Field k
G : Type u
inst✝² : Group G
inst✝¹ : Fintype G
inst✝ : Invertible ↑(Fintype.card G)
V : FdRep k G
⊢ ⅟↑(Fintype.card G) • ∑ g : G, V.character g = (trace k (CoeSort.coe V)) (averageMap V.ρ)
state_after: no goals
Theorem: symmDiff_hnot_self
File: Mathlib/Order/SymmDiff.lean

tactic: rw [symmDiff_comm, hnot_symmDiff_self]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : CoheytingAlgebra α
a : α
⊢ a ∆ (￢a) = ⊤
state_after: no goals
Theorem: le_self_pow
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: simpa only [pow_one] using pow_le_pow_right ha <| Nat.pos_iff_ne_zero.2 h
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
n m : ℕ
ha : 1 ≤ a
h : m ≠ 0
⊢ a ≤ a ^ m
state_after: no goals
Theorem: Substring.Valid.foldr
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [h.foldr, h.toString]
state_before: α : Type u_1
f : Char → α → α
init : α
x✝ : Substring
h✝ : x✝.Valid
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ Substring.foldr f init x✝ = List.foldr f init x✝.toString.data
state_after: no goals
Theorem: contDiff_succ_iff_hasFDerivAt
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: simp only [← contDiffOn_univ, ← hasFDerivWithinAt_univ,
  contDiffOn_succ_iff_hasFDerivWithin uniqueDiffOn_univ, Set.mem_univ, forall_true_left]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f ↔ ∃ f', ContDiff 𝕜 (↑n) f' ∧ ∀ (x : E), HasFDerivAt f (f' x) x
state_after: no goals
Theorem: Real.exp_neg_one_gt_d9
File: Mathlib/Data/Complex/ExponentialBounds.lean

tactic: rw [exp_neg, lt_inv _ (exp_pos _)]
state_before: ⊢ 0.36787944116 < rexp (-1)
state_after: ⊢ rexp 1 < 0.36787944116⁻¹


⊢ 0 < 0.36787944116

tactic: refine lt_of_le_of_lt (sub_le_iff_le_add.1 (abs_sub_le_iff.1 exp_one_near_10).1) ?_
state_before: ⊢ rexp 1 < 0.36787944116⁻¹
state_after: ⊢ 1 / 10 ^ 10 + 2244083 / 825552 < 0.36787944116⁻¹

tactic: norm_num
state_before: ⊢ 1 / 10 ^ 10 + 2244083 / 825552 < 0.36787944116⁻¹
state_after: no goals

tactic: norm_num
state_before: ⊢ 0 < 0.36787944116
state_after: no goals
Theorem: List.IsRotated.refl
File: Mathlib/Data/List/Rotate.lean

tactic: simp
state_before: α : Type u
l✝ l' l : List α
⊢ l.rotate 0 = l
state_after: no goals
Theorem: Finset.Ioc_eq_empty_iff
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [← coe_eq_empty, coe_Ioc, Set.Ioc_eq_empty_iff]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Preorder α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ Ioc a b = ∅ ↔ ¬a < b
state_after: no goals
Theorem: Polynomial.rootSet_prod
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: classical
simp only [rootSet, aroots, ← Finset.mem_coe]
rw [Polynomial.map_prod, roots_prod, Finset.bind_toFinset, s.val_toFinset, Finset.coe_biUnion]
rwa [← Polynomial.map_prod, Ne, map_eq_zero]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : s.prod f ≠ 0
⊢ (s.prod f).rootSet S = ⋃ i ∈ s, (f i).rootSet S
state_after: no goals

tactic: simp only [rootSet, aroots, ← Finset.mem_coe]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : s.prod f ≠ 0
⊢ (s.prod f).rootSet S = ⋃ i ∈ s, (f i).rootSet S
state_after: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : s.prod f ≠ 0
⊢ ↑(map (algebraMap R S) (s.prod f)).roots.toFinset = ⋃ i ∈ ↑s, ↑(map (algebraMap R S) (f i)).roots.toFinset

tactic: rw [Polynomial.map_prod, roots_prod, Finset.bind_toFinset, s.val_toFinset, Finset.coe_biUnion]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : s.prod f ≠ 0
⊢ ↑(map (algebraMap R S) (s.prod f)).roots.toFinset = ⋃ i ∈ ↑s, ↑(map (algebraMap R S) (f i)).roots.toFinset
state_after: case a
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : s.prod f ≠ 0
⊢ ∏ i ∈ s, map (algebraMap R S) (f i) ≠ 0

tactic: rwa [← Polynomial.map_prod, Ne, map_eq_zero]
state_before: case a
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
ι : Type u_1
f : ι → R[X]
s : Finset ι
h : s.prod f ≠ 0
⊢ ∏ i ∈ s, map (algebraMap R S) (f i) ≠ 0
state_after: no goals
Theorem: Real.toNNReal_mul_nnnorm
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x y : ℝ
hx : 0 ≤ x
⊢ x.toNNReal * ‖y‖₊ = ‖x * y‖₊
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x y : ℝ
hx : 0 ≤ x
⊢ ↑(x.toNNReal * ‖y‖₊) = ↑‖x * y‖₊

tactic: simp only [NNReal.coe_mul, nnnorm_mul, coe_nnnorm, Real.toNNReal_of_nonneg, norm_of_nonneg, hx,
  NNReal.coe_mk]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
x y : ℝ
hx : 0 ≤ x
⊢ ↑(x.toNNReal * ‖y‖₊) = ↑‖x * y‖₊
state_after: no goals
Theorem: CategoryTheory.Adjunction.CoreHomEquiv.homEquiv_naturality_right_symm
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

tactic: rw [Equiv.symm_apply_eq]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ (adj.homEquiv X Y').symm (f ≫ G.map g) = (adj.homEquiv X Y).symm f ≫ g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = (adj.homEquiv X Y') ((adj.homEquiv X Y).symm f ≫ g)

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G : D ⥤ C
adj : CoreHomEquiv F G
X' X : C
Y Y' : D
f : X ⟶ G.obj Y
g : Y ⟶ Y'
⊢ f ≫ G.map g = (adj.homEquiv X Y') ((adj.homEquiv X Y).symm f ≫ g)
state_after: no goals
Theorem: Rat.toNNRat_inv
File: Mathlib/Data/NNRat/Lemmas.lean

tactic: obtain hq | hq := le_total q 0
state_before: p q✝ q : ℚ
⊢ q⁻¹.toNNRat = q.toNNRat⁻¹
state_after: case inl
p q✝ q : ℚ
hq : q ≤ 0
⊢ q⁻¹.toNNRat = q.toNNRat⁻¹

case inr
p q✝ q : ℚ
hq : 0 ≤ q
⊢ q⁻¹.toNNRat = q.toNNRat⁻¹

tactic: rw [toNNRat_eq_zero.mpr hq, inv_zero, toNNRat_eq_zero.mpr (inv_nonpos.mpr hq)]
state_before: case inl
p q✝ q : ℚ
hq : q ≤ 0
⊢ q⁻¹.toNNRat = q.toNNRat⁻¹
state_after: no goals

tactic: nth_rw 1 [← Rat.coe_toNNRat q hq]
state_before: case inr
p q✝ q : ℚ
hq : 0 ≤ q
⊢ q⁻¹.toNNRat = q.toNNRat⁻¹
state_after: case inr
p q✝ q : ℚ
hq : 0 ≤ q
⊢ (↑q.toNNRat)⁻¹.toNNRat = q.toNNRat⁻¹

tactic: rw [← coe_inv, toNNRat_coe]
state_before: case inr
p q✝ q : ℚ
hq : 0 ≤ q
⊢ (↑q.toNNRat)⁻¹.toNNRat = q.toNNRat⁻¹
state_after: no goals
Theorem: Cardinal.mk_equiv_eq_arrow_of_lift_eq
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: obtain ⟨e⟩ := lift_mk_eq'.mp leq
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
⊢ #(α ≃ β') = #(α → β')

tactic: have e₁ := lift_mk_eq'.mpr ⟨.equivCongr (.refl α) e⟩
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
⊢ #(α ≃ β') = #(α → β')

tactic: have e₂ := lift_mk_eq'.mpr ⟨.arrowCongr (.refl α) e⟩
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = lift.{u, max u v} #(α → β')
⊢ #(α ≃ β') = #(α → β')

tactic: rw [lift_id'.{u,v}] at e₁ e₂
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = lift.{u, max u v} #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = lift.{u, max u v} #(α → β')
⊢ #(α ≃ β') = #(α → β')
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = #(α → β')
⊢ #(α ≃ β') = #(α → β')

tactic: rw [← e₁, ← e₂, lift_inj, mk_perm_eq_self_power, power_def]
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
e : α ≃ β'
e₁ : lift.{max u v, u} #(α ≃ α) = #(α ≃ β')
e₂ : lift.{max u v, u} #(α → α) = #(α → β')
⊢ #(α ≃ β') = #(α → β')
state_after: no goals
Theorem: Prod.comul_comp_inl
File: Mathlib/RingTheory/Coalgebra/Basic.lean

tactic: ext
state_before: R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
⊢ comul ∘ₗ inl R A B = TensorProduct.map (inl R A B) (inl R A B) ∘ₗ comul
state_after: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : A
⊢ (comul ∘ₗ inl R A B) x✝ = (TensorProduct.map (inl R A B) (inl R A B) ∘ₗ comul) x✝

tactic: simp
state_before: case h
R : Type u
A : Type v
B : Type w
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : Module R A
inst✝² : Module R B
inst✝¹ : Coalgebra R A
inst✝ : Coalgebra R B
x✝ : A
⊢ (comul ∘ₗ inl R A B) x✝ = (TensorProduct.map (inl R A B) (inl R A B) ∘ₗ comul) x✝
state_after: no goals
Theorem: norm_deriv_le_of_lip'
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simpa [norm_deriv_eq_norm_fderiv] using norm_fderiv_le_of_lip' 𝕜 hC₀ hlip
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f✝ f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
f : 𝕜 → F
x₀ : 𝕜
C : ℝ
hC₀ : 0 ≤ C
hlip : ∀ᶠ (x : 𝕜) in 𝓝 x₀, ‖f x - f x₀‖ ≤ C * ‖x - x₀‖
⊢ ‖deriv f x₀‖ ≤ C
state_after: no goals
Theorem: lt_one_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa using lt_inv ha hb
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
hb : 0 < b
⊢ a < 1 / b ↔ b < 1 / a
state_after: no goals
Theorem: ProbabilityTheory.kernel.withDensity_apply
File: Mathlib/Probability/Kernel/WithDensity.lean

tactic: classical
rw [withDensity, dif_pos hf]
rfl
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
f : α → β → ℝ≥0∞
κ : ↥(kernel α β)
inst✝ : IsSFiniteKernel κ
hf : Measurable (Function.uncurry f)
a : α
⊢ (withDensity κ f) a = (κ a).withDensity (f a)
state_after: no goals

tactic: rw [withDensity, dif_pos hf]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
f : α → β → ℝ≥0∞
κ : ↥(kernel α β)
inst✝ : IsSFiniteKernel κ
hf : Measurable (Function.uncurry f)
a : α
⊢ (withDensity κ f) a = (κ a).withDensity (f a)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
f : α → β → ℝ≥0∞
κ : ↥(kernel α β)
inst✝ : IsSFiniteKernel κ
hf : Measurable (Function.uncurry f)
a : α
⊢ ⟨fun a => (κ a).withDensity (f a), ⋯⟩ a = (κ a).withDensity (f a)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
f : α → β → ℝ≥0∞
κ : ↥(kernel α β)
inst✝ : IsSFiniteKernel κ
hf : Measurable (Function.uncurry f)
a : α
⊢ ⟨fun a => (κ a).withDensity (f a), ⋯⟩ a = (κ a).withDensity (f a)
state_after: no goals
Theorem: MeasureTheory.AEEqFun.compQuasiMeasurePreserving_eq_mk
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: rw [← compQuasiMeasurePreserving_mk g.aestronglyMeasurable hf, mk_coeFn]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : MeasurableSpace α
μ ν✝ : Measure α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : TopologicalSpace δ
inst✝ : MeasurableSpace β
ν : Measure β
f : α → β
g : β →ₘ[ν] γ
hf : QuasiMeasurePreserving f μ ν
⊢ g.compQuasiMeasurePreserving f hf = mk (↑g ∘ f) ⋯
state_after: no goals
Theorem: MeasureTheory.Measure.outerMeasure_le_iff
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simpa only [μ.trimmed] using OuterMeasure.le_trim_iff (m₂ := μ.1)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
m : OuterMeasure α
⊢ m ≤ μ.toOuterMeasure ↔ ∀ (s : Set α), MeasurableSet s → m s ≤ μ s
state_after: no goals
Theorem: CategoryTheory.Limits.kernelSubobjectMap_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

tactic: simp [kernelSubobjectMap]
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y Z : C
inst✝² : HasZeroMorphisms C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
sq : Arrow.mk f ⟶ Arrow.mk f'
⊢ kernelSubobjectMap sq ≫ (kernelSubobject f').arrow = (kernelSubobject f).arrow ≫ sq.left
state_after: no goals
Theorem: Batteries.RBNode.Stream.foldl_eq_foldl_toList
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: induction t generalizing init <;> simp [*, RBNode.foldl_eq_foldl_toList]
state_before: α : Type u_1
α✝ : Type u_2
f : α✝ → α → α✝
init : α✝
t : RBNode.Stream α
⊢ foldl f init t = List.foldl f init t.toList
state_after: no goals
Theorem: CategoryTheory.Cat.associator_hom_app
File: Mathlib/CategoryTheory/Category/Cat.lean

tactic: simp
state_before: B C D E : Cat
F : B ⟶ C
G : C ⟶ D
H : D ⟶ E
X : ↑B
⊢ ((F ≫ G) ≫ H).obj X = (F ≫ G ≫ H).obj X
state_after: no goals
Theorem: List.keys_kreplace
File: Mathlib/Data/List/Sigma.lean

tactic: rintro ⟨a₁, b₂⟩ ⟨a₂, b₂⟩
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
⊢ ∀ (a_1 b_1 : Sigma β), (b_1 ∈ if a = a_1.fst then some ⟨a, b⟩ else none) → a_1.fst = b_1.fst
state_after: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = ⟨a₁, b₂✝⟩.fst then some ⟨a, b⟩ else none) → ⟨a₁, b₂✝⟩.fst = ⟨a₂, b₂⟩.fst

tactic: dsimp
state_before: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = ⟨a₁, b₂✝⟩.fst then some ⟨a, b⟩ else none) → ⟨a₁, b₂✝⟩.fst = ⟨a₂, b₂⟩.fst
state_after: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = a₁ then some ⟨a, b⟩ else none) → a₁ = a₂

tactic: split_ifs with h <;> simp (config := { contextual := true }) [h]
state_before: case mk.mk
α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a₁ : α
b₂✝ : β a₁
a₂ : α
b₂ : β a₂
⊢ (⟨a₂, b₂⟩ ∈ if a = a₁ then some ⟨a, b⟩ else none) → a₁ = a₂
state_after: no goals
Theorem: ultrafilter_extend_extends
File: Mathlib/Topology/StoneCech.lean

tactic: letI : TopologicalSpace α := ⊥
state_before: α : Type u
γ : Type u_1
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
⊢ Ultrafilter.extend f ∘ pure = f
state_after: α : Type u
γ : Type u_1
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
this : TopologicalSpace α := ⊥
⊢ Ultrafilter.extend f ∘ pure = f

tactic: haveI : DiscreteTopology α := ⟨rfl⟩
state_before: α : Type u
γ : Type u_1
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
this : TopologicalSpace α := ⊥
⊢ Ultrafilter.extend f ∘ pure = f
state_after: α : Type u
γ : Type u_1
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
this✝ : TopologicalSpace α := ⊥
this : DiscreteTopology α
⊢ Ultrafilter.extend f ∘ pure = f

tactic: exact funext (denseInducing_pure.extend_eq continuous_of_discreteTopology)
state_before: α : Type u
γ : Type u_1
inst✝¹ : TopologicalSpace γ
inst✝ : T2Space γ
f : α → γ
this✝ : TopologicalSpace α := ⊥
this : DiscreteTopology α
⊢ Ultrafilter.extend f ∘ pure = f
state_after: no goals
Theorem: Nat.ofDigits_mod_eq_head!
File: Mathlib/Data/Nat/Digits.lean

tactic: induction l <;> simp [Nat.ofDigits, Int.ModEq]
state_before: n b : ℕ
l : List ℕ
⊢ ofDigits b l % b = l.head! % b
state_after: no goals
Theorem: untrop_sum_eq_sInf_image
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: rcases s.eq_empty_or_nonempty with (rfl | h)
state_before: R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → Tropical (WithTop R)
⊢ untrop (∑ i ∈ s, f i) = sInf (untrop ∘ f '' ↑s)
state_after: case inl
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
f : S → Tropical (WithTop R)
⊢ untrop (∑ i ∈ ∅, f i) = sInf (untrop ∘ f '' ↑∅)

case inr
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → Tropical (WithTop R)
h : s.Nonempty
⊢ untrop (∑ i ∈ s, f i) = sInf (untrop ∘ f '' ↑s)

tactic: simp only [Set.image_empty, coe_empty, sum_empty, WithTop.sInf_empty, untrop_zero]
state_before: case inl
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
f : S → Tropical (WithTop R)
⊢ untrop (∑ i ∈ ∅, f i) = sInf (untrop ∘ f '' ↑∅)
state_after: no goals

tactic: rw [← inf'_eq_csInf_image _ h, inf'_eq_inf, Finset.untrop_sum']
state_before: case inr
R : Type u_1
S : Type u_2
inst✝ : ConditionallyCompleteLinearOrder R
s : Finset S
f : S → Tropical (WithTop R)
h : s.Nonempty
⊢ untrop (∑ i ∈ s, f i) = sInf (untrop ∘ f '' ↑s)
state_after: no goals
Theorem: Ordinal.bsup_not_succ_of_ne_bsup
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← sup_eq_bsup] at *
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
hf : ∀ {i : Ordinal.{u}} (h : i < o), f i h ≠ o.bsup f
a : Ordinal.{max u v}
⊢ a < o.bsup f → succ a < o.bsup f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
hf : ∀ {i : Ordinal.{u}} (h : i < o), f i h ≠ sup (o.familyOfBFamily f)
a : Ordinal.{max u v}
⊢ a < sup (o.familyOfBFamily f) → succ a < sup (o.familyOfBFamily f)

tactic: exact sup_not_succ_of_ne_sup fun i => hf _
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}
hf : ∀ {i : Ordinal.{u}} (h : i < o), f i h ≠ sup (o.familyOfBFamily f)
a : Ordinal.{max u v}
⊢ a < sup (o.familyOfBFamily f) → succ a < sup (o.familyOfBFamily f)
state_after: no goals
Theorem: Set.Finite.interior_sInter
File: Mathlib/Topology/Basic.lean

tactic: rw [sInter_eq_biInter, hS.interior_biInter]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
S : Set (Set X)
hS : S.Finite
⊢ interior (⋂₀ S) = ⋂ s ∈ S, interior s
state_after: no goals
Theorem: Path.delayReflRight_one
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: ext t
state_before: X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflRight 1 γ = γ
state_after: case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ (delayReflRight 1 γ) t = γ t

tactic: exact congr_arg γ (qRight_one_right t)
state_before: case a.h
X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
t : ↑I
⊢ (delayReflRight 1 γ) t = γ t
state_after: no goals