File: Mathlib/Algebra/Order/UpperLower.lean

full_name: IsUpperSet.smul_subset
code: @[to_additive]
theorem IsUpperSet.smul_subset (hs : IsUpperSet s) (hx : 1 ≤ x) : x • s ⊆ s 
goal: x • s ⊆ s

full_name: IsUpperSet.vadd_subset
code: @[to_additive]
theorem IsUpperSet.smul_subset (hs : IsUpperSet s) (hx : 1 ≤ x) : x • s ⊆ s 
goal: x +ᵥ s ⊆ s

full_name: IsLowerSet.smul_subset
code: @[to_additive]
theorem IsLowerSet.smul_subset (hs : IsLowerSet s) (hx : x ≤ 1) : x • s ⊆ s 
goal: x • s ⊆ s

full_name: IsLowerSet.vadd_subset
code: @[to_additive]
theorem IsLowerSet.smul_subset (hs : IsLowerSet s) (hx : x ≤ 1) : x • s ⊆ s 
goal: x +ᵥ s ⊆ s

full_name: IsUpperSet.vadd
code: @[to_additive]
theorem IsUpperSet.smul (hs : IsUpperSet s) : IsUpperSet (a • s) 
goal: IsUpperSet (a +ᵥ s)

full_name: IsUpperSet.smul
code: @[to_additive]
theorem IsUpperSet.smul (hs : IsUpperSet s) : IsUpperSet (a • s) 
goal: IsUpperSet (a • s)

full_name: IsLowerSet.smul
code: @[to_additive]
theorem IsLowerSet.smul (hs : IsLowerSet s) : IsLowerSet (a • s) 
goal: IsLowerSet (a • s)

full_name: IsLowerSet.vadd
code: @[to_additive]
theorem IsLowerSet.smul (hs : IsLowerSet s) : IsLowerSet (a • s) 
goal: IsLowerSet (a +ᵥ s)

full_name: Set.OrdConnected.vadd
code: @[to_additive]
theorem Set.OrdConnected.smul (hs : s.OrdConnected) : (a • s).OrdConnected 
goal: (a +ᵥ s).OrdConnected

full_name: Set.OrdConnected.smul
code: @[to_additive]
theorem Set.OrdConnected.smul (hs : s.OrdConnected) : (a • s).OrdConnected 
goal: (a • s).OrdConnected

full_name: IsUpperSet.add_left
code: @[to_additive]
theorem IsUpperSet.mul_left (ht : IsUpperSet t) : IsUpperSet (s * t) 
goal: IsUpperSet (s + t)

full_name: IsUpperSet.mul_left
code: @[to_additive]
theorem IsUpperSet.mul_left (ht : IsUpperSet t) : IsUpperSet (s * t) 
goal: IsUpperSet (s * t)

full_name: IsUpperSet.add_right
code: @[to_additive]
theorem IsUpperSet.mul_right (hs : IsUpperSet s) : IsUpperSet (s * t) 
goal: IsUpperSet (s + t)

full_name: IsUpperSet.mul_right
code: @[to_additive]
theorem IsUpperSet.mul_right (hs : IsUpperSet s) : IsUpperSet (s * t) 
goal: IsUpperSet (s * t)

full_name: IsLowerSet.add_left
code: @[to_additive]
theorem IsLowerSet.mul_left (ht : IsLowerSet t) : IsLowerSet (s * t) 
goal: IsLowerSet (s + t)

full_name: IsLowerSet.mul_left
code: @[to_additive]
theorem IsLowerSet.mul_left (ht : IsLowerSet t) : IsLowerSet (s * t) 
goal: IsLowerSet (s * t)

full_name: IsLowerSet.mul_right
code: @[to_additive]
theorem IsLowerSet.mul_right (hs : IsLowerSet s) : IsLowerSet (s * t) 
goal: IsLowerSet (s * t)

full_name: IsLowerSet.add_right
code: @[to_additive]
theorem IsLowerSet.mul_right (hs : IsLowerSet s) : IsLowerSet (s * t) 
goal: IsLowerSet (s + t)

full_name: IsUpperSet.inv
code: @[to_additive]
theorem IsUpperSet.inv (hs : IsUpperSet s) : IsLowerSet s⁻¹ 
goal: IsLowerSet s⁻¹

full_name: IsUpperSet.neg
code: @[to_additive]
theorem IsUpperSet.inv (hs : IsUpperSet s) : IsLowerSet s⁻¹ 
goal: IsLowerSet (-s)

full_name: IsLowerSet.neg
code: @[to_additive]
theorem IsLowerSet.inv (hs : IsLowerSet s) : IsUpperSet s⁻¹ 
goal: IsUpperSet (-s)

full_name: IsLowerSet.inv
code: @[to_additive]
theorem IsLowerSet.inv (hs : IsLowerSet s) : IsUpperSet s⁻¹ 
goal: IsUpperSet s⁻¹

full_name: IsUpperSet.div_left
code: @[to_additive]
theorem IsUpperSet.div_left (ht : IsUpperSet t) : IsLowerSet (s / t) 
goal: IsLowerSet (s / t)

full_name: IsUpperSet.sub_left
code: @[to_additive]
theorem IsUpperSet.div_left (ht : IsUpperSet t) : IsLowerSet (s / t) 
goal: IsLowerSet (s - t)

full_name: IsUpperSet.div_right
code: @[to_additive]
theorem IsUpperSet.div_right (hs : IsUpperSet s) : IsUpperSet (s / t) 
goal: IsUpperSet (s / t)

full_name: IsUpperSet.sub_right
code: @[to_additive]
theorem IsUpperSet.div_right (hs : IsUpperSet s) : IsUpperSet (s / t) 
goal: IsUpperSet (s - t)

full_name: IsLowerSet.div_left
code: @[to_additive]
theorem IsLowerSet.div_left (ht : IsLowerSet t) : IsUpperSet (s / t) 
goal: IsUpperSet (s / t)

full_name: IsLowerSet.sub_left
code: @[to_additive]
theorem IsLowerSet.div_left (ht : IsLowerSet t) : IsUpperSet (s / t) 
goal: IsUpperSet (s - t)

full_name: IsLowerSet.sub_right
code: @[to_additive]
theorem IsLowerSet.div_right (hs : IsLowerSet s) : IsLowerSet (s / t) 
goal: IsLowerSet (s - t)

full_name: IsLowerSet.div_right
code: @[to_additive]
theorem IsLowerSet.div_right (hs : IsLowerSet s) : IsLowerSet (s / t) 
goal: IsLowerSet (s / t)

full_name: UpperSet.instZero
code: @[to_additive]
instance : One (UpperSet α) 
goal: Zero (UpperSet α)

full_name: UpperSet.instOne
code: @[to_additive]
instance : One (UpperSet α) 
goal: One (UpperSet α)

full_name: UpperSet.instMul
code: @[to_additive]
instance : Mul (UpperSet α) 
goal: Mul (UpperSet α)

full_name: UpperSet.instAdd
code: @[to_additive]
instance : Mul (UpperSet α) 
goal: Add (UpperSet α)

full_name: UpperSet.instDiv
code: @[to_additive]
instance : Div (UpperSet α) 
goal: Div (UpperSet α)

full_name: UpperSet.instSub
code: @[to_additive]
instance : Div (UpperSet α) 
goal: Sub (UpperSet α)

full_name: UpperSet.instSMul
code: @[to_additive]
instance : SMul α (UpperSet α) 
goal: SMul α (UpperSet α)

full_name: UpperSet.instVAdd
code: @[to_additive]
instance : SMul α (UpperSet α) 
goal: VAdd α (UpperSet α)

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

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

full_name: UpperSet.coe_mul
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_mul (s t : UpperSet α) : (↑(s * t) : Set α) = s * t 
goal: ↑(s * t) = ↑s * ↑t

full_name: UpperSet.coe_add
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_mul (s t : UpperSet α) : (↑(s * t) : Set α) = s * t 
goal: ↑(s + t) = ↑s + ↑t

full_name: UpperSet.coe_div
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_div (s t : UpperSet α) : (↑(s / t) : Set α) = s / t 
goal: ↑(s / t) = ↑s / ↑t

full_name: UpperSet.coe_sub
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_div (s t : UpperSet α) : (↑(s / t) : Set α) = s / t 
goal: ↑(s - t) = ↑s - ↑t

full_name: UpperSet.Ici_one
code: @[to_additive (attr := simp)]
theorem Ici_one : Ici (1 : α) = 1 
goal: UpperSet.Ici 1 = 1

full_name: UpperSet.Ici_zero
code: @[to_additive (attr := simp)]
theorem Ici_one : Ici (1 : α) = 1 
goal: UpperSet.Ici 0 = 0

full_name: UpperSet.instAddAction
code: @[to_additive]
instance : MulAction α (UpperSet α) 
goal: AddAction α (UpperSet α)

full_name: UpperSet.instMulAction
code: @[to_additive]
instance : MulAction α (UpperSet α) 
goal: MulAction α (UpperSet α)

full_name: UpperSet.addCommSemigroup
code: @[to_additive]
instance commSemigroup : CommSemigroup (UpperSet α) 
goal: AddCommSemigroup (UpperSet α)

full_name: UpperSet.commSemigroup
code: @[to_additive]
instance commSemigroup : CommSemigroup (UpperSet α) 
goal: CommSemigroup (UpperSet α)

full_name: _private.Mathlib.Algebra.Order.UpperLower.0.UpperSet.zero_add
code: @[to_additive]
private theorem one_mul (s : UpperSet α) : 1 * s = s 
goal: 0 + s = s

full_name: _private.Mathlib.Algebra.Order.UpperLower.0.UpperSet.one_mul
code: @[to_additive]
private theorem one_mul (s : UpperSet α) : 1 * s = s 
goal: 1 * s = s

full_name: UpperSet.instCommMonoid
code: @[to_additive]
instance : CommMonoid (UpperSet α) 
goal: CommMonoid (UpperSet α)

full_name: UpperSet.instAddCommMonoid
code: @[to_additive]
instance : CommMonoid (UpperSet α) 
goal: AddCommMonoid (UpperSet α)

full_name: LowerSet.instZero
code: @[to_additive]
instance : One (LowerSet α) 
goal: Zero (LowerSet α)

full_name: LowerSet.instOne
code: @[to_additive]
instance : One (LowerSet α) 
goal: One (LowerSet α)

full_name: LowerSet.instMul
code: @[to_additive]
instance : Mul (LowerSet α) 
goal: Mul (LowerSet α)

full_name: LowerSet.instAdd
code: @[to_additive]
instance : Mul (LowerSet α) 
goal: Add (LowerSet α)

full_name: LowerSet.instDiv
code: @[to_additive]
instance : Div (LowerSet α) 
goal: Div (LowerSet α)

full_name: LowerSet.instSub
code: @[to_additive]
instance : Div (LowerSet α) 
goal: Sub (LowerSet α)

full_name: LowerSet.instVAdd
code: @[to_additive]
instance : SMul α (LowerSet α) 
goal: VAdd α (LowerSet α)

full_name: LowerSet.instSMul
code: @[to_additive]
instance : SMul α (LowerSet α) 
goal: SMul α (LowerSet α)

full_name: LowerSet.coe_mul
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_mul (s t : LowerSet α) : (↑(s * t) : Set α) = s * t 
goal: ↑(s * t) = ↑s * ↑t

full_name: LowerSet.coe_add
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_mul (s t : LowerSet α) : (↑(s * t) : Set α) = s * t 
goal: ↑(s + t) = ↑s + ↑t

full_name: LowerSet.coe_sub
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_div (s t : LowerSet α) : (↑(s / t) : Set α) = s / t 
goal: ↑(s - t) = ↑s - ↑t

full_name: LowerSet.coe_div
code: @[to_additive (attr := simp,norm_cast)]
theorem coe_div (s t : LowerSet α) : (↑(s / t) : Set α) = s / t 
goal: ↑(s / t) = ↑s / ↑t

full_name: LowerSet.Iic_zero
code: @[to_additive (attr := simp)]
theorem Iic_one : Iic (1 : α) = 1 
goal: LowerSet.Iic 0 = 0

full_name: LowerSet.Iic_one
code: @[to_additive (attr := simp)]
theorem Iic_one : Iic (1 : α) = 1 
goal: LowerSet.Iic 1 = 1

full_name: LowerSet.instMulAction
code: @[to_additive]
instance : MulAction α (LowerSet α) 
goal: MulAction α (LowerSet α)

full_name: LowerSet.instAddAction
code: @[to_additive]
instance : MulAction α (LowerSet α) 
goal: AddAction α (LowerSet α)

full_name: LowerSet.commSemigroup
code: @[to_additive]
instance commSemigroup : CommSemigroup (LowerSet α) 
goal: CommSemigroup (LowerSet α)

full_name: LowerSet.addCommSemigroup
code: @[to_additive]
instance commSemigroup : CommSemigroup (LowerSet α) 
goal: AddCommSemigroup (LowerSet α)

full_name: _private.Mathlib.Algebra.Order.UpperLower.0.LowerSet.one_mul
code: @[to_additive]
private theorem one_mul (s : LowerSet α) : 1 * s = s 
goal: 1 * s = s

full_name: _private.Mathlib.Algebra.Order.UpperLower.0.LowerSet.zero_add
code: @[to_additive]
private theorem one_mul (s : LowerSet α) : 1 * s = s 
goal: 0 + s = s

full_name: LowerSet.instAddCommMonoid
code: @[to_additive]
instance : CommMonoid (LowerSet α) 
goal: AddCommMonoid (LowerSet α)

full_name: LowerSet.instCommMonoid
code: @[to_additive]
instance : CommMonoid (LowerSet α) 
goal: CommMonoid (LowerSet α)

full_name: upperClosure_one
code: @[to_additive (attr := simp)]
theorem upperClosure_one : upperClosure (1 : Set α) = 1 
goal: upperClosure 1 = 1

full_name: upperClosure_zero
code: @[to_additive (attr := simp)]
theorem upperClosure_one : upperClosure (1 : Set α) = 1 
goal: upperClosure 0 = 0

full_name: lowerClosure_one
code: @[to_additive (attr := simp)]
theorem lowerClosure_one : lowerClosure (1 : Set α) = 1 
goal: lowerClosure 1 = 1

full_name: lowerClosure_zero
code: @[to_additive (attr := simp)]
theorem lowerClosure_one : lowerClosure (1 : Set α) = 1 
goal: lowerClosure 0 = 0

full_name: upperClosure_vadd
code: @[to_additive (attr := simp)]
theorem upperClosure_smul : upperClosure (a • s) = a • upperClosure s 
goal: upperClosure (a +ᵥ s) = a +ᵥ upperClosure s

full_name: upperClosure_smul
code: @[to_additive (attr := simp)]
theorem upperClosure_smul : upperClosure (a • s) = a • upperClosure s 
goal: upperClosure (a • s) = a • upperClosure s

full_name: lowerClosure_smul
code: @[to_additive (attr := simp)]
theorem lowerClosure_smul : lowerClosure (a • s) = a • lowerClosure s 
goal: lowerClosure (a • s) = a • lowerClosure s

full_name: lowerClosure_vadd
code: @[to_additive (attr := simp)]
theorem lowerClosure_smul : lowerClosure (a • s) = a • lowerClosure s 
goal: lowerClosure (a +ᵥ s) = a +ᵥ lowerClosure s

full_name: mul_upperClosure
code: @[to_additive]
theorem mul_upperClosure : s * upperClosure t = upperClosure (s * t) 
goal: s * ↑(upperClosure t) = ↑(upperClosure (s * t))

full_name: add_upperClosure
code: @[to_additive]
theorem mul_upperClosure : s * upperClosure t = upperClosure (s * t) 
goal: s + ↑(upperClosure t) = ↑(upperClosure (s + t))

full_name: add_lowerClosure
code: @[to_additive]
theorem mul_lowerClosure : s * lowerClosure t = lowerClosure (s * t) 
goal: s + ↑(lowerClosure t) = ↑(lowerClosure (s + t))

full_name: mul_lowerClosure
code: @[to_additive]
theorem mul_lowerClosure : s * lowerClosure t = lowerClosure (s * t) 
goal: s * ↑(lowerClosure t) = ↑(lowerClosure (s * t))

full_name: upperClosure_add
code: @[to_additive]
theorem upperClosure_mul : ↑(upperClosure s) * t = upperClosure (s * t) 
goal: ↑(upperClosure s) + t = ↑(upperClosure (s + t))

full_name: upperClosure_mul
code: @[to_additive]
theorem upperClosure_mul : ↑(upperClosure s) * t = upperClosure (s * t) 
goal: ↑(upperClosure s) * t = ↑(upperClosure (s * t))

full_name: lowerClosure_add
code: @[to_additive]
theorem lowerClosure_mul : ↑(lowerClosure s) * t = lowerClosure (s * t) 
goal: ↑(lowerClosure s) + t = ↑(lowerClosure (s + t))

full_name: lowerClosure_mul
code: @[to_additive]
theorem lowerClosure_mul : ↑(lowerClosure s) * t = lowerClosure (s * t) 
goal: ↑(lowerClosure s) * t = ↑(lowerClosure (s * t))

full_name: upperClosure_mul_distrib
code: @[to_additive (attr := simp)]
theorem upperClosure_mul_distrib : upperClosure (s * t) = upperClosure s * upperClosure t 
goal: upperClosure (s * t) = upperClosure s * upperClosure t

full_name: upperClosure_add_distrib
code: @[to_additive (attr := simp)]
theorem upperClosure_mul_distrib : upperClosure (s * t) = upperClosure s * upperClosure t 
goal: upperClosure (s + t) = upperClosure s + upperClosure t

full_name: lowerClosure_mul_distrib
code: @[to_additive (attr := simp)]
theorem lowerClosure_mul_distrib : lowerClosure (s * t) = lowerClosure s * lowerClosure t 
goal: lowerClosure (s * t) = lowerClosure s * lowerClosure t

full_name: lowerClosure_add_distrib
code: @[to_additive (attr := simp)]
theorem lowerClosure_mul_distrib : lowerClosure (s * t) = lowerClosure s * lowerClosure t 
goal: lowerClosure (s + t) = lowerClosure s + lowerClosure t