1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.Functor.rightOp_leftOp_eq
File: Mathlib/CategoryTheory/Opposites.lean

tactic: cases F
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : Cᵒᵖ ⥤ D
⊢ F.rightOp.leftOp = F
state_after: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
toPrefunctor✝ : Cᵒᵖ ⥤q D
map_id✝ : ∀ (X : Cᵒᵖ), toPrefunctor✝.map (𝟙 X) = 𝟙 (toPrefunctor✝.obj X)
map_comp✝ :
  ∀ {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z), toPrefunctor✝.map (f ≫ g) = toPrefunctor✝.map f ≫ toPrefunctor✝.map g
⊢ { toPrefunctor := toPrefunctor✝, map_id := map_id✝, map_comp := map_comp✝ }.rightOp.leftOp =
    { toPrefunctor := toPrefunctor✝, map_id := map_id✝, map_comp := map_comp✝ }

tactic: rfl
state_before: case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
toPrefunctor✝ : Cᵒᵖ ⥤q D
map_id✝ : ∀ (X : Cᵒᵖ), toPrefunctor✝.map (𝟙 X) = 𝟙 (toPrefunctor✝.obj X)
map_comp✝ :
  ∀ {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z), toPrefunctor✝.map (f ≫ g) = toPrefunctor✝.map f ≫ toPrefunctor✝.map g
⊢ { toPrefunctor := toPrefunctor✝, map_id := map_id✝, map_comp := map_comp✝ }.rightOp.leftOp =
    { toPrefunctor := toPrefunctor✝, map_id := map_id✝, map_comp := map_comp✝ }
state_after: no goals
Theorem: PowerBasis.constr_pow_mul
File: Mathlib/RingTheory/PowerBasis.lean

tactic: obtain ⟨f, rfl⟩ := pb.exists_eq_aeval' x
state_before: R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type u_6
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_7
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : (aeval y) (minpoly A pb.gen) = 0
x x' : S
⊢ ((pb.basis.constr A) fun i => y ^ ↑i) (x * x') =
    ((pb.basis.constr A) fun i => y ^ ↑i) x * ((pb.basis.constr A) fun i => y ^ ↑i) x'
state_after: case intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type u_6
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_7
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : (aeval y) (minpoly A pb.gen) = 0
x' : S
f : A[X]
⊢ ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f * x') =
    ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f) * ((pb.basis.constr A) fun i => y ^ ↑i) x'

tactic: obtain ⟨g, rfl⟩ := pb.exists_eq_aeval' x'
state_before: case intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type u_6
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_7
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : (aeval y) (minpoly A pb.gen) = 0
x' : S
f : A[X]
⊢ ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f * x') =
    ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f) * ((pb.basis.constr A) fun i => y ^ ↑i) x'
state_after: case intro.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type u_6
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_7
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : (aeval y) (minpoly A pb.gen) = 0
f g : A[X]
⊢ ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f * (aeval pb.gen) g) =
    ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f) * ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) g)

tactic: simp only [← aeval_mul, pb.constr_pow_aeval hy]
state_before: case intro.intro
R : Type u_1
S : Type u_2
T : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : Ring S
inst✝⁸ : Algebra R S
A : Type u_4
B : Type u_5
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : IsDomain B
inst✝⁴ : Algebra A B
K : Type u_6
inst✝³ : Field K
inst✝² : Algebra A S
S' : Type u_7
inst✝¹ : Ring S'
inst✝ : Algebra A S'
pb : PowerBasis A S
y : S'
hy : (aeval y) (minpoly A pb.gen) = 0
f g : A[X]
⊢ ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f * (aeval pb.gen) g) =
    ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) f) * ((pb.basis.constr A) fun i => y ^ ↑i) ((aeval pb.gen) g)
state_after: no goals
Theorem: Cardinal.empty_theory_categorical
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: rw [empty.nonempty_equiv_iff, hM, hN]
state_before: L : Language
κ : Cardinal.{w}
T✝ : L.Theory
T : Language.empty.Theory
M N : T.ModelType
hM : #↑M = κ
hN : #↑N = κ
⊢ Nonempty (↑M ≃[Language.empty] ↑N)
state_after: no goals
Theorem: LocallyFinite.isClosed_iUnion
File: Mathlib/Topology/LocallyFinite.lean

tactic: simp only [← closure_eq_iff_isClosed, hf.closure_iUnion, (hc _).closure_eq]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
X : Type u_4
Y : Type u_5
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
f g : ι → Set X
hf : LocallyFinite f
hc : ∀ (i : ι), IsClosed (f i)
⊢ IsClosed (⋃ i, f i)
state_after: no goals
Theorem: ConvexOn.smul_concaveOn
File: Mathlib/Analysis/Convex/Mul.lean

tactic: rw [← neg_convexOn_iff, ← smul_neg]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : LinearOrderedCommRing 𝕜
inst✝⁹ : LinearOrderedCommRing E
inst✝⁸ : LinearOrderedAddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : Module E F
inst✝⁴ : IsScalarTower 𝕜 E F
inst✝³ : SMulCommClass 𝕜 E F
inst✝² : OrderedSMul 𝕜 E
inst✝¹ : OrderedSMul 𝕜 F
inst✝ : OrderedSMul E F
s : Set 𝕜
f : 𝕜 → E
g : 𝕜 → F
hf : ConvexOn 𝕜 s f
hg : ConcaveOn 𝕜 s g
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x
hg₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → g x ≤ 0
hfg : AntivaryOn f g s
⊢ ConcaveOn 𝕜 s (f • g)
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : LinearOrderedCommRing 𝕜
inst✝⁹ : LinearOrderedCommRing E
inst✝⁸ : LinearOrderedAddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : Module E F
inst✝⁴ : IsScalarTower 𝕜 E F
inst✝³ : SMulCommClass 𝕜 E F
inst✝² : OrderedSMul 𝕜 E
inst✝¹ : OrderedSMul 𝕜 F
inst✝ : OrderedSMul E F
s : Set 𝕜
f : 𝕜 → E
g : 𝕜 → F
hf : ConvexOn 𝕜 s f
hg : ConcaveOn 𝕜 s g
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x
hg₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → g x ≤ 0
hfg : AntivaryOn f g s
⊢ ConvexOn 𝕜 s (f • -g)

tactic: exact hf.smul' hg.neg hf₀ (fun x hx ↦ neg_nonneg.2 <| hg₀ hx) hfg.neg_right
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : LinearOrderedCommRing 𝕜
inst✝⁹ : LinearOrderedCommRing E
inst✝⁸ : LinearOrderedAddCommGroup F
inst✝⁷ : Module 𝕜 E
inst✝⁶ : Module 𝕜 F
inst✝⁵ : Module E F
inst✝⁴ : IsScalarTower 𝕜 E F
inst✝³ : SMulCommClass 𝕜 E F
inst✝² : OrderedSMul 𝕜 E
inst✝¹ : OrderedSMul 𝕜 F
inst✝ : OrderedSMul E F
s : Set 𝕜
f : 𝕜 → E
g : 𝕜 → F
hf : ConvexOn 𝕜 s f
hg : ConcaveOn 𝕜 s g
hf₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → 0 ≤ f x
hg₀ : ∀ ⦃x : 𝕜⦄, x ∈ s → g x ≤ 0
hfg : AntivaryOn f g s
⊢ ConvexOn 𝕜 s (f • -g)
state_after: no goals
Theorem: ProbabilityTheory.kernel.setLIntegral_piecewise
File: Mathlib/Probability/Kernel/Basic.lean

tactic: simp_rw [piecewise_apply]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : ↥(kernel α β)
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
g : β → ℝ≥0∞
t : Set β
⊢ ∫⁻ (b : β) in t, g b ∂(piecewise hs κ η) a = if a ∈ s then ∫⁻ (b : β) in t, g b ∂κ a else ∫⁻ (b : β) in t, g b ∂η a
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : ↥(kernel α β)
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
g : β → ℝ≥0∞
t : Set β
⊢ (∫⁻ (b : β) in t, g b ∂if a ∈ s then κ a else η a) =
    if a ∈ s then ∫⁻ (b : β) in t, g b ∂κ a else ∫⁻ (b : β) in t, g b ∂η a

tactic: split_ifs <;> rfl
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ η : ↥(kernel α β)
s : Set α
hs : MeasurableSet s
inst✝ : DecidablePred fun x => x ∈ s
a : α
g : β → ℝ≥0∞
t : Set β
⊢ (∫⁻ (b : β) in t, g b ∂if a ∈ s then κ a else η a) =
    if a ∈ s then ∫⁻ (b : β) in t, g b ∂κ a else ∫⁻ (b : β) in t, g b ∂η a
state_after: no goals
Theorem: algebraMap_strictMono
File: Mathlib/Algebra/Order/Module/Algebra.lean

tactic: simpa only [Algebra.algebraMap_eq_smul_one] using smul_lt_smul_of_pos_right ha zero_lt_one
state_before: α : Type u_1
β : Type u_2
inst✝³ : OrderedCommSemiring α
inst✝² : StrictOrderedSemiring β
inst✝¹ : Algebra α β
inst✝ : SMulPosStrictMono α β
a a₁✝ a₂✝ a₁ a₂ : α
ha : a₁ < a₂
⊢ (algebraMap α β) a₁ < (algebraMap α β) a₂
state_after: no goals
Theorem: IsOpen.frontier_eq
File: Mathlib/Topology/Basic.lean

tactic: rw [frontier, hs.interior_eq]
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
hs : IsOpen s
⊢ frontier s = closure s \ s
state_after: no goals
Theorem: MeasureTheory.AEStronglyMeasurable.integral_condKernel
File: Mathlib/Probability/Kernel/Disintegration/Integral.lean

tactic: rw [← ρ.compProd_fst_condKernel] at hf
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : AEStronglyMeasurable f ρ
⊢ AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂ρ.condKernel x) ρ.fst
state_after: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : AEStronglyMeasurable f (ρ.fst ⊗ₘ ρ.condKernel)
⊢ AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂ρ.condKernel x) ρ.fst

tactic: exact AEStronglyMeasurable.integral_kernel_compProd hf
state_before: α : Type u_1
β : Type u_2
Ω : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
inst✝⁵ : MeasurableSpace Ω
inst✝⁴ : StandardBorelSpace Ω
inst✝³ : Nonempty Ω
ρ : Measure (β × Ω)
inst✝² : IsFiniteMeasure ρ
E : Type u_4
f : β × Ω → E
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
hf : AEStronglyMeasurable f (ρ.fst ⊗ₘ ρ.condKernel)
⊢ AEStronglyMeasurable (fun x => ∫ (y : Ω), f (x, y) ∂ρ.condKernel x) ρ.fst
state_after: no goals
Theorem: Fin.castLE_injective
File: Mathlib/Data/Fin/Basic.lean

tactic: have := congr_arg val hab
state_before: n m : ℕ
hmn : m ≤ n
a b : Fin m
hab : castLE hmn a = castLE hmn b
⊢ ↑a = ↑b
state_after: n m : ℕ
hmn : m ≤ n
a b : Fin m
hab : castLE hmn a = castLE hmn b
this : ↑(castLE hmn a) = ↑(castLE hmn b)
⊢ ↑a = ↑b

tactic: exact this
state_before: n m : ℕ
hmn : m ≤ n
a b : Fin m
hab : castLE hmn a = castLE hmn b
this : ↑(castLE hmn a) = ↑(castLE hmn b)
⊢ ↑a = ↑b
state_after: no goals
Theorem: CategoryTheory.isIso_of_epi_of_strongMono
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

tactic: simp
state_before: C : Type u
inst✝² : Category.{v, u} C
P Q : C
f : P ⟶ Q
inst✝¹ : Epi f
inst✝ : StrongMono f
⊢ 𝟙 P ≫ f = f ≫ 𝟙 Q
state_after: no goals

tactic: aesop_cat
state_before: C : Type u
inst✝² : Category.{v, u} C
P Q : C
f : P ⟶ Q
inst✝¹ : Epi f
inst✝ : StrongMono f
⊢ f ≫ ⋯.lift = 𝟙 P ∧ ⋯.lift ≫ f = 𝟙 Q
state_after: no goals
Theorem: rank_eq_zero_iff_isTorsion
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

tactic: rw [Module.IsTorsion, rank_eq_zero_iff]
state_before: R✝ : Type u
M✝ M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹² : Ring R✝
inst✝¹¹ : AddCommGroup M✝
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R✝ M✝
inst✝⁷ : Module R✝ M'
inst✝⁶ : Module R✝ M₁
inst✝⁵ : Nontrivial R✝
inst✝⁴ : NoZeroSMulDivisors R✝ M✝
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ Module.rank R M = 0 ↔ Module.IsTorsion R M
state_after: R✝ : Type u
M✝ M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹² : Ring R✝
inst✝¹¹ : AddCommGroup M✝
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R✝ M✝
inst✝⁷ : Module R✝ M'
inst✝⁶ : Module R✝ M₁
inst✝⁵ : Nontrivial R✝
inst✝⁴ : NoZeroSMulDivisors R✝ M✝
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ (∀ (x : M), ∃ a, a ≠ 0 ∧ a • x = 0) ↔ ∀ ⦃x : M⦄, ∃ a, a • x = 0

tactic: simp [mem_nonZeroDivisors_iff_ne_zero]
state_before: R✝ : Type u
M✝ M₁ : Type v
M' : Type v'
ι : Type w
inst✝¹² : Ring R✝
inst✝¹¹ : AddCommGroup M✝
inst✝¹⁰ : AddCommGroup M'
inst✝⁹ : AddCommGroup M₁
inst✝⁸ : Module R✝ M✝
inst✝⁷ : Module R✝ M'
inst✝⁶ : Module R✝ M₁
inst✝⁵ : Nontrivial R✝
inst✝⁴ : NoZeroSMulDivisors R✝ M✝
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
⊢ (∀ (x : M), ∃ a, a ≠ 0 ∧ a • x = 0) ↔ ∀ ⦃x : M⦄, ∃ a, a • x = 0
state_after: no goals
Theorem: differentiableWithinAt_dslope_of_ne
File: Mathlib/Analysis/Calculus/Dslope.lean

tactic: refine ⟨DifferentiableWithinAt.of_dslope, fun hd => ?_⟩
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
⊢ DifferentiableWithinAt 𝕜 (dslope f a) s b ↔ DifferentiableWithinAt 𝕜 f s b
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hd : DifferentiableWithinAt 𝕜 f s b
⊢ DifferentiableWithinAt 𝕜 (dslope f a) s b

tactic: refine (((differentiableWithinAt_id.sub_const a).inv (sub_ne_zero.2 h)).smul
  (hd.sub_const (f a))).congr_of_eventuallyEq ?_ (dslope_of_ne _ h)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hd : DifferentiableWithinAt 𝕜 f s b
⊢ DifferentiableWithinAt 𝕜 (dslope f a) s b
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hd : DifferentiableWithinAt 𝕜 f s b
⊢ dslope f a =ᶠ[𝓝[s] b] fun y => (id y - a)⁻¹ • (f y - f a)

tactic: refine (eqOn_dslope_slope _ _).eventuallyEq_of_mem ?_
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hd : DifferentiableWithinAt 𝕜 f s b
⊢ dslope f a =ᶠ[𝓝[s] b] fun y => (id y - a)⁻¹ • (f y - f a)
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hd : DifferentiableWithinAt 𝕜 f s b
⊢ {a}ᶜ ∈ 𝓝[s] b

tactic: exact mem_nhdsWithin_of_mem_nhds (isOpen_ne.mem_nhds h)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → E
a b : 𝕜
s : Set 𝕜
h : b ≠ a
hd : DifferentiableWithinAt 𝕜 f s b
⊢ {a}ᶜ ∈ 𝓝[s] b
state_after: no goals
Theorem: MeasureTheory.lintegral_le_of_lmarginal_le
File: Mathlib/MeasureTheory/Integral/Marginal.lean

tactic: rcases isEmpty_or_nonempty (∀ i, π i) with h|⟨⟨x⟩⟩
state_before: δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝³ : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝² : ∀ (i : δ), SigmaFinite (μ i)
inst✝¹ : DecidableEq δ
s✝ t : Finset δ
f✝ g✝ : ((i : δ) → π i) → ℝ≥0∞
x y : (i : δ) → π i
i : δ
inst✝ : Fintype δ
s : Finset δ
f g : ((i : δ) → π i) → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hfg : ∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ
⊢ ∫⁻ (x : (i : δ) → π i), f x ∂Measure.pi μ ≤ ∫⁻ (x : (i : δ) → π i), g x ∂Measure.pi μ
state_after: case inl
δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝³ : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝² : ∀ (i : δ), SigmaFinite (μ i)
inst✝¹ : DecidableEq δ
s✝ t : Finset δ
f✝ g✝ : ((i : δ) → π i) → ℝ≥0∞
x y : (i : δ) → π i
i : δ
inst✝ : Fintype δ
s : Finset δ
f g : ((i : δ) → π i) → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hfg : ∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ
h : IsEmpty ((i : δ) → π i)
⊢ ∫⁻ (x : (i : δ) → π i), f x ∂Measure.pi μ ≤ ∫⁻ (x : (i : δ) → π i), g x ∂Measure.pi μ

case inr.intro
δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝³ : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝² : ∀ (i : δ), SigmaFinite (μ i)
inst✝¹ : DecidableEq δ
s✝ t : Finset δ
f✝ g✝ : ((i : δ) → π i) → ℝ≥0∞
x✝ y : (i : δ) → π i
i : δ
inst✝ : Fintype δ
s : Finset δ
f g : ((i : δ) → π i) → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hfg : ∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ
x : (i : δ) → π i
⊢ ∫⁻ (x : (i : δ) → π i), f x ∂Measure.pi μ ≤ ∫⁻ (x : (i : δ) → π i), g x ∂Measure.pi μ

tactic: simp_rw [lintegral_eq_lmarginal_univ x, lmarginal_le_of_subset (Finset.subset_univ s) hf hg hfg x]
state_before: case inr.intro
δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝³ : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝² : ∀ (i : δ), SigmaFinite (μ i)
inst✝¹ : DecidableEq δ
s✝ t : Finset δ
f✝ g✝ : ((i : δ) → π i) → ℝ≥0∞
x✝ y : (i : δ) → π i
i : δ
inst✝ : Fintype δ
s : Finset δ
f g : ((i : δ) → π i) → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hfg : ∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ
x : (i : δ) → π i
⊢ ∫⁻ (x : (i : δ) → π i), f x ∂Measure.pi μ ≤ ∫⁻ (x : (i : δ) → π i), g x ∂Measure.pi μ
state_after: no goals

tactic: simp_rw [lintegral_of_isEmpty, le_rfl]
state_before: case inl
δ : Type u_1
δ' : Type u_2
π : δ → Type u_3
inst✝³ : (x : δ) → MeasurableSpace (π x)
μ : (i : δ) → Measure (π i)
inst✝² : ∀ (i : δ), SigmaFinite (μ i)
inst✝¹ : DecidableEq δ
s✝ t : Finset δ
f✝ g✝ : ((i : δ) → π i) → ℝ≥0∞
x y : (i : δ) → π i
i : δ
inst✝ : Fintype δ
s : Finset δ
f g : ((i : δ) → π i) → ℝ≥0∞
hf : Measurable f
hg : Measurable g
hfg : ∫⋯∫⁻_s, f ∂μ ≤ ∫⋯∫⁻_s, g ∂μ
h : IsEmpty ((i : δ) → π i)
⊢ ∫⁻ (x : (i : δ) → π i), f x ∂Measure.pi μ ≤ ∫⁻ (x : (i : δ) → π i), g x ∂Measure.pi μ
state_after: no goals
Theorem: Matrix.rank_self_mul_transpose
File: Mathlib/Data/Matrix/Rank.lean

tactic: simpa only [rank_transpose, transpose_transpose] using rank_transpose_mul_self Aᵀ
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : Fintype m
inst✝ : LinearOrderedField R
A : Matrix m n R
⊢ (A * Aᵀ).rank = A.rank
state_after: no goals
Theorem: MeasureTheory.Integrable.smul_measure
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at h ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ Integrable f (c • μ)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Memℒp f 1 μ
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ Memℒp f 1 (c • μ)

tactic: exact h.smul_measure hc
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Memℒp f 1 μ
c : ℝ≥0∞
hc : c ≠ ⊤
⊢ Memℒp f 1 (c • μ)
state_after: no goals
Theorem: Int.ceil_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← ceil_add_int a (1 : ℤ), cast_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ ⌈a + 1⌉ = ⌈a⌉ + 1
state_after: no goals
Theorem: List.findIdx_of_get?_eq_some
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction xs with
| nil => simp_all
| cons x xs ih => by_cases h : p x <;> simp_all [findIdx_cons]
state_before: α : Type u_1
p : α → Bool
y : α
xs : List α
w : xs.get? (findIdx p xs) = some y
⊢ p y = true
state_after: no goals

tactic: simp_all
state_before: case nil
α : Type u_1
p : α → Bool
y : α
w : [].get? (findIdx p []) = some y
⊢ p y = true
state_after: no goals

tactic: by_cases h : p x <;> simp_all [findIdx_cons]
state_before: case cons
α : Type u_1
p : α → Bool
y x : α
xs : List α
ih : xs.get? (findIdx p xs) = some y → p y = true
w : (x :: xs).get? (findIdx p (x :: xs)) = some y
⊢ p y = true
state_after: no goals
Theorem: quadraticChar_zero
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

tactic: simp only [quadraticChar_apply, quadraticCharFun_zero]
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
⊢ (quadraticChar F) 0 = 0
state_after: no goals
Theorem: GaloisInsertion.isAtom_iff'
File: Mathlib/Order/Atoms.lean

tactic: rw [← gi.isAtom_iff hbot h_atom, gi.l_u_eq]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
inst✝⁴ : PartialOrder α
inst✝³ : PartialOrder β
inst✝² : OrderBot α
inst✝¹ : IsAtomic α
inst✝ : OrderBot β
l : α → β
u : β → α
gi : GaloisInsertion l u
hbot : u ⊥ = ⊥
h_atom : ∀ (a : α), IsAtom a → u (l a) = a
b : β
⊢ IsAtom (u b) ↔ IsAtom b
state_after: no goals
Theorem: le_max_left
File: Mathlib/Init/Order/LinearOrder.lean

tactic: if h : a ≤ b
then simp [max_def, if_pos h]; exact h
else simp [max_def, if_neg h, le_refl]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
⊢ a ≤ max a b
state_after: no goals

tactic: simp [max_def, if_pos h]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ a ≤ max a b
state_after: α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ a ≤ b

tactic: exact h
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ a ≤ b
state_after: no goals

tactic: simp [max_def, if_neg h, le_refl]
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h : ¬a ≤ b
⊢ a ≤ max a b
state_after: no goals
Theorem: Polynomial.prod_multiset_X_sub_C_of_monic_of_roots_card_eq
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: convert C_leadingCoeff_mul_prod_multiset_X_sub_C hroots
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp : p.Monic
hroots : Multiset.card p.roots = p.natDegree
⊢ (Multiset.map (fun a => X - C a) p.roots).prod = p
state_after: case h.e'_2
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp : p.Monic
hroots : Multiset.card p.roots = p.natDegree
⊢ (Multiset.map (fun a => X - C a) p.roots).prod = C p.leadingCoeff * (Multiset.map (fun a => X - C a) p.roots).prod

tactic: rw [hp.leadingCoeff, C_1, one_mul]
state_before: case h.e'_2
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp : p.Monic
hroots : Multiset.card p.roots = p.natDegree
⊢ (Multiset.map (fun a => X - C a) p.roots).prod = C p.leadingCoeff * (Multiset.map (fun a => X - C a) p.roots).prod
state_after: no goals
Theorem: Ordinal.type_fin
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simp
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
n : ℕ
⊢ (type fun x x_1 => x < x_1) = ↑n
state_after: no goals