File: Mathlib/Order/Heyting/Basic.lean

full_name: Prod.instHImp
code: instance Prod.instHImp [HImp α] [HImp β] : HImp (α × β) 
goal: HImp (α × β)

full_name: Prod.instHNot
code: instance Prod.instHNot [HNot α] [HNot β] : HNot (α × β) 
goal: HNot (α × β)

full_name: Prod.instSDiff
code: instance Prod.instSDiff [SDiff α] [SDiff β] : SDiff (α × β) 
goal: SDiff (α × β)

full_name: Prod.instHasCompl
code: instance Prod.instHasCompl [HasCompl α] [HasCompl β] : HasCompl (α × β) 
goal: HasCompl (α × β)

full_name: fst_himp
code: @[simp]
theorem fst_himp [HImp α] [HImp β] (a b : α × β) : (a ⇨ b).1 = a.1 ⇨ b.1 
goal: (a ⇨ b).1 = a.1 ⇨ b.1

full_name: snd_himp
code: @[simp]
theorem snd_himp [HImp α] [HImp β] (a b : α × β) : (a ⇨ b).2 = a.2 ⇨ b.2 
goal: (a ⇨ b).2 = a.2 ⇨ b.2

full_name: fst_hnot
code: @[simp]
theorem fst_hnot [HNot α] [HNot β] (a : α × β) : (￢a).1 = ￢a.1 
goal: (￢a).1 = ￢a.1

full_name: snd_hnot
code: @[simp]
theorem snd_hnot [HNot α] [HNot β] (a : α × β) : (￢a).2 = ￢a.2 
goal: (￢a).2 = ￢a.2

full_name: fst_sdiff
code: @[simp]
theorem fst_sdiff [SDiff α] [SDiff β] (a b : α × β) : (a \ b).1 = a.1 \ b.1 
goal: (a \ b).1 = a.1 \ b.1

full_name: snd_sdiff
code: @[simp]
theorem snd_sdiff [SDiff α] [SDiff β] (a b : α × β) : (a \ b).2 = a.2 \ b.2 
goal: (a \ b).2 = a.2 \ b.2

full_name: fst_compl
code: @[simp]
theorem fst_compl [HasCompl α] [HasCompl β] (a : α × β) : aᶜ.1 = a.1ᶜ 
goal: aᶜ.1 = a.1ᶜ

full_name: snd_compl
code: @[simp]
theorem snd_compl [HasCompl α] [HasCompl β] (a : α × β) : aᶜ.2 = a.2ᶜ 
goal: aᶜ.2 = a.2ᶜ

full_name: Pi.instHImpForall
code: instance [∀ i, HImp (π i)] : HImp (∀ i, π i) 
goal: HImp ((i : ι) → π i)

full_name: Pi.instHNotForall
code: instance [∀ i, HNot (π i)] : HNot (∀ i, π i) 
goal: HNot ((i : ι) → π i)

full_name: Pi.himp_def
code: theorem himp_def [∀ i, HImp (π i)] (a b : ∀ i, π i) : a ⇨ b = fun i => a i ⇨ b i 
goal: a ⇨ b = fun i => a i ⇨ b i

full_name: Pi.hnot_def
code: theorem hnot_def [∀ i, HNot (π i)] (a : ∀ i, π i) : ￢a = fun i => ￢a i 
goal: ￢a = fun i => ￢a i

full_name: Pi.himp_apply
code: @[simp]
theorem himp_apply [∀ i, HImp (π i)] (a b : ∀ i, π i) (i : ι) : (a ⇨ b) i = a i ⇨ b i 
goal: (a ⇨ b) i = a i ⇨ b i

full_name: Pi.hnot_apply
code: @[simp]
theorem hnot_apply [∀ i, HNot (π i)] (a : ∀ i, π i) (i : ι) : (￢a) i = ￢a i 
goal: (￢a) i = ￢a i

full_name: GeneralizedHeytingAlgebra
code: /-- A generalized Heyting algebra is a lattice with an additional binary operation `⇨` called
Heyting implication such that `a ⇨` is right adjoint to `a ⊓`.

 This generalizes `HeytingAlgebra` by not requiring a bottom element. -/
class GeneralizedHeytingAlgebra (α : Type*) extends Lattice α, OrderTop α, HImp α where
  /-- `a ⇨` is right adjoint to `a ⊓` -/
  le_himp_iff (a b c : α) : a ≤ b ⇨ c ↔ a ⊓ b ≤ c
goal: Type u_4

full_name: GeneralizedHeytingAlgebra.le_himp_iff
code: /-- A generalized Heyting algebra is a lattice with an additional binary operation `⇨` called
Heyting implication such that `a ⇨` is right adjoint to `a ⊓`.

 This generalizes `HeytingAlgebra` by not requiring a bottom element. -/
class GeneralizedHeytingAlgebra (α : Type*) extends Lattice α, OrderTop α, HImp α where
  /-- `a ⇨` is right adjoint to `a ⊓` -/
  le_himp_iff (a b c : α) : a ≤ b ⇨ c ↔ a ⊓ b ≤ c
goal: a ≤ b ⇨ c ↔ a ⊓ b ≤ c

full_name: GeneralizedCoheytingAlgebra
code: /-- A generalized co-Heyting algebra is a lattice with an additional binary
difference operation `\` such that `\ a` is right adjoint to `⊔ a`.

This generalizes `CoheytingAlgebra` by not requiring a top element. -/
class GeneralizedCoheytingAlgebra (α : Type*) extends Lattice α, OrderBot α, SDiff α where
  /-- `\ a` is right adjoint to `⊔ a` -/
  sdiff_le_iff (a b c : α) : a \ b ≤ c ↔ a ≤ b ⊔ c
goal: Type u_4

full_name: GeneralizedCoheytingAlgebra.sdiff_le_iff
code: /-- A generalized co-Heyting algebra is a lattice with an additional binary
difference operation `\` such that `\ a` is right adjoint to `⊔ a`.

This generalizes `CoheytingAlgebra` by not requiring a top element. -/
class GeneralizedCoheytingAlgebra (α : Type*) extends Lattice α, OrderBot α, SDiff α where
  /-- `\ a` is right adjoint to `⊔ a` -/
  sdiff_le_iff (a b c : α) : a \ b ≤ c ↔ a ≤ b ⊔ c
goal: a \ b ≤ c ↔ a ≤ b ⊔ c

full_name: HeytingAlgebra
code: /-- A Heyting algebra is a bounded lattice with an additional binary operation `⇨` called Heyting
implication such that `a ⇨` is right adjoint to `a ⊓`. -/
class HeytingAlgebra (α : Type*) extends GeneralizedHeytingAlgebra α, OrderBot α, HasCompl α where
  /-- `a ⇨` is right adjoint to `a ⊓` -/
  himp_bot (a : α) : a ⇨ ⊥ = aᶜ
goal: Type u_4

full_name: HeytingAlgebra.himp_bot
code: /-- A Heyting algebra is a bounded lattice with an additional binary operation `⇨` called Heyting
implication such that `a ⇨` is right adjoint to `a ⊓`. -/
class HeytingAlgebra (α : Type*) extends GeneralizedHeytingAlgebra α, OrderBot α, HasCompl α where
  /-- `a ⇨` is right adjoint to `a ⊓` -/
  himp_bot (a : α) : a ⇨ ⊥ = aᶜ
goal: a ⇨ ⊥ = aᶜ

full_name: CoheytingAlgebra.top_sdiff
code: /-- A co-Heyting algebra is a bounded lattice with an additional binary difference operation `\`
such that `\ a` is right adjoint to `⊔ a`. -/
class CoheytingAlgebra (α : Type*) extends GeneralizedCoheytingAlgebra α, OrderTop α, HNot α where
  /-- `⊤ \ a` is `￢a` -/
  top_sdiff (a : α) : ⊤ \ a = ￢a
goal: ⊤ \ a = ￢a

full_name: CoheytingAlgebra
code: /-- A co-Heyting algebra is a bounded lattice with an additional binary difference operation `\`
such that `\ a` is right adjoint to `⊔ a`. -/
class CoheytingAlgebra (α : Type*) extends GeneralizedCoheytingAlgebra α, OrderTop α, HNot α where
  /-- `⊤ \ a` is `￢a` -/
  top_sdiff (a : α) : ⊤ \ a = ￢a
goal: Type u_4

full_name: BiheytingAlgebra.top_sdiff
code: /-- A bi-Heyting algebra is a Heyting algebra that is also a co-Heyting algebra. -/
class BiheytingAlgebra (α : Type*) extends HeytingAlgebra α, SDiff α, HNot α where
  /-- `\ a` is right adjoint to `⊔ a` -/
  sdiff_le_iff (a b c : α) : a \ b ≤ c ↔ a ≤ b ⊔ c
  /-- `⊤ \ a` is `￢a` -/
  top_sdiff (a : α) : ⊤ \ a = ￢a
goal: ⊤ \ a = ￢a

full_name: BiheytingAlgebra
code: /-- A bi-Heyting algebra is a Heyting algebra that is also a co-Heyting algebra. -/
class BiheytingAlgebra (α : Type*) extends HeytingAlgebra α, SDiff α, HNot α where
  /-- `\ a` is right adjoint to `⊔ a` -/
  sdiff_le_iff (a b c : α) : a \ b ≤ c ↔ a ≤ b ⊔ c
  /-- `⊤ \ a` is `￢a` -/
  top_sdiff (a : α) : ⊤ \ a = ￢a
goal: Type u_4

full_name: BiheytingAlgebra.sdiff_le_iff
code: /-- A bi-Heyting algebra is a Heyting algebra that is also a co-Heyting algebra. -/
class BiheytingAlgebra (α : Type*) extends HeytingAlgebra α, SDiff α, HNot α where
  /-- `\ a` is right adjoint to `⊔ a` -/
  sdiff_le_iff (a b c : α) : a \ b ≤ c ↔ a ≤ b ⊔ c
  /-- `⊤ \ a` is `￢a` -/
  top_sdiff (a : α) : ⊤ \ a = ￢a
goal: a \ b ≤ c ↔ a ≤ b ⊔ c

full_name: HeytingAlgebra.toBoundedOrder
code: instance (priority := 100) HeytingAlgebra.toBoundedOrder [HeytingAlgebra α] : BoundedOrder α 
goal: BoundedOrder α

full_name: CoheytingAlgebra.toBoundedOrder
code: instance (priority := 100) CoheytingAlgebra.toBoundedOrder [CoheytingAlgebra α] : BoundedOrder α 
goal: BoundedOrder α

full_name: BiheytingAlgebra.toCoheytingAlgebra
code: instance (priority := 100) BiheytingAlgebra.toCoheytingAlgebra [BiheytingAlgebra α] :
    CoheytingAlgebra α 
goal: CoheytingAlgebra α

full_name: HeytingAlgebra.ofHImp
code: /-- Construct a Heyting algebra from the lattice structure and Heyting implication alone. -/
abbrev HeytingAlgebra.ofHImp [DistribLattice α] [BoundedOrder α] (himp : α → α → α)
    (le_himp_iff : ∀ a b c, a ≤ himp b c ↔ a ⊓ b ≤ c) : HeytingAlgebra α 
goal: HeytingAlgebra α

full_name: HeytingAlgebra.ofCompl
code: /-- Construct a Heyting algebra from the lattice structure and complement operator alone. -/
abbrev HeytingAlgebra.ofCompl [DistribLattice α] [BoundedOrder α] (compl : α → α)
    (le_himp_iff : ∀ a b c, a ≤ compl b ⊔ c ↔ a ⊓ b ≤ c) : HeytingAlgebra α 
goal: HeytingAlgebra α

full_name: CoheytingAlgebra.ofSDiff
code: /-- Construct a co-Heyting algebra from the lattice structure and the difference alone. -/
abbrev CoheytingAlgebra.ofSDiff [DistribLattice α] [BoundedOrder α] (sdiff : α → α → α)
    (sdiff_le_iff : ∀ a b c, sdiff a b ≤ c ↔ a ≤ b ⊔ c) : CoheytingAlgebra α 
goal: CoheytingAlgebra α

full_name: CoheytingAlgebra.ofHNot
code: /-- Construct a co-Heyting algebra from the difference and Heyting negation alone. -/
abbrev CoheytingAlgebra.ofHNot [DistribLattice α] [BoundedOrder α] (hnot : α → α)
    (sdiff_le_iff : ∀ a b c, a ⊓ hnot b ≤ c ↔ a ≤ b ⊔ c) : CoheytingAlgebra α 
goal: CoheytingAlgebra α

full_name: le_himp_iff
code: /-- `p → q → r ↔ p ∧ q → r` -/
@[simp]
theorem le_himp_iff : a ≤ b ⇨ c ↔ a ⊓ b ≤ c 
goal: a ≤ b ⇨ c ↔ a ⊓ b ≤ c

full_name: le_himp_iff'
code: /-- `p → q → r ↔ q ∧ p → r` -/
theorem le_himp_iff' : a ≤ b ⇨ c ↔ b ⊓ a ≤ c 
goal: a ≤ b ⇨ c ↔ b ⊓ a ≤ c

full_name: le_himp_comm
code: /-- `p → q → r ↔ q → p → r` -/
theorem le_himp_comm : a ≤ b ⇨ c ↔ b ≤ a ⇨ c 
goal: a ≤ b ⇨ c ↔ b ≤ a ⇨ c

full_name: le_himp
code: /-- `p → q → p` -/
theorem le_himp : a ≤ b ⇨ a 
goal: a ≤ b ⇨ a

full_name: le_himp_iff_left
code: /-- `p → p → q ↔ p → q` -/
theorem le_himp_iff_left : a ≤ a ⇨ b ↔ a ≤ b 
goal: a ≤ a ⇨ b ↔ a ≤ b

full_name: himp_self
code: /-- `p → p` -/
@[simp]
theorem himp_self : a ⇨ a = ⊤ 
goal: a ⇨ a = ⊤

full_name: himp_inf_le
code: /-- `(p → q) ∧ p → q` -/
theorem himp_inf_le : (a ⇨ b) ⊓ a ≤ b 
goal: (a ⇨ b) ⊓ a ≤ b

full_name: inf_himp_le
code: /-- `p ∧ (p → q) → q` -/
theorem inf_himp_le : a ⊓ (a ⇨ b) ≤ b 
goal: a ⊓ (a ⇨ b) ≤ b

full_name: inf_himp
code: /-- `p ∧ (p → q) ↔ p ∧ q` -/
@[simp]
theorem inf_himp (a b : α) : a ⊓ (a ⇨ b) = a ⊓ b 
goal: a ⊓ (a ⇨ b) = a ⊓ b

full_name: himp_inf_self
code: /-- `(p → q) ∧ p ↔ q ∧ p` -/
@[simp]
theorem himp_inf_self (a b : α) : (a ⇨ b) ⊓ a = b ⊓ a 
goal: (a ⇨ b) ⊓ a = b ⊓ a

full_name: himp_eq_top_iff
code: /-- The **deduction theorem** in the Heyting algebra model of intuitionistic logic:
an implication holds iff the conclusion follows from the hypothesis. -/
@[simp]
theorem himp_eq_top_iff : a ⇨ b = ⊤ ↔ a ≤ b 
goal: a ⇨ b = ⊤ ↔ a ≤ b

full_name: himp_top
code: /-- `p → true`, `true → p ↔ p` -/
@[simp]
theorem himp_top : a ⇨ ⊤ = ⊤ 
goal: a ⇨ ⊤ = ⊤

full_name: top_himp
code: @[simp]
theorem top_himp : ⊤ ⇨ a = a 
goal: ⊤ ⇨ a = a

full_name: himp_himp
code: /-- `p → q → r ↔ p ∧ q → r` -/
theorem himp_himp (a b c : α) : a ⇨ b ⇨ c = a ⊓ b ⇨ c 
goal: a ⇨ b ⇨ c = a ⊓ b ⇨ c

full_name: himp_le_himp_himp_himp
code: /-- `(q → r) → (p → q) → q → r` -/
theorem himp_le_himp_himp_himp : b ⇨ c ≤ (a ⇨ b) ⇨ a ⇨ c 
goal: b ⇨ c ≤ (a ⇨ b) ⇨ a ⇨ c

full_name: himp_inf_himp_inf_le
code: @[simp]
theorem himp_inf_himp_inf_le : (b ⇨ c) ⊓ (a ⇨ b) ⊓ a ≤ c 
goal: (b ⇨ c) ⊓ (a ⇨ b) ⊓ a ≤ c

full_name: himp_left_comm
code: /-- `p → q → r ↔ q → p → r` -/
theorem himp_left_comm (a b c : α) : a ⇨ b ⇨ c = b ⇨ a ⇨ c 
goal: a ⇨ b ⇨ c = b ⇨ a ⇨ c

full_name: himp_idem
code: @[simp]
theorem himp_idem : b ⇨ b ⇨ a = b ⇨ a 
goal: b ⇨ b ⇨ a = b ⇨ a

full_name: himp_inf_distrib
code: theorem himp_inf_distrib (a b c : α) : a ⇨ b ⊓ c = (a ⇨ b) ⊓ (a ⇨ c) 
goal: a ⇨ b ⊓ c = (a ⇨ b) ⊓ (a ⇨ c)

full_name: sup_himp_distrib
code: theorem sup_himp_distrib (a b c : α) : a ⊔ b ⇨ c = (a ⇨ c) ⊓ (b ⇨ c) 
goal: a ⊔ b ⇨ c = (a ⇨ c) ⊓ (b ⇨ c)

full_name: himp_le_himp_left
code: theorem himp_le_himp_left (h : a ≤ b) : c ⇨ a ≤ c ⇨ b 
goal: c ⇨ a ≤ c ⇨ b

full_name: himp_le_himp_right
code: theorem himp_le_himp_right (h : a ≤ b) : b ⇨ c ≤ a ⇨ c 
goal: b ⇨ c ≤ a ⇨ c

full_name: himp_le_himp
code: theorem himp_le_himp (hab : a ≤ b) (hcd : c ≤ d) : b ⇨ c ≤ a ⇨ d 
goal: b ⇨ c ≤ a ⇨ d

full_name: sup_himp_self_left
code: @[simp]
theorem sup_himp_self_left (a b : α) : a ⊔ b ⇨ a = b ⇨ a 
goal: a ⊔ b ⇨ a = b ⇨ a

full_name: sup_himp_self_right
code: @[simp]
theorem sup_himp_self_right (a b : α) : a ⊔ b ⇨ b = a ⇨ b 
goal: a ⊔ b ⇨ b = a ⇨ b

full_name: Codisjoint.himp_eq_right
code: theorem Codisjoint.himp_eq_right (h : Codisjoint a b) : b ⇨ a = a 
goal: b ⇨ a = a

full_name: Codisjoint.himp_eq_left
code: theorem Codisjoint.himp_eq_left (h : Codisjoint a b) : a ⇨ b = b 
goal: a ⇨ b = b

full_name: Codisjoint.himp_inf_cancel_right
code: theorem Codisjoint.himp_inf_cancel_right (h : Codisjoint a b) : a ⇨ a ⊓ b = b 
goal: a ⇨ a ⊓ b = b

full_name: Codisjoint.himp_inf_cancel_left
code: theorem Codisjoint.himp_inf_cancel_left (h : Codisjoint a b) : b ⇨ a ⊓ b = a 
goal: b ⇨ a ⊓ b = a

full_name: Codisjoint.himp_le_of_right_le
code: /-- See `himp_le` for a stronger version in Boolean algebras. -/
theorem Codisjoint.himp_le_of_right_le (hac : Codisjoint a c) (hba : b ≤ a) : c ⇨ b ≤ a 
goal: c ⇨ b ≤ a

full_name: le_himp_himp
code: theorem le_himp_himp : a ≤ (a ⇨ b) ⇨ b 
goal: a ≤ (a ⇨ b) ⇨ b

full_name: himp_eq_himp_iff
code: @[simp] lemma himp_eq_himp_iff : b ⇨ a = a ⇨ b ↔ a = b 
goal: b ⇨ a = a ⇨ b ↔ a = b

full_name: himp_ne_himp_iff
code: lemma himp_ne_himp_iff : b ⇨ a ≠ a ⇨ b ↔ a ≠ b 
goal: b ⇨ a ≠ a ⇨ b ↔ a ≠ b

full_name: himp_triangle
code: theorem himp_triangle (a b c : α) : (a ⇨ b) ⊓ (b ⇨ c) ≤ a ⇨ c 
goal: (a ⇨ b) ⊓ (b ⇨ c) ≤ a ⇨ c

full_name: himp_inf_himp_cancel
code: theorem himp_inf_himp_cancel (hba : b ≤ a) (hcb : c ≤ b) : (a ⇨ b) ⊓ (b ⇨ c) = a ⇨ c 
goal: (a ⇨ b) ⊓ (b ⇨ c) = a ⇨ c

full_name: GeneralizedHeytingAlgebra.toDistribLattice
code: instance (priority := 100) GeneralizedHeytingAlgebra.toDistribLattice : DistribLattice α 
goal: DistribLattice α

full_name: OrderDual.instGeneralizedCoheytingAlgebra
code: instance OrderDual.instGeneralizedCoheytingAlgebra : GeneralizedCoheytingAlgebra αᵒᵈ 
goal: GeneralizedCoheytingAlgebra αᵒᵈ

full_name: Prod.instGeneralizedHeytingAlgebra
code: instance Prod.instGeneralizedHeytingAlgebra [GeneralizedHeytingAlgebra β] :
    GeneralizedHeytingAlgebra (α × β) 
goal: GeneralizedHeytingAlgebra (α × β)

full_name: Pi.instGeneralizedHeytingAlgebra
code: instance Pi.instGeneralizedHeytingAlgebra {α : ι → Type*} [∀ i, GeneralizedHeytingAlgebra (α i)] :
    GeneralizedHeytingAlgebra (∀ i, α i) 
goal: GeneralizedHeytingAlgebra ((i : ι) → α i)

full_name: sdiff_le_iff
code: @[simp]
theorem sdiff_le_iff : a \ b ≤ c ↔ a ≤ b ⊔ c 
goal: a \ b ≤ c ↔ a ≤ b ⊔ c

full_name: sdiff_le_iff'
code: theorem sdiff_le_iff' : a \ b ≤ c ↔ a ≤ c ⊔ b 
goal: a \ b ≤ c ↔ a ≤ c ⊔ b

full_name: sdiff_le_comm
code: theorem sdiff_le_comm : a \ b ≤ c ↔ a \ c ≤ b 
goal: a \ b ≤ c ↔ a \ c ≤ b

full_name: sdiff_le
code: theorem sdiff_le : a \ b ≤ a 
goal: a \ b ≤ a

full_name: Disjoint.disjoint_sdiff_left
code: theorem Disjoint.disjoint_sdiff_left (h : Disjoint a b) : Disjoint (a \ c) b 
goal: Disjoint (a \ c) b

full_name: Disjoint.disjoint_sdiff_right
code: theorem Disjoint.disjoint_sdiff_right (h : Disjoint a b) : Disjoint a (b \ c) 
goal: Disjoint a (b \ c)

full_name: sdiff_le_iff_left
code: theorem sdiff_le_iff_left : a \ b ≤ b ↔ a ≤ b 
goal: a \ b ≤ b ↔ a ≤ b

full_name: sdiff_self
code: @[simp]
theorem sdiff_self : a \ a = ⊥ 
goal: a \ a = ⊥

full_name: le_sup_sdiff
code: theorem le_sup_sdiff : a ≤ b ⊔ a \ b 
goal: a ≤ b ⊔ a \ b

full_name: le_sdiff_sup
code: theorem le_sdiff_sup : a ≤ a \ b ⊔ b 
goal: a ≤ a \ b ⊔ b

full_name: sup_sdiff_left
code: theorem sup_sdiff_left : a ⊔ a \ b = a 
goal: a ⊔ a \ b = a

full_name: sup_sdiff_right
code: theorem sup_sdiff_right : a \ b ⊔ a = a 
goal: a \ b ⊔ a = a

full_name: inf_sdiff_left
code: theorem inf_sdiff_left : a \ b ⊓ a = a \ b 
goal: a \ b ⊓ a = a \ b

full_name: inf_sdiff_right
code: theorem inf_sdiff_right : a ⊓ a \ b = a \ b 
goal: a ⊓ a \ b = a \ b

full_name: sup_sdiff_self
code: @[simp]
theorem sup_sdiff_self (a b : α) : a ⊔ b \ a = a ⊔ b 
goal: a ⊔ b \ a = a ⊔ b

full_name: sdiff_sup_self
code: @[simp]
theorem sdiff_sup_self (a b : α) : b \ a ⊔ a = b ⊔ a 
goal: b \ a ⊔ a = b ⊔ a

full_name: sup_sdiff_eq_sup
code: theorem sup_sdiff_eq_sup (h : c ≤ a) : a ⊔ b \ c = a ⊔ b 
goal: a ⊔ b \ c = a ⊔ b

full_name: sup_sdiff_cancel'
code: theorem sup_sdiff_cancel' (hab : a ≤ b) (hbc : b ≤ c) : b ⊔ c \ a = c 
goal: b ⊔ c \ a = c

full_name: sup_sdiff_cancel_right
code: theorem sup_sdiff_cancel_right (h : a ≤ b) : a ⊔ b \ a = b 
goal: a ⊔ b \ a = b

full_name: sdiff_sup_cancel
code: theorem sdiff_sup_cancel (h : b ≤ a) : a \ b ⊔ b = a 
goal: a \ b ⊔ b = a

full_name: sup_le_of_le_sdiff_left
code: theorem sup_le_of_le_sdiff_left (h : b ≤ c \ a) (hac : a ≤ c) : a ⊔ b ≤ c 
goal: a ⊔ b ≤ c

full_name: sup_le_of_le_sdiff_right
code: theorem sup_le_of_le_sdiff_right (h : a ≤ c \ b) (hbc : b ≤ c) : a ⊔ b ≤ c 
goal: a ⊔ b ≤ c

full_name: sdiff_eq_bot_iff
code: @[simp]
theorem sdiff_eq_bot_iff : a \ b = ⊥ ↔ a ≤ b 
goal: a \ b = ⊥ ↔ a ≤ b

full_name: sdiff_bot
code: @[simp]
theorem sdiff_bot : a \ ⊥ = a 
goal: a \ ⊥ = a

full_name: bot_sdiff
code: @[simp]
theorem bot_sdiff : ⊥ \ a = ⊥ 
goal: ⊥ \ a = ⊥

full_name: sdiff_sdiff_sdiff_le_sdiff
code: theorem sdiff_sdiff_sdiff_le_sdiff : (a \ b) \ (a \ c) ≤ c \ b 
goal: (a \ b) \ (a \ c) ≤ c \ b

full_name: le_sup_sdiff_sup_sdiff
code: @[simp]
theorem le_sup_sdiff_sup_sdiff : a ≤ b ⊔ (a \ c ⊔ c \ b) 
goal: a ≤ b ⊔ (a \ c ⊔ c \ b)

full_name: sdiff_sdiff
code: theorem sdiff_sdiff (a b c : α) : (a \ b) \ c = a \ (b ⊔ c) 
goal: (a \ b) \ c = a \ (b ⊔ c)

full_name: sdiff_sdiff_left
code: theorem sdiff_sdiff_left : (a \ b) \ c = a \ (b ⊔ c) 
goal: (a \ b) \ c = a \ (b ⊔ c)

full_name: sdiff_right_comm
code: theorem sdiff_right_comm (a b c : α) : (a \ b) \ c = (a \ c) \ b 
goal: (a \ b) \ c = (a \ c) \ b

full_name: sdiff_sdiff_comm
code: theorem sdiff_sdiff_comm : (a \ b) \ c = (a \ c) \ b 
goal: (a \ b) \ c = (a \ c) \ b

full_name: sdiff_idem
code: @[simp]
theorem sdiff_idem : (a \ b) \ b = a \ b 
goal: (a \ b) \ b = a \ b

full_name: sdiff_sdiff_self
code: @[simp]
theorem sdiff_sdiff_self : (a \ b) \ a = ⊥ 
goal: (a \ b) \ a = ⊥

full_name: sup_sdiff_distrib
code: theorem sup_sdiff_distrib (a b c : α) : (a ⊔ b) \ c = a \ c ⊔ b \ c 
goal: (a ⊔ b) \ c = a \ c ⊔ b \ c

full_name: sdiff_inf_distrib
code: theorem sdiff_inf_distrib (a b c : α) : a \ (b ⊓ c) = a \ b ⊔ a \ c 
goal: a \ (b ⊓ c) = a \ b ⊔ a \ c

full_name: sup_sdiff
code: theorem sup_sdiff : (a ⊔ b) \ c = a \ c ⊔ b \ c 
goal: (a ⊔ b) \ c = a \ c ⊔ b \ c

full_name: sup_sdiff_right_self
code: @[simp]
theorem sup_sdiff_right_self : (a ⊔ b) \ b = a \ b 
goal: (a ⊔ b) \ b = a \ b

full_name: sup_sdiff_left_self
code: @[simp]
theorem sup_sdiff_left_self : (a ⊔ b) \ a = b \ a 
goal: (a ⊔ b) \ a = b \ a

full_name: sdiff_le_sdiff_right
code: @[gcongr]
theorem sdiff_le_sdiff_right (h : a ≤ b) : a \ c ≤ b \ c 
goal: a \ c ≤ b \ c

full_name: sdiff_le_sdiff_left
code: @[gcongr]
theorem sdiff_le_sdiff_left (h : a ≤ b) : c \ b ≤ c \ a 
goal: c \ b ≤ c \ a

full_name: sdiff_le_sdiff
code: @[gcongr]
theorem sdiff_le_sdiff (hab : a ≤ b) (hcd : c ≤ d) : a \ d ≤ b \ c 
goal: a \ d ≤ b \ c

full_name: sdiff_inf
code: theorem sdiff_inf : a \ (b ⊓ c) = a \ b ⊔ a \ c 
goal: a \ (b ⊓ c) = a \ b ⊔ a \ c

full_name: sdiff_inf_self_left
code: @[simp]
theorem sdiff_inf_self_left (a b : α) : a \ (a ⊓ b) = a \ b 
goal: a \ (a ⊓ b) = a \ b

full_name: sdiff_inf_self_right
code: @[simp]
theorem sdiff_inf_self_right (a b : α) : b \ (a ⊓ b) = b \ a 
goal: b \ (a ⊓ b) = b \ a

full_name: Disjoint.sdiff_eq_left
code: theorem Disjoint.sdiff_eq_left (h : Disjoint a b) : a \ b = a 
goal: a \ b = a

full_name: Disjoint.sdiff_eq_right
code: theorem Disjoint.sdiff_eq_right (h : Disjoint a b) : b \ a = b 
goal: b \ a = b

full_name: Disjoint.sup_sdiff_cancel_left
code: theorem Disjoint.sup_sdiff_cancel_left (h : Disjoint a b) : (a ⊔ b) \ a = b 
goal: (a ⊔ b) \ a = b

full_name: Disjoint.sup_sdiff_cancel_right
code: theorem Disjoint.sup_sdiff_cancel_right (h : Disjoint a b) : (a ⊔ b) \ b = a 
goal: (a ⊔ b) \ b = a

full_name: Disjoint.le_sdiff_of_le_left
code: /-- See `le_sdiff` for a stronger version in generalised Boolean algebras. -/
theorem Disjoint.le_sdiff_of_le_left (hac : Disjoint a c) (hab : a ≤ b) : a ≤ b \ c 
goal: a ≤ b \ c

full_name: sdiff_sdiff_le
code: theorem sdiff_sdiff_le : a \ (a \ b) ≤ b 
goal: a \ (a \ b) ≤ b

full_name: sdiff_eq_sdiff_iff
code: @[simp] lemma sdiff_eq_sdiff_iff : a \ b = b \ a ↔ a = b 
goal: a \ b = b \ a ↔ a = b

full_name: sdiff_ne_sdiff_iff
code: lemma sdiff_ne_sdiff_iff : a \ b ≠ b \ a ↔ a ≠ b 
goal: a \ b ≠ b \ a ↔ a ≠ b

full_name: sdiff_triangle
code: theorem sdiff_triangle (a b c : α) : a \ c ≤ a \ b ⊔ b \ c 
goal: a \ c ≤ a \ b ⊔ b \ c

full_name: sdiff_sup_sdiff_cancel
code: theorem sdiff_sup_sdiff_cancel (hba : b ≤ a) (hcb : c ≤ b) : a \ b ⊔ b \ c = a \ c 
goal: a \ b ⊔ b \ c = a \ c

full_name: sdiff_le_sdiff_of_sup_le_sup_left
code: theorem sdiff_le_sdiff_of_sup_le_sup_left (h : c ⊔ a ≤ c ⊔ b) : a \ c ≤ b \ c 
goal: a \ c ≤ b \ c

full_name: sdiff_le_sdiff_of_sup_le_sup_right
code: theorem sdiff_le_sdiff_of_sup_le_sup_right (h : a ⊔ c ≤ b ⊔ c) : a \ c ≤ b \ c 
goal: a \ c ≤ b \ c

full_name: inf_sdiff_sup_left
code: @[simp]
theorem inf_sdiff_sup_left : a \ c ⊓ (a ⊔ b) = a \ c 
goal: a \ c ⊓ (a ⊔ b) = a \ c

full_name: inf_sdiff_sup_right
code: @[simp]
theorem inf_sdiff_sup_right : a \ c ⊓ (b ⊔ a) = a \ c 
goal: a \ c ⊓ (b ⊔ a) = a \ c

full_name: GeneralizedCoheytingAlgebra.toDistribLattice
code: instance (priority := 100) GeneralizedCoheytingAlgebra.toDistribLattice : DistribLattice α 
goal: DistribLattice α

full_name: OrderDual.instGeneralizedHeytingAlgebra
code: instance OrderDual.instGeneralizedHeytingAlgebra : GeneralizedHeytingAlgebra αᵒᵈ 
goal: GeneralizedHeytingAlgebra αᵒᵈ

full_name: Prod.instGeneralizedCoheytingAlgebra
code: instance Prod.instGeneralizedCoheytingAlgebra [GeneralizedCoheytingAlgebra β] :
    GeneralizedCoheytingAlgebra (α × β) 
goal: GeneralizedCoheytingAlgebra (α × β)

full_name: Pi.instGeneralizedCoheytingAlgebra
code: instance Pi.instGeneralizedCoheytingAlgebra {α : ι → Type*}
    [∀ i, GeneralizedCoheytingAlgebra (α i)] : GeneralizedCoheytingAlgebra (∀ i, α i) 
goal: GeneralizedCoheytingAlgebra ((i : ι) → α i)

full_name: himp_bot
code: @[simp]
theorem himp_bot (a : α) : a ⇨ ⊥ = aᶜ 
goal: a ⇨ ⊥ = aᶜ

full_name: bot_himp
code: @[simp]
theorem bot_himp (a : α) : ⊥ ⇨ a = ⊤ 
goal: ⊥ ⇨ a = ⊤

full_name: compl_sup_distrib
code: theorem compl_sup_distrib (a b : α) : (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ 
goal: (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ

full_name: compl_sup
code: @[simp]
theorem compl_sup : (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ 
goal: (a ⊔ b)ᶜ = aᶜ ⊓ bᶜ

full_name: compl_le_himp
code: theorem compl_le_himp : aᶜ ≤ a ⇨ b 
goal: aᶜ ≤ a ⇨ b

full_name: compl_sup_le_himp
code: theorem compl_sup_le_himp : aᶜ ⊔ b ≤ a ⇨ b 
goal: aᶜ ⊔ b ≤ a ⇨ b

full_name: sup_compl_le_himp
code: theorem sup_compl_le_himp : b ⊔ aᶜ ≤ a ⇨ b 
goal: b ⊔ aᶜ ≤ a ⇨ b

full_name: himp_compl
code: @[simp]
theorem himp_compl (a : α) : a ⇨ aᶜ = aᶜ 
goal: a ⇨ aᶜ = aᶜ

full_name: himp_compl_comm
code: theorem himp_compl_comm (a b : α) : a ⇨ bᶜ = b ⇨ aᶜ 
goal: a ⇨ bᶜ = b ⇨ aᶜ

full_name: le_compl_iff_disjoint_right
code: theorem le_compl_iff_disjoint_right : a ≤ bᶜ ↔ Disjoint a b 
goal: a ≤ bᶜ ↔ Disjoint a b

full_name: le_compl_iff_disjoint_left
code: theorem le_compl_iff_disjoint_left : a ≤ bᶜ ↔ Disjoint b a 
goal: a ≤ bᶜ ↔ Disjoint b a

full_name: le_compl_comm
code: theorem le_compl_comm : a ≤ bᶜ ↔ b ≤ aᶜ 
goal: a ≤ bᶜ ↔ b ≤ aᶜ

full_name: disjoint_compl_left
code: theorem disjoint_compl_left : Disjoint aᶜ a 
goal: Disjoint aᶜ a

full_name: disjoint_compl_right
code: theorem disjoint_compl_right : Disjoint a aᶜ 
goal: Disjoint a aᶜ

full_name: LE.le.disjoint_compl_left
code: theorem LE.le.disjoint_compl_left (h : b ≤ a) : Disjoint aᶜ b 
goal: Disjoint aᶜ b

full_name: LE.le.disjoint_compl_right
code: theorem LE.le.disjoint_compl_right (h : a ≤ b) : Disjoint a bᶜ 
goal: Disjoint a bᶜ

full_name: IsCompl.compl_eq
code: theorem IsCompl.compl_eq (h : IsCompl a b) : aᶜ = b 
goal: aᶜ = b

full_name: IsCompl.eq_compl
code: theorem IsCompl.eq_compl (h : IsCompl a b) : a = bᶜ 
goal: a = bᶜ

full_name: compl_unique
code: theorem compl_unique (h₀ : a ⊓ b = ⊥) (h₁ : a ⊔ b = ⊤) : aᶜ = b 
goal: aᶜ = b

full_name: inf_compl_self
code: @[simp]
theorem inf_compl_self (a : α) : a ⊓ aᶜ = ⊥ 
goal: a ⊓ aᶜ = ⊥

full_name: compl_inf_self
code: @[simp]
theorem compl_inf_self (a : α) : aᶜ ⊓ a = ⊥ 
goal: aᶜ ⊓ a = ⊥

full_name: inf_compl_eq_bot
code: theorem inf_compl_eq_bot : a ⊓ aᶜ = ⊥ 
goal: a ⊓ aᶜ = ⊥

full_name: compl_inf_eq_bot
code: theorem compl_inf_eq_bot : aᶜ ⊓ a = ⊥ 
goal: aᶜ ⊓ a = ⊥

full_name: compl_top
code: @[simp]
theorem compl_top : (⊤ : α)ᶜ = ⊥ 
goal: ⊤ᶜ = ⊥

full_name: compl_bot
code: @[simp]
theorem compl_bot : (⊥ : α)ᶜ = ⊤ 
goal: ⊥ᶜ = ⊤

full_name: le_compl_self
code: @[simp] theorem le_compl_self : a ≤ aᶜ ↔ a = ⊥ 
goal: a ≤ aᶜ ↔ a = ⊥

full_name: ne_compl_self
code: @[simp] theorem ne_compl_self [Nontrivial α] : a ≠ aᶜ 
goal: a ≠ aᶜ

full_name: compl_ne_self
code: @[simp] theorem compl_ne_self [Nontrivial α] : aᶜ ≠ a 
goal: aᶜ ≠ a

full_name: lt_compl_self
code: @[simp] theorem lt_compl_self [Nontrivial α] : a < aᶜ ↔ a = ⊥ 
goal: a < aᶜ ↔ a = ⊥

full_name: le_compl_compl
code: theorem le_compl_compl : a ≤ aᶜᶜ 
goal: a ≤ aᶜᶜ

full_name: compl_anti
code: theorem compl_anti : Antitone (compl : α → α) 
goal: Antitone compl

full_name: compl_le_compl
code: @[gcongr]
theorem compl_le_compl (h : a ≤ b) : bᶜ ≤ aᶜ 
goal: bᶜ ≤ aᶜ

full_name: compl_compl_compl
code: @[simp]
theorem compl_compl_compl (a : α) : aᶜᶜᶜ = aᶜ 
goal: aᶜᶜᶜ = aᶜ

full_name: disjoint_compl_compl_left_iff
code: @[simp]
theorem disjoint_compl_compl_left_iff : Disjoint aᶜᶜ b ↔ Disjoint a b 
goal: Disjoint aᶜᶜ b ↔ Disjoint a b

full_name: disjoint_compl_compl_right_iff
code: @[simp]
theorem disjoint_compl_compl_right_iff : Disjoint a bᶜᶜ ↔ Disjoint a b 
goal: Disjoint a bᶜᶜ ↔ Disjoint a b

full_name: compl_sup_compl_le
code: theorem compl_sup_compl_le : aᶜ ⊔ bᶜ ≤ (a ⊓ b)ᶜ 
goal: aᶜ ⊔ bᶜ ≤ (a ⊓ b)ᶜ

full_name: compl_compl_inf_distrib
code: theorem compl_compl_inf_distrib (a b : α) : (a ⊓ b)ᶜᶜ = aᶜᶜ ⊓ bᶜᶜ 
goal: (a ⊓ b)ᶜᶜ = aᶜᶜ ⊓ bᶜᶜ

full_name: compl_compl_himp_distrib
code: theorem compl_compl_himp_distrib (a b : α) : (a ⇨ b)ᶜᶜ = aᶜᶜ ⇨ bᶜᶜ 
goal: (a ⇨ b)ᶜᶜ = aᶜᶜ ⇨ bᶜᶜ

full_name: OrderDual.instCoheytingAlgebra
code: instance OrderDual.instCoheytingAlgebra : CoheytingAlgebra αᵒᵈ 
goal: CoheytingAlgebra αᵒᵈ

full_name: ofDual_hnot
code: @[simp]
theorem ofDual_hnot (a : αᵒᵈ) : ofDual (￢a) = (ofDual a)ᶜ 
goal: OrderDual.ofDual (￢a) = (OrderDual.ofDual a)ᶜ

full_name: toDual_compl
code: @[simp]
theorem toDual_compl (a : α) : toDual aᶜ = ￢toDual a 
goal: OrderDual.toDual aᶜ = ￢OrderDual.toDual a

full_name: Prod.instHeytingAlgebra
code: instance Prod.instHeytingAlgebra [HeytingAlgebra β] : HeytingAlgebra (α × β) 
goal: HeytingAlgebra (α × β)

full_name: Pi.instHeytingAlgebra
code: instance Pi.instHeytingAlgebra {α : ι → Type*} [∀ i, HeytingAlgebra (α i)] :
    HeytingAlgebra (∀ i, α i) 
goal: HeytingAlgebra ((i : ι) → α i)

full_name: top_sdiff'
code: @[simp]
theorem top_sdiff' (a : α) : ⊤ \ a = ￢a 
goal: ⊤ \ a = ￢a

full_name: sdiff_top
code: @[simp]
theorem sdiff_top (a : α) : a \ ⊤ = ⊥ 
goal: a \ ⊤ = ⊥

full_name: hnot_inf_distrib
code: theorem hnot_inf_distrib (a b : α) : ￢(a ⊓ b) = ￢a ⊔ ￢b 
goal: ￢(a ⊓ b) = ￢a ⊔ ￢b

full_name: sdiff_le_hnot
code: theorem sdiff_le_hnot : a \ b ≤ ￢b 
goal: a \ b ≤ ￢b

full_name: sdiff_le_inf_hnot
code: theorem sdiff_le_inf_hnot : a \ b ≤ a ⊓ ￢b 
goal: a \ b ≤ a ⊓ ￢b

full_name: CoheytingAlgebra.toDistribLattice
code: instance (priority := 100) CoheytingAlgebra.toDistribLattice : DistribLattice α 
goal: DistribLattice α

full_name: hnot_sdiff
code: @[simp]
theorem hnot_sdiff (a : α) : ￢a \ a = ￢a 
goal: ￢a \ a = ￢a

full_name: hnot_sdiff_comm
code: theorem hnot_sdiff_comm (a b : α) : ￢a \ b = ￢b \ a 
goal: ￢a \ b = ￢b \ a

full_name: hnot_le_iff_codisjoint_right
code: theorem hnot_le_iff_codisjoint_right : ￢a ≤ b ↔ Codisjoint a b 
goal: ￢a ≤ b ↔ Codisjoint a b

full_name: hnot_le_iff_codisjoint_left
code: theorem hnot_le_iff_codisjoint_left : ￢a ≤ b ↔ Codisjoint b a 
goal: ￢a ≤ b ↔ Codisjoint b a

full_name: hnot_le_comm
code: theorem hnot_le_comm : ￢a ≤ b ↔ ￢b ≤ a 
goal: ￢a ≤ b ↔ ￢b ≤ a

full_name: codisjoint_hnot_right
code: theorem codisjoint_hnot_right : Codisjoint a (￢a) 
goal: Codisjoint a (￢a)

full_name: codisjoint_hnot_left
code: theorem codisjoint_hnot_left : Codisjoint (￢a) a 
goal: Codisjoint (￢a) a

full_name: LE.le.codisjoint_hnot_left
code: theorem LE.le.codisjoint_hnot_left (h : a ≤ b) : Codisjoint (￢a) b 
goal: Codisjoint (￢a) b

full_name: LE.le.codisjoint_hnot_right
code: theorem LE.le.codisjoint_hnot_right (h : b ≤ a) : Codisjoint a (￢b) 
goal: Codisjoint a (￢b)

full_name: IsCompl.hnot_eq
code: theorem IsCompl.hnot_eq (h : IsCompl a b) : ￢a = b 
goal: ￢a = b

full_name: IsCompl.eq_hnot
code: theorem IsCompl.eq_hnot (h : IsCompl a b) : a = ￢b 
goal: a = ￢b

full_name: sup_hnot_self
code: @[simp]
theorem sup_hnot_self (a : α) : a ⊔ ￢a = ⊤ 
goal: a ⊔ ￢a = ⊤

full_name: hnot_sup_self
code: @[simp]
theorem hnot_sup_self (a : α) : ￢a ⊔ a = ⊤ 
goal: ￢a ⊔ a = ⊤

full_name: hnot_bot
code: @[simp]
theorem hnot_bot : ￢(⊥ : α) = ⊤ 
goal: ￢⊥ = ⊤

full_name: hnot_top
code: @[simp]
theorem hnot_top : ￢(⊤ : α) = ⊥ 
goal: ￢⊤ = ⊥

full_name: hnot_hnot_le
code: theorem hnot_hnot_le : ￢￢a ≤ a 
goal: ￢￢a ≤ a

full_name: hnot_anti
code: theorem hnot_anti : Antitone (hnot : α → α) 
goal: Antitone hnot

full_name: hnot_le_hnot
code: theorem hnot_le_hnot (h : a ≤ b) : ￢b ≤ ￢a 
goal: ￢b ≤ ￢a

full_name: hnot_hnot_hnot
code: @[simp]
theorem hnot_hnot_hnot (a : α) : ￢￢￢a = ￢a 
goal: ￢￢￢a = ￢a

full_name: codisjoint_hnot_hnot_left_iff
code: @[simp]
theorem codisjoint_hnot_hnot_left_iff : Codisjoint (￢￢a) b ↔ Codisjoint a b 
goal: Codisjoint (￢￢a) b ↔ Codisjoint a b

full_name: codisjoint_hnot_hnot_right_iff
code: @[simp]
theorem codisjoint_hnot_hnot_right_iff : Codisjoint a (￢￢b) ↔ Codisjoint a b 
goal: Codisjoint a (￢￢b) ↔ Codisjoint a b

full_name: le_hnot_inf_hnot
code: theorem le_hnot_inf_hnot : ￢(a ⊔ b) ≤ ￢a ⊓ ￢b 
goal: ￢(a ⊔ b) ≤ ￢a ⊓ ￢b

full_name: hnot_hnot_sup_distrib
code: theorem hnot_hnot_sup_distrib (a b : α) : ￢￢(a ⊔ b) = ￢￢a ⊔ ￢￢b 
goal: ￢￢(a ⊔ b) = ￢￢a ⊔ ￢￢b

full_name: hnot_hnot_sdiff_distrib
code: theorem hnot_hnot_sdiff_distrib (a b : α) : ￢￢(a \ b) = ￢￢a \ ￢￢b 
goal: ￢￢(a \ b) = ￢￢a \ ￢￢b

full_name: OrderDual.instHeytingAlgebra
code: instance OrderDual.instHeytingAlgebra : HeytingAlgebra αᵒᵈ 
goal: HeytingAlgebra αᵒᵈ

full_name: ofDual_compl
code: @[simp]
theorem ofDual_compl (a : αᵒᵈ) : ofDual aᶜ = ￢ofDual a 
goal: OrderDual.ofDual aᶜ = ￢OrderDual.ofDual a

full_name: ofDual_himp
code: @[simp]
theorem ofDual_himp (a b : αᵒᵈ) : ofDual (a ⇨ b) = ofDual b \ ofDual a 
goal: OrderDual.ofDual (a ⇨ b) = OrderDual.ofDual b \ OrderDual.ofDual a

full_name: toDual_hnot
code: @[simp]
theorem toDual_hnot (a : α) : toDual (￢a) = (toDual a)ᶜ 
goal: OrderDual.toDual (￢a) = (OrderDual.toDual a)ᶜ

full_name: toDual_sdiff
code: @[simp]
theorem toDual_sdiff (a b : α) : toDual (a \ b) = toDual b ⇨ toDual a 
goal: OrderDual.toDual (a \ b) = OrderDual.toDual b ⇨ OrderDual.toDual a

full_name: Prod.instCoheytingAlgebra
code: instance Prod.instCoheytingAlgebra [CoheytingAlgebra β] : CoheytingAlgebra (α × β) 
goal: CoheytingAlgebra (α × β)

full_name: Pi.instCoheytingAlgebra
code: instance Pi.instCoheytingAlgebra {α : ι → Type*} [∀ i, CoheytingAlgebra (α i)] :
    CoheytingAlgebra (∀ i, α i) 
goal: CoheytingAlgebra ((i : ι) → α i)

full_name: compl_le_hnot
code: theorem compl_le_hnot : aᶜ ≤ ￢a 
goal: aᶜ ≤ ￢a

full_name: Prop.instHeytingAlgebra
code: /-- Propositions form a Heyting algebra with implication as Heyting implication and negation as
complement. -/
instance Prop.instHeytingAlgebra : HeytingAlgebra Prop 
goal: HeytingAlgebra Prop

full_name: himp_iff_imp
code: @[simp]
theorem himp_iff_imp (p q : Prop) : p ⇨ q ↔ p → q 
goal: p ⇨ q ↔ p → q

full_name: compl_iff_not
code: @[simp]
theorem compl_iff_not (p : Prop) : pᶜ ↔ ¬p 
goal: pᶜ ↔ ¬p

full_name: LinearOrder.toBiheytingAlgebra
code: /-- A bounded linear order is a bi-Heyting algebra by setting
* `a ⇨ b = ⊤` if `a ≤ b` and `a ⇨ b = b` otherwise.
* `a \ b = ⊥` if `a ≤ b` and `a \ b = a` otherwise. -/
abbrev LinearOrder.toBiheytingAlgebra [LinearOrder α] [BoundedOrder α] : BiheytingAlgebra α 
goal: BiheytingAlgebra α

full_name: OrderDual.instBiheytingAlgebra
code: instance OrderDual.instBiheytingAlgebra [BiheytingAlgebra α] : BiheytingAlgebra αᵒᵈ 
goal: BiheytingAlgebra αᵒᵈ

full_name: Prod.instBiheytingAlgebra
code: instance Prod.instBiheytingAlgebra [BiheytingAlgebra α] [BiheytingAlgebra β] :
    BiheytingAlgebra (α × β) 
goal: BiheytingAlgebra (α × β)

full_name: Pi.instBiheytingAlgebra
code: instance Pi.instBiheytingAlgebra {α : ι → Type*} [∀ i, BiheytingAlgebra (α i)] :
    BiheytingAlgebra (∀ i, α i) 
goal: BiheytingAlgebra ((i : ι) → α i)

full_name: Function.Injective.generalizedHeytingAlgebra
code: /-- Pullback a `GeneralizedHeytingAlgebra` along an injection. -/
protected abbrev Function.Injective.generalizedHeytingAlgebra [Sup α] [Inf α] [Top α]
    [HImp α] [GeneralizedHeytingAlgebra β] (f : α → β) (hf : Injective f)
    (map_sup : ∀ a b, f (a ⊔ b) = f a ⊔ f b) (map_inf : ∀ a b, f (a ⊓ b) = f a ⊓ f b)
    (map_top : f ⊤ = ⊤) (map_himp : ∀ a b, f (a ⇨ b) = f a ⇨ f b) : GeneralizedHeytingAlgebra α 
goal: GeneralizedHeytingAlgebra α

full_name: Function.Injective.generalizedCoheytingAlgebra
code: /-- Pullback a `GeneralizedCoheytingAlgebra` along an injection. -/
protected abbrev Function.Injective.generalizedCoheytingAlgebra [Sup α] [Inf α] [Bot α]
    [SDiff α] [GeneralizedCoheytingAlgebra β] (f : α → β) (hf : Injective f)
    (map_sup : ∀ a b, f (a ⊔ b) = f a ⊔ f b) (map_inf : ∀ a b, f (a ⊓ b) = f a ⊓ f b)
    (map_bot : f ⊥ = ⊥) (map_sdiff : ∀ a b, f (a \ b) = f a \ f b) :
    GeneralizedCoheytingAlgebra α 
goal: GeneralizedCoheytingAlgebra α

full_name: Function.Injective.heytingAlgebra
code: /-- Pullback a `HeytingAlgebra` along an injection. -/
protected abbrev Function.Injective.heytingAlgebra [Sup α] [Inf α] [Top α] [Bot α]
    [HasCompl α] [HImp α] [HeytingAlgebra β] (f : α → β) (hf : Injective f)
    (map_sup : ∀ a b, f (a ⊔ b) = f a ⊔ f b) (map_inf : ∀ a b, f (a ⊓ b) = f a ⊓ f b)
    (map_top : f ⊤ = ⊤) (map_bot : f ⊥ = ⊥) (map_compl : ∀ a, f aᶜ = (f a)ᶜ)
    (map_himp : ∀ a b, f (a ⇨ b) = f a ⇨ f b) : HeytingAlgebra α 
goal: HeytingAlgebra α

full_name: Function.Injective.coheytingAlgebra
code: /-- Pullback a `CoheytingAlgebra` along an injection. -/
protected abbrev Function.Injective.coheytingAlgebra [Sup α] [Inf α] [Top α] [Bot α]
    [HNot α] [SDiff α] [CoheytingAlgebra β] (f : α → β) (hf : Injective f)
    (map_sup : ∀ a b, f (a ⊔ b) = f a ⊔ f b) (map_inf : ∀ a b, f (a ⊓ b) = f a ⊓ f b)
    (map_top : f ⊤ = ⊤) (map_bot : f ⊥ = ⊥) (map_hnot : ∀ a, f (￢a) = ￢f a)
    (map_sdiff : ∀ a b, f (a \ b) = f a \ f b) : CoheytingAlgebra α 
goal: CoheytingAlgebra α

full_name: Function.Injective.biheytingAlgebra
code: /-- Pullback a `BiheytingAlgebra` along an injection. -/
protected abbrev Function.Injective.biheytingAlgebra [Sup α] [Inf α] [Top α] [Bot α]
    [HasCompl α] [HNot α] [HImp α] [SDiff α] [BiheytingAlgebra β] (f : α → β)
    (hf : Injective f) (map_sup : ∀ a b, f (a ⊔ b) = f a ⊔ f b)
    (map_inf : ∀ a b, f (a ⊓ b) = f a ⊓ f b) (map_top : f ⊤ = ⊤) (map_bot : f ⊥ = ⊥)
    (map_compl : ∀ a, f aᶜ = (f a)ᶜ) (map_hnot : ∀ a, f (￢a) = ￢f a)
    (map_himp : ∀ a b, f (a ⇨ b) = f a ⇨ f b) (map_sdiff : ∀ a b, f (a \ b) = f a \ f b) :
    BiheytingAlgebra α 
goal: BiheytingAlgebra α

full_name: PUnit.instBiheytingAlgebra
code: instance instBiheytingAlgebra : BiheytingAlgebra PUnit.{u+1} 
goal: BiheytingAlgebra PUnit.{u + 1}

full_name: PUnit.top_eq
code: @[simp]
theorem top_eq : (⊤ : PUnit) = unit 
goal: ⊤ = PUnit.unit

full_name: PUnit.bot_eq
code: @[simp]
theorem bot_eq : (⊥ : PUnit) = unit 
goal: ⊥ = PUnit.unit

full_name: PUnit.sup_eq
code: @[simp, nolint simpNF]
theorem sup_eq : a ⊔ b = unit 
goal: a ⊔ b = PUnit.unit

full_name: PUnit.inf_eq
code: @[simp, nolint simpNF]
theorem inf_eq : a ⊓ b = unit 
goal: a ⊓ b = PUnit.unit

full_name: PUnit.compl_eq
code: @[simp]
theorem compl_eq : aᶜ = unit 
goal: aᶜ = PUnit.unit

full_name: PUnit.sdiff_eq
code: @[simp, nolint simpNF]
theorem sdiff_eq : a \ b = unit 
goal: a \ b = PUnit.unit

full_name: PUnit.hnot_eq
code: @[simp, nolint simpNF]
theorem hnot_eq : ￢a = unit 
goal: ￢a = PUnit.unit

full_name: PUnit.himp_eq
code: @[simp, nolint simpNF]
theorem himp_eq : a ⇨ b = unit 
goal: a ⇨ b = PUnit.unit