Documentation

Init.Internal.Order.Basic

This module contains some basic definitions and results from domain theory, intended to be used as the underlying construction of the partial_fixpoint feature. It is not meant to be used as a general purpose library for domain theory, but can be of interest to users who want to extend the partial_fixpoint machinery (e.g. mark more functions as monotone or register more monads).

This follows the corresponding Isabelle development, as also described in Alexander Krauss: Recursive Definitions of Monadic Functions.

class Lean.Order.PartialOrder (α : Sort u) :
Sort (max 1 u)

A partial order is a reflexive, transitive and antisymmetric relation.

This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

  • rel : ααProp

    A “less-or-equal-to” or “approximates” relation.

    This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

  • rel_refl {x : α} : rel x x

    The “less-or-equal-to” or “approximates” relation is reflexive.

  • rel_trans {x y z : α} : rel x yrel y zrel x z

    The “less-or-equal-to” or “approximates” relation is transitive.

  • rel_antisymm {x y : α} : rel x yrel y xx = y

    The “less-or-equal-to” or “approximates” relation is antisymmetric.

Instances

    A “less-or-equal-to” or “approximates” relation.

    This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

    Equations
      Instances For
        theorem Lean.Order.PartialOrder.rel_of_eq {α : Sort u} [PartialOrder α] {x y : α} (h : x = y) :
        rel x y
        def Lean.Order.chain {α : Sort u} [PartialOrder α] (c : αProp) :

        A chain is a totally ordered set (representing a set as a predicate).

        This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

        Equations
          Instances For
            class Lean.Order.CCPO (α : Sort u) extends Lean.Order.PartialOrder α :
            Sort (max 1 u)

            A chain-complete partial order (CCPO) is a partial order where every chain has a least upper bound.

            This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

            • rel : ααProp
            • rel_refl {x : α} : rel x x
            • rel_trans {x y z : α} : rel x yrel y zrel x z
            • rel_antisymm {x y : α} : rel x yrel y xx = y
            • csup : (αProp)α

              The least upper bound of a chain.

              This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

            • csup_spec {x : α} {c : αProp} (hc : chain c) : PartialOrder.rel (csup c) x ∀ (y : α), c yPartialOrder.rel y x

              csup c is the least upper bound of the chain c when all elements x that are at least as large as csup c are at least as large as all elements of c, and vice versa.

            Instances
              theorem Lean.Order.csup_le {α : Sort u} [CCPO α] {x : α} {c : αProp} (hchain : chain c) :
              (∀ (y : α), c yPartialOrder.rel y x)PartialOrder.rel (CCPO.csup c) x
              theorem Lean.Order.le_csup {α : Sort u} [CCPO α] {c : αProp} (hchain : chain c) {y : α} (hy : c y) :
              def Lean.Order.bot {α : Sort u} [CCPO α] :
              α

              The bottom element is the least upper bound of the empty chain.

              This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

              Equations
                Instances For
                  Equations
                    Instances For
                      theorem Lean.Order.bot_le {α : Sort u} [CCPO α] (x : α) :
                      class Lean.Order.CompleteLattice (α : Sort u) extends Lean.Order.PartialOrder α :
                      Sort (max 1 u)

                      A complete lattice is a partial order where every subset has a least upper bound.

                      Instances
                        theorem Lean.Order.sup_le {α : Sort u} [CompleteLattice α] {x : α} {c : αProp} :
                        (∀ (y : α), c yPartialOrder.rel y x)PartialOrder.rel (CompleteLattice.sup c) x
                        theorem Lean.Order.le_sup {α : Sort u} [CompleteLattice α] {c : αProp} {y : α} (hy : c y) :
                        def Lean.Order.inf {α : Sort u} [CompleteLattice α] (c : αProp) :
                        α
                        Equations
                          Instances For
                            theorem Lean.Order.inf_spec {α : Sort u} [CompleteLattice α] {x : α} {c : αProp} :
                            PartialOrder.rel x (inf c) ∀ (y : α), c yPartialOrder.rel x y
                            theorem Lean.Order.le_inf {α : Sort u} [CompleteLattice α] {x : α} {c : αProp} :
                            (∀ (y : α), c yPartialOrder.rel x y)PartialOrder.rel x (inf c)
                            theorem Lean.Order.inf_le {α : Sort u} [CompleteLattice α] {c : αProp} {y : α} (hy : c y) :
                            def Lean.Order.monotone {α : Sort u} [PartialOrder α] {β : Sort v} [PartialOrder β] (f : αβ) :

                            A function is monotone if it maps related elements to related elements.

                            This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                            Equations
                              Instances For
                                theorem Lean.Order.monotone_const {α : Sort u} [PartialOrder α] {β : Sort v} [PartialOrder β] (c : β) :
                                monotone fun (x : α) => c
                                theorem Lean.Order.monotone_id {α : Sort u} [PartialOrder α] :
                                monotone fun (x : α) => x
                                theorem Lean.Order.monotone_compose {α : Sort u} [PartialOrder α] {β : Sort v} [PartialOrder β] {γ : Sort w} [PartialOrder γ] {f : αβ} {g : βγ} (hf : monotone f) (hg : monotone g) :
                                monotone fun (x : α) => g (f x)
                                def Lean.Order.admissible {α : Sort u} [CCPO α] (P : αProp) :

                                A predicate is admissible if it can be transferred from the elements of a chain to the chains least upper bound. Such predicates can be used in fixpoint induction.

                                This definition implies P ⊥. Sometimes (e.g. in Isabelle) the empty chain is excluded from this definition, and P ⊥ is a separate condition of the induction predicate.

                                This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                Equations
                                  Instances For
                                    theorem Lean.Order.admissible_const_true {α : Sort u} [CCPO α] :
                                    admissible fun (x : α) => True
                                    theorem Lean.Order.admissible_and {α : Sort u} [CCPO α] (P Q : αProp) (hadm₁ : admissible P) (hadm₂ : admissible Q) :
                                    admissible fun (x : α) => P x Q x
                                    theorem Lean.Order.chain_conj {α : Sort u} [CCPO α] (c P : αProp) (hchain : chain c) :
                                    chain fun (x : α) => c x P x
                                    theorem Lean.Order.csup_conj {α : Sort u} [CCPO α] (c P : αProp) (hchain : chain c) (h : ∀ (x : α), c x (y : α), c y PartialOrder.rel x y P y) :
                                    CCPO.csup c = CCPO.csup fun (x : α) => c x P x
                                    theorem Lean.Order.admissible_or {α : Sort u} [CCPO α] (P Q : αProp) (hadm₁ : admissible P) (hadm₂ : admissible Q) :
                                    admissible fun (x : α) => P x Q x
                                    def Lean.Order.admissible_pi {α : Sort u} [CCPO α] {β : Sort u_1} (P : αβProp) (hadm₁ : ∀ (y : β), admissible fun (x : α) => P x y) :
                                    admissible fun (x : α) => ∀ (y : β), P x y
                                    Equations
                                      Instances For
                                        def Lean.Order.lfp {α : Sort u} [CompleteLattice α] (f : αα) :
                                        α
                                        Equations
                                          Instances For
                                            def Lean.Order.lfp_monotone {α : Sort u} [CompleteLattice α] (f : αα) (hm : monotone f) :
                                            α
                                            Equations
                                              Instances For
                                                theorem Lean.Order.lfp_prefixed {α : Sort u} [CompleteLattice α] {f : αα} {hm : monotone f} :
                                                theorem Lean.Order.lfp_postfixed {α : Sort u} [CompleteLattice α] {f : αα} {hm : monotone f} :
                                                theorem Lean.Order.lfp_fix {α : Sort u} [CompleteLattice α] {f : αα} (hm : monotone f) :
                                                lfp f = f (lfp f)
                                                theorem Lean.Order.lfp_monotone_fix {α : Sort u} [CompleteLattice α] {f : αα} {hm : monotone f} :
                                                theorem Lean.Order.lfp_le_of_le {α : Sort u} [CompleteLattice α] {x : α} {f : αα} :

                                                Park induction principle for least fixpoint. In general, this construction does not require monotonicity of f. Monotonicity is required to show that lfp f is indeed a fixpoint of f.

                                                theorem Lean.Order.lfp_le_of_le_monotone {α : Sort u} [CompleteLattice α] (f : αα) {hm : monotone f} (x : α) :

                                                Park induction for least fixpoint of a monotone function f. Takes an explicit witness of f being monotone.

                                                inductive Lean.Order.iterates {α : Sort u} [CCPO α] (f : αα) :
                                                αProp

                                                The transfinite iteration of a function f is a set that is and is closed under application of f and csup.

                                                This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                                Instances For
                                                  theorem Lean.Order.chain_iterates {α : Sort u} [CCPO α] {f : αα} (hf : monotone f) :
                                                  theorem Lean.Order.rel_f_of_iterates {α : Sort u} [CCPO α] {f : αα} (hf : monotone f) {x : α} (hx : iterates f x) :
                                                  def Lean.Order.fix {α : Sort u} [CCPO α] (f : αα) (hmono : monotone f) :
                                                  α

                                                  The least fixpoint of a monotone function is the least upper bound of its transfinite iteration.

                                                  The monotone f assumption is not strictly necessarily for the definition, but without this the definition is not very meaningful and it simplifies applying theorems like fix_eq if every use of fix already has the monotonicty requirement.

                                                  This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                                  Equations
                                                    Instances For
                                                      theorem Lean.Order.fix_eq {α : Sort u} [CCPO α] {f : αα} (hf : monotone f) :
                                                      fix f hf = f (fix f hf)

                                                      The main fixpoint theorem for fixedpoints of monotone functions in chain-complete partial orders.

                                                      This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                                      theorem Lean.Order.fix_induct {α : Sort u} [CCPO α] {f : αα} (hf : monotone f) (motive : αProp) (hadm : admissible motive) (h : ∀ (x : α), motive xmotive (f x)) :
                                                      motive (fix f hf)

                                                      The fixpoint induction theme: An admissible predicate holds for a least fixpoint if it is preserved by the fixpoint's function.

                                                      This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                                      instance Lean.Order.instOrderPi {α : Sort u} {β : αSort v} [(x : α) → PartialOrder (β x)] :
                                                      PartialOrder ((x : α) → β x)
                                                      Equations
                                                        theorem Lean.Order.monotone_of_monotone_apply {α : Sort u} {β : αSort v} {γ : Sort w} [PartialOrder γ] [(x : α) → PartialOrder (β x)] (f : γ(x : α) → β x) (h : ∀ (y : α), monotone fun (x : γ) => f x y) :
                                                        theorem Lean.Order.monotone_apply {α : Sort u} {β : αSort v} {γ : Sort w} [PartialOrder γ] [(x : α) → PartialOrder (β x)] (a : α) (f : γ(x : α) → β x) (h : monotone f) :
                                                        monotone fun (x : γ) => f x a
                                                        theorem Lean.Order.chain_apply {α : Sort u} {β : αSort v} [(x : α) → PartialOrder (β x)] {c : ((x : α) → β x)Prop} (hc : chain c) (x : α) :
                                                        chain fun (y : β x) => (f : (x : α) → β x), c f f x = y
                                                        def Lean.Order.fun_csup {α : Sort u} {β : αSort v} [(x : α) → CCPO (β x)] (c : ((x : α) → β x)Prop) (x : α) :
                                                        β x
                                                        Equations
                                                          Instances For
                                                            def Lean.Order.fun_sup {α : Sort u} {β : αSort v} [(x : α) → CompleteLattice (β x)] (c : ((x : α) → β x)Prop) (x : α) :
                                                            β x
                                                            Equations
                                                              Instances For
                                                                instance Lean.Order.instCCPOPi {α : Sort u} {β : αSort v} [(x : α) → CCPO (β x)] :
                                                                CCPO ((x : α) → β x)
                                                                Equations
                                                                  instance Lean.Order.instCompleteLatticePi {α : Sort u} {β : αSort v} [(x : α) → CompleteLattice (β x)] :
                                                                  CompleteLattice ((x : α) → β x)
                                                                  Equations
                                                                    def Lean.Order.admissible_apply {α : Sort u} {β : αSort v} [(x : α) → CCPO (β x)] (P : (x : α) → β xProp) (x : α) (hadm : admissible (P x)) :
                                                                    admissible fun (f : (x : α) → β x) => P x (f x)
                                                                    Equations
                                                                      Instances For
                                                                        def Lean.Order.admissible_pi_apply {α : Sort u} {β : αSort v} [(x : α) → CCPO (β x)] (P : (x : α) → β xProp) (hadm : ∀ (x : α), admissible (P x)) :
                                                                        admissible fun (f : (x : α) → β x) => ∀ (x : α), P x (f x)
                                                                        Equations
                                                                          Instances For
                                                                            theorem Lean.Order.monotone_letFun {α : Sort u} {β : Sort v} {γ : Sort w} [PartialOrder α] [PartialOrder β] (v : γ) (k : αγβ) (hmono : ∀ (y : γ), monotone fun (x : α) => k x y) :
                                                                            monotone fun (x : α) => letFun v (k x)
                                                                            theorem Lean.Order.monotone_ite {α : Sort u} {β : Sort v} [PartialOrder α] [PartialOrder β] (c : Prop) [Decidable c] (k₁ k₂ : αβ) (hmono₁ : monotone k₁) (hmono₂ : monotone k₂) :
                                                                            monotone fun (x : α) => if c then k₁ x else k₂ x
                                                                            theorem Lean.Order.monotone_dite {α : Sort u} {β : Sort v} [PartialOrder α] [PartialOrder β] (c : Prop) [Decidable c] (k₁ : αcβ) (k₂ : α¬cβ) (hmono₁ : monotone k₁) (hmono₂ : monotone k₂) :
                                                                            monotone fun (x : α) => dite c (k₁ x) (k₂ x)
                                                                            Equations
                                                                              theorem Lean.Order.PProd.monotone_mk {α : Sort u} {β : Sort v} {γ : Sort w} [PartialOrder α] [PartialOrder β] [PartialOrder γ] {f : γα} {g : γβ} (hf : monotone f) (hg : monotone g) :
                                                                              monotone fun (x : γ) => f x, g x
                                                                              theorem Lean.Order.PProd.monotone_fst {α : Sort u} {β : Sort v} {γ : Sort w} [PartialOrder α] [PartialOrder β] [PartialOrder γ] {f : γα ×' β} (hf : monotone f) :
                                                                              monotone fun (x : γ) => (f x).fst
                                                                              theorem Lean.Order.PProd.monotone_snd {α : Sort u} {β : Sort v} {γ : Sort w} [PartialOrder α] [PartialOrder β] [PartialOrder γ] {f : γα ×' β} (hf : monotone f) :
                                                                              monotone fun (x : γ) => (f x).snd
                                                                              def Lean.Order.PProd.chain.fst {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (c : α ×' βProp) :
                                                                              αProp
                                                                              Equations
                                                                                Instances For
                                                                                  def Lean.Order.PProd.chain.snd {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (c : α ×' βProp) :
                                                                                  βProp
                                                                                  Equations
                                                                                    Instances For
                                                                                      def Lean.Order.PProd.fst {α : Sort u} {β : Sort v} [CompleteLattice α] [CompleteLattice β] (c : α ×' βProp) :
                                                                                      αProp
                                                                                      Equations
                                                                                        Instances For
                                                                                          def Lean.Order.PProd.snd {α : Sort u} {β : Sort v} [CompleteLattice α] [CompleteLattice β] (c : α ×' βProp) :
                                                                                          βProp
                                                                                          Equations
                                                                                            Instances For
                                                                                              theorem Lean.Order.PProd.chain.chain_fst {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] {c : α ×' βProp} (hchain : chain c) :
                                                                                              theorem Lean.Order.PProd.chain.chain_snd {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] {c : α ×' βProp} (hchain : chain c) :
                                                                                              instance Lean.Order.instCCPOPProd {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] :
                                                                                              CCPO (α ×' β)
                                                                                              Equations
                                                                                                theorem Lean.Order.admissible_pprod_fst {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (P : αProp) (hadm : admissible P) :
                                                                                                admissible fun (x : α ×' β) => P x.fst
                                                                                                theorem Lean.Order.admissible_pprod_snd {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (P : βProp) (hadm : admissible P) :
                                                                                                admissible fun (x : α ×' β) => P x.snd
                                                                                                def Lean.Order.FlatOrder {α : Sort u} (b : α) :

                                                                                                FlatOrder b wraps the type α with the flat partial order generated by ∀ x, b ⊑ x.

                                                                                                This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                                                                                Equations
                                                                                                  Instances For
                                                                                                    inductive Lean.Order.FlatOrder.rel {α : Sort u} {b : α} (x y : FlatOrder b) :

                                                                                                    The flat partial order generated by ∀ x, b ⊑ x.

                                                                                                    This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                                                                                    Instances For
                                                                                                      Equations
                                                                                                        noncomputable def Lean.Order.flat_csup {α : Sort u} {b : α} (c : FlatOrder bProp) :
                                                                                                        Equations
                                                                                                          Instances For
                                                                                                            noncomputable instance Lean.Order.FlatOrder.instCCPO {α : Sort u} {b : α} :
                                                                                                            Equations
                                                                                                              theorem Lean.Order.admissible_flatOrder {α : Sort u} {b : α} (P : FlatOrder bProp) (hnot : P b) :
                                                                                                              class Lean.Order.MonoBind (m : Type u → Type v) [Bind m] [(α : Type u) → PartialOrder (m α)] :

                                                                                                              The class MonoBind m indicates that every m α has a PartialOrder, and that the bind operation on m is monotone in both arguments with regard to that order.

                                                                                                              This is intended to be used in the construction of partial_fixpoint, and not meant to be used otherwise.

                                                                                                              Instances
                                                                                                                theorem Lean.Order.monotone_bind (m : Type u → Type v) [Bind m] [(α : Type u) → PartialOrder (m α)] [MonoBind m] {α β : Type u} {γ : Type w} [PartialOrder γ] (f : γm α) (g : γαm β) (hmono₁ : monotone f) (hmono₂ : monotone g) :
                                                                                                                monotone fun (x : γ) => f x >>= g x
                                                                                                                noncomputable instance Lean.Order.instCCPOOption {α : Type u_1} :
                                                                                                                Equations
                                                                                                                  theorem Lean.Order.Option.admissible_eq_some {α : Type u_1} (P : Prop) (y : α) :
                                                                                                                  admissible fun (x : Option α) => x = some yP
                                                                                                                  instance Lean.Order.instPartialOrderExceptTOfMonad {m : Type u_1 → Type u_2} {ε α : Type u_1} [Monad m] [inst : (α : Type u_1) → PartialOrder (m α)] :
                                                                                                                  Equations
                                                                                                                    instance Lean.Order.instCCPOExceptTOfMonadOfPartialOrder {m : Type u_1 → Type u_2} {ε α : Type u_1} [Monad m] [(α : Type u_1) → PartialOrder (m α)] [inst : (α : Type u_1) → CCPO (m α)] :
                                                                                                                    CCPO (ExceptT ε m α)
                                                                                                                    Equations
                                                                                                                      instance Lean.Order.instMonoBindExceptTOfCCPO {m : Type u_1 → Type u_2} {ε : Type u_1} [Monad m] [(α : Type u_1) → PartialOrder (m α)] [(α : Type u_1) → CCPO (m α)] [MonoBind m] :
                                                                                                                      Equations
                                                                                                                        Instances For
                                                                                                                          theorem Lean.Order.implication_order_monotone_exists {α : Sort u_1} [PartialOrder α] {β : Sort u_2} (f : αβImplicationOrder) (h : monotone f) :
                                                                                                                          monotone fun (x : α) => Exists (f x)
                                                                                                                          theorem Lean.Order.implication_order_monotone_forall {α : Sort u_1} [PartialOrder α] {β : Sort u_2} (f : αβImplicationOrder) (h : monotone f) :
                                                                                                                          monotone fun (x : α) => ∀ (y : β), f x y
                                                                                                                          theorem Lean.Order.implication_order_monotone_and {α : Sort u_1} [PartialOrder α] (f₁ f₂ : αImplicationOrder) (h₁ : monotone f₁) (h₂ : monotone f₂) :
                                                                                                                          monotone fun (x : α) => f₁ x f₂ x
                                                                                                                          theorem Lean.Order.implication_order_monotone_or {α : Sort u_1} [PartialOrder α] (f₁ f₂ : αImplicationOrder) (h₁ : monotone f₁) (h₂ : monotone f₂) :
                                                                                                                          monotone fun (x : α) => f₁ x f₂ x
                                                                                                                          theorem Lean.Order.coind_monotone_exists {α : Sort u_1} [PartialOrder α] {β : Sort u_2} (f : αβReverseImplicationOrder) (h : monotone f) :
                                                                                                                          monotone fun (x : α) => Exists (f x)
                                                                                                                          theorem Lean.Order.coind_monotone_forall {α : Sort u_1} [PartialOrder α] {β : Sort u_2} (f : αβReverseImplicationOrder) (h : monotone f) :
                                                                                                                          monotone fun (x : α) => ∀ (y : β), f x y
                                                                                                                          theorem Lean.Order.coind_monotone_and {α : Sort u_1} [PartialOrder α] (f₁ f₂ : αProp) (h₁ : monotone f₁) (h₂ : monotone f₂) :
                                                                                                                          monotone fun (x : α) => f₁ x f₂ x
                                                                                                                          theorem Lean.Order.coind_monotone_or {α : Sort u_1} [PartialOrder α] (f₁ f₂ : αProp) (h₁ : monotone f₁) (h₂ : monotone f₂) :
                                                                                                                          monotone fun (x : α) => f₁ x f₂ x
                                                                                                                          def Lean.Order.Example.findF (P : NatBool) (rec : NatOption Nat) (x : Nat) :
                                                                                                                          Equations
                                                                                                                            Instances For
                                                                                                                              noncomputable def Lean.Order.Example.find (P : NatBool) :
                                                                                                                              Equations
                                                                                                                                Instances For
                                                                                                                                  theorem Lean.Order.Example.find_spec {P : NatBool} (n m : Nat) :
                                                                                                                                  find P n = some mn m P m = true