File: Mathlib/Topology/Homotopy/HSpaces.lean

full_name: HSpace
code: /-- A topological space `X` is an H-space if it behaves like a (potentially non-associative)
topological group, but where the axioms for a group only hold up to homotopy.
-/
class HSpace (X : Type u) [TopologicalSpace X] where
  hmul : C(X × X, X)
  e : X
  hmul_e_e : hmul (e, e) = e
  eHmul :
    (hmul.comp <| (const X e).prodMk <| ContinuousMap.id X).HomotopyRel (ContinuousMap.id X) {e}
  hmulE :
    (hmul.comp <| (ContinuousMap.id X).prodMk <| const X e).HomotopyRel (ContinuousMap.id X) {e}
goal: Type u

full_name: HSpace.hmul_e_e
code: /-- A topological space `X` is an H-space if it behaves like a (potentially non-associative)
topological group, but where the axioms for a group only hold up to homotopy.
-/
class HSpace (X : Type u) [TopologicalSpace X] where
  hmul : C(X × X, X)
  e : X
  hmul_e_e : hmul (e, e) = e
  eHmul :
    (hmul.comp <| (const X e).prodMk <| ContinuousMap.id X).HomotopyRel (ContinuousMap.id X) {e}
  hmulE :
    (hmul.comp <| (ContinuousMap.id X).prodMk <| const X e).HomotopyRel (ContinuousMap.id X) {e}
goal: HSpace.hmul (HSpace.e, HSpace.e) = HSpace.e

full_name: HSpace.eHmul
code: /-- A topological space `X` is an H-space if it behaves like a (potentially non-associative)
topological group, but where the axioms for a group only hold up to homotopy.
-/
class HSpace (X : Type u) [TopologicalSpace X] where
  hmul : C(X × X, X)
  e : X
  hmul_e_e : hmul (e, e) = e
  eHmul :
    (hmul.comp <| (const X e).prodMk <| ContinuousMap.id X).HomotopyRel (ContinuousMap.id X) {e}
  hmulE :
    (hmul.comp <| (ContinuousMap.id X).prodMk <| const X e).HomotopyRel (ContinuousMap.id X) {e}
goal: (HSpace.hmul.comp ((ContinuousMap.const X HSpace.e).prodMk (ContinuousMap.id X))).HomotopyRel (ContinuousMap.id X)
  {HSpace.e}

full_name: HSpace.e
code: /-- A topological space `X` is an H-space if it behaves like a (potentially non-associative)
topological group, but where the axioms for a group only hold up to homotopy.
-/
class HSpace (X : Type u) [TopologicalSpace X] where
  hmul : C(X × X, X)
  e : X
  hmul_e_e : hmul (e, e) = e
  eHmul :
    (hmul.comp <| (const X e).prodMk <| ContinuousMap.id X).HomotopyRel (ContinuousMap.id X) {e}
  hmulE :
    (hmul.comp <| (ContinuousMap.id X).prodMk <| const X e).HomotopyRel (ContinuousMap.id X) {e}
goal: X

full_name: HSpace.hmulE
code: /-- A topological space `X` is an H-space if it behaves like a (potentially non-associative)
topological group, but where the axioms for a group only hold up to homotopy.
-/
class HSpace (X : Type u) [TopologicalSpace X] where
  hmul : C(X × X, X)
  e : X
  hmul_e_e : hmul (e, e) = e
  eHmul :
    (hmul.comp <| (const X e).prodMk <| ContinuousMap.id X).HomotopyRel (ContinuousMap.id X) {e}
  hmulE :
    (hmul.comp <| (ContinuousMap.id X).prodMk <| const X e).HomotopyRel (ContinuousMap.id X) {e}
goal: (HSpace.hmul.comp ((ContinuousMap.id X).prodMk (ContinuousMap.const X HSpace.e))).HomotopyRel (ContinuousMap.id X)
  {HSpace.e}

full_name: HSpace.hmul
code: /-- A topological space `X` is an H-space if it behaves like a (potentially non-associative)
topological group, but where the axioms for a group only hold up to homotopy.
-/
class HSpace (X : Type u) [TopologicalSpace X] where
  hmul : C(X × X, X)
  e : X
  hmul_e_e : hmul (e, e) = e
  eHmul :
    (hmul.comp <| (const X e).prodMk <| ContinuousMap.id X).HomotopyRel (ContinuousMap.id X) {e}
  hmulE :
    (hmul.comp <| (ContinuousMap.id X).prodMk <| const X e).HomotopyRel (ContinuousMap.id X) {e}
goal: C(X × X, X)

full_name: HSpaces.«_aux_Mathlib_Topology_Homotopy_HSpaces___macroRules_HSpaces_term_⋀__1»
code: /-- The binary operation `hmul` on an `H`-space -/
scoped[HSpaces] notation x "⋀" y => HSpace.hmul (x, y)
goal: Lean.Macro

full_name: HSpaces._aux_Mathlib_Topology_Homotopy_HSpaces___unexpand_HSpace_hmul_1
code: /-- The binary operation `hmul` on an `H`-space -/
scoped[HSpaces] notation x "⋀" y => HSpace.hmul (x, y)
goal: Lean.PrettyPrinter.Unexpander

full_name: HSpace.prod
code: instance HSpace.prod (X : Type u) (Y : Type v) [TopologicalSpace X] [TopologicalSpace Y] [HSpace X]
    [HSpace Y] : HSpace (X × Y) 
goal: HSpace (X × Y)

full_name: TopologicalAddGroup.toHSpace
code: /-- The definition `toHSpace` is not an instance because its additive version would
lead to a diamond since a topological field would inherit two `HSpace` structures, one from the
`MulOneClass` and one from the `AddZeroClass`. In the case of a group, we make
`TopologicalGroup.hSpace` an instance."-/
@[to_additive
      "The definition `toHSpace` is not an instance because it comes together with a
      multiplicative version which would lead to a diamond since a topological field would inherit
      two `HSpace` structures, one from the `MulOneClass` and one from the `AddZeroClass`.
      In the case of an additive group, we make `TopologicalAddGroup.hSpace` an instance."]
def toHSpace (M : Type u) [MulOneClass M] [TopologicalSpace M] [ContinuousMul M] : HSpace M 
goal: HSpace M

full_name: TopologicalGroup.toHSpace
code: /-- The definition `toHSpace` is not an instance because its additive version would
lead to a diamond since a topological field would inherit two `HSpace` structures, one from the
`MulOneClass` and one from the `AddZeroClass`. In the case of a group, we make
`TopologicalGroup.hSpace` an instance."-/
@[to_additive
      "The definition `toHSpace` is not an instance because it comes together with a
      multiplicative version which would lead to a diamond since a topological field would inherit
      two `HSpace` structures, one from the `MulOneClass` and one from the `AddZeroClass`.
      In the case of an additive group, we make `TopologicalAddGroup.hSpace` an instance."]
def toHSpace (M : Type u) [MulOneClass M] [TopologicalSpace M] [ContinuousMul M] : HSpace M 
goal: HSpace M

full_name: TopologicalGroup.hSpace
code: @[to_additive]
instance (priority := 600) hSpace (G : Type u) [TopologicalSpace G] [Group G] [TopologicalGroup G] :
    HSpace G 
goal: HSpace G

full_name: TopologicalAddGroup.hSpace
code: @[to_additive]
instance (priority := 600) hSpace (G : Type u) [TopologicalSpace G] [Group G] [TopologicalGroup G] :
    HSpace G 
goal: HSpace G

full_name: TopologicalGroup.one_eq_hSpace_e
code: theorem one_eq_hSpace_e {G : Type u} [TopologicalSpace G] [Group G] [TopologicalGroup G] :
    (1 : G) = HSpace.e 
goal: 1 = HSpace.e

full_name: unitInterval.qRight
code: /-- `qRight` is analogous to the function `Q` defined on p. 475 of [serre1951] that helps proving
continuity of `delayReflRight`. -/
def qRight (p : I × I) : I 
goal: ↑I

full_name: unitInterval.continuous_qRight
code: theorem continuous_qRight : Continuous qRight 
goal: Continuous unitInterval.qRight

full_name: unitInterval.qRight_zero_left
code: theorem qRight_zero_left (θ : I) : qRight (0, θ) = 0 
goal: unitInterval.qRight (0, θ) = 0

full_name: unitInterval.qRight_one_left
code: theorem qRight_one_left (θ : I) : qRight (1, θ) = 1 
goal: unitInterval.qRight (1, θ) = 1

full_name: unitInterval.qRight_zero_right
code: theorem qRight_zero_right (t : I) :
    (qRight (t, 0) : ℝ) = if (t : ℝ) ≤ 1 / 2 then (2 : ℝ) * t else 1 
goal: ↑(unitInterval.qRight (t, 0)) = if ↑t ≤ 1 / 2 then 2 * ↑t else 1

full_name: unitInterval.qRight_one_right
code: theorem qRight_one_right (t : I) : qRight (t, 1) = t 
goal: unitInterval.qRight (t, 1) = t

full_name: Path.delayReflRight
code: /-- This is the function analogous to the one on p. 475 of [serre1951], defining a homotopy from
the product path `γ ∧ e` to `γ`. -/
def delayReflRight (θ : I) (γ : Path x y) : Path x y 
goal: Path x y

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

full_name: Path.delayReflRight_zero
code: theorem delayReflRight_zero (γ : Path x y) : delayReflRight 0 γ = γ.trans (Path.refl y) 
goal: Path.delayReflRight 0 γ = γ.trans (Path.refl y)

full_name: Path.delayReflRight_one
code: theorem delayReflRight_one (γ : Path x y) : delayReflRight 1 γ = γ 
goal: Path.delayReflRight 1 γ = γ

full_name: Path.delayReflLeft
code: /-- This is the function on p. 475 of [serre1951], defining a homotopy from a path `γ` to the
product path `e ∧ γ`. -/
def delayReflLeft (θ : I) (γ : Path x y) : Path x y 
goal: Path x y

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

full_name: Path.delayReflLeft_zero
code: theorem delayReflLeft_zero (γ : Path x y) : delayReflLeft 0 γ = (Path.refl x).trans γ 
goal: Path.delayReflLeft 0 γ = (Path.refl x).trans γ

full_name: Path.delayReflLeft_one
code: theorem delayReflLeft_one (γ : Path x y) : delayReflLeft 1 γ = γ 
goal: Path.delayReflLeft 1 γ = γ

full_name: Path.instHSpace
code: /-- The loop space at x carries a structure of an H-space. Note that the field `eHmul`
(resp. `hmulE`) neither implies nor is implied by `Path.Homotopy.reflTrans`
(resp. `Path.Homotopy.transRefl`).
-/
instance (x : X) : HSpace (Path x x) 
goal: HSpace (Path x x)