The semantics domains #
@[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 «Σ» Γ α γ
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 «Σ» Γ α γ
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 «Σ» Γ α γ
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 «Σ» Γ α γ
Instances For
@[reducible, match_pattern, inline]
abbrev
Branch.next
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{γ : Type y}
(σ : «Σ»)
(p : Restriction γ unitInterval.half _proof_2)
:
Branch «Σ» Γ α γ
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
- Branch.casesOn recv send close sync next (Sum.inl (c, π)) = recv c π
- Branch.casesOn recv send close sync next (Sum.inr (Sum.inl (c, v, p))) = send c v p
- Branch.casesOn recv send close sync next (Sum.inr (Sum.inr (Sum.inl (c, p)))) = close c p
- Branch.casesOn recv send close sync next (Sum.inr (Sum.inr (Sum.inr (Sum.inl (c, p))))) = sync c p
- Branch.casesOn recv send close sync next (Sum.inr (Sum.inr (Sum.inr (Sum.inr (σ, p))))) = next σ p
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.
instance
instIsUltrametricIDistBranch
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{γ : Type y}
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
[PseudoIMetricSpace γ]
[IsUltrametricIDist «Σ»]
[IsUltrametricIDist Γ]
[IsUltrametricIDist α]
[IsUltrametricIDist γ]
:
IsUltrametricIDist (Branch «Σ» Γ α γ)
@[implicit_reducible]
noncomputable instance
Branch.instIMetricSpace
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{γ : Type y}
[IMetricSpace «Σ»]
[IMetricSpace Γ]
[IMetricSpace α]
[IMetricSpace γ]
:
IMetricSpace (Branch «Σ» Γ α γ)
Equations
- Branch.instIMetricSpace = { toPseudoIMetricSpace := Branch.instPseudoIMetricSpace, eq_of_idist_eq_zero := ⋯ }
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))}
:
@[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}
:
@[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}
:
@[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}
:
@[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}
:
Equations
- IterativeDomain «Σ» Γ α β 0 = (β ⊕ PUnit.{(max ?u.4 ?u.3 ?u.2) + 1})
- IterativeDomain «Σ» Γ α β n.succ = (β ⊕ PUnit.{?u.8 + 1} ⊕ UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n))))
Instances For
@[implicit_reducible]
instance
instPseudoIMetricSpaceIterativeDomain
(«Σ» : Type u)
(Γ : Type v)
(α : Type w)
(β : Type x)
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
{n : ℕ}
:
PseudoIMetricSpace (IterativeDomain «Σ» Γ α β n)
Equations
- One or more equations did not get rendered due to their size.
instance
instUltrametricIDistIterativeDomain
(«Σ» : Type u)
(Γ : Type v)
(α : Type w)
(β : Type x)
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
{n : ℕ}
[IsUltrametricIDist «Σ»]
[IsUltrametricIDist Γ]
[IsUltrametricIDist α]
[IsUltrametricIDist β]
:
IsUltrametricIDist (IterativeDomain «Σ» Γ α β n)
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)
:
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))
:
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))
:
@[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 : ℕ}
:
@[match_pattern]
def
IterativeDomain.abort
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
{n : ℕ}
:
IterativeDomain «Σ» Γ α β n
Equations
Instances For
@[simp]
theorem
IterativeDomain.idist_abort_abort
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
{n : ℕ}
:
@[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
@[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)))}
:
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 : Γ}
:
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}
:
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}
:
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}
:
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}
:
Lifting depth of trees #
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))}
:
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}
:
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 π'
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)
:
∃ (p' : Restriction γ unitInterval.half _proof_2), 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)
:
∃ (p' : Restriction γ unitInterval.half _proof_2), b = Branch.send c v p' ∧ p = Restriction.map f 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)
:
∃ (p' : Restriction γ unitInterval.half _proof_2), 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 «Σ» Γ α γ)
:
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)
:
UniformContinuous (map g)
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 «Σ» Γ α γ)
:
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 «Σ» Γ α γ)
:
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 «Σ» Γ α γ)
:
def
IterativeDomain.lift
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
{m n : ℕ}
(h : m ≤ n := by linarith)
:
IterativeDomain «Σ» Γ α β m → IterativeDomain «Σ» Γ α β n
Equations
- IterativeDomain.lift h_2 = id
- IterativeDomain.lift h_2 = Sum.elim (fun (v : β) => Sum.inl v) fun (x : PUnit.{(max ?u.8 ?u.7 ?u.6) + 1}) => IterativeDomain.abort
- IterativeDomain.lift h_2 = Sum.map id (Sum.map id (UniformFun.map (Set.image (Branch.map (IterativeDomain.lift ⋯)))))
Instances For
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_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}
:
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)
:
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}
:
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}
:
def
IterativeDomain.trunc
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
{n m : ℕ}
:
n ≤ m → IterativeDomain «Σ» Γ α β m → IterativeDomain «Σ» Γ α β n
Equations
- One or more equations did not get rendered due to their size.
- IterativeDomain.trunc x_4 x_5 = x_5
- IterativeDomain.trunc x_4 x_5 = Sum.elim Sum.inl (fun (x : PUnit.{?u.8 + 1} ⊕ UniformFun «Σ» (Set (Branch «Σ» Γ α (IterativeDomain «Σ» Γ α β n)))) => Sum.inr PUnit.unit) x_5
Instances For
def
DomainUnion
(«Σ» : Type u)
(Γ : Type v)
(α : Type w)
(β : Type x)
:
Type (max (max (max x w) v) u)
Equations
- DomainUnion «Σ» Γ α β = ((n : ℕ) × IterativeDomain «Σ» Γ α β n)
Instances For
@[reducible, inline]
abbrev
DomainUnion.mk
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
{n : ℕ}
(x : IterativeDomain «Σ» Γ α β n)
:
DomainUnion «Σ» Γ α β
Equations
- DomainUnion.mk x = ⟨n, x⟩
Instances For
@[reducible, inline]
noncomputable abbrev
DomainUnion.idist
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
:
DomainUnion «Σ» Γ α β → DomainUnion «Σ» Γ α β → ↑unitInterval
Equations
- DomainUnion.idist ⟨m, p⟩ ⟨n, q⟩ = idist (IterativeDomain.lift ⋯ p) (IterativeDomain.lift ⋯ q)
Instances For
theorem
DomainUnion.idist_self
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
(x : DomainUnion «Σ» Γ α β)
:
theorem
DomainUnion.idist_comm
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
(x y : DomainUnion «Σ» Γ α β)
:
theorem
DomainUnion.idist_triangle
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
(x y z : DomainUnion «Σ» Γ α β)
:
@[implicit_reducible]
noncomputable instance
instPseudoIMetricSpaceDomainUnion
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
:
PseudoIMetricSpace (DomainUnion «Σ» Γ α β)
Equations
- instPseudoIMetricSpaceDomainUnion = { idist := DomainUnion.idist, idist_self := ⋯, idist_comm := ⋯, idist_triangle := ⋯, uniformity_idist := ⋯ }
theorem
DomainUnion.idist_eq
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
{m n : ℕ}
{p : IterativeDomain «Σ» Γ α β m}
{q : IterativeDomain «Σ» Γ α β n}
:
instance
instIsUltrametricIDistDomainUnion
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
[IsUltrametricIDist «Σ»]
[IsUltrametricIDist Γ]
[IsUltrametricIDist α]
[IsUltrametricIDist β]
:
IsUltrametricIDist (DomainUnion «Σ» Γ α β)
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)
:
@[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
- Domain «Σ» Γ α β = UniformSpace.Completion (DomainUnion «Σ» Γ α β)
Instances For
theorem
UniformSpace.Completion.dist_le_iff
{α : Type u_1}
[PseudoMetricSpace α]
{ε : ℝ}
(h : ∀ (x y : α), dist x y ≤ ε)
(x y : Completion α)
:
@[implicit_reducible]
instance
instIsUltrametricIDistCompletion_core
{α : Type u_1}
[PseudoIMetricSpace α]
[IsUltrametricIDist α]
:
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 «Σ» Γ α β}
:
@[reducible, inline]
noncomputable abbrev
embedAt
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
(n : ℕ)
(x : IterativeDomain «Σ» Γ α β n)
:
Domain «Σ» Γ α β
Equations
- embedAt n x = ↑(DomainUnion.mk x)
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)
:
def
φ
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
:
DomainUnion «Σ» Γ α β →
β ⊕ PUnit.{x + 1} ⊕ UniformFun «Σ» (TopologicalSpace.Closeds (Branch «Σ» Γ α (Domain «Σ» Γ α β)))
Equations
- φ ⟨0, Sum.inl v⟩ = Sum.inl v
- φ ⟨n.succ, Sum.inl v⟩ = Sum.inl v
- φ ⟨0, Sum.inr PUnit.unit⟩ = Sum.inr (Sum.inl PUnit.unit)
- φ ⟨n.succ, Sum.inr (Sum.inl PUnit.unit)⟩ = Sum.inr (Sum.inl PUnit.unit)
- φ ⟨n.succ, Sum.inr (Sum.inr f)⟩ = Sum.inr (Sum.inr fun (σ : «Σ») => { carrier := closure (Branch.map (embedAt n) '' f σ), isClosed' := ⋯ })
Instances For
theorem
Domain.approx_uniform
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
(d : Domain «Σ» Γ α β)
(n : ℕ)
:
theorem
Branch.approx_uniform_depth
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
(b : Branch «Σ» Γ α (Domain «Σ» Γ α β))
(n : ℕ)
:
theorem
Branch.approx_at_depth
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[PseudoIMetricSpace β]
[PseudoIMetricSpace «Σ»]
[PseudoIMetricSpace Γ]
[PseudoIMetricSpace α]
(b : Branch «Σ» Γ α (Domain «Σ» Γ α β))
{ε : ℝ}
(hε : 0 < ε)
:
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 α]
:
theorem
φ_uniform_continuous
{«Σ» : 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
- Domain.isSolution = { toEquiv := Equiv.ofBijective (UniformSpace.Completion.extension φ) ⋯, isometry_toFun := ⋯ }
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
- Domain.leaf v = Domain.isSolution.symm (Sum.inl v)
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
- Domain.branch f = Domain.isSolution.symm (Sum.inr (Sum.inr fun (σ : «Σ») => { carrier := closure (f σ), isClosed' := ⋯ }))
Instances For
@[implicit_reducible]
noncomputable instance
instInhabitedDomain
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[IMetricSpace «Σ»]
[IMetricSpace Γ]
[IMetricSpace α]
[IMetricSpace β]
[CompleteSpace «Σ»]
[CompleteSpace Γ]
[CompleteSpace α]
[CompleteSpace β]
:
Equations
- instInhabitedDomain = { default := Domain.abort }
theorem
Domain.idist_leaf_leaf
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[IMetricSpace «Σ»]
[IMetricSpace Γ]
[IMetricSpace α]
[IMetricSpace β]
[CompleteSpace «Σ»]
[CompleteSpace Γ]
[CompleteSpace α]
[CompleteSpace β]
{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 «Σ» Γ α β)))}
:
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 β]
:
theorem
Domain.isOpen_singleton_abort'
{«Σ» : Type u}
{Γ : Type v}
{α : Type w}
{β : Type x}
[IMetricSpace «Σ»]
[IMetricSpace Γ]
[IMetricSpace α]
[IMetricSpace β]
:
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 β]
:
∃ (n : ℕ), abort = ↑(DomainUnion.mk IterativeDomain.abort)
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 σ)
The type of values that can be sent through channels.
- bool {ℍ : Type y} {Typ : Type w} (b : Bool) : Send𝕍 ℍ Typ
- int {ℍ : Type y} {Typ : Type w} (n : ℤ) : Send𝕍 ℍ Typ
- str {ℍ : Type y} {Typ : Type w} (s : String) : Send𝕍 ℍ Typ
- slice {ℍ : Type y} {Typ : Type w} (cap low high : ℕ) (arr : ℍ) : Send𝕍 ℍ Typ
- chan {ℍ : Type y} {Typ : Type w} (len : ℍ) (τ : Typ) (arr closed? : ℍ) : Send𝕍 ℍ Typ
- struct {ℍ : Type y} {Typ : Type w} (fields : List (String × Send𝕍 ℍ Typ)) : Send𝕍 ℍ Typ
- array {ℍ : Type y} {Typ : Type w} (len : ℕ) (indices : Fin len → Send𝕍 ℍ Typ) : Send𝕍 ℍ Typ
- map {ℍ : Type y} {Typ : Type w} (fields : List (Send𝕍 ℍ Typ × ℍ)) (τ : Typ) (nil : Bool) : Send𝕍 ℍ Typ
- tuple {ℍ : Type y} {Typ : Type w} (fields : List (Send𝕍 ℍ Typ)) : Send𝕍 ℍ Typ
Instances For
@[implicit_reducible]
Equations
- Value.instDecidableEqSend𝕍 ℍ Typ = sorry
@[implicit_reducible]
instance
Value.instDiscreteIMetricSpaceSend𝕍
(ℍ : Type y)
(Typ : Type w)
:
DiscreteIMetricSpace (Send𝕍 ℍ Typ)
Equations
- Value.instDiscreteIMetricSpaceSend𝕍 ℍ Typ = { toIMetricSpace := IMetricSpace.discrete, idist_discrete := ⋯ }
@[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.𝕍_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]
:
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
noncomputable def
Value.𝕍.bool
{«Σ» : Type u}
{Γ : Type v}
[IMetricSpace «Σ»]
[DecidableEq Γ]
[DiscreteIMetricSpace Γ]
{ℍ : Type y}
{Typ : Type w}
[IMetricSpace ℍ]
[IMetricSpace Typ]
(b : Bool)
:
Equations
- Value.𝕍.bool b = Value.𝕍_iso.symm (Sum.inl b)
Instances For
noncomputable def
Value.𝕍.int
{«Σ» : Type u}
{Γ : Type v}
[IMetricSpace «Σ»]
[DecidableEq Γ]
[DiscreteIMetricSpace Γ]
{ℍ : Type y}
{Typ : Type w}
[IMetricSpace ℍ]
[IMetricSpace Typ]
(n : ℤ)
:
Equations
- Value.𝕍.int n = Value.𝕍_iso.symm (Sum.inr (Sum.inl n))
Instances For
noncomputable def
Value.𝕍.str
{«Σ» : Type u}
{Γ : Type v}
[IMetricSpace «Σ»]
[DecidableEq Γ]
[DiscreteIMetricSpace Γ]
{ℍ : Type y}
{Typ : Type w}
[IMetricSpace ℍ]
[IMetricSpace Typ]
(s : String)
:
Equations
- Value.𝕍.str s = Value.𝕍_iso.symm (Sum.inr (Sum.inr (Sum.inl s)))
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 : ℍ)
:
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 : ℍ)
:
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))
:
Equations
- Value.𝕍.struct fields = Value.𝕍_iso.symm (Sum.inr (Sum.inr (Sum.inr (Sum.inr (Sum.inr (Sum.inl fields))))))
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)
:
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)
:
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}))
:
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)
:
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]
:
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]
Go.Typ's equality, decided classically: nothing in the compiler pipeline computes it, it
exists only to satisfy IMetricSpace.discrete's constraint below.
Equations
- instDecidableEqTyp a b = Classical.propDecidable (a = b)
@[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
- instDiscreteIMetricSpaceTyp = { toIMetricSpace := IMetricSpace.discrete, idist_discrete := instDiscreteIMetricSpaceTyp._proof_1 }
@[implicit_reducible]
Equations
- instInhabitedChannel = { default := instInhabitedChannel._aux_1 }
@[implicit_reducible]
Equations
- instDecidableEqChannel a b = Classical.propDecidable (a = b)
@[implicit_reducible]
Equations
- instDiscreteIMetricSpaceChannel = { toIMetricSpace := IMetricSpace.discrete, idist_discrete := instDiscreteIMetricSpaceChannel._proof_1 }
noncomputable def
Store.insert
(σ : Store.type)
(addr : Address)
(v : (Value.𝕍 Store.type Channel Address Go.Typ).type)
:
Equations
- Store.insert σ addr v = Store_iso.symm (Function.update (Store.type.h σ) addr (some v), Store.type.ϙ σ)
Instances For
Equations
- Store.freshAddr σ = Classical.epsilon fun (a : Address) => (match (Store_iso σ).1 a with | none => true | x => false) = true
Instances For
Equations
- Store.addrOf σ x = match Store.type.ϙ σ with | [] => none | ϙ' :: tail => ϙ' x