File: Mathlib/Algebra/Bounds.lean

full_name: bddAbove_inv
code: @[to_additive (attr := simp)]
theorem bddAbove_inv : BddAbove s⁻¹ ↔ BddBelow s 
goal: BddAbove s⁻¹ ↔ BddBelow s

full_name: bddAbove_neg
code: @[to_additive (attr := simp)]
theorem bddAbove_inv : BddAbove s⁻¹ ↔ BddBelow s 
goal: BddAbove (-s) ↔ BddBelow s

full_name: bddBelow_inv
code: @[to_additive (attr := simp)]
theorem bddBelow_inv : BddBelow s⁻¹ ↔ BddAbove s 
goal: BddBelow s⁻¹ ↔ BddAbove s

full_name: bddBelow_neg
code: @[to_additive (attr := simp)]
theorem bddBelow_inv : BddBelow s⁻¹ ↔ BddAbove s 
goal: BddBelow (-s) ↔ BddAbove s

full_name: BddAbove.neg
code: @[to_additive]
theorem BddAbove.inv (h : BddAbove s) : BddBelow s⁻¹ 
goal: BddBelow (-s)

full_name: BddAbove.inv
code: @[to_additive]
theorem BddAbove.inv (h : BddAbove s) : BddBelow s⁻¹ 
goal: BddBelow s⁻¹

full_name: BddBelow.neg
code: @[to_additive]
theorem BddBelow.inv (h : BddBelow s) : BddAbove s⁻¹ 
goal: BddAbove (-s)

full_name: BddBelow.inv
code: @[to_additive]
theorem BddBelow.inv (h : BddBelow s) : BddAbove s⁻¹ 
goal: BddAbove s⁻¹

full_name: isLUB_neg
code: @[to_additive (attr := simp)]
theorem isLUB_inv : IsLUB s⁻¹ a ↔ IsGLB s a⁻¹ 
goal: IsLUB (-s) a ↔ IsGLB s (-a)

full_name: isLUB_inv
code: @[to_additive (attr := simp)]
theorem isLUB_inv : IsLUB s⁻¹ a ↔ IsGLB s a⁻¹ 
goal: IsLUB s⁻¹ a ↔ IsGLB s a⁻¹

full_name: isLUB_neg'
code: @[to_additive]
theorem isLUB_inv' : IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a 
goal: IsLUB (-s) (-a) ↔ IsGLB s a

full_name: isLUB_inv'
code: @[to_additive]
theorem isLUB_inv' : IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a 
goal: IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a

full_name: IsGLB.inv
code: @[to_additive]
theorem IsGLB.inv (h : IsGLB s a) : IsLUB s⁻¹ a⁻¹ 
goal: IsLUB s⁻¹ a⁻¹

full_name: IsGLB.neg
code: @[to_additive]
theorem IsGLB.inv (h : IsGLB s a) : IsLUB s⁻¹ a⁻¹ 
goal: IsLUB (-s) (-a)

full_name: isGLB_neg
code: @[to_additive (attr := simp)]
theorem isGLB_inv : IsGLB s⁻¹ a ↔ IsLUB s a⁻¹ 
goal: IsGLB (-s) a ↔ IsLUB s (-a)

full_name: isGLB_inv
code: @[to_additive (attr := simp)]
theorem isGLB_inv : IsGLB s⁻¹ a ↔ IsLUB s a⁻¹ 
goal: IsGLB s⁻¹ a ↔ IsLUB s a⁻¹

full_name: isGLB_neg'
code: @[to_additive]
theorem isGLB_inv' : IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a 
goal: IsGLB (-s) (-a) ↔ IsLUB s a

full_name: isGLB_inv'
code: @[to_additive]
theorem isGLB_inv' : IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a 
goal: IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a

full_name: IsLUB.inv
code: @[to_additive]
theorem IsLUB.inv (h : IsLUB s a) : IsGLB s⁻¹ a⁻¹ 
goal: IsGLB s⁻¹ a⁻¹

full_name: IsLUB.neg
code: @[to_additive]
theorem IsLUB.inv (h : IsLUB s a) : IsGLB s⁻¹ a⁻¹ 
goal: IsGLB (-s) (-a)

full_name: BddBelow.range_neg
code: @[to_additive]
lemma BddBelow.range_inv {α : Type*} {f : α → G} (hf : BddBelow (range f)) :
    BddAbove (range (fun x => (f x)⁻¹)) 
goal: BddAbove (Set.range fun x => -f x)

full_name: BddBelow.range_inv
code: @[to_additive]
lemma BddBelow.range_inv {α : Type*} {f : α → G} (hf : BddBelow (range f)) :
    BddAbove (range (fun x => (f x)⁻¹)) 
goal: BddAbove (Set.range fun x => (f x)⁻¹)

full_name: BddAbove.range_inv
code: @[to_additive]
lemma BddAbove.range_inv {α : Type*} {f : α → G} (hf : BddAbove (range f)) :
    BddBelow (range (fun x => (f x)⁻¹)) 
goal: BddBelow (Set.range fun x => (f x)⁻¹)

full_name: BddAbove.range_neg
code: @[to_additive]
lemma BddAbove.range_inv {α : Type*} {f : α → G} (hf : BddAbove (range f)) :
    BddBelow (range (fun x => (f x)⁻¹)) 
goal: BddBelow (Set.range fun x => -f x)

full_name: mul_mem_upperBounds_mul
code: @[to_additive]
theorem mul_mem_upperBounds_mul {s t : Set M} {a b : M} (ha : a ∈ upperBounds s)
    (hb : b ∈ upperBounds t) : a * b ∈ upperBounds (s * t) 
goal: a * b ∈ upperBounds (s * t)

full_name: add_mem_upperBounds_add
code: @[to_additive]
theorem mul_mem_upperBounds_mul {s t : Set M} {a b : M} (ha : a ∈ upperBounds s)
    (hb : b ∈ upperBounds t) : a * b ∈ upperBounds (s * t) 
goal: a + b ∈ upperBounds (s + t)

full_name: subset_upperBounds_mul
code: @[to_additive]
theorem subset_upperBounds_mul (s t : Set M) :
    upperBounds s * upperBounds t ⊆ upperBounds (s * t) 
goal: upperBounds s * upperBounds t ⊆ upperBounds (s * t)

full_name: subset_upperBounds_add
code: @[to_additive]
theorem subset_upperBounds_mul (s t : Set M) :
    upperBounds s * upperBounds t ⊆ upperBounds (s * t) 
goal: upperBounds s + upperBounds t ⊆ upperBounds (s + t)

full_name: mul_mem_lowerBounds_mul
code: @[to_additive]
theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds s)
    (hb : b ∈ lowerBounds t) : a * b ∈ lowerBounds (s * t) 
goal: a * b ∈ lowerBounds (s * t)

full_name: add_mem_lowerBounds_add
code: @[to_additive]
theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds s)
    (hb : b ∈ lowerBounds t) : a * b ∈ lowerBounds (s * t) 
goal: a + b ∈ lowerBounds (s + t)

full_name: subset_lowerBounds_mul
code: @[to_additive]
theorem subset_lowerBounds_mul (s t : Set M) :
    lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t) 
goal: lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t)

full_name: subset_lowerBounds_add
code: @[to_additive]
theorem subset_lowerBounds_mul (s t : Set M) :
    lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t) 
goal: lowerBounds s + lowerBounds t ⊆ lowerBounds (s + t)

full_name: BddAbove.add
code: @[to_additive]
theorem BddAbove.mul {s t : Set M} (hs : BddAbove s) (ht : BddAbove t) : BddAbove (s * t) 
goal: BddAbove (s + t)

full_name: BddAbove.mul
code: @[to_additive]
theorem BddAbove.mul {s t : Set M} (hs : BddAbove s) (ht : BddAbove t) : BddAbove (s * t) 
goal: BddAbove (s * t)

full_name: BddBelow.add
code: @[to_additive]
theorem BddBelow.mul {s t : Set M} (hs : BddBelow s) (ht : BddBelow t) : BddBelow (s * t) 
goal: BddBelow (s + t)

full_name: BddBelow.mul
code: @[to_additive]
theorem BddBelow.mul {s t : Set M} (hs : BddBelow s) (ht : BddBelow t) : BddBelow (s * t) 
goal: BddBelow (s * t)

full_name: BddAbove.range_mul
code: @[to_additive]
lemma BddAbove.range_mul {α : Type*} {f g : α → M} (hf : BddAbove (range f))
    (hg : BddAbove (range g)) : BddAbove (range (fun x => f x * g x)) 
goal: BddAbove (Set.range fun x => f x * g x)

full_name: BddAbove.range_add
code: @[to_additive]
lemma BddAbove.range_mul {α : Type*} {f g : α → M} (hf : BddAbove (range f))
    (hg : BddAbove (range g)) : BddAbove (range (fun x => f x * g x)) 
goal: BddAbove (Set.range fun x => f x + g x)

full_name: BddBelow.range_mul
code: @[to_additive]
lemma BddBelow.range_mul {α : Type*} {f g : α → M} (hf : BddBelow (range f))
    (hg : BddBelow (range g)) : BddBelow (range (fun x => f x * g x)) 
goal: BddBelow (Set.range fun x => f x * g x)

full_name: BddBelow.range_add
code: @[to_additive]
lemma BddBelow.range_mul {α : Type*} {f g : α → M} (hf : BddBelow (range f))
    (hg : BddBelow (range g)) : BddBelow (range (fun x => f x * g x)) 
goal: BddBelow (Set.range fun x => f x + g x)

full_name: ciSup_mul
code: @[to_additive]
theorem ciSup_mul (hf : BddAbove (range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a 
goal: (⨆ i, f i) * a = ⨆ i, f i * a

full_name: ciSup_add
code: @[to_additive]
theorem ciSup_mul (hf : BddAbove (range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a 
goal: (⨆ i, f i) + a = ⨆ i, f i + a

full_name: ciSup_div
code: @[to_additive]
theorem ciSup_div (hf : BddAbove (range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a 
goal: (⨆ i, f i) / a = ⨆ i, f i / a

full_name: ciSup_sub
code: @[to_additive]
theorem ciSup_div (hf : BddAbove (range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a 
goal: (⨆ i, f i) - a = ⨆ i, f i - a

full_name: ciInf_add
code: @[to_additive]
theorem ciInf_mul (hf : BddBelow (range f)) (a : G) : (⨅ i, f i) * a = ⨅ i, f i * a 
goal: (⨅ i, f i) + a = ⨅ i, f i + a

full_name: ciInf_mul
code: @[to_additive]
theorem ciInf_mul (hf : BddBelow (range f)) (a : G) : (⨅ i, f i) * a = ⨅ i, f i * a 
goal: (⨅ i, f i) * a = ⨅ i, f i * a

full_name: ciInf_div
code: @[to_additive]
theorem ciInf_div (hf : BddBelow (range f)) (a : G) : (⨅ i, f i) / a = ⨅ i, f i / a 
goal: (⨅ i, f i) / a = ⨅ i, f i / a

full_name: ciInf_sub
code: @[to_additive]
theorem ciInf_div (hf : BddBelow (range f)) (a : G) : (⨅ i, f i) / a = ⨅ i, f i / a 
goal: (⨅ i, f i) - a = ⨅ i, f i - a

full_name: mul_ciSup
code: @[to_additive]
theorem mul_ciSup (hf : BddAbove (range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i 
goal: a * ⨆ i, f i = ⨆ i, a * f i

full_name: add_ciSup
code: @[to_additive]
theorem mul_ciSup (hf : BddAbove (range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i 
goal: a + ⨆ i, f i = ⨆ i, a + f i

full_name: mul_ciInf
code: @[to_additive]
theorem mul_ciInf (hf : BddBelow (range f)) (a : G) : (a * ⨅ i, f i) = ⨅ i, a * f i 
goal: a * ⨅ i, f i = ⨅ i, a * f i

full_name: add_ciInf
code: @[to_additive]
theorem mul_ciInf (hf : BddBelow (range f)) (a : G) : (a * ⨅ i, f i) = ⨅ i, a * f i 
goal: a + ⨅ i, f i = ⨅ i, a + f i