File: Mathlib/Control/LawfulFix.lean

full_name: LawfulFix
code: /-- Intuitively, a fixed point operator `fix` is lawful if it satisfies `fix f = f (fix f)` for all
`f`, but this is inconsistent / uninteresting in most cases due to the existence of "exotic"
functions `f`, such as the function that is defined iff its argument is not, familiar from the
halting problem. Instead, this requirement is limited to only functions that are `Continuous` in the
sense of `ω`-complete partial orders, which excludes the example because it is not monotone
(making the input argument less defined can make `f` more defined). -/
class LawfulFix (α : Type*) [OmegaCompletePartialOrder α] extends Fix α where
  fix_eq : ∀ {f : α →o α}, Continuous f → Fix.fix f = f (Fix.fix f)
goal: Type u_3

full_name: LawfulFix.fix_eq
code: /-- Intuitively, a fixed point operator `fix` is lawful if it satisfies `fix f = f (fix f)` for all
`f`, but this is inconsistent / uninteresting in most cases due to the existence of "exotic"
functions `f`, such as the function that is defined iff its argument is not, familiar from the
halting problem. Instead, this requirement is limited to only functions that are `Continuous` in the
sense of `ω`-complete partial orders, which excludes the example because it is not monotone
(making the input argument less defined can make `f` more defined). -/
class LawfulFix (α : Type*) [OmegaCompletePartialOrder α] extends Fix α where
  fix_eq : ∀ {f : α →o α}, Continuous f → Fix.fix f = f (Fix.fix f)
goal: OmegaCompletePartialOrder.Continuous f → Fix.fix ⇑f = f (Fix.fix ⇑f)

full_name: LawfulFix.fix_eq'
code: theorem LawfulFix.fix_eq' {α} [OmegaCompletePartialOrder α] [LawfulFix α] {f : α → α}
    (hf : Continuous' f) : Fix.fix f = f (Fix.fix f) 
goal: Fix.fix f = f (Fix.fix f)

full_name: Part.Fix.approx_mono'
code: theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) 
goal: Part.Fix.approx (⇑f) i ≤ Part.Fix.approx (⇑f) i.succ

full_name: Part.Fix.approx_mono
code: theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j 
goal: Part.Fix.approx (⇑f) i ≤ Part.Fix.approx (⇑f) j

full_name: Part.Fix.mem_iff
code: theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a 
goal: b ∈ Part.fix (⇑f) a ↔ ∃ i, b ∈ Part.Fix.approx (⇑f) i a

full_name: Part.Fix.approx_le_fix
code: theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f 
goal: Part.Fix.approx (⇑f) i ≤ Part.fix ⇑f

full_name: Part.Fix.exists_fix_le_approx
code: theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x 
goal: ∃ i, Part.fix (⇑f) x ≤ Part.Fix.approx (⇑f) i x

full_name: Part.Fix.approxChain
code: /-- The series of approximations of `fix f` (see `approx`) as a `Chain` -/
def approxChain : Chain ((a : _) → Part <| β a) 
goal: OmegaCompletePartialOrder.Chain ((a : α) → Part (β a))

full_name: Part.Fix.le_f_of_mem_approx
code: theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x 
goal: x ∈ Part.Fix.approxChain f → x ≤ f x

full_name: Part.Fix.approx_mem_approxChain
code: theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f 
goal: Part.Fix.approx (⇑f) i ∈ Part.Fix.approxChain f

full_name: Part.fix_eq_ωSup
code: theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f) 
goal: Part.fix ⇑f = OmegaCompletePartialOrder.ωSup (Part.Fix.approxChain f)

full_name: Part.fix_le
code: theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X 
goal: Part.fix ⇑f ≤ X

full_name: Part.fix_eq
code: theorem fix_eq (hc : Continuous f) : Part.fix f = f (Part.fix f) 
goal: Part.fix ⇑f = f (Part.fix ⇑f)

full_name: Part.toUnitMono
code: /-- `toUnit` as a monotone function -/
@[simps]
def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α 
goal: (Unit → Part α) →o Unit → Part α

full_name: Part.toUnitMono_coe
code: /-- `toUnit` as a monotone function -/
@[simps]
def toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α 
goal: (Part.toUnitMono f) x u = f (x u)

full_name: Part.to_unit_cont
code: theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)
  
goal: OmegaCompletePartialOrder.Continuous (Part.toUnitMono f)

full_name: Part.lawfulFix
code: instance lawfulFix : LawfulFix (Part α) 
goal: LawfulFix (Part α)

full_name: Pi.lawfulFix
code: instance lawfulFix {β} : LawfulFix (α → Part β) 
goal: LawfulFix (α → Part β)

full_name: Pi.monotoneCurry
code: /-- `Sigma.curry` as a monotone function. -/
@[simps]
def monotoneCurry [(x y : _) → Preorder <| γ x y] :
    (∀ x : Σa, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b 
goal: ((x : (a : α) × β a) → γ x.fst x.snd) →o (a : α) → (b : β a) → γ a b

full_name: Pi.monotoneCurry_coe
code: /-- `Sigma.curry` as a monotone function. -/
@[simps]
def monotoneCurry [(x y : _) → Preorder <| γ x y] :
    (∀ x : Σa, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b 
goal: (Pi.monotoneCurry α β γ) f x y = Sigma.curry f x y

full_name: Pi.monotoneUncurry
code: /-- `Sigma.uncurry` as a monotone function. -/
@[simps]
def monotoneUncurry [(x y : _) → Preorder <| γ x y] :
    (∀ (a) (b : β a), γ a b) →o ∀ x : Σa, β a, γ x.1 x.2 
goal: ((a : α) → (b : β a) → γ a b) →o (x : (a : α) × β a) → γ x.fst x.snd

full_name: Pi.monotoneUncurry_coe
code: /-- `Sigma.uncurry` as a monotone function. -/
@[simps]
def monotoneUncurry [(x y : _) → Preorder <| γ x y] :
    (∀ (a) (b : β a), γ a b) →o ∀ x : Σa, β a, γ x.1 x.2 
goal: (Pi.monotoneUncurry α β γ) f x = Sigma.uncurry f x

full_name: Pi.continuous_curry
code: theorem continuous_curry : Continuous <| monotoneCurry α β γ 
goal: OmegaCompletePartialOrder.Continuous (Pi.monotoneCurry α β γ)

full_name: Pi.continuous_uncurry
code: theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ 
goal: OmegaCompletePartialOrder.Continuous (Pi.monotoneUncurry α β γ)

full_name: Pi.hasFix
code: instance hasFix [Fix <| (x : Sigma β) → γ x.1 x.2] : Fix ((x : _) → (y : β x) → γ x y) 
goal: Fix ((x : α) → (y : β x) → γ x y)

full_name: Pi.uncurry_curry_continuous
code: theorem uncurry_curry_continuous (hc : Continuous f) :
    Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ 
goal: OmegaCompletePartialOrder.Continuous ((Pi.monotoneUncurry α β γ).comp (f.comp (Pi.monotoneCurry α β γ)))

full_name: Pi.lawfulFix'
code: instance lawfulFix' [LawfulFix <| (x : Sigma β) → γ x.1 x.2] :
    LawfulFix ((x y : _) → γ x y) 
goal: LawfulFix ((x : α) → (y : β x) → γ x y)