File: Mathlib/Order/Booleanisation.lean

full_name: Booleanisation
code: /-- Boolean algebra containing a given generalised Boolean algebra `α` as a sublattice.

This should be thought of as made of a copy of `α` (representing elements of `α`) living under
another copy of `α` (representing complements of elements of `α`). -/
def Booleanisation (α : Type*) 
goal: Type u_2

full_name: Booleanisation.instDecidableEq
code: instance instDecidableEq [DecidableEq α] : DecidableEq (Booleanisation α) 
goal: DecidableEq (Booleanisation α)

full_name: Booleanisation.lift
code: /-- The natural inclusion `a ↦ a` from a generalized Boolean algebra to its generated Boolean
algebra. -/
@[match_pattern] def lift : α → Booleanisation α 
goal: α → Booleanisation α

full_name: Booleanisation.comp
code: /-- The inclusion `a ↦ aᶜ from a generalized Boolean algebra to its generated Boolean algebra. -/
@[match_pattern] def comp : α → Booleanisation α 
goal: α → Booleanisation α

full_name: Booleanisation.instCompl
code: /-- The complement operator on `Booleanisation α` sends `a` to `aᶜ` and `aᶜ` to `a`, for `a : α`. -/
instance instCompl : HasCompl (Booleanisation α) 
goal: HasCompl (Booleanisation α)

full_name: Booleanisation.compl_lift
code: @[simp] lemma compl_lift (a : α) : (lift a)ᶜ = comp a 
goal: (Booleanisation.lift a)ᶜ = Booleanisation.comp a

full_name: Booleanisation.compl_comp
code: @[simp] lemma compl_comp (a : α) : (comp a)ᶜ = lift a 
goal: (Booleanisation.comp a)ᶜ = Booleanisation.lift a

full_name: Booleanisation.LE.lift
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a ≤ b` iff `a ≤ b` in `α`
* `a ≤ bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ ≤ bᶜ` iff `b ≤ a` in `α`
* `¬ aᶜ ≤ b` -/
protected inductive LE : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a ≤ b → Booleanisation.LE (lift a) (lift b)
  | protected comp {a b} : a ≤ b → Booleanisation.LE (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LE (lift a) (comp b)
goal: a ≤ b → (Booleanisation.lift a).LE (Booleanisation.lift b)

full_name: Booleanisation.LE
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a ≤ b` iff `a ≤ b` in `α`
* `a ≤ bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ ≤ bᶜ` iff `b ≤ a` in `α`
* `¬ aᶜ ≤ b` -/
protected inductive LE : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a ≤ b → Booleanisation.LE (lift a) (lift b)
  | protected comp {a b} : a ≤ b → Booleanisation.LE (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LE (lift a) (comp b)
goal: Booleanisation α → Booleanisation α → Prop

full_name: Booleanisation.LE.comp
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a ≤ b` iff `a ≤ b` in `α`
* `a ≤ bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ ≤ bᶜ` iff `b ≤ a` in `α`
* `¬ aᶜ ≤ b` -/
protected inductive LE : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a ≤ b → Booleanisation.LE (lift a) (lift b)
  | protected comp {a b} : a ≤ b → Booleanisation.LE (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LE (lift a) (comp b)
goal: a ≤ b → (Booleanisation.comp b).LE (Booleanisation.comp a)

full_name: Booleanisation.LE.sep
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a ≤ b` iff `a ≤ b` in `α`
* `a ≤ bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ ≤ bᶜ` iff `b ≤ a` in `α`
* `¬ aᶜ ≤ b` -/
protected inductive LE : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a ≤ b → Booleanisation.LE (lift a) (lift b)
  | protected comp {a b} : a ≤ b → Booleanisation.LE (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LE (lift a) (comp b)
goal: Disjoint a b → (Booleanisation.lift a).LE (Booleanisation.comp b)

full_name: Booleanisation.LT.lift
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a < b` iff `a < b` in `α`
* `a < bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ < bᶜ` iff `b < a` in `α`
* `¬ aᶜ < b` -/
protected inductive LT : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a < b → Booleanisation.LT (lift a) (lift b)
  | protected comp {a b} : a < b → Booleanisation.LT (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LT (lift a) (comp b)
goal: a < b → (Booleanisation.lift a).LT (Booleanisation.lift b)

full_name: Booleanisation.LT
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a < b` iff `a < b` in `α`
* `a < bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ < bᶜ` iff `b < a` in `α`
* `¬ aᶜ < b` -/
protected inductive LT : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a < b → Booleanisation.LT (lift a) (lift b)
  | protected comp {a b} : a < b → Booleanisation.LT (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LT (lift a) (comp b)
goal: Booleanisation α → Booleanisation α → Prop

full_name: Booleanisation.LT.comp
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a < b` iff `a < b` in `α`
* `a < bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ < bᶜ` iff `b < a` in `α`
* `¬ aᶜ < b` -/
protected inductive LT : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a < b → Booleanisation.LT (lift a) (lift b)
  | protected comp {a b} : a < b → Booleanisation.LT (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LT (lift a) (comp b)
goal: a < b → (Booleanisation.comp b).LT (Booleanisation.comp a)

full_name: Booleanisation.LT.sep
code: /-- The order on `Booleanisation α` is as follows: For `a b : α`,
* `a < b` iff `a < b` in `α`
* `a < bᶜ` iff `a` and `b` are disjoint in `α`
* `aᶜ < bᶜ` iff `b < a` in `α`
* `¬ aᶜ < b` -/
protected inductive LT : Booleanisation α → Booleanisation α → Prop
  | protected lift {a b} : a < b → Booleanisation.LT (lift a) (lift b)
  | protected comp {a b} : a < b → Booleanisation.LT (comp b) (comp a)
  | protected sep {a b} : Disjoint a b → Booleanisation.LT (lift a) (comp b)
goal: Disjoint a b → (Booleanisation.lift a).LT (Booleanisation.comp b)

full_name: Booleanisation.instLE
code: @[inherit_doc Booleanisation.LE]
instance instLE : LE (Booleanisation α) 
goal: LE (Booleanisation α)

full_name: Booleanisation.instLT
code: @[inherit_doc Booleanisation.LT]
instance instLT : LT (Booleanisation α) 
goal: LT (Booleanisation α)

full_name: Booleanisation.instSup
code: /-- The supremum on `Booleanisation α` is as follows: For `a b : α`,
* `a ⊔ b` is `a ⊔ b`
* `a ⊔ bᶜ` is `(b \ a)ᶜ`
* `aᶜ ⊔ b` is `(a \ b)ᶜ`
* `aᶜ ⊔ bᶜ` is `(a ⊓ b)ᶜ` -/
instance instSup : Sup (Booleanisation α) 
goal: Sup (Booleanisation α)

full_name: Booleanisation.instInf
code: /-- The infimum on `Booleanisation α` is as follows: For `a b : α`,
* `a ⊓ b` is `a ⊓ b`
* `a ⊓ bᶜ` is `a \ b`
* `aᶜ ⊓ b` is `b \ a`
* `aᶜ ⊓ bᶜ` is `(a ⊔ b)ᶜ` -/
instance instInf : Inf (Booleanisation α) 
goal: Inf (Booleanisation α)

full_name: Booleanisation.instBot
code: /-- The bottom element of `Booleanisation α` is the bottom element of `α`. -/
instance instBot : Bot (Booleanisation α) 
goal: Bot (Booleanisation α)

full_name: Booleanisation.instTop
code: /-- The top element of `Booleanisation α` is the complement of the bottom element of `α`. -/
instance instTop : Top (Booleanisation α) 
goal: Top (Booleanisation α)

full_name: Booleanisation.instSDiff
code: /-- The difference operator on `Booleanisation α` is as follows: For `a b : α`,
* `a \ b` is `a \ b`
* `a \ bᶜ` is `a ⊓ b`
* `aᶜ \ b` is `(a ⊔ b)ᶜ`
* `aᶜ \ bᶜ` is `b \ a` -/
instance instSDiff : SDiff (Booleanisation α) 
goal: SDiff (Booleanisation α)

full_name: Booleanisation.lift_le_lift
code: @[simp] lemma lift_le_lift : lift a ≤ lift b ↔ a ≤ b 
goal: Booleanisation.lift a ≤ Booleanisation.lift b ↔ a ≤ b

full_name: Booleanisation.comp_le_comp
code: @[simp] lemma comp_le_comp : comp a ≤ comp b ↔ b ≤ a 
goal: Booleanisation.comp a ≤ Booleanisation.comp b ↔ b ≤ a

full_name: Booleanisation.lift_le_comp
code: @[simp] lemma lift_le_comp : lift a ≤ comp b ↔ Disjoint a b 
goal: Booleanisation.lift a ≤ Booleanisation.comp b ↔ Disjoint a b

full_name: Booleanisation.not_comp_le_lift
code: @[simp] lemma not_comp_le_lift : ¬ comp a ≤ lift b 
goal: ¬Booleanisation.comp a ≤ Booleanisation.lift b

full_name: Booleanisation.lift_lt_lift
code: @[simp] lemma lift_lt_lift : lift a < lift b ↔ a < b 
goal: Booleanisation.lift a < Booleanisation.lift b ↔ a < b

full_name: Booleanisation.comp_lt_comp
code: @[simp] lemma comp_lt_comp : comp a < comp b ↔ b < a 
goal: Booleanisation.comp a < Booleanisation.comp b ↔ b < a

full_name: Booleanisation.lift_lt_comp
code: @[simp] lemma lift_lt_comp : lift a < comp b ↔ Disjoint a b 
goal: Booleanisation.lift a < Booleanisation.comp b ↔ Disjoint a b

full_name: Booleanisation.not_comp_lt_lift
code: @[simp] lemma not_comp_lt_lift : ¬ comp a < lift b 
goal: ¬Booleanisation.comp a < Booleanisation.lift b

full_name: Booleanisation.lift_sup_lift
code: @[simp] lemma lift_sup_lift (a b : α) : lift a ⊔ lift b = lift (a ⊔ b) 
goal: Booleanisation.lift a ⊔ Booleanisation.lift b = Booleanisation.lift (a ⊔ b)

full_name: Booleanisation.lift_sup_comp
code: @[simp] lemma lift_sup_comp (a b : α) : lift a ⊔ comp b = comp (b \ a) 
goal: Booleanisation.lift a ⊔ Booleanisation.comp b = Booleanisation.comp (b \ a)

full_name: Booleanisation.comp_sup_lift
code: @[simp] lemma comp_sup_lift (a b : α) : comp a ⊔ lift b = comp (a \ b) 
goal: Booleanisation.comp a ⊔ Booleanisation.lift b = Booleanisation.comp (a \ b)

full_name: Booleanisation.comp_sup_comp
code: @[simp] lemma comp_sup_comp (a b : α) : comp a ⊔ comp b = comp (a ⊓ b) 
goal: Booleanisation.comp a ⊔ Booleanisation.comp b = Booleanisation.comp (a ⊓ b)

full_name: Booleanisation.lift_inf_lift
code: @[simp] lemma lift_inf_lift (a b : α) : lift a ⊓ lift b = lift (a ⊓ b) 
goal: Booleanisation.lift a ⊓ Booleanisation.lift b = Booleanisation.lift (a ⊓ b)

full_name: Booleanisation.lift_inf_comp
code: @[simp] lemma lift_inf_comp (a b : α) : lift a ⊓ comp b = lift (a \ b) 
goal: Booleanisation.lift a ⊓ Booleanisation.comp b = Booleanisation.lift (a \ b)

full_name: Booleanisation.comp_inf_lift
code: @[simp] lemma comp_inf_lift (a b : α) : comp a ⊓ lift b = lift (b \ a) 
goal: Booleanisation.comp a ⊓ Booleanisation.lift b = Booleanisation.lift (b \ a)

full_name: Booleanisation.comp_inf_comp
code: @[simp] lemma comp_inf_comp (a b : α) : comp a ⊓ comp b = comp (a ⊔ b) 
goal: Booleanisation.comp a ⊓ Booleanisation.comp b = Booleanisation.comp (a ⊔ b)

full_name: Booleanisation.lift_bot
code: @[simp] lemma lift_bot : lift (⊥ : α) = ⊥ 
goal: Booleanisation.lift ⊥ = ⊥

full_name: Booleanisation.comp_bot
code: @[simp] lemma comp_bot : comp (⊥ : α) = ⊤ 
goal: Booleanisation.comp ⊥ = ⊤

full_name: Booleanisation.lift_sdiff_lift
code: @[simp] lemma lift_sdiff_lift (a b : α) : lift a \ lift b = lift (a \ b) 
goal: Booleanisation.lift a \ Booleanisation.lift b = Booleanisation.lift (a \ b)

full_name: Booleanisation.lift_sdiff_comp
code: @[simp] lemma lift_sdiff_comp (a b : α) : lift a \ comp b = lift (a ⊓ b) 
goal: Booleanisation.lift a \ Booleanisation.comp b = Booleanisation.lift (a ⊓ b)

full_name: Booleanisation.comp_sdiff_lift
code: @[simp] lemma comp_sdiff_lift (a b : α) : comp a \ lift b = comp (a ⊔ b) 
goal: Booleanisation.comp a \ Booleanisation.lift b = Booleanisation.comp (a ⊔ b)

full_name: Booleanisation.comp_sdiff_comp
code: @[simp] lemma comp_sdiff_comp (a b : α) : comp a \ comp b = lift (b \ a) 
goal: Booleanisation.comp a \ Booleanisation.comp b = Booleanisation.lift (b \ a)

full_name: Booleanisation.instPreorder
code: instance instPreorder : Preorder (Booleanisation α) 
goal: Preorder (Booleanisation α)

full_name: Booleanisation.instPartialOrder
code: instance instPartialOrder : PartialOrder (Booleanisation α) 
goal: PartialOrder (Booleanisation α)

full_name: Booleanisation.instSemilatticeSup
code: instance instSemilatticeSup : SemilatticeSup (Booleanisation α) 
goal: SemilatticeSup (Booleanisation α)

full_name: Booleanisation.instSemilatticeInf
code: instance instSemilatticeInf : SemilatticeInf (Booleanisation α) 
goal: SemilatticeInf (Booleanisation α)

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

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

full_name: Booleanisation.instBooleanAlgebra
code: instance instBooleanAlgebra : BooleanAlgebra (Booleanisation α) 
goal: BooleanAlgebra (Booleanisation α)

full_name: Booleanisation.liftLatticeHom
code: /-- The embedding from a generalised Boolean algebra to its generated Boolean algebra. -/
def liftLatticeHom : LatticeHom α (Booleanisation α) 
goal: LatticeHom α (Booleanisation α)

full_name: Booleanisation.liftLatticeHom_injective
code: lemma liftLatticeHom_injective : Injective (liftLatticeHom (α := α)) 
goal: Function.Injective ⇑Booleanisation.liftLatticeHom