File: Mathlib/Topology/UnitInterval.lean

full_name: unitInterval
code: /-- The unit interval `[0,1]` in ℝ. -/
abbrev unitInterval : Set ℝ 
goal: Set ℝ

full_name: unitInterval._aux_Mathlib_Topology_UnitInterval___unexpand_unitInterval_1
code: @[inherit_doc]
scoped[unitInterval] notation "I" => unitInterval
goal: Lean.PrettyPrinter.Unexpander

full_name: unitInterval._aux_Mathlib_Topology_UnitInterval___macroRules_unitInterval_termI_1
code: @[inherit_doc]
scoped[unitInterval] notation "I" => unitInterval
goal: Lean.Macro

full_name: unitInterval.zero_mem
code: theorem zero_mem : (0 : ℝ) ∈ I 
goal: 0 ∈ unitInterval

full_name: unitInterval.one_mem
code: theorem one_mem : (1 : ℝ) ∈ I 
goal: 1 ∈ unitInterval

full_name: unitInterval.mul_mem
code: theorem mul_mem {x y : ℝ} (hx : x ∈ I) (hy : y ∈ I) : x * y ∈ I 
goal: x * y ∈ unitInterval

full_name: unitInterval.div_mem
code: theorem div_mem {x y : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y) (hxy : x ≤ y) : x / y ∈ I 
goal: x / y ∈ unitInterval

full_name: unitInterval.fract_mem
code: theorem fract_mem (x : ℝ) : fract x ∈ I 
goal: Int.fract x ∈ unitInterval

full_name: unitInterval.mem_iff_one_sub_mem
code: theorem mem_iff_one_sub_mem {t : ℝ} : t ∈ I ↔ 1 - t ∈ I 
goal: t ∈ unitInterval ↔ 1 - t ∈ unitInterval

full_name: unitInterval.hasZero
code: instance hasZero : Zero I 
goal: Zero ↑unitInterval

full_name: unitInterval.hasOne
code: instance hasOne : One I 
goal: One ↑unitInterval

full_name: unitInterval.instZeroLEOneClassElemReal
code: instance : ZeroLEOneClass I 
goal: ZeroLEOneClass ↑unitInterval

full_name: unitInterval.instBoundedOrderElemReal
code: instance : BoundedOrder I 
goal: BoundedOrder ↑unitInterval

full_name: unitInterval.univ_eq_Icc
code: lemma univ_eq_Icc : (univ : Set I) = Icc (0 : I) (1 : I) 
goal: Set.univ = Set.Icc 0 1

full_name: unitInterval.coe_ne_zero
code: theorem coe_ne_zero {x : I} : (x : ℝ) ≠ 0 ↔ x ≠ 0 
goal: ↑x ≠ 0 ↔ x ≠ 0

full_name: unitInterval.coe_ne_one
code: theorem coe_ne_one {x : I} : (x : ℝ) ≠ 1 ↔ x ≠ 1 
goal: ↑x ≠ 1 ↔ x ≠ 1

full_name: unitInterval.instNonemptyElemReal
code: instance : Nonempty I 
goal: Nonempty ↑unitInterval

full_name: unitInterval.instMulElemReal
code: instance : Mul I 
goal: Mul ↑unitInterval

full_name: unitInterval.mul_le_left
code: theorem mul_le_left {x y : I} : x * y ≤ x 
goal: x * y ≤ x

full_name: unitInterval.mul_le_right
code: theorem mul_le_right {x y : I} : x * y ≤ y 
goal: x * y ≤ y

full_name: unitInterval.symm
code: /-- Unit interval central symmetry. -/
def symm : I → I 
goal: ↑unitInterval → ↑unitInterval

full_name: unitInterval._aux_Mathlib_Topology_UnitInterval___macroRules_unitInterval_termσ_1
code: @[inherit_doc]
scoped notation "σ" => unitInterval.symm
goal: Lean.Macro

full_name: unitInterval._aux_Mathlib_Topology_UnitInterval___unexpand_unitInterval_symm_1
code: @[inherit_doc]
scoped notation "σ" => unitInterval.symm
goal: Lean.PrettyPrinter.Unexpander

full_name: unitInterval.symm_zero
code: @[simp]
theorem symm_zero : σ 0 = 1 
goal: unitInterval.symm 0 = 1

full_name: unitInterval.symm_one
code: @[simp]
theorem symm_one : σ 1 = 0 
goal: unitInterval.symm 1 = 0

full_name: unitInterval.symm_symm
code: @[simp]
theorem symm_symm (x : I) : σ (σ x) = x 
goal: unitInterval.symm (unitInterval.symm x) = x

full_name: unitInterval.symm_involutive
code: theorem symm_involutive : Function.Involutive (symm : I → I) 
goal: Function.Involutive unitInterval.symm

full_name: unitInterval.symm_bijective
code: theorem symm_bijective : Function.Bijective (symm : I → I) 
goal: Function.Bijective unitInterval.symm

full_name: unitInterval.coe_symm_eq
code: @[simp]
theorem coe_symm_eq (x : I) : (σ x : ℝ) = 1 - x 
goal: ↑(unitInterval.symm x) = 1 - ↑x

full_name: unitInterval.continuous_symm
code: @[continuity, fun_prop]
theorem continuous_symm : Continuous σ 
goal: Continuous unitInterval.symm

full_name: unitInterval.symmHomeomorph_symm_apply
code: /-- `unitInterval.symm` as a `Homeomorph`. -/
@[simps]
def symmHomeomorph : I ≃ₜ I 
goal: ∀ (a : ↑unitInterval), unitInterval.symmHomeomorph.symm a = unitInterval.symm a

full_name: unitInterval.symmHomeomorph_apply
code: /-- `unitInterval.symm` as a `Homeomorph`. -/
@[simps]
def symmHomeomorph : I ≃ₜ I 
goal: ∀ (a : ↑unitInterval), unitInterval.symmHomeomorph a = unitInterval.symm a

full_name: unitInterval.symmHomeomorph
code: /-- `unitInterval.symm` as a `Homeomorph`. -/
@[simps]
def symmHomeomorph : I ≃ₜ I 
goal: ↑unitInterval ≃ₜ ↑unitInterval

full_name: unitInterval.strictAnti_symm
code: theorem strictAnti_symm : StrictAnti σ 
goal: StrictAnti unitInterval.symm

full_name: unitInterval.half_le_symm_iff
code: theorem half_le_symm_iff (t : I) : 1 / 2 ≤ (σ t : ℝ) ↔ (t : ℝ) ≤ 1 / 2 
goal: 1 / 2 ≤ ↑(unitInterval.symm t) ↔ ↑t ≤ 1 / 2

full_name: unitInterval.instConnectedSpaceElemReal
code: instance : ConnectedSpace I 
goal: ConnectedSpace ↑unitInterval

full_name: unitInterval.nonneg
code: theorem nonneg (x : I) : 0 ≤ (x : ℝ) 
goal: 0 ≤ ↑x

full_name: unitInterval.one_minus_nonneg
code: theorem one_minus_nonneg (x : I) : 0 ≤ 1 - (x : ℝ) 
goal: 0 ≤ 1 - ↑x

full_name: unitInterval.le_one
code: theorem le_one (x : I) : (x : ℝ) ≤ 1 
goal: ↑x ≤ 1

full_name: unitInterval.one_minus_le_one
code: theorem one_minus_le_one (x : I) : 1 - (x : ℝ) ≤ 1 
goal: 1 - ↑x ≤ 1

full_name: unitInterval.add_pos
code: theorem add_pos {t : I} {x : ℝ} (hx : 0 < x) : 0 < (x + t : ℝ) 
goal: 0 < x + ↑t

full_name: unitInterval.nonneg'
code: /-- like `unitInterval.nonneg`, but with the inequality in `I`. -/
theorem nonneg' {t : I} : 0 ≤ t 
goal: 0 ≤ t

full_name: unitInterval.le_one'
code: /-- like `unitInterval.le_one`, but with the inequality in `I`. -/
theorem le_one' {t : I} : t ≤ 1 
goal: t ≤ 1

full_name: unitInterval.instNontrivialElemReal
code: instance : Nontrivial I 
goal: Nontrivial ↑unitInterval

full_name: unitInterval.mul_pos_mem_iff
code: theorem mul_pos_mem_iff {a t : ℝ} (ha : 0 < a) : a * t ∈ I ↔ t ∈ Set.Icc (0 : ℝ) (1 / a) 
goal: a * t ∈ unitInterval ↔ t ∈ Set.Icc 0 (1 / a)

full_name: unitInterval.two_mul_sub_one_mem_iff
code: theorem two_mul_sub_one_mem_iff {t : ℝ} : 2 * t - 1 ∈ I ↔ t ∈ Set.Icc (1 / 2 : ℝ) 1 
goal: 2 * t - 1 ∈ unitInterval ↔ t ∈ Set.Icc (1 / 2) 1

full_name: Set.abs_projIcc_sub_projIcc
code: /-- `Set.projIcc` is a contraction. -/
lemma _root_.Set.abs_projIcc_sub_projIcc : (|projIcc a b h c - projIcc a b h d| : α) ≤ |c - d| 
goal: |↑(Set.projIcc a b h c) - ↑(Set.projIcc a b h d)| ≤ |c - d|

full_name: Set.Icc.addNSMul
code: /-- When `h : a ≤ b` and `δ > 0`, `addNSMul h δ` is a sequence of points in the closed interval
  `[a,b]`, which is initially equally spaced but eventually stays at the right endpoint `b`. -/
def addNSMul (δ : α) (n : ℕ) : Icc a b 
goal: ↑(Set.Icc a b)

full_name: Set.Icc.addNSMul_zero
code: lemma addNSMul_zero : addNSMul h δ 0 = a 
goal: ↑(Set.Icc.addNSMul h δ 0) = a

full_name: Set.Icc.addNSMul_eq_right
code: lemma addNSMul_eq_right [Archimedean α] (hδ : 0 < δ) :
    ∃ m, ∀ n ≥ m, addNSMul h δ n = b 
goal: ∃ m, ∀ n ≥ m, ↑(Set.Icc.addNSMul h δ n) = b

full_name: Set.Icc.monotone_addNSMul
code: lemma monotone_addNSMul (hδ : 0 ≤ δ) : Monotone (addNSMul h δ) 
goal: Monotone (Set.Icc.addNSMul h δ)

full_name: Set.Icc.abs_sub_addNSMul_le
code: lemma abs_sub_addNSMul_le (hδ : 0 ≤ δ) {t : Icc a b} (n : ℕ)
    (ht : t ∈ Icc (addNSMul h δ n) (addNSMul h δ (n+1))) :
    (|t - addNSMul h δ n| : α) ≤ δ 
goal: |↑t - ↑(Set.Icc.addNSMul h δ n)| ≤ δ

full_name: exists_monotone_Icc_subset_open_cover_Icc
code: /-- Any open cover `c` of a closed interval `[a, b]` in ℝ can be refined to
  a finite partition into subintervals. -/
lemma exists_monotone_Icc_subset_open_cover_Icc {ι} {a b : ℝ} (h : a ≤ b) {c : ι → Set (Icc a b)}
    (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : univ ⊆ ⋃ i, c i) : ∃ t : ℕ → Icc a b, t 0 = a ∧
      Monotone t ∧ (∃ m, ∀ n ≥ m, t n = b) ∧ ∀ n, ∃ i, Icc (t n) (t (n + 1)) ⊆ c i 
goal: ∃ t, ↑(t 0) = a ∧ Monotone t ∧ (∃ m, ∀ n ≥ m, ↑(t n) = b) ∧ ∀ (n : ℕ), ∃ i, Set.Icc (t n) (t (n + 1)) ⊆ c i

full_name: exists_monotone_Icc_subset_open_cover_unitInterval
code: /-- Any open cover of the unit interval can be refined to a finite partition into subintervals. -/
lemma exists_monotone_Icc_subset_open_cover_unitInterval {ι} {c : ι → Set I}
    (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : univ ⊆ ⋃ i, c i) : ∃ t : ℕ → I, t 0 = 0 ∧
      Monotone t ∧ (∃ n, ∀ m ≥ n, t m = 1) ∧ ∀ n, ∃ i, Icc (t n) (t (n + 1)) ⊆ c i 
goal: ∃ t, t 0 = 0 ∧ Monotone t ∧ (∃ n, ∀ m ≥ n, t m = 1) ∧ ∀ (n : ℕ), ∃ i, Set.Icc (t n) (t (n + 1)) ⊆ c i

full_name: exists_monotone_Icc_subset_open_cover_unitInterval_prod_self
code: lemma exists_monotone_Icc_subset_open_cover_unitInterval_prod_self {ι} {c : ι → Set (I × I)}
    (hc₁ : ∀ i, IsOpen (c i)) (hc₂ : univ ⊆ ⋃ i, c i) :
    ∃ t : ℕ → I, t 0 = 0 ∧ Monotone t ∧ (∃ n, ∀ m ≥ n, t m = 1) ∧
      ∀ n m, ∃ i, Icc (t n) (t (n + 1)) ×ˢ Icc (t m) (t (m + 1)) ⊆ c i 
goal: ∃ t,
  t 0 = 0 ∧
    Monotone t ∧
      (∃ n, ∀ m ≥ n, t m = 1) ∧ ∀ (n m : ℕ), ∃ i, Set.Icc (t n) (t (n + 1)) ×ˢ Set.Icc (t m) (t (m + 1)) ⊆ c i

full_name: projIcc_eq_zero
code: @[simp]
theorem projIcc_eq_zero {x : ℝ} : projIcc (0 : ℝ) 1 zero_le_one x = 0 ↔ x ≤ 0 
goal: Set.projIcc 0 1 ⋯ x = 0 ↔ x ≤ 0

full_name: projIcc_eq_one
code: @[simp]
theorem projIcc_eq_one {x : ℝ} : projIcc (0 : ℝ) 1 zero_le_one x = 1 ↔ 1 ≤ x 
goal: Set.projIcc 0 1 ⋯ x = 1 ↔ 1 ≤ x

full_name: Tactic.Interactive._aux_Mathlib_Topology_UnitInterval___macroRules_Tactic_Interactive_tacticUnit_interval_1
code: macro "unit_interval" : tactic =>
  `(tactic| (first
  | apply unitInterval.nonneg
  | apply unitInterval.one_minus_nonneg
  | apply unitInterval.le_one
  | apply unitInterval.one_minus_le_one))
goal: Lean.Macro

full_name: Tactic.Interactive.tacticUnit_interval
code: macro "unit_interval" : tactic =>
  `(tactic| (first
  | apply unitInterval.nonneg
  | apply unitInterval.one_minus_nonneg
  | apply unitInterval.le_one
  | apply unitInterval.one_minus_le_one))
goal: Lean.ParserDescr

full_name: affineHomeomorph_image_I
code: /-- The image of `[0,1]` under the homeomorphism `fun x ↦ a * x + b` is `[b, a+b]`.
-/
theorem affineHomeomorph_image_I (a b : 𝕜) (h : 0 < a) :
    affineHomeomorph a b h.ne.symm '' Set.Icc 0 1 = Set.Icc b (a + b) 
goal: ⇑(affineHomeomorph a b ⋯) '' Set.Icc 0 1 = Set.Icc b (a + b)

full_name: iccHomeoI
code: /-- The affine homeomorphism from a nontrivial interval `[a,b]` to `[0,1]`.
-/
def iccHomeoI (a b : 𝕜) (h : a < b) : Set.Icc a b ≃ₜ Set.Icc (0 : 𝕜) (1 : 𝕜) 
goal: ↑(Set.Icc a b) ≃ₜ ↑(Set.Icc 0 1)

full_name: iccHomeoI_apply_coe
code: @[simp]
theorem iccHomeoI_apply_coe (a b : 𝕜) (h : a < b) (x : Set.Icc a b) :
    ((iccHomeoI a b h) x : 𝕜) = (x - a) / (b - a) 
goal: ↑((iccHomeoI a b h) x) = (↑x - a) / (b - a)

full_name: iccHomeoI_symm_apply_coe
code: @[simp]
theorem iccHomeoI_symm_apply_coe (a b : 𝕜) (h : a < b) (x : Set.Icc (0 : 𝕜) (1 : 𝕜)) :
    ((iccHomeoI a b h).symm x : 𝕜) = (b - a) * x + a 
goal: ↑((iccHomeoI a b h).symm x) = (b - a) * ↑x + a