tasksource/leandojo huggingface dataset:
Theorem: Pmf.bindOnSupport_eq_bind
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: ext b
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.108006
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
f : α → Pmf β
⊢ (bindOnSupport p fun a x => f a) = bind p f

tactic: have : ∀ a, ite (p a = 0) 0 (p a * f a b) = p a * f a b :=
  fun a => ite_eq_right_iff.2 fun h => h.symm ▸ symm (MulZeroClass.zero_mul <| f a b)
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.108006
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
f : α → Pmf β
b : β
⊢ ↑(bindOnSupport p fun a x => f a) b = ↑(bind p f) b

tactic: simp only [bindOnSupport_apply fun a _ => f a, p.bind_apply f, dite_eq_ite, mul_ite,
  MulZeroClass.mul_zero, this]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.108006
p✝ : Pmf α
f✝ : (a : α) → a ∈ support p✝ → Pmf β
p : Pmf α
f : α → Pmf β
b : β
this : ∀ (a : α), (if ↑p a = 0 then 0 else ↑p a * ↑(f a) b) = ↑p a * ↑(f a) b
⊢ ↑(bindOnSupport p fun a x => f a) b = ↑(bind p f) b
Theorem: Nat.Linear.Poly.isNum?_eq_some
File: src/lean/Init/Data/Nat/Linear.lean

tactic: simp [isNum?]
state_before: ctx : Context
p : Poly
k : Nat
⊢ isNum? p = some k → denote ctx p = k

tactic: split
state_before: ctx : Context
p : Poly
k : Nat
⊢ (match p with
      | [] => some 0
      | [(k, v)] => bif v == fixedVar then some k else none
      | x => none) =
      some k →
    denote ctx p = k

tactic: next => intro h; injection h
state_before: case h_1
ctx : Context
k : Nat
p✝ : Poly
⊢ some 0 = some k → denote ctx [] = k

case h_2
ctx : Context
k : Nat
p✝ : Poly
k✝ : Nat
v✝ : Var
⊢ (bif v✝ == fixedVar then some k✝ else none) = some k → denote ctx [(k✝, v✝)] = k

case h_3
ctx : Context
p : Poly
k : Nat
p✝ : Poly
x✝¹ : p = [] → False
x✝ : ∀ (k : Nat) (v : Var), p = [(k, v)] → False
⊢ none = some k → denote ctx p = k

tactic: next k v => by_cases h : v == fixedVar <;> simp [h]; intros; simp [Var.denote, eq_of_beq h]; assumption
state_before: case h_2
ctx : Context
k : Nat
p✝ : Poly
k✝ : Nat
v✝ : Var
⊢ (bif v✝ == fixedVar then some k✝ else none) = some k → denote ctx [(k✝, v✝)] = k

case h_3
ctx : Context
p : Poly
k : Nat
p✝ : Poly
x✝¹ : p = [] → False
x✝ : ∀ (k : Nat) (v : Var), p = [(k, v)] → False
⊢ none = some k → denote ctx p = k

tactic: next => intros; contradiction
state_before: case h_3
ctx : Context
p : Poly
k : Nat
p✝ : Poly
x✝¹ : p = [] → False
x✝ : ∀ (k : Nat) (v : Var), p = [(k, v)] → False
⊢ none = some k → denote ctx p = k

tactic: intro h
state_before: ctx : Context
k : Nat
p✝ : Poly
⊢ some 0 = some k → denote ctx [] = k

tactic: injection h
state_before: ctx : Context
k : Nat
p✝ : Poly
h : some 0 = some k
⊢ denote ctx [] = k

tactic: by_cases h : v == fixedVar <;> simp [h]
state_before: ctx : Context
k✝ : Nat
p✝ : Poly
k : Nat
v : Var
⊢ (bif v == fixedVar then some k else none) = some k✝ → denote ctx [(k, v)] = k✝

tactic: intros
state_before: case inl
ctx : Context
k✝ : Nat
p✝ : Poly
k : Nat
v : Var
h : (v == fixedVar) = true
⊢ k = k✝ → k * Var.denote ctx v = k✝

tactic: simp [Var.denote, eq_of_beq h]
state_before: case inl
ctx : Context
k✝ : Nat
p✝ : Poly
k : Nat
v : Var
h : (v == fixedVar) = true
a✝ : k = k✝
⊢ k * Var.denote ctx v = k✝

tactic: assumption
state_before: case inl
ctx : Context
k✝ : Nat
p✝ : Poly
k : Nat
v : Var
h : (v == fixedVar) = true
a✝ : k = k✝
⊢ k = k✝

tactic: intros
state_before: ctx : Context
p : Poly
k : Nat
p✝ : Poly
x✝¹ : p = [] → False
x✝ : ∀ (k : Nat) (v : Var), p = [(k, v)] → False
⊢ none = some k → denote ctx p = k

tactic: contradiction
state_before: ctx : Context
p : Poly
k : Nat
p✝ : Poly
x✝¹ : p = [] → False
x✝ : ∀ (k : Nat) (v : Var), p = [(k, v)] → False
a✝ : none = some k
⊢ denote ctx p = k
Theorem: CategoryTheory.Limits.IsBilimit.total
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: cases j
state_before: C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
f : J → C
b : Bicone f
i : Bicone.IsBilimit b
j : Discrete J
⊢ (∑ j : J, Bicone.π b j ≫ Bicone.ι b j) ≫ (Bicone.toCone b).π.app j = 𝟙 b.pt ≫ (Bicone.toCone b).π.app j

tactic: simp [sum_comp, b.ι_π, comp_dite]
state_before: case mk
C : Type u
inst✝² : Category C
inst✝¹ : Preadditive C
J : Type
inst✝ : Fintype J
f : J → C
b : Bicone f
i : Bicone.IsBilimit b
as✝ : J
⊢ (∑ j : J, Bicone.π b j ≫ Bicone.ι b j) ≫ (Bicone.toCone b).π.app { as := as✝ } =
    𝟙 b.pt ≫ (Bicone.toCone b).π.app { as := as✝ }
Theorem: Order.Ideal.toLowerSet_injective
File: Mathlib/Order/Ideal.lean

tactic: cases s
state_before: P : Type u_1
inst✝ : LE P
I J s✝ t✝ : Ideal P
x y : P
s t : Ideal P
x✝ : s.toLowerSet = t.toLowerSet
⊢ s = t

tactic: cases t
state_before: case mk
P : Type u_1
inst✝ : LE P
I J s t✝ : Ideal P
x y : P
t : Ideal P
toLowerSet✝ : LowerSet P
nonempty'✝ : Set.Nonempty toLowerSet✝.carrier
directed'✝ : DirectedOn (fun x x_1 => x ≤ x_1) toLowerSet✝.carrier
x✝ : { toLowerSet := toLowerSet✝, nonempty' := nonempty'✝, directed' := directed'✝ }.toLowerSet = t.toLowerSet
⊢ { toLowerSet := toLowerSet✝, nonempty' := nonempty'✝, directed' := directed'✝ } = t

tactic: congr
state_before: case mk.mk
P : Type u_1
inst✝ : LE P
I J s t : Ideal P
x y : P
toLowerSet✝¹ : LowerSet P
nonempty'✝¹ : Set.Nonempty toLowerSet✝¹.carrier
directed'✝¹ : DirectedOn (fun x x_1 => x ≤ x_1) toLowerSet✝¹.carrier
toLowerSet✝ : LowerSet P
nonempty'✝ : Set.Nonempty toLowerSet✝.carrier
directed'✝ : DirectedOn (fun x x_1 => x ≤ x_1) toLowerSet✝.carrier
x✝ :
  { toLowerSet := toLowerSet✝¹, nonempty' := nonempty'✝¹, directed' := directed'✝¹ }.toLowerSet =
    { toLowerSet := toLowerSet✝, nonempty' := nonempty'✝, directed' := directed'✝ }.toLowerSet
⊢ { toLowerSet := toLowerSet✝¹, nonempty' := nonempty'✝¹, directed' := directed'✝¹ } =
    { toLowerSet := toLowerSet✝, nonempty' := nonempty'✝, directed' := directed'✝ }
Theorem: CategoryTheory.Over.OverMorphism.ext
File: Mathlib/CategoryTheory/Over.lean

tactic: let ⟨_,b,_⟩ := f
state_before: T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Over X
f g : U ⟶ V
h : f.left = g.left
⊢ f = g

tactic: let ⟨_,e,_⟩ := g
state_before: T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Over X
f g : U ⟶ V
left✝ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝ : (𝟭 T).map left✝ ≫ V.hom = U.hom ≫ (Functor.fromPUnit X).map b
h : (CommaMorphism.mk left✝ b).left = g.left
⊢ CommaMorphism.mk left✝ b = g

tactic: congr
state_before: T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Over X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (𝟭 T).map left✝¹ ≫ V.hom = U.hom ≫ (Functor.fromPUnit X).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (𝟭 T).map left✝ ≫ V.hom = U.hom ≫ (Functor.fromPUnit X).map e
h : (CommaMorphism.mk left✝¹ b).left = (CommaMorphism.mk left✝ e).left
⊢ CommaMorphism.mk left✝¹ b = CommaMorphism.mk left✝ e

tactic: simp only [eq_iff_true_of_subsingleton]
state_before: case e_right
T : Type u₁
inst✝ : Category T
X✝ X : T
U V : Over X
f g : U ⟶ V
left✝¹ : U.left ⟶ V.left
b : U.right ⟶ V.right
w✝¹ : (𝟭 T).map left✝¹ ≫ V.hom = U.hom ≫ (Functor.fromPUnit X).map b
left✝ : U.left ⟶ V.left
e : U.right ⟶ V.right
w✝ : (𝟭 T).map left✝ ≫ V.hom = U.hom ≫ (Functor.fromPUnit X).map e
h : (CommaMorphism.mk left✝¹ b).left = (CommaMorphism.mk left✝ e).left
⊢ b = e
Theorem: BilinForm.IsAdjointPair.sub
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [LinearMap.sub_apply, LinearMap.sub_apply, sub_left, sub_right, h, h']
state_before: R : Type ?u.1050969
M : Type ?u.1050972
inst✝²² : Semiring R
inst✝²¹ : AddCommMonoid M
inst✝²⁰ : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹⁹ : Ring R₁
inst✝¹⁸ : AddCommGroup M₁
inst✝¹⁷ : Module R₁ M₁
R₂ : Type ?u.1051620
M₂ : Type ?u.1051623
inst✝¹⁶ : CommSemiring R₂
inst✝¹⁵ : AddCommMonoid M₂
inst✝¹⁴ : Module R₂ M₂
R₃ : Type ?u.1051810
M₃ : Type ?u.1051813
inst✝¹³ : CommRing R₃
inst✝¹² : AddCommGroup M₃
inst✝¹¹ : Module R₃ M₃
V : Type ?u.1052401
K : Type ?u.1052404
inst✝¹⁰ : Field K
inst✝⁹ : AddCommGroup V
inst✝⁸ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
M₂' : Type ?u.1053618
M₂'' : Type ?u.1053621
inst✝⁷ : AddCommMonoid M₂'
inst✝⁶ : AddCommMonoid M₂''
inst✝⁵ : Module R₂ M₂'
inst✝⁴ : Module R₂ M₂''
F : BilinForm R M
M' : Type ?u.1053932
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
B' : BilinForm R M'
f f' : M →ₗ[R] M'
g g' : M' →ₗ[R] M
M₁' : Type u_3
inst✝¹ : AddCommGroup M₁'
inst✝ : Module R₁ M₁'
B₁' : BilinForm R₁ M₁'
f₁ f₁' : M₁ →ₗ[R₁] M₁'
g₁ g₁' : M₁' →ₗ[R₁] M₁
h : IsAdjointPair B₁ B₁' f₁ g₁
h' : IsAdjointPair B₁ B₁' f₁' g₁'
x : M₁
y : M₁'
⊢ bilin B₁' (↑(f₁ - f₁') x) y = bilin B₁ x (↑(g₁ - g₁') y)
Theorem: IsHilbertSum.linearIsometryEquiv_symm_apply_dfinsupp_sum_single
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: simp [IsHilbertSum.linearIsometryEquiv, OrthogonalFamily.linearIsometry_apply_dfinsupp_sum_single]
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
V : (i : ι) → G i →ₗᵢ[𝕜] E
F : ι → Submodule 𝕜 E
hV : IsHilbertSum 𝕜 G V
W₀ : Π₀ (i : ι), G i
⊢ ↑(LinearIsometryEquiv.symm (linearIsometryEquiv hV)) (Dfinsupp.sum W₀ (lp.single 2)) = Dfinsupp.sum W₀ fun i => ↑(V i)
Theorem: zpow_strictMono_left
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: rw [← one_lt_div', ← div_zpow]
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 < n
a b : α
hab : a < b
⊢ (fun x => x ^ n) a < (fun x => x ^ n) b

tactic: exact one_lt_zpow' (one_lt_div'.2 hab) hn
state_before: α : Type u_1
M : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝ : OrderedCommGroup α
m n : ℤ
a✝ b✝ : α
hn : 0 < n
a b : α
hab : a < b
⊢ 1 < (b / a) ^ n
Theorem: List.scanl_cons
File: Mathlib/Data/List/Basic.lean

tactic: simp only [scanl, eq_self_iff_true, singleton_append, and_self_iff]
state_before: ι : Type ?u.239529
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : β → α → β
b : β
a : α
l : List α
⊢ scanl f b (a :: l) = [b] ++ scanl f (f b a) l
Theorem: LieAlgebra.derivedSeriesOfIdeal_add
File: Mathlib/Algebra/Lie/Solvable.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
k l : ℕ
⊢ D (k + l) I = D k (D l I)

tactic: rw [Nat.zero_add, derivedSeriesOfIdeal_zero]
state_before: case zero
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
l : ℕ
⊢ D (Nat.zero + l) I = D Nat.zero (D l I)

tactic: rw [Nat.succ_add k l, derivedSeriesOfIdeal_succ, derivedSeriesOfIdeal_succ, ih]
state_before: case succ
R : Type u
L : Type v
M : Type w
L' : Type w₁
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I J : LieIdeal R L
f : L' →ₗ⁅R⁆ L
l k : ℕ
ih : D (k + l) I = D k (D l I)
⊢ D (Nat.succ k + l) I = D (Nat.succ k) (D l I)
Theorem: BilinForm.zero_left
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [← @zero_smul R _ _ _ _ (0 : M), smul_left, MulZeroClass.zero_mul]
state_before: R : Type u_1
M : Type u_2
inst✝¹⁴ : Semiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type ?u.37057
M₁ : Type ?u.37060
inst✝¹¹ : Ring R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
R₂ : Type ?u.37669
M₂ : Type ?u.37672
inst✝⁸ : CommSemiring R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
R₃ : Type ?u.37859
M₃ : Type ?u.37862
inst✝⁵ : CommRing R₃
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R₃ M₃
V : Type ?u.38450
K : Type ?u.38453
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
x : M
⊢ bilin B 0 x = 0
Theorem: ConvexBody.hausdorffEdist_ne_top
File: Mathlib/Analysis/Convex/Body.lean

tactic: apply_rules [Metric.hausdorffEdist_ne_top_of_nonempty_of_bounded, ConvexBody.nonempty,
  ConvexBody.bounded]
state_before: V : Type u_1
inst✝¹ : SeminormedAddCommGroup V
inst✝ : NormedSpace ℝ V
K✝ L✝ K L : ConvexBody V
⊢ EMetric.hausdorffEdist ↑K ↑L ≠ ⊤
Theorem: Equiv.piCongr'_symm_apply_symm_apply
File: Mathlib/Logic/Equiv/Basic.lean

tactic: change Eq.ndrec _ _ = _
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b : β
⊢ ↑(piCongr' h₁ h₂).symm f (↑h₁.symm b) = ↑(h₂ b).symm (f b)

tactic: generalize_proofs hWb
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b : β
⊢ (_ : ↑h₁.symm.symm.symm (↑h₁.symm.symm (↑h₁.symm b)) = ↑h₁.symm b) ▸
      ↑(piCongrRight fun b => (h₂ b).symm) f (↑h₁.symm.symm (↑h₁.symm b)) =
    ↑(h₂ b).symm (f b)

tactic: revert hWb
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b : β
hWb : ↑h₁.symm.symm.symm (↑h₁.symm.symm (↑h₁.symm b)) = ↑h₁.symm b
⊢ hWb ▸ ↑(piCongrRight fun b => (h₂ b).symm) f (↑h₁.symm.symm (↑h₁.symm b)) = ↑(h₂ b).symm (f b)

tactic: generalize hb : h₁ (h₁.symm b) = b'
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b : β
⊢ ∀ (hWb : ↑h₁.symm.symm.symm (↑h₁.symm.symm (↑h₁.symm b)) = ↑h₁.symm b),
    hWb ▸ ↑(piCongrRight fun b => (h₂ b).symm) f (↑h₁.symm.symm (↑h₁.symm b)) = ↑(h₂ b).symm (f b)

tactic: rw [h₁.apply_symm_apply b] at hb
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b b' : β
hb : ↑h₁ (↑h₁.symm b) = b'
⊢ ∀ (hWb : ↑h₁.symm.symm.symm b' = ↑h₁.symm b), hWb ▸ ↑(piCongrRight fun b => (h₂ b).symm) f b' = ↑(h₂ b).symm (f b)

tactic: subst hb
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b b' : β
hb : b = b'
⊢ ∀ (hWb : ↑h₁.symm.symm.symm b' = ↑h₁.symm b), hWb ▸ ↑(piCongrRight fun b => (h₂ b).symm) f b' = ↑(h₂ b).symm (f b)

tactic: simp
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b : β
⊢ ∀ (hWb : ↑h₁.symm.symm.symm b = ↑h₁.symm b), hWb ▸ ↑(piCongrRight fun b => (h₂ b).symm) f b = ↑(h₂ b).symm (f b)

tactic: rfl
state_before: α : Sort u_1
β : Sort u_2
W : α → Sort w
Z : β → Sort z
h₁ : α ≃ β
h₂ : (b : β) → W (↑h₁.symm b) ≃ Z b
f : (b : β) → Z b
b : β
⊢ ↑(piCongrRight fun b => (h₂ b).symm) f b = ↑(h₂ b).symm (f b)
Theorem: List.Nodup.filterMap
File: Mathlib/Data/List/Nodup.lean

tactic: rw [← e]
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a✝ b✝ : α
f : α → Option β
h : ∀ (a a' : α) (b : β), b ∈ f a → b ∈ f a' → a = a'
a a' : α
n : a ≠ a'
b : β
bm : b ∈ f a
b' : β
bm' : b' ∈ f a'
e : b = b'
⊢ b' ∈ f a

tactic: exact bm
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a✝ b✝ : α
f : α → Option β
h : ∀ (a a' : α) (b : β), b ∈ f a → b ∈ f a' → a = a'
a a' : α
n : a ≠ a'
b : β
bm : b ∈ f a
b' : β
bm' : b' ∈ f a'
e : b = b'
⊢ b ∈ f a
Theorem: MeasureTheory.zero_mem_ℒp'
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: convert zero_memℒp (E := E)
state_before: α : Type u_2
E : Type u_1
F : Type ?u.936435
G : Type ?u.936438
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
⊢ Memℒp (fun x => 0) p
Theorem: Polynomial.natDegree_opRingEquiv
File: Mathlib/RingTheory/Polynomial/Opposites.lean

tactic: by_cases p0 : p = 0
state_before: R : Type u_1
inst✝ : Semiring R
p : R[X]ᵐᵒᵖ
⊢ natDegree (↑(opRingEquiv R) p) = natDegree (unop p)

tactic: simp only [p0, _root_.map_zero, natDegree_zero, unop_zero]
state_before: case pos
R : Type u_1
inst✝ : Semiring R
p : R[X]ᵐᵒᵖ
p0 : p = 0
⊢ natDegree (↑(opRingEquiv R) p) = natDegree (unop p)

tactic: simp only [p0, natDegree_eq_support_max', Ne.def, AddEquivClass.map_eq_zero_iff, not_false_iff,
  support_opRingEquiv, unop_eq_zero_iff]
state_before: case neg
R : Type u_1
inst✝ : Semiring R
p : R[X]ᵐᵒᵖ
p0 : ¬p = 0
⊢ natDegree (↑(opRingEquiv R) p) = natDegree (unop p)
Theorem: Metric.exists_lt_mem_ball_of_mem_ball
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp only [mem_ball] at h ⊢
state_before: α : Type u
β : Type v
X : Type ?u.26466
ι : Type ?u.26469
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : x ∈ ball y ε
⊢ ∃ ε', ε' < ε ∧ x ∈ ball y ε'

tactic: exact ⟨(dist x y + ε) / 2, by linarith, by linarith⟩
state_before: α : Type u
β : Type v
X : Type ?u.26466
ι : Type ?u.26469
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : dist x y < ε
⊢ ∃ ε', ε' < ε ∧ dist x y < ε'

tactic: linarith
state_before: α : Type u
β : Type v
X : Type ?u.26466
ι : Type ?u.26469
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : dist x y < ε
⊢ (dist x y + ε) / 2 < ε

tactic: linarith
state_before: α : Type u
β : Type v
X : Type ?u.26466
ι : Type ?u.26469
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
h : dist x y < ε
⊢ dist x y < (dist x y + ε) / 2
Theorem: TypeVec.append_prod_appendFun
File: Mathlib/Data/TypeVec.lean

tactic: ext (i a)
state_before: n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁))

tactic: cases i
state_before: case a.h
n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
i : Fin2 (n + 1)
a : ((α ⊗ β) ::: (φ × ψ)) i
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) i a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) i a

tactic: . cases a
  rfl
state_before: case a.h.fz
n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
a : ((α ⊗ β) ::: (φ × ψ)) Fin2.fz
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) Fin2.fz a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) Fin2.fz a

case a.h.fs
n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
a✝ : Fin2 (Nat.add n 0)
a : ((α ⊗ β) ::: (φ × ψ)) (Fin2.fs a✝)
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) (Fin2.fs a✝) a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) (Fin2.fs a✝) a

tactic: . rfl
state_before: case a.h.fs
n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
a✝ : Fin2 (Nat.add n 0)
a : ((α ⊗ β) ::: (φ × ψ)) (Fin2.fs a✝)
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) (Fin2.fs a✝) a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) (Fin2.fs a✝) a

tactic: cases a
state_before: case a.h.fz
n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
a : ((α ⊗ β) ::: (φ × ψ)) Fin2.fz
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) Fin2.fz a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) Fin2.fz a

tactic: rfl
state_before: case a.h.fz.mk
n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
fst✝ : φ
snd✝ : ψ
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) Fin2.fz (fst✝, snd✝) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) Fin2.fz (fst✝, snd✝)

tactic: rfl
state_before: case a.h.fs
n✝ n : ℕ
α α' β β' : TypeVec n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
a✝ : Fin2 (Nat.add n 0)
a : ((α ⊗ β) ::: (φ × ψ)) (Fin2.fs a✝)
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) (Fin2.fs a✝) a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) (Fin2.fs a✝) a
Theorem: Int.dvd_div_of_mul_dvd
File: Mathlib/Data/Int/Order/Lemmas.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: a✝ b✝ : ℤ
n : ℕ
a b c : ℤ
h : a * b ∣ c
⊢ b ∣ c / a

tactic: rcases h with ⟨d, rfl⟩
state_before: case inr
a✝ b✝ : ℤ
n : ℕ
a b c : ℤ
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a

tactic: refine' ⟨d, _⟩
state_before: case inr.intro
a✝ b✝ : ℤ
n : ℕ
a b : ℤ
ha : a ≠ 0
d : ℤ
⊢ b ∣ a * b * d / a

tactic: rw [mul_assoc, Int.mul_ediv_cancel_left _ ha]
state_before: case inr.intro
a✝ b✝ : ℤ
n : ℕ
a b : ℤ
ha : a ≠ 0
d : ℤ
⊢ a * b * d / a = b * d

tactic: simp only [Int.ediv_zero, dvd_zero]
state_before: case inl
a b✝ : ℤ
n : ℕ
b c : ℤ
h : 0 * b ∣ c
⊢ b ∣ c / 0
Theorem: intervalIntegral.smul_integral_comp_mul_add
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: by_cases hc : c = 0 <;> simp [hc, integral_comp_mul_add]
state_before: ι : Type ?u.14875219
𝕜 : Type ?u.14875222
E : Type u_1
F : Type ?u.14875228
A : Type ?u.14875231
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b c✝ d✝ : ℝ
f : ℝ → E
c d : ℝ
⊢ (c • ∫ (x : ℝ) in a..b, f (c * x + d)) = ∫ (x : ℝ) in c * a + d..c * b + d, f x
Theorem: le_mul_left
File: Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean

tactic: simp
state_before: α : Type u
inst✝ : CanonicallyOrderedMonoid α
a b c d : α
h : a ≤ c
⊢ a = 1 * a
Theorem: MeasureTheory.pow_mul_meas_ge_le_snorm
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: rw [snorm_eq_lintegral_rpow_nnnorm hp_ne_zero hp_ne_top]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4265033
G : Type ?u.4265036
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (ε * ↑↑μ {x | ε ≤ ↑‖f x‖₊ ^ ENNReal.toReal p}) ^ (1 / ENNReal.toReal p) ≤ snorm f p μ

tactic: exact
  ENNReal.rpow_le_rpow (mul_meas_ge_le_lintegral₀ (hf.ennnorm.pow_const _) ε)
    (one_div_nonneg.2 ENNReal.toReal_nonneg)
state_before: α : Type u_1
E : Type u_2
F : Type ?u.4265033
G : Type ?u.4265036
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → E
hp_ne_zero : p ≠ 0
hp_ne_top : p ≠ ⊤
hf : AEStronglyMeasurable f μ
ε : ℝ≥0∞
⊢ (ε * ↑↑μ {x | ε ≤ ↑‖f x‖₊ ^ ENNReal.toReal p}) ^ (1 / ENNReal.toReal p) ≤
    (∫⁻ (x : α), ↑‖f x‖₊ ^ ENNReal.toReal p ∂μ) ^ (1 / ENNReal.toReal p)
Theorem: Option.ball_ne_none
File: Std/Data/Option/Lemmas.lean

tactic: have := h <| x.get <| ne_none_iff_isSome.1 hx
state_before: α : Type u_1
p : Option α → Prop
h : ∀ (x : α), p (some x)
x : Option α
hx : x ≠ none
⊢ p x

tactic: simp [some_get] at this ⊢
state_before: α : Type u_1
p : Option α → Prop
h : ∀ (x : α), p (some x)
x : Option α
hx : x ≠ none
this : p (some (get x (_ : isSome x = true)))
⊢ p x

tactic: exact this
state_before: α : Type u_1
p : Option α → Prop
h : ∀ (x : α), p (some x)
x : Option α
hx : x ≠ none
this : p x
⊢ p x