Additional Complete Lattice Operations

Extensions to Lean.Order.CompleteLattice providing additional operations needed for program verification.

noncomputable def Lean.Order.top {α : Type u} [CompleteLattice α] : α

Top element of a complete lattice (supremum of all elements)

Equations

• Lean.Order.top = Lean.Order.CompleteLattice.sup fun (x : α) => True

def Lean.Order.«term⊤» : ParserDescr

Top element of a complete lattice (supremum of all elements)

Equations

• Lean.Order.«term⊤» = Lean.ParserDescr.node `Lean.Order.«term⊤» 1024 (Lean.ParserDescr.symbol "⊤")

theorem Lean.Order.le_top {α : Type u} [CompleteLattice α] (x : α) : PartialOrder.rel x top

@[implicit_reducible]

noncomputable def Lean.Order.instCCPO_std {α : Type u} [CompleteLattice α] : CCPO α

A complete lattice is a chain-complete partial order.

Equations

• Lean.Order.instCCPO_std = { toPartialOrder := inst✝.toPartialOrder, has_csup := ⋯ }

noncomputable def Lean.Order.meet {α : Type u} [CompleteLattice α] (x y : α) : α

Binary meet (infimum)

Equations

• Lean.Order.meet x y = Lean.Order.inf fun (z : α) => z = x ∨ z = y

def Lean.Order.«term_⊓_» : TrailingParserDescr

Binary meet (infimum)

Equations

• Lean.Order.«term_⊓_» = Lean.ParserDescr.trailingNode `Lean.Order.«term_⊓_» 70 70 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ⊓ ") (Lean.ParserDescr.cat `term 71))

theorem Lean.Order.meet_le_left {α : Type u} [CompleteLattice α] (x y : α) : PartialOrder.rel (meet x y) x

theorem Lean.Order.meet_le_right {α : Type u} [CompleteLattice α] (x y : α) : PartialOrder.rel (meet x y) y

theorem Lean.Order.le_meet {α : Type u} [CompleteLattice α] (x y z : α) : PartialOrder.rel x y → PartialOrder.rel x z → PartialOrder.rel x (meet y z)

noncomputable def Lean.Order.join {α : Type u} [CompleteLattice α] (x y : α) : α

Binary join (supremum)

Equations

• Lean.Order.join x y = Lean.Order.CompleteLattice.sup fun (z : α) => z = x ∨ z = y

def Lean.Order.«term_⊔_» : TrailingParserDescr

Binary join (supremum)

Equations

• Lean.Order.«term_⊔_» = Lean.ParserDescr.trailingNode `Lean.Order.«term_⊔_» 65 65 (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol " ⊔ ") (Lean.ParserDescr.cat `term 66))

theorem Lean.Order.left_le_join {α : Type u} [CompleteLattice α] (x y : α) : PartialOrder.rel x (join x y)

theorem Lean.Order.right_le_join {α : Type u} [CompleteLattice α] (x y : α) : PartialOrder.rel y (join x y)

theorem Lean.Order.join_le {α : Type u} [CompleteLattice α] (x y z : α) : PartialOrder.rel x z → PartialOrder.rel y z → PartialOrder.rel (join x y) z

noncomputable def Lean.Order.iInf {α : Type u} [CompleteLattice α] {ι : Type v} (f : ι → α) : α

Indexed infimum

Equations

• Lean.Order.iInf f = Lean.Order.inf fun (x : α) => ∃ (i : ι), f i = x

theorem Lean.Order.iInf_le {α : Type u} [CompleteLattice α] {ι : Type v} (f : ι → α) (i : ι) : PartialOrder.rel (iInf f) (f i)

theorem Lean.Order.le_iInf {α : Type u} [CompleteLattice α] {ι : Type v} (f : ι → α) (x : α) : (∀ (i : ι), PartialOrder.rel x (f i)) → PartialOrder.rel x (iInf f)

@[simp]

theorem Lean.Order.iInf_apply {ι : Type v} {σ : Type w} {β : Type u} [CompleteLattice β] (f : ι → σ → β) (s : σ) : iInf f s = iInf fun (i : ι) => f i s

Pointwise characterization of indexed infimum on function lattices.

noncomputable def Lean.Order.iSup {α : Type u} [CompleteLattice α] {ι : Type v} (f : ι → α) : α

Indexed supremum

Equations

• Lean.Order.iSup f = Lean.Order.CompleteLattice.sup fun (x : α) => ∃ (i : ι), f i = x

theorem Lean.Order.le_iSup {α : Type u} [CompleteLattice α] {ι : Type v} (f : ι → α) (i : ι) : PartialOrder.rel (f i) (iSup f)

theorem Lean.Order.iSup_le {α : Type u} [CompleteLattice α] {ι : Type v} (f : ι → α) (x : α) : (∀ (i : ι), PartialOrder.rel (f i) x) → PartialOrder.rel (iSup f) x

@[simp]

theorem Lean.Order.iSup_apply {ι : Type v} {σ : Type w} {β : Type u} [CompleteLattice β] (f : ι → σ → β) (s : σ) : iSup f s = iSup fun (i : ι) => f i s

Pointwise characterization of indexed supremum on function lattices.

theorem Lean.Order.sup_apply {σ : Type v} {β : Type w} [CompleteLattice β] (c : (σ → β) → Prop) (s : σ) : CompleteLattice.sup c s = CompleteLattice.sup fun (y : β) => ∃ (f : σ → β), c f ∧ f s = y

Pointwise characterization of CompleteLattice.sup on function lattices: (sup c) s = sup (fun y => ∃ f, c f ∧ f s = y).

@[simp]

theorem Lean.Order.meet_apply {σ : Type v} {β : Type w} [CompleteLattice β] (a b : σ → β) (s : σ) : meet a b s = meet (a s) (b s)

Pointwise characterization of binary meet on function lattices.

@[simp]

theorem Lean.Order.join_apply {σ : Type v} {β : Type w} [CompleteLattice β] (a b : σ → β) (s : σ) : join a b s = join (a s) (b s)

Pointwise characterization of binary join on function lattices.

@[simp]

theorem Lean.Order.top_apply {σ : Type v} {β : Type w} [CompleteLattice β] (s : σ) : top s = top

Pointwise characterization of ⊤ on a function lattice.

@[simp]

theorem Lean.Order.bot_apply {σ : Type v} {β : Type w} [CompleteLattice β] (s : σ) : bot s = bot

Pointwise characterization of ⊥ on a function lattice.

Prop Embedding into Partial Order

Embedding propositions into a partial order with top and bottom.

CompleteLattice instance for Prop

We define a CompleteLattice structure on Prop where:

• rel is implication (→)
• sup is existential quantification over the predicate

@[implicit_reducible]

instance Lean.Order.instPartialOrderProp_std : PartialOrder Prop

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Lean.Order.le_prop_eq_imp (p q : Prop) : PartialOrder.rel p q = (p → q)

def Lean.Order.propSup (c : Prop → Prop) : Prop

Supremum for Prop: true iff some element of the set is true

Equations

• Lean.Order.propSup c = ∃ (p : Prop), c p ∧ p

theorem Lean.Order.propSup_is_sup (c : Prop → Prop) : is_sup c (propSup c)

@[implicit_reducible]

instance Lean.Order.instCompleteLatticeProp_std : CompleteLattice Prop

Equations

• Lean.Order.instCompleteLatticeProp_std = { toPartialOrder := Lean.Order.instPartialOrderProp_std, has_sup := Lean.Order.instCompleteLatticeProp_std._proof_1 }

theorem Lean.Order.le_of_imp_top_le (x y : Prop) : (x → PartialOrder.rel top y) → PartialOrder.rel x y

theorem Lean.Order.top_le_prop (x : Prop) : x → PartialOrder.rel top x

theorem Lean.Order.le_of_right (x y : Prop) : y → PartialOrder.rel x y

theorem Lean.Order.of_top_le_prop {x : Prop} : PartialOrder.rel top x → x

theorem Lean.Order.true_le_of_top_le (x : Prop) : PartialOrder.rel top x → PartialOrder.rel True x

@[simp]

theorem Lean.Order.iInf_prop_eq_forall {ι : Type u} (f : ι → Prop) : iInf f = ∀ (i : ι), f i

@[simp]

theorem Lean.Order.iSup_prop_eq_exists {ι : Type u} (f : ι → Prop) : iSup f = ∃ (i : ι), f i

@[simp]

theorem Lean.Order.meet_prop_eq_and (a b : Prop) : meet a b = (a ∧ b)

@[simp]

theorem Lean.Order.join_prop_eq_or (a b : Prop) : join a b = (a ∨ b)

noncomputable def Lean.Order.CompleteLattice.ofProp {l : Type u_1} [CompleteLattice l] (p : Prop) : l

Embedding of propositions into an CompleteLattice type. ⌜p⌝ embeds p : Prop as ⊤ if p holds and ⊥ otherwise.

Equations

• Lean.Order.CompleteLattice.ofProp p = if p then Lean.Order.top else Lean.Order.bot

def Lean.Order.«term⌜_⌝» : ParserDescr

Embedding of propositions into an CompleteLattice type. ⌜p⌝ embeds p : Prop as ⊤ if p holds and ⊥ otherwise.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem Lean.Order.CompleteLattice.ofProp_true (l : Type v) [CompleteLattice l] : ofProp True = top

@[simp]

theorem Lean.Order.CompleteLattice.ofProp_false (l : Type v) [CompleteLattice l] : ofProp False = bot

theorem Lean.Order.CompleteLattice.ofProp_imp {l : Type u_1} [CompleteLattice l] (p₁ p₂ : Prop) : (p₁ → p₂) → PartialOrder.rel (ofProp p₁) (ofProp p₂)

@[simp]

theorem Lean.Order.CompleteLattice.ofProp_intro {l : Type u_1} [CompleteLattice l] (p : Prop) (h : l) : PartialOrder.rel (ofProp p) h = (p → PartialOrder.rel top h)

@[simp]

theorem Lean.Order.CompleteLattice.ofProp_intro_l {l : Type u_1} [CompleteLattice l] (p : Prop) (x y : l) : PartialOrder.rel (meet x (ofProp p)) y = (p → PartialOrder.rel x y)

@[simp]

theorem Lean.Order.CompleteLattice.ofProp_intro_r {l : Type u_1} [CompleteLattice l] (p : Prop) (x y : l) : PartialOrder.rel (meet (ofProp p) x) y = (p → PartialOrder.rel x y)

@[simp]

theorem Lean.Order.CompleteLattice.ofProp_apply {σ : Type v} {β : Type u} [CompleteLattice β] (p : Prop) (s : σ) : ofProp p s = ofProp p

Pointwise characterization of CompleteLattice.ofProp on a function lattice.

theorem Lean.Order.top_le_ofProp {l : Type u_1} [CompleteLattice l] (p : Prop) : p → PartialOrder.rel top (CompleteLattice.ofProp p)

theorem Lean.Order.le_ofProp {l : Type u_1} [CompleteLattice l] (x : l) (p : Prop) : p → PartialOrder.rel x (CompleteLattice.ofProp p)

x ⊑ ⌜p⌝ whenever p holds.

theorem Lean.Order.ofProp_le {l : Type u_1} [CompleteLattice l] (p : Prop) (rhs : l) : (p → PartialOrder.rel top rhs) → PartialOrder.rel (CompleteLattice.ofProp p) rhs

⌜p⌝ ⊑ rhs reduces to assuming p and proving ⊤ ⊑ rhs.

theorem Lean.Order.le_iff_forall_le {σ α : Type u} [PartialOrder α] {f g : σ → α} : PartialOrder.rel f g ↔ ∀ (s : σ), PartialOrder.rel (f s) (g s)

Entailment between functions is pointwise.

theorem Lean.Order.le_of_forall_le {σ α : Type u} [PartialOrder α] {f g : σ → α} : (∀ (s : σ), PartialOrder.rel (f s) (g s)) → PartialOrder.rel f g

Entailment between functions follows from pointwise entailment.

theorem Lean.Order.top_le_of_forall_top_le {σ α : Type u} [CompleteLattice α] {g : σ → α} : (∀ (s : σ), PartialOrder.rel top (g s)) → PartialOrder.rel top g

⊤ ⊑ g for a function g follows from pointwise ⊤ ⊑ g s.

@[simp]

theorem Lean.Order.top_prop_eq : top = True

The top element of the Prop lattice is True. Not a global @[simp] lemma: collapsing the lattice ⊤/⊥/⌜·⌝ to True/False/p would change how mvcgen discharge lattice goals. Tagged @[grind =] for use under grind.

@[simp]

theorem Lean.Order.bot_prop_eq : bot = False

The bottom element of the Prop lattice is False. See top_prop_eq for why this is not @[simp].

@[simp]

theorem Lean.Order.ofProp_prop_eq (p : Prop) : CompleteLattice.ofProp p = p

Embedding a proposition into the Prop lattice (⌜p⌝) is the proposition itself. See top_prop_eq for why this is not @[simp].