l3lab/ntp-mathlib huggingface dataset:
@[simp]
theorem nth_le_inits (l : List α) (n : ℕ) (hn : n < length (inits l)) :
    nthLe (inits l) n hn = l.take n := by
  induction' l with x l IH generalizing n
  · simp
  · 

Proof state:
case cons
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n✝ : ℕ
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (inits l)), nthLe (inits l) n hn = take n l
n : ℕ
hn : n < length (inits (x :: l))
⊢ nthLe (inits (x :: l)) n hn = take n (x :: l)

Next tactic:
cases n
@[simp]
theorem nth_le_inits (l : List α) (n : ℕ) (hn : n < length (inits l)) :
    nthLe (inits l) n hn = l.take n := by
  induction' l with x l IH generalizing n
  · simp
  · cases n
    · 

Proof state:
case cons.zero
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (inits l)), nthLe (inits l) n hn = take n l
hn : zero < length (inits (x :: l))
⊢ nthLe (inits (x :: l)) zero hn = take zero (x :: l)

Next tactic:
simp[nthLe_cons]
@[simp]
theorem nth_le_inits (l : List α) (n : ℕ) (hn : n < length (inits l)) :
    nthLe (inits l) n hn = l.take n := by
  induction' l with x l IH generalizing n
  · simp
  · cases n
    · simp[nthLe_cons]
    · 

Proof state:
case cons.succ
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
x : α
l : List α
IH : ∀ (n : ℕ) (hn : n < length (inits l)), nthLe (inits l) n hn = take n l
n✝ : ℕ
hn : succ n✝ < length (inits (x :: l))
⊢ nthLe (inits (x :: l)) (succ n✝) hn = take (succ n✝) (x :: l)

Next tactic:
simpa[nthLe_cons] using IH _ _
theorem insert_eq_ite (a : α) (l : List α) : insert a l = if a ∈ l then l else a :: l := by
  

Proof state:
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
⊢ insert a l = if a ∈ l then l else a :: l

Next tactic:
simp only [← elem_iff]
theorem insert_eq_ite (a : α) (l : List α) : insert a l = if a ∈ l then l else a :: l := by
  simp only [← elem_iff]
  

Proof state:
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
⊢ insert a l = if elem a l = true then l else a :: l

Next tactic:
rfl
@[simp]
theorem suffix_insert (a : α) (l : List α) : l <:+ l.insert a := by
  

Proof state:
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
⊢ l <:+ List.insert a l

Next tactic:
by_cases h : a ∈ l
@[simp]
theorem suffix_insert (a : α) (l : List α) : l <:+ l.insert a := by
  by_cases h : a ∈ l
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
h : a ∈ l
⊢ l <:+ List.insert a l

Next tactic:
simp only [insert_of_mem h, insert, suffix_refl]
@[simp]
theorem suffix_insert (a : α) (l : List α) : l <:+ l.insert a := by
  by_cases h : a ∈ l
  · simp only [insert_of_mem h, insert, suffix_refl]
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
h : ¬a ∈ l
⊢ l <:+ List.insert a l

Next tactic:
simp only [insert_of_not_mem h, suffix_cons, insert]
/-- Convert a lazily-evaluated `List` to a `DList` -/
def lazy_ofList (l : Thunk (List α)) : DList α :=
  ⟨fun xs => l.get ++ xs, fun t => by 

Proof state:
α : Type u
l : Thunk (List α)
t : List α
⊢ (fun xs => Thunk.get l ++ xs) t = (fun xs => Thunk.get l ++ xs) [] ++ t

Next tactic:
simp
theorem toList_ofList (l : List α) : DList.toList (DList.ofList l) = l := by
  

Proof state:
α : Type u
l : List α
⊢ toList (ofList l) = l

Next tactic:
cases l
theorem toList_ofList (l : List α) : DList.toList (DList.ofList l) = l := by
  cases l; 

Proof state:
case nil
α : Type u
⊢ toList (ofList []) = []
case cons α : Type u head✝ : α tail✝ : List α ⊢ toList (ofList (head✝ :: tail✝)) = head✝ :: tail✝

Next tactic:
rfl
theorem toList_ofList (l : List α) : DList.toList (DList.ofList l) = l := by
  cases l; rfl; 

Proof state:
case cons
α : Type u
head✝ : α
tail✝ : List α
⊢ toList (ofList (head✝ :: tail✝)) = head✝ :: tail✝

Next tactic:
simp only [DList.toList, DList.ofList, List.cons_append, List.append_nil]
theorem ofList_toList (l : DList α) : DList.ofList (DList.toList l) = l := by
   

Proof state:
α : Type u
l : DList α
⊢ ofList (toList l) = l

Next tactic:
cases' l with app inv
theorem ofList_toList (l : DList α) : DList.ofList (DList.toList l) = l := by
   cases' l with app inv
   

Proof state:
case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ ofList (toList { apply := app, invariant := inv }) = { apply := app, invariant := inv }

Next tactic:
simp only [ofList, toList, mk.injEq]
theorem ofList_toList (l : DList α) : DList.ofList (DList.toList l) = l := by
   cases' l with app inv
   simp only [ofList, toList, mk.injEq]
   

Proof state:
case mk
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
⊢ (fun x => app [] ++ x) = app

Next tactic:
funext x
theorem ofList_toList (l : DList α) : DList.ofList (DList.toList l) = l := by
   cases' l with app inv
   simp only [ofList, toList, mk.injEq]
   funext x
   

Proof state:
case mk.h
α : Type u
app : List α → List α
inv : ∀ (l : List α), app l = app [] ++ l
x : List α
⊢ app [] ++ x = app x

Next tactic:
rw [(inv x)]
theorem toList_empty : toList (@empty α) = [] := by 

Proof state:
α : Type u
⊢ toList empty = []

Next tactic:
simp
theorem toList_singleton (x : α) : toList (singleton x) = [x] := by 

Proof state:
α : Type u
x : α
⊢ toList (singleton x) = [x]

Next tactic:
simp
theorem toList_append (l₁ l₂ : DList α) : toList (l₁ ++ l₂) = toList l₁ ++ toList l₂ :=
  show toList (DList.append l₁ l₂) = toList l₁ ++ toList l₂ by
    

Proof state:
α : Type u
l₁ l₂ : DList α
⊢ toList (append l₁ l₂) = toList l₁ ++ toList l₂

Next tactic:
cases' l₁ with _ l₁_invariant
theorem toList_append (l₁ l₂ : DList α) : toList (l₁ ++ l₂) = toList l₁ ++ toList l₂ :=
  show toList (DList.append l₁ l₂) = toList l₁ ++ toList l₂ by
    cases' l₁ with _ l₁_invariant; 

Proof state:
case mk
α : Type u
l₂ : DList α
apply✝ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (append { apply := apply✝, invariant := l₁_invariant } l₂) =
    toList { apply := apply✝, invariant := l₁_invariant } ++ toList l₂

Next tactic:
cases' l₂
theorem toList_append (l₁ l₂ : DList α) : toList (l₁ ++ l₂) = toList l₁ ++ toList l₂ :=
  show toList (DList.append l₁ l₂) = toList l₁ ++ toList l₂ by
    cases' l₁ with _ l₁_invariant; cases' l₂; 

Proof state:
case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (append { apply := apply✝¹, invariant := l₁_invariant } { apply := apply✝, invariant := invariant✝ }) =
    toList { apply := apply✝¹, invariant := l₁_invariant } ++ toList { apply := apply✝, invariant := invariant✝ }

Next tactic:
simp
theorem toList_append (l₁ l₂ : DList α) : toList (l₁ ++ l₂) = toList l₁ ++ toList l₂ :=
  show toList (DList.append l₁ l₂) = toList l₁ ++ toList l₂ by
    cases' l₁ with _ l₁_invariant; cases' l₂; simp; 

Proof state:
case mk.mk
α : Type u
apply✝¹ : List α → List α
l₁_invariant : ∀ (l : List α), apply✝¹ l = apply✝¹ [] ++ l
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝¹ (apply✝ []) = apply✝¹ [] ++ apply✝ []

Next tactic:
rw [l₁_invariant]
theorem toList_cons (x : α) (l : DList α) : toList (cons x l) = x :: toList l := by
  

Proof state:
α : Type u
x : α
l : DList α
⊢ toList (cons x l) = x :: toList l

Next tactic:
cases l
theorem toList_cons (x : α) (l : DList α) : toList (cons x l) = x :: toList l := by
  cases l; 

Proof state:
case mk
α : Type u
x : α
apply✝ : List α → List α
invariant✝ : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (cons x { apply := apply✝, invariant := invariant✝ }) =
    x :: toList { apply := apply✝, invariant := invariant✝ }

Next tactic:
simp
theorem toList_push (x : α) (l : DList α) : toList (push l x) = toList l ++ [x] := by
  

Proof state:
α : Type u
x : α
l : DList α
⊢ toList (push l x) = toList l ++ [x]

Next tactic:
cases' l with _ l_invariant
theorem toList_push (x : α) (l : DList α) : toList (push l x) = toList l ++ [x] := by
  cases' l with _ l_invariant; 

Proof state:
case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ toList (push { apply := apply✝, invariant := l_invariant } x) =
    toList { apply := apply✝, invariant := l_invariant } ++ [x]

Next tactic:
simp
theorem toList_push (x : α) (l : DList α) : toList (push l x) = toList l ++ [x] := by
  cases' l with _ l_invariant; simp; 

Proof state:
case mk
α : Type u
x : α
apply✝ : List α → List α
l_invariant : ∀ (l : List α), apply✝ l = apply✝ [] ++ l
⊢ apply✝ [x] = apply✝ [] ++ [x]

Next tactic:
rw [l_invariant]
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s := by
  

Proof state:
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul ℝ E
s : Set E
x : E
h : StarConvex ℝ x s
hne : Set.Nonempty s
⊢ ContractibleSpace ↑s

Next tactic:
refine'
    (contractible_iff_id_nullhomotopic s).2
      ⟨⟨x, h.mem hne⟩,
        ⟨⟨⟨fun p => ⟨p.1.1 • x + (1 - p.1.1) • (p.2 : E), _⟩, _⟩, fun x => _, fun x => _⟩⟩⟩
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s := by
  refine'
    (contractible_iff_id_nullhomotopic s).2
      ⟨⟨x, h.mem hne⟩,
        ⟨⟨⟨fun p => ⟨p.1.1 • x + (1 - p.1.1) • (p.2 : E), _⟩, _⟩, fun x => _, fun x => _⟩⟩⟩
  · 

Proof state:
case refine'_1
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul ℝ E
s : Set E
x : E
h : StarConvex ℝ x s
hne : Set.Nonempty s
p : ↑unitInterval × ↑s
⊢ ↑p.1 • x + (1 - ↑p.1) • ↑p.2 ∈ s

Next tactic:
exact h p.2.2 p.1.2.1 (sub_nonneg.2 p.1.2.2) (add_sub_cancel'_right _ _)
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s := by
  refine'
    (contractible_iff_id_nullhomotopic s).2
      ⟨⟨x, h.mem hne⟩,
        ⟨⟨⟨fun p => ⟨p.1.1 • x + (1 - p.1.1) • (p.2 : E), _⟩, _⟩, fun x => _, fun x => _⟩⟩⟩
  · exact h p.2.2 p.1.2.1 (sub_nonneg.2 p.1.2.2) (add_sub_cancel'_right _ _)
  · 

Proof state:
case refine'_2
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul ℝ E
s : Set E
x : E
h : StarConvex ℝ x s
hne : Set.Nonempty s
⊢ Continuous fun p => { val := ↑p.1 • x + (1 - ↑p.1) • ↑p.2, property := (_ : ↑p.1 • x + (1 - ↑p.1) • ↑p.2 ∈ s) }

Next tactic:
exact
      ((continuous_subtype_val.fst'.smul continuous_const).add
            ((continuous_const.sub continuous_subtype_val.fst').smul
              continuous_subtype_val.snd')).subtype_mk
        _
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s := by
  refine'
    (contractible_iff_id_nullhomotopic s).2
      ⟨⟨x, h.mem hne⟩,
        ⟨⟨⟨fun p => ⟨p.1.1 • x + (1 - p.1.1) • (p.2 : E), _⟩, _⟩, fun x => _, fun x => _⟩⟩⟩
  · exact h p.2.2 p.1.2.1 (sub_nonneg.2 p.1.2.2) (add_sub_cancel'_right _ _)
  · exact
      ((continuous_subtype_val.fst'.smul continuous_const).add
            ((continuous_const.sub continuous_subtype_val.fst').smul
              continuous_subtype_val.snd')).subtype_mk
        _
  · 

Proof state:
case refine'_3
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul ℝ E
s : Set E
x✝ : E
h : StarConvex ℝ x✝ s
hne : Set.Nonempty s
x : ↑s
⊢ ContinuousMap.toFun
      (ContinuousMap.mk fun p =>
        { val := ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2, property := (_ : ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2 ∈ s) })
      (0, x) =
    (ContinuousMap.id ↑s) x

Next tactic:
ext1
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s := by
  refine'
    (contractible_iff_id_nullhomotopic s).2
      ⟨⟨x, h.mem hne⟩,
        ⟨⟨⟨fun p => ⟨p.1.1 • x + (1 - p.1.1) • (p.2 : E), _⟩, _⟩, fun x => _, fun x => _⟩⟩⟩
  · exact h p.2.2 p.1.2.1 (sub_nonneg.2 p.1.2.2) (add_sub_cancel'_right _ _)
  · exact
      ((continuous_subtype_val.fst'.smul continuous_const).add
            ((continuous_const.sub continuous_subtype_val.fst').smul
              continuous_subtype_val.snd')).subtype_mk
        _
  · ext1
    

Proof state:
case refine'_3.a
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul ℝ E
s : Set E
x✝ : E
h : StarConvex ℝ x✝ s
hne : Set.Nonempty s
x : ↑s
⊢ ↑(ContinuousMap.toFun
        (ContinuousMap.mk fun p =>
          { val := ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2, property := (_ : ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2 ∈ s) })
        (0, x)) =
    ↑((ContinuousMap.id ↑s) x)

Next tactic:
simp
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s := by
  refine'
    (contractible_iff_id_nullhomotopic s).2
      ⟨⟨x, h.mem hne⟩,
        ⟨⟨⟨fun p => ⟨p.1.1 • x + (1 - p.1.1) • (p.2 : E), _⟩, _⟩, fun x => _, fun x => _⟩⟩⟩
  · exact h p.2.2 p.1.2.1 (sub_nonneg.2 p.1.2.2) (add_sub_cancel'_right _ _)
  · exact
      ((continuous_subtype_val.fst'.smul continuous_const).add
            ((continuous_const.sub continuous_subtype_val.fst').smul
              continuous_subtype_val.snd')).subtype_mk
        _
  · ext1
    simp
  · 

Proof state:
case refine'_4
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul ℝ E
s : Set E
x✝ : E
h : StarConvex ℝ x✝ s
hne : Set.Nonempty s
x : ↑s
⊢ ContinuousMap.toFun
      (ContinuousMap.mk fun p =>
        { val := ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2, property := (_ : ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2 ∈ s) })
      (1, x) =
    (ContinuousMap.const ↑s { val := x✝, property := (_ : x✝ ∈ s) }) x

Next tactic:
ext1
/-- A non-empty star convex set is a contractible space. -/
protected theorem StarConvex.contractibleSpace (h : StarConvex ℝ x s) (hne : s.Nonempty) :
    ContractibleSpace s := by
  refine'
    (contractible_iff_id_nullhomotopic s).2
      ⟨⟨x, h.mem hne⟩,
        ⟨⟨⟨fun p => ⟨p.1.1 • x + (1 - p.1.1) • (p.2 : E), _⟩, _⟩, fun x => _, fun x => _⟩⟩⟩
  · exact h p.2.2 p.1.2.1 (sub_nonneg.2 p.1.2.2) (add_sub_cancel'_right _ _)
  · exact
      ((continuous_subtype_val.fst'.smul continuous_const).add
            ((continuous_const.sub continuous_subtype_val.fst').smul
              continuous_subtype_val.snd')).subtype_mk
        _
  · ext1
    simp
  · ext1
    

Proof state:
case refine'_4.a
E : Type u_1
inst✝⁴ : AddCommGroup E
inst✝³ : Module ℝ E
inst✝² : TopologicalSpace E
inst✝¹ : ContinuousAdd E
inst✝ : ContinuousSMul ℝ E
s : Set E
x✝ : E
h : StarConvex ℝ x✝ s
hne : Set.Nonempty s
x : ↑s
⊢ ↑(ContinuousMap.toFun
        (ContinuousMap.mk fun p =>
          { val := ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2, property := (_ : ↑p.1 • x✝ + (1 - ↑p.1) • ↑p.2 ∈ s) })
        (1, x)) =
    ↑((ContinuousMap.const ↑s { val := x✝, property := (_ : x✝ ∈ s) }) x)

Next tactic:
simp
instance (X : Type u) [TopologicalSpace X] (x : X) : Group (FundamentalGroup X x) := by
  

Proof state:
X✝ : Type u
Y : Type v
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x₀ x₁ : X✝
X : Type u
inst✝ : TopologicalSpace X
x : X
⊢ Group (FundamentalGroup X x)

Next tactic:
dsimp only [FundamentalGroup]
instance (X : Type u) [TopologicalSpace X] (x : X) : Group (FundamentalGroup X x) := by
  dsimp only [FundamentalGroup]
  

Proof state:
X✝ : Type u
Y : Type v
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x₀ x₁ : X✝
X : Type u
inst✝ : TopologicalSpace X
x : X
⊢ Group (Aut { as := x })

Next tactic:
infer_instance
instance (X : Type u) [TopologicalSpace X] (x : X) : Inhabited (FundamentalGroup X x) := by
  

Proof state:
X✝ : Type u
Y : Type v
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x₀ x₁ : X✝
X : Type u
inst✝ : TopologicalSpace X
x : X
⊢ Inhabited (FundamentalGroup X x)

Next tactic:
dsimp only [FundamentalGroup]
instance (X : Type u) [TopologicalSpace X] (x : X) : Inhabited (FundamentalGroup X x) := by
  dsimp only [FundamentalGroup]
  

Proof state:
X✝ : Type u
Y : Type v
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x₀ x₁ : X✝
X : Type u
inst✝ : TopologicalSpace X
x : X
⊢ Inhabited (Aut { as := x })

Next tactic:
infer_instance
@[symm]
protected theorem IsFormalAdjoint.symm (h : T.IsFormalAdjoint S) :
    S.IsFormalAdjoint T := fun y _ => by
  

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
T : E →ₗ.[𝕜] F
S : F →ₗ.[𝕜] E
h : IsFormalAdjoint T S
y : ↥S.domain
x✝ : ↥T.domain
⊢ inner (↑S y) ↑x✝ = inner (↑y) (↑T x✝)

Next tactic:
rw [← inner_conj_symm, ← inner_conj_symm (y : F), h]
/-- The domain of the adjoint operator.

This definition is needed to construct the adjoint operator and the preferred version to use is
`T.adjoint.domain` instead of `T.adjointDomain`. -/
def adjointDomain : Submodule 𝕜 F where
  carrier := {y | Continuous ((innerₛₗ 𝕜 y).comp T.toFun)}
  zero_mem' := by
    rw [Set.mem_setOf_eq, LinearMap.map_zero, LinearMap.zero_comp]
    exact continuous_zero
  add_mem' hx hy := by 

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
T : E →ₗ.[𝕜] F
S : F →ₗ.[𝕜] E
a✝ b✝ : F
hx : a✝ ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}
hy : b✝ ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}
⊢ a✝ + b✝ ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}

Next tactic:
rw [Set.mem_setOf_eq, LinearMap.map_add] at *
/-- The domain of the adjoint operator.

This definition is needed to construct the adjoint operator and the preferred version to use is
`T.adjoint.domain` instead of `T.adjointDomain`. -/
def adjointDomain : Submodule 𝕜 F where
  carrier := {y | Continuous ((innerₛₗ 𝕜 y).comp T.toFun)}
  zero_mem' := by
    rw [Set.mem_setOf_eq, LinearMap.map_zero, LinearMap.zero_comp]
    exact continuous_zero
  add_mem' hx hy := by rw [Set.mem_setOf_eq, LinearMap.map_add] at *; 

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
T : E →ₗ.[𝕜] F
S : F →ₗ.[𝕜] E
a✝ b✝ : F
hx : Continuous ⇑((innerₛₗ 𝕜) a✝ ∘ₗ T.toFun)
hy : Continuous ⇑((innerₛₗ 𝕜) b✝ ∘ₗ T.toFun)
⊢ Continuous ⇑(((innerₛₗ 𝕜) a✝ + (innerₛₗ 𝕜) b✝) ∘ₗ T.toFun)

Next tactic:
exact hx.add hy
/-- The domain of the adjoint operator.

This definition is needed to construct the adjoint operator and the preferred version to use is
`T.adjoint.domain` instead of `T.adjointDomain`. -/
def adjointDomain : Submodule 𝕜 F where
  carrier := {y | Continuous ((innerₛₗ 𝕜 y).comp T.toFun)}
  zero_mem' := by
    

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
T : E →ₗ.[𝕜] F
S : F →ₗ.[𝕜] E
⊢ 0 ∈
    { carrier := {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)},
        add_mem' :=
          (_ :
            ∀ {a b : F},
              a ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                  a + b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}) }.carrier

Next tactic:
rw [Set.mem_setOf_eq, LinearMap.map_zero, LinearMap.zero_comp]
/-- The domain of the adjoint operator.

This definition is needed to construct the adjoint operator and the preferred version to use is
`T.adjoint.domain` instead of `T.adjointDomain`. -/
def adjointDomain : Submodule 𝕜 F where
  carrier := {y | Continuous ((innerₛₗ 𝕜 y).comp T.toFun)}
  zero_mem' := by
    rw [Set.mem_setOf_eq, LinearMap.map_zero, LinearMap.zero_comp]
    

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
T : E →ₗ.[𝕜] F
S : F →ₗ.[𝕜] E
⊢ Continuous ⇑0

Next tactic:
exact continuous_zero
/-- The domain of the adjoint operator.

This definition is needed to construct the adjoint operator and the preferred version to use is
`T.adjoint.domain` instead of `T.adjointDomain`. -/
def adjointDomain : Submodule 𝕜 F where
  carrier := {y | Continuous ((innerₛₗ 𝕜 y).comp T.toFun)}
  zero_mem' := by
    rw [Set.mem_setOf_eq, LinearMap.map_zero, LinearMap.zero_comp]
    exact continuous_zero
  add_mem' hx hy := by rw [Set.mem_setOf_eq, LinearMap.map_add] at *; exact hx.add hy
  smul_mem' a x hx := by
    

Proof state:
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
T : E →ₗ.[𝕜] F
S : F →ₗ.[𝕜] E
a : 𝕜
x : F
hx :
  x ∈
    {
          toAddSubsemigroup :=
            { carrier := {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)},
              add_mem' :=
                (_ :
                  ∀ {a b : F},
                    a ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                      b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                        a + b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}) },
          zero_mem' :=
            (_ :
              0 ∈
                { carrier := {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)},
                    add_mem' :=
                      (_ :
                        ∀ {a b : F},
                          a ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                            b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                              a + b ∈
                                {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}) }.carrier) }.toAddSubsemigroup.carrier
⊢ a • x ∈
    {
          toAddSubsemigroup :=
            { carrier := {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)},
              add_mem' :=
                (_ :
                  ∀ {a b : F},
                    a ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                      b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                        a + b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}) },
          zero_mem' :=
            (_ :
              0 ∈
                { carrier := {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)},
                    add_mem' :=
                      (_ :
                        ∀ {a b : F},
                          a ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                            b ∈ {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)} →
                              a + b ∈
                                {y | Continuous ⇑((innerₛₗ 𝕜) y ∘ₗ T.toFun)}) }.carrier) }.toAddSubsemigroup.carrier

Next tactic:
rw [Set.mem_setOf_eq, LinearMap.map_smulₛₗ] at *