The unit interval, as a topological space

Use open unitInterval to turn on the notation I := Set.Icc (0 : ℝ) (1 : ℝ).

We provide basic instances, as well as a custom tactic for discharging 0 ≤ ↑x, 0 ≤ 1 - ↑x, ↑x ≤ 1, and 1 - ↑x ≤ 1 when x : I.

The unit interval

@[reducible, inline]

abbrev unitInterval : Set ℝ

The unit interval [0,1] in ℝ.

Equations

• unitInterval = Set.Icc 0 1

theorem unitInterval.zero_mem : 0 ∈ unitInterval

theorem unitInterval.one_mem : 1 ∈ unitInterval

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

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

theorem unitInterval.fract_mem (x : ℝ) : Int.fract x ∈ unitInterval

theorem unitInterval.mem_iff_one_sub_mem {t : ℝ} : t ∈ unitInterval ↔ 1 - t ∈ unitInterval

instance unitInterval.hasZero : Zero ↑unitInterval

Equations

• unitInterval.hasZero = { zero := ⟨0, unitInterval.zero_mem⟩ }

instance unitInterval.hasOne : One ↑unitInterval

Equations

• unitInterval.hasOne = { one := ⟨1, unitInterval.hasOne.proof_1⟩ }

instance unitInterval.instZeroLEOneClassElemReal : ZeroLEOneClass ↑unitInterval

Equations

• unitInterval.instZeroLEOneClassElemReal = ⋯

instance unitInterval.instBoundedOrderElemReal : BoundedOrder ↑unitInterval

Equations

• unitInterval.instBoundedOrderElemReal = Set.Icc.boundedOrder unitInterval.instBoundedOrderElemReal.proof_1

theorem unitInterval.univ_eq_Icc : Set.univ = Set.Icc 0 1

theorem unitInterval.coe_ne_zero {x : ↑unitInterval} : ↑x ≠ 0 ↔ x ≠ 0

theorem unitInterval.coe_ne_one {x : ↑unitInterval} : ↑x ≠ 1 ↔ x ≠ 1

@[simp]

theorem unitInterval.coe_pos {x : ↑unitInterval} : 0 < ↑x ↔ 0 < x

@[simp]

theorem unitInterval.coe_lt_one {x : ↑unitInterval} : ↑x < 1 ↔ x < 1

instance unitInterval.instNonemptyElemReal : Nonempty ↑unitInterval

Equations

• unitInterval.instNonemptyElemReal = ⋯

instance unitInterval.instMulElemReal : Mul ↑unitInterval

Equations

• unitInterval.instMulElemReal = { mul := fun (x y : ↑unitInterval) => ⟨↑x * ↑y, ⋯⟩ }

theorem unitInterval.mul_le_left {x : ↑unitInterval} {y : ↑unitInterval} : x * y ≤ x

theorem unitInterval.mul_le_right {x : ↑unitInterval} {y : ↑unitInterval} : x * y ≤ y

def unitInterval.symm : ↑unitInterval → ↑unitInterval

Unit interval central symmetry.

Equations

• unitInterval.symm t = ⟨1 - ↑t, ⋯⟩

@[simp]

theorem unitInterval.symm_zero : unitInterval.symm 0 = 1

@[simp]

theorem unitInterval.symm_one : unitInterval.symm 1 = 0

@[simp]

theorem unitInterval.symm_symm (x : ↑unitInterval) : unitInterval.symm (unitInterval.symm x) = x

theorem unitInterval.symm_involutive : Function.Involutive unitInterval.symm

theorem unitInterval.symm_bijective : Function.Bijective unitInterval.symm

@[simp]

theorem unitInterval.coe_symm_eq (x : ↑unitInterval) : ↑(unitInterval.symm x) = 1 - ↑x

theorem unitInterval.continuous_symm : Continuous unitInterval.symm

def unitInterval.symmHomeomorph : ↑unitInterval ≃ₜ ↑unitInterval

unitInterval.symm as a Homeomorph.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem unitInterval.symmHomeomorph_symm_apply : ∀ (a : ↑unitInterval), unitInterval.symmHomeomorph.symm a = unitInterval.symm a

@[simp]

theorem unitInterval.symmHomeomorph_apply : ∀ (a : ↑unitInterval), unitInterval.symmHomeomorph a = unitInterval.symm a

theorem unitInterval.strictAnti_symm : StrictAnti unitInterval.symm

@[deprecated unitInterval.symm_involutive]

theorem unitInterval.involutive_symm : Function.Involutive unitInterval.symm

Alias of unitInterval.symm_involutive.

@[deprecated unitInterval.symm_bijective]

theorem unitInterval.bijective_symm : Function.Bijective unitInterval.symm

Alias of unitInterval.symm_bijective.

@[simp]

theorem unitInterval.symm_inj {i : ↑unitInterval} {j : ↑unitInterval} : unitInterval.symm i = unitInterval.symm j ↔ i = j

theorem unitInterval.half_le_symm_iff (t : ↑unitInterval) : 1 / 2 ≤ ↑(unitInterval.symm t) ↔ ↑t ≤ 1 / 2

@[simp]

theorem unitInterval.symm_eq_one {i : ↑unitInterval} : unitInterval.symm i = 1 ↔ i = 0

@[simp]

theorem unitInterval.symm_eq_zero {i : ↑unitInterval} : unitInterval.symm i = 0 ↔ i = 1

@[simp]

theorem unitInterval.symm_le_symm {i : ↑unitInterval} {j : ↑unitInterval} : unitInterval.symm i ≤ unitInterval.symm j ↔ j ≤ i

theorem unitInterval.le_symm_comm {i : ↑unitInterval} {j : ↑unitInterval} : i ≤ unitInterval.symm j ↔ j ≤ unitInterval.symm i

theorem unitInterval.symm_le_comm {i : ↑unitInterval} {j : ↑unitInterval} : unitInterval.symm i ≤ j ↔ unitInterval.symm j ≤ i

@[simp]

theorem unitInterval.symm_lt_symm {i : ↑unitInterval} {j : ↑unitInterval} : unitInterval.symm i < unitInterval.symm j ↔ j < i

theorem unitInterval.lt_symm_comm {i : ↑unitInterval} {j : ↑unitInterval} : i < unitInterval.symm j ↔ j < unitInterval.symm i

theorem unitInterval.symm_lt_comm {i : ↑unitInterval} {j : ↑unitInterval} : unitInterval.symm i < j ↔ unitInterval.symm j < i

instance unitInterval.instConnectedSpaceElemReal : ConnectedSpace ↑unitInterval

Equations

• unitInterval.instConnectedSpaceElemReal = ⋯

theorem unitInterval.nonneg (x : ↑unitInterval) : 0 ≤ ↑x

theorem unitInterval.one_minus_nonneg (x : ↑unitInterval) : 0 ≤ 1 - ↑x

theorem unitInterval.le_one (x : ↑unitInterval) : ↑x ≤ 1

theorem unitInterval.one_minus_le_one (x : ↑unitInterval) : 1 - ↑x ≤ 1

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

theorem unitInterval.nonneg' {t : ↑unitInterval} : 0 ≤ t

like unitInterval.nonneg, but with the inequality in I.

theorem unitInterval.le_one' {t : ↑unitInterval} : t ≤ 1

like unitInterval.le_one, but with the inequality in I.

theorem unitInterval.pos_iff_ne_zero {x : ↑unitInterval} : 0 < x ↔ x ≠ 0

theorem unitInterval.lt_one_iff_ne_one {x : ↑unitInterval} : x < 1 ↔ x ≠ 1

theorem unitInterval.eq_one_or_eq_zero_of_le_mul {i : ↑unitInterval} {j : ↑unitInterval} (h : i ≤ j * i) : i = 0 ∨ j = 1

instance unitInterval.instNontrivialElemReal : Nontrivial ↑unitInterval

Equations

• unitInterval.instNontrivialElemReal = ⋯

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

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

instance unitInterval.instLinearOrderedCommMonoidWithZeroElemReal : LinearOrderedCommMonoidWithZero ↑unitInterval

Equations

• One or more equations did not get rendered due to their size.

theorem Set.abs_projIcc_sub_projIcc {α : Type u_1} [LinearOrderedAddCommGroup α] {a : α} {b : α} {c : α} {d : α} (h : a ≤ b) : |↑(Set.projIcc a b h c) - ↑(Set.projIcc a b h d)| ≤ |c - d|

Set.projIcc is a contraction.

def Set.Icc.addNSMul {α : Type u_1} [LinearOrderedAddCommGroup α] {a : α} {b : α} (h : a ≤ b) (δ : α) (n : ℕ) : ↑(Set.Icc a b)

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.

Equations

• Set.Icc.addNSMul h δ n = Set.projIcc a b h (a + n • δ)

theorem Set.Icc.addNSMul_zero {α : Type u_1} [LinearOrderedAddCommGroup α] {a : α} {b : α} (h : a ≤ b) {δ : α} : ↑(Set.Icc.addNSMul h δ 0) = a

theorem Set.Icc.addNSMul_eq_right {α : Type u_1} [LinearOrderedAddCommGroup α] {a : α} {b : α} (h : a ≤ b) {δ : α} [Archimedean α] (hδ : 0 < δ) : ∃ (m : ℕ), ∀ n ≥ m, ↑(Set.Icc.addNSMul h δ n) = b

theorem Set.Icc.monotone_addNSMul {α : Type u_1} [LinearOrderedAddCommGroup α] {a : α} {b : α} (h : a ≤ b) {δ : α} (hδ : 0 ≤ δ) : Monotone (Set.Icc.addNSMul h δ)

theorem Set.Icc.abs_sub_addNSMul_le {α : Type u_1} [LinearOrderedAddCommGroup α] {a : α} {b : α} (h : a ≤ b) {δ : α} (hδ : 0 ≤ δ) {t : ↑(Set.Icc a b)} (n : ℕ) (ht : t ∈ Set.Icc (Set.Icc.addNSMul h δ n) (Set.Icc.addNSMul h δ (n + 1))) : |↑t - ↑(Set.Icc.addNSMul h δ n)| ≤ δ

theorem exists_monotone_Icc_subset_open_cover_Icc {ι : Sort u_1} {a : ℝ} {b : ℝ} (h : a ≤ b) {c : ι → Set ↑(Set.Icc a b)} (hc₁ : ∀ (i : ι), IsOpen (c i)) (hc₂ : Set.univ ⊆ ⋃ (i : ι), c i) : ∃ (t : ℕ → ↑(Set.Icc a b)), ↑(t 0) = a ∧ Monotone t ∧ (∃ (m : ℕ), ∀ n ≥ m, ↑(t n) = b) ∧ ∀ (n : ℕ), ∃ (i : ι), Set.Icc (t n) (t (n + 1)) ⊆ c i

Any open cover c of a closed interval [a, b] in ℝ can be refined to a finite partition into subintervals.

theorem exists_monotone_Icc_subset_open_cover_unitInterval {ι : Sort u_1} {c : ι → Set ↑unitInterval} (hc₁ : ∀ (i : ι), IsOpen (c i)) (hc₂ : Set.univ ⊆ ⋃ (i : ι), c i) : ∃ (t : ℕ → ↑unitInterval), t 0 = 0 ∧ Monotone t ∧ (∃ (n : ℕ), ∀ m ≥ n, t m = 1) ∧ ∀ (n : ℕ), ∃ (i : ι), Set.Icc (t n) (t (n + 1)) ⊆ c i

Any open cover of the unit interval can be refined to a finite partition into subintervals.

theorem exists_monotone_Icc_subset_open_cover_unitInterval_prod_self {ι : Sort u_1} {c : ι → Set (↑unitInterval × ↑unitInterval)} (hc₁ : ∀ (i : ι), IsOpen (c i)) (hc₂ : Set.univ ⊆ ⋃ (i : ι), c i) : ∃ (t : ℕ → ↑unitInterval), 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

@[simp]

theorem projIcc_eq_zero {x : ℝ} : Set.projIcc 0 1 ⋯ x = 0 ↔ x ≤ 0

@[simp]

theorem projIcc_eq_one {x : ℝ} : Set.projIcc 0 1 ⋯ x = 1 ↔ 1 ≤ x

def Tactic.Interactive.tacticUnit_interval : Lean.ParserDescr

A tactic that solves 0 ≤ ↑x, 0 ≤ 1 - ↑x, ↑x ≤ 1, and 1 - ↑x ≤ 1 for x : I.

Equations

• Tactic.Interactive.tacticUnit_interval = Lean.ParserDescr.node `Tactic.Interactive.tacticUnit_interval 1024 (Lean.ParserDescr.nonReservedSymbol "unit_interval" false)

theorem affineHomeomorph_image_I {𝕜 : Type u_1} [LinearOrderedField 𝕜] [TopologicalSpace 𝕜] [TopologicalRing 𝕜] (a : 𝕜) (b : 𝕜) (h : 0 < a) : ⇑(affineHomeomorph a b ⋯) '' Set.Icc 0 1 = Set.Icc b (a + b)

The image of [0,1] under the homeomorphism fun x ↦ a * x + b is [b, a+b].

def iccHomeoI {𝕜 : Type u_1} [LinearOrderedField 𝕜] [TopologicalSpace 𝕜] [TopologicalRing 𝕜] (a : 𝕜) (b : 𝕜) (h : a < b) : ↑(Set.Icc a b) ≃ₜ ↑(Set.Icc 0 1)

The affine homeomorphism from a nontrivial interval [a,b] to [0,1].

Equations

• iccHomeoI a b h = (((affineHomeomorph (b - a) a ⋯).image (Set.Icc 0 1)).trans (Homeomorph.setCongr ⋯)).symm

@[simp]

theorem iccHomeoI_apply_coe {𝕜 : Type u_1} [LinearOrderedField 𝕜] [TopologicalSpace 𝕜] [TopologicalRing 𝕜] (a : 𝕜) (b : 𝕜) (h : a < b) (x : ↑(Set.Icc a b)) : ↑((iccHomeoI a b h) x) = (↑x - a) / (b - a)

@[simp]

theorem iccHomeoI_symm_apply_coe {𝕜 : Type u_1} [LinearOrderedField 𝕜] [TopologicalSpace 𝕜] [TopologicalRing 𝕜] (a : 𝕜) (b : 𝕜) (h : a < b) (x : ↑(Set.Icc 0 1)) : ↑((iccHomeoI a b h).symm x) = (b - a) * ↑x + a