tasksource/leandojo huggingface dataset:
Theorem: Hindman.FP_drop_subset_FP
File: Mathlib/Combinatorics/Hindman.lean

tactic: induction' n with n ih
state_before: M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
⊢ FP (Stream'.drop n a) ⊆ FP a

tactic: rw [Nat.succ_eq_one_add, ← Stream'.drop_drop]
state_before: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop (Nat.succ n) a) ⊆ FP a

tactic: exact _root_.trans (FP.tail _) ih
state_before: case succ
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
n : ℕ
ih : FP (Stream'.drop n a) ⊆ FP a
⊢ FP (Stream'.drop 1 (Stream'.drop n a)) ⊆ FP a

tactic: rfl
state_before: case zero
M : Type u_1
inst✝ : Semigroup M
a : Stream' M
⊢ FP (Stream'.drop Nat.zero a) ⊆ FP a
Theorem: Asymptotics.isTheta_of_norm_eventuallyEq'
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simp only [← hx, norm_norm]
state_before: α : Type u_1
β : Type ?u.24296
E : Type ?u.24299
F : Type ?u.24302
G : Type ?u.24305
E' : Type u_2
F' : Type ?u.24311
G' : Type ?u.24314
E'' : Type ?u.24317
F'' : Type ?u.24320
G'' : Type ?u.24323
R : Type ?u.24326
R' : Type ?u.24329
𝕜 : Type ?u.24332
𝕜' : Type ?u.24335
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''
l l' : Filter α
g : α → ℝ
h : (fun x => ‖f' x‖) =ᶠ[l] g
x : α
hx : (fun x => ‖f' x‖) x = g x
⊢ (fun x => ‖f' x‖) x = (fun x => ‖g x‖) x
Theorem: Function.Antiperiodic.const_smul₀
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [smul_add, smul_inv_smul₀ ha] using h (a • x)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝³ : AddCommMonoid α
inst✝² : Neg β
inst✝¹ : DivisionSemiring γ
inst✝ : Module γ α
h : Antiperiodic f c
a : γ
ha : a ≠ 0
x : α
⊢ (fun x => f (a • x)) (x + a⁻¹ • c) = -(fun x => f (a • x)) x
Theorem: Mon_.mul_leftUnitor
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: rw [← Category.comp_id (λ_ (𝟙_ C)).hom, ← Category.id_comp M.mul, tensor_comp]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ M.mul)) ≫ (λ_ M.X).hom =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul

tactic: slice_lhs 3 4 => rw [leftUnitor_naturality]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ (tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (𝟙 (𝟙_ C) ⊗ M.mul)) ≫ (λ_ M.X).hom =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

tactic: slice_lhs 1 3 => rw [← leftUnitor_monoidal]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ tensor_μ C (𝟙_ C, M.X) (𝟙_ C, M.X) ≫ ((λ_ (𝟙_ C)).hom ⊗ 𝟙 (M.X ⊗ M.X)) ≫ (λ_ (M.X ⊗ M.X)).hom ≫ M.mul =
    ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul

tactic: simp only [Category.assoc, Category.id_comp]
state_before: C : Type u₁
inst✝² : Category C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
M : Mon_ C
⊢ ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ M.mul = ((λ_ M.X).hom ⊗ (λ_ M.X).hom) ≫ 𝟙 (M.X ⊗ M.X) ≫ M.mul
Theorem: MeasureTheory.lintegral_one
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [lintegral_const, one_mul]
state_before: α : Type u_1
β : Type ?u.75222
γ : Type ?u.75225
δ : Type ?u.75228
m : MeasurableSpace α
μ ν : Measure α
⊢ (∫⁻ (x : α), 1 ∂μ) = ↑↑μ univ
Theorem: Nat.Linear.Poly.mul.go_denote
File: src/lean/Init/Data/Nat/Linear.lean

tactic: match p with
| [] => rfl
| (k', v) :: p => simp [Poly.mul.go, go_denote]
state_before: ctx : Context
k : Nat
p : Poly
⊢ denote ctx (go k p) = k * denote ctx p

tactic: rfl
state_before: ctx : Context
k : Nat
p : Poly
⊢ denote ctx (go k []) = k * denote ctx []

tactic: simp [Poly.mul.go, go_denote]
state_before: ctx : Context
k : Nat
p✝ : Poly
k' : Nat
v : Var
p : List (Nat × Var)
⊢ denote ctx (go k ((k', v) :: p)) = k * denote ctx ((k', v) :: p)
Theorem: Set.iUnion₂_prod_const
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [iUnion_prod_const]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.232320
ι : Sort u_3
ι' : Sort ?u.232326
ι₂ : Sort ?u.232329
κ : ι → Sort u_4
κ₁ : ι → Sort ?u.232339
κ₂ : ι → Sort ?u.232344
κ' : ι' → Sort ?u.232349
s : (i : ι) → κ i → Set α
t : Set β
⊢ (⋃ (i : ι) (j : κ i), s i j) ×ˢ t = ⋃ (i : ι) (j : κ i), s i j ×ˢ t
Theorem: InnerProductGeometry.norm_div_tan_angle_sub_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x y = 0
h0 : x = 0 ∨ y ≠ 0
⊢ ‖y‖ / Real.tan (angle x (x - y)) = ‖x‖

tactic: rw [← neg_ne_zero] at h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x = 0 ∨ y ≠ 0
⊢ ‖y‖ / Real.tan (angle x (x - y)) = ‖x‖

tactic: rw [sub_eq_add_neg, ← norm_neg, norm_div_tan_angle_add_of_inner_eq_zero h h0]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : inner x (-y) = 0
h0 : x = 0 ∨ -y ≠ 0
⊢ ‖y‖ / Real.tan (angle x (x - y)) = ‖x‖
Theorem: TopCat.of_isoOfHomeo
File: Mathlib/Topology/Category/TopCat/Basic.lean

tactic: dsimp [homeoOfIso, isoOfHomeo]
state_before: X Y : TopCat
f : ↑X ≃ₜ ↑Y
⊢ homeoOfIso (isoOfHomeo f) = f

tactic: ext
state_before: X Y : TopCat
f : ↑X ≃ₜ ↑Y
⊢ Homeomorph.mk
      { toFun := (forget TopCat).map (Homeomorph.toContinuousMap f),
        invFun := (forget TopCat).map (Homeomorph.toContinuousMap (Homeomorph.symm f)),
        left_inv :=
          (_ :
            ∀ (x : ↑X),
              (forget TopCat).map
                  (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).inv
                  ((forget TopCat).map
                    (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).hom x) =
                x),
        right_inv :=
          (_ :
            ∀ (x : ↑Y),
              (forget TopCat).map
                  (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).hom
                  ((forget TopCat).map
                    (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).inv x) =
                x) } =
    f

tactic: rfl
state_before: case H
X Y : TopCat
f : ↑X ≃ₜ ↑Y
x✝ : ↑X
⊢ ↑(Homeomorph.mk
          { toFun := (forget TopCat).map (Homeomorph.toContinuousMap f),
            invFun := (forget TopCat).map (Homeomorph.toContinuousMap (Homeomorph.symm f)),
            left_inv :=
              (_ :
                ∀ (x : ↑X),
                  (forget TopCat).map
                      (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).inv
                      ((forget TopCat).map
                        (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).hom
                        x) =
                    x),
            right_inv :=
              (_ :
                ∀ (x : ↑Y),
                  (forget TopCat).map
                      (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).hom
                      ((forget TopCat).map
                        (Iso.mk (Homeomorph.toContinuousMap f) (Homeomorph.toContinuousMap (Homeomorph.symm f))).inv
                        x) =
                    x) })
      x✝ =
    ↑f x✝
Theorem: TypeVec.fst_prod_mk
File: Mathlib/Data/TypeVec.lean

tactic: funext i
state_before: n : ℕ
α α' β β' : TypeVec n
f : α ⟹ β
g : α' ⟹ β'
⊢ prod.fst ⊚ (f ⊗' g) = f ⊚ prod.fst

tactic: induction i
state_before: case h
n : ℕ
α α' β β' : TypeVec n
f : α ⟹ β
g : α' ⟹ β'
i : Fin2 n
⊢ (prod.fst ⊚ (f ⊗' g)) i = (f ⊚ prod.fst) i

tactic: case fz => rfl
state_before: case h.fz
n n✝ : ℕ
α α' β β' : TypeVec (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) Fin2.fz = (f ⊚ prod.fst) Fin2.fz

case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α α' β β' : TypeVec n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.fst ⊚ (f ⊗' g)) a✝ = (f ⊚ prod.fst) a✝
α α' β β' : TypeVec (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) (Fin2.fs a✝) = (f ⊚ prod.fst) (Fin2.fs a✝)

tactic: case fs _ _ i_ih => apply i_ih
state_before: case h.fs
n n✝ : ℕ
a✝ : Fin2 n✝
a_ih✝ : ∀ {α α' β β' : TypeVec n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.fst ⊚ (f ⊗' g)) a✝ = (f ⊚ prod.fst) a✝
α α' β β' : TypeVec (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) (Fin2.fs a✝) = (f ⊚ prod.fst) (Fin2.fs a✝)

tactic: rfl
state_before: n n✝ : ℕ
α α' β β' : TypeVec (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) Fin2.fz = (f ⊚ prod.fst) Fin2.fz

tactic: apply i_ih
state_before: n n✝ : ℕ
a✝ : Fin2 n✝
i_ih : ∀ {α α' β β' : TypeVec n✝} (f : α ⟹ β) (g : α' ⟹ β'), (prod.fst ⊚ (f ⊗' g)) a✝ = (f ⊚ prod.fst) a✝
α α' β β' : TypeVec (succ n✝)
f : α ⟹ β
g : α' ⟹ β'
⊢ (prod.fst ⊚ (f ⊗' g)) (Fin2.fs a✝) = (f ⊚ prod.fst) (Fin2.fs a✝)
Theorem: finAddFlip_apply_mk_left
File: Mathlib/Logic/Equiv/Fin.lean

tactic: convert finAddFlip_apply_castAdd ⟨k, h⟩ n
state_before: m n k : ℕ
h : k < m
hk : optParam (k < m + n) (_ : k < m + n)
hnk : optParam (n + k < n + m) (_ : n + k < n + m)
⊢ ↑finAddFlip { val := k, isLt := hk } = { val := n + k, isLt := hnk }
Theorem: CategoryTheory.MonoidalCategory.associator_inv_conjugation
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [associator_naturality, inv_hom_id_assoc]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X✝ Y✝ Z✝ X X' Y Y' Z Z' : C
f : X ⟶ X'
g : Y ⟶ Y'
h : Z ⟶ Z'
⊢ f ⊗ g ⊗ h = (α_ X Y Z).inv ≫ ((f ⊗ g) ⊗ h) ≫ (α_ X' Y' Z').hom
Theorem: CategoryTheory.Bicategory.leftUnitor_inv_whiskerRight
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ inv ((λ_ f).inv ▷ g) = inv ((λ_ (f ≫ g)).inv ≫ (α_ (𝟙 a) f g).inv)
Theorem: Submodule.equivSubtypeMap_symm_apply
File: Mathlib/LinearAlgebra/Basic.lean

tactic: cases x
state_before: R : Type u_1
R₁ : Type ?u.2231117
R₂ : Type ?u.2231120
R₃ : Type ?u.2231123
R₄ : Type ?u.2231126
S : Type ?u.2231129
K : Type ?u.2231132
K₂ : Type ?u.2231135
M : Type u_2
M' : Type ?u.2231141
M₁ : Type ?u.2231144
M₂ : Type ?u.2231147
M₃ : Type ?u.2231150
M₄ : Type ?u.2231153
N : Type ?u.2231156
N₂ : Type ?u.2231159
ι : Type ?u.2231162
V : Type ?u.2231165
V₂ : Type ?u.2231168
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
q : Submodule R { x // x ∈ p }
x : { x // x ∈ map (Submodule.subtype p) q }
⊢ ↑↑(↑(LinearEquiv.symm (equivSubtypeMap p q)) x) = ↑x

tactic: rfl
state_before: case mk
R : Type u_1
R₁ : Type ?u.2231117
R₂ : Type ?u.2231120
R₃ : Type ?u.2231123
R₄ : Type ?u.2231126
S : Type ?u.2231129
K : Type ?u.2231132
K₂ : Type ?u.2231135
M : Type u_2
M' : Type ?u.2231141
M₁ : Type ?u.2231144
M₂ : Type ?u.2231147
M₃ : Type ?u.2231150
M₄ : Type ?u.2231153
N : Type ?u.2231156
N₂ : Type ?u.2231159
ι : Type ?u.2231162
V : Type ?u.2231165
V₂ : Type ?u.2231168
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
p : Submodule R M
q : Submodule R { x // x ∈ p }
val✝ : M
property✝ : val✝ ∈ map (Submodule.subtype p) q
⊢ ↑↑(↑(LinearEquiv.symm (equivSubtypeMap p q)) { val := val✝, property := property✝ }) =
    ↑{ val := val✝, property := property✝ }
Theorem: LieAlgebra.Orthogonal.indefiniteDiagonal_transform
File: Mathlib/Algebra/Lie/Classical.lean

tactic: ext (x y)
state_before: n : Type ?u.52016
p : Type u_1
q : Type u_2
l : Type ?u.52025
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
⊢ (Pso p q R i)ᵀ ⬝ indefiniteDiagonal p q R ⬝ Pso p q R i = 1

tactic: rcases x with ⟨x⟩|⟨x⟩ <;> rcases y with ⟨y⟩|⟨y⟩
state_before: case a.h
n : Type ?u.52016
p : Type u_1
q : Type u_2
l : Type ?u.52025
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : p ⊕ q
⊢ ((Pso p q R i)ᵀ ⬝ indefiniteDiagonal p q R ⬝ Pso p q R i) x y = OfNat.ofNat 1 x y

tactic: by_cases h : x = y <;>
simp [Pso, indefiniteDiagonal, h]
state_before: case a.h.inl.inl
n : Type ?u.52016
p : Type u_1
q : Type u_2
l : Type ?u.52025
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : p
⊢ ((Pso p q R i)ᵀ ⬝ indefiniteDiagonal p q R ⬝ Pso p q R i) (Sum.inl x) (Sum.inl y) =
    OfNat.ofNat 1 (Sum.inl x) (Sum.inl y)

tactic: simp [Pso, indefiniteDiagonal]
state_before: case a.h.inl.inr
n : Type ?u.52016
p : Type u_1
q : Type u_2
l : Type ?u.52025
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x : p
y : q
⊢ ((Pso p q R i)ᵀ ⬝ indefiniteDiagonal p q R ⬝ Pso p q R i) (Sum.inl x) (Sum.inr y) =
    OfNat.ofNat 1 (Sum.inl x) (Sum.inr y)

tactic: simp [Pso, indefiniteDiagonal]
state_before: case a.h.inr.inl
n : Type ?u.52016
p : Type u_1
q : Type u_2
l : Type ?u.52025
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x : q
y : p
⊢ ((Pso p q R i)ᵀ ⬝ indefiniteDiagonal p q R ⬝ Pso p q R i) (Sum.inr x) (Sum.inl y) =
    OfNat.ofNat 1 (Sum.inr x) (Sum.inl y)

tactic: by_cases h : x = y <;>
simp [Pso, indefiniteDiagonal, h, hi]
state_before: case a.h.inr.inr
n : Type ?u.52016
p : Type u_1
q : Type u_2
l : Type ?u.52025
R : Type u₂
inst✝⁶ : DecidableEq n
inst✝⁵ : DecidableEq p
inst✝⁴ : DecidableEq q
inst✝³ : DecidableEq l
inst✝² : CommRing R
inst✝¹ : Fintype p
inst✝ : Fintype q
i : R
hi : i * i = -1
x y : q
⊢ ((Pso p q R i)ᵀ ⬝ indefiniteDiagonal p q R ⬝ Pso p q R i) (Sum.inr x) (Sum.inr y) =
    OfNat.ofNat 1 (Sum.inr x) (Sum.inr y)
Theorem: Monotone.ne_of_lt_of_lt_nat
File: Mathlib/Order/Monotone/Basic.lean

tactic: rintro rfl
state_before: ι : Type ?u.45154
α : Type u
β : Type v
γ : Type w
δ : Type ?u.45163
π : ι → Type ?u.45168
r : α → α → Prop
inst✝ : Preorder α
f : ℕ → α
hf : Monotone f
n : ℕ
x : α
h1 : f n < x
h2 : x < f (n + 1)
a : ℕ
⊢ f a ≠ x

tactic: exact (hf.reflect_lt h1).not_le (Nat.le_of_lt_succ <| hf.reflect_lt h2)
state_before: ι : Type ?u.45154
α : Type u
β : Type v
γ : Type w
δ : Type ?u.45163
π : ι → Type ?u.45168
r : α → α → Prop
inst✝ : Preorder α
f : ℕ → α
hf : Monotone f
n a : ℕ
h1 : f n < f a
h2 : f a < f (n + 1)
⊢ False
Theorem: Orthonormal.linearIsometryEquiv_symm_apply_single_one
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

tactic: rw [IsHilbertSum.linearIsometryEquiv_symm_apply_single, LinearIsometry.toSpanSingleton_apply,
  one_smul]
state_before: ι : Type u_3
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type ?u.899044
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
v : ι → E
hv : Orthonormal 𝕜 v
h : ⊤ ≤ topologicalClosure (span 𝕜 (Set.range v))
i : ι
⊢ ↑(LinearIsometryEquiv.symm
          (IsHilbertSum.linearIsometryEquiv
            (_ : IsHilbertSum 𝕜 (fun x => 𝕜) fun i => LinearIsometry.toSpanSingleton 𝕜 E (_ : ‖v i‖ = 1))))
      (lp.single 2 i 1) =
    v i
Theorem: Set.le_einfsep_pi_of_le
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: refine' le_einfsep fun x hx y hy hxy => _
state_before: α : Type ?u.48758
β : Type u_2
inst✝² : PseudoEMetricSpace α
x y z : α
s✝ t : Set α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoEMetricSpace (π b)
s : (b : β) → Set (π b)
c : ℝ≥0∞
h : ∀ (b : β), c ≤ einfsep (s b)
⊢ c ≤ einfsep (pi univ s)

tactic: rw [mem_univ_pi] at hx hy
state_before: α : Type ?u.48758
β : Type u_2
inst✝² : PseudoEMetricSpace α
x✝ y✝ z : α
s✝ t : Set α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoEMetricSpace (π b)
s : (b : β) → Set (π b)
c : ℝ≥0∞
h : ∀ (b : β), c ≤ einfsep (s b)
x : (i : β) → π i
hx : x ∈ pi univ s
y : (i : β) → π i
hy : y ∈ pi univ s
hxy : x ≠ y
⊢ c ≤ edist x y

tactic: rcases Function.ne_iff.mp hxy with ⟨i, hi⟩
state_before: α : Type ?u.48758
β : Type u_2
inst✝² : PseudoEMetricSpace α
x✝ y✝ z : α
s✝ t : Set α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoEMetricSpace (π b)
s : (b : β) → Set (π b)
c : ℝ≥0∞
h : ∀ (b : β), c ≤ einfsep (s b)
x : (i : β) → π i
hx : ∀ (i : β), x i ∈ s i
y : (i : β) → π i
hy : ∀ (i : β), y i ∈ s i
hxy : x ≠ y
⊢ c ≤ edist x y

tactic: exact le_trans (le_einfsep_iff.1 (h i) _ (hx _) _ (hy _) hi) (edist_le_pi_edist _ _ i)
state_before: case intro
α : Type ?u.48758
β : Type u_2
inst✝² : PseudoEMetricSpace α
x✝ y✝ z : α
s✝ t : Set α
π : β → Type u_1
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoEMetricSpace (π b)
s : (b : β) → Set (π b)
c : ℝ≥0∞
h : ∀ (b : β), c ≤ einfsep (s b)
x : (i : β) → π i
hx : ∀ (i : β), x i ∈ s i
y : (i : β) → π i
hy : ∀ (i : β), y i ∈ s i
hxy : x ≠ y
i : β
hi : x i ≠ y i
⊢ c ≤ edist x y
Theorem: Real.sqrt_eq_zero
File: Mathlib/Data/Real/Sqrt.lean

tactic: simpa using sqrt_inj h le_rfl
state_before: x y : ℝ
h : 0 ≤ x
⊢ sqrt x = 0 ↔ x = 0
Theorem: Int.eq_one_of_mul_eq_self_left
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.one_mul, H]
state_before: a b : Int
Hpos : a ≠ 0
H : b * a = a
⊢ b * a = 1 * a
Theorem: Equiv.Perm.mem_iff_ofSubtype_apply_mem
File: Mathlib/GroupTheory/Perm/Basic.lean

tactic: simpa only [h, true_iff_iff, MonoidHom.coe_mk, ofSubtype_apply_of_mem f h] using (f ⟨x, h⟩).2
state_before: α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm (Subtype p)
x : α
h : p x
⊢ p x ↔ p (↑(↑ofSubtype f) x)

tactic: simp [h, ofSubtype_apply_of_not_mem f h]
state_before: α : Type u
β : Type v
p : α → Prop
f✝ : Perm α
inst✝ : DecidablePred p
a : α
f : Perm (Subtype p)
x : α
h : ¬p x
⊢ p x ↔ p (↑(↑ofSubtype f) x)
Theorem: ENNReal.rpow_sum_le_const_mul_sum_rpow
File: Mathlib/Analysis/MeanInequalities.lean

tactic: cases' eq_or_lt_of_le hp with hp hp
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q : ℝ
hp : 1 ≤ p
⊢ (∑ i in s, f i) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, f i ^ p

tactic: let q : ℝ := p / (p - 1)
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
⊢ (∑ i in s, f i) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, f i ^ p

tactic: have hpq : p.IsConjugateExponent q := by rw [Real.isConjugateExponent_iff hp]
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
⊢ (∑ i in s, f i) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, f i ^ p

tactic: have hp₁ : 1 / p * p = 1 := one_div_mul_cancel hpq.ne_zero
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : Real.IsConjugateExponent p q
⊢ (∑ i in s, f i) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, f i ^ p

tactic: have hq : 1 / q * p = p - 1 := by
  rw [← hpq.div_conj_eq_sub_one]
  ring
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : Real.IsConjugateExponent p q
hp₁ : 1 / p * p = 1
⊢ (∑ i in s, f i) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, f i ^ p

tactic: simpa only [ENNReal.mul_rpow_of_nonneg _ _ hpq.nonneg, ← ENNReal.rpow_mul, hp₁, hq, coe_one,
  one_mul, one_rpow, rpow_one, Pi.one_apply, sum_const, Nat.smul_one_eq_coe] using
  ENNReal.rpow_le_rpow (inner_le_Lp_mul_Lq s 1 f hpq.symm) hpq.nonneg
state_before: case inr
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : Real.IsConjugateExponent p q
hp₁ : 1 / p * p = 1
hq : 1 / q * p = p - 1
⊢ (∑ i in s, f i) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, f i ^ p

tactic: simp [← hp]
state_before: case inl
ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q : ℝ
hp✝ : 1 ≤ p
hp : 1 = p
⊢ (∑ i in s, f i) ^ p ≤ ↑(card s) ^ (p - 1) * ∑ i in s, f i ^ p

tactic: rw [Real.isConjugateExponent_iff hp]
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
⊢ Real.IsConjugateExponent p q

tactic: rw [← hpq.div_conj_eq_sub_one]
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : Real.IsConjugateExponent p q
hp₁ : 1 / p * p = 1
⊢ 1 / q * p = p - 1

tactic: ring
state_before: ι : Type u
s : Finset ι
f g : ι → ℝ≥0∞
p q✝ : ℝ
hp✝ : 1 ≤ p
hp : 1 < p
q : ℝ := p / (p - 1)
hpq : Real.IsConjugateExponent p q
hp₁ : 1 / p * p = 1
⊢ 1 / q * p = p / q
Theorem: List.kreplace_of_forall_not
File: Mathlib/Data/List/Sigma.lean

tactic: rintro ⟨a', b'⟩ h
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
H : ∀ (b : β a), ¬{ fst := a, snd := b } ∈ l
⊢ ∀ (a_1 : Sigma β), a_1 ∈ l → (if a = a_1.fst then some { fst := a, snd := b } else none) = none

tactic: dsimp
state_before: case mk
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
H : ∀ (b : β a), ¬{ fst := a, snd := b } ∈ l
a' : α
b' : β a'
h : { fst := a', snd := b' } ∈ l
⊢ (if a = { fst := a', snd := b' }.fst then some { fst := a, snd := b } else none) = none

tactic: split_ifs
state_before: case mk
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
H : ∀ (b : β a), ¬{ fst := a, snd := b } ∈ l
a' : α
b' : β a'
h : { fst := a', snd := b' } ∈ l
⊢ (if a = a' then some { fst := a, snd := b } else none) = none

tactic: . rfl
state_before: case mk.inr
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
H : ∀ (b : β a), ¬{ fst := a, snd := b } ∈ l
a' : α
b' : β a'
h : { fst := a', snd := b' } ∈ l
h✝ : ¬a = a'
⊢ none = none

tactic: subst a'
state_before: case mk.inl
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
H : ∀ (b : β a), ¬{ fst := a, snd := b } ∈ l
a' : α
b' : β a'
h : { fst := a', snd := b' } ∈ l
h✝ : a = a'
⊢ False

tactic: exact H _ h
state_before: case mk.inl
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
H : ∀ (b : β a), ¬{ fst := a, snd := b } ∈ l
b' : β a
h : { fst := a, snd := b' } ∈ l
⊢ False

tactic: rfl
state_before: case mk.inr
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
H : ∀ (b : β a), ¬{ fst := a, snd := b } ∈ l
a' : α
b' : β a'
h : { fst := a', snd := b' } ∈ l
h✝ : ¬a = a'
⊢ none = none
Theorem: Finset.map_subtype_embedding_Icc
File: Mathlib/Order/LocallyFinite.lean

tactic: rw [subtype_Icc_eq]
state_before: α : Type u_1
β : Type ?u.218518
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Icc a b) = Icc ↑a ↑b

tactic: refine' Finset.subtype_map_of_mem fun x hx => _
state_before: α : Type u_1
β : Type ?u.218518
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Icc ↑a ↑b)) = Icc ↑a ↑b

tactic: rw [mem_Icc] at hx
state_before: α : Type u_1
β : Type ?u.218518
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Icc ↑a ↑b
⊢ p x

tactic: exact hp hx.1 hx.2 a.prop b.prop
state_before: α : Type u_1
β : Type ?u.218518
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a ≤ x ∧ x ≤ ↑b
⊢ p x