File: Mathlib/Order/Heyting/Regular.lean

full_name: Heyting.IsRegular
code: /-- An element of a Heyting algebra is regular if its double complement is itself. -/
def IsRegular (a : α) : Prop 
goal: Prop

full_name: Heyting.IsRegular.eq
code: protected theorem IsRegular.eq : IsRegular a → aᶜᶜ = a 
goal: Heyting.IsRegular a → aᶜᶜ = a

full_name: Heyting.IsRegular.decidablePred
code: instance IsRegular.decidablePred [DecidableEq α] : @DecidablePred α IsRegular 
goal: DecidablePred Heyting.IsRegular

full_name: Heyting.isRegular_bot
code: theorem isRegular_bot : IsRegular (⊥ : α) 
goal: Heyting.IsRegular ⊥

full_name: Heyting.isRegular_top
code: theorem isRegular_top : IsRegular (⊤ : α) 
goal: Heyting.IsRegular ⊤

full_name: Heyting.IsRegular.inf
code: theorem IsRegular.inf (ha : IsRegular a) (hb : IsRegular b) : IsRegular (a ⊓ b) 
goal: Heyting.IsRegular (a ⊓ b)

full_name: Heyting.IsRegular.himp
code: theorem IsRegular.himp (ha : IsRegular a) (hb : IsRegular b) : IsRegular (a ⇨ b) 
goal: Heyting.IsRegular (a ⇨ b)

full_name: Heyting.isRegular_compl
code: theorem isRegular_compl (a : α) : IsRegular aᶜ 
goal: Heyting.IsRegular aᶜ

full_name: Heyting.IsRegular.disjoint_compl_left_iff
code: protected theorem IsRegular.disjoint_compl_left_iff (ha : IsRegular a) :
    Disjoint aᶜ b ↔ b ≤ a 
goal: Disjoint aᶜ b ↔ b ≤ a

full_name: Heyting.IsRegular.disjoint_compl_right_iff
code: protected theorem IsRegular.disjoint_compl_right_iff (hb : IsRegular b) :
    Disjoint a bᶜ ↔ a ≤ b 
goal: Disjoint a bᶜ ↔ a ≤ b

full_name: BooleanAlgebra.ofRegular
code: /-- A Heyting algebra with regular excluded middle is a boolean algebra. -/
abbrev _root_.BooleanAlgebra.ofRegular (h : ∀ a : α, IsRegular (a ⊔ aᶜ)) : BooleanAlgebra α 
goal: BooleanAlgebra α

full_name: Heyting.Regular
code: /-- The boolean algebra of Heyting regular elements. -/
def Regular : Type _ 
goal: Type u_1

full_name: Heyting.Regular.val
code: /-- The coercion `Regular α → α` -/
@[coe] def val : Regular α → α 
goal: Heyting.Regular α → α

full_name: Heyting.Regular.prop
code: theorem prop : ∀ a : Regular α, IsRegular a.val 
goal: Heyting.IsRegular ↑a

full_name: Heyting.Regular.instCoeOut
code: instance : CoeOut (Regular α) α 
goal: CoeOut (Heyting.Regular α) α

full_name: Heyting.Regular.coe_injective
code: theorem coe_injective : Injective ((↑) : Regular α → α) 
goal: Function.Injective Heyting.Regular.val

full_name: Heyting.Regular.coe_inj
code: @[simp]
theorem coe_inj {a b : Regular α} : (a : α) = b ↔ a = b 
goal: ↑a = ↑b ↔ a = b

full_name: Heyting.Regular.top
code: instance top : Top (Regular α) 
goal: Top (Heyting.Regular α)

full_name: Heyting.Regular.bot
code: instance bot : Bot (Regular α) 
goal: Bot (Heyting.Regular α)

full_name: Heyting.Regular.inf
code: instance inf : Inf (Regular α) 
goal: Inf (Heyting.Regular α)

full_name: Heyting.Regular.himp
code: instance himp : HImp (Regular α) 
goal: HImp (Heyting.Regular α)

full_name: Heyting.Regular.hasCompl
code: instance hasCompl : HasCompl (Regular α) 
goal: HasCompl (Heyting.Regular α)

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

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

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

full_name: Heyting.Regular.coe_himp
code: @[simp, norm_cast]
theorem coe_himp (a b : Regular α) : (↑(a ⇨ b) : α) = (a : α) ⇨ b 
goal: ↑(a ⇨ b) = ↑a ⇨ ↑b

full_name: Heyting.Regular.coe_compl
code: @[simp, norm_cast]
theorem coe_compl (a : Regular α) : (↑aᶜ : α) = (a : α)ᶜ 
goal: ↑aᶜ = (↑a)ᶜ

full_name: Heyting.Regular.instInhabited
code: instance : Inhabited (Regular α) 
goal: Inhabited (Heyting.Regular α)

full_name: Heyting.Regular.instSemilatticeInf
code: instance : SemilatticeInf (Regular α) 
goal: SemilatticeInf (Heyting.Regular α)

full_name: Heyting.Regular.boundedOrder
code: instance boundedOrder : BoundedOrder (Regular α) 
goal: BoundedOrder (Heyting.Regular α)

full_name: Heyting.Regular.coe_le_coe
code: @[simp, norm_cast]
theorem coe_le_coe {a b : Regular α} : (a : α) ≤ b ↔ a ≤ b 
goal: ↑a ≤ ↑b ↔ a ≤ b

full_name: Heyting.Regular.coe_lt_coe
code: @[simp, norm_cast]
theorem coe_lt_coe {a b : Regular α} : (a : α) < b ↔ a < b 
goal: ↑a < ↑b ↔ a < b

full_name: Heyting.Regular.toRegular
code: /-- **Regularization** of `a`. The smallest regular element greater than `a`. -/
def toRegular : α →o Regular α 
goal: α →o Heyting.Regular α

full_name: Heyting.Regular.coe_toRegular
code: @[simp, norm_cast]
theorem coe_toRegular (a : α) : (toRegular a : α) = aᶜᶜ 
goal: ↑(Heyting.Regular.toRegular a) = aᶜᶜ

full_name: Heyting.Regular.toRegular_coe
code: @[simp]
theorem toRegular_coe (a : Regular α) : toRegular (a : α) = a 
goal: Heyting.Regular.toRegular ↑a = a

full_name: Heyting.Regular.gi
code: /-- The Galois insertion between `Regular.toRegular` and `coe`. -/
def gi : GaloisInsertion toRegular ((↑) : Regular α → α) 
goal: GaloisInsertion (⇑Heyting.Regular.toRegular) Heyting.Regular.val

full_name: Heyting.Regular.lattice
code: instance lattice : Lattice (Regular α) 
goal: Lattice (Heyting.Regular α)

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

full_name: Heyting.Regular.instBooleanAlgebra
code: instance : BooleanAlgebra (Regular α) 
goal: BooleanAlgebra (Heyting.Regular α)

full_name: Heyting.Regular.coe_sdiff
code: @[simp, norm_cast]
theorem coe_sdiff (a b : Regular α) : (↑(a \ b) : α) = (a : α) ⊓ bᶜ 
goal: ↑(a \ b) = ↑a ⊓ (↑b)ᶜ

full_name: Heyting.isRegular_of_boolean
code: theorem isRegular_of_boolean : ∀ a : α, IsRegular a 
goal: Heyting.IsRegular a

full_name: Heyting.isRegular_of_decidable
code: /-- A decidable proposition is intuitionistically Heyting-regular. -/
-- Porting note: removed @[nolint decidable_classical]
theorem isRegular_of_decidable (p : Prop) [Decidable p] : IsRegular p 
goal: Heyting.IsRegular p