Documentation

MIPRE.Foundations.CL.Basic

Conditionally linear functions #

Blueprint def:cl-function (paper linear.tex, Definition def:cl-func; ledger node 1.1.2). The question distribution of every game in the pipeline is conditionally linear: linear maps applied in stages to complementary register subspaces of V = F^ι, the register subspace and the linear map of each stage being allowed to depend on the outputs of the previous stages.

Presentations and functions #

The paper defines the set of ℓ-level CL functions on V inductively: the 0-level one is the zero function, and an ℓ-level one is any L of the form L(x) = L₁(x^{V₁}) + L_{>1, L₁(x^{V₁})}(x^{V_{>1}}) for complementary register subspaces V₁ ⊕ V_{>1} = V, a linear map L₁ on V₁, and (ℓ-1)-level CL functions L_{>1,v} on V_{>1}, one for each value v of L₁. Everything downstream — the structure lemma lem:cl-kth, the query interface of a sampler, the hiding tests of introspection — works with the decomposition data, which the function does not determine. So the Lean object is the data:

Two departures from the letter of the paper, both harmless: continuations are indexed by all vectors rather than by the values of L₁ (the others are never evaluated), and there is one ambient space F^ι throughout, register subspaces of it playing the role of the paper's V_{>1}, U ⊕ V, and so on.

The structure lemma (lem:cl-kth) #

lem:cl-kth attaches to an ℓ-level CL function its marginals L_{≤k}, factor spaces V_{k,u} and stage maps L_{k,u}, u being the prefix L_{<k}(x). Here:

inductive MIPRE.CL.CLFun (F : Type u) [Semiring F] (ι : Type v) [DecidableEq ι] :
ℕ → Type (max u v)

Presentations of ℓ-level conditionally linear functions on the ambient space ι → F (blueprint def:cl-function). cons S L₁ next presents x ↦ L₁ x + next (L₁ x) (x^{V_{Sᶜ}}).

Instances For
    theorem MIPRE.CL.CLFun.eq_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] (P : CLFun F ι 0) :

    Support #

    def MIPRE.CL.CLFun.SupportedOn {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} :
    CLFun F ι ℓ → Finset ι → Prop

    P.SupportedOn T: P is a presentation on V_T — its first register subspace lies inside T, and every continuation is a presentation on the complementary V_{T \ S}.

    Equations
    Instances For
      @[simp]
      theorem MIPRE.CL.CLFun.supportedOn_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] (T : Finset ι) :
      @[simp]
      theorem MIPRE.CL.CLFun.supportedOn_cons {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (T : Finset ι) :
      (cons S L₁ next).SupportedOn T ↔ S ⊆ T ∧ ∀ (v : ι → F), (next v).SupportedOn (T \ S)
      theorem MIPRE.CL.CLFun.SupportedOn.mono {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {P : CLFun F ι ℓ} {T T' : Finset ι} (hP : P.SupportedOn T) (h : T ⊆ T') :

      Levels: padding and marginals #

      def MIPRE.CL.CLFun.lift {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] (T : Finset ι) {ℓ : ℕ} :
      CLFun F ι ℓ → CLFun F ι (ℓ + 1)

      One more level at the bottom, acting on the register subspace V_T by the zero map: the paper's rk:higher-level, every ℓ-level CL function being (ℓ + 1)-level. Padding with T = ∅ preserves every support; padding with the coordinates not yet used preserves exactness (ExactlyOn.lift).

      Equations
      Instances For
        theorem MIPRE.CL.CLFun.SupportedOn.lift {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {P : CLFun F ι ℓ} {T T' : Finset ι} (hP : P.SupportedOn T) (h : T' ⊆ T) :
        def MIPRE.CL.CLFun.liftN {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} (T : Finset ι) (n : ℕ) :
        CLFun F ι ℓ → CLFun F ι (ℓ + n)

        n trivial levels at the bottom.

        Equations
        Instances For
          def MIPRE.CL.CLFun.truncate {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] (k : ℕ) {ℓ : ℕ} :
          CLFun F ι ℓ → CLFun F ι k

          The first k levels of P: the k-th marginal L_{≤k} of lem:cl-kth. When k exceeds the level of P, the missing levels are trivial.

          Equations
          Instances For
            @[simp]
            theorem MIPRE.CL.CLFun.truncate_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} (P : CLFun F ι ℓ) :
            @[simp]
            theorem MIPRE.CL.CLFun.truncate_succ_cons {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (k : ℕ) :
            truncate (k + 1) (cons S L₁ next) = cons S L₁ fun (v : ι → F) => truncate k (next v)
            @[simp]
            theorem MIPRE.CL.CLFun.truncate_self {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} (P : CLFun F ι ℓ) :
            truncate ℓ P = P

            Item (4) of lem:cl-kth: L = L_{≤ℓ}.

            theorem MIPRE.CL.CLFun.SupportedOn.truncate {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.SupportedOn T) (k : ℕ) :

            Item (1) of lem:cl-kth: the k-th marginal is a k-level CL function on the same space.

            Exact support #

            def MIPRE.CL.CLFun.ExactlyOn {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} :
            CLFun F ι ℓ → Finset ι → Prop

            P.ExactlyOn T: P is a presentation on V_T whose last level leaves nothing over, so that the factor spaces along every run partition T (ExactlyOn.biUnion_factorAt). This is item (2) of lem:cl-kth, V = ⊕ᵢ V_{i, L_{<i}(x)}.

            Equations
            Instances For
              @[simp]
              theorem MIPRE.CL.CLFun.exactlyOn_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] (T : Finset ι) :
              @[simp]
              theorem MIPRE.CL.CLFun.exactlyOn_cons {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (T : Finset ι) :
              (cons S L₁ next).ExactlyOn T ↔ S ⊆ T ∧ ∀ (v : ι → F), (next v).ExactlyOn (T \ S)
              theorem MIPRE.CL.CLFun.ExactlyOn.supportedOn {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.ExactlyOn T) :
              theorem MIPRE.CL.CLFun.ExactlyOn.lift {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.ExactlyOn T) :
              theorem MIPRE.CL.CLFun.ExactlyOn.liftN {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.ExactlyOn T) (n : ℕ) :

              Evaluation #

              def MIPRE.CL.CLFun.eval {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] {ℓ : ℕ} :
              CLFun F ι ℓ → (ι → F) → ι → F

              The function presented: L(x) = x^{L₁} + L_{>1, x^{L₁}}(x^{V_{>1}}).

              Equations
              Instances For
                @[simp]
                theorem MIPRE.CL.CLFun.eval_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] (x : ι → F) :
                zero.eval x = 0
                @[simp]
                theorem MIPRE.CL.CLFun.eval_cons {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (x : ι → F) :
                (cons S L₁ next).eval x = L₁ x + (next (L₁ x)).eval ((proj Sᶜ) x)
                @[simp]
                theorem MIPRE.CL.CLFun.eval_zero_vec {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] (P : CLFun F ι ℓ) :
                P.eval 0 = 0
                theorem MIPRE.CL.CLFun.SupportedOn.eval_proj_of_subset {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T U : Finset ι} (hP : P.SupportedOn T) (hTU : T ⊆ U) (x : ι → F) :
                P.eval ((proj U) x) = P.eval x

                A presentation on V_T reads only the coordinates in T.

                theorem MIPRE.CL.CLFun.SupportedOn.proj_eval {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.SupportedOn T) (x : ι → F) :
                (proj T) (P.eval x) = P.eval x

                A presentation on V_T takes its values in V_T.

                theorem MIPRE.CL.CLFun.SupportedOn.proj_eval_of_subset {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T U : Finset ι} (hP : P.SupportedOn T) (h : T ⊆ U) (x : ι → F) :
                (proj U) (P.eval x) = P.eval x
                theorem MIPRE.CL.CLFun.SupportedOn.proj_eval_of_disjoint {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T U : Finset ι} (hP : P.SupportedOn T) (h : Disjoint U T) (x : ι → F) :
                (proj U) (P.eval x) = 0

                Evaluation of padded and truncated presentations #

                @[simp]
                theorem MIPRE.CL.CLFun.eval_lift {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] (T : Finset ι) (P : CLFun F ι ℓ) (x : ι → F) :
                (lift T P).eval x = P.eval x
                @[simp]
                theorem MIPRE.CL.CLFun.eval_liftN {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] (T : Finset ι) (n : ℕ) (P : CLFun F ι ℓ) (x : ι → F) :
                (liftN T n P).eval x = P.eval x
                @[simp]
                theorem MIPRE.CL.CLFun.eval_truncate_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] (P : CLFun F ι 0) (k : ℕ) (x : ι → F) :
                (truncate k P).eval x = 0

                The data of a stage #

                def MIPRE.CL.CLFun.factorAt {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] {ℓ : ℕ} :
                CLFun F ι ℓ → ℕ → (ι → F) → Finset ι

                The register subspace acted on at stage k + 1 on the input x: the factor space V_{k+1,u} of lem:cl-kth, u = L_{≤k}(x) the prefix. Beyond the level of P it is empty.

                Equations
                Instances For
                  def MIPRE.CL.CLFun.mapAt {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] {ℓ : ℕ} :
                  CLFun F ι ℓ → ℕ → (ι → F) → (ι → F) →ₗ[F] ι → F

                  The linear map applied at stage k + 1 on the input x: the map L_{k+1,u} of lem:cl-kth, u = L_{≤k}(x) the prefix, as an endomorphism of the ambient space. Beyond the level of P it is zero.

                  Equations
                  Instances For
                    @[simp]
                    theorem MIPRE.CL.CLFun.factorAt_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] (k : ℕ) (x : ι → F) :
                    @[simp]
                    theorem MIPRE.CL.CLFun.factorAt_cons_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (x : ι → F) :
                    (cons S L₁ next).factorAt 0 x = S
                    @[simp]
                    theorem MIPRE.CL.CLFun.factorAt_cons_succ {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (k : ℕ) (x : ι → F) :
                    (cons S L₁ next).factorAt (k + 1) x = (next (L₁ x)).factorAt k ((proj Sᶜ) x)
                    @[simp]
                    theorem MIPRE.CL.CLFun.mapAt_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] (k : ℕ) (x : ι → F) :
                    zero.mapAt k x = 0
                    @[simp]
                    theorem MIPRE.CL.CLFun.mapAt_cons_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (x : ι → F) :
                    (cons S L₁ next).mapAt 0 x = L₁.toLinearMap
                    @[simp]
                    theorem MIPRE.CL.CLFun.mapAt_cons_succ {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (k : ℕ) (x : ι → F) :
                    (cons S L₁ next).mapAt (k + 1) x = (next (L₁ x)).mapAt k ((proj Sᶜ) x)
                    theorem MIPRE.CL.CLFun.SupportedOn.factorAt_subset {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.SupportedOn T) (k : ℕ) (x : ι → F) :
                    P.factorAt k x ⊆ T

                    The factor spaces along a run lie in T.

                    theorem MIPRE.CL.CLFun.SupportedOn.disjoint_factorAt {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.SupportedOn T) {i j : ℕ} (hij : i < j) (x : ι → F) :
                    Disjoint (P.factorAt i x) (P.factorAt j x)

                    The factor spaces along a run are pairwise disjoint.

                    theorem MIPRE.CL.CLFun.SupportedOn.mapAt_apply_proj {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T U : Finset ι} (hP : P.SupportedOn T) (hTU : T ⊆ U) (k : ℕ) (x y : ι → F) :
                    (P.mapAt k x) ((proj U) y) = (P.mapAt k x) y

                    The stage maps of a presentation on V_T read only the coordinates in T.

                    theorem MIPRE.CL.CLFun.SupportedOn.eval_truncate_eq_sum {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.SupportedOn T) (k : ℕ) (x : ι → F) :
                    (CLFun.truncate k P).eval x = ∑ i ∈ Finset.range k, (P.mapAt i x) x

                    Item (3) of lem:cl-kth: L_{≤k}(x) = ∑_{i ≤ k} x^{L_i}, the marginal is the sum of the stage maps applied to the input.

                    Stage data from the prefix #

                    def MIPRE.CL.CLFun.factorOfPrefix {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] {ℓ : ℕ} :
                    CLFun F ι ℓ → ℕ → (ι → F) → Finset ι

                    The factor space at stage k + 1, read off the prefix u = L_{≤k}(x) rather than the input x: the paper's V_{k+1,u}. The prefix determines the branch taken at each earlier stage — its V_S-component is the value of that stage's map — and this is how a sampler's factor query is answered.

                    Equations
                    Instances For
                      def MIPRE.CL.CLFun.mapOfPrefix {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] {ℓ : ℕ} :
                      CLFun F ι ℓ → ℕ → (ι → F) → (ι → F) →ₗ[F] ι → F

                      The linear map at stage k + 1, read off the prefix u = L_{≤k}(x): the paper's L_{k+1,u}; how a sampler's linear query is answered.

                      Equations
                      Instances For
                        @[simp]
                        theorem MIPRE.CL.CLFun.factorOfPrefix_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] (k : ℕ) (u : ι → F) :
                        @[simp]
                        theorem MIPRE.CL.CLFun.factorOfPrefix_cons_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (u : ι → F) :
                        (cons S L₁ next).factorOfPrefix 0 u = S
                        @[simp]
                        theorem MIPRE.CL.CLFun.factorOfPrefix_cons_succ {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (k : ℕ) (u : ι → F) :
                        (cons S L₁ next).factorOfPrefix (k + 1) u = (next ((proj S) u)).factorOfPrefix k ((proj Sᶜ) u)
                        @[simp]
                        theorem MIPRE.CL.CLFun.mapOfPrefix_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] (k : ℕ) (u : ι → F) :
                        @[simp]
                        theorem MIPRE.CL.CLFun.mapOfPrefix_cons_zero {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (u : ι → F) :
                        (cons S L₁ next).mapOfPrefix 0 u = L₁.toLinearMap
                        @[simp]
                        theorem MIPRE.CL.CLFun.mapOfPrefix_cons_succ {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} (L₁ : RegLinear F S) (next : (ι → F) → CLFun F ι ℓ) (k : ℕ) (u : ι → F) :
                        (cons S L₁ next).mapOfPrefix (k + 1) u = (next ((proj S) u)).mapOfPrefix k ((proj Sᶜ) u)
                        theorem MIPRE.CL.CLFun.SupportedOn.proj_eval_truncate_succ {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {S : Finset ι} {L₁ : RegLinear F S} {next : (ι → F) → CLFun F ι ℓ} {T : Finset ι} (hP : (cons S L₁ next).SupportedOn T) (k : ℕ) (x : ι → F) :
                        (proj S) ((CLFun.truncate (k + 1) (cons S L₁ next)).eval x) = L₁ x ∧ (proj Sᶜ) ((CLFun.truncate (k + 1) (cons S L₁ next)).eval x) = (CLFun.truncate k (next (L₁ x))).eval ((proj Sᶜ) x)

                        The two components of the prefix L_{≤(k+1)}(x) = L₁ x + r of a presentation cons S L₁ next on V_T: L₁ x on V_S, and r, the prefix of the continuation, on V_{T \ S}.

                        theorem MIPRE.CL.CLFun.SupportedOn.factorOfPrefix_eval {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.SupportedOn T) (k : ℕ) (x : ι → F) :

                        The factor space at a stage is determined by the prefix: factorOfPrefix computes factorAt. This is what makes the paper's indexing V_{k,u} by u ∈ L_{<k}(V) well defined.

                        theorem MIPRE.CL.CLFun.SupportedOn.mapOfPrefix_eval {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.SupportedOn T) (k : ℕ) (x : ι → F) :
                        P.mapOfPrefix k ((CLFun.truncate k P).eval x) = P.mapAt k x

                        The linear map at a stage is determined by the prefix: mapOfPrefix computes mapAt.

                        theorem MIPRE.CL.CLFun.ExactlyOn.biUnion_factorAt {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] {ℓ : ℕ} [Fintype ι] {P : CLFun F ι ℓ} {T : Finset ι} (hP : P.ExactlyOn T) (x : ι → F) :
                        ((Finset.range ℓ).biUnion fun (i : ℕ) => P.factorAt i x) = T

                        Item (2) of lem:cl-kth: along every run, the factor spaces partition the coordinates.

                        The paper's notion #

                        def MIPRE.CL.IsCLFun {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] (ℓ : ℕ) (T : Finset ι) (f : (ι → F) → ι → F) :

                        Blueprint def:cl-function: f is an ℓ-level conditionally linear function on V_T if some ℓ-level presentation on V_T evaluates to it.

                        Equations
                        Instances For
                          theorem MIPRE.CL.IsCLFun.succ {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] {ℓ : ℕ} {T : Finset ι} {f : (ι → F) → ι → F} (h : IsCLFun ℓ T f) :
                          IsCLFun (ℓ + 1) T f

                          The paper's rk:higher-level: an ℓ-level CL function is (ℓ + 1)-level.

                          theorem MIPRE.CL.IsCLFun.of_le {F : Type u} [Semiring F] {ι : Type v} [DecidableEq ι] [Fintype ι] {ℓ ℓ' : ℕ} {T : Finset ι} {f : (ι → F) → ι → F} (h : IsCLFun ℓ T f) (hℓ : ℓ ≤ ℓ') :
                          IsCLFun ℓ' T f