Documentation

PolyFun.IPFunctor.Scoped.StackedInterpretation

Interpretations of two-level binding families #

A model of a stacked family interprets its type level (tyAlg). It gives value-level typing rules as functions of evaluated annotations (bindersV, sortV, resultV) and a value-level side condition WFV. One coherence equation per rule relates the value-level typing to the syntactic one, in the type-level meanings Den. A language whose coercions change a type to one with the same carrier states that carrier equation in WFV, and its interpretation of the coercion casts there.

The two kinds of interpretation follow the signature-level names. An ordinary Model.Interp V and a continuous Model.DomainInterp D see a head only through its evaluated annotations. They receive each child as a function, respectively a continuous function, of the child's type arguments and fresh value binders. Model.denote and Model.denoteDomain fold them at every type assignment. Because heads are seen only through their evaluated annotations:

Both folds are exposed, so a meaning computes definitionally on a concrete term. denote_stackedNode and denoteDomain_stackedNode state one step of that computation; a large meaning is better computed by rewriting with them than by one rfl.

Evaluated annotations #

@[reducible, inline]
abbrev IPFunctor.ScopedSignature.Heads.AnnV {K : Type u} (H : Heads K) (Den : K → Type d) (h : H.Shape) :
Type (max u d u)

Evaluated annotations: each slot as a function of its own type binders.

Equations
Instances For
    def IPFunctor.ScopedSignature.Heads.evalAnn {K : Type u} {τ : ScopedSignature K} {H : Heads K} {Den : K → Type d} (alg : τ.Interpretation Den) {h : H.Shape} {Θ : List K} (a : H.Ann τ h Θ) (ρ : Env Den Θ) :
    H.AnnV Den h

    Evaluate every annotation at a type assignment.

    Equations
    Instances For
      theorem IPFunctor.ScopedSignature.Heads.evalAnn_subst {K : Type u} {τ : ScopedSignature K} {H : Heads K} {Den : K → Type d} (alg : τ.Interpretation Den) {h : H.Shape} {Θ Θ' : List K} (θ : τ.Substitution Θ Θ') (a : H.Ann τ h Θ) (ρ' : Env Den Θ') :
      evalAnn (fun {a : K} => alg) (Ann.subst θ a) ρ' = evalAnn (fun {a : K} => alg) a (Term.substitutionEnv (fun {a : K} => alg) θ ρ')

      Evaluating substituted annotations evaluates at the substituted assignment.

      structure IPFunctor.ScopedSignature.Stacked.Model {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} (S : τ.Stacked k₀ H) :
      Type (max (max (max (max (max (d + 1) u) v) w) x) y)

      A model of a stacked family: type-level meanings, and value-level typing on evaluated annotations, coherent with the syntactic typing.

      Instances For

        Environments of a child #

        def IPFunctor.ScopedSignature.Stacked.Model.ambientEnv {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e) {Θ : List K} {Γ : List (τ.Term Θ k₀)} (Ξ : List K) (ξ : Env M.Den Ξ) (ρ : Env M.Den Θ) :
        Env (fun (s : τ.Term Θ k₀) => V (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ → Env (fun (s : τ.Term (Ξ ++ Θ) k₀) => V (Term.denote (fun {a : K} => M.tyAlg) s (ξ.append ρ))) ((enter Ξ).context Γ)

        Move a value environment below a block of type binders. Below no binders it is unchanged; below a non-empty block each value is transported along the weakening of its sort.

        Equations
        Instances For
          noncomputable def IPFunctor.ScopedSignature.Stacked.Model.ambientEnvContinuous {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] {Θ : List K} {Γ : List (τ.Term Θ k₀)} (Ξ : List K) (ξ : Env M.Den Ξ) (ρ : Env M.Den Θ) :
          Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ →𝒄 Env (fun (s : τ.Term (Ξ ++ Θ) k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s (ξ.append ρ))) ((enter Ξ).context Γ)

          ambientEnv as a continuous map.

          Equations
          Instances For
            theorem IPFunctor.ScopedSignature.Stacked.Model.ambientEnvContinuous_apply {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] {Θ : List K} {Γ : List (τ.Term Θ k₀)} (Ξ : List K) (ξ : Env M.Den Ξ) (ρ : Env M.Den Θ) (η : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ) :
            (M.ambientEnvContinuous D Ξ ξ ρ) η = M.ambientEnv D Ξ ξ ρ η
            def IPFunctor.ScopedSignature.Stacked.Model.binderEnv {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e) {Θ : List K} {h : H.Shape} (a : H.Ann τ h Θ) (wf : S.WF h a) (ρ : Env M.Den Θ) (p : H.Arg h) (ξ : Env M.Den (H.tbind h p)) (ηb : Env V (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) p ξ)) :
            Env (fun (s : τ.Term (H.tbind h p ++ Θ) k₀) => V (Term.denote (fun {a : K} => M.tyAlg) s (ξ.append ρ))) (S.binders h a p)

            Read the fresh value binders of a child through the binder coherence equation.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              noncomputable def IPFunctor.ScopedSignature.Stacked.Model.binderEnvContinuous {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] {Θ : List K} {h : H.Shape} (a : H.Ann τ h Θ) (wf : S.WF h a) (ρ : Env M.Den Θ) (p : H.Arg h) (ξ : Env M.Den (H.tbind h p)) :
              Env D (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) p ξ) →𝒄 Env (fun (s : τ.Term (H.tbind h p ++ Θ) k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s (ξ.append ρ))) (S.binders h a p)

              binderEnv as a continuous map.

              Equations
              Instances For

                Ordinary interpretations #

                @[reducible, inline]
                abbrev IPFunctor.ScopedSignature.Stacked.Model.Interp {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e') :
                Type (max (max (max (max (max (max (max (max e' x) d) u) y) d) u) e') d)

                An ordinary interpretation of the value level into a family of types. It sees each head only through its evaluated annotations and value-level side condition.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  @[reducible, inline]
                  abbrev IPFunctor.ScopedSignature.Stacked.Model.Sem {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e') (j : ScopedFamily.Judgment fun (Θ : List K) => τ.Term Θ k₀) :
                  Type (max (max (max (max e' d) u) e') (max u v) w)

                  Ordinary meanings of terms: for each type assignment, a function of the value environment.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    def IPFunctor.ScopedSignature.Stacked.Model.alg {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e') (I : M.Interp V) :

                    The syntax algebra induced by an ordinary interpretation over evaluated heads.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For
                      def IPFunctor.ScopedSignature.Stacked.Model.denote {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e') (I : M.Interp V) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (t : S.toFamily.Term Θ Γ s) :
                      M.Sem V ⟨Θ, (Γ, s)⟩

                      The ordinary meaning: the generic fold.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        @[simp]
                        theorem IPFunctor.ScopedSignature.Stacked.Model.denote_var {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e') (I : M.Interp V) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (x : ScopedVar Γ s) (ρ : Env M.Den Θ) (η : Env (fun (s : τ.Term Θ k₀) => V (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ) :
                        M.denote V I (ScopedFamily.Term.var x) ρ η = η s x
                        theorem IPFunctor.ScopedSignature.Stacked.Model.denote_node {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e') (I : M.Interp V) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (o : S.toFamily.Op Θ s) (args : (p : S.toFamily.Arg o) → S.toFamily.Term (S.toFamily.world o p) (S.toFamily.binders o p ++ (S.toFamily.ambient o p).context Γ) (S.toFamily.sort o p)) (ρ : Env M.Den Θ) :
                        M.denote V I (ScopedFamily.Term.node o args) ρ = M.alg V I ⟨Θ, (Γ, s)⟩ o (fun (p : S.toFamily.polynomial.B ⟨Θ, (Γ, s)⟩ o) => M.denote V I (args p)) ρ
                        theorem IPFunctor.ScopedSignature.Stacked.Model.denote_stackedNode {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (V : M.Den k₀ → Type e') (I : M.Interp V) {Θ : List K} {Γ : List (τ.Term Θ k₀)} (h : H.Shape) (a : H.Ann τ h Θ) (wf : S.WF h a) (args : (p : H.Arg h) → S.toFamily.Term (H.tbind h p ++ Θ) (S.binders h a p ++ (enter (H.tbind h p)).context Γ) (S.sort h a p)) (ρ : Env M.Den Θ) (η : Env (fun (s : τ.Term Θ k₀) => V (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ) :
                        M.denote V I (S.node h a wf args) ρ η = cast ⋯ (I h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) ⋯ fun (p : H.Arg h) (ξ : Env M.Den (H.tbind h p)) (ηb : Env V (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) p ξ)) => cast ⋯ (M.denote V I (args p) (ξ.append ρ) ((M.binderEnv V a wf ρ p ξ ηb).append (M.ambientEnv V (H.tbind h p) ξ ρ η))))

                        A checked node means its interpretation at the evaluated head, with each child read in its fresh binders and the ambient environment moved below the child's type binders.

                        Continuous interpretations #

                        @[reducible, inline]
                        abbrev IPFunctor.ScopedSignature.Stacked.Model.DomainInterp {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] :
                        Type (max (max (max (max x d) u) e) (max (max d e) u) y)

                        A continuous interpretation of the value level. It sees each head only through its evaluated annotations and value-level side condition, and receives each child as a continuous function of the child's type arguments and fresh value binders.

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          @[reducible, inline]
                          abbrev IPFunctor.ScopedSignature.Stacked.Model.DomainSem {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (j : ScopedFamily.Judgment fun (Θ : List K) => τ.Term Θ k₀) :
                          Type (max (max (max d u) e) e (max u v) w)

                          Continuous meanings of terms: for each type assignment, a continuous function of the value environment.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            noncomputable def IPFunctor.ScopedSignature.Stacked.Model.children {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (o : S.Op Θ s) (next : (p : H.Arg (↑o).fst) → M.DomainSem D (S.toFamily.polynomial.src ⟨Θ, (Γ, s)⟩ o p)) (ρ : Env M.Den Θ) :
                            Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ →𝒄 (p : H.Arg (↑o).fst) → (ξ : Env M.Den (H.tbind (↑o).fst p)) → Env D (M.bindersV (↑o).fst (Heads.evalAnn (fun {a : K} => M.tyAlg) (↑o).snd ρ) p ξ) →𝒄 D (M.sortV (↑o).fst (Heads.evalAnn (fun {a : K} => M.tyAlg) (↑o).snd ρ) p ξ)

                            The children of a head as a continuous function of the ambient environment.

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              theorem IPFunctor.ScopedSignature.Stacked.Model.children_apply {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (o : S.Op Θ s) (next : (p : H.Arg (↑o).fst) → M.DomainSem D (S.toFamily.polynomial.src ⟨Θ, (Γ, s)⟩ o p)) (ρ : Env M.Den Θ) (η : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ) (p : H.Arg (↑o).fst) (ξ : Env M.Den (H.tbind (↑o).fst p)) (ηb : Env D (M.bindersV (↑o).fst (Heads.evalAnn (fun {a : K} => M.tyAlg) (↑o).snd ρ) p ξ)) :
                              ((M.children D o next ρ) η p ξ) ηb = (OmegaCompletePartialOrder.ContinuousHom.ofEq D ⋯) ((next p (ξ.append ρ)) ((M.binderEnv D (↑o).snd ⋯ ρ p ξ ηb).append (M.ambientEnv D (H.tbind (↑o).fst p) ξ ρ η)))
                              noncomputable def IPFunctor.ScopedSignature.Stacked.Model.domainAlg {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) :

                              The syntax algebra induced by a continuous interpretation over evaluated heads.

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                noncomputable def IPFunctor.ScopedSignature.Stacked.Model.denoteDomain {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (t : S.toFamily.Term Θ Γ s) :
                                M.DomainSem D ⟨Θ, (Γ, s)⟩

                                The continuous meaning: the generic fold.

                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For
                                  @[simp]
                                  theorem IPFunctor.ScopedSignature.Stacked.Model.denoteDomain_var {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (x : ScopedVar Γ s) (ρ : Env M.Den Θ) (η : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ) :
                                  (M.denoteDomain D I (ScopedFamily.Term.var x) ρ) η = η s x
                                  theorem IPFunctor.ScopedSignature.Stacked.Model.denoteDomain_node {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (o : S.toFamily.Op Θ s) (args : (p : S.toFamily.Arg o) → S.toFamily.Term (S.toFamily.world o p) (S.toFamily.binders o p ++ (S.toFamily.ambient o p).context Γ) (S.toFamily.sort o p)) (ρ : Env M.Den Θ) :
                                  M.denoteDomain D I (ScopedFamily.Term.node o args) ρ = M.domainAlg D I ⟨Θ, (Γ, s)⟩ o (fun (p : S.toFamily.polynomial.B ⟨Θ, (Γ, s)⟩ o) => M.denoteDomain D I (args p)) ρ
                                  theorem IPFunctor.ScopedSignature.Stacked.Model.denoteDomain_stackedNode {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {Γ : List (τ.Term Θ k₀)} (h : H.Shape) (a : H.Ann τ h Θ) (wf : S.WF h a) (args : (p : H.Arg h) → S.toFamily.Term (H.tbind h p ++ Θ) (S.binders h a p ++ (enter (H.tbind h p)).context Γ) (S.sort h a p)) (ρ : Env M.Den Θ) (η : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ) :
                                  (M.denoteDomain D I (S.node h a wf args) ρ) η = (OmegaCompletePartialOrder.ContinuousHom.ofEq D ⋯) ((I h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) ⋯) fun (p : H.Arg h) (ξ : Env M.Den (H.tbind h p)) => OmegaCompletePartialOrder.ContinuousHom.ofFun (fun (ηb : Env D (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) p ξ)) => (OmegaCompletePartialOrder.ContinuousHom.ofEq D ⋯) ((M.denoteDomain D I (args p) (ξ.append ρ)) (((M.binderEnvContinuous D a wf ρ p ξ) ηb).append ((M.ambientEnvContinuous D (H.tbind h p) ξ ρ) η)))) ⋯)

                                  A checked node means its interpretation at the evaluated head, with each child read in its fresh binders and the ambient environment moved below the child's type binders.

                                  theorem IPFunctor.ScopedSignature.Stacked.Model.denoteDomain_cast {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {Γ Δ : List (τ.Term Θ k₀)} {s s' : τ.Term Θ k₀} (hΓ : Γ = Δ) (hs : s = s') (t : S.toFamily.Term Θ Γ s) (ρ : Env M.Den Θ) (E : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Δ) :
                                  (M.denoteDomain D I (ScopedFamily.Term.cast hΓ hs t) ρ) E ≍ (M.denoteDomain D I t ρ) (Env.castCtx ⋯ E)
                                  theorem IPFunctor.ScopedSignature.Stacked.Model.denoteDomain_congr {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (t : S.toFamily.Term Θ Γ s) {ρ₁ ρ₂ : Env M.Den Θ} (hρ : ρ₁ = ρ₂) {E₁ : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ₁)) Γ} {E₂ : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ₂)) Γ} (hE : E₁ ≍ E₂) :
                                  (M.denoteDomain D I t ρ₁) E₁ ≍ (M.denoteDomain D I t ρ₂) E₂
                                  theorem IPFunctor.ScopedSignature.Stacked.Model.domainInterp_heq {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) (h : H.Shape) {v₁ v₂ : H.AnnV M.Den h} (hv : v₁ = v₂) (w₁ : M.WFV h v₁) (w₂ : M.WFV h v₂) {c₁ : (p : H.Arg h) → (ξ : Env M.Den (H.tbind h p)) → Env D (M.bindersV h v₁ p ξ) →𝒄 D (M.sortV h v₁ p ξ)} {c₂ : (p : H.Arg h) → (ξ : Env M.Den (H.tbind h p)) → Env D (M.bindersV h v₂ p ξ) →𝒄 D (M.sortV h v₂ p ξ)} (hc : ∀ (p : H.Arg h) (ξ : Env M.Den (H.tbind h p)) (ηb₁ : Env D (M.bindersV h v₁ p ξ)) (ηb₂ : Env D (M.bindersV h v₂ p ξ)), ηb₁ ≍ ηb₂ → (c₁ p ξ) ηb₁ ≍ (c₂ p ξ) ηb₂) :
                                  (I h v₁ w₁) c₁ ≍ (I h v₂ w₂) c₂

                                  Type-parameter substitution commutes with the continuous meaning #

                                  theorem IPFunctor.ScopedSignature.Stacked.Model.pointwise_binderEnv {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) {Θ Θ' : List K} {h : H.Shape} (θ : τ.Substitution Θ Θ') (a : H.Ann τ h Θ) (wf : S.WF h a) (ρ' : Env M.Den Θ') (p : H.Arg h) (ξ : Env M.Den (H.tbind h p)) (ηb₁ : Env D (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) (Heads.Ann.subst θ a) ρ') p ξ)) (ηb₂ : Env D (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) a (Term.substitutionEnv (fun {a : K} => M.tyAlg) θ ρ')) p ξ)) (hb : ηb₁ ≍ ηb₂) :
                                  (M.binderEnv D a wf (Term.substitutionEnv (fun {a : K} => M.tyAlg) θ ρ') p ξ ηb₂).Pointwise (M.binderEnv D (Heads.Ann.subst θ a) ⋯ ρ' p ξ ηb₁)
                                  theorem IPFunctor.ScopedSignature.Stacked.Model.pointwise_ambientEnv {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) {Θ Θ' : List K} (Ξ : List K) (θ : τ.Substitution Θ Θ') (ξ : Env M.Den Ξ) (ρ' : Env M.Den Θ') {Γ : List (τ.Term Θ k₀)} (η' : Env (fun (s : τ.Term Θ' k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ')) (List.map (fun (x : τ.Term Θ k₀) => Term.subst θ x) Γ)) (η : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s (Term.substitutionEnv (fun {a : K} => M.tyAlg) θ ρ'))) Γ) (hη : η.Pointwise η') :
                                  (M.ambientEnv D Ξ ξ (Term.substitutionEnv (fun {a : K} => M.tyAlg) θ ρ') η).Pointwise (M.ambientEnv D Ξ ξ ρ' η')
                                  theorem IPFunctor.ScopedSignature.Stacked.Model.denoteDomain_map {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {Γ : List (τ.Term Θ k₀)} {s : τ.Term Θ k₀} (t : S.toFamily.Term Θ Γ s) {Θ' : List K} (θ : τ.Substitution Θ Θ') (ρ' : Env M.Den Θ') (η' : Env (fun (s : τ.Term Θ' k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ')) (List.map (fun (x : τ.Term Θ k₀) => Term.subst θ x) Γ)) (η : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s (Term.substitutionEnv (fun {a : K} => M.tyAlg) θ ρ'))) Γ) (hη : η.Pointwise η') :
                                  (M.denoteDomain D I (ScopedFamily.Term.map S.paramHom θ t) ρ') η' ≍ (M.denoteDomain D I t (Term.substitutionEnv (fun {a : K} => M.tyAlg) θ ρ')) η

                                  Substituting type parameters commutes with the continuous meaning, for every interpretation over evaluated heads. The value environments agree at every position.

                                  theorem IPFunctor.ScopedSignature.Stacked.Model.denoteDomain_map_closed {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} (M : S.Model) (D : M.Den k₀ → Type e) [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] (I : M.DomainInterp D) {Θ : List K} {s : τ.Term Θ k₀} (t : S.toFamily.Term Θ [] s) {Θ' : List K} (θ : τ.Substitution Θ Θ') (ρ' : Env M.Den Θ') :
                                  (M.denoteDomain D I (ScopedFamily.Term.map S.paramHom θ t) ρ') Env.empty ≍ (M.denoteDomain D I t (Term.substitutionEnv (fun {a : K} => M.tyAlg) θ ρ')) Env.empty

                                  The closed case: instantiate the parameters of a term with no free values.

                                  The fundamental lemma #

                                  def IPFunctor.ScopedSignature.Stacked.Model.DomainInterp.Related {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} {M : S.Model} {D : M.Den k₀ → Type e} [(d : M.Den k₀) → OmegaCompletePartialOrder (D d)] {V : M.Den k₀ → Type e'} (R : (d : M.Den k₀) → D d → V d → Prop) (I : M.DomainInterp D) (I' : M.Interp V) :

                                  A continuous interpretation simulated by an ordinary one: at every evaluated head, children related on related fresh binders give related results.

                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For
                                    theorem IPFunctor.ScopedSignature.Stacked.Model.rel_cast {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} {M : S.Model} {D : M.Den k₀ → Type e} {V : M.Den k₀ → Type e'} {R : (d : M.Den k₀) → D d → V d → Prop} {d d' : M.Den k₀} (h : d = d') {x : D d} {y : V d} (hxy : R d x y) :
                                    R d' (cast ⋯ x) (cast ⋯ y)

                                    A relation indexed by type-level meanings survives transport along their equations.

                                    theorem IPFunctor.ScopedSignature.Stacked.Model.liftRel_binderEnv {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} {M : S.Model} {D : M.Den k₀ → Type e} {V : M.Den k₀ → Type e'} {R : (d : M.Den k₀) → D d → V d → Prop} {Θ : List K} {h : H.Shape} (a : H.Ann τ h Θ) (wf : S.WF h a) (ρ : Env M.Den Θ) (p : H.Arg h) (ξ : Env M.Den (H.tbind h p)) {ηb : Env D (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) p ξ)} {ζb : Env V (M.bindersV h (Heads.evalAnn (fun {a : K} => M.tyAlg) a ρ) p ξ)} (hb : Env.LiftRel R ηb ζb) :
                                    Env.LiftRel (fun (s : τ.Term (H.tbind h p ++ Θ) k₀) => R (Term.denote (fun {a : K} => M.tyAlg) s (ξ.append ρ))) (M.binderEnv D a wf ρ p ξ ηb) (M.binderEnv V a wf ρ p ξ ζb)

                                    Related fresh binders give related binder environments.

                                    theorem IPFunctor.ScopedSignature.Stacked.Model.liftRel_ambientEnv {K : Type u} {τ : ScopedSignature K} {k₀ : K} {H : Heads K} {S : τ.Stacked k₀ H} {M : S.Model} {D : M.Den k₀ → Type e} {V : M.Den k₀ → Type e'} {R : (d : M.Den k₀) → D d → V d → Prop} {Θ : List K} {Γ : List (τ.Term Θ k₀)} (Ξ : List K) (ξ : Env M.Den Ξ) (ρ : Env M.Den Θ) {η : Env (fun (s : τ.Term Θ k₀) => D (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ} {ζ : Env (fun (s : τ.Term Θ k₀) => V (Term.denote (fun {a : K} => M.tyAlg) s ρ)) Γ} (hη : Env.LiftRel (fun (s : τ.Term Θ k₀) => R (Term.denote (fun {a : K} => M.tyAlg) s ρ)) η ζ) :
                                    Env.LiftRel (fun (s : τ.Term (Ξ ++ Θ) k₀) => R (Term.denote (fun {a : K} => M.tyAlg) s (ξ.append ρ))) (M.ambientEnv D Ξ ξ ρ η) (M.ambientEnv V Ξ ξ ρ ζ)

                                    Related environments stay related below a block of type binders.