tasksource/leandojo huggingface dataset:
Theorem: CategoryTheory.Limits.hasColimitOfIso
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: rw [Cocones.precompose_obj_ι, NatTrans.comp_app, colimit.cocone_ι]
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasColimit F
α : G ≅ F
s : Cocone G
j : J
⊢ ((Cocones.precompose α.hom).obj (colimit.cocone F)).ι.app j ≫
      (fun s => colimit.desc F ((Cocones.precompose α.inv).obj s)) s =
    s.ι.app j

tactic: rw [Category.assoc, colimit.ι_desc, ← NatIso.app_hom, ← Iso.eq_inv_comp]
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasColimit F
α : G ≅ F
s : Cocone G
j : J
⊢ (α.hom.app j ≫ colimit.ι F j) ≫ (fun s => colimit.desc F ((Cocones.precompose α.inv).obj s)) s = s.ι.app j

tactic: rfl
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasColimit F
α : G ≅ F
s : Cocone G
j : J
⊢ ((Cocones.precompose α.inv).obj s).ι.app j = (α.app j).inv ≫ s.ι.app j

tactic: apply colimit.hom_ext
state_before: J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasColimit F
α : G ≅ F
s : Cocone G
m : ((Cocones.precompose α.hom).obj (colimit.cocone F)).pt ⟶ s.pt
w : ∀ (j : J), ((Cocones.precompose α.hom).obj (colimit.cocone F)).ι.app j ≫ m = s.ι.app j
⊢ m = (fun s => colimit.desc F ((Cocones.precompose α.inv).obj s)) s

tactic: intro j
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasColimit F
α : G ≅ F
s : Cocone G
m : ((Cocones.precompose α.hom).obj (colimit.cocone F)).pt ⟶ s.pt
w : ∀ (j : J), ((Cocones.precompose α.hom).obj (colimit.cocone F)).ι.app j ≫ m = s.ι.app j
⊢ ∀ (j : J), colimit.ι F j ≫ m = colimit.ι F j ≫ (fun s => colimit.desc F ((Cocones.precompose α.inv).obj s)) s

tactic: rw [colimit.ι_desc, Cocones.precompose_obj_ι, NatTrans.comp_app, ← NatIso.app_inv,
  Iso.eq_inv_comp]
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasColimit F
α : G ≅ F
s : Cocone G
m : ((Cocones.precompose α.hom).obj (colimit.cocone F)).pt ⟶ s.pt
w : ∀ (j : J), ((Cocones.precompose α.hom).obj (colimit.cocone F)).ι.app j ≫ m = s.ι.app j
j : J
⊢ colimit.ι F j ≫ m = colimit.ι F j ≫ (fun s => colimit.desc F ((Cocones.precompose α.inv).obj s)) s

tactic: simpa using w j
state_before: case w
J : Type u₁
inst✝³ : Category J
K : Type u₂
inst✝² : Category K
C : Type u
inst✝¹ : Category C
F✝ F G : J ⥤ C
inst✝ : HasColimit F
α : G ≅ F
s : Cocone G
m : ((Cocones.precompose α.hom).obj (colimit.cocone F)).pt ⟶ s.pt
w : ∀ (j : J), ((Cocones.precompose α.hom).obj (colimit.cocone F)).ι.app j ≫ m = s.ι.app j
j : J
⊢ (α.app j).hom ≫ colimit.ι F j ≫ m = s.ι.app j
Theorem: convexJoin_singletons
File: Mathlib/Analysis/Convex/Join.lean

tactic: simp
state_before: ι : Sort ?u.34631
𝕜 : Type u_2
E : Type u_1
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s t s₁ s₂ t₁ t₂ u : Set E
x✝ y x : E
⊢ convexJoin 𝕜 {x} {y} = segment 𝕜 x y
Theorem: Ordinal.opow_pos
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: have h0 : 0 < (a^0) := by simp only [opow_zero, zero_lt_one]
state_before: a b : Ordinal
a0 : 0 < a
⊢ 0 < a ^ b

tactic: apply limitRecOn b
state_before: a b : Ordinal
a0 : 0 < a
h0 : 0 < a ^ 0
⊢ 0 < a ^ b

tactic: simp only [opow_zero, zero_lt_one]
state_before: a b : Ordinal
a0 : 0 < a
⊢ 0 < a ^ 0

tactic: exact h0
state_before: case H₁
a b : Ordinal
a0 : 0 < a
h0 : 0 < a ^ 0
⊢ 0 < a ^ 0

tactic: intro b IH
state_before: case H₂
a b : Ordinal
a0 : 0 < a
h0 : 0 < a ^ 0
⊢ ∀ (o : Ordinal), 0 < a ^ o → 0 < a ^ succ o

tactic: rw [opow_succ]
state_before: case H₂
a b✝ : Ordinal
a0 : 0 < a
h0 : 0 < a ^ 0
b : Ordinal
IH : 0 < a ^ b
⊢ 0 < a ^ succ b

tactic: exact mul_pos IH a0
state_before: case H₂
a b✝ : Ordinal
a0 : 0 < a
h0 : 0 < a ^ 0
b : Ordinal
IH : 0 < a ^ b
⊢ 0 < a ^ b * a

tactic: exact fun b l _ => (lt_opow_of_limit (Ordinal.pos_iff_ne_zero.1 a0) l).2 ⟨0, l.pos, h0⟩
state_before: case H₃
a b : Ordinal
a0 : 0 < a
h0 : 0 < a ^ 0
⊢ ∀ (o : Ordinal), IsLimit o → (∀ (o' : Ordinal), o' < o → 0 < a ^ o') → 0 < a ^ o
Theorem: Polynomial.map_monomial
File: Mathlib/Data/Polynomial/Eval.lean

tactic: dsimp only [map]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
a : R
⊢ map f (↑(monomial n) a) = ↑(monomial n) (↑f a)

tactic: rw [eval₂_monomial, ← C_mul_X_pow_eq_monomial]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
a : R
⊢ eval₂ (RingHom.comp C f) X (↑(monomial n) a) = ↑(monomial n) (↑f a)

tactic: rfl
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a✝ b : R
m n✝ : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
n : ℕ
a : R
⊢ ↑(RingHom.comp C f) a * X ^ n = ↑C (↑f a) * X ^ n
Theorem: CategoryTheory.Limits.zero_of_comp_mono
File: Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean

tactic: rw [← zero_comp, cancel_mono] at h
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono g
h : f ≫ g = 0
⊢ f = 0

tactic: exact h
state_before: C : Type u
inst✝³ : Category C
D : Type u'
inst✝² : Category D
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono g
h✝ : f ≫ g = 0
h : f = 0
⊢ f = 0
Theorem: Polynomial.addSubmonoid_closure_setOf_eq_monomial
File: Mathlib/Data/Polynomial/Basic.lean

tactic: apply top_unique
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ AddSubmonoid.closure {p | ∃ n a, p = ↑(monomial n) a} = ⊤

tactic: rw [← AddSubmonoid.map_equiv_top (toFinsuppIso R).symm.toAddEquiv, ←
  Finsupp.add_closure_setOf_eq_single, AddMonoidHom.map_mclosure]
state_before: case h
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ ⊤ ≤ AddSubmonoid.closure {p | ∃ n a, p = ↑(monomial n) a}

tactic: refine' AddSubmonoid.closure_mono (Set.image_subset_iff.2 _)
state_before: case h
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ AddSubmonoid.closure
      (↑(AddEquiv.toAddMonoidHom (RingEquiv.toAddEquiv (RingEquiv.symm (toFinsuppIso R)))) ''
        {f | ∃ a b, f = Finsupp.single a b}) ≤
    AddSubmonoid.closure {p | ∃ n a, p = ↑(monomial n) a}

tactic: rintro _ ⟨n, a, rfl⟩
state_before: case h
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ {f | ∃ a b, f = Finsupp.single a b} ⊆
    ↑(AddEquiv.toAddMonoidHom (RingEquiv.toAddEquiv (RingEquiv.symm (toFinsuppIso R)))) ⁻¹'
      {p | ∃ n a, p = ↑(monomial n) a}

tactic: exact ⟨n, a, Polynomial.ofFinsupp_single _ _⟩
state_before: case h.intro.intro
R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
⊢ Finsupp.single n a ∈
    ↑(AddEquiv.toAddMonoidHom (RingEquiv.toAddEquiv (RingEquiv.symm (toFinsuppIso R)))) ⁻¹'
      {p | ∃ n a, p = ↑(monomial n) a}
Theorem: PEquiv.mem_ofSet_iff
File: Mathlib/Data/PEquiv.lean

tactic: dsimp [ofSet]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a b : α
⊢ a ∈ ↑(ofSet s) b ↔ a = b ∧ a ∈ s

tactic: split_ifs with h
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a b : α
⊢ (a ∈ if b ∈ s then some b else none) ↔ a = b ∧ a ∈ s

tactic: simp only [mem_def, eq_comm, some.injEq, iff_self_and]
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a b : α
h : b ∈ s
⊢ a ∈ some b ↔ a = b ∧ a ∈ s

tactic: rintro rfl
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a b : α
h : b ∈ s
⊢ a = b → a ∈ s

tactic: exact h
state_before: case inl
α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a : α
h : a ∈ s
⊢ a ∈ s

tactic: simp only [mem_def, false_iff, not_and]
state_before: case inr
α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a b : α
h : ¬b ∈ s
⊢ a ∈ none ↔ a = b ∧ a ∈ s

tactic: rintro rfl
state_before: case inr
α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a b : α
h : ¬b ∈ s
⊢ a = b → ¬a ∈ s

tactic: exact h
state_before: case inr
α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a : α
h : ¬a ∈ s
⊢ ¬a ∈ s
Theorem: Matrix.pow_sub'
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: rw [← tsub_add_cancel_of_le h, pow_add, mul_eq_mul, Matrix.mul_assoc, mul_nonsing_inv,
  tsub_add_cancel_of_le h, Matrix.mul_one]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℕ
ha : IsUnit (det A)
h : n ≤ m
⊢ A ^ (m - n) = A ^ m ⬝ (A ^ n)⁻¹

tactic: simpa using ha.pow n
state_before: case h
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
m n : ℕ
ha : IsUnit (det A)
h : n ≤ m
⊢ IsUnit (det (A ^ n))
Theorem: LinearMap.det_toMatrix
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: haveI := Classical.decEq M
state_before: R : Type ?u.421389
inst✝⁹ : CommRing R
M : Type u_3
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
M' : Type ?u.421980
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M'
ι : Type u_1
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝² : CommRing A
inst✝¹ : Module A M
κ : Type ?u.423498
inst✝ : Fintype κ
b : Basis ι A M
f : M →ₗ[A] M
⊢ det (↑(toMatrix b b) f) = ↑LinearMap.det f

tactic: rw [det_eq_det_toMatrix_of_finset b.reindexFinsetRange]
state_before: R : Type ?u.421389
inst✝⁹ : CommRing R
M : Type u_3
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
M' : Type ?u.421980
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M'
ι : Type u_1
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝² : CommRing A
inst✝¹ : Module A M
κ : Type ?u.423498
inst✝ : Fintype κ
b : Basis ι A M
f : M →ₗ[A] M
this : DecidableEq M
⊢ det (↑(toMatrix b b) f) = ↑LinearMap.det f

tactic: apply det_toMatrix_eq_det_toMatrix b
state_before: R : Type ?u.421389
inst✝⁹ : CommRing R
M : Type u_3
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
M' : Type ?u.421980
inst✝⁶ : AddCommGroup M'
inst✝⁵ : Module R M'
ι : Type u_1
inst✝⁴ : DecidableEq ι
inst✝³ : Fintype ι
e : Basis ι R M
A : Type u_2
inst✝² : CommRing A
inst✝¹ : Module A M
κ : Type ?u.423498
inst✝ : Fintype κ
b : Basis ι A M
f : M →ₗ[A] M
this : DecidableEq M
⊢ det (↑(toMatrix b b) f) = det (↑(toMatrix (Basis.reindexFinsetRange b) (Basis.reindexFinsetRange b)) f)
Theorem: CategoryTheory.right_unitality_app
File: Mathlib/CategoryTheory/Monoidal/End.lean

tactic: have := congr_app (F.toLaxMonoidalFunctor.right_unitality n) X
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
⊢ F.ε.app ((F.obj n).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))

tactic: dsimp [endofunctorMonoidalCategory] at this
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  (ρ_ (F.obj n)).hom.app X =
    ((𝟙 (F.obj n) ⊗ F.ε) ≫ LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M) ≫ F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))

tactic: simpa using this.symm
state_before: C : Type u
inst✝² : Category C
M : Type u_2
inst✝¹ : Category M
inst✝ : MonoidalCategory M
F : MonoidalFunctor M (C ⥤ C)
n : M
X : C
this :
  𝟙 ((F.obj n).obj X) =
    (F.ε.app ((F.obj n).obj X) ≫ (F.obj (𝟙_ M)).map (𝟙 ((F.obj n).obj X))) ≫
      (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X
⊢ F.ε.app ((F.obj n).obj X) ≫ (LaxMonoidalFunctor.μ F.toLaxMonoidalFunctor n (𝟙_ M)).app X ≫ (F.map (ρ_ n).hom).app X =
    𝟙 ((𝟙_ (C ⥤ C)).obj ((F.obj n).obj X))
Theorem: Real.sqrt_pos
File: Mathlib/Data/Real/Sqrt.lean

tactic: simp [le_antisymm_iff, sqrt_nonneg]
state_before: x y : ℝ
⊢ sqrt x ≤ 0 ↔ sqrt x = 0
Theorem: MeasureTheory.L1.integral_of_fun_eq_integral
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [MeasureTheory.integral, L1.integral]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.949136
𝕜 : Type ?u.949139
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
hf : Integrable f
⊢ (∫ (a : α), ↑↑(Integrable.toL1 f hf) a ∂μ) = ∫ (a : α), f a ∂μ

tactic: exact setToFun_toL1 (dominatedFinMeasAdditive_weightedSMul μ) hf
state_before: α : Type u_2
E : Type u_1
F : Type ?u.949136
𝕜 : Type ?u.949139
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
f : α → E
hf : Integrable f
⊢ (if hf_1 : Integrable fun a => ↑↑(Integrable.toL1 f hf) a then
      ↑integralCLM (Integrable.toL1 (fun a => ↑↑(Integrable.toL1 f hf) a) hf_1)
    else 0) =
    if hf : Integrable fun a => f a then ↑integralCLM (Integrable.toL1 (fun a => f a) hf) else 0
Theorem: FirstOrder.Language.Structure.CG.map_of_surjective
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [← Hom.range_eq_top] at hs
state_before: L : Language
M : Type u_4
inst✝¹ : Structure L M
N : Type u_1
inst✝ : Structure L N
h : CG L M
f : M →[L] N
hs : Function.Surjective ↑f
⊢ CG L N

tactic: rw [cg_def, ← hs]
state_before: L : Language
M : Type u_4
inst✝¹ : Structure L M
N : Type u_1
inst✝ : Structure L N
h : CG L M
f : M →[L] N
hs : Hom.range f = ⊤
⊢ CG L N

tactic: exact h.range f
state_before: L : Language
M : Type u_4
inst✝¹ : Structure L M
N : Type u_1
inst✝ : Structure L N
h : CG L M
f : M →[L] N
hs : Hom.range f = ⊤
⊢ Substructure.CG (Hom.range f)
Theorem: setOf_liouville_eq_iInter_iUnion
File: Mathlib/NumberTheory/Liouville/Residual.lean

tactic: ext x
state_before: ⊢ {x | Liouville x} = ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}

tactic: simp only [mem_iInter, mem_iUnion, Liouville, mem_setOf_eq, exists_prop, mem_diff,
  mem_singleton_iff, mem_ball, Real.dist_eq, and_comm]
state_before: case h
x : ℝ
⊢ x ∈ {x | Liouville x} ↔ x ∈ ⋂ (n : ℕ), ⋃ (a : ℤ) (b : ℤ) (_ : 1 < b), ball (↑a / ↑b) (1 / ↑b ^ n) \ {↑a / ↑b}
Theorem: IntervalIntegrable.comp_add_left
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [add_comm] using IntervalIntegrable.comp_add_right hf c
state_before: ι : Type ?u.7443118
𝕜 : Type ?u.7443121
E : Type u_1
F : Type ?u.7443127
A : Type ?u.7443130
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedRing A
f g : ℝ → E
a b : ℝ
μ : MeasureTheory.Measure ℝ
hf : IntervalIntegrable f volume a b
c : ℝ
⊢ IntervalIntegrable (fun x => f (c + x)) volume (a - c) (b - c)
Theorem: Int.cast_two
File: Mathlib/Data/Int/Cast/Basic.lean

tactic: rw [cast_ofNat, Nat.cast_ofNat]
state_before: R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑↑2 = ↑2
Theorem: posMulMono_iff_covariant_pos
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: obtain ha | ha := a.prop.eq_or_lt
state_before: α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : CovariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x ≤ x_1
a : { x // 0 ≤ x }
b c : α
h : b ≤ c
⊢ ↑a * b ≤ ↑a * c

tactic: simp [←ha]
state_before: case inl
α : Type u_1
a✝ b✝ c✝ d : α
inst✝¹ : MulZeroClass α
inst✝ : PartialOrder α
h✝ : CovariantClass { x // 0 < x } α (fun x y => ↑x * y) fun x x_1 => x ≤ x_1
a : { x // 0 ≤ x }
b c : α
h : b ≤ c
ha : 0 = ↑a
⊢ ↑a * b ≤ ↑a * c
Theorem: Asymptotics.isBigO_fst_prod'
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa [IsBigO_def, IsBigOWith_def] using isBigO_fst_prod (E' := E') (F' := F')
state_before: α : Type u_3
β : Type ?u.140991
E : Type ?u.140994
F : Type ?u.140997
G : Type ?u.141000
E' : Type u_1
F' : Type u_2
G' : Type ?u.141009
E'' : Type ?u.141012
F'' : Type ?u.141015
G'' : Type ?u.141018
R : Type ?u.141021
R' : Type ?u.141024
𝕜 : Type ?u.141027
𝕜' : Type ?u.141030
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f'✝ : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f' : α → E' × F'
⊢ (fun x => (f' x).fst) =O[l] f'
Theorem: Matrix.fromBlocks_submatrix_sum_swap_right
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (i j)
state_before: l : Type u_2
m : Type u_4
n : Type u_1
o : Type u_5
p : Type u_6
q : Type ?u.19562
m' : o → Type ?u.19567
n' : o → Type ?u.19572
p' : o → Type ?u.19577
R : Type ?u.19580
S : Type ?u.19583
α : Type u_3
β : Type ?u.19589
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
f : p → n ⊕ o
⊢ submatrix (fromBlocks A B C D) f Sum.swap = submatrix (fromBlocks B A D C) f id

tactic: cases j <;> dsimp <;> cases f i <;> rfl
state_before: case a.h
l : Type u_2
m : Type u_4
n : Type u_1
o : Type u_5
p : Type u_6
q : Type ?u.19562
m' : o → Type ?u.19567
n' : o → Type ?u.19572
p' : o → Type ?u.19577
R : Type ?u.19580
S : Type ?u.19583
α : Type u_3
β : Type ?u.19589
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
f : p → n ⊕ o
i : p
j : m ⊕ l
⊢ submatrix (fromBlocks A B C D) f Sum.swap i j = submatrix (fromBlocks B A D C) f id i j
Theorem: Nat.factorization_eq_zero_of_not_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [factorization_eq_zero_iff, h]
state_before: n p : ℕ
h : ¬p ∣ n
⊢ ↑(factorization n) p = 0
Theorem: div_le_div_right₀
File: Mathlib/Algebra/Order/WithZero.lean

tactic: rw [div_eq_mul_inv, div_eq_mul_inv, mul_le_mul_right₀ (inv_ne_zero hc)]
state_before: α : Type u_1
a b c d x y z : α
inst✝ : LinearOrderedCommGroupWithZero α
hc : c ≠ 0
⊢ a / c ≤ b / c ↔ a ≤ b
Theorem: HasDerivAt.complexToReal_fderiv
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: simpa only [Complex.restrictScalars_one_smulRight] using h.hasFDerivAt.restrictScalars ℝ
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type ?u.127606
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℂ → ℂ
f' x : ℂ
h : HasDerivAt f f' x
⊢ HasFDerivAt f (f' • 1) x
Theorem: Multiset.card_Icc
File: Mathlib/Data/Multiset/Interval.lean

tactic: simp_rw [Icc_eq, Finset.card_map, Dfinsupp.card_Icc, Nat.card_Icc, Multiset.toDfinsupp_apply,
  toDfinsupp_support]
state_before: α : Type u_1
β : α → Type ?u.41665
inst✝ : DecidableEq α
f g : Multiset α
⊢ Finset.card (Finset.Icc f g) = ∏ i in toFinset f ∪ toFinset g, (count i g + 1 - count i f)
Theorem: if_true_left_eq_or
File: Mathlib/Init/IteSimp.lean

tactic: by_cases p <;> simp [h]
state_before: p : Prop
h : Decidable p
q : Prop
⊢ (if p then True else q) = (p ∨ q)
Theorem: MeasureTheory.integral_smul
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp only [integral, L1.integral]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.923884
𝕜 : Type u_3
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
c : 𝕜
f : α → E
⊢ (∫ (a : α), c • f a ∂μ) = c • ∫ (a : α), f a ∂μ

tactic: exact setToFun_smul (dominatedFinMeasAdditive_weightedSMul μ) weightedSMul_smul c f
state_before: α : Type u_2
E : Type u_1
F : Type ?u.923884
𝕜 : Type u_3
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
inst✝⁵ : NontriviallyNormedField 𝕜
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
c : 𝕜
f : α → E
⊢ (if hf : Integrable fun a => c • f a then ↑L1.integralCLM (Integrable.toL1 (fun a => c • f a) hf) else 0) =
    c • if hf : Integrable fun a => f a then ↑L1.integralCLM (Integrable.toL1 (fun a => f a) hf) else 0
Theorem: Finset.product_eq_empty
File: Mathlib/Data/Finset/Prod.lean

tactic: rw [← not_nonempty_iff_eq_empty, nonempty_product, not_and_or, not_nonempty_iff_eq_empty,
  not_nonempty_iff_eq_empty]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.68091
s✝ s' : Finset α
t✝ t' : Finset β
a : α
b : β
s : Finset α
t : Finset β
⊢ s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅
Theorem: forall_eq'
File: Std/Logic.lean

tactic: simp [@eq_comm _ a']
state_before: α : Sort u_1
p q : α → Prop
b : Prop
a' : α
⊢ (∀ (a : α), a' = a → p a) ↔ p a'
Theorem: indicator_ae_eq_zero_of_restrict_ae_eq_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [Filter.EventuallyEq, ae_restrict_iff' hs] at hf
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4867261
δ : Type ?u.4867264
ι : Type ?u.4867267
R : Type ?u.4867270
R' : Type ?u.4867273
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
hf : f =ᶠ[ae (Measure.restrict μ s)] 0
⊢ indicator s f =ᶠ[ae μ] 0

tactic: filter_upwards [hf]with x hx
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.4867261
δ : Type ?u.4867264
ι : Type ?u.4867267
R : Type ?u.4867270
R' : Type ?u.4867273
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
hf : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = OfNat.ofNat 0 x
⊢ indicator s f =ᶠ[ae μ] 0

tactic: by_cases hxs : x ∈ s
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.4867261
δ : Type ?u.4867264
ι : Type ?u.4867267
R : Type ?u.4867270
R' : Type ?u.4867273
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
hf : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = OfNat.ofNat 0 x
x : α
hx : x ∈ s → f x = OfNat.ofNat 0 x
⊢ indicator s f x = OfNat.ofNat 0 x

tactic: simp only [hxs, hx hxs, Set.indicator_of_mem]
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.4867261
δ : Type ?u.4867264
ι : Type ?u.4867267
R : Type ?u.4867270
R' : Type ?u.4867273
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
hf : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = OfNat.ofNat 0 x
x : α
hx : x ∈ s → f x = OfNat.ofNat 0 x
hxs : x ∈ s
⊢ indicator s f x = OfNat.ofNat 0 x

tactic: simp [hx, hxs]
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.4867261
δ : Type ?u.4867264
ι : Type ?u.4867267
R : Type ?u.4867270
R' : Type ?u.4867273
inst✝¹ : MeasurableSpace α
μ : MeasureTheory.Measure α
s t : Set α
f : α → β
inst✝ : Zero β
hs : MeasurableSet s
hf : ∀ᵐ (x : α) ∂μ, x ∈ s → f x = OfNat.ofNat 0 x
x : α
hx : x ∈ s → f x = OfNat.ofNat 0 x
hxs : ¬x ∈ s
⊢ indicator s f x = OfNat.ofNat 0 x
Theorem: ZFSet.IsTransitive.powerset
File: Mathlib/SetTheory/ZFC/Ordinal.lean

tactic: rw [mem_powerset] at hy⊢
state_before: x y✝ z✝ : ZFSet
h : IsTransitive x
y : ZFSet
hy : y ∈ powerset x
z : ZFSet
hz : z ∈ y
⊢ z ∈ powerset x

tactic: exact h.subset_of_mem (hy hz)
state_before: x y✝ z✝ : ZFSet
h : IsTransitive x
y : ZFSet
hy : y ⊆ x
z : ZFSet
hz : z ∈ y
⊢ z ⊆ x