Documentation

Determinize.Proof.Semantics.Measurability

Measurability of the paper semantics #

The expression space is decomposed into countably many fixed-skeleton fibers. On each fiber, reduction is represented by a measurable family of actions; these pieces assemble into the global one-step kernel.

theorem Determinize.Proof.Paper.measurable_envCons {n : ℕ} :
Measurable fun (input : ℝ × (Fin n → ℝ)) => Env.cons input.1 input.2

Extending a finite real environment is measurable.

structure Determinize.Proof.Paper.SFiniteKernel (α : Type u_1) (β : Type u_2) [MeasurableSpace α] [MeasurableSpace β] :
Type (max u_1 u_2)

An s-finite kernel packaged with the instance needed for composition.

Instances For
    noncomputable def Determinize.Proof.Paper.SFiniteKernel.zero {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] :
    Equations
    Instances For
      noncomputable def Determinize.Proof.Paper.SFiniteKernel.deterministic {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] (function : α → β) (measurable : Measurable function) :
      Equations
      Instances For
        noncomputable def Determinize.Proof.Paper.SFiniteKernel.piecewise {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] {set : Set α} (measurableSet : MeasurableSet set) (thenKernel elseKernel : SFiniteKernel α β) :
        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          noncomputable def Determinize.Proof.Paper.SFiniteKernel.mapWithInput {α : Type u_1} {β : Type u_2} {γ : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] (draw : SFiniteKernel α β) (transform : α × β → γ) (measurableTransform : Measurable transform) :
          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem Determinize.Proof.Paper.SFiniteKernel.mapWithInput_apply {α : Type u_1} {β : Type u_2} {γ : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] (draw : SFiniteKernel α β) (transform : α × β → γ) (measurableTransform : Measurable transform) (parameter : α) :
            (draw.mapWithInput transform measurableTransform).kernel parameter = MeasureTheory.Measure.map (fun (value : β) => transform (parameter, value)) (draw.kernel parameter)
            noncomputable def Determinize.Proof.Paper.SFiniteKernel.pullback {α : Type u_1} {β : Type u_2} {γ : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] (draw : SFiniteKernel β γ) (parameters : α → β) (measurableParameters : Measurable parameters) :
            Equations
            Instances For
              instance Determinize.Proof.Paper.instCountableExpr {Literal✝ Site✝ : Type} [Countable Literal✝] [Countable Site✝] :
              Countable (Spec.Paper.Expr Literal✝ Site✝)

              The canonical expression with a given skeleton: every literal is 0.

              Equations
              Instances For
                theorem Determinize.Proof.Paper.RealCoordinates.measurable_of_length_getD {α : Type u_1} [MeasurableSpace α] {coordinates : α → Spec.Paper.RealCoordinates} (lengthMeasurable : Measurable fun (parameter : α) => (coordinates parameter).values.length) (coordinateMeasurable : ∀ (index : ℕ), Measurable fun (parameter : α) => (coordinates parameter).values.getD index 0) :
                Measurable coordinates

                A map into real coordinates is measurable once its length and each of its zero-padded coordinates are.

                structure Determinize.Proof.Paper.MeasurableFamily (α : Type u_1) [MeasurableSpace α] (expression : α → Spec.Paper.Expr) :

                A family of expressions with a fixed real-free skeleton and measurably varying real coordinates.

                Instances For
                  theorem Determinize.Proof.Paper.MeasurableFamily.coordinate_count {α : Type u_1} [MeasurableSpace α] {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) (parameter : α) :

                  Every member of a family has as many real coordinates as the skeleton's real arity.

                  def Determinize.Proof.Paper.MeasurableFamily.comp {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) (function : β → α) (measurableFunction : Measurable function) :
                  MeasurableFamily β (expression ∘ function)
                  Equations
                  • family.comp function measurableFunction = { skeleton := family.skeleton, skeleton_eq := ⋯, coordinate_measurable := ⋯ }
                  Instances For
                    def Determinize.Proof.Paper.MeasurableFamily.extractContiguous {α : Type u_1} [MeasurableSpace α] {parent child : α → Spec.Paper.Expr} (parentFamily : MeasurableFamily α parent) (childSkeleton : Spec.Paper.Skeleton) (offset : ℕ) (child_skeleton : ∀ (parameter : α), (child parameter).skeleton = childSkeleton) (coordinate_rule : ∀ (parameter : α), ∀ index < Spec.Paper.Expr.realArity childSkeleton, (child parameter).realCoordinates.getD index 0 = (parent parameter).realCoordinates.getD (offset + index) 0) :

                    Extract a fixed-skeleton child whose coordinates occupy a contiguous block of the parent's coordinate traversal.

                    Equations
                    • parentFamily.extractContiguous childSkeleton offset child_skeleton coordinate_rule = { skeleton := childSkeleton, skeleton_eq := child_skeleton, coordinate_measurable := ⋯ }
                    Instances For
                      theorem Determinize.Proof.Paper.MeasurableFamily.measurable_realCoordinates {α : Type u_1} [MeasurableSpace α] {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) :
                      Measurable fun (parameter : α) => { values := (expression parameter).realCoordinates }
                      theorem Determinize.Proof.Paper.MeasurableFamily.measurable {α : Type u_1} [MeasurableSpace α] {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) :
                      Measurable expression
                      def Determinize.Proof.Paper.MeasurableFamily.constant {α : Type u_1} [MeasurableSpace α] (expression : Spec.Paper.Expr) :
                      MeasurableFamily α fun (x : α) => expression
                      Equations
                      Instances For
                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          def Determinize.Proof.Paper.MeasurableFamily.combine {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (constructor : Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (l r : Spec.Paper.Expr), (constructor l r).skeleton = skeletonConstructor l.skeleton r.skeleton) (coordinates_rule : ∀ (l r : Spec.Paper.Expr), (constructor l r).realCoordinates = l.realCoordinates ++ r.realCoordinates) :
                          MeasurableFamily α fun (parameter : α) => constructor (left parameter) (right parameter)

                          Combine two fixed-skeleton families through a constructor whose coordinate traversal is concatenation.

                          Equations
                          • One or more equations did not get rendered due to their size.
                          Instances For
                            def Determinize.Proof.Paper.MeasurableFamily.app {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) :
                            MeasurableFamily α fun (parameter : α) => (left parameter).app ℝ Spec.Paper.DistributionAction (right parameter)
                            Equations
                            • One or more equations did not get rendered due to their size.
                            Instances For
                              def Determinize.Proof.Paper.MeasurableFamily.pair {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) :
                              MeasurableFamily α fun (parameter : α) => (left parameter).pair ℝ Spec.Paper.DistributionAction (right parameter)
                              Equations
                              • One or more equations did not get rendered due to their size.
                              Instances For
                                def Determinize.Proof.Paper.MeasurableFamily.cons {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) :
                                MeasurableFamily α fun (parameter : α) => (left parameter).cons ℝ Spec.Paper.DistributionAction (right parameter)
                                Equations
                                • One or more equations did not get rendered due to their size.
                                Instances For
                                  def Determinize.Proof.Paper.MeasurableFamily.add {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) :
                                  MeasurableFamily α fun (parameter : α) => (left parameter).add ℝ Spec.Paper.DistributionAction (right parameter)
                                  Equations
                                  • One or more equations did not get rendered due to their size.
                                  Instances For
                                    def Determinize.Proof.Paper.MeasurableFamily.mul {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) :
                                    MeasurableFamily α fun (parameter : α) => (left parameter).mul ℝ Spec.Paper.DistributionAction (right parameter)
                                    Equations
                                    • One or more equations did not get rendered due to their size.
                                    Instances For
                                      def Determinize.Proof.Paper.MeasurableFamily.div {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) :
                                      MeasurableFamily α fun (parameter : α) => (left parameter).div ℝ Spec.Paper.DistributionAction (right parameter)
                                      Equations
                                      • One or more equations did not get rendered due to their size.
                                      Instances For
                                        def Determinize.Proof.Paper.MeasurableFamily.lt {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) :
                                        MeasurableFamily α fun (parameter : α) => (left parameter).lt ℝ Spec.Paper.DistributionAction (right parameter)
                                        Equations
                                        • One or more equations did not get rendered due to their size.
                                        Instances For
                                          def Determinize.Proof.Paper.MeasurableFamily.wrap {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (constructor : Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).skeleton = skeletonConstructor expression.skeleton) (coordinates_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).realCoordinates = expression.realCoordinates) :
                                          MeasurableFamily α fun (parameter : α) => constructor (body parameter)

                                          Lift a unary constructor whose real-coordinate traversal is unchanged.

                                          Equations
                                          • bodyFamily.wrap constructor skeletonConstructor skeleton_rule coordinates_rule = { skeleton := skeletonConstructor bodyFamily.skeleton, skeleton_eq := ⋯, coordinate_measurable := ⋯ }
                                          Instances For
                                            def Determinize.Proof.Paper.MeasurableFamily.fst {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (family : MeasurableFamily α body) :
                                            MeasurableFamily α fun (parameter : α) => (body parameter).fst ℝ Spec.Paper.DistributionAction
                                            Equations
                                            • One or more equations did not get rendered due to their size.
                                            Instances For
                                              def Determinize.Proof.Paper.MeasurableFamily.snd {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (family : MeasurableFamily α body) :
                                              MeasurableFamily α fun (parameter : α) => (body parameter).snd ℝ Spec.Paper.DistributionAction
                                              Equations
                                              • One or more equations did not get rendered due to their size.
                                              Instances For
                                                def Determinize.Proof.Paper.MeasurableFamily.inl {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (family : MeasurableFamily α body) :
                                                MeasurableFamily α fun (parameter : α) => (body parameter).inl ℝ Spec.Paper.DistributionAction
                                                Equations
                                                • One or more equations did not get rendered due to their size.
                                                Instances For
                                                  def Determinize.Proof.Paper.MeasurableFamily.inr {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (family : MeasurableFamily α body) :
                                                  MeasurableFamily α fun (parameter : α) => (body parameter).inr ℝ Spec.Paper.DistributionAction
                                                  Equations
                                                  • One or more equations did not get rendered due to their size.
                                                  Instances For
                                                    def Determinize.Proof.Paper.MeasurableFamily.neg {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (family : MeasurableFamily α body) :
                                                    MeasurableFamily α fun (parameter : α) => (body parameter).neg ℝ Spec.Paper.DistributionAction
                                                    Equations
                                                    • One or more equations did not get rendered due to their size.
                                                    Instances For

                                                      Structural child projections used on a fixed skeleton fiber. Their fallback is unreachable once the enclosing skeleton constructor is fixed.

                                                      Equations
                                                      Instances For
                                                        Equations
                                                        Instances For
                                                          Equations
                                                          Instances For
                                                            Equations
                                                            Instances For
                                                              Equations
                                                              Instances For
                                                                theorem Determinize.Proof.Paper.list_getD_append_right {α : Type u_1} (left right : List α) (index : ℕ) (default : α) :
                                                                (left ++ right).getD (left.length + index) default = right.getD index default

                                                                List.getD_append_right at an index offset by the left length, the form the coordinate lemmas rewrite with.

                                                                theorem Determinize.Proof.Paper.list_getD_append_middle {α : Type u_1} (first second third : List α) (index : ℕ) (default : α) (inBounds : index < second.length) :
                                                                (first ++ second ++ third).getD (first.length + index) default = second.getD index default
                                                                theorem Determinize.Proof.Paper.firstChild_coordinate (expression : Spec.Paper.Expr) (index : ℕ) (inBounds : index < Spec.Paper.Expr.realArity (Expr.firstChild expression).skeleton) :
                                                                (Expr.firstChild expression).realCoordinates.getD index 0 = expression.realCoordinates.getD index 0
                                                                def Determinize.Proof.Paper.MeasurableFamily.firstChild {α : Type u_1} [MeasurableSpace α] {parent : α → Spec.Paper.Expr} (family : MeasurableFamily α parent) :
                                                                MeasurableFamily α fun (parameter : α) => Expr.firstChild (parent parameter)
                                                                Equations
                                                                Instances For
                                                                  def Determinize.Proof.Paper.MeasurableFamily.thirdChild {α : Type u_1} [MeasurableSpace α] {parent : α → Spec.Paper.Expr} (family : MeasurableFamily α parent) :
                                                                  MeasurableFamily α fun (parameter : α) => Expr.thirdChild (parent parameter)
                                                                  Equations
                                                                  Instances For
                                                                    theorem Determinize.Proof.Paper.measurable_realCoordinateAt {α : Type u_1} [MeasurableSpace α] (coordinates : α → Spec.Paper.RealCoordinates) (coordinatesMeasurable : Measurable coordinates) (index : α → ℕ) (indexMeasurable : Measurable index) :
                                                                    Measurable fun (parameter : α) => (coordinates parameter).values.getD (index parameter) 0
                                                                    theorem Determinize.Proof.Paper.measurable_expr_of_parts {α : Type u_1} [MeasurableSpace α] (expression : α → Spec.Paper.Expr) (skeletonMeasurable : Measurable fun (parameter : α) => (expression parameter).skeleton) (coordinatesMeasurable : Measurable fun (parameter : α) => { values := (expression parameter).realCoordinates }) :
                                                                    Measurable expression
                                                                    theorem Determinize.Proof.Paper.measurable_binaryConstructor {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftMeasurable : Measurable left) (rightMeasurable : Measurable right) (constructor : Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (l r : Spec.Paper.Expr), (constructor l r).skeleton = skeletonConstructor l.skeleton r.skeleton) (coordinates_rule : ∀ (l r : Spec.Paper.Expr), (constructor l r).realCoordinates = l.realCoordinates ++ r.realCoordinates) :
                                                                    Measurable fun (parameter : α) => constructor (left parameter) (right parameter)
                                                                    theorem Determinize.Proof.Paper.measurable_unaryConstructor {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (bodyMeasurable : Measurable body) (constructor : Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).skeleton = skeletonConstructor expression.skeleton) (coordinates_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).realCoordinates = expression.realCoordinates) :
                                                                    Measurable fun (parameter : α) => constructor (body parameter)
                                                                    theorem Determinize.Proof.Paper.measurable_realLiteral {α : Type u_1} [MeasurableSpace α] {value : α → ℝ} (valueMeasurable : Measurable value) :
                                                                    Measurable fun (parameter : α) => Spec.Paper.Expr.real ℝ Spec.Paper.DistributionAction (value parameter)
                                                                    Equations
                                                                    Instances For
                                                                      theorem Determinize.Proof.Paper.shift_skeleton (amount cutoff : ℕ) (expression : Spec.Paper.Expr) :
                                                                      (Spec.Paper.Expr.shift amount cutoff expression).skeleton = skeletonShift amount cutoff expression.skeleton
                                                                      theorem Determinize.Proof.Paper.shift_realCoordinates (amount cutoff : ℕ) (expression : Spec.Paper.Expr) :
                                                                      (Spec.Paper.Expr.shift amount cutoff expression).realCoordinates = expression.realCoordinates
                                                                      def Determinize.Proof.Paper.MeasurableFamily.shift {α : Type u_1} [MeasurableSpace α] {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) (amount cutoff : ℕ) :
                                                                      MeasurableFamily α fun (parameter : α) => Spec.Paper.Expr.shift amount cutoff (expression parameter)
                                                                      Equations
                                                                      Instances For
                                                                        theorem Determinize.Proof.Paper.substAt_skeleton (depth : ℕ) (replacement expression : Spec.Paper.Expr) :
                                                                        (Spec.Paper.Expr.substAt depth replacement expression).skeleton = skeletonSubstAt depth replacement.skeleton expression.skeleton
                                                                        Instances For
                                                                          Equations
                                                                          Instances For
                                                                            theorem Determinize.Proof.Paper.map_range_getD (values : List ℝ) :
                                                                            List.map (fun (index : ℕ) => values.getD index 0) (List.range values.length) = values
                                                                            @[simp]
                                                                            theorem Determinize.Proof.Paper.applyCoordinatePlan_append (left right : List CoordinateSelector) (body replacement : List ℝ) :
                                                                            applyCoordinatePlan (left ++ right) body replacement = applyCoordinatePlan left body replacement ++ applyCoordinatePlan right body replacement
                                                                            theorem Determinize.Proof.Paper.applyCoordinatePlan_bodyAtPrefix (before suffix : List ℝ) (value : ℝ) (replacement : List ℝ) :
                                                                            applyCoordinatePlan [CoordinateSelector.body before.length] (before ++ value :: suffix) replacement = [value]
                                                                            theorem Determinize.Proof.Paper.applyCoordinatePlan_coordinatePlan (depth : ℕ) (replacement expression : Spec.Paper.Expr) (before suffix : List ℝ) :
                                                                            applyCoordinatePlan (coordinatePlan depth replacement.skeleton before.length expression.skeleton) (before ++ expression.realCoordinates ++ suffix) replacement.realCoordinates = (Spec.Paper.Expr.substAt depth replacement expression).realCoordinates
                                                                            theorem Determinize.Proof.Paper.substAt_realCoordinates (depth : ℕ) (replacement expression : Spec.Paper.Expr) :
                                                                            applyCoordinatePlan (coordinatePlan depth replacement.skeleton 0 expression.skeleton) expression.realCoordinates replacement.realCoordinates = (Spec.Paper.Expr.substAt depth replacement expression).realCoordinates
                                                                            theorem Determinize.Proof.Paper.applyCoordinatePlan_getD_of_lt (plan : List CoordinateSelector) (body replacement : List ℝ) (index : ℕ) (inBounds : index < plan.length) :
                                                                            (applyCoordinatePlan plan body replacement).getD index 0 = CoordinateSelector.eval body replacement plan[index]
                                                                            def Determinize.Proof.Paper.MeasurableFamily.substAt {α : Type u_1} [MeasurableSpace α] {body replacement : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (depth : ℕ) (replacementFamily : MeasurableFamily α replacement) :
                                                                            MeasurableFamily α fun (parameter : α) => Spec.Paper.Expr.substAt depth (replacement parameter) (body parameter)
                                                                            Equations
                                                                            • One or more equations did not get rendered due to their size.
                                                                            Instances For
                                                                              def Determinize.Proof.Paper.MeasurableFamily.substHead {α : Type u_1} [MeasurableSpace α] {body replacement : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (replacementFamily : MeasurableFamily α replacement) :
                                                                              MeasurableFamily α fun (parameter : α) => (body parameter).substHead (replacement parameter)
                                                                              Equations
                                                                              Instances For
                                                                                def Determinize.Proof.Paper.MeasurableFamily.substTwo {α : Type u_1} [MeasurableSpace α] {body argument function : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (argumentFamily : MeasurableFamily α argument) (functionFamily : MeasurableFamily α function) :
                                                                                MeasurableFamily α fun (parameter : α) => (body parameter).substTwo (argument parameter) (function parameter)
                                                                                Equations
                                                                                Instances For
                                                                                  theorem Determinize.Proof.Paper.MeasurableFamily.isValue_eq {α : Type u_1} [MeasurableSpace α] {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) (parameter : α) :
                                                                                  (expression parameter).isValue = Spec.Paper.Expr.isValue family.skeleton
                                                                                  Equations
                                                                                  • One or more equations did not get rendered due to their size.
                                                                                  Instances For
                                                                                    theorem Determinize.Proof.Paper.paramsFromCoordinates_eq_getElem (op : Spec.Paper.Op) (affine general : List ℝ) (affineArity : affine.length = Spec.Paper.affineArity op) (generalArity : general.length = Spec.Paper.generalArity op) :
                                                                                    paramsFromCoordinates op affine general = (fun (index : Fin (Spec.Paper.affineArity op)) => affine[↑index], fun (index : Fin (Spec.Paper.generalArity op)) => general[↑index])

                                                                                    The kernel of a primitive site in its evaluated parameters: the primitive's law at a stochastic site, the Dirac mass at its mean on the parameter domain at a mean site.

                                                                                    Equations
                                                                                    Instances For
                                                                                      theorem Determinize.Proof.Paper.primitiveFiber_eq_atomic (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) (op : Spec.Paper.Op) (affine general : List ℝ) (affineArity : affine.length = Spec.Paper.affineArity op) (generalArity : general.length = Spec.Paper.generalArity op) :
                                                                                      Spec.Paper.primitiveFiber kind op affine general = (primitiveKernelPack laws kind op).kernel (paramsFromCoordinates op affine general)

                                                                                      A measurable finite-piece description of a parameter-dependent reduction action. Sample continuations are jointly measurable in the original parameter and the freshly drawn real.

                                                                                      Instances For
                                                                                        theorem Determinize.Proof.Paper.MeasurableActionFamily.pullback_apply {α : Type u_1} {β : Type u_2} {γ : Type u_3} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] (draw : SFiniteKernel β γ) (function : α → β) (measurableFunction : Measurable function) (parameter : α) :
                                                                                        (draw.pullback function measurableFunction).kernel parameter = draw.kernel (function parameter)
                                                                                        def Determinize.Proof.Paper.MeasurableActionFamily.congr {α : Type u_1} [MeasurableSpace α] {first second : α → Spec.Paper.Action} (family : MeasurableActionFamily α first) (equal : first = second) :
                                                                                        Equations
                                                                                        Instances For
                                                                                          def Determinize.Proof.Paper.MeasurableActionFamily.comp {α : Type u_1} {β : Type u_2} [MeasurableSpace α] [MeasurableSpace β] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (function : β → α) (measurableFunction : Measurable function) :
                                                                                          MeasurableActionFamily β (action ∘ function)
                                                                                          Equations
                                                                                          Instances For
                                                                                            def Determinize.Proof.Paper.MeasurableActionFamily.map {α : Type u_1} [MeasurableSpace α] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (context : α → Spec.Paper.Expr → Spec.Paper.Expr) (nextMeasurable : ∀ {body : α → Spec.Paper.Expr}, Measurable body → Measurable fun (input : α) => context input (body input)) (sampleMeasurable : ∀ {body : α × ℝ → Spec.Paper.Expr}, Measurable body → Measurable fun (input : α × ℝ) => context input.1 (body input)) :
                                                                                            MeasurableActionFamily α fun (parameter : α) => Spec.Paper.Action.wrap (context parameter) (action parameter)

                                                                                            Map every successor and sample continuation through a jointly measurable parameter-dependent one-hole context.

                                                                                            Equations
                                                                                            Instances For

                                                                                              The kernel of uniform in its evaluated operands.

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

                                                                                                The kernel of gaussian in its evaluated operands.

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

                                                                                                  The kernel of beta in its evaluated operands.

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

                                                                                                    The kernel of gamma in its evaluated operands.

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

                                                                                                      The kernel of poisson in its evaluated operands.

                                                                                                      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
                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.discreteDraw_apply (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) (arity : ℕ) (weights : List ℝ) (lengthEq : weights.length = arity) :
                                                                                                          ((discreteDraw laws kind arity).kernel fun (index : Fin arity) => weights.getD (↑index) 0) = Spec.Paper.discreteFiber kind weights
                                                                                                          Equations
                                                                                                          • One or more equations did not get rendered due to their size.
                                                                                                          Instances For

                                                                                                            The kernel of exponential in its evaluated operands.

                                                                                                            Equations
                                                                                                            • One or more equations did not get rendered due to their size.
                                                                                                            Instances For
                                                                                                              def Determinize.Proof.Paper.MeasurableActionFamily.wrapUnary {α : Type u_1} [MeasurableSpace α] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (constructor : Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).skeleton = skeletonConstructor expression.skeleton) (coordinates_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).realCoordinates = expression.realCoordinates) :
                                                                                                              MeasurableActionFamily α fun (parameter : α) => Spec.Paper.Action.wrap constructor (action parameter)
                                                                                                              Equations
                                                                                                              • family.wrapUnary constructor skeletonConstructor skeleton_rule coordinates_rule = family.map (fun (x : α) => constructor) ⋯ ⋯
                                                                                                              Instances For
                                                                                                                def Determinize.Proof.Paper.MeasurableActionFamily.wrapBinaryLeft {α : Type u_1} [MeasurableSpace α] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (right : α → Spec.Paper.Expr) (rightMeasurable : Measurable right) (constructor : Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (left right : Spec.Paper.Expr), (constructor left right).skeleton = skeletonConstructor left.skeleton right.skeleton) (coordinates_rule : ∀ (left right : Spec.Paper.Expr), (constructor left right).realCoordinates = left.realCoordinates ++ right.realCoordinates) :
                                                                                                                MeasurableActionFamily α fun (parameter : α) => Spec.Paper.Action.wrap (fun (next : Spec.Paper.Expr) => constructor next (right parameter)) (action parameter)
                                                                                                                Equations
                                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                                Instances For
                                                                                                                  def Determinize.Proof.Paper.MeasurableActionFamily.wrapBinaryRight {α : Type u_1} [MeasurableSpace α] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (left : α → Spec.Paper.Expr) (leftMeasurable : Measurable left) (constructor : Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (left right : Spec.Paper.Expr), (constructor left right).skeleton = skeletonConstructor left.skeleton right.skeleton) (coordinates_rule : ∀ (left right : Spec.Paper.Expr), (constructor left right).realCoordinates = left.realCoordinates ++ right.realCoordinates) :
                                                                                                                  MeasurableActionFamily α fun (parameter : α) => Spec.Paper.Action.wrap (fun (next : Spec.Paper.Expr) => constructor (left parameter) next) (action parameter)
                                                                                                                  Equations
                                                                                                                  • One or more equations did not get rendered due to their size.
                                                                                                                  Instances For
                                                                                                                    theorem Determinize.Proof.Paper.MeasurableActionFamily.measurable_ternaryConstructor {α : Type u_1} [MeasurableSpace α] {first second third : α → Spec.Paper.Expr} (firstMeasurable : Measurable first) (secondMeasurable : Measurable second) (thirdMeasurable : Measurable third) (constructor : Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (first second third : Spec.Paper.Expr), (constructor first second third).skeleton = skeletonConstructor first.skeleton second.skeleton third.skeleton) (coordinates_rule : ∀ (first second third : Spec.Paper.Expr), (constructor first second third).realCoordinates = first.realCoordinates ++ second.realCoordinates ++ third.realCoordinates) :
                                                                                                                    Measurable fun (parameter : α) => constructor (first parameter) (second parameter) (third parameter)
                                                                                                                    def Determinize.Proof.Paper.MeasurableActionFamily.wrapTernaryFirst {α : Type u_1} [MeasurableSpace α] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (second third : α → Spec.Paper.Expr) (secondMeasurable : Measurable second) (thirdMeasurable : Measurable third) (constructor : Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (first second third : Spec.Paper.Expr), (constructor first second third).skeleton = skeletonConstructor first.skeleton second.skeleton third.skeleton) (coordinates_rule : ∀ (first second third : Spec.Paper.Expr), (constructor first second third).realCoordinates = first.realCoordinates ++ second.realCoordinates ++ third.realCoordinates) :
                                                                                                                    MeasurableActionFamily α fun (parameter : α) => Spec.Paper.Action.wrap (fun (next : Spec.Paper.Expr) => constructor next (second parameter) (third parameter)) (action parameter)
                                                                                                                    Equations
                                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                                    Instances For
                                                                                                                      noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reducePair {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                      MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((left parameter).pair ℝ Spec.Paper.DistributionAction (right parameter))
                                                                                                                      Equations
                                                                                                                      • One or more equations did not get rendered due to their size.
                                                                                                                      Instances For
                                                                                                                        noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceCons {α : Type u_1} [MeasurableSpace α] {head tail : α → Spec.Paper.Expr} (headFamily : MeasurableFamily α head) (tailFamily : MeasurableFamily α tail) (headReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (head parameter)) (tailReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (tail parameter)) :
                                                                                                                        MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((head parameter).cons ℝ Spec.Paper.DistributionAction (tail parameter))
                                                                                                                        Equations
                                                                                                                        • One or more equations did not get rendered due to their size.
                                                                                                                        Instances For
                                                                                                                          noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceInl {α : Type u_1} [MeasurableSpace α] {value : α → Spec.Paper.Expr} (valueFamily : MeasurableFamily α value) (valueReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (value parameter)) :
                                                                                                                          MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((value parameter).inl ℝ Spec.Paper.DistributionAction)
                                                                                                                          Equations
                                                                                                                          • One or more equations did not get rendered due to their size.
                                                                                                                          Instances For
                                                                                                                            noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceInr {α : Type u_1} [MeasurableSpace α] {value : α → Spec.Paper.Expr} (valueFamily : MeasurableFamily α value) (valueReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (value parameter)) :
                                                                                                                            MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((value parameter).inr ℝ Spec.Paper.DistributionAction)
                                                                                                                            Equations
                                                                                                                            • One or more equations did not get rendered due to their size.
                                                                                                                            Instances For
                                                                                                                              noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceApp {α : Type u_1} [MeasurableSpace α] {function argument : α → Spec.Paper.Expr} (functionFamily : MeasurableFamily α function) (argumentFamily : MeasurableFamily α argument) (functionReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (function parameter)) (argumentReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (argument parameter)) :
                                                                                                                              MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((function parameter).app ℝ Spec.Paper.DistributionAction (argument parameter))
                                                                                                                              Equations
                                                                                                                              • One or more equations did not get rendered due to their size.
                                                                                                                              Instances For
                                                                                                                                noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceFst {α : Type u_1} [MeasurableSpace α] {pair : α → Spec.Paper.Expr} (pairFamily : MeasurableFamily α pair) (pairReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (pair parameter)) :
                                                                                                                                MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((pair parameter).fst ℝ Spec.Paper.DistributionAction)
                                                                                                                                Equations
                                                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                                                Instances For
                                                                                                                                  noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceSnd {α : Type u_1} [MeasurableSpace α] {pair : α → Spec.Paper.Expr} (pairFamily : MeasurableFamily α pair) (pairReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (pair parameter)) :
                                                                                                                                  MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((pair parameter).snd ℝ Spec.Paper.DistributionAction)
                                                                                                                                  Equations
                                                                                                                                  • One or more equations did not get rendered due to their size.
                                                                                                                                  Instances For
                                                                                                                                    noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceMatchSum {α : Type u_1} [MeasurableSpace α] {scrutinee left right : α → Spec.Paper.Expr} (scrutineeFamily : MeasurableFamily α scrutinee) (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (scrutineeReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (scrutinee parameter)) :
                                                                                                                                    MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((scrutinee parameter).matchSum ℝ Spec.Paper.DistributionAction (left parameter) (right parameter))
                                                                                                                                    Equations
                                                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                                                    Instances For
                                                                                                                                      noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceMatchList {α : Type u_1} [MeasurableSpace α] {scrutinee nilCase consCase : α → Spec.Paper.Expr} (scrutineeFamily : MeasurableFamily α scrutinee) (nilFamily : MeasurableFamily α nilCase) (consFamily : MeasurableFamily α consCase) (scrutineeReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (scrutinee parameter)) :
                                                                                                                                      MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((scrutinee parameter).matchList ℝ Spec.Paper.DistributionAction (nilCase parameter) (consCase parameter))
                                                                                                                                      Equations
                                                                                                                                      • One or more equations did not get rendered due to their size.
                                                                                                                                      Instances For
                                                                                                                                        noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceIte {α : Type u_1} [MeasurableSpace α] {condition thenBranch elseBranch : α → Spec.Paper.Expr} (conditionFamily : MeasurableFamily α condition) (thenFamily : MeasurableFamily α thenBranch) (elseFamily : MeasurableFamily α elseBranch) (conditionReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (condition parameter)) :
                                                                                                                                        MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((condition parameter).ite ℝ Spec.Paper.DistributionAction (thenBranch parameter) (elseBranch parameter))
                                                                                                                                        Equations
                                                                                                                                        • One or more equations did not get rendered due to their size.
                                                                                                                                        Instances For
                                                                                                                                          noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceLet {α : Type u_1} [MeasurableSpace α] {value body : α → Spec.Paper.Expr} (valueFamily : MeasurableFamily α value) (bodyFamily : MeasurableFamily α body) (valueReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (value parameter)) :
                                                                                                                                          MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((value parameter).letE ℝ Spec.Paper.DistributionAction (body parameter))
                                                                                                                                          Equations
                                                                                                                                          • One or more equations did not get rendered due to their size.
                                                                                                                                          Instances For
                                                                                                                                            noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceNeg {α : Type u_1} [MeasurableSpace α] {body : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (bodyReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (body parameter)) :
                                                                                                                                            MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((body parameter).neg ℝ Spec.Paper.DistributionAction)
                                                                                                                                            Equations
                                                                                                                                            • One or more equations did not get rendered due to their size.
                                                                                                                                            Instances For
                                                                                                                                              noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceAdd {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                              MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((left parameter).add ℝ Spec.Paper.DistributionAction (right parameter))
                                                                                                                                              Equations
                                                                                                                                              • One or more equations did not get rendered due to their size.
                                                                                                                                              Instances For
                                                                                                                                                noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceMul {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((left parameter).mul ℝ Spec.Paper.DistributionAction (right parameter))
                                                                                                                                                Equations
                                                                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                                                                Instances For
                                                                                                                                                  noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceDiv {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                  MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((left parameter).div ℝ Spec.Paper.DistributionAction (right parameter))
                                                                                                                                                  Equations
                                                                                                                                                  • One or more equations did not get rendered due to their size.
                                                                                                                                                  Instances For
                                                                                                                                                    noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceLt {α : Type u_1} [MeasurableSpace α] {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                    MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce ((left parameter).lt ℝ Spec.Paper.DistributionAction (right parameter))
                                                                                                                                                    Equations
                                                                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                                                                    Instances For
                                                                                                                                                      noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceBinaryDraw {α : Type u_1} [MeasurableSpace α] (site : Spec.Paper.DistributionAction × Spec.Paper.Op) (constructor : Spec.Paper.Expr → Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (left right : Spec.Paper.Expr), (constructor left right).skeleton = skeletonConstructor left.skeleton right.skeleton) (coordinates_rule : ∀ (left right : Spec.Paper.Expr), (constructor left right).realCoordinates = left.realCoordinates ++ right.realCoordinates) (fiber : ℝ → ℝ → MeasureTheory.Measure ℝ) (reduce_eq : ∀ (left right : Spec.Paper.Expr), Spec.Paper.reduce (constructor left right) = if left.isValue = true then if right.isValue = true then match Spec.Paper.realValue? left, Spec.Paper.realValue? right with | some a, some b => Spec.Paper.Action.sample site (fiber a b) Spec.Paper.Expr.real | x, x_1 => Spec.Paper.Action.stuck else Spec.Paper.Action.wrap (constructor left) (Spec.Paper.reduce right) else Spec.Paper.Action.wrap (fun (next : Spec.Paper.Expr) => constructor next right) (Spec.Paper.reduce left)) (draw : SFiniteKernel (ℝ × ℝ) ℝ) (draw_apply : ∀ (a b : ℝ), draw.kernel (a, b) = fiber a b) {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                      MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (constructor (left parameter) (right parameter))

                                                                                                                                                      The reducer of a primitive with two real operands on a fixed-skeleton fiber: once both operands are values, real skeletons draw from the primitive's kernel in the operands' coordinates and every other skeleton is stuck; otherwise the active operand is reduced under the site. reduce_eq is the primitive's unfolding lemma and draw_apply identifies the packaged kernel with the primitive's fiber.

                                                                                                                                                      Equations
                                                                                                                                                      • One or more equations did not get rendered due to their size.
                                                                                                                                                      Instances For
                                                                                                                                                        noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceUnaryDraw {α : Type u_1} [MeasurableSpace α] (site : Spec.Paper.DistributionAction × Spec.Paper.Op) (constructor : Spec.Paper.Expr → Spec.Paper.Expr) (skeletonConstructor : Spec.Paper.Skeleton → Spec.Paper.Skeleton) (skeleton_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).skeleton = skeletonConstructor expression.skeleton) (coordinates_rule : ∀ (expression : Spec.Paper.Expr), (constructor expression).realCoordinates = expression.realCoordinates) (fiber : ℝ → MeasureTheory.Measure ℝ) (reduce_eq : ∀ (body : Spec.Paper.Expr), Spec.Paper.reduce (constructor body) = if body.isValue = true then match Spec.Paper.realValue? body with | some value => Spec.Paper.Action.sample site (fiber value) Spec.Paper.Expr.real | none => Spec.Paper.Action.stuck else Spec.Paper.Action.wrap constructor (Spec.Paper.reduce body)) (draw : SFiniteKernel ℝ ℝ) (draw_apply : ∀ (value : ℝ), draw.kernel value = fiber value) {body : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (bodyReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (body parameter)) :
                                                                                                                                                        MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (constructor (body parameter))

                                                                                                                                                        reduceBinaryDraw for a primitive with one real operand.

                                                                                                                                                        Equations
                                                                                                                                                        • One or more equations did not get rendered due to their size.
                                                                                                                                                        Instances For
                                                                                                                                                          noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceUniform {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                          MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (Spec.Paper.Expr.uniform ℝ Spec.Paper.DistributionAction kind (left parameter) (right parameter))
                                                                                                                                                          Equations
                                                                                                                                                          • One or more equations did not get rendered due to their size.
                                                                                                                                                          Instances For
                                                                                                                                                            noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceGaussian {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                            MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (Spec.Paper.Expr.gaussian ℝ Spec.Paper.DistributionAction kind (left parameter) (right parameter))
                                                                                                                                                            Equations
                                                                                                                                                            • One or more equations did not get rendered due to their size.
                                                                                                                                                            Instances For
                                                                                                                                                              noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceBeta {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                              MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (Spec.Paper.Expr.beta ℝ Spec.Paper.DistributionAction kind (left parameter) (right parameter))
                                                                                                                                                              Equations
                                                                                                                                                              • One or more equations did not get rendered due to their size.
                                                                                                                                                              Instances For
                                                                                                                                                                noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceGamma {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {left right : α → Spec.Paper.Expr} (leftFamily : MeasurableFamily α left) (rightFamily : MeasurableFamily α right) (leftReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (left parameter)) (rightReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (right parameter)) :
                                                                                                                                                                MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (Spec.Paper.Expr.gamma ℝ Spec.Paper.DistributionAction kind (left parameter) (right parameter))
                                                                                                                                                                Equations
                                                                                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                                                                                Instances For
                                                                                                                                                                  noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reducePoisson {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {body : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (bodyReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (body parameter)) :
                                                                                                                                                                  Equations
                                                                                                                                                                  • One or more equations did not get rendered due to their size.
                                                                                                                                                                  Instances For
                                                                                                                                                                    noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceBernoulli {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {body : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (bodyReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (body parameter)) :
                                                                                                                                                                    Equations
                                                                                                                                                                    • One or more equations did not get rendered due to their size.
                                                                                                                                                                    Instances For
                                                                                                                                                                      noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceExponential {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {body : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (bodyReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (body parameter)) :
                                                                                                                                                                      Equations
                                                                                                                                                                      • One or more equations did not get rendered due to their size.
                                                                                                                                                                      Instances For
                                                                                                                                                                        noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceDiscrete {α : Type u_1} [MeasurableSpace α] (laws : PrimitiveLaws) (kind : Spec.Paper.DistributionAction) {body : α → Spec.Paper.Expr} (bodyFamily : MeasurableFamily α body) (bodyReduce : MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (body parameter)) :
                                                                                                                                                                        Equations
                                                                                                                                                                        • One or more equations did not get rendered due to their size.
                                                                                                                                                                        Instances For
                                                                                                                                                                          noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceFamilyAux (laws : PrimitiveLaws) (size : ℕ) {α : Type u} [MeasurableSpace α] {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) :
                                                                                                                                                                          sizeOf family.skeleton = size → MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (expression parameter)
                                                                                                                                                                          Equations
                                                                                                                                                                          • One or more equations did not get rendered due to their size.
                                                                                                                                                                          Instances For
                                                                                                                                                                            noncomputable def Determinize.Proof.Paper.MeasurableActionFamily.reduceFamily {α : Type u} [MeasurableSpace α] (laws : PrimitiveLaws) {expression : α → Spec.Paper.Expr} (family : MeasurableFamily α expression) :
                                                                                                                                                                            MeasurableActionFamily α fun (parameter : α) => Spec.Paper.reduce (expression parameter)
                                                                                                                                                                            Equations
                                                                                                                                                                            Instances For
                                                                                                                                                                              Equations
                                                                                                                                                                              Instances For
                                                                                                                                                                                theorem Determinize.Proof.Paper.MeasurableActionFamily.kernel_apply {α : Type u_1} [MeasurableSpace α] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (parameter : α) :
                                                                                                                                                                                family.kernel.kernel parameter = match action parameter with | Spec.Paper.Action.next successor => MeasureTheory.Measure.dirac successor | Spec.Paper.Action.sample _site fiber continuation => MeasureTheory.Measure.map continuation fiber | Spec.Paper.Action.stuck => 0
                                                                                                                                                                                Equations
                                                                                                                                                                                • One or more equations did not get rendered due to their size.
                                                                                                                                                                                Instances For
                                                                                                                                                                                  @[simp]
                                                                                                                                                                                  theorem Determinize.Proof.Paper.MeasurableActionFamily.toSkeletonFiber_coe_of_mem (skeleton : Spec.Paper.Skeleton) (expression : Spec.Paper.Expr) (member : expression ∈ SkeletonFiber skeleton) :
                                                                                                                                                                                  ↑(toSkeletonFiber skeleton expression) = expression
                                                                                                                                                                                  Equations
                                                                                                                                                                                  • One or more equations did not get rendered due to their size.
                                                                                                                                                                                  Instances For
                                                                                                                                                                                    theorem Determinize.Proof.Paper.MeasurableActionFamily.skeletonKernel_apply_of_mem (laws : PrimitiveLaws) (skeleton : Spec.Paper.Skeleton) (expression : Spec.Paper.Expr) (member : expression ∈ SkeletonFiber skeleton) :
                                                                                                                                                                                    (skeletonKernel laws skeleton) expression = Spec.Paper.stepMeasure expression
                                                                                                                                                                                    theorem Determinize.Proof.Paper.MeasurableActionFamily.skeletonKernel_apply_of_not_mem (laws : PrimitiveLaws) (skeleton : Spec.Paper.Skeleton) (expression : Spec.Paper.Expr) (notMember : expression ∉ SkeletonFiber skeleton) :
                                                                                                                                                                                    (skeletonKernel laws skeleton) expression = 0
                                                                                                                                                                                    theorem Determinize.Proof.Paper.MeasurableActionFamily.sample_continuation_measurable_of_family {site : Spec.Paper.DistributionAction × Spec.Paper.Op} {α : Type u_1} [MeasurableSpace α] {action : α → Spec.Paper.Action} (family : MeasurableActionFamily α action) (parameter : α) {fiber : MeasureTheory.Measure ℝ} {continuation : ℝ → Spec.Paper.Expr} (equality : action parameter = Spec.Paper.Action.sample site fiber continuation) :
                                                                                                                                                                                    Measurable continuation
                                                                                                                                                                                    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
                                                                                                                                                                                        theorem Determinize.Proof.Paper.MeasurableActionFamily.exactOutputKernel_apply (stepKernel : StepKernel) (depth : ℕ) (expression : Spec.Paper.Expr) :
                                                                                                                                                                                        (exactOutputKernel stepKernel depth) expression = exactOutputMeasure stepKernel depth expression
                                                                                                                                                                                        Equations
                                                                                                                                                                                        • One or more equations did not get rendered due to their size.
                                                                                                                                                                                        Instances For
                                                                                                                                                                                          @[simp]
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.nStepKernelPack_succ_kernel (stepKernel : StepKernel) (fuel : ℕ) :
                                                                                                                                                                                          (nStepKernelPack stepKernel (fuel + 1)).kernel = stepKernel.kernel.comp (nStepKernelPack stepKernel fuel).kernel
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.nStepKernelPack_apply (stepKernel : StepKernel) (fuel : ℕ) (expression : Spec.Paper.Expr) :
                                                                                                                                                                                          (nStepKernelPack stepKernel fuel).kernel expression = nStepMeasure stepKernel fuel expression
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.cumulativeOutputMeasure_eq_kernel (stepKernel : StepKernel) (fuel : ℕ) (program : Spec.Paper.Expr) :
                                                                                                                                                                                          cumulativeOutputMeasure stepKernel fuel program = ((exactOutputKernel stepKernel 0).comp (nStepKernelPack stepKernel fuel).kernel) program
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.stepKernel_eq_dirac_of_value (stepKernel : StepKernel) (expression : Spec.Paper.Expr) (isValue : expression.isValue = true) :
                                                                                                                                                                                          stepKernel.kernel expression = MeasureTheory.Measure.dirac expression
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.nStepKernel_commutes (stepKernel : StepKernel) (fuel : ℕ) :
                                                                                                                                                                                          stepKernel.kernel.comp (nStepKernelPack stepKernel fuel).kernel = (nStepKernelPack stepKernel fuel).kernel.comp stepKernel.kernel
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.cumulativeKernel_succ (stepKernel : StepKernel) (fuel : ℕ) :
                                                                                                                                                                                          (exactOutputKernel stepKernel 0).comp (nStepKernelPack stepKernel (fuel + 1)).kernel = ((exactOutputKernel stepKernel 0).comp (nStepKernelPack stepKernel fuel).kernel).comp stepKernel.kernel
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.exactOutputKernel_succ_apply_of_not_value (stepKernel : StepKernel) (depth : ℕ) (expression : Spec.Paper.Expr) (notValue : expression.isValue ≠ true) :
                                                                                                                                                                                          (exactOutputKernel stepKernel (depth + 1)) expression = ((exactOutputKernel stepKernel depth).comp stepKernel.kernel) expression
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.exactOutputKernel_succ_apply_of_value (stepKernel : StepKernel) (depth : ℕ) (expression : Spec.Paper.Expr) (isValue : expression.isValue = true) :
                                                                                                                                                                                          (exactOutputKernel stepKernel (depth + 1)) expression = 0
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.exactOutputKernel_succ_comp_step (stepKernel : StepKernel) (depth : ℕ) :
                                                                                                                                                                                          (exactOutputKernel stepKernel (depth + 1)).comp stepKernel.kernel = exactOutputKernel stepKernel (depth + 2)
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.finsetSum_comp_kernel {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Type u_4} [MeasurableSpace α] [MeasurableSpace β] [MeasurableSpace γ] (indices : Finset ι) (kernels : ι → ProbabilityTheory.Kernel β γ) (kernel : ProbabilityTheory.Kernel α β) :
                                                                                                                                                                                          (∑ index ∈ indices, kernels index).comp kernel = ∑ index ∈ indices, (kernels index).comp kernel
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.cumulativeKernel_eq_finsetSum (stepKernel : StepKernel) (fuel : ℕ) :
                                                                                                                                                                                          (exactOutputKernel stepKernel 0).comp (nStepKernelPack stepKernel fuel).kernel = ∑ depth ∈ Finset.range (fuel + 1), exactOutputKernel stepKernel depth
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.cumulativeOutputMeasure_eq_finsetSum (stepKernel : StepKernel) (fuel : ℕ) (program : Spec.Paper.Expr) :
                                                                                                                                                                                          cumulativeOutputMeasure stepKernel fuel program = ∑ depth ∈ Finset.range (fuel + 1), exactOutputMeasure stepKernel depth program
                                                                                                                                                                                          theorem Determinize.Proof.Paper.MeasurableActionFamily.measure_sum_eq_iSup_range_succ {α : Type u_1} [MeasurableSpace α] (measures : ℕ → MeasureTheory.Measure α) :
                                                                                                                                                                                          MeasureTheory.Measure.sum measures = ⨆ (fuel : ℕ), ∑ depth ∈ Finset.range (fuel + 1), measures depth