File: Mathlib/Algebra/Order/Interval/Basic.lean

full_name: instOneNonemptyInterval
code: @[to_additive]
instance : One (NonemptyInterval α) 
goal: One (NonemptyInterval α)

full_name: instZeroNonemptyInterval
code: @[to_additive]
instance : One (NonemptyInterval α) 
goal: Zero (NonemptyInterval α)

full_name: NonemptyInterval.toProd_one
code: @[to_additive (attr := simp) toProd_zero]
theorem toProd_one : (1 : NonemptyInterval α).toProd = 1 
goal: NonemptyInterval.toProd 1 = 1

full_name: NonemptyInterval.toProd_zero
code: @[to_additive (attr := simp) toProd_zero]
theorem toProd_one : (1 : NonemptyInterval α).toProd = 1 
goal: NonemptyInterval.toProd 0 = 0

full_name: NonemptyInterval.fst_one
code: @[to_additive]
theorem fst_one : (1 : NonemptyInterval α).fst = 1 
goal: (NonemptyInterval.toProd 1).1 = 1

full_name: NonemptyInterval.fst_zero
code: @[to_additive]
theorem fst_one : (1 : NonemptyInterval α).fst = 1 
goal: (NonemptyInterval.toProd 0).1 = 0

full_name: NonemptyInterval.snd_one
code: @[to_additive]
theorem snd_one : (1 : NonemptyInterval α).snd = 1 
goal: (NonemptyInterval.toProd 1).2 = 1

full_name: NonemptyInterval.snd_zero
code: @[to_additive]
theorem snd_one : (1 : NonemptyInterval α).snd = 1 
goal: (NonemptyInterval.toProd 0).2 = 0

full_name: NonemptyInterval.coe_zero_interval
code: @[to_additive (attr := push_cast, simp)]
theorem coe_one_interval : ((1 : NonemptyInterval α) : Interval α) = 1 
goal: ↑0 = 0

full_name: NonemptyInterval.coe_one_interval
code: @[to_additive (attr := push_cast, simp)]
theorem coe_one_interval : ((1 : NonemptyInterval α) : Interval α) = 1 
goal: ↑1 = 1

full_name: NonemptyInterval.pure_one
code: @[to_additive (attr := simp)]
theorem pure_one : pure (1 : α) = 1 
goal: NonemptyInterval.pure 1 = 1

full_name: NonemptyInterval.pure_zero
code: @[to_additive (attr := simp)]
theorem pure_one : pure (1 : α) = 1 
goal: NonemptyInterval.pure 0 = 0

full_name: Interval.pure_one
code: @[to_additive (attr := simp)]
theorem pure_one : pure (1 : α) = 1 
goal: Interval.pure 1 = 1

full_name: Interval.pure_zero
code: @[to_additive (attr := simp)]
theorem pure_one : pure (1 : α) = 1 
goal: Interval.pure 0 = 0

full_name: Interval.zero_ne_bot
code: @[to_additive] lemma one_ne_bot : (1 : Interval α) ≠ ⊥ 
goal: 0 ≠ ⊥

full_name: Interval.one_ne_bot
code: @[to_additive] lemma one_ne_bot : (1 : Interval α) ≠ ⊥ 
goal: 1 ≠ ⊥

full_name: Interval.bot_ne_zero
code: @[to_additive] lemma bot_ne_one : (⊥ : Interval α) ≠ 1 
goal: ⊥ ≠ 0

full_name: Interval.bot_ne_one
code: @[to_additive] lemma bot_ne_one : (⊥ : Interval α) ≠ 1 
goal: ⊥ ≠ 1

full_name: NonemptyInterval.coe_zero
code: @[to_additive (attr := simp)]
theorem coe_one : ((1 : NonemptyInterval α) : Set α) = 1 
goal: ↑0 = 0

full_name: NonemptyInterval.coe_one
code: @[to_additive (attr := simp)]
theorem coe_one : ((1 : NonemptyInterval α) : Set α) = 1 
goal: ↑1 = 1

full_name: NonemptyInterval.one_mem_one
code: @[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : NonemptyInterval α) 
goal: 1 ∈ 1

full_name: NonemptyInterval.zero_mem_zero
code: @[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : NonemptyInterval α) 
goal: 0 ∈ 0

full_name: Interval.coe_one
code: @[to_additive (attr := simp)]
theorem coe_one : ((1 : Interval α) : Set α) = 1 
goal: ↑1 = 1

full_name: Interval.coe_zero
code: @[to_additive (attr := simp)]
theorem coe_one : ((1 : Interval α) : Set α) = 1 
goal: ↑0 = 0

full_name: Interval.zero_mem_zero
code: @[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : Interval α) 
goal: 0 ∈ 0

full_name: Interval.one_mem_one
code: @[to_additive]
theorem one_mem_one : (1 : α) ∈ (1 : Interval α) 
goal: 1 ∈ 1

full_name: instAddNonemptyInterval
code: @[to_additive]
instance : Mul (NonemptyInterval α) 
goal: Add (NonemptyInterval α)

full_name: instMulNonemptyInterval
code: @[to_additive]
instance : Mul (NonemptyInterval α) 
goal: Mul (NonemptyInterval α)

full_name: instAddInterval
code: @[to_additive]
instance : Mul (Interval α) 
goal: Add (Interval α)

full_name: instMulInterval
code: @[to_additive]
instance : Mul (Interval α) 
goal: Mul (Interval α)

full_name: NonemptyInterval.toProd_mul
code: @[to_additive (attr := simp) toProd_add]
theorem toProd_mul : (s * t).toProd = s.toProd * t.toProd 
goal: (s * t).toProd = s.toProd * t.toProd

full_name: NonemptyInterval.toProd_add
code: @[to_additive (attr := simp) toProd_add]
theorem toProd_mul : (s * t).toProd = s.toProd * t.toProd 
goal: (s + t).toProd = s.toProd + t.toProd

full_name: NonemptyInterval.fst_add
code: @[to_additive]
theorem fst_mul : (s * t).fst = s.fst * t.fst 
goal: (s + t).toProd.1 = s.toProd.1 + t.toProd.1

full_name: NonemptyInterval.fst_mul
code: @[to_additive]
theorem fst_mul : (s * t).fst = s.fst * t.fst 
goal: (s * t).toProd.1 = s.toProd.1 * t.toProd.1

full_name: NonemptyInterval.snd_add
code: @[to_additive]
theorem snd_mul : (s * t).snd = s.snd * t.snd 
goal: (s + t).toProd.2 = s.toProd.2 + t.toProd.2

full_name: NonemptyInterval.snd_mul
code: @[to_additive]
theorem snd_mul : (s * t).snd = s.snd * t.snd 
goal: (s * t).toProd.2 = s.toProd.2 * t.toProd.2

full_name: NonemptyInterval.coe_mul_interval
code: @[to_additive (attr := simp)]
theorem coe_mul_interval : (↑(s * t) : Interval α) = s * t 
goal: ↑(s * t) = ↑s * ↑t

full_name: NonemptyInterval.coe_add_interval
code: @[to_additive (attr := simp)]
theorem coe_mul_interval : (↑(s * t) : Interval α) = s * t 
goal: ↑(s + t) = ↑s + ↑t

full_name: NonemptyInterval.pure_add_pure
code: @[to_additive (attr := simp)]
theorem pure_mul_pure : pure a * pure b = pure (a * b) 
goal: NonemptyInterval.pure a + NonemptyInterval.pure b = NonemptyInterval.pure (a + b)

full_name: NonemptyInterval.pure_mul_pure
code: @[to_additive (attr := simp)]
theorem pure_mul_pure : pure a * pure b = pure (a * b) 
goal: NonemptyInterval.pure a * NonemptyInterval.pure b = NonemptyInterval.pure (a * b)

full_name: Interval.bot_mul
code: @[to_additive (attr := simp)]
theorem bot_mul : ⊥ * t = ⊥ 
goal: ⊥ * t = ⊥

full_name: Interval.bot_add
code: @[to_additive (attr := simp)]
theorem bot_mul : ⊥ * t = ⊥ 
goal: ⊥ + t = ⊥

full_name: Interval.add_bot
code: @[to_additive]
theorem mul_bot : s * ⊥ = ⊥ 
goal: s + ⊥ = ⊥

full_name: Interval.mul_bot
code: @[to_additive]
theorem mul_bot : s * ⊥ = ⊥ 
goal: s * ⊥ = ⊥

full_name: NonemptyInterval.hasNSMul
code: instance NonemptyInterval.hasNSMul [AddMonoid α] [Preorder α] [CovariantClass α α (· + ·) (· ≤ ·)]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] : SMul ℕ (NonemptyInterval α) 
goal: SMul ℕ (NonemptyInterval α)

full_name: NonemptyInterval.hasPow
code: @[to_additive existing]
instance NonemptyInterval.hasPow
  [CovariantClass α α (· * ·) (· ≤ ·)] [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
  Pow (NonemptyInterval α) ℕ 
goal: Pow (NonemptyInterval α) ℕ

full_name: NonemptyInterval.toProd_pow
code: @[to_additive (attr := simp) toProd_nsmul]
theorem toProd_pow : (s ^ n).toProd = s.toProd ^ n 
goal: (s ^ n).toProd = s.toProd ^ n

full_name: NonemptyInterval.toProd_nsmul
code: @[to_additive (attr := simp) toProd_nsmul]
theorem toProd_pow : (s ^ n).toProd = s.toProd ^ n 
goal: (n • s).toProd = n • s.toProd

full_name: NonemptyInterval.fst_pow
code: @[to_additive]
theorem fst_pow : (s ^ n).fst = s.fst ^ n 
goal: (s ^ n).toProd.1 = s.toProd.1 ^ n

full_name: NonemptyInterval.fst_nsmul
code: @[to_additive]
theorem fst_pow : (s ^ n).fst = s.fst ^ n 
goal: (n • s).toProd.1 = n • s.toProd.1

full_name: NonemptyInterval.snd_pow
code: @[to_additive]
theorem snd_pow : (s ^ n).snd = s.snd ^ n 
goal: (s ^ n).toProd.2 = s.toProd.2 ^ n

full_name: NonemptyInterval.snd_nsmul
code: @[to_additive]
theorem snd_pow : (s ^ n).snd = s.snd ^ n 
goal: (n • s).toProd.2 = n • s.toProd.2

full_name: NonemptyInterval.pure_pow
code: @[to_additive (attr := simp)]
theorem pure_pow : pure a ^ n = pure (a ^ n) 
goal: NonemptyInterval.pure a ^ n = NonemptyInterval.pure (a ^ n)

full_name: NonemptyInterval.pure_nsmul
code: @[to_additive (attr := simp)]
theorem pure_pow : pure a ^ n = pure (a ^ n) 
goal: n • NonemptyInterval.pure a = NonemptyInterval.pure (n • a)

full_name: NonemptyInterval.commMonoid
code: @[to_additive]
instance commMonoid [OrderedCommMonoid α] : CommMonoid (NonemptyInterval α) 
goal: CommMonoid (NonemptyInterval α)

full_name: NonemptyInterval.addCommMonoid
code: @[to_additive]
instance commMonoid [OrderedCommMonoid α] : CommMonoid (NonemptyInterval α) 
goal: AddCommMonoid (NonemptyInterval α)

full_name: Interval.mulOneClass
code: @[to_additive]
instance Interval.mulOneClass [OrderedCommMonoid α] : MulOneClass (Interval α) 
goal: MulOneClass (Interval α)

full_name: Interval.addZeroClass
code: @[to_additive]
instance Interval.mulOneClass [OrderedCommMonoid α] : MulOneClass (Interval α) 
goal: AddZeroClass (Interval α)

full_name: Interval.commMonoid
code: @[to_additive]
instance Interval.commMonoid [OrderedCommMonoid α] : CommMonoid (Interval α) 
goal: CommMonoid (Interval α)

full_name: Interval.addCommMonoid
code: @[to_additive]
instance Interval.commMonoid [OrderedCommMonoid α] : CommMonoid (Interval α) 
goal: AddCommMonoid (Interval α)

full_name: NonemptyInterval.coe_nsmul_interval
code: @[to_additive]
theorem coe_pow_interval [OrderedCommMonoid α] (s : NonemptyInterval α) (n : ℕ) :
    ↑(s ^ n) = (s : Interval α) ^ n 
goal: ↑(n • s) = n • ↑s

full_name: NonemptyInterval.coe_pow_interval
code: @[to_additive]
theorem coe_pow_interval [OrderedCommMonoid α] (s : NonemptyInterval α) (n : ℕ) :
    ↑(s ^ n) = (s : Interval α) ^ n 
goal: ↑(s ^ n) = ↑s ^ n

full_name: Interval.bot_pow
code: @[to_additive]
theorem bot_pow : ∀ {n : ℕ}, n ≠ 0 → (⊥ : Interval α) ^ n = ⊥
  
goal: n ≠ 0 → ⊥ ^ n = ⊥

full_name: Interval.bot_nsmul
code: @[to_additive]
theorem bot_pow : ∀ {n : ℕ}, n ≠ 0 → (⊥ : Interval α) ^ n = ⊥
  
goal: n ≠ 0 → n • ⊥ = ⊥

full_name: instSubNonemptyInterval
code: instance : Sub (NonemptyInterval α) 
goal: Sub (NonemptyInterval α)

full_name: instSubInterval
code: instance : Sub (Interval α) 
goal: Sub (Interval α)

full_name: NonemptyInterval.fst_sub
code: @[simp]
theorem fst_sub : (s - t).fst = s.fst - t.snd 
goal: (s - t).toProd.1 = s.toProd.1 - t.toProd.2

full_name: NonemptyInterval.snd_sub
code: @[simp]
theorem snd_sub : (s - t).snd = s.snd - t.fst 
goal: (s - t).toProd.2 = s.toProd.2 - t.toProd.1

full_name: NonemptyInterval.coe_sub_interval
code: @[simp]
theorem coe_sub_interval : (↑(s - t) : Interval α) = s - t 
goal: ↑(s - t) = ↑s - ↑t

full_name: NonemptyInterval.sub_mem_sub
code: theorem sub_mem_sub (ha : a ∈ s) (hb : b ∈ t) : a - b ∈ s - t 
goal: a - b ∈ s - t

full_name: NonemptyInterval.pure_sub_pure
code: @[simp]
theorem pure_sub_pure (a b : α) : pure a - pure b = pure (a - b) 
goal: NonemptyInterval.pure a - NonemptyInterval.pure b = NonemptyInterval.pure (a - b)

full_name: Interval.bot_sub
code: @[simp]
theorem bot_sub : ⊥ - t = ⊥ 
goal: ⊥ - t = ⊥

full_name: Interval.sub_bot
code: @[simp]
theorem sub_bot : s - ⊥ = ⊥ 
goal: s - ⊥ = ⊥

full_name: instDivNonemptyInterval
code: @[to_additive existing]
instance : Div (NonemptyInterval α) 
goal: Div (NonemptyInterval α)

full_name: instDivInterval
code: @[to_additive existing]
instance : Div (Interval α) 
goal: Div (Interval α)

full_name: NonemptyInterval.fst_div
code: @[to_additive existing (attr := simp)]
theorem fst_div : (s / t).fst = s.fst / t.snd 
goal: (s / t).toProd.1 = s.toProd.1 / t.toProd.2

full_name: NonemptyInterval.snd_div
code: @[to_additive existing (attr := simp)]
theorem snd_div : (s / t).snd = s.snd / t.fst 
goal: (s / t).toProd.2 = s.toProd.2 / t.toProd.1

full_name: NonemptyInterval.coe_div_interval
code: @[to_additive existing (attr := simp)]
theorem coe_div_interval : (↑(s / t) : Interval α) = s / t 
goal: ↑(s / t) = ↑s / ↑t

full_name: NonemptyInterval.div_mem_div
code: @[to_additive existing]
theorem div_mem_div (ha : a ∈ s) (hb : b ∈ t) : a / b ∈ s / t 
goal: a / b ∈ s / t

full_name: NonemptyInterval.pure_div_pure
code: @[to_additive existing (attr := simp)]
theorem pure_div_pure : pure a / pure b = pure (a / b) 
goal: NonemptyInterval.pure a / NonemptyInterval.pure b = NonemptyInterval.pure (a / b)

full_name: Interval.bot_div
code: @[to_additive existing (attr := simp)]
theorem bot_div : ⊥ / t = ⊥ 
goal: ⊥ / t = ⊥

full_name: Interval.div_bot
code: @[to_additive existing (attr := simp)]
theorem div_bot : s / ⊥ = ⊥ 
goal: s / ⊥ = ⊥

full_name: instNegNonemptyInterval
code: @[to_additive]
instance : Inv (NonemptyInterval α) 
goal: Neg (NonemptyInterval α)

full_name: instInvNonemptyInterval
code: @[to_additive]
instance : Inv (NonemptyInterval α) 
goal: Inv (NonemptyInterval α)

full_name: instInvInterval
code: @[to_additive]
instance : Inv (Interval α) 
goal: Inv (Interval α)

full_name: instNegInterval
code: @[to_additive]
instance : Inv (Interval α) 
goal: Neg (Interval α)

full_name: NonemptyInterval.fst_inv
code: @[to_additive (attr := simp)]
theorem fst_inv : s⁻¹.fst = s.snd⁻¹ 
goal: s⁻¹.toProd.1 = s.toProd.2⁻¹

full_name: NonemptyInterval.fst_neg
code: @[to_additive (attr := simp)]
theorem fst_inv : s⁻¹.fst = s.snd⁻¹ 
goal: (-s).toProd.1 = -s.toProd.2

full_name: NonemptyInterval.snd_inv
code: @[to_additive (attr := simp)]
theorem snd_inv : s⁻¹.snd = s.fst⁻¹ 
goal: s⁻¹.toProd.2 = s.toProd.1⁻¹

full_name: NonemptyInterval.snd_neg
code: @[to_additive (attr := simp)]
theorem snd_inv : s⁻¹.snd = s.fst⁻¹ 
goal: (-s).toProd.2 = -s.toProd.1

full_name: NonemptyInterval.coe_neg_interval
code: @[to_additive (attr := simp)]
theorem coe_inv_interval : (↑(s⁻¹) : Interval α) = (↑s)⁻¹ 
goal: ↑(-s) = -↑s

full_name: NonemptyInterval.coe_inv_interval
code: @[to_additive (attr := simp)]
theorem coe_inv_interval : (↑(s⁻¹) : Interval α) = (↑s)⁻¹ 
goal: ↑s⁻¹ = (↑s)⁻¹

full_name: NonemptyInterval.inv_mem_inv
code: @[to_additive]
theorem inv_mem_inv (ha : a ∈ s) : a⁻¹ ∈ s⁻¹ 
goal: a⁻¹ ∈ s⁻¹

full_name: NonemptyInterval.neg_mem_neg
code: @[to_additive]
theorem inv_mem_inv (ha : a ∈ s) : a⁻¹ ∈ s⁻¹ 
goal: -a ∈ -s

full_name: NonemptyInterval.inv_pure
code: @[to_additive (attr := simp)]
theorem inv_pure : (pure a)⁻¹ = pure a⁻¹ 
goal: (NonemptyInterval.pure a)⁻¹ = NonemptyInterval.pure a⁻¹

full_name: NonemptyInterval.neg_pure
code: @[to_additive (attr := simp)]
theorem inv_pure : (pure a)⁻¹ = pure a⁻¹ 
goal: -NonemptyInterval.pure a = NonemptyInterval.pure (-a)

full_name: Interval.neg_bot
code: @[to_additive (attr := simp)]
theorem Interval.inv_bot : (⊥ : Interval α)⁻¹ = ⊥ 
goal: -⊥ = ⊥

full_name: Interval.inv_bot
code: @[to_additive (attr := simp)]
theorem Interval.inv_bot : (⊥ : Interval α)⁻¹ = ⊥ 
goal: ⊥⁻¹ = ⊥

full_name: NonemptyInterval.mul_eq_one_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1 
goal: s * t = 1 ↔ ∃ a b, s = NonemptyInterval.pure a ∧ t = NonemptyInterval.pure b ∧ a * b = 1

full_name: NonemptyInterval.add_eq_zero_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1 
goal: s + t = 0 ↔ ∃ a b, s = NonemptyInterval.pure a ∧ t = NonemptyInterval.pure b ∧ a + b = 0

full_name: NonemptyInterval.subtractionCommMonoid
code: instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (NonemptyInterval α) 
goal: SubtractionCommMonoid (NonemptyInterval α)

full_name: NonemptyInterval.divisionCommMonoid
code: @[to_additive existing NonemptyInterval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (NonemptyInterval α) 
goal: DivisionCommMonoid (NonemptyInterval α)

full_name: Interval.add_eq_zero_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1 
goal: s + t = 0 ↔ ∃ a b, s = Interval.pure a ∧ t = Interval.pure b ∧ a + b = 0

full_name: Interval.mul_eq_one_iff
code: @[to_additive]
protected theorem mul_eq_one_iff : s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1 
goal: s * t = 1 ↔ ∃ a b, s = Interval.pure a ∧ t = Interval.pure b ∧ a * b = 1

full_name: Interval.subtractionCommMonoid
code: instance subtractionCommMonoid {α : Type u} [OrderedAddCommGroup α] :
    SubtractionCommMonoid (Interval α) 
goal: SubtractionCommMonoid (Interval α)

full_name: Interval.divisionCommMonoid
code: @[to_additive existing Interval.subtractionCommMonoid]
instance divisionCommMonoid : DivisionCommMonoid (Interval α) 
goal: DivisionCommMonoid (Interval α)

full_name: NonemptyInterval.length
code: /-- The length of an interval is its first component minus its second component. This measures the
accuracy of the approximation by an interval. -/
def length : α 
goal: α

full_name: NonemptyInterval.length_nonneg
code: @[simp]
theorem length_nonneg : 0 ≤ s.length 
goal: 0 ≤ s.length

full_name: NonemptyInterval.length_pure
code: @[simp]
theorem length_pure : (pure a).length = 0 
goal: (NonemptyInterval.pure a).length = 0

full_name: NonemptyInterval.length_zero
code: @[simp]
theorem length_zero : (0 : NonemptyInterval α).length = 0 
goal: NonemptyInterval.length 0 = 0

full_name: NonemptyInterval.length_neg
code: @[simp]
theorem length_neg : (-s).length = s.length 
goal: (-s).length = s.length

full_name: NonemptyInterval.length_add
code: @[simp]
theorem length_add : (s + t).length = s.length + t.length 
goal: (s + t).length = s.length + t.length

full_name: NonemptyInterval.length_sub
code: @[simp]
theorem length_sub : (s - t).length = s.length + t.length 
goal: (s - t).length = s.length + t.length

full_name: NonemptyInterval.length_sum
code: @[simp]
theorem length_sum (f : ι → NonemptyInterval α) (s : Finset ι) :
    (∑ i ∈ s, f i).length = ∑ i ∈ s, (f i).length 
goal: (∑ i ∈ s, f i).length = ∑ i ∈ s, (f i).length

full_name: Interval.length
code: /-- The length of an interval is its first component minus its second component. This measures the
accuracy of the approximation by an interval. -/
def length : Interval α → α
  
goal: Interval α → α

full_name: Interval.length_nonneg
code: @[simp]
theorem length_nonneg : ∀ s : Interval α, 0 ≤ s.length
  
goal: 0 ≤ s.length

full_name: Interval.length_pure
code: @[simp]
theorem length_pure : (pure a).length = 0 
goal: (Interval.pure a).length = 0

full_name: Interval.length_zero
code: @[simp]
theorem length_zero : (0 : Interval α).length = 0 
goal: Interval.length 0 = 0

full_name: Interval.length_neg
code: @[simp]
theorem length_neg : ∀ s : Interval α, (-s).length = s.length
  
goal: (-s).length = s.length

full_name: Interval.length_add_le
code: theorem length_add_le : ∀ s t : Interval α, (s + t).length ≤ s.length + t.length
  
goal: (s + t).length ≤ s.length + t.length

full_name: Interval.length_sub_le
code: theorem length_sub_le : (s - t).length ≤ s.length + t.length 
goal: (s - t).length ≤ s.length + t.length

full_name: Interval.length_sum_le
code: theorem length_sum_le (f : ι → Interval α) (s : Finset ι) :
    (∑ i ∈ s, f i).length ≤ ∑ i ∈ s, (f i).length 
goal: (∑ i ∈ s, f i).length ≤ ∑ i ∈ s, (f i).length

full_name: Mathlib.Meta.Positivity.evalNonemptyIntervalLength
code: /-- Extension for the `positivity` tactic: The length of an interval is always nonnegative. -/
@[positivity NonemptyInterval.length _]
def evalNonemptyIntervalLength : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt

full_name: Mathlib.Meta.Positivity.evalIntervalLength
code: /-- Extension for the `positivity` tactic: The length of an interval is always nonnegative. -/
@[positivity Interval.length _]
def evalIntervalLength : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt