File: Mathlib/Order/Disjoint.lean

full_name: Disjoint
code: /-- Two elements of a lattice are disjoint if their inf is the bottom element.
  (This generalizes disjoint sets, viewed as members of the subset lattice.)

Note that we define this without reference to `⊓`, as this allows us to talk about orders where
the infimum is not unique, or where implementing `Inf` would require additional `Decidable`
arguments. -/
def Disjoint (a b : α) : Prop 
goal: Prop

full_name: disjoint_of_subsingleton
code: @[simp]
theorem disjoint_of_subsingleton [Subsingleton α] : Disjoint a b 
goal: Disjoint a b

full_name: disjoint_comm
code: theorem disjoint_comm : Disjoint a b ↔ Disjoint b a 
goal: Disjoint a b ↔ Disjoint b a

full_name: Disjoint.symm
code: @[symm]
theorem Disjoint.symm ⦃a b : α⦄ : Disjoint a b → Disjoint b a 
goal: Disjoint a b → Disjoint b a

full_name: symmetric_disjoint
code: theorem symmetric_disjoint : Symmetric (Disjoint : α → α → Prop) 
goal: Symmetric Disjoint

full_name: disjoint_bot_left
code: @[simp]
theorem disjoint_bot_left : Disjoint ⊥ a 
goal: Disjoint ⊥ a

full_name: disjoint_bot_right
code: @[simp]
theorem disjoint_bot_right : Disjoint a ⊥ 
goal: Disjoint a ⊥

full_name: Disjoint.mono
code: theorem Disjoint.mono (h₁ : a ≤ b) (h₂ : c ≤ d) : Disjoint b d → Disjoint a c 
goal: Disjoint b d → Disjoint a c

full_name: Disjoint.mono_left
code: theorem Disjoint.mono_left (h : a ≤ b) : Disjoint b c → Disjoint a c 
goal: Disjoint b c → Disjoint a c

full_name: Disjoint.mono_right
code: theorem Disjoint.mono_right : b ≤ c → Disjoint a c → Disjoint a b 
goal: b ≤ c → Disjoint a c → Disjoint a b

full_name: disjoint_self
code: @[simp]
theorem disjoint_self : Disjoint a a ↔ a = ⊥ 
goal: Disjoint a a ↔ a = ⊥

full_name: Disjoint.ne
code: theorem Disjoint.ne (ha : a ≠ ⊥) (hab : Disjoint a b) : a ≠ b 
goal: a ≠ b

full_name: Disjoint.eq_bot_of_le
code: theorem Disjoint.eq_bot_of_le (hab : Disjoint a b) (h : a ≤ b) : a = ⊥ 
goal: a = ⊥

full_name: Disjoint.eq_bot_of_ge
code: theorem Disjoint.eq_bot_of_ge (hab : Disjoint a b) : b ≤ a → b = ⊥ 
goal: b ≤ a → b = ⊥

full_name: Disjoint.eq_iff
code: lemma Disjoint.eq_iff (hab : Disjoint a b) : a = b ↔ a = ⊥ ∧ b = ⊥ 
goal: a = b ↔ a = ⊥ ∧ b = ⊥

full_name: Disjoint.ne_iff
code: lemma Disjoint.ne_iff (hab : Disjoint a b) : a ≠ b ↔ a ≠ ⊥ ∨ b ≠ ⊥ 
goal: a ≠ b ↔ a ≠ ⊥ ∨ b ≠ ⊥

full_name: disjoint_top
code: @[simp]
theorem disjoint_top : Disjoint a ⊤ ↔ a = ⊥ 
goal: Disjoint a ⊤ ↔ a = ⊥

full_name: top_disjoint
code: @[simp]
theorem top_disjoint : Disjoint ⊤ a ↔ a = ⊥ 
goal: Disjoint ⊤ a ↔ a = ⊥

full_name: disjoint_iff_inf_le
code: theorem disjoint_iff_inf_le : Disjoint a b ↔ a ⊓ b ≤ ⊥ 
goal: Disjoint a b ↔ a ⊓ b ≤ ⊥

full_name: disjoint_iff
code: theorem disjoint_iff : Disjoint a b ↔ a ⊓ b = ⊥ 
goal: Disjoint a b ↔ a ⊓ b = ⊥

full_name: Disjoint.le_bot
code: theorem Disjoint.le_bot : Disjoint a b → a ⊓ b ≤ ⊥ 
goal: Disjoint a b → a ⊓ b ≤ ⊥

full_name: Disjoint.eq_bot
code: theorem Disjoint.eq_bot : Disjoint a b → a ⊓ b = ⊥ 
goal: Disjoint a b → a ⊓ b = ⊥

full_name: disjoint_assoc
code: theorem disjoint_assoc : Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c) 
goal: Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c)

full_name: disjoint_left_comm
code: theorem disjoint_left_comm : Disjoint a (b ⊓ c) ↔ Disjoint b (a ⊓ c) 
goal: Disjoint a (b ⊓ c) ↔ Disjoint b (a ⊓ c)

full_name: disjoint_right_comm
code: theorem disjoint_right_comm : Disjoint (a ⊓ b) c ↔ Disjoint (a ⊓ c) b 
goal: Disjoint (a ⊓ b) c ↔ Disjoint (a ⊓ c) b

full_name: Disjoint.inf_left
code: theorem Disjoint.inf_left (h : Disjoint a b) : Disjoint (a ⊓ c) b 
goal: Disjoint (a ⊓ c) b

full_name: Disjoint.inf_left'
code: theorem Disjoint.inf_left' (h : Disjoint a b) : Disjoint (c ⊓ a) b 
goal: Disjoint (c ⊓ a) b

full_name: Disjoint.inf_right
code: theorem Disjoint.inf_right (h : Disjoint a b) : Disjoint a (b ⊓ c) 
goal: Disjoint a (b ⊓ c)

full_name: Disjoint.inf_right'
code: theorem Disjoint.inf_right' (h : Disjoint a b) : Disjoint a (c ⊓ b) 
goal: Disjoint a (c ⊓ b)

full_name: Disjoint.of_disjoint_inf_of_le
code: theorem Disjoint.of_disjoint_inf_of_le (h : Disjoint (a ⊓ b) c) (hle : a ≤ c) : Disjoint a b 
goal: Disjoint a b

full_name: Disjoint.of_disjoint_inf_of_le'
code: theorem Disjoint.of_disjoint_inf_of_le' (h : Disjoint (a ⊓ b) c) (hle : b ≤ c) : Disjoint a b 
goal: Disjoint a b

full_name: disjoint_sup_left
code: @[simp]
theorem disjoint_sup_left : Disjoint (a ⊔ b) c ↔ Disjoint a c ∧ Disjoint b c 
goal: Disjoint (a ⊔ b) c ↔ Disjoint a c ∧ Disjoint b c

full_name: disjoint_sup_right
code: @[simp]
theorem disjoint_sup_right : Disjoint a (b ⊔ c) ↔ Disjoint a b ∧ Disjoint a c 
goal: Disjoint a (b ⊔ c) ↔ Disjoint a b ∧ Disjoint a c

full_name: Disjoint.sup_left
code: theorem Disjoint.sup_left (ha : Disjoint a c) (hb : Disjoint b c) : Disjoint (a ⊔ b) c 
goal: Disjoint (a ⊔ b) c

full_name: Disjoint.sup_right
code: theorem Disjoint.sup_right (hb : Disjoint a b) (hc : Disjoint a c) : Disjoint a (b ⊔ c) 
goal: Disjoint a (b ⊔ c)

full_name: Disjoint.left_le_of_le_sup_right
code: theorem Disjoint.left_le_of_le_sup_right (h : a ≤ b ⊔ c) (hd : Disjoint a c) : a ≤ b 
goal: a ≤ b

full_name: Disjoint.left_le_of_le_sup_left
code: theorem Disjoint.left_le_of_le_sup_left (h : a ≤ c ⊔ b) (hd : Disjoint a c) : a ≤ b 
goal: a ≤ b

full_name: Codisjoint
code: /-- Two elements of a lattice are codisjoint if their sup is the top element.

Note that we define this without reference to `⊔`, as this allows us to talk about orders where
the supremum is not unique, or where implement `Sup` would require additional `Decidable`
arguments. -/
def Codisjoint (a b : α) : Prop 
goal: Prop

full_name: Codisjoint_comm
code: theorem Codisjoint_comm : Codisjoint a b ↔ Codisjoint b a 
goal: Codisjoint a b ↔ Codisjoint b a

full_name: Codisjoint.symm
code: @[symm]
theorem Codisjoint.symm ⦃a b : α⦄ : Codisjoint a b → Codisjoint b a 
goal: Codisjoint a b → Codisjoint b a

full_name: symmetric_codisjoint
code: theorem symmetric_codisjoint : Symmetric (Codisjoint : α → α → Prop) 
goal: Symmetric Codisjoint

full_name: codisjoint_top_left
code: @[simp]
theorem codisjoint_top_left : Codisjoint ⊤ a 
goal: Codisjoint ⊤ a

full_name: codisjoint_top_right
code: @[simp]
theorem codisjoint_top_right : Codisjoint a ⊤ 
goal: Codisjoint a ⊤

full_name: Codisjoint.mono
code: theorem Codisjoint.mono (h₁ : a ≤ b) (h₂ : c ≤ d) : Codisjoint a c → Codisjoint b d 
goal: Codisjoint a c → Codisjoint b d

full_name: Codisjoint.mono_left
code: theorem Codisjoint.mono_left (h : a ≤ b) : Codisjoint a c → Codisjoint b c 
goal: Codisjoint a c → Codisjoint b c

full_name: Codisjoint.mono_right
code: theorem Codisjoint.mono_right : b ≤ c → Codisjoint a b → Codisjoint a c 
goal: b ≤ c → Codisjoint a b → Codisjoint a c

full_name: codisjoint_self
code: @[simp]
theorem codisjoint_self : Codisjoint a a ↔ a = ⊤ 
goal: Codisjoint a a ↔ a = ⊤

full_name: Codisjoint.ne
code: theorem Codisjoint.ne (ha : a ≠ ⊤) (hab : Codisjoint a b) : a ≠ b 
goal: a ≠ b

full_name: Codisjoint.eq_top_of_le
code: theorem Codisjoint.eq_top_of_le (hab : Codisjoint a b) (h : b ≤ a) : a = ⊤ 
goal: a = ⊤

full_name: Codisjoint.eq_top_of_ge
code: theorem Codisjoint.eq_top_of_ge (hab : Codisjoint a b) : a ≤ b → b = ⊤ 
goal: a ≤ b → b = ⊤

full_name: Codisjoint.eq_iff
code: lemma Codisjoint.eq_iff (hab : Codisjoint a b) : a = b ↔ a = ⊤ ∧ b = ⊤ 
goal: a = b ↔ a = ⊤ ∧ b = ⊤

full_name: Codisjoint.ne_iff
code: lemma Codisjoint.ne_iff (hab : Codisjoint a b) : a ≠ b ↔ a ≠ ⊤ ∨ b ≠ ⊤ 
goal: a ≠ b ↔ a ≠ ⊤ ∨ b ≠ ⊤

full_name: codisjoint_bot
code: @[simp]
theorem codisjoint_bot : Codisjoint a ⊥ ↔ a = ⊤ 
goal: Codisjoint a ⊥ ↔ a = ⊤

full_name: bot_codisjoint
code: @[simp]
theorem bot_codisjoint : Codisjoint ⊥ a ↔ a = ⊤ 
goal: Codisjoint ⊥ a ↔ a = ⊤

full_name: Codisjoint.ne_bot_of_ne_top
code: lemma Codisjoint.ne_bot_of_ne_top (h : Codisjoint a b) (ha : a ≠ ⊤) : b ≠ ⊥ 
goal: b ≠ ⊥

full_name: Codisjoint.ne_bot_of_ne_top'
code: lemma Codisjoint.ne_bot_of_ne_top' (h : Codisjoint a b) (hb : b ≠ ⊤) : a ≠ ⊥ 
goal: a ≠ ⊥

full_name: codisjoint_iff_le_sup
code: theorem codisjoint_iff_le_sup : Codisjoint a b ↔ ⊤ ≤ a ⊔ b 
goal: Codisjoint a b ↔ ⊤ ≤ a ⊔ b

full_name: codisjoint_iff
code: theorem codisjoint_iff : Codisjoint a b ↔ a ⊔ b = ⊤ 
goal: Codisjoint a b ↔ a ⊔ b = ⊤

full_name: Codisjoint.top_le
code: theorem Codisjoint.top_le : Codisjoint a b → ⊤ ≤ a ⊔ b 
goal: Codisjoint a b → ⊤ ≤ a ⊔ b

full_name: Codisjoint.eq_top
code: theorem Codisjoint.eq_top : Codisjoint a b → a ⊔ b = ⊤ 
goal: Codisjoint a b → a ⊔ b = ⊤

full_name: codisjoint_assoc
code: theorem codisjoint_assoc : Codisjoint (a ⊔ b) c ↔ Codisjoint a (b ⊔ c) 
goal: Codisjoint (a ⊔ b) c ↔ Codisjoint a (b ⊔ c)

full_name: codisjoint_left_comm
code: theorem codisjoint_left_comm : Codisjoint a (b ⊔ c) ↔ Codisjoint b (a ⊔ c) 
goal: Codisjoint a (b ⊔ c) ↔ Codisjoint b (a ⊔ c)

full_name: codisjoint_right_comm
code: theorem codisjoint_right_comm : Codisjoint (a ⊔ b) c ↔ Codisjoint (a ⊔ c) b 
goal: Codisjoint (a ⊔ b) c ↔ Codisjoint (a ⊔ c) b

full_name: Codisjoint.sup_left
code: theorem Codisjoint.sup_left (h : Codisjoint a b) : Codisjoint (a ⊔ c) b 
goal: Codisjoint (a ⊔ c) b

full_name: Codisjoint.sup_left'
code: theorem Codisjoint.sup_left' (h : Codisjoint a b) : Codisjoint (c ⊔ a) b 
goal: Codisjoint (c ⊔ a) b

full_name: Codisjoint.sup_right
code: theorem Codisjoint.sup_right (h : Codisjoint a b) : Codisjoint a (b ⊔ c) 
goal: Codisjoint a (b ⊔ c)

full_name: Codisjoint.sup_right'
code: theorem Codisjoint.sup_right' (h : Codisjoint a b) : Codisjoint a (c ⊔ b) 
goal: Codisjoint a (c ⊔ b)

full_name: Codisjoint.of_codisjoint_sup_of_le
code: theorem Codisjoint.of_codisjoint_sup_of_le (h : Codisjoint (a ⊔ b) c) (hle : c ≤ a) :
    Codisjoint a b 
goal: Codisjoint a b

full_name: Codisjoint.of_codisjoint_sup_of_le'
code: theorem Codisjoint.of_codisjoint_sup_of_le' (h : Codisjoint (a ⊔ b) c) (hle : c ≤ b) :
    Codisjoint a b 
goal: Codisjoint a b

full_name: codisjoint_inf_left
code: @[simp]
theorem codisjoint_inf_left : Codisjoint (a ⊓ b) c ↔ Codisjoint a c ∧ Codisjoint b c 
goal: Codisjoint (a ⊓ b) c ↔ Codisjoint a c ∧ Codisjoint b c

full_name: codisjoint_inf_right
code: @[simp]
theorem codisjoint_inf_right : Codisjoint a (b ⊓ c) ↔ Codisjoint a b ∧ Codisjoint a c 
goal: Codisjoint a (b ⊓ c) ↔ Codisjoint a b ∧ Codisjoint a c

full_name: Codisjoint.inf_left
code: theorem Codisjoint.inf_left (ha : Codisjoint a c) (hb : Codisjoint b c) : Codisjoint (a ⊓ b) c 
goal: Codisjoint (a ⊓ b) c

full_name: Codisjoint.inf_right
code: theorem Codisjoint.inf_right (hb : Codisjoint a b) (hc : Codisjoint a c) : Codisjoint a (b ⊓ c) 
goal: Codisjoint a (b ⊓ c)

full_name: Codisjoint.left_le_of_le_inf_right
code: theorem Codisjoint.left_le_of_le_inf_right (h : a ⊓ b ≤ c) (hd : Codisjoint b c) : a ≤ c 
goal: a ≤ c

full_name: Codisjoint.left_le_of_le_inf_left
code: theorem Codisjoint.left_le_of_le_inf_left (h : b ⊓ a ≤ c) (hd : Codisjoint b c) : a ≤ c 
goal: a ≤ c

full_name: Disjoint.dual
code: theorem Disjoint.dual [SemilatticeInf α] [OrderBot α] {a b : α} :
    Disjoint a b → Codisjoint (toDual a) (toDual b) 
goal: Disjoint a b → Codisjoint (OrderDual.toDual a) (OrderDual.toDual b)

full_name: Codisjoint.dual
code: theorem Codisjoint.dual [SemilatticeSup α] [OrderTop α] {a b : α} :
    Codisjoint a b → Disjoint (toDual a) (toDual b) 
goal: Codisjoint a b → Disjoint (OrderDual.toDual a) (OrderDual.toDual b)

full_name: disjoint_toDual_iff
code: @[simp]
theorem disjoint_toDual_iff [SemilatticeSup α] [OrderTop α] {a b : α} :
    Disjoint (toDual a) (toDual b) ↔ Codisjoint a b 
goal: Disjoint (OrderDual.toDual a) (OrderDual.toDual b) ↔ Codisjoint a b

full_name: disjoint_ofDual_iff
code: @[simp]
theorem disjoint_ofDual_iff [SemilatticeInf α] [OrderBot α] {a b : αᵒᵈ} :
    Disjoint (ofDual a) (ofDual b) ↔ Codisjoint a b 
goal: Disjoint (OrderDual.ofDual a) (OrderDual.ofDual b) ↔ Codisjoint a b

full_name: codisjoint_toDual_iff
code: @[simp]
theorem codisjoint_toDual_iff [SemilatticeInf α] [OrderBot α] {a b : α} :
    Codisjoint (toDual a) (toDual b) ↔ Disjoint a b 
goal: Codisjoint (OrderDual.toDual a) (OrderDual.toDual b) ↔ Disjoint a b

full_name: codisjoint_ofDual_iff
code: @[simp]
theorem codisjoint_ofDual_iff [SemilatticeSup α] [OrderTop α] {a b : αᵒᵈ} :
    Codisjoint (ofDual a) (ofDual b) ↔ Disjoint a b 
goal: Codisjoint (OrderDual.ofDual a) (OrderDual.ofDual b) ↔ Disjoint a b

full_name: Disjoint.le_of_codisjoint
code: theorem Disjoint.le_of_codisjoint (hab : Disjoint a b) (hbc : Codisjoint b c) : a ≤ c 
goal: a ≤ c

full_name: IsCompl
code: /-- Two elements `x` and `y` are complements of each other if `x ⊔ y = ⊤` and `x ⊓ y = ⊥`. -/
structure IsCompl [PartialOrder α] [BoundedOrder α] (x y : α) : Prop where
  /-- If `x` and `y` are to be complementary in an order, they should be disjoint. -/
  protected disjoint : Disjoint x y
  /-- If `x` and `y` are to be complementary in an order, they should be codisjoint. -/
  protected codisjoint : Codisjoint x y
goal: Prop

full_name: IsCompl.codisjoint
code: /-- Two elements `x` and `y` are complements of each other if `x ⊔ y = ⊤` and `x ⊓ y = ⊥`. -/
structure IsCompl [PartialOrder α] [BoundedOrder α] (x y : α) : Prop where
  /-- If `x` and `y` are to be complementary in an order, they should be disjoint. -/
  protected disjoint : Disjoint x y
  /-- If `x` and `y` are to be complementary in an order, they should be codisjoint. -/
  protected codisjoint : Codisjoint x y
goal: Codisjoint x y

full_name: IsCompl.disjoint
code: /-- Two elements `x` and `y` are complements of each other if `x ⊔ y = ⊤` and `x ⊓ y = ⊥`. -/
structure IsCompl [PartialOrder α] [BoundedOrder α] (x y : α) : Prop where
  /-- If `x` and `y` are to be complementary in an order, they should be disjoint. -/
  protected disjoint : Disjoint x y
  /-- If `x` and `y` are to be complementary in an order, they should be codisjoint. -/
  protected codisjoint : Codisjoint x y
goal: Disjoint x y

full_name: isCompl_iff
code: theorem isCompl_iff [PartialOrder α] [BoundedOrder α] {a b : α} :
    IsCompl a b ↔ Disjoint a b ∧ Codisjoint a b 
goal: IsCompl a b ↔ Disjoint a b ∧ Codisjoint a b

full_name: IsCompl.symm
code: @[symm]
protected theorem symm (h : IsCompl x y) : IsCompl y x 
goal: IsCompl y x

full_name: isCompl_comm
code: lemma _root_.isCompl_comm : IsCompl x y ↔ IsCompl y x 
goal: IsCompl x y ↔ IsCompl y x

full_name: IsCompl.dual
code: theorem dual (h : IsCompl x y) : IsCompl (toDual x) (toDual y) 
goal: IsCompl (OrderDual.toDual x) (OrderDual.toDual y)

full_name: IsCompl.ofDual
code: theorem ofDual {a b : αᵒᵈ} (h : IsCompl a b) : IsCompl (ofDual a) (ofDual b) 
goal: IsCompl (OrderDual.ofDual a) (OrderDual.ofDual b)

full_name: IsCompl.of_le
code: theorem of_le (h₁ : x ⊓ y ≤ ⊥) (h₂ : ⊤ ≤ x ⊔ y) : IsCompl x y 
goal: IsCompl x y

full_name: IsCompl.of_eq
code: theorem of_eq (h₁ : x ⊓ y = ⊥) (h₂ : x ⊔ y = ⊤) : IsCompl x y 
goal: IsCompl x y

full_name: IsCompl.inf_eq_bot
code: theorem inf_eq_bot (h : IsCompl x y) : x ⊓ y = ⊥ 
goal: x ⊓ y = ⊥

full_name: IsCompl.sup_eq_top
code: theorem sup_eq_top (h : IsCompl x y) : x ⊔ y = ⊤ 
goal: x ⊔ y = ⊤

full_name: IsCompl.inf_left_le_of_le_sup_right
code: theorem inf_left_le_of_le_sup_right (h : IsCompl x y) (hle : a ≤ b ⊔ y) : a ⊓ x ≤ b 
goal: a ⊓ x ≤ b

full_name: IsCompl.le_sup_right_iff_inf_left_le
code: theorem le_sup_right_iff_inf_left_le {a b} (h : IsCompl x y) : a ≤ b ⊔ y ↔ a ⊓ x ≤ b 
goal: a ≤ b ⊔ y ↔ a ⊓ x ≤ b

full_name: IsCompl.inf_left_eq_bot_iff
code: theorem inf_left_eq_bot_iff (h : IsCompl y z) : x ⊓ y = ⊥ ↔ x ≤ z 
goal: x ⊓ y = ⊥ ↔ x ≤ z

full_name: IsCompl.inf_right_eq_bot_iff
code: theorem inf_right_eq_bot_iff (h : IsCompl y z) : x ⊓ z = ⊥ ↔ x ≤ y 
goal: x ⊓ z = ⊥ ↔ x ≤ y

full_name: IsCompl.disjoint_left_iff
code: theorem disjoint_left_iff (h : IsCompl y z) : Disjoint x y ↔ x ≤ z 
goal: Disjoint x y ↔ x ≤ z

full_name: IsCompl.disjoint_right_iff
code: theorem disjoint_right_iff (h : IsCompl y z) : Disjoint x z ↔ x ≤ y 
goal: Disjoint x z ↔ x ≤ y

full_name: IsCompl.le_left_iff
code: theorem le_left_iff (h : IsCompl x y) : z ≤ x ↔ Disjoint z y 
goal: z ≤ x ↔ Disjoint z y

full_name: IsCompl.le_right_iff
code: theorem le_right_iff (h : IsCompl x y) : z ≤ y ↔ Disjoint z x 
goal: z ≤ y ↔ Disjoint z x

full_name: IsCompl.left_le_iff
code: theorem left_le_iff (h : IsCompl x y) : x ≤ z ↔ Codisjoint z y 
goal: x ≤ z ↔ Codisjoint z y

full_name: IsCompl.right_le_iff
code: theorem right_le_iff (h : IsCompl x y) : y ≤ z ↔ Codisjoint z x 
goal: y ≤ z ↔ Codisjoint z x

full_name: IsCompl.Antitone
code: protected theorem Antitone {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') (hx : x ≤ x') : y' ≤ y 
goal: y' ≤ y

full_name: IsCompl.right_unique
code: theorem right_unique (hxy : IsCompl x y) (hxz : IsCompl x z) : y = z 
goal: y = z

full_name: IsCompl.left_unique
code: theorem left_unique (hxz : IsCompl x z) (hyz : IsCompl y z) : x = y 
goal: x = y

full_name: IsCompl.sup_inf
code: theorem sup_inf {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') : IsCompl (x ⊔ x') (y ⊓ y') 
goal: IsCompl (x ⊔ x') (y ⊓ y')

full_name: IsCompl.inf_sup
code: theorem inf_sup {x' y'} (h : IsCompl x y) (h' : IsCompl x' y') : IsCompl (x ⊓ x') (y ⊔ y') 
goal: IsCompl (x ⊓ x') (y ⊔ y')

full_name: Prod.disjoint_iff
code: protected theorem disjoint_iff [OrderBot α] [OrderBot β] {x y : α × β} :
    Disjoint x y ↔ Disjoint x.1 y.1 ∧ Disjoint x.2 y.2 
goal: Disjoint x y ↔ Disjoint x.1 y.1 ∧ Disjoint x.2 y.2

full_name: Prod.codisjoint_iff
code: protected theorem codisjoint_iff [OrderTop α] [OrderTop β] {x y : α × β} :
    Codisjoint x y ↔ Codisjoint x.1 y.1 ∧ Codisjoint x.2 y.2 
goal: Codisjoint x y ↔ Codisjoint x.1 y.1 ∧ Codisjoint x.2 y.2

full_name: Prod.isCompl_iff
code: protected theorem isCompl_iff [BoundedOrder α] [BoundedOrder β] {x y : α × β} :
    IsCompl x y ↔ IsCompl x.1 y.1 ∧ IsCompl x.2 y.2 
goal: IsCompl x y ↔ IsCompl x.1 y.1 ∧ IsCompl x.2 y.2

full_name: isCompl_toDual_iff
code: @[simp]
theorem isCompl_toDual_iff : IsCompl (toDual a) (toDual b) ↔ IsCompl a b 
goal: IsCompl (OrderDual.toDual a) (OrderDual.toDual b) ↔ IsCompl a b

full_name: isCompl_ofDual_iff
code: @[simp]
theorem isCompl_ofDual_iff {a b : αᵒᵈ} : IsCompl (ofDual a) (ofDual b) ↔ IsCompl a b 
goal: IsCompl (OrderDual.ofDual a) (OrderDual.ofDual b) ↔ IsCompl a b

full_name: isCompl_bot_top
code: theorem isCompl_bot_top : IsCompl (⊥ : α) ⊤ 
goal: IsCompl ⊥ ⊤

full_name: isCompl_top_bot
code: theorem isCompl_top_bot : IsCompl (⊤ : α) ⊥ 
goal: IsCompl ⊤ ⊥

full_name: eq_top_of_isCompl_bot
code: theorem eq_top_of_isCompl_bot (h : IsCompl x ⊥) : x = ⊤ 
goal: x = ⊤

full_name: eq_top_of_bot_isCompl
code: theorem eq_top_of_bot_isCompl (h : IsCompl ⊥ x) : x = ⊤ 
goal: x = ⊤

full_name: eq_bot_of_isCompl_top
code: theorem eq_bot_of_isCompl_top (h : IsCompl x ⊤) : x = ⊥ 
goal: x = ⊥

full_name: eq_bot_of_top_isCompl
code: theorem eq_bot_of_top_isCompl (h : IsCompl ⊤ x) : x = ⊥ 
goal: x = ⊥

full_name: IsComplemented
code: /-- An element is *complemented* if it has a complement. -/
def IsComplemented (a : α) : Prop 
goal: Prop

full_name: isComplemented_bot
code: theorem isComplemented_bot : IsComplemented (⊥ : α) 
goal: IsComplemented ⊥

full_name: isComplemented_top
code: theorem isComplemented_top : IsComplemented (⊤ : α) 
goal: IsComplemented ⊤

full_name: IsComplemented.sup
code: theorem IsComplemented.sup : IsComplemented a → IsComplemented b → IsComplemented (a ⊔ b) 
goal: IsComplemented a → IsComplemented b → IsComplemented (a ⊔ b)

full_name: IsComplemented.inf
code: theorem IsComplemented.inf : IsComplemented a → IsComplemented b → IsComplemented (a ⊓ b) 
goal: IsComplemented a → IsComplemented b → IsComplemented (a ⊓ b)

full_name: ComplementedLattice.exists_isCompl
code: /-- A complemented bounded lattice is one where every element has a (not necessarily unique)
complement. -/
class ComplementedLattice (α) [Lattice α] [BoundedOrder α] : Prop where
  /-- In a `ComplementedLattice`, every element admits a complement. -/
  exists_isCompl : ∀ a : α, ∃ b : α, IsCompl a b
goal: ∃ b, IsCompl a b

full_name: ComplementedLattice
code: /-- A complemented bounded lattice is one where every element has a (not necessarily unique)
complement. -/
class ComplementedLattice (α) [Lattice α] [BoundedOrder α] : Prop where
  /-- In a `ComplementedLattice`, every element admits a complement. -/
  exists_isCompl : ∀ a : α, ∃ b : α, IsCompl a b
goal: Prop

full_name: Subsingleton.instComplementedLattice
code: instance Subsingleton.instComplementedLattice
    [Lattice α] [BoundedOrder α] [Subsingleton α] : ComplementedLattice α 
goal: ComplementedLattice α

full_name: ComplementedLattice.instOrderDual
code: instance : ComplementedLattice αᵒᵈ 
goal: ComplementedLattice αᵒᵈ

full_name: Complementeds
code: /-- The sublattice of complemented elements. -/
abbrev Complementeds (α : Type*) [Lattice α] [BoundedOrder α] : Type _ 
goal: Type u_2

full_name: Complementeds.hasCoeT
code: instance hasCoeT : CoeTC (Complementeds α) α 
goal: CoeTC (Complementeds α) α

full_name: Complementeds.coe_injective
code: theorem coe_injective : Injective ((↑) : Complementeds α → α) 
goal: Function.Injective Subtype.val

full_name: Complementeds.coe_inj
code: @[simp, norm_cast]
theorem coe_inj : (a : α) = b ↔ a = b 
goal: ↑a = ↑b ↔ a = b

full_name: Complementeds.coe_le_coe
code: @[norm_cast]
theorem coe_le_coe : (a : α) ≤ b ↔ a ≤ b 
goal: ↑a ≤ ↑b ↔ a ≤ b

full_name: Complementeds.coe_lt_coe
code: @[norm_cast]
theorem coe_lt_coe : (a : α) < b ↔ a < b 
goal: ↑a < ↑b ↔ a < b

full_name: Complementeds.instBoundedOrder
code: instance : BoundedOrder (Complementeds α) 
goal: BoundedOrder (Complementeds α)

full_name: Complementeds.coe_bot
code: @[simp, norm_cast]
theorem coe_bot : ((⊥ : Complementeds α) : α) = ⊥ 
goal: ↑⊥ = ⊥

full_name: Complementeds.coe_top
code: @[simp, norm_cast]
theorem coe_top : ((⊤ : Complementeds α) : α) = ⊤ 
goal: ↑⊤ = ⊤

full_name: Complementeds.mk_bot
code: theorem mk_bot : (⟨⊥, isComplemented_bot⟩ : Complementeds α) = ⊥ 
goal: ⟨⊥, ⋯⟩ = ⊥

full_name: Complementeds.mk_top
code: theorem mk_top : (⟨⊤, isComplemented_top⟩ : Complementeds α) = ⊤ 
goal: ⟨⊤, ⋯⟩ = ⊤

full_name: Complementeds.instInhabited
code: instance : Inhabited (Complementeds α) 
goal: Inhabited (Complementeds α)

full_name: Complementeds.instSup
code: instance : Sup (Complementeds α) 
goal: Sup (Complementeds α)

full_name: Complementeds.instInf
code: instance : Inf (Complementeds α) 
goal: Inf (Complementeds α)

full_name: Complementeds.coe_sup
code: @[simp, norm_cast]
theorem coe_sup (a b : Complementeds α) : ↑(a ⊔ b) = (a : α) ⊔ b 
goal: ↑(a ⊔ b) = ↑a ⊔ ↑b

full_name: Complementeds.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (a b : Complementeds α) : ↑(a ⊓ b) = (a : α) ⊓ b 
goal: ↑(a ⊓ b) = ↑a ⊓ ↑b

full_name: Complementeds.mk_sup_mk
code: @[simp]
theorem mk_sup_mk {a b : α} (ha : IsComplemented a) (hb : IsComplemented b) :
    (⟨a, ha⟩ ⊔ ⟨b, hb⟩ : Complementeds α) = ⟨a ⊔ b, ha.sup hb⟩ 
goal: ⟨a, ha⟩ ⊔ ⟨b, hb⟩ = ⟨a ⊔ b, ⋯⟩

full_name: Complementeds.mk_inf_mk
code: @[simp]
theorem mk_inf_mk {a b : α} (ha : IsComplemented a) (hb : IsComplemented b) :
    (⟨a, ha⟩ ⊓ ⟨b, hb⟩ : Complementeds α) = ⟨a ⊓ b, ha.inf hb⟩ 
goal: ⟨a, ha⟩ ⊓ ⟨b, hb⟩ = ⟨a ⊓ b, ⋯⟩

full_name: Complementeds.instDistribLattice
code: instance : DistribLattice (Complementeds α) 
goal: DistribLattice (Complementeds α)

full_name: Complementeds.disjoint_coe
code: @[simp, norm_cast]
theorem disjoint_coe : Disjoint (a : α) b ↔ Disjoint a b 
goal: Disjoint ↑a ↑b ↔ Disjoint a b

full_name: Complementeds.codisjoint_coe
code: @[simp, norm_cast]
theorem codisjoint_coe : Codisjoint (a : α) b ↔ Codisjoint a b 
goal: Codisjoint ↑a ↑b ↔ Codisjoint a b

full_name: Complementeds.isCompl_coe
code: @[simp, norm_cast]
theorem isCompl_coe : IsCompl (a : α) b ↔ IsCompl a b 
goal: IsCompl ↑a ↑b ↔ IsCompl a b

full_name: Complementeds.instComplementedLattice
code: instance : ComplementedLattice (Complementeds α) 
goal: ComplementedLattice (Complementeds α)