Documentation

MIPRE.Background.Tailored.Intro.LpIntroData

The register data of the introspection processor #

Issue #281 (Phase 3 of planning/aldous-lyons-track.md). The linear-constraints processor of the tailored introspection verifier (LpIntro.lean) works on an environment Env prepared once per input: the clock 2^{(λn + 1)^5} in unary, the clamped description of the input M, the index 2^n, the Pauli parameters (k, j, 2^j) in unary and the register width Q and the cutoff R in unary (envOf). This file computes from it, at an auxiliary label t and a register y of Q bits, the data the readable condition Typed.G reads:

Each has its correctness theorem at envOf c λ n (clamp (T.progs, λ)), for a λ-bounded tailored input T, a λ-bounded normal form verifier V with T's sampler program, and 1 ≤ n.

The environment #

@[reducible, inline]

The field width k and the selector width j at (c, λ, n).

Equations
Instances For
    @[reducible, inline]

    The register width Q = 2^{2^j} k (SourceCompiler.registerBits), in the form of Typed.Q.

    Equations
    Instances For
      @[reducible, inline]

      The environment: the clock, the clamped description, the index 2^n, the Pauli parameters, Q and R in unary.

      Equations
      • One or more equations did not get rendered due to their size.
      Instances For

        The environment at (c, λ, n) and the description M.

        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
            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              @[simp]
              @[simp]
              theorem MIPRE.Tailored.Intro.LpIntro.eQ_apply (e : Env) :
              eQ.toFun e = e.2.2.2.2.1
              @[simp]
              theorem MIPRE.Tailored.Intro.LpIntro.eR_apply (e : Env) :
              eR.toFun e = e.2.2.2.2.2

              The kernel's context of role w, from the environment.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For

                The register level #

                @[reducible, inline]

                A register with the environment.

                Equations
                Instances For

                  The input question at an auxiliary label: L_w of the register at Sample, the register's first dim bits otherwise.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For

                    A clocked result read as a length, in unary.

                    Equations
                    • One or more equations did not get rendered due to their size.
                    Instances For

                      The input's split at an auxiliary label, in unary: readable (κ = false) or linear.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For

                        Whether the input's answer fits the cutoff, off Hide (srcFits).

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For

                          The prefix condition (Typed.prefixOK).

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For

                            Source membership at an Introspect register.

                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For

                              The readable condition Typed.G, as a Boolean.

                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For

                                Correctness #

                                @[reducible, inline]
                                noncomputable abbrev MIPRE.Tailored.Intro.LpIntro.envT (c lam n : ℕ) (T : TailoredVerifier 7) :

                                The environment of the input T at (c, λ, n).

                                Equations
                                Instances For
                                  theorem MIPRE.Tailored.Intro.LpIntro.ctxP_envT {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hsamp : V.sampler.prog = T.sampler.prog) (w : Bool) :
                                  (ctxP w).toFun (envT c lam n T) = CLData.context V lam n (QQ c lam n) w
                                  theorem MIPRE.Tailored.Intro.LpIntro.cIn_envT {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hsamp : V.sampler.prog = T.sampler.prog) (w : Bool) (y : Cost.BitStr) :
                                  (cIn w).toFun (envT c lam n T, y) = (CLData.context V lam n (QQ c lam n) w, y)
                                  theorem MIPRE.Tailored.Intro.LpIntro.srcQP_envT (U : Cost.ClockedUniversalMachine) {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hV : V.IsBounded lam) (hn : 1 ≤ n) (hsamp : V.sampler.prog = T.sampler.prog) (hs : V.sampler.dim (2 ^ n) ≤ QQ c lam n) (t : Introspection.AuxType 7 × Bool) (y : Cost.BitStr) (hy : List.length y = QQ c lam n) :
                                  (srcQP U t).toFun (envT c lam n T, y) = srcQuestion V hs t y

                                  The input question at a register.

                                  theorem MIPRE.Tailored.Intro.LpIntro.length_srcQuestion_le {c lam n : ℕ} (V : Verifier 7) (hV : V.IsBounded lam) (hn : 1 ≤ n) (hs : V.sampler.dim (2 ^ n) ≤ QQ c lam n) (t : Introspection.AuxType 7 × Bool) (y : Cost.BitStr) :
                                  List.length (srcQuestion V hs t y) ≤ (2 ^ n) ^ lam

                                  The input question has at most (2^n)^λ bits.

                                  theorem MIPRE.Tailored.Intro.LpIntro.length_splitU (U : Cost.ClockedUniversalMachine) {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hV : V.IsBounded lam) (hn : 1 ≤ n) (hsamp : V.sampler.prog = T.sampler.prog) (hs : V.sampler.dim (2 ^ n) ≤ QQ c lam n) (κ : Bool) (t : Introspection.AuxType 7 × Bool) (y : Cost.BitStr) (hy : List.length y = QQ c lam n) :
                                  List.length ((splitU U κ t).toFun (envT c lam n T, y)) = T.lenOf (2 ^ n) (srcQuestion V hs t y) κ

                                  The input's split at a register, in unary.

                                  theorem MIPRE.Tailored.Intro.LpIntro.splitU_envT (U : Cost.ClockedUniversalMachine) {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hV : V.IsBounded lam) (hn : 1 ≤ n) (hsamp : V.sampler.prog = T.sampler.prog) (hs : V.sampler.dim (2 ^ n) ≤ QQ c lam n) (κ : Bool) (t : Introspection.AuxType 7 × Bool) (y : Cost.BitStr) (hy : List.length y = QQ c lam n) :
                                  (splitU U κ t).toFun (envT c lam n T, y) = Cost.unary (T.lenOf (2 ^ n) (srcQuestion V hs t y) κ)
                                  theorem MIPRE.Tailored.Intro.LpIntro.fitsP_envT (U : Cost.ClockedUniversalMachine) {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hV : V.IsBounded lam) (hn : 1 ≤ n) (hsamp : V.sampler.prog = T.sampler.prog) (hs : V.sampler.dim (2 ^ n) ≤ QQ c lam n) (t : Introspection.AuxType 7 × Bool) (y : Cost.BitStr) (hy : List.length y = QQ c lam n) :
                                  (fitsP U t).toFun (envT c lam n T, y) = true ↔ srcFits ((2 ^ n) ^ lam) (srcSplitR T V hs) (srcSplitL T V hs) t y
                                  theorem MIPRE.Tailored.Intro.LpIntro.prefP_envT (U : Cost.ClockedUniversalMachine) {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hV : V.IsBounded lam) (hn : 1 ≤ n) (hsamp : V.sampler.prog = T.sampler.prog) (hs : V.sampler.dim (2 ^ n) ≤ QQ c lam n) (t : Introspection.AuxType 7 × Bool) (y : Cost.BitStr) (hy : List.length y = QQ c lam n) :
                                  (prefP U t).toFun (envT c lam n T, y) = true ↔ Typed.prefixOK (kk c lam n) (jj c lam n) V hs t y
                                  theorem MIPRE.Tailored.Intro.LpIntro.GP_envT (U : Cost.ClockedUniversalMachine) {c lam n : ℕ} (T : TailoredVerifier 7) (V : Verifier 7) (hT : T.IsBounded lam) (hV : V.IsBounded lam) (hn : 1 ≤ n) (hsamp : V.sampler.prog = T.sampler.prog) (hs : V.sampler.dim (2 ^ n) ≤ QQ c lam n) (t : Introspection.AuxType 7 × Bool) (y : Cost.BitStr) (hy : List.length y = QQ c lam n) :
                                  (GP U t).toFun (envT c lam n T, y) = true ↔ Typed.G (kk c lam n) (jj c lam n) ((2 ^ n) ^ lam) T V hs t y

                                  The readable condition Typed.G at a register of Q bits.