Documentation

Core.Go.Semantics.Domains

theorem max_succ {m n : ℕ} :
max (m + 1) (n + 1) = max m n + 1

The semantics domains #

def Branch («Σ» : Type u) (Γ : Type v) (α : Type w) (γ : Type y) :
Type (max (max (max y w) v) (max (max y u) y v) (max y w) v)
Equations
  • One or more equations did not get rendered due to their size.
Instances For
    @[reducible, match_pattern, inline]
    abbrev Branch.recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} (c : Γ) (π : UniformFun α (UniformFun Bool (Restriction γ unitInterval.half _proof_2))) :
    Branch «Σ» Γ α γ
    Equations
    Instances For
      @[reducible, match_pattern, inline]
      abbrev Branch.send {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} (c : Γ) (v : α) (p : Restriction γ unitInterval.half _proof_2) :
      Branch «Σ» Γ α γ
      Equations
      Instances For
        @[reducible, match_pattern, inline]
        abbrev Branch.close {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} (c : Γ) (p : Restriction γ unitInterval.half _proof_2) :
        Branch «Σ» Γ α γ
        Equations
        Instances For
          @[reducible, match_pattern, inline]
          abbrev Branch.sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} (c : Γ) (p : Restriction γ unitInterval.half _proof_2) :
          Branch «Σ» Γ α γ
          Equations
          Instances For
            @[reducible, match_pattern, inline]
            abbrev Branch.next {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} (σ : «Σ») (p : Restriction γ unitInterval.half _proof_2) :
            Branch «Σ» Γ α γ
            Equations
            Instances For
              def Branch.casesOn {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {motive : Branch «Σ» Γ α γ → Sort u_1} (recv : (c : Γ) → (π : UniformFun α (UniformFun Bool (Restriction γ unitInterval.half _proof_2))) → motive (Branch.recv c π)) (send : (c : Γ) → (v : α) → (p : Restriction γ unitInterval.half _proof_2) → motive (Branch.send c v p)) (close : (c : Γ) → (p : Restriction γ unitInterval.half _proof_2) → motive (Branch.close c p)) (sync : (c : Γ) → (p : Restriction γ unitInterval.half _proof_2) → motive (Branch.sync c p)) (next : (σ : «Σ») → (p : Restriction γ unitInterval.half _proof_2) → motive (Branch.next σ p)) (b : Branch «Σ» Γ α γ) :
              motive b
              Equations
              Instances For
                @[implicit_reducible]
                noncomputable instance Branch.instPseudoIMetricSpace {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] :
                PseudoIMetricSpace (Branch «Σ» Γ α γ)
                Equations
                • One or more equations did not get rendered due to their size.
                @[implicit_reducible]
                noncomputable instance Branch.instIMetricSpace {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace γ] :
                IMetricSpace (Branch «Σ» Γ α γ)
                Equations
                instance Branch.instCompleteSpace {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [IMetricSpace «Σ»] [CompleteSpace «Σ»] [IMetricSpace Γ] [CompleteSpace Γ] [IMetricSpace α] [CompleteSpace α] [IMetricSpace γ] [CompleteSpace γ] :
                CompleteSpace (Branch «Σ» Γ α γ)
                @[simp]
                theorem Branch.idist_recv_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {c c' : Γ} {π π' : UniformFun α (UniformFun Bool (Restriction γ unitInterval.half _proof_2))} :
                idist (Branch.recv c π) (Branch.recv c' π') = max (idist c c') (idist π π')
                @[simp]
                theorem Branch.idist_send_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {c c' : Γ} {v v' : α} {p p' : Restriction γ unitInterval.half _proof_2} :
                idist (Branch.send c v p) (Branch.send c' v' p') = max (max (idist c c') (idist v v')) (idist p p')
                @[simp]
                theorem Branch.idist_sync_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {c c' : Γ} {p p' : Restriction γ unitInterval.half _proof_2} :
                idist (Branch.sync c p) (Branch.sync c' p') = max (idist c c') (idist p p')
                @[simp]
                theorem Branch.idist_close_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {c c' : Γ} {p p' : Restriction γ unitInterval.half _proof_2} :
                idist (Branch.close c p) (Branch.close c' p') = max (idist c c') (idist p p')
                @[simp]
                theorem Branch.idist_next_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {σ σ' : «Σ»} {p p' : Restriction γ unitInterval.half _proof_2} :
                idist (Branch.next σ p) (Branch.next σ' p') = max (idist σ σ') (idist p p')
                def IterativeDomain («Σ» : Type u) (Γ : Type v) (α : Type w) (β : Type x) :
                ℕ → Type (max u v w x)
                Equations
                Instances For
                  @[implicit_reducible]
                  instance instPseudoIMetricSpaceIterativeDomain («Σ» : Type u) (Γ : Type v) (α : Type w) (β : Type x) [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} :
                  Equations
                  • One or more equations did not get rendered due to their size.
                  theorem IterativeDomain.idist_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} (h : m = n) (p q : IterativeDomain «Σ» Γ α β m) :
                  idist p q = idist (h ▸ p) (h ▸ q)
                  theorem IterativeDomain.idist_cast' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} (h : m = n) (f : ℕ → ℕ) (p q : IterativeDomain «Σ» Γ α β (f m)) :
                  idist p q = idist (h ▸ p) (h ▸ q)
                  theorem IterativeDomain.Branch.idist_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} (h : m = n) (p q : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)) :
                  idist p q = idist (h ▸ p) (h ▸ q)
                  @[match_pattern]
                  def IterativeDomain.leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {n : ℕ} (v : β) :
                  IterativeDomain «Σ» Γ α β n
                  Equations
                  Instances For
                    @[simp]
                    theorem IterativeDomain.idist_leaf_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {v v' : β} {n : ℕ} :
                    idist (leaf v) (leaf v') = idist v v'
                    theorem IterativeDomain.leaf_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {v : β} {m n : ℕ} {h : m = n} :
                    h ▸ leaf v = leaf v
                    @[match_pattern]
                    def IterativeDomain.abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {n : ℕ} :
                    IterativeDomain «Σ» Γ α β n
                    Equations
                    Instances For
                      theorem IterativeDomain.abort_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} {h : m = n} :
                      @[simp]
                      @[simp]
                      theorem IterativeDomain.idist_abort_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} {v : β} :
                      @[simp]
                      theorem IterativeDomain.idist_leaf_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} {v : β} :
                      @[match_pattern]
                      def IterativeDomain.branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {n : ℕ} (f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))) :
                      IterativeDomain «Σ» Γ α β (n + 1)
                      Equations
                      Instances For
                        theorem jsp {m n : ℕ} (h : m + 1 = n) :
                        n - 1 + 1 = n
                        theorem IterativeDomain.branch_cast {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m + 1 = n + 1) (f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)))) :
                        h ▸ branch f = branch fun (σ : «Σ») => ⋯ ▸ f σ
                        theorem IterativeDomain.branch_cast' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m + 1 = n) (f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)))) :
                        h ▸ branch f = ⋯ ▸ branch fun (σ : «Σ») => ⋯ ▸ f σ
                        @[simp]
                        theorem IterativeDomain.idist_leaf_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} {v : β} {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
                        @[simp]
                        theorem IterativeDomain.idist_branch_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} {v : β} {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
                        @[simp]
                        theorem IterativeDomain.idist_abort_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
                        @[simp]
                        theorem IterativeDomain.idist_branch_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
                        @[simp]
                        theorem IterativeDomain.idist_branch_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} {f g : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))} :
                        idist (branch f) (branch g) = ⨆ (σ : «Σ»), IMetric.hausdorffIDist (f σ) (g σ)
                        theorem IterativeDomain.Branch.cast_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m = n) {π : UniformFun α (UniformFun Bool (Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half Branch._proof_2))} {c : Γ} :
                        h ▸ Branch.recv c π = Branch.recv c fun (v : α) (ok : Bool) => { val := h ▸ (π v ok).val }
                        theorem IterativeDomain.Branch.cast_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m = n) {c : Γ} {v : α} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half Branch._proof_2} :
                        h ▸ Branch.send c v p = Branch.send c v { val := h ▸ p.val }
                        theorem IterativeDomain.Branch.cast_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m = n) {c : Γ} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half Branch._proof_2} :
                        h ▸ Branch.close c p = Branch.close c { val := h ▸ p.val }
                        theorem IterativeDomain.Branch.cast_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m = n) {c : Γ} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half Branch._proof_2} :
                        h ▸ Branch.sync c p = Branch.sync c { val := h ▸ p.val }
                        theorem IterativeDomain.Branch.cast_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m = n) {σ : «Σ»} {p : Restriction (IterativeDomain «Σ» Γ α β m) unitInterval.half Branch._proof_2} :
                        h ▸ Branch.next σ p = Branch.next σ { val := h ▸ p.val }

                        Lifting depth of trees #

                        noncomputable def Branch.map {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} (g : γ → γ') :
                        Branch «Σ» Γ α γ → Branch «Σ» Γ α γ'
                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          theorem Branch.map_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {f : γ → γ'} {c : Γ} {π : UniformFun α (UniformFun Bool (Restriction γ unitInterval.half _proof_2))} :
                          map f (Branch.recv c π) = Branch.recv c fun (v : α) (ok : Bool) => Restriction.map f (π v ok)
                          theorem Branch.map_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {f : γ → γ'} {c : Γ} {v : α} {x : Restriction γ unitInterval.half _proof_2} :
                          theorem Branch.map_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {f : γ → γ'} {c : Γ} {x : Restriction γ unitInterval.half _proof_2} :
                          theorem Branch.map_sync {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {f : γ → γ'} {c : Γ} {x : Restriction γ unitInterval.half _proof_2} :
                          theorem Branch.map_next {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {f : γ → γ'} {σ : «Σ»} {x : Restriction γ unitInterval.half _proof_2} :
                          theorem IterativeDomain.Branch.map_cast_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {γ : Type y} {m n o : ℕ} (h : n = o) {b : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)} {f : IterativeDomain «Σ» Γ α β m → IterativeDomain «Σ» Γ α γ n} :
                          h ▸ Branch.map f b = Branch.map (fun (x : IterativeDomain «Σ» Γ α β m) => h ▸ f x) b
                          theorem Branch.map_eq_recv {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {c : Γ} {π : UniformFun α (UniformFun Bool (Restriction γ' unitInterval.half _proof_2))} {f : γ → γ'} {b : Branch «Σ» Γ α γ} (h : map f b = Branch.recv c π) :
                          theorem Branch.map_eq_recv' {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {c : Γ} {π : UniformFun α (UniformFun Bool (Restriction γ' unitInterval.half _proof_2))} {f : γ → γ'} {b : Branch «Σ» Γ α γ} (h : map f b = Branch.recv c π) :
                          ∃ (π' : UniformFun α (UniformFun Bool (Restriction γ unitInterval.half _proof_2))), b = Branch.recv c π' ∧ π = fun (v : α) (ok : Bool) => Restriction.map f (π' v ok)
                          theorem Branch.map_eq_send {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {c : Γ} {v : α} {p : Restriction γ' unitInterval.half _proof_2} {f : γ → γ'} {b : Branch «Σ» Γ α γ} (h : map f b = Branch.send c v p) :
                          theorem Branch.map_eq_send' {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {c : Γ} {v : α} {p : Restriction γ' unitInterval.half _proof_2} {f : γ → γ'} {b : Branch «Σ» Γ α γ} (h : map f b = Branch.send c v p) :
                          theorem Branch.map_eq_close {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {c : Γ} {p : Restriction γ' unitInterval.half _proof_2} {f : γ → γ'} {b : Branch «Σ» Γ α γ} (h : map f b = Branch.close c p) :
                          theorem Branch.map_isometry' {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {γ' : Type y} [PseudoIMetricSpace γ'] {g : γ → γ'} (hg : ∀ (x y : γ), idist (g x) (g y) = idist x y) (x y : Branch «Σ» Γ α γ) :
                          idist (map g x) (map g y) = idist x y
                          theorem Branch.map_isometry {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {γ' : Type y} [PseudoIMetricSpace γ'] {g : γ → γ'} (hg : Isometry g) :
                          theorem Branch.map_uniform_continuous {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] [PseudoIMetricSpace γ] {γ' : Type u_1} [PseudoIMetricSpace γ'] {g : γ → γ'} (hg : UniformContinuous g) :
                          theorem Branch.map_comp {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {γ'' : Type u_2} (f : γ → γ') (g : γ' → γ'') :
                          map g ∘ map f = map (g ∘ f)
                          theorem Branch.map_comp' {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} {γ' : Type u_1} {γ'' : Type u_2} (f : γ → γ') (g : γ' → γ'') {b : Branch «Σ» Γ α γ} :
                          map g (map f b) = map (g ∘ f) b
                          theorem Branch.map_id {«Σ» : Type u} {Γ : Type v} {α : Type w} {γ : Type y} :
                          theorem Branch.map_idist_le_left' {«Σ» : Type u} {Γ : Type v} {α : Type w} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {γ : Type u_1} {γ' : Type u_2} [PseudoIMetricSpace γ] [PseudoIMetricSpace γ'] {g g' : γ → γ'} {r : ℝ} (hr' : 0 ≤ r) (hr : ∀ (x : γ), ↑unitInterval.half * ↑(idist (g x) (g' x)) ≤ r) (b : Branch «Σ» Γ α γ) :
                          ↑(idist (map g b) (map g' b)) ≤ r
                          theorem Branch.map_idist_le_left {«Σ» : Type u} {Γ : Type v} {α : Type w} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {γ : Type u_1} {γ' : Type u_2} [PseudoIMetricSpace γ] [PseudoIMetricSpace γ'] {g g' : γ → γ'} {r : ↑unitInterval} (hr : ∀ (x : γ), unitInterval.half * idist (g x) (g' x) ≤ r) (b : Branch «Σ» Γ α γ) :
                          idist (map g b) (map g' b) ≤ r
                          theorem Branch.map_idist_le_right' {«Σ» : Type u} {Γ : Type v} {α : Type w} [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {γ : Type u_1} {γ' : Type u_2} [PseudoIMetricSpace γ] [PseudoIMetricSpace γ'] {g : γ → γ'} {r : ℝ} (hr' : 1 ≤ r) (hr : ∀ (x y : γ), ↑(idist (g x) (g y)) ≤ r * ↑(idist x y)) (b b' : Branch «Σ» Γ α γ) :
                          ↑(idist (map g b) (map g b')) ≤ r * ↑(idist b b')
                          def IterativeDomain.lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m ≤ n := by linarith) :
                          IterativeDomain «Σ» Γ α β m → IterativeDomain «Σ» Γ α β n
                          Equations
                          Instances For
                            @[simp]
                            theorem IterativeDomain.lift_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m ≤ n) {v : β} :
                            lift h (leaf v) = leaf v
                            @[simp]
                            theorem IterativeDomain.lift_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m ≤ n) :
                            @[simp]
                            theorem IterativeDomain.lift_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m + 1 ≤ n + 1) {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)))} :
                            lift h (branch f) = branch fun (σ : «Σ») => Branch.map (lift ⋯) '' f σ
                            theorem IterativeDomain.lift_branch' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n : ℕ} (h : m + 1 ≤ n) {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)))} :
                            lift h (branch f) = ⋯ ▸ branch fun (σ : «Σ») => Branch.map (lift ⋯) '' f σ
                            theorem IterativeDomain.lift_cast_left_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n o : ℕ} {h : m ≤ n} {h' : n = o} {p : IterativeDomain «Σ» Γ α β m} :
                            h' ▸ lift h p = lift ⋯ p
                            theorem IterativeDomain.lift_cast_right {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m n o : ℕ} {h : m ≤ n} {h' : m = o} {p : IterativeDomain «Σ» Γ α β m} :
                            lift ⋯ (h' ▸ p) = lift h p
                            theorem IterativeDomain.lift_refl {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {m : ℕ} :
                            lift ⋯ = id
                            theorem IterativeDomain.lift_refl_of_eq {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {k k' m n : ℕ} (h : m = n) (h' : k = k') {h'' : m ≤ k} :
                            lift h'' = Eq.rec (motive := fun (x : ℕ) (h : n = x) => IterativeDomain «Σ» Γ α β x → IterativeDomain «Σ» Γ α β k) (Eq.rec (motive := fun (x : ℕ) (h : k' = x) => IterativeDomain «Σ» Γ α β n → IterativeDomain «Σ» Γ α β x) (lift ⋯) ⋯) ⋯
                            theorem IterativeDomain.lift_refl_of_eq' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {k k' m n : ℕ} (h : m = n) (h' : k = k') {h'' : m ≤ k} {x : IterativeDomain «Σ» Γ α β m} :
                            lift h'' x = ⋯ ▸ lift ⋯ (h ▸ x)
                            theorem IterativeDomain.lift_isometry {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} (h : m ≤ n) :
                            theorem IterativeDomain.lift_isometry' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} (h : m ≤ n) {x y : IterativeDomain «Σ» Γ α β m} :
                            idist (lift h x) (lift h y) = idist x y
                            theorem IterativeDomain.lift_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n o : ℕ} (h₁ : m ≤ n) (h₂ : n ≤ o) :
                            lift h₂ ∘ lift h₁ = lift ⋯
                            theorem IterativeDomain.lift_lift' {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n o : ℕ} (h₁ : m ≤ n) (h₂ : n ≤ o) {p : IterativeDomain «Σ» Γ α β m} :
                            lift h₂ (lift h₁ p) = lift ⋯ p
                            theorem IterativeDomain.idist_lift_lift {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n o o' : ℕ} (h₁ : m ≤ o) (h₂ : n ≤ o) (h₃ : m ≤ o') (h₄ : n ≤ o') {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α β n} :
                            idist (lift h₁ p) (lift h₂ q) = idist (lift h₃ p) (lift h₄ q)
                            def IterativeDomain.trunc {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {n m : ℕ} :
                            n ≤ m → IterativeDomain «Σ» Γ α β m → IterativeDomain «Σ» Γ α β n
                            Equations
                            Instances For
                              def DomainUnion («Σ» : Type u) (Γ : Type v) (α : Type w) (β : Type x) :
                              Type (max (max (max x w) v) u)
                              Equations
                              Instances For
                                @[reducible, inline]
                                abbrev DomainUnion.mk {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} {n : ℕ} (x : IterativeDomain «Σ» Γ α β n) :
                                DomainUnion «Σ» Γ α β
                                Equations
                                Instances For
                                  @[reducible, inline]
                                  noncomputable abbrev DomainUnion.idist {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] :
                                  DomainUnion «Σ» Γ α β → DomainUnion «Σ» Γ α β → ↑unitInterval
                                  Equations
                                  Instances For
                                    theorem DomainUnion.idist_self {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (x : DomainUnion «Σ» Γ α β) :
                                    x.idist x = 0
                                    theorem DomainUnion.idist_comm {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (x y : DomainUnion «Σ» Γ α β) :
                                    x.idist y = y.idist x
                                    theorem DomainUnion.idist_triangle {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (x y z : DomainUnion «Σ» Γ α β) :
                                    ↑(x.idist z) ≤ ↑(x.idist y) + ↑(y.idist z)
                                    @[implicit_reducible]
                                    noncomputable instance instPseudoIMetricSpaceDomainUnion {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] :
                                    Equations
                                    theorem DomainUnion.idist_eq {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} {p : IterativeDomain «Σ» Γ α β m} {q : IterativeDomain «Σ» Γ α β n} :
                                    theorem DomainUnion.mk_isometry {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n : ℕ} :
                                    theorem DomainUnion.lift_idist_zero {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n m : ℕ} (h : n ≤ m) (x : IterativeDomain «Σ» Γ α β n) :
                                    theorem IterativeDomain.trunc_idist {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n m : ℕ} (h : n ≤ m) (x : IterativeDomain «Σ» Γ α β m) :
                                    ↑(DomainUnion.idist ⟨m, x⟩ ⟨n, trunc h x⟩) ≤ (1 / 2) ^ n
                                    @[reducible, inline]
                                    abbrev Domain («Σ» : Type u) (Γ : Type v) (α : Type w) (β : Type x) [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] :
                                    Type (max (max (max x w) v) u)
                                    Equations
                                    Instances For
                                      theorem UniformSpace.Completion.dist_le_iff {α : Type u_1} [PseudoMetricSpace α] {ε : ℝ} (h : ∀ (x y : α), dist x y ≤ ε) (x y : Completion α) :
                                      dist x y ≤ ε
                                      theorem UniformSpace.Completion.idist_eq {α : Type u} [PseudoIMetricSpace α] (x y : α) :
                                      idist ↑x ↑y = idist x y
                                      theorem Domain.edist_eq («Σ» : Type u) (Γ : Type v) (α : Type w) (β : Type x) [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {x y : Domain «Σ» Γ α β} :
                                      theorem Domain.dist_eq («Σ» : Type u) (Γ : Type v) (α : Type w) (β : Type x) [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {x y : Domain «Σ» Γ α β} :
                                      dist x y = ↑(idist x y)
                                      @[reducible, inline]
                                      noncomputable abbrev embedAt {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (n : ℕ) (x : IterativeDomain «Σ» Γ α β n) :
                                      Domain «Σ» Γ α β
                                      Equations
                                      Instances For
                                        theorem embedAt_lift_eq {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} (h : m ≤ n) (p : IterativeDomain «Σ» Γ α β m) :
                                        theorem embedAt_comp_lift_eq {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m n : ℕ} (h : m ≤ n) :
                                        theorem embedAt_isometry {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {m : ℕ} :
                                        theorem embedAt_idist_eq {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] {n m : ℕ} (x : IterativeDomain «Σ» Γ α β n) (y : IterativeDomain «Σ» Γ α β m) :
                                        ↑(idist (embedAt n x) (embedAt m y)) = ↑(DomainUnion.idist ⟨n, x⟩ ⟨m, y⟩)
                                        def φ {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] :
                                        DomainUnion «Σ» Γ α β → β ⊕ PUnit.{x + 1} ⊕ UniformFun «Σ» (TopologicalSpace.Closeds (Branch «Σ» Γ α (Domain «Σ» Γ α β)))
                                        Equations
                                        Instances For
                                          theorem Domain.approx_uniform {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (d : Domain «Σ» Γ α β) (n : ℕ) :
                                          ∃ (x : IterativeDomain «Σ» Γ α β n), ↑(idist d (embedAt n x)) < 2 * (1 / 2) ^ n
                                          theorem Branch.approx_uniform_depth {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (b : Branch «Σ» Γ α (Domain «Σ» Γ α β)) (n : ℕ) :
                                          ∃ (b_n : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)), ↑(idist b (map (embedAt n) b_n)) ≤ (1 / 2) ^ n
                                          theorem Branch.approx_at_depth {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (b : Branch «Σ» Γ α (Domain «Σ» Γ α β)) {ε : ℝ} (hε : 0 < ε) :
                                          ∃ (n : ℕ) (b_n : Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)), ↑(idist b (map (embedAt n) b_n)) < ε
                                          theorem Closeds.Branch.approx_uniform {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] (h : «Σ» → TopologicalSpace.Closeds (Branch «Σ» Γ α (Domain «Σ» Γ α β))) {ε : ℝ} (hε : 0 < ε) :
                                          ∃ (n : ℕ), ∀ (σ : «Σ»), ∃ (T : Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n))), ↑(IMetric.hausdorffIDist (closure (Branch.map (embedAt n) '' T)) ↑(h σ)) ≤ ε / 2
                                          theorem φ_dense {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] :
                                          theorem φ_isometry {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [PseudoIMetricSpace β] [PseudoIMetricSpace «Σ»] [PseudoIMetricSpace Γ] [PseudoIMetricSpace α] :
                                          noncomputable def Domain.isSolution {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                          Domain «Σ» Γ α β ≃ᵢ β ⊕ PUnit.{x + 1} ⊕ UniformFun «Σ» (TopologicalSpace.Closeds (Branch «Σ» Γ α (Domain «Σ» Γ α β)))

                                          We establish the equivalence in order to prove that our defined domain is a solution to the original equation.

                                          Equations
                                          Instances For
                                            noncomputable def Domain.abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                            Domain «Σ» Γ α β
                                            Equations
                                            Instances For
                                              noncomputable def Domain.leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] (v : β) :
                                              Domain «Σ» Γ α β
                                              Equations
                                              Instances For
                                                noncomputable def Domain.branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] (f : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α β)))) :
                                                Domain «Σ» Γ α β
                                                Equations
                                                Instances For
                                                  @[implicit_reducible]
                                                  noncomputable instance instInhabitedDomain {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                                  Inhabited (Domain «Σ» Γ α β)
                                                  Equations
                                                  theorem Domain.idist_leaf_leaf {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] {v v' : β} :
                                                  idist (leaf v) (leaf v') = idist v v'
                                                  theorem Domain.idist_abort_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                                  theorem Domain.idist_branch_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] {f f' : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α β)))} :
                                                  idist (branch f) (branch f') = ⨆ (σ : «Σ»), idist (f σ) (f' σ)
                                                  theorem Domain.idist_abort_branch {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α β)))} :
                                                  theorem Domain.idist_branch_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] {f : UniformFun «Σ» (Set (Branch «Σ» Γ α (Domain «Σ» Γ α β)))} :
                                                  instance instNonemptyDomain {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                                  Nonempty (Domain «Σ» Γ α β)
                                                  theorem Domain.isOpen_singleton_abort {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                                  theorem Domain.exists_abort_eq {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] :
                                                  theorem Domain.coe_eq_abort_iff {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] {p : DomainUnion «Σ» Γ α β} :
                                                  theorem Domain.coe_eq_branch_iff {«Σ» : Type u} {Γ : Type v} {α : Type w} {β : Type x} [IMetricSpace «Σ»] [IMetricSpace Γ] [IMetricSpace α] [IMetricSpace β] [CompleteSpace «Σ»] [CompleteSpace Γ] [CompleteSpace α] [CompleteSpace β] {p : DomainUnion «Σ» Γ α β} {f : «Σ» → Set (Branch «Σ» Γ α (Domain «Σ» Γ α β))} :
                                                  ↑p = branch f ↔ ∃ (m : ℕ) (g : UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β m)))), p = ⟨m + 1, IterativeDomain.branch g⟩ ∧ ∀ (σ : «Σ»), closure (Branch.map (embedAt m) '' g σ) = closure (f σ)
                                                  inductive Value.Send𝕍 (ℍ : Type y) (Typ : Type w) :
                                                  Type (max w y)

                                                  The type of values that can be sent through channels.

                                                  Instances For
                                                    @[implicit_reducible]
                                                    instance Value.instDecidableEqSend𝕍 (ℍ : Type y) (Typ : Type w) :
                                                    Equations
                                                    @[implicit_reducible]
                                                    Equations
                                                    instance Value.instCompleteSpaceSend𝕍 (ℍ : Type y) (Typ : Type w) :
                                                    @[reducible, inline]
                                                    abbrev Value.F («Σ» : Type u) (Γ : Type v) [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] (ℍ : Type y) (Typ : Type w) (𝕍 : Type x) [IMetricSpace 𝕍] :
                                                    Type (max u v w x y)
                                                    Equations
                                                    • One or more equations did not get rendered due to their size.
                                                    Instances For
                                                      @[implicit_reducible]
                                                      noncomputable instance Value.instIMetricSpaceF {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] {𝕍 : Type u} [IMetricSpace 𝕍] :
                                                      IMetricSpace (Value.F «Σ» Γ ℍ Typ 𝕍)
                                                      Equations

                                                      𝕍 is constructed similarly to Domain. This is painful, and we know that it will work.

                                                        For now, let's just axiomatize `𝕍`. We know it exists (from various results
                                                        of domain theory), we just don't construct them yet.
                                                        `𝕍` is just very cumbersome to define and construct. We'll leave this as
                                                        future work for now.
                                                      
                                                      axiom Value.𝕍 («Σ» : Type u) (Γ : Type v) (ℍ : Type w) (Typ : Type x) :
                                                      instance Value.instNonemptyType𝕍 {«Σ» : Type u} {Γ : Type v} {ℍ : Type y} {Typ : Type w} :
                                                      Nonempty (𝕍 «Σ» Γ ℍ Typ).type
                                                      axiom Value.𝕍_metricSpace {«Σ» : Type u} {Γ : Type v} {ℍ : Type y} {Typ : Type w} :
                                                      IMetricSpace (𝕍 «Σ» Γ ℍ Typ).type
                                                      axiom Value.𝕍_iso {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] :
                                                      (𝕍 «Σ» Γ ℍ Typ).type ≃ᵢ Value.F «Σ» Γ ℍ Typ (𝕍 «Σ» Γ ℍ Typ).type

                                                      Axiomatize the fact that 𝕍 is a solution to the recursive domain equation 𝕍 = F(𝕍).

                                                      axiom Value.𝕍_complete {«Σ» : Type u} {Γ : Type v} {ℍ : Type y} {Typ : Type w} :
                                                      CompleteSpace (𝕍 «Σ» Γ ℍ Typ).type
                                                      axiom Value.𝕍_isSend {«Σ» : Type u} {Γ : Type v} {ℍ : Type y} {Typ : Type w} :
                                                      (𝕍 «Σ» Γ ℍ Typ).type → Prop
                                                      axiom Value.𝕍_isSend_decidable {«Σ» : Type u} {Γ : Type v} {ℍ : Type y} {Typ : Type w} {v : (𝕍 «Σ» Γ ℍ Typ).type} :
                                                      axiom Value.𝕍_extract {«Σ» : Type u} {Γ : Type v} {ℍ : Type y} {Typ : Type w} (v : (𝕍 «Σ» Γ ℍ Typ).type) (isSend : 𝕍_isSend v) :
                                                      Send𝕍 ℍ Typ
                                                      noncomputable def Value.𝕍.bool {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (b : Bool) :
                                                      (𝕍 «Σ» Γ ℍ Typ).type
                                                      Equations
                                                      Instances For
                                                        noncomputable def Value.𝕍.int {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (n : ℤ) :
                                                        (𝕍 «Σ» Γ ℍ Typ).type
                                                        Equations
                                                        Instances For
                                                          noncomputable def Value.𝕍.str {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (s : String) :
                                                          (𝕍 «Σ» Γ ℍ Typ).type
                                                          Equations
                                                          Instances For
                                                            noncomputable def Value.𝕍.slice {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (cap low high : ℕ) (array : ℍ) :
                                                            (𝕍 «Σ» Γ ℍ Typ).type
                                                            Equations
                                                            Instances For
                                                              noncomputable def Value.𝕍.chan {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (length : ℍ) (τ : Typ) (array closed : ℍ) :
                                                              (𝕍 «Σ» Γ ℍ Typ).type
                                                              Equations
                                                              Instances For
                                                                noncomputable def Value.𝕍.struct {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (fields : UniformFun String (Option (𝕍 «Σ» Γ ℍ Typ).type)) :
                                                                (𝕍 «Σ» Γ ℍ Typ).type
                                                                Equations
                                                                Instances For
                                                                  noncomputable def Value.𝕍.array {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (len : ℕ) (indices : UniformFun (Fin len) (𝕍 «Σ» Γ ℍ Typ).type) :
                                                                  (𝕍 «Σ» Γ ℍ Typ).type
                                                                  Equations
                                                                  Instances For
                                                                    noncomputable def Value.𝕍.map {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (maps : UniformFun (𝕍 «Σ» Γ ℍ Typ).type (Option ℍ)) (τ : Typ) (isNil : Bool) :
                                                                    (𝕍 «Σ» Γ ℍ Typ).type
                                                                    Equations
                                                                    Instances For
                                                                      noncomputable def Value.𝕍.func {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (call : UniformFun (List ℍ × List Γ) (Domain «Σ» Γ (Send𝕍 ℍ Typ) PUnit.{(max (max (max u v) w) y) + 1})) :
                                                                      (𝕍 «Σ» Γ ℍ Typ).type
                                                                      Equations
                                                                      • One or more equations did not get rendered due to their size.
                                                                      Instances For
                                                                        noncomputable def Value.𝕍.tuple {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] (vs : List (𝕍 «Σ» Γ ℍ Typ).type) :
                                                                        (𝕍 «Σ» Γ ℍ Typ).type
                                                                        Equations
                                                                        • One or more equations did not get rendered due to their size.
                                                                        Instances For
                                                                          axiom Value.𝕍_isSend.tuple {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] {vs : List (𝕍 «Σ» Γ ℍ Typ).type} (h : ∀ v ∈ vs, 𝕍_isSend v) :
                                                                          noncomputable def Value.Send𝕍.to𝕍 {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] :
                                                                          Send𝕍 ℍ Typ → (𝕍 «Σ» Γ ℍ Typ).type
                                                                          Equations
                                                                          • One or more equations did not get rendered due to their size.
                                                                          Instances For
                                                                            noncomputable def Value.𝕍.casesOn {«Σ» : Type u} {Γ : Type v} [IMetricSpace «Σ»] [DecidableEq Γ] [DiscreteIMetricSpace Γ] {ℍ : Type y} {Typ : Type w} [IMetricSpace ℍ] [IMetricSpace Typ] {motive : (𝕍 «Σ» Γ ℍ Typ).type → Sort u_1} (bool : (b : Bool) → motive (bool b)) (int : (n : ℤ) → motive (int n)) (str : (s : String) → motive (str s)) (slice : (cap low high : ℕ) → (array : ℍ) → motive (slice cap low high array)) (chan : (len : ℍ) → (τ : Typ) → (array closed : ℍ) → motive (chan len τ array closed)) (struct : (fields : UniformFun String (Option (𝕍 «Σ» Γ ℍ Typ).type)) → motive (struct fields)) (array : (len : ℕ) → (indices : UniformFun (Fin len) (𝕍 «Σ» Γ ℍ Typ).type) → motive (array len indices)) (map : (maps : UniformFun (𝕍 «Σ» Γ ℍ Typ).type (Option ℍ)) → (τ : Typ) → (isNil : Bool) → motive (map maps τ isNil)) (func : (call : UniformFun (List ℍ × List Γ) (Domain «Σ» Γ (Send𝕍 ℍ Typ) PUnit.{(max (max (max u v) w) y) + 1})) → motive (func call)) (tuple : (vs : List (𝕍 «Σ» Γ ℍ Typ).type) → motive (tuple vs)) (v : (𝕍 «Σ» Γ ℍ Typ).type) :
                                                                            motive v
                                                                            Equations
                                                                            • One or more equations did not get rendered due to their size.
                                                                            Instances For
                                                                              @[implicit_reducible]
                                                                              noncomputable instance instDecidableEqTyp :

                                                                              Go.Typ's equality, decided classically: nothing in the compiler pipeline computes it, it exists only to satisfy IMetricSpace.discrete's constraint below.

                                                                              Equations
                                                                              @[implicit_reducible]

                                                                              Go.Typ's metric: discrete, since Value.𝕍's Typ parameter is opaque throughout Domains.lean — nothing there inspects which two types are equal, only whether they are.

                                                                              Equations
                                                                              @[reducible, inline]
                                                                              abbrev Address :
                                                                              Equations
                                                                              Instances For
                                                                                @[reducible, inline]
                                                                                abbrev nil :
                                                                                Equations
                                                                                Instances For
                                                                                  @[reducible, inline]
                                                                                  abbrev dummy :
                                                                                  Equations
                                                                                  Instances For
                                                                                    @[implicit_reducible]
                                                                                    Equations
                                                                                    Equations
                                                                                    Instances For
                                                                                      @[implicit_reducible]
                                                                                      Equations
                                                                                      noncomputable def Store.type.ϙ :
                                                                                      Equations
                                                                                      Instances For
                                                                                        noncomputable def Store.popϙ (σ : Store.type) :
                                                                                        Equations
                                                                                        Instances For
                                                                                          Equations
                                                                                          Instances For
                                                                                            noncomputable def Store.insert (σ : Store.type) (addr : Address) (v : (Value.𝕍 Store.type Channel Address Go.Typ).type) :
                                                                                            Equations
                                                                                            Instances For
                                                                                              Equations
                                                                                              Instances For
                                                                                                noncomputable def Store.freshAddr (σ : Store.type) :
                                                                                                Equations
                                                                                                Instances For
                                                                                                  noncomputable def Store.addrOf (σ : Store.type) (x : String) :
                                                                                                  Equations
                                                                                                  Instances For
                                                                                                    noncomputable def Store.register (σ : Store.type) (x : String) (addr : Address) :
                                                                                                    Equations
                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                    Instances For
                                                                                                      Equations
                                                                                                      • One or more equations did not get rendered due to their size.
                                                                                                      Instances For