Documentation

Core.Go.Semantics.Operations

Functor #

def IterativeDomain.map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {β' : Type u_1} [IMetricSpace β'] (f : UniformFun β β') {n : ℕ} :
IterativeDomain «Σ» Γ α β n → IterativeDomain «Σ» Γ α β' n
Equations
Instances For
    theorem IterativeDomain.map_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} [IMetricSpace β'] {f : UniformFun β β'} {v : β} {n : ℕ} :
    map f (leaf v) = leaf (f v)
    theorem IterativeDomain.map_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} [IMetricSpace β'] {f : UniformFun β β'} {n : ℕ} :
    theorem IterativeDomain.map_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} [IMetricSpace β'] {f : UniformFun β β'} {n : ℕ} {g : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
    map f (branch g) = branch fun (σ : «Σ») => Branch.map (map f) '' g σ
    theorem IterativeDomain.map_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} (h : m = n) {f : UniformFun β γ} {p : IterativeDomain «Σ» Γ α β m} :
    map f (h ▸ p) = h ▸ map f p
    theorem IterativeDomain.map_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} [IMetricSpace β'] (f : UniformFun β β') {m n : ℕ} (h : m ≤ n) (x : IterativeDomain «Σ» Γ α β m) :
    lift h (map f x) = map f (lift h x)
    theorem IterativeDomain.map_id {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {n : ℕ} {p : IterativeDomain «Σ» Γ α β n} :
    map id p = p
    theorem IterativeDomain.map_idist_le {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {n : ℕ} {q : IterativeDomain «Σ» Γ α β n} {f f' : UniformFun β γ} :
    idist (map f q) (map f' q) ≤ idist f f'
    theorem IterativeDomain.map_idist_le' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {n : ℕ} {K : NNReal} {q q' : IterativeDomain «Σ» Γ α β n} {f : β →ₗ[K] γ} (hk : 1 ≤ K) :
    ↑(idist (map f.toFun q) (map f.toFun q')) ≤ ↑K * ↑(idist q q')
    theorem IterativeDomain.map_idist_le'' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {K : NNReal} {β' : Type u_1} [IMetricSpace β'] {m : ℕ} {p : IterativeDomain «Σ» Γ α β m} {f g : β →ₗ[K] β'} :
    idist (map f.toFun p) (map g.toFun p) ≤ idist f g
    theorem IterativeDomain.map_id' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {n : ℕ} :
    theorem IterativeDomain.map_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {γ' : Type u_1} [IMetricSpace γ'] {n : ℕ} {f : UniformFun β γ} {g : UniformFun γ γ'} {p : IterativeDomain «Σ» Γ α β n} :
    map g (map f p) = map (g ∘ f) p
    theorem IterativeDomain.map_map' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {γ' : Type u_1} [IMetricSpace γ'] {n : ℕ} {f : UniformFun β γ} {g : UniformFun γ γ'} :
    map g ∘ map f = map (g ∘ f)
    theorem IterativeDomain.map_uniformContinuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} [IMetricSpace β'] {n : ℕ} (f : UniformFun β β') (hf : UniformContinuous f) :
    def DomainUnion.map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {β' : Type u_1} [IMetricSpace β'] (f : UniformFun β β') :
    DomainUnion «Σ» Γ α β → DomainUnion «Σ» Γ α β'
    Equations
    Instances For
      theorem DomainUnion.map_mk {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {n : ℕ} {p : IterativeDomain «Σ» Γ α β n} {f : UniformFun β γ} :
      theorem DomainUnion.map_id {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {p : DomainUnion «Σ» Γ α β} :
      map id p = p
      theorem DomainUnion.map_id' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] :
      theorem DomainUnion.map_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {γ' : Type u_1} [IMetricSpace γ'] {f : UniformFun β γ} {g : UniformFun γ γ'} {p : DomainUnion «Σ» Γ α β} :
      map g (map f p) = map (g ∘ f) p
      theorem DomainUnion.map_map' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {γ' : Type u_1} [IMetricSpace γ'] {f : UniformFun β γ} {g : UniformFun γ γ'} :
      map g ∘ map f = map (g ∘ f)
      theorem DomainUnion.map_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} {K : NNReal} [IMetricSpace β'] (f : UniformFun β β') (hf : LipschitzWith K f) (hk : 1 ≤ K) :
      theorem DomainUnion.map_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {K : NNReal} {β' : Type u_1} [IMetricSpace β'] {p : DomainUnion «Σ» Γ α β} :
      LipschitzWith 1 fun (f : β →ₗ[K] β') => map f.toFun p
      theorem DomainUnion.map_uniform_continuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} {K : NNReal} [IMetricSpace β'] (f : UniformFun β β') (hf : LipschitzWith K f) (hk : 1 ≤ K) :
      noncomputable def Domain.map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} [IMetricSpace β'] (f : UniformFun β β') :
      Domain «Σ» Γ α β → Domain «Σ» Γ α β'

      Map leaves of the tree using a given function.

      Equations
      Instances For
        theorem Domain.map_coe {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} {K : NNReal} [IMetricSpace β'] (f : UniformFun β β') {p : DomainUnion «Σ» Γ α β} (hf : LipschitzWith K f) (hk : 1 ≤ K) :
        map f ↑p = ↑(DomainUnion.map f p)
        theorem Domain.map_id {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {p : Domain «Σ» Γ α β} :
        map id p = p
        theorem Domain.map_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {γ' : Type u_1} {Kf Kg : NNReal} [IMetricSpace γ'] {f : UniformFun β γ} {g : UniformFun γ γ'} {p : Domain «Σ» Γ α β} (hkf : 1 ≤ Kf) (hkg : 1 ≤ Kg) (hf : LipschitzWith Kf f) (hg : LipschitzWith Kg g) :
        map g (map f p) = map (g ∘ f) p
        theorem Domain.map_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} {K : NNReal} [IMetricSpace β'] (f : UniformFun β β') (hf : LipschitzWith K f) (hk : 1 ≤ K) :
        theorem Domain.map_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {K : NNReal} {β' : Type u_1} (hk : 1 ≤ K) [IMetricSpace β'] {p : Domain «Σ» Γ α β} :
        LipschitzWith 1 fun (f : β →ₗ[K] β') => map f.toFun p
        theorem Domain.map_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {f : UniformFun β γ} (hf : LipschitzWith K f) (hk : 1 ≤ K) {g : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α β)))} [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] [CompleteSpace γ] :
        map f (branch g) = branch fun (σ : «Σ») => Branch.map (map f) '' g σ
        class HasDefaultInit («Σ» : Type u_1) (Γ : Type u_2) (α : outParam (Type u_3)) :
        Type (max (max u_1 u_2) u_3)
        • zero : Γ → «Σ» → «Σ» × α
        Instances

          Applicative functor #

          theorem reorder {m n : ℕ} :
          m + 1 + n = m + n + 1
          def IterativeDomain.pure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {n : ℕ} (v : β) :
          IterativeDomain «Σ» Γ α β n
          Equations
          Instances For
            noncomputable def Domain.pure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (v : β) :
            Domain «Σ» Γ α β
            Equations
            Instances For
              noncomputable def Domain.pureₗ {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] :
              β →ₗ[1] Domain «Σ» Γ α β
              Equations
              Instances For
                @[irreducible]
                def Branch.ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} (p' : IterativeDomain «Σ» Γ α β n) :
                Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) → Branch «Σ» Γ α (IterativeDomain «Σ» Γ α γ (m + n))
                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  @[irreducible]
                  def IterativeDomain.ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} :
                  IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m → IterativeDomain «Σ» Γ α β n → IterativeDomain «Σ» Γ α γ (m + n)
                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    theorem IterativeDomain.ap_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {v : β →ₗ[K] γ} {m n : ℕ} {q : IterativeDomain «Σ» Γ α β n} :
                    (leaf v).ap q = map v.toFun (lift ⋯ q)
                    theorem IterativeDomain.ap_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {q : IterativeDomain «Σ» Γ α β n} :
                    theorem IterativeDomain.ap_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {g : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m)))} {q : IterativeDomain «Σ» Γ α β n} :
                    (branch g).ap q = ⋯ ▸ branch fun (σ : «Σ») => Branch.ap q '' g σ
                    theorem Branch.ap_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {c : Γ} {m n : ℕ} {K : NNReal} {π : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) unitInterval.half ap_recv._proof_2))} {q : IterativeDomain «Σ» Γ α β n} :
                    ap q (Branch.recv c π) = Branch.recv c fun (v : α) (ok : Bool) => Restriction.map (fun (x : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) => x.ap q) (π v ok)
                    theorem Branch.ap_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {c : Γ} {v : α} {m n : ℕ} {K : NNReal} {p : Restriction (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α β n} :
                    ap q (Branch.send c v p) = Branch.send c v (Restriction.map (fun (x : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) => x.ap q) p)
                    theorem Branch.ap_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {c : Γ} {m n : ℕ} {K : NNReal} {p : Restriction (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α β n} :
                    ap q (Branch.close c p) = Branch.close c (Restriction.map (fun (x : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) => x.ap q) p)
                    theorem Branch.ap_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {c : Γ} {m n : ℕ} {K : NNReal} {p : Restriction (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α β n} :
                    ap q (Branch.sync c p) = Branch.sync c (Restriction.map (fun (x : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) => x.ap q) p)
                    theorem Branch.ap_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {σ : «Σ»} {m n : ℕ} {K : NNReal} {p : Restriction (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α β n} :
                    ap q (Branch.next σ p) = Branch.next σ (Restriction.map (fun (x : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) => x.ap q) p)
                    theorem Branch.ap_eq_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {m n : ℕ} {q : IterativeDomain «Σ» Γ α β n} {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m)} :
                    ap q b = map (fun (x : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) => x.ap q) b
                    theorem Branch.ap_idist_le_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {b b' : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m)} {q : IterativeDomain «Σ» Γ α β n} :
                    idist (ap q b) (ap q b') ≤ idist b b'
                    theorem IterativeDomain.ap_idist_le_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {x y : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} {q : IterativeDomain «Σ» Γ α β n} :
                    idist (x.ap q) (y.ap q) ≤ idist x y
                    theorem IterativeDomain.ap_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {q : IterativeDomain «Σ» Γ α β n} :
                    LipschitzWith 1 fun (p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m) => p.ap q
                    theorem Branch.ap_idist_le_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m)} {q q' : IterativeDomain «Σ» Γ α β n} (hk : 1 ≤ K) :
                    ↑(idist (ap q b) (ap q' b)) ≤ ↑K * ↑(idist q q')
                    theorem IterativeDomain.ap_idist_le_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {q q' : IterativeDomain «Σ» Γ α β n} {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} (hk : 1 ≤ K) :
                    ↑(idist (p.ap q) (p.ap q')) ≤ ↑K * ↑(idist q q')
                    theorem IterativeDomain.ap_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} (hk : 1 ≤ K) {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} :
                    theorem IterativeDomain.pure_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} {f : β →ₗ[K] γ} {q : IterativeDomain «Σ» Γ α β n} :
                    (pure f).ap q = lift ⋯ (map f.toFun q)
                    theorem IterativeDomain.ap_lipschitz {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} (hk : 1 ≤ K) :
                    theorem IterativeDomain.ap.uniform_continuous₂ {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {K : NNReal} (hk : 1 ≤ K) :
                    theorem IterativeDomain.ap_cast_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} {K : NNReal} (h : m = o) {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} {q : IterativeDomain «Σ» Γ α β n} :
                    (h ▸ p).ap q = h ▸ p.ap q
                    theorem IterativeDomain.ap_cast_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} {K : NNReal} (h : n = o) {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} {q : IterativeDomain «Σ» Γ α β n} :
                    p.ap (h ▸ q) = h ▸ p.ap q
                    theorem Branch.ap_lift_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} {K : NNReal} (h : m + n ≤ o) {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m)} {q : IterativeDomain «Σ» Γ α β n} :
                    theorem IterativeDomain.ap_lift_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} {K : NNReal} (h : m + n ≤ o) {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} {q : IterativeDomain «Σ» Γ α β n} :
                    lift h (p.ap q) = ⋯ ▸ (lift ⋯ p).ap q
                    theorem Branch.ap_lift_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} {K : NNReal} (h : m + n ≤ o) {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m)} {q : IterativeDomain «Σ» Γ α β n} :
                    theorem IterativeDomain.ap_lift_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} {K : NNReal} (h : m + n ≤ o) {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} {q : IterativeDomain «Σ» Γ α β n} :
                    lift h (p.ap q) = ⋯ ▸ p.ap (lift ⋯ q)
                    theorem Branch.ap_pure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {x : β} {m n : ℕ} {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m)} :
                    theorem IterativeDomain.ap_pure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {x : β} {m n : ℕ} {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} :
                    p.ap (pure x) = lift ⋯ (map (fun (f : β →ₗ[K] γ) => f x) p)
                    theorem Branch.map_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {f : UniformFun γ δ} [IMetricSpace δ] {K₁ K₂ : NNReal} {m n : ℕ} {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β →ₗ[K₁] γ) m)} {q : IterativeDomain «Σ» Γ α β n} (hf : LipschitzWith K₂ f) :
                    map (IterativeDomain.map f) (ap q b) = ap q (map (IterativeDomain.map fun (g : β →ₗ[K₁] γ) => { toFun := f, lipschitz := hf } ∘ₗ g) b)
                    theorem IterativeDomain.map_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {f : UniformFun γ δ} [IMetricSpace δ] {K₁ K₂ : NNReal} {m n : ℕ} {p : IterativeDomain «Σ» Γ α (β →ₗ[K₁] γ) m} {q : IterativeDomain «Σ» Γ α β n} (hf : LipschitzWith K₂ f) :
                    map f (p.ap q) = (map (fun (g : β →ₗ[K₁] γ) => { toFun := f, lipschitz := hf } ∘ₗ g) p).ap q
                    theorem Branch.ap_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K₁ K₂ : NNReal} [IMetricSpace δ] {m n o : ℕ} {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (γ →ₗ[K₂] β) m)} {q : IterativeDomain «Σ» Γ α (δ →ₗ[K₁] γ) n} {r : IterativeDomain «Σ» Γ α δ o} :
                    ap (q.ap r) b = ⋯ ▸ ap r (ap q (map (IterativeDomain.map fun (f : γ →ₗ[K₂] β) => { toFun := f.comp, lipschitz := ⋯ }) b))
                    theorem IterativeDomain.ap_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K₁ K₂ : NNReal} [IMetricSpace δ] {m n o : ℕ} {p : IterativeDomain «Σ» Γ α (γ →ₗ[K₂] β) m} {q : IterativeDomain «Σ» Γ α (δ →ₗ[K₁] γ) n} {r : IterativeDomain «Σ» Γ α δ o} :
                    p.ap (q.ap r) = ⋯ ▸ ((map (fun (f : γ →ₗ[K₂] β) => { toFun := f.comp, lipschitz := ⋯ }) p).ap q).ap r
                    noncomputable def DomainUnion.ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace β] [IMetricSpace γ] {K : NNReal} :
                    DomainUnion «Σ» Γ α (β →ₗ[K] γ) → DomainUnion «Σ» Γ α β → DomainUnion «Σ» Γ α γ
                    Equations
                    Instances For
                      theorem DomainUnion.pure_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] {β' : Type u_1} {K : NNReal} [IMetricSpace β'] {f : β →ₗ[K] β'} (q : DomainUnion «Σ» Γ α β) :
                      theorem DomainUnion.ap_pure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {x : β} {p : DomainUnion «Σ» Γ α (β →ₗ[K] γ)} :
                      p.ap (mk (IterativeDomain.pure x)) = map (fun (f : β →ₗ[K] γ) => f x) p
                      theorem DomainUnion.ap_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K₁ K₂ : NNReal} [IMetricSpace δ] {p : DomainUnion «Σ» Γ α (γ →ₗ[K₂] β)} {q : DomainUnion «Σ» Γ α (δ →ₗ[K₁] γ)} {r : DomainUnion «Σ» Γ α δ} :
                      p.ap (q.ap r) = ((map (fun (f : γ →ₗ[K₂] β) => { toFun := f.comp, lipschitz := ⋯ }) p).ap q).ap r
                      theorem DomainUnion.map_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [IMetricSpace δ] {K₁ K₂ : NNReal} {f : UniformFun β δ} (hf : LipschitzWith K₁ f) {p : DomainUnion «Σ» Γ α (γ →ₗ[K₂] β)} {q : DomainUnion «Σ» Γ α γ} :
                      map f (p.ap q) = (map (fun (g : γ →ₗ[K₂] β) => { toFun := f, lipschitz := hf } ∘ₗ g) p).ap q
                      theorem DomainUnion.ap_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {q : DomainUnion «Σ» Γ α β} :
                      LipschitzWith 1 fun (p : DomainUnion «Σ» Γ α (β →ₗ[K] γ)) => p.ap q
                      theorem DomainUnion.ap_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} (hk : 1 ≤ K) {p : DomainUnion «Σ» Γ α (β →ₗ[K] γ)} :
                      theorem DomainUnion.ap_lipschitz {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} (hk : 1 ≤ K) :
                      theorem DomainUnion.ap.uniform_continuous₂ {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} (hk : 1 ≤ K) :
                      noncomputable def Domain.ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} :
                      Domain «Σ» Γ α (β →ₗ[K] γ) → Domain «Σ» Γ α β → Domain «Σ» Γ α γ
                      Equations
                      Instances For
                        theorem Domain.ap_coe_coe {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {p : DomainUnion «Σ» Γ α (β →ₗ[K] γ)} {q : DomainUnion «Σ» Γ α β} (hk : 1 ≤ K) :
                        ap ↑p ↑q = ↑(p.ap q)
                        theorem Domain.ap_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} (hk : 1 ≤ K) {q : Domain «Σ» Γ α β} :
                        LipschitzWith 1 fun (p : Domain «Σ» Γ α (β →ₗ[K] γ)) => p.ap q
                        theorem Domain.ap_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} (hk : 1 ≤ K) {p : Domain «Σ» Γ α (β →ₗ[K] γ)} :
                        theorem Domain.pure_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {f : β →ₗ[K] γ} {q : Domain «Σ» Γ α β} (hk : 1 ≤ K) :
                        (pure f).ap q = map f.toFun q
                        theorem Domain.map_pure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {f : β →ₗ[K] γ} {x : β} (hk : 1 ≤ K) :
                        map f.toFun (pure x) = pure (f x)
                        theorem Domain.ap_pure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {x : β} (hk : 1 ≤ K) {p : Domain «Σ» Γ α (β →ₗ[K] γ)} :
                        p.ap (pure x) = map (fun (f : β →ₗ[K] γ) => f x) p
                        theorem Domain.map_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [IMetricSpace δ] {K₁ K₂ : NNReal} {p : Domain «Σ» Γ α (γ →ₗ[K₂] β)} {q : Domain «Σ» Γ α γ} {f : UniformFun β δ} (hf : LipschitzWith K₁ f) (hk₁ : 1 ≤ K₁) (hk₂ : 1 ≤ K₂) :
                        map f (p.ap q) = (map (fun (g : γ →ₗ[K₂] β) => { toFun := f, lipschitz := hf } ∘ₗ g) p).ap q
                        theorem Domain.ap_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K₁ K₂ : NNReal} [IMetricSpace δ] {p : Domain «Σ» Γ α (γ →ₗ[K₂] β)} {q : Domain «Σ» Γ α (δ →ₗ[K₁] γ)} {r : Domain «Σ» Γ α δ} (hk₁ : 1 ≤ K₁) (hk₂ : 1 ≤ K₂) :
                        p.ap (q.ap r) = ((map LipschitzMap.comp' p).ap q).ap r
                        theorem Domain.seq_map_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K₁ K₂ : NNReal} [IMetricSpace δ] {p : Domain «Σ» Γ α (γ →ₗ[K₁] δ)} {f : UniformFun β γ} {q : Domain «Σ» Γ α β} (hf : LipschitzWith K₂ f) (hk₁ : 1 ≤ K₁) (hk₂ : 1 ≤ K₂) :
                        p.ap (map f q) = (map (fun (x : γ →ₗ[K₁] δ) => x ∘ₗ { toFun := f, lipschitz := hf }) p).ap q
                        theorem Domain.map_seq_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {β' : Type u_1} {γ' : Type u_2} [IMetricSpace β'] [IMetricSpace γ'] {K₁ K₂ K₃ : NNReal} {f : UniformFun β (γ' →ₗ[K₁] γ)} {g : β' →ₗ[K₂] γ'} {p : Domain «Σ» Γ α β} {q : Domain «Σ» Γ α β'} (hk₁ : 1 ≤ K₁) (hk₂ : 1 ≤ K₂) (hk₃ : 1 ≤ K₃) (hf : LipschitzWith K₃ f) :
                        (map f p).ap (map g.toFun q) = (map ((fun (x : γ' →ₗ[K₁] γ) => x ∘ₗ g) ∘ f) p).ap q
                        theorem UniformSpace.Completion.extension₂_unique {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace α] [UniformSpace β] [UniformSpace γ] [T0Space γ] [CompleteSpace γ] {f : α → β → γ} (hf : UniformContinuous₂ f) {g : Completion α → Completion β → γ} (hg : UniformContinuous₂ g) (h : ∀ (a : α) (b : β), f a b = g ↑a ↑b) :
                        theorem IterativeDomain.embedAt_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} (hk : 1 ≤ K) {m n : ℕ} {q : IterativeDomain «Σ» Γ α β n} {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} :
                        embedAt (m + n) (p.ap q) = (embedAt m p).ap ↑(DomainUnion.mk q)
                        theorem Domain.branch_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} (hk : 1 ≤ K) {p : Domain «Σ» Γ α β} {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α (β →ₗ[K] γ))))} [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] [CompleteSpace γ] :
                        (branch f).ap p = branch fun (σ : «Σ») => (Branch.map fun (x : Domain «Σ» Γ α (β →ₗ[K] γ)) => x.ap p) '' f σ
                        noncomputable def Domain.ap' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} :
                        Domain «Σ» Γ α (β →ₗ[K] γ) → Domain «Σ» Γ α β → Domain «Σ» Γ α γ

                        General form of sequential composition.

                        Equations
                        Instances For

                          Monad #

                          @[irreducible]
                          def Branch.bind {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {n : ℕ} (f : UniformFun β (Domain «Σ» Γ α γ)) (b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)) :
                          Branch «Σ» Γ α (Domain «Σ» Γ α γ)
                          Equations
                          Instances For
                            @[irreducible]
                            def IterativeDomain.bind {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {n : ℕ} (p : IterativeDomain «Σ» Γ α β n) (f : UniformFun β (Domain «Σ» Γ α γ)) :
                            Domain «Σ» Γ α γ
                            Equations
                            Instances For
                              theorem Branch.bind_eq_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {m : ℕ} {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)} {f : UniformFun β (Domain «Σ» Γ α γ)} :
                              bind f b = map (fun (x : IterativeDomain «Σ» Γ α β m) => x.bind f) b
                              theorem IterativeDomain.bind_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {n : ℕ} {v : β} {f : UniformFun β (Domain «Σ» Γ α γ)} :
                              (leaf v).bind f = f v
                              theorem IterativeDomain.bind_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {n : ℕ} {f : UniformFun β (Domain «Σ» Γ α γ)} :
                              theorem IterativeDomain.bind_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {n : ℕ} {f : UniformFun β (Domain «Σ» Γ α γ)} {g : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
                              (branch g).bind f = Domain.branch fun (σ : «Σ») => (Branch.map fun (x : IterativeDomain «Σ» Γ α β n) => x.bind f) '' g σ
                              theorem IterativeDomain.bind_cast_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {f : UniformFun β (Domain «Σ» Γ α γ)} (h : m = n) :
                              (h ▸ p).bind f = p.bind f
                              theorem IterativeDomain.bind_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {f : UniformFun β (Domain «Σ» Γ α γ)} (h : m ≤ n) :
                              p.bind f = (lift h p).bind f
                              theorem IterativeDomain.bind_lipschitz_left' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {n : ℕ} {p q : IterativeDomain «Σ» Γ α β n} {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K f) (hk : 1 ≤ K) :
                              ↑(idist (p.bind f) (q.bind (UniformFun.toFun f))) ≤ ↑K * ↑(idist p q)
                              theorem IterativeDomain.bind_lipschitz_right' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {f g : β →ₗ[K] Domain «Σ» Γ α γ} {m : ℕ} {p : IterativeDomain «Σ» Γ α β m} :
                              idist (p.bind f.toFun) (p.bind g.toFun) ≤ idist f g
                              theorem IterativeDomain.bind_pure_comp {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {f : UniformFun β γ} {m : ℕ} {p : IterativeDomain «Σ» Γ α β m} :
                              theorem IterativeDomain.bind_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} (hk : 1 ≤ K) {m n : ℕ} {p : IterativeDomain «Σ» Γ α (β →ₗ[K] γ) m} {q : IterativeDomain «Σ» Γ α β n} :
                              (p.bind fun (f : β →ₗ[K] γ) => ↑(DomainUnion.mk (map f.toFun q))) = ↑(DomainUnion.mk (p.ap q))
                              noncomputable def DomainUnion.bind {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] (p : DomainUnion «Σ» Γ α β) :
                              UniformFun (UniformFun β (Domain «Σ» Γ α γ)) (Domain «Σ» Γ α γ)
                              Equations
                              Instances For
                                theorem DomainUnion.bind_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K f) (hk : 1 ≤ K) :
                                LipschitzWith K fun (x : DomainUnion «Σ» Γ α β) => x.bind (UniformFun.toFun f)
                                theorem DomainUnion.pure_bind {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {n : ℕ} {v : β} {f : UniformFun β (Domain «Σ» Γ α γ)} :
                                theorem DomainUnion.bind_pure_comp {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {f : UniformFun β γ} {p : DomainUnion «Σ» Γ α β} :
                                p.bind (Domain.pure ∘ f) = ↑(map f p)
                                theorem DomainUnion.bind_uniform_continuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {f : β → Domain «Σ» Γ α γ} (hf : LipschitzWith K f) (hk : 1 ≤ K) :
                                UniformContinuous fun (x : DomainUnion «Σ» Γ α β) => x.bind f
                                noncomputable def Domain.bind {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] (p : Domain «Σ» Γ α β) (f : UniformFun β (Domain «Σ» Γ α γ)) :
                                Domain «Σ» Γ α γ

                                Replace leaves of the tree with subtrees depending on the value of the leaves.

                                Equations
                                Instances For
                                  theorem Domain.bind_coe {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {p : DomainUnion «Σ» Γ α β} {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K f) (hk : 1 ≤ K) :
                                  bind (↑p) f = p.bind f
                                  theorem Domain.bind_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} (hk : 1 ≤ K) {f : β → Domain «Σ» Γ α γ} (hf : LipschitzWith K f) :
                                  LipschitzWith K fun (p : Domain «Σ» Γ α β) => p.bind f
                                  theorem Domain.bind_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {p : Domain «Σ» Γ α β} (hk : 1 ≤ K) :
                                  LipschitzWith 1 fun (f : β →ₗ[K] Domain «Σ» Γ α γ) => p.bind f.toFun
                                  theorem Domain.bind_lipschitz {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} (hk : 1 ≤ K) :
                                  LipschitzWith (K + 1) (Function.uncurry fun (p : Domain «Σ» Γ α β) (f : β →ₗ[K] Domain «Σ» Γ α γ) => p.bind f.toFun)
                                  theorem Domain.bind_pure_comp {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {p : Domain «Σ» Γ α β} {f : β →ₗ[K] γ} (hk : 1 ≤ K) :
                                  p.bind (pure ∘ ⇑f) = map f.toFun p
                                  theorem Domain.bind_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {p : Domain «Σ» Γ α (β →ₗ[K] γ)} {q : Domain «Σ» Γ α β} (hk : 1 ≤ K) :
                                  (p.bind fun (x : β →ₗ[K] γ) => map x.toFun q) = p.ap q
                                  theorem Domain.pure_bind {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} {v : β} {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K f) (hk : 1 ≤ K) :
                                  (pure v).bind f = f v
                                  theorem Domain.bind_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] [CompleteSpace β] {K : NNReal} (hk : 1 ≤ K) {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K f) :
                                  theorem IterativeDomain.bind_eq_bind_embedAt {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} (hk : 1 ≤ K) {m : ℕ} {p : IterativeDomain «Σ» Γ α β m} {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K f) :
                                  p.bind f = (embedAt m p).bind f
                                  theorem Domain.bind_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} (hk : 1 ≤ K) [CompleteSpace β] {h : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α β)))} {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K f) :
                                  (branch h).bind f = branch fun (σ : «Σ») => (Branch.map fun (x : Domain «Σ» Γ α β) => x.bind f) '' h σ
                                  theorem Domain.bind_branch' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K : NNReal} (hk : 1 ≤ K) [CompleteSpace β] {p : Domain «Σ» Γ α β} {f : UniformFun β (UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α γ))))} (hf : LipschitzWith K f) (hp : p ≠ abort) :
                                  ∃ (g : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α γ)))), p.bind (branch ∘ f) = branch g
                                  theorem IterativeDomain.bind_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K₁ K₂ : NNReal} [IMetricSpace δ] [CompleteSpace δ] {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K₁ f) {g : UniformFun γ (Domain «Σ» Γ α δ)} (hg : LipschitzWith K₂ g) (hk₂ : 1 ≤ K₂) {m : ℕ} {p : IterativeDomain «Σ» Γ α β m} :
                                  (p.bind f).bind g = p.bind fun (x : β) => (f x).bind g
                                  theorem Domain.bind_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace γ] {K₁ K₂ : NNReal} [IMetricSpace δ] [CompleteSpace δ] {p : Domain «Σ» Γ α β} {f : UniformFun β (Domain «Σ» Γ α γ)} (hf : LipschitzWith K₁ f) {g : UniformFun γ (Domain «Σ» Γ α δ)} (hg : LipschitzWith K₂ g) (hk₁ : 1 ≤ K₁) (hk₂ : 1 ≤ K₂) :
                                  (p.bind f).bind g = p.bind fun (x : β) => (f x).bind g
                                  @[irreducible]
                                  def Branch.seq {«Σ» : Type u} {Γ : Type v} {α : Type w} {m n : ℕ} (q : IterativeDomain «Σ» Γ α PUnit.{x + 1} n) :
                                  Branch «Σ» Γ α (IterativeDomain «Σ» Γ α PUnit.{x + 1} m) → Branch «Σ» Γ α (IterativeDomain «Σ» Γ α PUnit.{x + 1} (m + n))
                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For
                                    @[irreducible]
                                    def IterativeDomain.seq {«Σ» : Type u} {Γ : Type v} {α : Type w} {m n : ℕ} :
                                    IterativeDomain «Σ» Γ α PUnit.{x + 1} m → IterativeDomain «Σ» Γ α PUnit.{x + 1} n → IterativeDomain «Σ» Γ α PUnit.{x + 1} (m + n)
                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      theorem IterativeDomain.seq_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {v : PUnit.{u_1 + 1}} {m n : ℕ} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      (leaf v).seq q = lift ⋯ q
                                      theorem IterativeDomain.seq_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      theorem IterativeDomain.seq_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {g : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m)))} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      (branch g).seq q = ⋯ ▸ branch fun (σ : «Σ») => Branch.seq q '' g σ
                                      theorem Branch.seq_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {c : Γ} {π : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) unitInterval.half ap_recv._proof_2))} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      seq q (Branch.recv c π) = Branch.recv c fun (v : α) (ok : Bool) => Restriction.map (fun (x : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) => x.seq q) (π v ok)
                                      theorem Branch.seq_send {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {c : Γ} {v : α} {p : Restriction (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      seq q (Branch.send c v p) = Branch.send c v (Restriction.map (fun (x : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) => x.seq q) p)
                                      theorem Branch.seq_close {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {c : Γ} {p : Restriction (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      seq q (Branch.close c p) = Branch.close c (Restriction.map (fun (x : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) => x.seq q) p)
                                      theorem Branch.seq_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {c : Γ} {p : Restriction (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      seq q (Branch.sync c p) = Branch.sync c (Restriction.map (fun (x : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) => x.seq q) p)
                                      theorem Branch.seq_next {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {σ : «Σ»} {p : Restriction (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) unitInterval.half ap_recv._proof_2} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                      seq q (Branch.next σ p) = Branch.next σ (Restriction.map (fun (x : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) => x.seq q) p)
                                      theorem Branch.seq_eq_app {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α PUnit.{x + 1} m)} {q : IterativeDomain «Σ» Γ α PUnit.{x + 1} n} :
                                      seq q b = (ap q ∘ map (IterativeDomain.map fun (x : PUnit.{x + 1}) => { toFun := fun (x : PUnit.{x + 1}) => PUnit.unit, lipschitz := ⋯ })) b
                                      theorem IterativeDomain.seq_eq_app {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {p : IterativeDomain «Σ» Γ α PUnit.{x + 1} m} {q : IterativeDomain «Σ» Γ α PUnit.{x + 1} n} :
                                      p.seq q = (map (fun (x : PUnit.{x + 1}) => { toFun := fun (x : PUnit.{x + 1}) => PUnit.unit, lipschitz := ⋯ }) p).ap q
                                      noncomputable def DomainUnion.seq {«Σ» : Type u} {Γ : Type v} {α : Type w} :
                                      DomainUnion «Σ» Γ α PUnit.{u_1 + 1} → DomainUnion «Σ» Γ α PUnit.{u_1 + 1} → DomainUnion «Σ» Γ α PUnit.{u_1 + 1}
                                      Equations
                                      Instances For
                                        theorem DomainUnion.seq_eq_app {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : DomainUnion «Σ» Γ α PUnit.{x + 1}} :
                                        p.seq q = (map (fun (x : PUnit.{x + 1}) => { toFun := fun (x : PUnit.{x + 1}) => PUnit.unit, lipschitz := ⋯ }) p).ap q
                                        theorem DomainUnion.seq_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {q : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}} :
                                        LipschitzWith 1 fun (p : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}) => p.seq q
                                        noncomputable def Domain.seq {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] :
                                        Domain «Σ» Γ α PUnit.{u_1 + 1} → Domain «Σ» Γ α PUnit.{u_1 + 1} → Domain «Σ» Γ α PUnit.{u_1 + 1}

                                        Restricted form of sequential composition where all leaves are replaced with the same subtree.

                                        Equations
                                        Instances For
                                          theorem Domain.seq_coe_coe {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}} :
                                          seq ↑p ↑q = ↑(p.seq q)
                                          theorem Domain.seq_eq_app {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : Domain «Σ» Γ α PUnit.{x + 1}} :
                                          p.seq q = (map (fun (x : PUnit.{x + 1}) => { toFun := fun (x : PUnit.{x + 1}) => PUnit.unit, lipschitz := ⋯ }) p).ap q
                                          theorem Domain.seq_branch_contracting_right {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [CompleteSpace Γ] [CompleteSpace «Σ»] [CompleteSpace α] (f : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α PUnit.{u_1 + 1})))) (p p' : Domain «Σ» Γ α PUnit.{u_1 + 1}) :
                                          theorem Domain.seq_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q r : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                          p.seq (q.seq r) = (p.seq q).seq r
                                          noncomputable def Domain.seq' {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] :
                                          Domain «Σ» Γ α PUnit.{u_1 + 1} → Domain «Σ» Γ α PUnit.{u_1 + 1} → Domain «Σ» Γ α PUnit.{u_1 + 1}

                                          Restricted form of sequential composition where all leaves are replaced with the same subtree.

                                          Equations
                                          Instances For
                                            theorem Domain.seq'_eq_app {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : Domain «Σ» Γ α PUnit.{x + 1}} :
                                            q.seq' p = (map (fun (x : PUnit.{x + 1}) => { toFun := fun (x : PUnit.{x + 1}) => PUnit.unit, lipschitz := ⋯ }) p).ap q
                                            theorem Domain.seq'_branch_contracting_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [CompleteSpace Γ] [CompleteSpace «Σ»] [CompleteSpace α] (f : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α PUnit.{u_1 + 1})))) (p p' : Domain «Σ» Γ α PUnit.{u_1 + 1}) :
                                            theorem Domain.seq'_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q r : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                            (r.seq' q).seq' p = r.seq' (q.seq' p)
                                            theorem Domain.seq'_left_nonexpansive {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p p' q : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                            idist (q.seq' p) (q.seq' p') ≤ idist p p'
                                            theorem Domain.seq'_is_branch_of_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : Domain «Σ» Γ α PUnit.{u_1 + 1}} [CompleteSpace Γ] [CompleteSpace «Σ»] [CompleteSpace α] {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α PUnit.{u_1 + 1})))} (hf : p = branch f) :
                                            ∃ (g : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α PUnit.{u_1 + 1})))), q.seq' p = branch g

                                            Channel closure #

                                            @[irreducible]
                                            def Branch.syncClose {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [DecidableEq Γ] (zero : Γ → «Σ» → «Σ» × α) {n : ℕ} (c : Γ) (σ : «Σ») :
                                            Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n) → Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)
                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For
                                              @[irreducible]
                                              def IterativeDomain.syncClose {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [DecidableEq Γ] (zero : Γ → «Σ» → «Σ» × α) {n : ℕ} (c : Γ) :
                                              IterativeDomain «Σ» Γ α β n → IterativeDomain «Σ» Γ α β n
                                              Equations
                                              Instances For
                                                theorem IterativeDomain.syncClose_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {v : β} {n : ℕ} :
                                                syncClose zero c (leaf v) = leaf v
                                                theorem IterativeDomain.syncClose_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} :
                                                theorem IterativeDomain.syncClose_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} {f : «Σ» → Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n))} :
                                                syncClose zero c (branch f) = branch fun (σ : «Σ») => Branch.syncClose zero c σ '' f σ
                                                theorem IterativeDomain.syncClose_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} (h : m = n) :
                                                h ▸ syncClose zero c p = syncClose zero c (h ▸ p)
                                                theorem Branch.syncClose_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {m : ℕ} {c c' : Γ} {σ : «Σ»} {π : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2))} :
                                                syncClose zero c σ (Branch.recv c' π) = if c = c' then Branch.next (zero c σ).1 { val := IterativeDomain.syncClose zero c (π (zero c σ).2 false).val } else Branch.recv c' fun (v : α) (ok : Bool) => { val := IterativeDomain.syncClose zero c (π v ok).val }
                                                theorem Branch.syncClose_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {m : ℕ} {c c' : Γ} {σ : «Σ»} {v : α} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                theorem Branch.syncClose_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {m : ℕ} {c c' : Γ} {σ : «Σ»} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                theorem Branch.syncClose_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {m : ℕ} {c c' : Γ} {σ : «Σ»} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                theorem Branch.syncClose_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {m : ℕ} {c : Γ} {σ σ' : «Σ»} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                syncClose zero c σ (Branch.next σ' p) = Branch.next σ' { val := IterativeDomain.syncClose zero c p.val }
                                                theorem Branch.syncClose_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {m n : ℕ} {c : Γ} {σ : «Σ»} (h : m ≤ n) {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)} :
                                                theorem IterativeDomain.syncClose_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {m n : ℕ} {c : Γ} (h : m ≤ n) {p : IterativeDomain «Σ» Γ α β m} :
                                                lift h (syncClose zero c p) = syncClose zero c (lift h p)
                                                theorem Branch.syncClose_idist_le {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {σ : «Σ»} {n : ℕ} {b b' : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)} :
                                                idist (syncClose zero c σ b) (syncClose zero c σ b') ≤ idist b b'
                                                theorem IterativeDomain.syncClose_idist_le {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} {p q : IterativeDomain «Σ» Γ α β n} :
                                                idist (syncClose zero c p) (syncClose zero c q) ≤ idist p q
                                                theorem IterativeDomain.syncClose_lipschitz {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} :
                                                theorem IterativeDomain.syncClose.uniform_continuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} :
                                                def DomainUnion.syncClose {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [DecidableEq Γ] (zero : Γ → «Σ» → «Σ» × α) (c : Γ) :
                                                DomainUnion «Σ» Γ α β → DomainUnion «Σ» Γ α β
                                                Equations
                                                Instances For
                                                  theorem DomainUnion.syncClose_lipschitz {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} :
                                                  theorem DomainUnion.syncClose.uniform_continuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} :
                                                  noncomputable def Domain.syncClose {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) (c : Γ) :
                                                  Domain «Σ» Γ α β → Domain «Σ» Γ α β

                                                  Close a synchronous channel c in the tree, pruning subtrees accordingly.

                                                  Equations
                                                  Instances For
                                                    @[reducible, inline]
                                                    noncomputable abbrev Domain.syncClose' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [inst : HasDefaultInit «Σ» Γ α] (c : Γ) :
                                                    Domain «Σ» Γ α β → Domain «Σ» Γ α β

                                                    Close a synchronous channel c in the tree, pruning subtrees accordingly.

                                                    Equations
                                                    Instances For
                                                      theorem IterativeDomain.choice_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} {v : PUnit.{u_1 + 1}} :
                                                      p.choice (leaf v) = lift ⋯ p
                                                      theorem IterativeDomain.leaf_choice {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} {v : PUnit.{u_1 + 1}} :
                                                      (leaf v).choice q = lift ⋯ q
                                                      theorem IterativeDomain.choice_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} :
                                                      theorem IterativeDomain.abort_choice {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                                      theorem IterativeDomain.choice_branch_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m)))} {f' : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n)))} :
                                                      (branch f).choice (branch f') = ⋯ ▸ branch fun (σ : «Σ») => Branch.map (lift ⋯) '' f σ ∪ Branch.map (lift ⋯) '' f' σ
                                                      theorem IterativeDomain.choice_cast_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n o : ℕ} {h : m = o} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} :
                                                      h ▸ p.choice q = (h ▸ p).choice q
                                                      theorem IterativeDomain.choice_cast_right {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n o : ℕ} {h : n = o} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} :
                                                      h ▸ p.choice q = p.choice (h ▸ q)
                                                      theorem IterativeDomain.choice_lipschitz_left' {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} {p p' : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} :
                                                      idist (p.choice q) (p'.choice q) ≤ idist p p'
                                                      theorem IterativeDomain.choice_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                                      LipschitzWith 1 fun (p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m) => p.choice q
                                                      theorem IterativeDomain.choice_lipschitz_right' {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {q q' : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} :
                                                      idist (p.choice q) (p.choice q') ≤ idist q q'
                                                      theorem IterativeDomain.lift_choice_left' {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n o : ℕ} (h : m ≤ o) {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                                      (lift h p).choice q = lift ⋯ (p.choice q)
                                                      theorem IterativeDomain.lift_choice_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n o : ℕ} (h : max m n ≤ o) {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                                      lift h (p.choice q) = ⋯ ▸ (lift ⋯ p).choice q
                                                      theorem IterativeDomain.lift_choice_right' {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n o : ℕ} (h : n ≤ o) {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                                      p.choice (lift h q) = lift ⋯ (p.choice q)
                                                      theorem IterativeDomain.lift_choice_right {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n o : ℕ} (h : max m n ≤ o) {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                                      lift h (p.choice q) = ⋯ ▸ p.choice (lift ⋯ q)
                                                      theorem IterativeDomain.choice_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n o : ℕ} {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} {r : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} o} :
                                                      p.choice (q.choice r) = ⋯ ▸ (p.choice q).choice r
                                                      theorem IterativeDomain.choice_comm {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {m n : ℕ} {p : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} m} {q : IterativeDomain «Σ» Γ α PUnit.{u_1 + 1} n} :
                                                      p.choice q = ⋯ ▸ q.choice p
                                                      def DomainUnion.choice {«Σ» : Type u} {Γ : Type v} {α : Type w} :
                                                      DomainUnion «Σ» Γ α PUnit.{u_1 + 1} → DomainUnion «Σ» Γ α PUnit.{u_1 + 1} → DomainUnion «Σ» Γ α PUnit.{u_1 + 1}
                                                      Equations
                                                      Instances For
                                                        theorem DomainUnion.choice_lipschitz_left' {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p p' q : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}} :
                                                        theorem DomainUnion.choice_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {q : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}} :
                                                        LipschitzWith 1 fun (p : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}) => p.choice q
                                                        theorem DomainUnion.choice_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q r : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}} :
                                                        p.choice (q.choice r) = (p.choice q).choice r
                                                        theorem DomainUnion.choice_comm {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}} :
                                                        p.choice q = q.choice p
                                                        noncomputable def Domain.choice {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] :
                                                        Domain «Σ» Γ α PUnit.{u_1 + 1} → Domain «Σ» Γ α PUnit.{u_1 + 1} → Domain «Σ» Γ α PUnit.{u_1 + 1}

                                                        Non-deterministic choice, aka tree union.

                                                        Equations
                                                        Instances For
                                                          theorem Domain.choice_coe_coe {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : DomainUnion «Σ» Γ α PUnit.{u_1 + 1}} :
                                                          choice ↑p ↑q = ↑(p.choice q)
                                                          theorem Domain.choice_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {q : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                                          LipschitzWith 1 fun (p : Domain «Σ» Γ α PUnit.{u_1 + 1}) => p.choice q
                                                          theorem Domain.choice_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                                          LipschitzWith 1 fun (q : Domain «Σ» Γ α PUnit.{u_1 + 1}) => p.choice q
                                                          theorem Domain.choice_idist_le_max {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p p' q q' : Domain «Σ» Γ α PUnit.{u_1 + 1}} [IsUltrametricIDist «Σ»] [IsUltrametricIDist Γ] [IsUltrametricIDist α] :
                                                          idist (p.choice q) (p'.choice q') ≤ max (idist p p') (idist q q')
                                                          noncomputable def Domain.failure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                                          Domain «Σ» Γ α β
                                                          Equations
                                                          Instances For
                                                            theorem Domain.failure_eq {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                                            ∃ (n : ℕ), failure = ↑(DomainUnion.mk (IterativeDomain.branch fun (σ : «Σ») => {Branch.next σ { val := IterativeDomain.abort }}))
                                                            theorem Domain.map_failure {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] [CompleteSpace γ] {f : UniformFun β γ} {K : NNReal} (hk : 1 ≤ K) (hf : LipschitzWith K f) :
                                                            theorem Domain.failure_ap {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {K : NNReal} {p : Domain «Σ» Γ α β} [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] [CompleteSpace γ] (hk : 1 ≤ K) :
                                                            theorem Domain.choice_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] {p : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                                            theorem Domain.abort_choice {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] {q : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                                            theorem Domain.choice_comm {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                                            p.choice q = q.choice p
                                                            theorem Domain.choice_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q r : Domain «Σ» Γ α PUnit.{u_1 + 1}} :
                                                            p.choice (q.choice r) = (p.choice q).choice r
                                                            theorem Domain.choice_distrib_map {«Σ» : Type u} {Γ : Type v} {α : Type w} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] {p q : Domain «Σ» Γ α PUnit.{x + 1}} {f : PUnit.{x + 1} → PUnit.{x + 1}} :
                                                            map f (p.choice q) = (map f p).choice (map f q)

                                                            Event hiding #

                                                            @[irreducible]
                                                            def Branch.hide {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [DecidableEq Γ] (zero : Γ → «Σ» → «Σ» × α) (σ : «Σ») (c : Γ) {n : ℕ} :
                                                            Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n) → Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n))
                                                            Equations
                                                            • One or more equations did not get rendered due to their size.
                                                            Instances For
                                                              @[irreducible]
                                                              def IterativeDomain.hide {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [DecidableEq Γ] (zero : Γ → «Σ» → «Σ» × α) (c : Γ) {n : ℕ} :
                                                              IterativeDomain «Σ» Γ α β n → IterativeDomain «Σ» Γ α β n
                                                              Equations
                                                              Instances For
                                                                theorem IterativeDomain.hide_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} {v : β} :
                                                                hide zero c (leaf v) = leaf v
                                                                theorem IterativeDomain.hide_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} :
                                                                hide zero c abort = abort
                                                                theorem IterativeDomain.hide_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
                                                                hide zero c (branch f) = branch fun (σ : «Σ») => (⋃ b ∈ f σ, Branch.hide zero σ c b) ∪ if ⋃ b ∈ f σ, Branch.hide zero σ c b = ∅ ∧ f σ ≠ ∅ then {Branch.next σ { val := abort }} else ∅
                                                                theorem Branch.hide_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {σ : «Σ»} {c c' : Γ} {n : ℕ} {π : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α β n) unitInterval.half ap_recv._proof_2))} :
                                                                hide zero σ c (Branch.recv c' π) = if c = c' then ∅ else {Branch.recv c' fun (v : α) (ok : Bool) => Restriction.map (IterativeDomain.hide zero c) (π v ok)}
                                                                theorem Branch.hide_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {σ : «Σ»} {c c' : Γ} {v : α} {n : ℕ} {p : Restriction (IterativeDomain «Σ» Γ α β n) unitInterval.half ap_recv._proof_2} :
                                                                hide zero σ c (Branch.send c' v p) = if c = c' then ∅ else {Branch.send c' v (Restriction.map (IterativeDomain.hide zero c) p)}
                                                                theorem Branch.hide_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {σ : «Σ»} {c c' : Γ} {n : ℕ} {p : Restriction (IterativeDomain «Σ» Γ α β n) unitInterval.half ap_recv._proof_2} :
                                                                theorem Branch.hide_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {σ : «Σ»} {c c' : Γ} {n : ℕ} {p : Restriction (IterativeDomain «Σ» Γ α β n) unitInterval.half ap_recv._proof_2} :
                                                                theorem Branch.hide_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {σ σ' : «Σ»} {c : Γ} {n : ℕ} {p : Restriction (IterativeDomain «Σ» Γ α β n) unitInterval.half ap_recv._proof_2} :
                                                                theorem Branch.hide_idist_le {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {σ : «Σ»} {c : Γ} {n : ℕ} {b b' : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)} :
                                                                IMetric.hausdorffIDist (hide zero σ c b) (hide zero σ c b') ≤ idist b b'
                                                                theorem IterativeDomain.hide_idist_le {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} {p p' : IterativeDomain «Σ» Γ α β n} :
                                                                idist (hide zero c p) (hide zero c p') ≤ idist p p'
                                                                theorem IterativeDomain.hide_lipschitz {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} :
                                                                LipschitzWith 1 (hide zero c)
                                                                theorem IterativeDomain.hide_uniform_continuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {n : ℕ} :
                                                                theorem IterativeDomain.hide_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {m n : ℕ} {h : m = n} {p : IterativeDomain «Σ» Γ α β m} :
                                                                h ▸ hide zero c p = hide zero c (h ▸ p)
                                                                theorem Branch.hide_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {σ : «Σ»} {c : Γ} {m n : ℕ} (h : m ≤ n) {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)} :
                                                                map (IterativeDomain.lift h) '' hide zero σ c b = hide zero σ c (map (IterativeDomain.lift h) b)
                                                                theorem IterativeDomain.hide_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} {m n : ℕ} (h : m ≤ n) {p : IterativeDomain «Σ» Γ α β m} :
                                                                lift h (hide zero c p) = hide zero c (lift h p)
                                                                def DomainUnion.hide {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [DecidableEq Γ] (zero : Γ → «Σ» → «Σ» × α) (c : Γ) :
                                                                DomainUnion «Σ» Γ α β → DomainUnion «Σ» Γ α β
                                                                Equations
                                                                Instances For
                                                                  theorem DomainUnion.hide_lipschitz {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} :
                                                                  LipschitzWith 1 (hide zero c)
                                                                  theorem DomainUnion.hide_uniform_continuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) {c : Γ} :
                                                                  noncomputable def Domain.hide {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] (zero : Γ → «Σ» → «Σ» × α) (c : Γ) :
                                                                  Domain «Σ» Γ α β → Domain «Σ» Γ α β
                                                                  Equations
                                                                  Instances For
                                                                    noncomputable def Domain.hide' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [inst : HasDefaultInit «Σ» Γ α] :
                                                                    Domain «Σ» Γ α β → Γ → Domain «Σ» Γ α β

                                                                    Remove branches that mention the synchronous channel c, but replace the pruning of all branches at a particular point by abortion.

                                                                    Equations
                                                                    Instances For

                                                                      Parallel composition #

                                                                      @[irreducible]
                                                                      def Branch.parallel_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} (p' : IterativeDomain «Σ» Γ α γ n) :
                                                                      Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m) → Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β × γ) (m + n))
                                                                      Equations
                                                                      • One or more equations did not get rendered due to their size.
                                                                      Instances For
                                                                        @[irreducible]
                                                                        def Branch.parallel_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} (p : IterativeDomain «Σ» Γ α β m) :
                                                                        Branch «Σ» Γ α (IterativeDomain «Σ» Γ α γ n) → Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β × γ) (m + n))
                                                                        Equations
                                                                        • One or more equations did not get rendered due to their size.
                                                                        Instances For
                                                                          @[irreducible]
                                                                          def IterativeDomain.parallel {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} (p : IterativeDomain «Σ» Γ α β m) (p' : IterativeDomain «Σ» Γ α γ n) :
                                                                          IterativeDomain «Σ» Γ α (β × γ) (m + n)
                                                                          Equations
                                                                          Instances For
                                                                            theorem IterativeDomain.leaf_parallel {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {v : β} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            (leaf v).parallel q = lift ⋯ (map (fun (x : γ) => (v, x)) q)
                                                                            theorem IterativeDomain.parallel_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {v : β} {p : IterativeDomain «Σ» Γ α γ m} :
                                                                            p.parallel (leaf v) = lift ⋯ (map (fun (x : γ) => (x, v)) p)
                                                                            theorem IterativeDomain.abort_parallel {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            theorem IterativeDomain.parallel_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            theorem IterativeDomain.parallel_branch_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {g : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)))} {g' : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α γ n)))} :
                                                                            (branch g).parallel (branch g') = branch fun (σ : «Σ») => {x : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β × γ) (m + 1 + n)) | ∃ b ∈ g σ, ⋯ ▸ Branch.parallel_left (branch g') b = x} ∪ {x : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β × γ) (m + 1 + n)) | ∃ b' ∈ g' σ, Branch.parallel_right (branch g) b' = x} ∪ {p : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β × γ) (m + 1 + n)) | ∃ (v : α) (γ_1 : Γ) (p' : IterativeDomain «Σ» Γ α β m) (π' : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α γ n) unitInterval.half Branch._proof_2))), Branch.send γ_1 v { val := p' } ∈ g σ ∧ Branch.recv γ_1 π' ∈ g' σ ∧ p = Branch.sync γ_1 { val := lift ⋯ (p'.parallel (π' v true).val) }} ∪ {p : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α (β × γ) (m + 1 + n)) | ∃ (v : α) (γ_1 : Γ) (p' : IterativeDomain «Σ» Γ α γ n) (π' : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half Branch._proof_2))), Branch.send γ_1 v { val := p' } ∈ g' σ ∧ Branch.recv γ_1 π' ∈ g σ ∧ p = Branch.sync γ_1 { val := lift ⋯ ((π' v true).val.parallel p') }}
                                                                            theorem Branch.parallel_left_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} {c : Γ} {π : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2))} :
                                                                            parallel_left q (Branch.recv c π) = Branch.recv c fun (v : α) (ok : Bool) => Restriction.map (fun (x : IterativeDomain «Σ» Γ α β m) => x.parallel q) (π v ok)
                                                                            theorem Branch.parallel_left_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} {c : Γ} {v : α} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                                            parallel_left q (Branch.send c v p) = Branch.send c v (Restriction.map (fun (x : IterativeDomain «Σ» Γ α β m) => x.parallel q) p)
                                                                            theorem Branch.parallel_left_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} {c : Γ} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                                            parallel_left q (Branch.close c p) = Branch.close c (Restriction.map (fun (x : IterativeDomain «Σ» Γ α β m) => x.parallel q) p)
                                                                            theorem Branch.parallel_left_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} {c : Γ} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                                            parallel_left q (Branch.sync c p) = Branch.sync c (Restriction.map (fun (x : IterativeDomain «Σ» Γ α β m) => x.parallel q) p)
                                                                            theorem Branch.parallel_left_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} {σ : «Σ»} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half ap_recv._proof_2} :
                                                                            parallel_left q (Branch.next σ p) = Branch.next σ (Restriction.map (fun (x : IterativeDomain «Σ» Γ α β m) => x.parallel q) p)
                                                                            theorem Branch.parallel_left_eq_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            parallel_left q = map fun (x : IterativeDomain «Σ» Γ α β m) => x.parallel q
                                                                            theorem Branch.parallel_right_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {c : Γ} {π : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α γ n) unitInterval.half ap_recv._proof_2))} :
                                                                            parallel_right p (Branch.recv c π) = Branch.recv c fun (v : α) (ok : Bool) => Restriction.map p.parallel (π v ok)
                                                                            theorem Branch.parallel_right_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {c : Γ} {v : α} {q : Restriction (IterativeDomain «Σ» Γ α γ n) unitInterval.half ap_recv._proof_2} :
                                                                            theorem Branch.parallel_right_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {c : Γ} {q : Restriction (IterativeDomain «Σ» Γ α γ n) unitInterval.half ap_recv._proof_2} :
                                                                            theorem Branch.parallel_right_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {c : Γ} {q : Restriction (IterativeDomain «Σ» Γ α γ n) unitInterval.half ap_recv._proof_2} :
                                                                            theorem Branch.parallel_right_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {σ : «Σ»} {q : Restriction (IterativeDomain «Σ» Γ α γ n) unitInterval.half ap_recv._proof_2} :
                                                                            theorem Branch.parallel_right_eq_map {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} :
                                                                            theorem IterativeDomain.parallel_comm {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            theorem IterativeDomain.parallel_idist_le_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p p' : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            idist (p.parallel q) (p'.parallel q) ≤ idist p p'
                                                                            theorem IterativeDomain.parallel_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            LipschitzWith 1 fun (p : IterativeDomain «Σ» Γ α β m) => p.parallel q
                                                                            theorem IterativeDomain.parallel_idist_le_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {q q' : IterativeDomain «Σ» Γ α γ n} :
                                                                            idist (p.parallel q) (p.parallel q') ≤ idist q q'
                                                                            theorem IterativeDomain.parallel_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} :
                                                                            theorem IterativeDomain.parallel_cast_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} (h : m = o) {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            h ▸ p.parallel q = (h ▸ p).parallel q
                                                                            theorem IterativeDomain.parallel_cast_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} (h : n = o) {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            h ▸ p.parallel q = p.parallel (h ▸ q)
                                                                            theorem IterativeDomain.parallel_lift_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} (h : m + n ≤ o) {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            lift h (p.parallel q) = ⋯ ▸ (lift ⋯ p).parallel q
                                                                            theorem IterativeDomain.parallel_lift_left' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} (h : m ≤ o) {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            lift ⋯ (p.parallel q) = (lift h p).parallel q
                                                                            theorem IterativeDomain.parallel_lift_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} (h : m + n ≤ o) {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            lift h (p.parallel q) = ⋯ ▸ p.parallel (lift ⋯ q)
                                                                            theorem IterativeDomain.parallel_lift_right' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {m n o : ℕ} (h : n ≤ o) {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            lift ⋯ (p.parallel q) = p.parallel (lift h q)
                                                                            theorem IterativeDomain.parallel_map_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [IMetricSpace δ] {f : β → δ} {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            (map f p).parallel q = map (Prod.map f id) (p.parallel q)
                                                                            theorem IterativeDomain.parallel_map_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [IMetricSpace δ] {f : γ → δ} {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} :
                                                                            p.parallel (map f q) = map (Prod.map id f) (p.parallel q)
                                                                            theorem IterativeDomain.parallel_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [IMetricSpace δ] {m n o : ℕ} {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α γ n} {r : IterativeDomain «Σ» Γ α δ o} :
                                                                            (p.parallel q).parallel r = ⋯ ▸ map (fun (x : β × γ × δ) => match x with | (x, y, z) => ((x, y), z)) (p.parallel (q.parallel r))
                                                                            noncomputable def DomainUnion.parallel {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace β] [IMetricSpace γ] :
                                                                            DomainUnion «Σ» Γ α β → DomainUnion «Σ» Γ α γ → DomainUnion «Σ» Γ α (β × γ)
                                                                            Equations
                                                                            Instances For
                                                                              theorem DomainUnion.parallel_lipschitz_left {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {q : DomainUnion «Σ» Γ α β} :
                                                                              LipschitzWith 1 fun (p : DomainUnion «Σ» Γ α γ) => p.parallel q
                                                                              theorem DomainUnion.parallel_lipschitz_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {p : DomainUnion «Σ» Γ α γ} :
                                                                              theorem DomainUnion.parallel_comm {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {p : DomainUnion «Σ» Γ α β} {q : DomainUnion «Σ» Γ α γ} :
                                                                              theorem DomainUnion.parallel_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [IMetricSpace δ] {p : DomainUnion «Σ» Γ α β} {q : DomainUnion «Σ» Γ α γ} {r : DomainUnion «Σ» Γ α δ} :
                                                                              (p.parallel q).parallel r = map (fun (x : β × γ × δ) => match x with | (x, y, z) => ((x, y), z)) (p.parallel (q.parallel r))
                                                                              noncomputable def Domain.parallel {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] :
                                                                              Domain «Σ» Γ α β → Domain «Σ» Γ α γ → Domain «Σ» Γ α (β × γ)

                                                                              Parallel composition. Generates all the possible interleavings as well as synchronizations.

                                                                              Equations
                                                                              Instances For
                                                                                theorem Domain.parallel_coe_coe {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {p : DomainUnion «Σ» Γ α β} {q : DomainUnion «Σ» Γ α γ} :
                                                                                parallel ↑p ↑q = ↑(p.parallel q)
                                                                                theorem Domain.parallel_comm {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] {p : Domain «Σ» Γ α β} {q : Domain «Σ» Γ α γ} :
                                                                                theorem Domain.parallel_assoc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {δ : Type z} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] [DecidableEq α] [DiscreteIMetricSpace α] [IMetricSpace β] [IMetricSpace γ] [IMetricSpace δ] {p : Domain «Σ» Γ α β} {q : Domain «Σ» Γ α γ} {r : Domain «Σ» Γ α δ} :
                                                                                (p.parallel q).parallel r = map (fun (x : β × γ × δ) => match x with | (x, y, z) => ((x, y), z)) (p.parallel (q.parallel r))

                                                                                Map leaves of the tree using a given function.

                                                                                Equations
                                                                                Instances For

                                                                                  Close a synchronous channel c in the tree, pruning subtrees accordingly.

                                                                                  Equations
                                                                                  Instances For

                                                                                    General form of sequential composition.

                                                                                    Equations
                                                                                    Instances For

                                                                                      Replace leaves of the tree with subtrees depending on the value of the leaves.

                                                                                      Equations
                                                                                      Instances For

                                                                                        Restricted form of sequential composition where all leaves are replaced with the same subtree.

                                                                                        Equations
                                                                                        Instances For

                                                                                          Non-deterministic choice, aka tree union.

                                                                                          Equations
                                                                                          Instances For

                                                                                            Remove branches that mention the synchronous channel c, but replace the pruning of all branches at a particular point by abortion.

                                                                                            Equations
                                                                                            Instances For

                                                                                              Parallel composition. Generates all the possible interleavings as well as synchronizations.

                                                                                              Equations
                                                                                              Instances For