File: Mathlib/Topology/Connected/PathConnected.lean

full_name: Path.target'
code: /-- Continuous path connecting two points `x` and `y` in a topological space -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure Path (x y : X) extends C(I, X) where
  /-- The start point of a `Path`. -/
  source' : toFun 0 = x
  /-- The end point of a `Path`. -/
  target' : toFun 1 = y
goal: self.toFun 1 = y

full_name: Path
code: /-- Continuous path connecting two points `x` and `y` in a topological space -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure Path (x y : X) extends C(I, X) where
  /-- The start point of a `Path`. -/
  source' : toFun 0 = x
  /-- The end point of a `Path`. -/
  target' : toFun 1 = y
goal: Type u_1

full_name: Path.source'
code: /-- Continuous path connecting two points `x` and `y` in a topological space -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure Path (x y : X) extends C(I, X) where
  /-- The start point of a `Path`. -/
  source' : toFun 0 = x
  /-- The end point of a `Path`. -/
  target' : toFun 1 = y
goal: self.toFun 0 = x

full_name: Path.funLike
code: instance Path.funLike : FunLike (Path x y) I X 
goal: FunLike (Path x y) (↑I) X

full_name: Path.continuousMapClass
code: instance Path.continuousMapClass : ContinuousMapClass (Path x y) I X 
goal: ContinuousMapClass (Path x y) (↑I) X

full_name: Path.ext
code: @[ext]
protected theorem Path.ext : ∀ {γ₁ γ₂ : Path x y}, (γ₁ : I → X) = γ₂ → γ₁ = γ₂ 
goal: ⇑γ₁ = ⇑γ₂ → γ₁ = γ₂

full_name: Path.coe_mk_mk
code: @[simp]
theorem coe_mk_mk (f : I → X) (h₁) (h₂ : f 0 = x) (h₃ : f 1 = y) :
    ⇑(mk ⟨f, h₁⟩ h₂ h₃ : Path x y) = f 
goal: ⇑{ toFun := f, continuous_toFun := h₁, source' := h₂, target' := h₃ } = f

full_name: Path.continuous
code: @[continuity]
protected theorem continuous : Continuous γ 
goal: Continuous ⇑γ

full_name: Path.source
code: @[simp]
protected theorem source : γ 0 = x 
goal: γ 0 = x

full_name: Path.target
code: @[simp]
protected theorem target : γ 1 = y 
goal: γ 1 = y

full_name: Path.simps.apply
code: /-- See Note [custom simps projection]. We need to specify this projection explicitly in this case,
because it is a composition of multiple projections. -/
def simps.apply : I → X 
goal: ↑I → X

full_name: Path.coe_toContinuousMap
code: @[simp]
theorem coe_toContinuousMap : ⇑γ.toContinuousMap = γ 
goal: ⇑γ.toContinuousMap = ⇑γ

full_name: Path.coe_mk
code: @[simp]
theorem coe_mk : ⇑(γ : C(I, X)) = γ 
goal: ⇑↑γ = ⇑γ

full_name: Path.hasUncurryPath
code: /-- Any function `φ : Π (a : α), Path (x a) (y a)` can be seen as a function `α × I → X`. -/
instance hasUncurryPath {X α : Type*} [TopologicalSpace X] {x y : α → X} :
    HasUncurry (∀ a : α, Path (x a) (y a)) (α × I) X 
goal: Function.HasUncurry ((a : α) → Path (x a) (y a)) (α × ↑I) X

full_name: Path.refl
code: /-- The constant path from a point to itself -/
@[refl, simps]
def refl (x : X) : Path x x 
goal: Path x x

full_name: Path.refl_apply
code: /-- The constant path from a point to itself -/
@[refl, simps]
def refl (x : X) : Path x x 
goal: (Path.refl x) _t = x

full_name: Path.refl_range
code: @[simp]
theorem refl_range {a : X} : range (Path.refl a) = {a} 
goal: Set.range ⇑(Path.refl a) = {a}

full_name: Path.symm_apply
code: /-- The reverse of a path from `x` to `y`, as a path from `y` to `x` -/
@[symm, simps]
def symm (γ : Path x y) : Path y x 
goal: ∀ (a : ↑I), γ.symm a = (⇑γ ∘ σ) a

full_name: Path.symm
code: /-- The reverse of a path from `x` to `y`, as a path from `y` to `x` -/
@[symm, simps]
def symm (γ : Path x y) : Path y x 
goal: Path y x

full_name: Path.symm_symm
code: @[simp]
theorem symm_symm (γ : Path x y) : γ.symm.symm = γ 
goal: γ.symm.symm = γ

full_name: Path.symm_bijective
code: theorem symm_bijective : Function.Bijective (Path.symm : Path x y → Path y x) 
goal: Function.Bijective Path.symm

full_name: Path.refl_symm
code: @[simp]
theorem refl_symm {a : X} : (Path.refl a).symm = Path.refl a 
goal: (Path.refl a).symm = Path.refl a

full_name: Path.symm_range
code: @[simp]
theorem symm_range {a b : X} (γ : Path a b) : range γ.symm = range γ 
goal: Set.range ⇑γ.symm = Set.range ⇑γ

full_name: Path.topologicalSpace
code: /-- The following instance defines the topology on the path space to be induced from the
compact-open topology on the space `C(I,X)` of continuous maps from `I` to `X`.
-/
instance topologicalSpace : TopologicalSpace (Path x y) 
goal: TopologicalSpace (Path x y)

full_name: Path.continuous_eval
code: theorem continuous_eval : Continuous fun p : Path x y × I => p.1 p.2 
goal: Continuous fun p => p.1 p.2

full_name: Continuous.path_eval
code: @[continuity]
theorem _root_.Continuous.path_eval {Y} [TopologicalSpace Y] {f : Y → Path x y} {g : Y → I}
    (hf : Continuous f) (hg : Continuous g) : Continuous fun y => f y (g y) 
goal: Continuous fun y_1 => (f y_1) (g y_1)

full_name: Path.continuous_uncurry_iff
code: theorem continuous_uncurry_iff {Y} [TopologicalSpace Y] {g : Y → Path x y} :
    Continuous ↿g ↔ Continuous g 
goal: Continuous ↿g ↔ Continuous g

full_name: Path.extend
code: /-- A continuous map extending a path to `ℝ`, constant before `0` and after `1`. -/
def extend : ℝ → X 
goal: ℝ → X

full_name: Continuous.path_extend
code: /-- See Note [continuity lemma statement]. -/
theorem _root_.Continuous.path_extend {γ : Y → Path x y} {f : Y → ℝ} (hγ : Continuous ↿γ)
    (hf : Continuous f) : Continuous fun t => (γ t).extend (f t) 
goal: Continuous fun t => (γ t).extend (f t)

full_name: Path.continuous_extend
code: /-- A useful special case of `Continuous.path_extend`. -/
@[continuity, fun_prop]
theorem continuous_extend : Continuous γ.extend 
goal: Continuous γ.extend

full_name: Filter.Tendsto.path_extend
code: theorem _root_.Filter.Tendsto.path_extend
    {l r : Y → X} {y : Y} {l₁ : Filter ℝ} {l₂ : Filter X} {γ : ∀ y, Path (l y) (r y)}
    (hγ : Tendsto (↿γ) (𝓝 y ×ˢ l₁.map (projIcc 0 1 zero_le_one)) l₂) :
    Tendsto (↿fun x => (γ x).extend) (𝓝 y ×ˢ l₁) l₂ 
goal: Filter.Tendsto (↿fun x => (γ x).extend) (𝓝 y ×ˢ l₁) l₂

full_name: ContinuousAt.path_extend
code: theorem _root_.ContinuousAt.path_extend {g : Y → ℝ} {l r : Y → X} (γ : ∀ y, Path (l y) (r y))
    {y : Y} (hγ : ContinuousAt (↿γ) (y, projIcc 0 1 zero_le_one (g y))) (hg : ContinuousAt g y) :
    ContinuousAt (fun i => (γ i).extend (g i)) y 
goal: ContinuousAt (fun i => (γ i).extend (g i)) y

full_name: Path.extend_extends
code: @[simp]
theorem extend_extends {a b : X} (γ : Path a b) {t : ℝ}
    (ht : t ∈ (Icc 0 1 : Set ℝ)) : γ.extend t = γ ⟨t, ht⟩ 
goal: γ.extend t = γ ⟨t, ht⟩

full_name: Path.extend_zero
code: theorem extend_zero : γ.extend 0 = x 
goal: γ.extend 0 = x

full_name: Path.extend_one
code: theorem extend_one : γ.extend 1 = y 
goal: γ.extend 1 = y

full_name: Path.extend_extends'
code: @[simp]
theorem extend_extends' {a b : X} (γ : Path a b) (t : (Icc 0 1 : Set ℝ)) : γ.extend t = γ t 
goal: γ.extend ↑t = γ t

full_name: Path.extend_range
code: @[simp]
theorem extend_range {a b : X} (γ : Path a b) :
    range γ.extend = range γ 
goal: Set.range γ.extend = Set.range ⇑γ

full_name: Path.extend_of_le_zero
code: theorem extend_of_le_zero {a b : X} (γ : Path a b) {t : ℝ}
    (ht : t ≤ 0) : γ.extend t = a 
goal: γ.extend t = a

full_name: Path.extend_of_one_le
code: theorem extend_of_one_le {a b : X} (γ : Path a b) {t : ℝ}
    (ht : 1 ≤ t) : γ.extend t = b 
goal: γ.extend t = b

full_name: Path.refl_extend
code: @[simp]
theorem refl_extend {a : X} : (Path.refl a).extend = fun _ => a 
goal: (Path.refl a).extend = fun x => a

full_name: Path.ofLine
code: /-- The path obtained from a map defined on `ℝ` by restriction to the unit interval. -/
def ofLine {f : ℝ → X} (hf : ContinuousOn f I) (h₀ : f 0 = x) (h₁ : f 1 = y) : Path x y 
goal: Path x y

full_name: Path.ofLine_mem
code: theorem ofLine_mem {f : ℝ → X} (hf : ContinuousOn f I) (h₀ : f 0 = x) (h₁ : f 1 = y) :
    ∀ t, ofLine hf h₀ h₁ t ∈ f '' I 
goal: (Path.ofLine hf h₀ h₁) t ∈ f '' I

full_name: Path.trans
code: /-- Concatenation of two paths from `x` to `y` and from `y` to `z`, putting the first
path on `[0, 1/2]` and the second one on `[1/2, 1]`. -/
@[trans]
def trans (γ : Path x y) (γ' : Path y z) : Path x z 
goal: Path x z

full_name: Path.trans_apply
code: theorem trans_apply (γ : Path x y) (γ' : Path y z) (t : I) :
    (γ.trans γ') t =
      if h : (t : ℝ) ≤ 1 / 2 then γ ⟨2 * t, (mul_pos_mem_iff zero_lt_two).2 ⟨t.2.1, h⟩⟩
      else γ' ⟨2 * t - 1, two_mul_sub_one_mem_iff.2 ⟨(not_le.1 h).le, t.2.2⟩⟩ 
goal: (γ.trans γ') t = if h : ↑t ≤ 1 / 2 then γ ⟨2 * ↑t, ⋯⟩ else γ' ⟨2 * ↑t - 1, ⋯⟩

full_name: Path.trans_symm
code: @[simp]
theorem trans_symm (γ : Path x y) (γ' : Path y z) : (γ.trans γ').symm = γ'.symm.trans γ.symm 
goal: (γ.trans γ').symm = γ'.symm.trans γ.symm

full_name: Path.refl_trans_refl
code: @[simp]
theorem refl_trans_refl {a : X} :
    (Path.refl a).trans (Path.refl a) = Path.refl a 
goal: (Path.refl a).trans (Path.refl a) = Path.refl a

full_name: Path.trans_range
code: theorem trans_range {a b c : X} (γ₁ : Path a b) (γ₂ : Path b c) :
    range (γ₁.trans γ₂) = range γ₁ ∪ range γ₂ 
goal: Set.range ⇑(γ₁.trans γ₂) = Set.range ⇑γ₁ ∪ Set.range ⇑γ₂

full_name: Path.map'
code: /-- Image of a path from `x` to `y` by a map which is continuous on the path. -/
def map' (γ : Path x y) {f : X → Y} (h : ContinuousOn f (range γ)) : Path (f x) (f y) 
goal: Path (f x) (f y)

full_name: Path.map
code: /-- Image of a path from `x` to `y` by a continuous map -/
def map (γ : Path x y) {f : X → Y} (h : Continuous f) :
    Path (f x) (f y) 
goal: Path (f x) (f y)

full_name: Path.map_coe
code: @[simp]
theorem map_coe (γ : Path x y) {f : X → Y} (h : Continuous f) :
    (γ.map h : I → Y) = f ∘ γ 
goal: ⇑(γ.map h) = f ∘ ⇑γ

full_name: Path.map_symm
code: @[simp]
theorem map_symm (γ : Path x y) {f : X → Y} (h : Continuous f) :
    (γ.map h).symm = γ.symm.map h 
goal: (γ.map h).symm = γ.symm.map h

full_name: Path.map_trans
code: @[simp]
theorem map_trans (γ : Path x y) (γ' : Path y z) {f : X → Y}
    (h : Continuous f) : (γ.trans γ').map h = (γ.map h).trans (γ'.map h) 
goal: (γ.trans γ').map h = (γ.map h).trans (γ'.map h)

full_name: Path.map_id
code: @[simp]
theorem map_id (γ : Path x y) : γ.map continuous_id = γ 
goal: γ.map ⋯ = γ

full_name: Path.map_map
code: @[simp]
theorem map_map (γ : Path x y) {Z : Type*} [TopologicalSpace Z]
    {f : X → Y} (hf : Continuous f) {g : Y → Z} (hg : Continuous g) :
    (γ.map hf).map hg = γ.map (hg.comp hf) 
goal: (γ.map hf).map hg = γ.map ⋯

full_name: Path.cast
code: /-- Casting a path from `x` to `y` to a path from `x'` to `y'` when `x' = x` and `y' = y` -/
def cast (γ : Path x y) {x' y'} (hx : x' = x) (hy : y' = y) : Path x' y' 
goal: Path x' y'

full_name: Path.symm_cast
code: @[simp]
theorem symm_cast {a₁ a₂ b₁ b₂ : X} (γ : Path a₂ b₂) (ha : a₁ = a₂) (hb : b₁ = b₂) :
    (γ.cast ha hb).symm = γ.symm.cast hb ha 
goal: (γ.cast ha hb).symm = γ.symm.cast hb ha

full_name: Path.trans_cast
code: @[simp]
theorem trans_cast {a₁ a₂ b₁ b₂ c₁ c₂ : X} (γ : Path a₂ b₂)
    (γ' : Path b₂ c₂) (ha : a₁ = a₂) (hb : b₁ = b₂) (hc : c₁ = c₂) :
    (γ.cast ha hb).trans (γ'.cast hb hc) = (γ.trans γ').cast ha hc 
goal: (γ.cast ha hb).trans (γ'.cast hb hc) = (γ.trans γ').cast ha hc

full_name: Path.cast_coe
code: @[simp]
theorem cast_coe (γ : Path x y) {x' y'} (hx : x' = x) (hy : y' = y) : (γ.cast hx hy : I → X) = γ 
goal: ⇑(γ.cast hx hy) = ⇑γ

full_name: Path.symm_continuous_family
code: @[continuity, fun_prop]
theorem symm_continuous_family {ι : Type*} [TopologicalSpace ι]
    {a b : ι → X} (γ : ∀ t : ι, Path (a t) (b t)) (h : Continuous ↿γ) :
    Continuous ↿fun t => (γ t).symm 
goal: Continuous ↿fun t => (γ t).symm

full_name: Path.continuous_symm
code: @[continuity]
theorem continuous_symm : Continuous (symm : Path x y → Path y x) 
goal: Continuous Path.symm

full_name: Path.continuous_uncurry_extend_of_continuous_family
code: @[continuity]
theorem continuous_uncurry_extend_of_continuous_family {ι : Type*} [TopologicalSpace ι]
    {a b : ι → X} (γ : ∀ t : ι, Path (a t) (b t)) (h : Continuous ↿γ) :
    Continuous ↿fun t => (γ t).extend 
goal: Continuous ↿fun t => (γ t).extend

full_name: Path.trans_continuous_family
code: @[continuity]
theorem trans_continuous_family {ι : Type*} [TopologicalSpace ι]
    {a b c : ι → X} (γ₁ : ∀ t : ι, Path (a t) (b t)) (h₁ : Continuous ↿γ₁)
    (γ₂ : ∀ t : ι, Path (b t) (c t)) (h₂ : Continuous ↿γ₂) :
    Continuous ↿fun t => (γ₁ t).trans (γ₂ t) 
goal: Continuous ↿fun t => (γ₁ t).trans (γ₂ t)

full_name: Continuous.path_trans
code: @[continuity]
theorem _root_.Continuous.path_trans {f : Y → Path x y} {g : Y → Path y z} :
    Continuous f → Continuous g → Continuous fun t => (f t).trans (g t) 
goal: Continuous f → Continuous g → Continuous fun t => (f t).trans (g t)

full_name: Path.continuous_trans
code: @[continuity]
theorem continuous_trans {x y z : X} : Continuous fun ρ : Path x y × Path y z => ρ.1.trans ρ.2 
goal: Continuous fun ρ => ρ.1.trans ρ.2

full_name: Path.prod
code: /-- Given a path in `X` and a path in `Y`, we can take their pointwise product to get a path in
`X × Y`. -/
protected def prod (γ₁ : Path a₁ a₂) (γ₂ : Path b₁ b₂) : Path (a₁, b₁) (a₂, b₂) 
goal: Path (a₁, b₁) (a₂, b₂)

full_name: Path.prod_coe
code: @[simp]
theorem prod_coe (γ₁ : Path a₁ a₂) (γ₂ : Path b₁ b₂) :
    ⇑(γ₁.prod γ₂) = fun t => (γ₁ t, γ₂ t) 
goal: ⇑(γ₁.prod γ₂) = fun t => (γ₁ t, γ₂ t)

full_name: Path.trans_prod_eq_prod_trans
code: /-- Path composition commutes with products -/
theorem trans_prod_eq_prod_trans (γ₁ : Path a₁ a₂) (δ₁ : Path a₂ a₃) (γ₂ : Path b₁ b₂)
    (δ₂ : Path b₂ b₃) : (γ₁.prod γ₂).trans (δ₁.prod δ₂) = (γ₁.trans δ₁).prod (γ₂.trans δ₂) 
goal: (γ₁.prod γ₂).trans (δ₁.prod δ₂) = (γ₁.trans δ₁).prod (γ₂.trans δ₂)

full_name: Path.pi
code: /-- Given a family of paths, one in each Xᵢ, we take their pointwise product to get a path in
Π i, Xᵢ. -/
protected def pi (γ : ∀ i, Path (as i) (bs i)) : Path as bs 
goal: Path as bs

full_name: Path.pi_coe
code: @[simp]
theorem pi_coe (γ : ∀ i, Path (as i) (bs i)) : ⇑(Path.pi γ) = fun t i => γ i t 
goal: ⇑(Path.pi γ) = fun t i => (γ i) t

full_name: Path.trans_pi_eq_pi_trans
code: /-- Path composition commutes with products -/
theorem trans_pi_eq_pi_trans (γ₀ : ∀ i, Path (as i) (bs i)) (γ₁ : ∀ i, Path (bs i) (cs i)) :
    (Path.pi γ₀).trans (Path.pi γ₁) = Path.pi fun i => (γ₀ i).trans (γ₁ i) 
goal: (Path.pi γ₀).trans (Path.pi γ₁) = Path.pi fun i => (γ₀ i).trans (γ₁ i)

full_name: Path.add
code: /-- Pointwise multiplication of paths in a topological group. The additive version is probably more
useful. -/
@[to_additive "Pointwise addition of paths in a topological additive group."]
protected def mul [Mul X] [ContinuousMul X] {a₁ b₁ a₂ b₂ : X} (γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) :
    Path (a₁ * a₂) (b₁ * b₂) 
goal: Path (a₁ + a₂) (b₁ + b₂)

full_name: Path.mul
code: /-- Pointwise multiplication of paths in a topological group. The additive version is probably more
useful. -/
@[to_additive "Pointwise addition of paths in a topological additive group."]
protected def mul [Mul X] [ContinuousMul X] {a₁ b₁ a₂ b₂ : X} (γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) :
    Path (a₁ * a₂) (b₁ * b₂) 
goal: Path (a₁ * a₂) (b₁ * b₂)

full_name: Path.add_apply
code: @[to_additive]
protected theorem mul_apply [Mul X] [ContinuousMul X] {a₁ b₁ a₂ b₂ : X} (γ₁ : Path a₁ b₁)
    (γ₂ : Path a₂ b₂) (t : unitInterval) : (γ₁.mul γ₂) t = γ₁ t * γ₂ t 
goal: (γ₁.add γ₂) t = γ₁ t + γ₂ t

full_name: Path.mul_apply
code: @[to_additive]
protected theorem mul_apply [Mul X] [ContinuousMul X] {a₁ b₁ a₂ b₂ : X} (γ₁ : Path a₁ b₁)
    (γ₂ : Path a₂ b₂) (t : unitInterval) : (γ₁.mul γ₂) t = γ₁ t * γ₂ t 
goal: (γ₁.mul γ₂) t = γ₁ t * γ₂ t

full_name: Path.truncate
code: /-- `γ.truncate t₀ t₁` is the path which follows the path `γ` on the
  time interval `[t₀, t₁]` and stays still otherwise. -/
def truncate {X : Type*} [TopologicalSpace X] {a b : X} (γ : Path a b) (t₀ t₁ : ℝ) :
    Path (γ.extend <| min t₀ t₁) (γ.extend t₁) 
goal: Path (γ.extend (min t₀ t₁)) (γ.extend t₁)

full_name: Path.truncateOfLE
code: /-- `γ.truncateOfLE t₀ t₁ h`, where `h : t₀ ≤ t₁` is `γ.truncate t₀ t₁`
  casted as a path from `γ.extend t₀` to `γ.extend t₁`. -/
def truncateOfLE {X : Type*} [TopologicalSpace X] {a b : X} (γ : Path a b) {t₀ t₁ : ℝ}
    (h : t₀ ≤ t₁) : Path (γ.extend t₀) (γ.extend t₁) 
goal: Path (γ.extend t₀) (γ.extend t₁)

full_name: Path.truncate_range
code: theorem truncate_range {a b : X} (γ : Path a b) {t₀ t₁ : ℝ} :
    range (γ.truncate t₀ t₁) ⊆ range γ 
goal: Set.range ⇑(γ.truncate t₀ t₁) ⊆ Set.range ⇑γ

full_name: Path.truncate_continuous_family
code: /-- For a path `γ`, `γ.truncate` gives a "continuous family of paths", by which we
  mean the uncurried function which maps `(t₀, t₁, s)` to `γ.truncate t₀ t₁ s` is continuous. -/
@[continuity]
theorem truncate_continuous_family {a b : X} (γ : Path a b) :
    Continuous (fun x => γ.truncate x.1 x.2.1 x.2.2 : ℝ × ℝ × I → X) 
goal: Continuous fun x => (γ.truncate x.1 x.2.1) x.2.2

full_name: Path.truncate_const_continuous_family
code: @[continuity]
theorem truncate_const_continuous_family {a b : X} (γ : Path a b)
    (t : ℝ) : Continuous ↿(γ.truncate t) 
goal: Continuous ↿(γ.truncate t)

full_name: Path.truncate_self
code: @[simp]
theorem truncate_self {a b : X} (γ : Path a b) (t : ℝ) :
    γ.truncate t t = (Path.refl <| γ.extend t).cast (by rw [min_self]) rfl 
goal: γ.truncate t t = (Path.refl (γ.extend t)).cast ⋯ ⋯

full_name: Path.truncate_zero_zero
code: @[simp 1001] -- Porting note: increase `simp` priority so left-hand side doesn't simplify
theorem truncate_zero_zero {a b : X} (γ : Path a b) :
    γ.truncate 0 0 = (Path.refl a).cast (by rw [min_self, γ.extend_zero]) γ.extend_zero 
goal: γ.truncate 0 0 = (Path.refl a).cast ⋯ ⋯

full_name: Path.truncate_one_one
code: @[simp 1001] -- Porting note: increase `simp` priority so left-hand side doesn't simplify
theorem truncate_one_one {a b : X} (γ : Path a b) :
    γ.truncate 1 1 = (Path.refl b).cast (by rw [min_self, γ.extend_one]) γ.extend_one 
goal: γ.truncate 1 1 = (Path.refl b).cast ⋯ ⋯

full_name: Path.truncate_zero_one
code: @[simp]
theorem truncate_zero_one {a b : X} (γ : Path a b) :
    γ.truncate 0 1 = γ.cast (by simp [zero_le_one, extend_zero]) (by simp) 
goal: γ.truncate 0 1 = γ.cast ⋯ ⋯

full_name: Path.reparam
code: /-- Given a path `γ` and a function `f : I → I` where `f 0 = 0` and `f 1 = 1`, `γ.reparam f` is the
path defined by `γ ∘ f`.
-/
def reparam (γ : Path x y) (f : I → I) (hfcont : Continuous f) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
    Path x y 
goal: Path x y

full_name: Path.coe_reparam
code: @[simp]
theorem coe_reparam (γ : Path x y) {f : I → I} (hfcont : Continuous f) (hf₀ : f 0 = 0)
    (hf₁ : f 1 = 1) : ⇑(γ.reparam f hfcont hf₀ hf₁) = γ ∘ f 
goal: ⇑(γ.reparam f hfcont hf₀ hf₁) = ⇑γ ∘ f

full_name: Path.reparam_id
code: @[simp]
theorem reparam_id (γ : Path x y) : γ.reparam id continuous_id rfl rfl = γ 
goal: γ.reparam id ⋯ ⋯ ⋯ = γ

full_name: Path.range_reparam
code: theorem range_reparam (γ : Path x y) {f : I → I} (hfcont : Continuous f) (hf₀ : f 0 = 0)
    (hf₁ : f 1 = 1) : range (γ.reparam f hfcont hf₀ hf₁) = range γ 
goal: Set.range ⇑(γ.reparam f hfcont hf₀ hf₁) = Set.range ⇑γ

full_name: Path.refl_reparam
code: theorem refl_reparam {f : I → I} (hfcont : Continuous f) (hf₀ : f 0 = 0) (hf₁ : f 1 = 1) :
    (refl x).reparam f hfcont hf₀ hf₁ = refl x 
goal: (Path.refl x).reparam f hfcont hf₀ hf₁ = Path.refl x

full_name: Joined
code: /-- The relation "being joined by a path". This is an equivalence relation. -/
def Joined (x y : X) : Prop 
goal: Prop

full_name: Joined.refl
code: @[refl]
theorem Joined.refl (x : X) : Joined x x 
goal: Joined x x

full_name: Joined.somePath
code: /-- When two points are joined, choose some path from `x` to `y`. -/
def Joined.somePath (h : Joined x y) : Path x y 
goal: Path x y

full_name: Joined.symm
code: @[symm]
theorem Joined.symm {x y : X} (h : Joined x y) : Joined y x 
goal: Joined y x

full_name: Joined.trans
code: @[trans]
theorem Joined.trans {x y z : X} (hxy : Joined x y) (hyz : Joined y z) : Joined x z 
goal: Joined x z

full_name: pathSetoid
code: /-- The setoid corresponding the equivalence relation of being joined by a continuous path. -/
def pathSetoid : Setoid X 
goal: Setoid X

full_name: ZerothHomotopy
code: /-- The quotient type of points of a topological space modulo being joined by a continuous path. -/
def ZerothHomotopy 
goal: Type u_1

full_name: ZerothHomotopy.inhabited
code: instance ZerothHomotopy.inhabited : Inhabited (ZerothHomotopy ℝ) 
goal: Inhabited (ZerothHomotopy ℝ)

full_name: JoinedIn
code: /-- The relation "being joined by a path in `F`". Not quite an equivalence relation since it's not
reflexive for points that do not belong to `F`. -/
def JoinedIn (F : Set X) (x y : X) : Prop 
goal: Prop

full_name: JoinedIn.mem
code: theorem JoinedIn.mem (h : JoinedIn F x y) : x ∈ F ∧ y ∈ F 
goal: x ∈ F ∧ y ∈ F

full_name: JoinedIn.source_mem
code: theorem JoinedIn.source_mem (h : JoinedIn F x y) : x ∈ F 
goal: x ∈ F

full_name: JoinedIn.target_mem
code: theorem JoinedIn.target_mem (h : JoinedIn F x y) : y ∈ F 
goal: y ∈ F

full_name: JoinedIn.somePath
code: /-- When `x` and `y` are joined in `F`, choose a path from `x` to `y` inside `F` -/
def JoinedIn.somePath (h : JoinedIn F x y) : Path x y 
goal: Path x y

full_name: JoinedIn.somePath_mem
code: theorem JoinedIn.somePath_mem (h : JoinedIn F x y) (t : I) : h.somePath t ∈ F 
goal: h.somePath t ∈ F

full_name: JoinedIn.joined_subtype
code: /-- If `x` and `y` are joined in the set `F`, then they are joined in the subtype `F`. -/
theorem JoinedIn.joined_subtype (h : JoinedIn F x y) :
    Joined (⟨x, h.source_mem⟩ : F) (⟨y, h.target_mem⟩ : F) 
goal: Joined ⟨x, ⋯⟩ ⟨y, ⋯⟩

full_name: JoinedIn.ofLine
code: theorem JoinedIn.ofLine {f : ℝ → X} (hf : ContinuousOn f I) (h₀ : f 0 = x) (h₁ : f 1 = y)
    (hF : f '' I ⊆ F) : JoinedIn F x y 
goal: JoinedIn F x y

full_name: JoinedIn.joined
code: theorem JoinedIn.joined (h : JoinedIn F x y) : Joined x y 
goal: Joined x y

full_name: joinedIn_iff_joined
code: theorem joinedIn_iff_joined (x_in : x ∈ F) (y_in : y ∈ F) :
    JoinedIn F x y ↔ Joined (⟨x, x_in⟩ : F) (⟨y, y_in⟩ : F) 
goal: JoinedIn F x y ↔ Joined ⟨x, x_in⟩ ⟨y, y_in⟩

full_name: joinedIn_univ
code: @[simp]
theorem joinedIn_univ : JoinedIn univ x y ↔ Joined x y 
goal: JoinedIn Set.univ x y ↔ Joined x y

full_name: JoinedIn.mono
code: theorem JoinedIn.mono {U V : Set X} (h : JoinedIn U x y) (hUV : U ⊆ V) : JoinedIn V x y 
goal: JoinedIn V x y

full_name: JoinedIn.refl
code: theorem JoinedIn.refl (h : x ∈ F) : JoinedIn F x x 
goal: JoinedIn F x x

full_name: JoinedIn.symm
code: @[symm]
theorem JoinedIn.symm (h : JoinedIn F x y) : JoinedIn F y x 
goal: JoinedIn F y x

full_name: JoinedIn.trans
code: theorem JoinedIn.trans (hxy : JoinedIn F x y) (hyz : JoinedIn F y z) : JoinedIn F x z 
goal: JoinedIn F x z

full_name: Specializes.joinedIn
code: theorem Specializes.joinedIn (h : x ⤳ y) (hx : x ∈ F) (hy : y ∈ F) : JoinedIn F x y 
goal: JoinedIn F x y

full_name: Inseparable.joinedIn
code: theorem Inseparable.joinedIn (h : Inseparable x y) (hx : x ∈ F) (hy : y ∈ F) : JoinedIn F x y 
goal: JoinedIn F x y

full_name: pathComponent
code: /-- The path component of `x` is the set of points that can be joined to `x`. -/
def pathComponent (x : X) 
goal: Set X

full_name: mem_pathComponent_self
code: @[simp]
theorem mem_pathComponent_self (x : X) : x ∈ pathComponent x 
goal: x ∈ pathComponent x

full_name: pathComponent.nonempty
code: @[simp]
theorem pathComponent.nonempty (x : X) : (pathComponent x).Nonempty 
goal: (pathComponent x).Nonempty

full_name: mem_pathComponent_of_mem
code: theorem mem_pathComponent_of_mem (h : x ∈ pathComponent y) : y ∈ pathComponent x 
goal: y ∈ pathComponent x

full_name: pathComponent_symm
code: theorem pathComponent_symm : x ∈ pathComponent y ↔ y ∈ pathComponent x 
goal: x ∈ pathComponent y ↔ y ∈ pathComponent x

full_name: pathComponent_congr
code: theorem pathComponent_congr (h : x ∈ pathComponent y) : pathComponent x = pathComponent y 
goal: pathComponent x = pathComponent y

full_name: pathComponent_subset_component
code: theorem pathComponent_subset_component (x : X) : pathComponent x ⊆ connectedComponent x 
goal: pathComponent x ⊆ connectedComponent x

full_name: pathComponentIn
code: /-- The path component of `x` in `F` is the set of points that can be joined to `x` in `F`. -/
def pathComponentIn (x : X) (F : Set X) 
goal: Set X

full_name: pathComponentIn_univ
code: @[simp]
theorem pathComponentIn_univ (x : X) : pathComponentIn x univ = pathComponent x 
goal: pathComponentIn x Set.univ = pathComponent x

full_name: Joined.mem_pathComponent
code: theorem Joined.mem_pathComponent (hyz : Joined y z) (hxy : y ∈ pathComponent x) :
    z ∈ pathComponent x 
goal: z ∈ pathComponent x

full_name: IsPathConnected
code: /-- A set `F` is path connected if it contains a point that can be joined to all other in `F`. -/
def IsPathConnected (F : Set X) : Prop 
goal: Prop

full_name: isPathConnected_iff_eq
code: theorem isPathConnected_iff_eq : IsPathConnected F ↔ ∃ x ∈ F, pathComponentIn x F = F 
goal: IsPathConnected F ↔ ∃ x ∈ F, pathComponentIn x F = F

full_name: IsPathConnected.joinedIn
code: theorem IsPathConnected.joinedIn (h : IsPathConnected F) :
    ∀ᵉ (x ∈ F) (y ∈ F), JoinedIn F x y 
goal: x ∈ F → ∀ y ∈ F, JoinedIn F x y

full_name: isPathConnected_iff
code: theorem isPathConnected_iff :
    IsPathConnected F ↔ F.Nonempty ∧ ∀ᵉ (x ∈ F) (y ∈ F), JoinedIn F x y 
goal: IsPathConnected F ↔ F.Nonempty ∧ ∀ x ∈ F, ∀ y ∈ F, JoinedIn F x y

full_name: IsPathConnected.image'
code: /-- If `f` is continuous on `F` and `F` is path-connected, so is `f(F)`. -/
theorem IsPathConnected.image' (hF : IsPathConnected F)
    {f : X → Y} (hf : ContinuousOn f F) : IsPathConnected (f '' F) 
goal: IsPathConnected (f '' F)

full_name: IsPathConnected.image
code: /-- If `f` is continuous and `F` is path-connected, so is `f(F)`. -/
theorem IsPathConnected.image (hF : IsPathConnected F) {f : X → Y}
    (hf : Continuous f) : IsPathConnected (f '' F) 
goal: IsPathConnected (f '' F)

full_name: Inducing.isPathConnected_iff
code: /-- If `f : X → Y` is a `Inducing`, `f(F)` is path-connected iff `F` is. -/
nonrec theorem Inducing.isPathConnected_iff {f : X → Y} (hf : Inducing f) :
    IsPathConnected F ↔ IsPathConnected (f '' F) 
goal: IsPathConnected F ↔ IsPathConnected (f '' F)

full_name: Homeomorph.isPathConnected_image
code: /-- If `h : X → Y` is a homeomorphism, `h(s)` is path-connected iff `s` is. -/
@[simp]
theorem Homeomorph.isPathConnected_image {s : Set X} (h : X ≃ₜ Y) :
    IsPathConnected (h '' s) ↔ IsPathConnected s 
goal: IsPathConnected (⇑h '' s) ↔ IsPathConnected s

full_name: Homeomorph.isPathConnected_preimage
code: /-- If `h : X → Y` is a homeomorphism, `h⁻¹(s)` is path-connected iff `s` is. -/
@[simp]
theorem Homeomorph.isPathConnected_preimage {s : Set Y} (h : X ≃ₜ Y) :
    IsPathConnected (h ⁻¹' s) ↔ IsPathConnected s 
goal: IsPathConnected (⇑h ⁻¹' s) ↔ IsPathConnected s

full_name: IsPathConnected.mem_pathComponent
code: theorem IsPathConnected.mem_pathComponent (h : IsPathConnected F) (x_in : x ∈ F) (y_in : y ∈ F) :
    y ∈ pathComponent x 
goal: y ∈ pathComponent x

full_name: IsPathConnected.subset_pathComponent
code: theorem IsPathConnected.subset_pathComponent (h : IsPathConnected F) (x_in : x ∈ F) :
    F ⊆ pathComponent x 
goal: F ⊆ pathComponent x

full_name: isPathConnected_singleton
code: theorem isPathConnected_singleton (x : X) : IsPathConnected ({x} : Set X) 
goal: IsPathConnected {x}

full_name: IsPathConnected.union
code: theorem IsPathConnected.union {U V : Set X} (hU : IsPathConnected U) (hV : IsPathConnected V)
    (hUV : (U ∩ V).Nonempty) : IsPathConnected (U ∪ V) 
goal: IsPathConnected (U ∪ V)

full_name: IsPathConnected.preimage_coe
code: /-- If a set `W` is path-connected, then it is also path-connected when seen as a set in a smaller
ambient type `U` (when `U` contains `W`). -/
theorem IsPathConnected.preimage_coe {U W : Set X} (hW : IsPathConnected W) (hWU : W ⊆ U) :
    IsPathConnected (((↑) : U → X) ⁻¹' W) 
goal: IsPathConnected (Subtype.val ⁻¹' W)

full_name: IsPathConnected.exists_path_through_family
code: theorem IsPathConnected.exists_path_through_family {n : ℕ}
    {s : Set X} (h : IsPathConnected s) (p : Fin (n + 1) → X) (hp : ∀ i, p i ∈ s) :
    ∃ γ : Path (p 0) (p n), range γ ⊆ s ∧ ∀ i, p i ∈ range γ 
goal: ∃ γ, Set.range ⇑γ ⊆ s ∧ ∀ (i : Fin (n + 1)), p i ∈ Set.range ⇑γ

full_name: IsPathConnected.exists_path_through_family'
code: theorem IsPathConnected.exists_path_through_family' {n : ℕ}
    {s : Set X} (h : IsPathConnected s) (p : Fin (n + 1) → X) (hp : ∀ i, p i ∈ s) :
    ∃ (γ : Path (p 0) (p n)) (t : Fin (n + 1) → I), (∀ t, γ t ∈ s) ∧ ∀ i, γ (t i) = p i 
goal: ∃ γ t, (∀ (t : ↑I), γ t ∈ s) ∧ ∀ (i : Fin (n + 1)), γ (t i) = p i

full_name: PathConnectedSpace.nonempty
code: /-- A topological space is path-connected if it is non-empty and every two points can be
joined by a continuous path. -/
class PathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- A path-connected space must be nonempty. -/
  nonempty : Nonempty X
  /-- Any two points in a path-connected space must be joined by a continuous path. -/
  joined : ∀ x y : X, Joined x y
goal: Nonempty X

full_name: PathConnectedSpace.joined
code: /-- A topological space is path-connected if it is non-empty and every two points can be
joined by a continuous path. -/
class PathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- A path-connected space must be nonempty. -/
  nonempty : Nonempty X
  /-- Any two points in a path-connected space must be joined by a continuous path. -/
  joined : ∀ x y : X, Joined x y
goal: Joined x y

full_name: PathConnectedSpace
code: /-- A topological space is path-connected if it is non-empty and every two points can be
joined by a continuous path. -/
class PathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- A path-connected space must be nonempty. -/
  nonempty : Nonempty X
  /-- Any two points in a path-connected space must be joined by a continuous path. -/
  joined : ∀ x y : X, Joined x y
goal: Prop

full_name: pathConnectedSpace_iff_zerothHomotopy
code: theorem pathConnectedSpace_iff_zerothHomotopy :
    PathConnectedSpace X ↔ Nonempty (ZerothHomotopy X) ∧ Subsingleton (ZerothHomotopy X) 
goal: PathConnectedSpace X ↔ Nonempty (ZerothHomotopy X) ∧ Subsingleton (ZerothHomotopy X)

full_name: PathConnectedSpace.somePath
code: /-- Use path-connectedness to build a path between two points. -/
def somePath (x y : X) : Path x y 
goal: Path x y

full_name: isPathConnected_iff_pathConnectedSpace
code: theorem isPathConnected_iff_pathConnectedSpace : IsPathConnected F ↔ PathConnectedSpace F 
goal: IsPathConnected F ↔ PathConnectedSpace ↑F

full_name: pathConnectedSpace_iff_univ
code: theorem pathConnectedSpace_iff_univ : PathConnectedSpace X ↔ IsPathConnected (univ : Set X) 
goal: PathConnectedSpace X ↔ IsPathConnected Set.univ

full_name: isPathConnected_univ
code: theorem isPathConnected_univ [PathConnectedSpace X] : IsPathConnected (univ : Set X) 
goal: IsPathConnected Set.univ

full_name: isPathConnected_range
code: theorem isPathConnected_range [PathConnectedSpace X] {f : X → Y} (hf : Continuous f) :
    IsPathConnected (range f) 
goal: IsPathConnected (Set.range f)

full_name: Function.Surjective.pathConnectedSpace
code: theorem Function.Surjective.pathConnectedSpace [PathConnectedSpace X]
    {f : X → Y} (hf : Surjective f) (hf' : Continuous f) : PathConnectedSpace Y 
goal: PathConnectedSpace Y

full_name: Quotient.instPathConnectedSpace
code: instance Quotient.instPathConnectedSpace {s : Setoid X} [PathConnectedSpace X] :
    PathConnectedSpace (Quotient s) 
goal: PathConnectedSpace (Quotient s)

full_name: Real.instPathConnectedSpace
code: /-- This is a special case of `NormedSpace.instPathConnectedSpace` (and
`TopologicalAddGroup.pathConnectedSpace`). It exists only to simplify dependencies. -/
instance Real.instPathConnectedSpace : PathConnectedSpace ℝ 
goal: PathConnectedSpace ℝ

full_name: pathConnectedSpace_iff_eq
code: theorem pathConnectedSpace_iff_eq : PathConnectedSpace X ↔ ∃ x : X, pathComponent x = univ 
goal: PathConnectedSpace X ↔ ∃ x, pathComponent x = Set.univ

full_name: PathConnectedSpace.connectedSpace
code: instance (priority := 100) PathConnectedSpace.connectedSpace [PathConnectedSpace X] :
    ConnectedSpace X 
goal: ConnectedSpace X

full_name: IsPathConnected.isConnected
code: theorem IsPathConnected.isConnected (hF : IsPathConnected F) : IsConnected F 
goal: IsConnected F

full_name: PathConnectedSpace.exists_path_through_family
code: theorem exists_path_through_family {n : ℕ} (p : Fin (n + 1) → X) :
    ∃ γ : Path (p 0) (p n), ∀ i, p i ∈ range γ 
goal: ∃ γ, ∀ (i : Fin (n + 1)), p i ∈ Set.range ⇑γ

full_name: PathConnectedSpace.exists_path_through_family'
code: theorem exists_path_through_family' {n : ℕ} (p : Fin (n + 1) → X) :
    ∃ (γ : Path (p 0) (p n)) (t : Fin (n + 1) → I), ∀ i, γ (t i) = p i 
goal: ∃ γ t, ∀ (i : Fin (n + 1)), γ (t i) = p i

full_name: LocPathConnectedSpace
code: /-- A topological space is locally path connected, at every point, path connected
neighborhoods form a neighborhood basis. -/
class LocPathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- Each neighborhood filter has a basis of path-connected neighborhoods. -/
  path_connected_basis : ∀ x : X, (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsPathConnected s) id
goal: Prop

full_name: LocPathConnectedSpace.path_connected_basis
code: /-- A topological space is locally path connected, at every point, path connected
neighborhoods form a neighborhood basis. -/
class LocPathConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  /-- Each neighborhood filter has a basis of path-connected neighborhoods. -/
  path_connected_basis : ∀ x : X, (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsPathConnected s) id
goal: (𝓝 x).HasBasis (fun s => s ∈ 𝓝 x ∧ IsPathConnected s) id

full_name: locPathConnected_of_bases
code: theorem locPathConnected_of_bases {p : ι → Prop} {s : X → ι → Set X}
    (h : ∀ x, (𝓝 x).HasBasis p (s x)) (h' : ∀ x i, p i → IsPathConnected (s x i)) :
    LocPathConnectedSpace X 
goal: LocPathConnectedSpace X

full_name: pathConnectedSpace_iff_connectedSpace
code: theorem pathConnectedSpace_iff_connectedSpace [LocPathConnectedSpace X] :
    PathConnectedSpace X ↔ ConnectedSpace X 
goal: PathConnectedSpace X ↔ ConnectedSpace X

full_name: pathConnected_subset_basis
code: theorem pathConnected_subset_basis [LocPathConnectedSpace X] {U : Set X} (h : IsOpen U)
    (hx : x ∈ U) : (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsPathConnected s ∧ s ⊆ U) id 
goal: (𝓝 x).HasBasis (fun s => s ∈ 𝓝 x ∧ IsPathConnected s ∧ s ⊆ U) id

full_name: locPathConnected_of_isOpen
code: theorem locPathConnected_of_isOpen [LocPathConnectedSpace X] {U : Set X} (h : IsOpen U) :
    LocPathConnectedSpace U 
goal: LocPathConnectedSpace ↑U

full_name: IsOpen.isConnected_iff_isPathConnected
code: theorem IsOpen.isConnected_iff_isPathConnected [LocPathConnectedSpace X] {U : Set X}
    (U_op : IsOpen U) : IsPathConnected U ↔ IsConnected U 
goal: IsPathConnected U ↔ IsConnected U