BanditRLProof.ConditionalRewardLawSource

No declaration docstring is present; use the chapter context and exact statement below.

private theorem eventually_ae_trim_of_eq_measurableSpace {Omega : Type u} {m0 m1 m2 : MeasurableSpace Omega} {mu : @MeasureTheory.Measure Omega m0} (h : m1 = m2) (hm1 : m1 <= m0) {hm2 : m2 <= m0} {p : Omega -> Prop} (hp : Filter.Eventually p (ae (mu.trim hm2))) : Filter.Eventually p (ae (mu.trim hm1))

The shifted policy-generated action trace whose state reads the finite reward history of the ambient reward trace.

def generatedActionFromRewardHistory {Omega : Type u} {State : Type w} {Action : Type x} [MeasurableSpace State] [MeasurableSpace Action] (policy : Nat -> Policy.MeasurablePolicy State Action) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) : Omega -> ActionTrace Action

Timewise measurable reward traces plus measurable reward-history state extractors make the generated reward-history action trace timewise measurable.

theorem generatedActionFromRewardHistory_measurable {Omega : Type u} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace State] [MeasurableSpace Action] (policy : Nat -> Policy.MeasurablePolicy State Action) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (hstate : forall n : Nat, Measurable (state n)) (t : Nat) : Measurable (fun omega : Omega => generatedActionFromRewardHistory policy state defaultAction reward omega t)

For actions generated deterministically from finite reward histories, the finite pair prefix and the finite reward prefix generate the same measurable space. The nontrivial inclusion is that every generated action coordinate through time `n` is measurable from the reward prefix through time `n`; the reverse inclusion is the measurable reward projection from pair histories.

theorem comap_finitePairHistoryOfTrace_generatedActionFromRewardHistory_eq_comap_finiteRewardHistoryOfTrace {Omega : Type u} {State : Type w} {Action : Type x} [MeasurableSpace State] [MeasurableSpace Action] (policy : Nat -> Policy.MeasurablePolicy State Action) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (n : Nat) : ((inferInstance : MeasurableSpace ((j : Finset.Iic n) -> Prod Action Rat)).comap (fun omega : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) n)) = ((inferInstance : MeasurableSpace ((j : Finset.Iic n) -> Rat)).comap (fun omega : Omega => History.finiteRewardHistoryOfTrace (reward omega) n))

The shifted generated action/reward history filtration is therefore exactly the comap of the finite reward prefix. This removes the generated action coordinates from the conditioning surface without changing the filtration.

theorem historyFiltrationSucc_generatedActionFromRewardHistory_eq_comap_finiteRewardHistoryOfTrace {Omega : Type u} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (policy : Nat -> Policy.MeasurablePolicy State Action) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (n : Nat) : ((History.historyFiltrationSucc (mOmega

The generated action at time `i + 1` is measurable with respect to the generated history filtration at time `i`. This is the predictable-action surface needed to mask successor rewards by a fixed arm before applying conditional concentration.

theorem generatedActionFromRewardHistory_succ_measurable_historyFiltrationSucc {Omega : Type u} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (policy : Nat -> Policy.MeasurablePolicy State Action) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (i : Nat) : @Measurable Omega Action ((History.historyFiltrationSucc (mOmega

Canonical reward-only `trajMeasure` selected-reward law on the generated finite-pair conditioning surface. The underlying trajectory contains only reward coordinates. The previous comap equality shows that adjoining the deterministically generated policy actions to each finite prefix does not change the conditioning measurable space, so the canonical reward-only law can be stated directly in the same finite-pair notation used by the ambient source contracts.

theorem historyStepKernelFamily_selectedMeasure_condExpKernel_map_trajMeasure_generatedActionFromRewardHistory_finitePairHistoryOfTrace {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] (mu0 : Measure Rat) [MeasureTheory.IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (n : Nat) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

Trim-a.e. canonical reward-only `trajMeasure` selected-reward law on the generated finite-pair conditioning surface. The trim-aware canonical reward law is first proved on the finite reward-prefix comap. Deterministically generated policy actions do not enlarge that comap, so the same law holds on the finite pair-prefix sigma-algebra used by the generated selected-reward source contract.

theorem historyStepKernelFamily_selectedMeasure_condExpKernel_map_trajMeasure_generatedActionFromRewardHistory_finitePairHistoryOfTrace_trim {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] (mu0 : Measure Rat) [MeasureTheory.IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (n : Nat) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

Explicit source contract for the remaining generated-history `partialTraj`/`condExpKernel` pair-law gap. The field is exactly the full finite pair-trace law used by the downstream `partialTraj` consumers, specialized to the definitional generated action trace `generatedActionFromRewardHistory`. It does not prove that law from a global trajectory measure; it only gives future disintegration work a named target.

structure GeneratedActionPartialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

Expose the exact generated-history finite-pair `partialTraj` law stored in a `GeneratedActionPartialTrajectoryPairLawSource`. This is a source-projection wrapper for `COND-EXPECT-REWARD-PARTIALTRAJ-CONDEXPKERNEL-PAIR-LAW-CARD`: it does not construct the law from a global trajectory/disintegration argument, but it gives downstream consumers a named theorem with the card's full Lean-facing target.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the generated-history finite-pair `partialTraj` source from the narrower frozen-prefix extension-map law. This packages the existing extension-to-full-trace adapter at the source layer: future disintegration work may prove only the conditional law of extending the already frozen `i`-prefix by the random successor pair, and this constructor turns that into the full `GeneratedActionPartialTrajectoryPairLawSource`.

def generatedActionPartialTrajectoryPairLawSource_of_partialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the generated-history finite-pair `partialTraj` source from a canonical history-step next-pair law. This lowers the future source obligation once more: a caller may identify the generated conditional law of the next `(action, reward)` pair with `RewardKernel.actionRewardHistoryStepKernelFamily`; the existing next-pair to extension-map adapter and the source constructor above then provide the full finite-pair `partialTraj` source.

def generatedActionPartialTrajectoryPairLawSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the generated-history finite-pair `partialTraj` source from split next-pair laws. This is the source-level version of the split next-pair route: a caller may separately supply the generated action conditional a.e. law and the policy-selected reward-coordinate map law, and the local split-law builder combines them into the history-step pair law consumed by `generatedActionPartialTrajectoryPairLawSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq`. It still does not prove either split law from an ambient trajectory disintegration argument.

def generatedActionPartialTrajectoryPairLawSource_of_action_ae_eq_policy_reward_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_action_ae_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => Filter.EventuallyEq (ae (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the generated-history finite-pair `partialTraj` source from only the policy-selected reward-coordinate law. For `generatedActionFromRewardHistory`, the action side of the split next-pair route is supplied by the shifted generated-trace action-freezing theorem. This constructor therefore leaves only the selected reward-coordinate `condExpKernel` map law as the explicit law input before reusing `generatedActionPartialTrajectoryPairLawSource_of_action_ae_eq_policy_reward_map_eq`. It still does not prove that reward-coordinate law from an ambient trajectory disintegration argument.

def generatedActionPartialTrajectoryPairLawSource_of_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a policy-selected reward-coordinate law stated at the generated reward history surface and expose the full generated finite-pair `partialTraj` law directly. This is the theorem-shaped wrapper around `generatedActionPartialTrajectoryPairLawSource_of_reward_map_eq_selected_policy`. It keeps the same reward-history selected-law contract and only projects the stored full finite-pair law from the generated partial-trajectory source; it does not prove the selected reward-coordinate law from an ambient trajectory construction.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the generated-history finite-pair `partialTraj` source from an actual-action reward-coordinate law stated directly for `generatedActionFromRewardHistory`. This removes the explicit action trace and generated-trace equality required by the generic generated-action theorem. The remaining law input is still the actual successor-action reward-coordinate `condExpKernel` map law; this wrapper does not prove that law from a global trajectory/disintegration argument.

def generatedActionPartialTrajectoryPairLawSource_of_reward_map_eq_actual_action {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume an actual-action reward-coordinate law stated at the generated reward history surface and expose the full generated finite-pair `partialTraj` law directly. This is the theorem-shaped wrapper around `generatedActionPartialTrajectoryPairLawSource_of_reward_map_eq_actual_action`. It keeps the same reward-history actual-action law contract and only projects the stored full finite-pair law from the generated partial-trajectory source.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_reward_map_eq_actual_action {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the generated-history finite-pair `partialTraj` source from a policy-selected reward-coordinate law stated at the generated finite pair prefix. Future disintegration work often naturally phrases the selected reward law with `History.finitePairHistoryOfTrace`. This adapter rewrites that prefix through `History.pairHistoryRewardProjection_finitePairHistoryOfTrace` and reuses the existing reward-history source constructor. It still assumes the ambient reward-coordinate law; it does not prove it.

def generatedActionPartialTrajectoryPairLawSource_of_finitePairHistory_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Explicit source contract for the generated ambient selected-reward law stated at the generated finite pair prefix. This is a narrower source surface than `GeneratedActionPartialTrajectoryPairLawSource`: it packages only the reward-coordinate `condExpKernel.map` law. The generated action side is later supplied by the definitional shifted-policy trace, so this source can be converted into the full finite-pair `partialTraj` law source without assuming a separate action law.

structure GeneratedActionSelectedRewardFinitePairHistoryLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

Build the selected-reward finite-pair-history source from the same `condExpKernel.map` law stated with the conditioning sigma-algebra as the comap of `History.finitePairHistoryOfTrace`. This is the source-layer consumer for `History.historyFiltrationSucc_eq_comap_finitePairHistoryOfTrace`: future trajectory/disintegration work can target the Mathlib-style finite-prefix comap conditioning surface and then enter the existing generated-history source route without restating the law at `History.historyFiltrationSucc`.

def generatedActionSelectedRewardFinitePairHistoryLawSource_of_comap_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the selected-reward finite-pair-history source from the same selected-reward law, but with the a.e. filter stated directly on the comap finite-pair-prefix sigma-algebra. This is the Mathlib-facing source entry: a future disintegration proof can state the law entirely at the finite-prefix comap conditioning surface. The adapter only rewrites that surface through `History.historyFiltrationSucc_eq_comap_finitePairHistoryOfTrace`; it still consumes, rather than proves, the selected-reward law.

def generatedActionSelectedRewardFinitePairHistoryLawSource_of_comap_trim_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by rw [← History.historyFiltrationSucc_eq_comap_finitePairHistoryOfTrace (mOmega

Construct the generated selected-reward finite-pair-history source for the canonical reward-only `trajMeasure`. Unlike the generic source adapters above, this constructor discharges the selected-reward law from Mathlib's `Kernel.trajMeasure` conditional-distribution result, routed through the trim-aware countable-target bridge. The remaining action assumptions are exactly those needed by the generated finite-pair filtration surface.

def historyStepKernelFamily_generatedActionSelectedRewardFinitePairHistoryLawSource_trajMeasure {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu0 : Measure Rat) [MeasureTheory.IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

Construct the generated selected-reward source on an ambient probability space whose complete reward trace is identically distributed with the canonical reward-only `trajMeasure`. The global `IdentDistrib` assumption is converted to the finite-prefix selected-reward law by the disintegration transport theorem. Deterministically generated actions do not enlarge the reward-prefix sigma-algebra, so the law then enters the existing finite-pair source surface without an ambient `condDistrib` or `condExpKernel.map` assumption.

def historyStepKernelFamily_generatedActionSelectedRewardFinitePairHistoryLawSource_of_identDistrib_trajMeasure {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] [Nonempty Omega] (mu : Measure Omega) [IsFiniteMeasure mu] (mu0 : Measure Rat) [IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (hident : ProbabilityTheory.IdentDistrib reward id mu (ProbabilityTheory.Kernel.trajMeasure (X

Construct the ambient generated selected-reward source from the recursive reward-process contract: the initial reward has law `mu0`, and each successor reward has the configured history-step conditional distribution. The recursive assumptions first identify the complete reward trace with the canonical `trajMeasure`; the existing distribution-transport constructor then supplies the selected-reward finite-pair-history law.

def historyStepKernelFamily_generatedActionSelectedRewardFinitePairHistoryLawSource_of_condDistrib {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] [Nonempty Omega] (mu : Measure Omega) [IsFiniteMeasure mu] (mu0 : Measure Rat) [IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (hzero : Measure.map (fun omega : Omega => reward omega 0) mu = mu0) (hcond : forall i : Nat, Filter.EventuallyEq (ae (mu.map (fun omega : Omega => Preorder.frestrictLe i (reward omega)))) (ProbabilityTheory.condDistrib (fun omega : Omega => reward omega (i + 1)) (fun omega : Omega => Preorder.frestrictLe i (reward omega)) mu) (RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate i)) : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward

Convert the generated ambient selected-reward finite-pair-history source into the full generated finite-pair `partialTraj` source. This uses the existing generated-action split route; it still consumes the selected-reward source field rather than proving it.

def generatedActionPartialTrajectoryPairLawSource_of_selectedRewardFinitePairHistoryLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward

Construct the full ambient generated finite-pair `partialTraj` source from an initial reward law and successor conditional-distribution recursion. The selected-reward coordinate is obtained from the complete reward-trace law; the action coordinate is supplied by the existing deterministic generated policy split.

def historyStepKernelFamily_generatedActionPartialTrajectoryPairLawSource_of_condDistrib {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] [Nonempty Omega] (mu : Measure Omega) [IsFiniteMeasure mu] (mu0 : Measure Rat) [IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (hzero : Measure.map (fun omega : Omega => reward omega 0) mu = mu0) (hcond : forall i : Nat, Filter.EventuallyEq (ae (mu.map (fun omega : Omega => Preorder.frestrictLe i (reward omega)))) (ProbabilityTheory.condDistrib (fun omega : Omega => reward omega (i + 1)) (fun omega : Omega => Preorder.frestrictLe i (reward omega)) mu) (RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate i)) : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward

Construct the full generated finite-pair `partialTraj` source for the canonical reward-only `trajMeasure`. The selected-reward law is supplied by the canonical trim-aware source, while the action coordinate is the deterministic generated policy action. Thus this constructor reaches the full pair-history source without assuming an ambient selected-reward or random-pair law.

def historyStepKernelFamily_generatedActionPartialTrajectoryPairLawSource_trajMeasure {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu0 : Measure Rat) [MeasureTheory.IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

Canonical reward-only `trajMeasure` full generated finite-pair `partialTraj` law. This is the theorem-shaped endpoint of the canonical selected-reward route: the next finite pair prefix under `condExpKernel`, conditioned on the generated finite pair history, has the configured one-step partial-trajectory kernel. No ambient selected-reward or random-pair source assumption remains.

theorem historyStepKernelFamily_actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_trajMeasure {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu0 : Measure Rat) [MeasureTheory.IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (i : Nat) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

Canonical reward-only `trajMeasure` successor centered reward has conditional expectation zero under the generated finite-pair history. The canonical full `partialTraj` law discharges the probability-law identification. Ambient integrability of the centered successor reward remains an explicit regularity contract; this avoids imposing pointwise bounds on every trace in `Nat -> Rat`, including null trajectories outside the generated law's support.

theorem historyStepKernelFamily_centeredReward_succ_condExp_eq_zero_trajMeasure {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu0 : Measure Rat) [MeasureTheory.IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (i : Nat) (h_integrable : Integrable (fun trajectory : RewardTrace Rat => (((trajectory (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace trajectory i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace trajectory i))) : Rat) : Real))) (ProbabilityTheory.Kernel.trajMeasure (X

Canonical reward-only `trajMeasure` successor centered reward has a conditional sub-Gaussian MGF under the generated finite-pair history. The canonical full `partialTraj` law supplies the reward-coordinate conditional law. Measurability follows from the measurable mean surface, and the integrated target-law transfer derives exponential integrability from the selected kernel MGF bounds. A deterministic bound over finite reward histories supplies the trim-a.e. variance domination.

theorem historyStepKernelFamily_centeredReward_succ_hasCondSubgaussianMGF_trajMeasure {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu0 : Measure Rat) [MeasureTheory.IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction : Action) (i : Nat) (c : NNReal) (hvariance : forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= c) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

A generated full finite-pair `partialTraj` source directly yields the successor centered-reward conditional MGF witness. Unlike the older bounded-source adapters, exponential integrability is derived by the integrated target-law transfer from `CenteredRewardKernelLaw`; only measurability of the mean surface and a deterministic selected-history variance bound remain analytic side conditions.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : Measure Omega) [IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (c : NNReal) (hvariance : forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Recursive ambient reward-process laws directly yield the successor centered reward conditional MGF witness under generated finite-pair history. The initial marginal and successor `condDistrib` recursion construct the full `partialTraj` source; the source-level integrated transfer then consumes only a measurable mean, centered kernel law, and selected-history variance bound.

theorem historyStepKernelFamily_centeredReward_succ_hasCondSubgaussianMGF_of_condDistrib {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] [Nonempty Omega] (mu : Measure Omega) [IsFiniteMeasure mu] (mu0 : Measure Rat) [IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (hzero : Measure.map (fun omega : Omega => reward omega 0) mu = mu0) (hcond : forall i : Nat, Filter.EventuallyEq (ae (mu.map (fun omega : Omega => Preorder.frestrictLe i (reward omega)))) (ProbabilityTheory.condDistrib (fun omega : Omega => reward omega (i + 1)) (fun omega : Omega => Preorder.frestrictLe i (reward omega)) mu) (RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate i)) (i : Nat) (c : NNReal) (hvariance : forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

The zero-initialized successor centered-reward process is strongly adapted to the generated shifted history filtration. Index zero is reserved for the deterministic value zero. At index `i + 1` the process uses reward `i + 1` centered by the context/action mean selected from the finite reward history through `i`. This indexing matches Mathlib's conditional sub-Gaussian finite-sum tail API.

theorem generatedActionFromRewardHistory_centeredRewardSuccProcess_stronglyAdapted {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) : let action := generatedActionFromRewardHistory policy state defaultAction reward let haction := generatedActionFromRewardHistory_measurable (policy

Masking the successor centered-reward process by selection of a fixed arm preserves strong adaptedness. The arm event at successor index `i + 1` is already measurable at filtration level `i`; monotonicity exposes it at level `i + 1`, where the centered reward it masks is measurable.

theorem generatedActionFromRewardHistory_armMaskedCenteredRewardSuccProcess_stronglyAdapted {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction arm : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) : let action := generatedActionFromRewardHistory policy state defaultAction reward let haction := generatedActionFromRewardHistory_measurable (policy

Ambient Azuma-Hoeffding bound for a recursively specified generated reward process. The initial marginal identifies the ambient measure as a probability measure. Successor `condDistrib` laws construct the full `partialTraj` source and hence all conditional MGF witnesses, while generated-history measurability supplies strong adaptedness. The sum contains the zero slot followed by centered rewards at indices `1, ..., n - 1`.

theorem historyStepKernelFamily_centeredRewardSuccProcess_sum_tail_ennreal_of_condDistrib {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] [Nonempty Omega] (mu : Measure Omega) [IsFiniteMeasure mu] (mu0 : Measure Rat) [IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (hzeroLaw : Measure.map (fun omega : Omega => reward omega 0) mu = mu0) (hcondLaw : forall i : Nat, Filter.EventuallyEq (ae (mu.map (fun omega : Omega => Preorder.frestrictLe i (reward omega)))) (ProbabilityTheory.condDistrib (fun omega : Omega => reward omega (i + 1)) (fun omega : Omega => Preorder.frestrictLe i (reward omega)) mu) (RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate i)) (varianceCeiling : Nat -> NNReal) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (n : Nat) {eps : Real} (heps : 0 <= eps) : let Y : Nat -> Omega -> Real := fun t omega => match t with | 0 => 0 | i + 1 => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)) let cY : Nat -> NNReal := fun t => match t with | 0 => 0 | i + 1 => varianceCeiling i mu {omega | eps <= (Finset.range n).sum (fun t => Y t omega)} <= ENNReal.ofReal (Real.exp (-eps ^ 2 / (2 * (((Finset.range n).sum cY : NNReal) : Real))))

Canonical reward-only `trajMeasure` Azuma-Hoeffding bound for the finite sum of successor policy-centered rewards. The zero initial term aligns the successor conditional-MGF witnesses with Mathlib's `Finset.range n` tail theorem. Thus the random sum contains centered rewards at indices `1, ..., n - 1`, and its proxy sum contains the corresponding history-selected deterministic ceilings.

theorem historyStepKernelFamily_centeredRewardSuccProcess_sum_tail_ennreal_trajMeasure {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu0 : Measure Rat) [IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction : Action) (varianceCeiling : Nat -> NNReal) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (n : Nat) {eps : Real} (heps : 0 <= eps) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

Canonical reward-only `trajMeasure` Azuma-Hoeffding bound for the empirical average of `m` successor policy-centered rewards. The `Finset.range (m + 1)` sum retains the deterministic zero slot required by the conditional-MGF tail API, so its remaining terms are exactly rewards `1, ..., m`. The strict positivity of `m` is the explicit denominator regularity contract used to rewrite the average-tail event as a sum-tail event with threshold `m * eps`.

theorem historyStepKernelFamily_centeredRewardSuccProcess_average_tail_ennreal_trajMeasure {Context : Type v} {State : Type w} {Action : Type x} [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu0 : Measure Rat) [IsProbabilityMeasure mu0] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (defaultAction : Action) (varianceCeiling : Nat -> NNReal) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (m : Nat) (hm : 0 < m) {eps : Real} (heps : 0 <= eps) : let stepKernel := RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate let trajMeasure := ProbabilityTheory.Kernel.trajMeasure (X

Build the full generated finite-pair `partialTraj` source directly from a selected-reward law stated at the finite pair-prefix comap conditioning sigma-algebra. This composes the comap-to-selected-source adapter with the existing selected-source-to-`partialTraj` route, so future disintegration work can target the Mathlib-style comap conditioning surface and immediately obtain the full generated finite-pair source.

def generatedActionPartialTrajectoryPairLawSource_of_comap_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the full generated finite-pair `partialTraj` source directly from a selected-reward law stated with both the conditioning sigma-algebra and the trim filter at the finite pair-prefix comap surface. This is the direct partialTraj entry for Mathlib-facing disintegration work: it composes the comap-trim selected-source adapter with the existing selected-source-to-`partialTraj` route, and still consumes rather than proves the selected-reward law.

def generatedActionPartialTrajectoryPairLawSource_of_comap_trim_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Consume the generated selected-reward finite-pair-history source at the exact full finite-pair `partialTraj` law surface. This is the Lean-facing theorem-card target specialized to the generated reward-history action trace. It still consumes the selected-reward source field; the ambient disintegration proof of that field remains separate.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_selectedRewardFinitePairHistoryLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a selected-reward law stated at the finite pair-prefix comap conditioning surface and expose the full generated finite-pair `partialTraj` law directly. This is a theorem-shaped wrapper around `generatedActionSelectedRewardFinitePairHistoryLawSource_of_comap_reward_map_eq_selected_policy` and `actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_selectedRewardFinitePairHistoryLawSource`. It still consumes the selected-reward conditional law; it does not prove that law from an ambient trajectory/disintegration construction.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_comap_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a selected-reward law stated entirely at the finite pair-prefix comap conditioning surface, including the `trim` a.e. filter, and expose the full generated finite-pair `partialTraj` law directly. This is the theorem-shaped companion to `generatedActionPartialTrajectoryPairLawSource_of_comap_trim_reward_map_eq_selected_policy`. It still consumes the selected-reward conditional law; it does not prove that law from an ambient trajectory/disintegration construction.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_comap_trim_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

A generated-policy conditional next-pair law source. The action trace is generated by the shifted policy from the reward-history state, and at each step the conditional law of the random next `(action, reward)` pair is the selected reward law pushed through `Prod.mk` at the actual next action. This is a contract surface: it packages the remaining law input, but does not prove it from a global trajectory measure.

structure GeneratedActionRandomPairMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

Generated-policy conditional reward-coordinate law source. This is weaker than `GeneratedActionRandomPairMapSource`: it assumes only the conditional law of the next reward coordinate under the actual next action, not the full conditional law of the random `(action, reward)` pair. The action trace is still required to be the shifted policy-generated trace over finite reward histories.

structure GeneratedActionActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

Definitional generated-policy conditional reward-coordinate law source. This is the definitional-action version of `GeneratedActionActualRewardMapSource`: the action trace is fixed to `generatedActionFromRewardHistory`, and its timewise measurability is derived from measurable reward-history state extractors plus timewise reward measurability. The reward-coordinate conditional law remains a source contract.

structure GeneratedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

Build the definitional actual reward-coordinate source from the same reward-coordinate law stated at the policy-selected action. For `generatedActionFromRewardHistory`, the successor coordinate `i + 1` is definitionally `(policy i).action` applied to the finite reward-history state. This adapter lets callers use that policy-facing law surface without first rewriting it to the generated successor action.

def generatedActionDefinitionalActualRewardMapSource_of_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Convert a definitional actual-action reward-coordinate source into the generated selected-reward finite-pair-history source. For `generatedActionFromRewardHistory`, the actual successor action is definitionally the policy-selected action at the finite reward history, and `History.pairHistoryRewardProjection_finitePairHistoryOfTrace` removes the irrelevant action coordinates from the generated finite pair prefix. This adapter exposes the same reward-coordinate law at the finite-pair-history source surface.

def generatedActionSelectedRewardFinitePairHistoryLawSource_of_definitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward where

Build the definitional actual reward-coordinate source from a full finite-pair `partialTraj` law over the generated action trace. This is a packaging step for the ambient trajectory-identification route: once callers identify the conditional kernel of the generated finite pair trace with the one-step action/reward `partialTraj` kernel, the compiled projection route supplies the reward-coordinate law required by `GeneratedActionDefinitionalActualRewardMapSource`.

def generatedActionDefinitionalActualRewardMapSource_of_partialTrajectoryKernel_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Project a generated-history `partialTraj` pair-law source to the definitional actual-action reward-coordinate source. The `partialTraj` source already packages context/state measurability and the full finite-pair trace law. This wrapper exposes the weaker reward-coordinate source interface needed by mean-zero and conditional-MGF consumers without asking callers to unpack the source fields manually.

def generatedActionDefinitionalActualRewardMapSource_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward

Project a generated-history `partialTraj` pair-law source to the selected reward-coordinate source stated at the generated finite-pair-history surface. This is the source-level reverse of the selected-reward-to-`partialTraj` constructor: it first projects the full pair law to the definitional actual-action reward law, then rewrites the generated successor action and finite-pair reward projection into the policy-selected reward-law source. It does not construct the full pair law or transport canonical `trajMeasure` to an ambient process.

def generatedActionSelectedRewardFinitePairHistoryLawSource_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward

Build the definitional actual reward-coordinate source from the frozen-prefix extension-map form of the generated finite-pair `partialTraj` law. Compared with `generatedActionDefinitionalActualRewardMapSource_of_partialTrajectoryKernel_map_eq`, the input law only identifies the conditional kernel after appending the random successor pair to the already frozen `i`-prefix. The compiled extension-to-full adapter then supplies the full finite-pair trace law needed by the source constructor.

def generatedActionDefinitionalActualRewardMapSource_of_partialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the definitional actual reward-coordinate source directly from the canonical history-step next-pair law. This is the source-packaging version of the direct history-step reward-map adapter: once callers identify the generated conditional next-pair law with `RewardKernel.actionRewardHistoryStepKernelFamily`, projection through `Prod.snd` supplies the reward-coordinate law stored by `GeneratedActionDefinitionalActualRewardMapSource`.

def generatedActionDefinitionalActualRewardMapSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Definitional generated-policy conditional next-pair law source. Here the action trace is not a separate parameter with an equality witness: it is definitionally `generatedActionFromRewardHistory`. Timewise action measurability is derived from measurable state extractors and reward traces. The random next-pair law remains a source contract.

structure GeneratedActionRandomPairDefinitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

Build the definitional generated-policy random next-pair source from a full finite-pair-trace `partialTraj` law. This is a source-side adapter for the remaining trajectory-law gap: once a future ambient construction identifies the conditional law of the whole `i + 1` finite pair trace with the Mathlib `partialTraj` kernel, the existing `partialTraj` next-coordinate projection and one-step action/reward kernel shape provide the `GeneratedActionRandomPairDefinitionalMapSource` field.

def generatedActionRandomPairDefinitionalMapSource_of_actionRewardPartialTrajectoryKernel_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source into the existing definitional random next-pair source interface.

def generatedActionRandomPairDefinitionalMapSource_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward

Build the definitional generated-policy random next-pair source from the frozen-prefix extension-map form of the `partialTraj` law. This is one step narrower than `generatedActionRandomPairDefinitionalMapSource_of_actionRewardPartialTrajectoryKernel_map_eq`: the input law only needs to identify the conditional kernel after appending the random next pair to the already frozen prefix. The existing extension-to-full adapter then supplies the full finite-pair-trace law needed by the source constructor above.

def generatedActionRandomPairDefinitionalMapSource_of_actionRewardPartialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the definitional generated-policy random next-pair source directly from the canonical history-step next-pair law. This is the source-packaging version of the history-step consumer: once the conditional kernel is identified with `RewardKernel.actionRewardHistoryStepKernelFamily`, the kernel's one-step shape supplies the random-pair map law stored by `GeneratedActionRandomPairDefinitionalMapSource`.

def generatedActionRandomPairDefinitionalMapSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the definitional generated-policy random next-pair source from a policy-selected reward-coordinate law. The policy-facing reward law is first rewritten to the generated successor action. The existing generated-action reward-map route then supplies the frozen-prefix extension-map `partialTraj` law consumed by the bare `GeneratedActionRandomPairDefinitionalMapSource` constructor.

def generatedActionRandomPairDefinitionalMapSource_of_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Convert the definitional generated-action source into the existing generated random-pair map source.

def generatedActionRandomPairMapSource_of_definitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Build the explicit generated-action random next-pair source directly from the canonical history-step next-pair law. This is the explicit-action counterpart of `generatedActionRandomPairDefinitionalMapSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq`: callers keep an `action` trace and provide the shifted generated-action identity once. The one-step shape of `RewardKernel.actionRewardHistoryStepKernelFamily` then supplies the packaged random-pair map law.

def generatedActionRandomPairMapSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Build the explicit generated-action random next-pair source from a full finite-pair `partialTraj` law. The full trace law is first projected to the canonical history-step next-pair law; the history-step source constructor then packages the random-pair law.

def generatedActionRandomPairMapSource_of_actionRewardPartialTrajectoryKernel_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Build the explicit generated-action random next-pair source from the frozen-prefix extension-map form of the `partialTraj` law. This narrows the source construction surface to the deterministic old-prefix extension map, then reuses the compiled extension-to-full-trace adapter.

def generatedActionRandomPairMapSource_of_actionRewardPartialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (action omega) (reward omega) i) (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Convert the definitional generated-action reward-coordinate source into the existing explicit-action actual reward-coordinate source.

def generatedActionActualRewardMapSource_of_definitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionActualRewardMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Project a generated-history `partialTraj` pair-law source to the explicit generated-action actual reward-coordinate source. This is the explicit-source companion to `generatedActionDefinitionalActualRewardMapSource_of_partialTrajectoryPairLawSource`. It keeps the action trace at `generatedActionFromRewardHistory` and derives its measurability from the packaged state measurability.

def generatedActionActualRewardMapSource_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionActualRewardMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Build the explicit generated-action actual reward-coordinate source from a full finite-pair `partialTraj` law. This is the non-definitional counterpart of `generatedActionDefinitionalActualRewardMapSource_of_partialTrajectoryKernel_map_eq`: callers keep their explicit `action` trace and supply the shifted generated trace equality once, then the compiled full-trace projection supplies the reward-coordinate law stored in `GeneratedActionActualRewardMapSource`.

def generatedActionActualRewardMapSource_of_partialTrajectoryKernel_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Build the explicit generated-action actual reward-coordinate source from the frozen-prefix extension-map form of the `partialTraj` law. The input law is narrower than the full finite-pair trace law: it only pushes forward by appending the random successor pair to the already frozen prefix. The existing extension-map reward-coordinate adapter discharges that projection before packaging the source.

def generatedActionActualRewardMapSource_of_partialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (action omega) (reward omega) i) (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Build the explicit generated-action actual reward-coordinate source directly from the canonical history-step next-pair law. This packages the history-step surface without first asking callers to project it manually through `Prod.snd` or to build a source record by hand.

def generatedActionActualRewardMapSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Convert a generated random next-pair source into the weaker generated actual-action reward-coordinate source. The conversion freezes the generated action coordinate under the conditional kernel, marginalizes the resulting actual-action pair-product law through `Prod.snd`, and keeps the original shifted generated-action equality. It still assumes the random next-pair source law; it only weakens the source surface exposed to later consumers.

def generatedActionActualRewardMapSource_of_randomPairMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward where

Upgrade a generated-action actual reward-coordinate source to the random next-pair map source. The source already fixes the action trace to the shifted generated policy and identifies the conditional reward-coordinate law at the actual successor action. The split-product condExpKernel law then recovers the full random `(action, reward)` next-pair pushforward.

def generatedActionRandomPairMapSource_of_generatedActionActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward where

Definitional generated-action actual reward-coordinate sources also produce the explicit generated-action random next-pair map source. This is the direct explicit-action counterpart of the definitional random-pair source conversion: it first exposes the definitional actual source as an explicit actual reward-coordinate source, then applies the split-product source upgrade above.

def generatedActionRandomPairMapSource_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Definitional generated-action version of `generatedActionActualRewardMapSource_of_randomPairMapSource`. This converts a definitional random next-pair source into the definitional actual-action reward-coordinate source, deriving the timewise action measurability from the source's state-measurability field.

def generatedActionDefinitionalActualRewardMapSource_of_randomPairDefinitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward where

Project a definitional generated random next-pair source to the policy-selected reward-coordinate law. The definitional source first weakens to the actual generated-action reward-coordinate source; unfolding `generatedActionFromRewardHistory` rewrites that generated successor action to the policy-selected action at the visible finite reward history.

theorem reward_condExpKernel_map_eq_selected_policy_of_generatedActionRandomPairDefinitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Convert a definitional generated random next-pair source into the generated finite-pair `partialTraj` source. The definitional random-pair source already contains a stronger next-pair law. Projecting it to the policy-selected reward-coordinate law and using the generated-trace action-freezing constructor above builds the `GeneratedActionPartialTrajectoryPairLawSource`. This is only a source-surface conversion; it does not prove the random-pair source law itself.

def generatedActionPartialTrajectoryPairLawSource_of_randomPairDefinitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward

Generated-policy random next-pair source plus centered-reward regularity. This packages the source contract together with the measurable context/state extractors, the centered reward-kernel law, and ambient integrability of the generated centered reward at every successor step. It is still a contract: the random next-pair law and integrability fields are supplied, not derived from a global trajectory construction.

structure GeneratedActionRandomPairCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

Definitional generated-policy variant of the centered random-pair source. The action trace is definitionally the shifted policy-generated trace over finite reward histories. This keeps the same centered-kernel and integrability contract as `GeneratedActionRandomPairCenteredSource`, while removing explicit `action` and `haction` inputs from callers.

structure GeneratedActionRandomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) where

A definitional centered source exposes ambient integrability of the generated centered successor reward directly.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) (i : Nat) : Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Turn a definitional centered source into the explicit centered source whose action trace is `generatedActionFromRewardHistory`.

def generatedActionRandomPairCenteredSource_of_definitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) : GeneratedActionRandomPairCenteredSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Convert a definitional centered generated random-pair source into the explicit generated random-pair map source whose action trace is `generatedActionFromRewardHistory`. The centered source already packages the definitional random-pair map source; its centered-kernel and integrability fields are not needed for this weaker map-source interface.

def generatedActionRandomPairMapSource_of_randomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) : GeneratedActionRandomPairMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Convert a definitional centered generated random-pair source into the weaker definitional actual-action reward-coordinate source. The centered source already packages the definitional random-pair map source; its centered-kernel and integrability fields are not needed for this weaker reward-map interface.

def generatedActionDefinitionalActualRewardMapSource_of_randomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward

Convert a definitional centered generated random-pair source into the explicit generated actual-action reward-coordinate source whose action trace is `generatedActionFromRewardHistory`. This is the explicit-action counterpart of `generatedActionDefinitionalActualRewardMapSource_of_randomPairDefinitionalCenteredSource`.

def generatedActionActualRewardMapSource_of_randomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) : GeneratedActionActualRewardMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Project a centered generated random next-pair source directly to its packaged random-pair map source. The centered source already contains the random-pair source used by its history-step and actual-reward projections. This wrapper records that weaker interface under a stable name for downstream law consumers.

def generatedActionRandomPairMapSource_of_randomPairCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a centered generated random next-pair source into the weaker generated actual-action reward-coordinate source. The centered source already contains the random-pair source and state measurability needed by `generatedActionActualRewardMapSource_of_randomPairMapSource`; this wrapper exposes that weaker interface for downstream consumers that do not need the centered-law or integrability fields.

def generatedActionActualRewardMapSource_of_randomPairCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Generated-policy random next-pair source plus bounded centered-reward regularity. This is a bounded-input variant of `GeneratedActionRandomPairCenteredSource`: ambient integrability is derived from a.e. measurability and a per-step a.e. interval bound via `MeasureTheory.Integrable.of_mem_Icc`.

structure GeneratedActionRandomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) where

Generated-policy random next-pair source plus raw-reward and selected-mean boundedness. This is a more primitive bounded-input variant: centered-reward a.e. measurability and bounds are derived from raw reward a.e. measurability/bounds and selected mean a.e. measurability/bounds.

structure GeneratedActionRandomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) where

Generated-policy random next-pair source plus raw-reward bounds and selected-mean measurability/bounds. This variant derives raw reward a.e. measurability from the already available timewise measurable reward trace `hreward`; selected-mean measurability remains explicit.

structure GeneratedActionRandomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) where

Generated-policy random next-pair source plus raw-reward bounds and a measurable selected mean. This variant derives selected-mean a.e. measurability by composing a measurable mean surface with the measurable finite reward history, context, state, and policy action. It still keeps selected-mean bounds as explicit source data.

structure GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) where

Generated-policy random next-pair source plus raw-reward bounds and a measurable mean with deterministic range bounds. This variant derives the selected-mean a.e. bound from a pointwise range contract for `mean`; it is still a source contract and does not derive the raw reward bounds or random next-pair law.

structure GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) where

Generated-policy random next-pair source plus pointwise raw-reward range bounds and a measurable mean with deterministic range bounds. This variant derives both raw-reward and selected-mean a.e. bounds from pointwise range contracts; it is still a source contract and does not derive the random next-pair law.

structure GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) where

Definitional generated-policy variant of the most primitive raw-range source. The action trace is definitionally the shifted policy-generated trace over finite reward histories, so callers do not provide a separate action trace or timewise action measurability proof. The random next-pair law is still a source contract, inherited through `GeneratedActionRandomPairDefinitionalMapSource`.

structure GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) where

Practical definitional raw-range source with a deterministic variance-proxy ceiling. The base source carries the generated-action random next-pair law, raw reward range, selected-mean range, and centered kernel law. This wrapper adds the uniform model-side upper bound needed to choose a deterministic `HasCondSubgaussianMGF` variance proxy.

structure GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) where

Practical definitional raw-range source with time-indexed selected-history variance-proxy ceilings. This is weaker than a global context/action ceiling: the bound only needs to hold on histories reachable by the reward-history context/state surface at the time being consumed.

structure GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) where

Project a definitional raw-range/measurable-mean-range uniform-variance source to its packaged base raw-range/measurable-mean-range bounded source. The uniform source adds a global variance-proxy ceiling for MGF consumers. This wrapper records the weaker base-source interface for downstream consumers that only need the generated random-pair law and raw/mean range regularity.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi

Project a definitional raw-range/measurable-mean-range history-variance source to its packaged base raw-range/measurable-mean-range bounded source. The history-variance source adds selected-history variance-proxy ceilings for MGF consumers. This wrapper records the weaker base-source interface for downstream consumers that only need the generated random-pair law and raw/mean range regularity.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi

A uniform variance-proxy ceiling is a constant time-indexed selected-history variance ceiling. This adapter lets downstream consumers that are stated against the weaker history-specific source interface reuse a stronger global context/action source.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi (fun _ : Nat => varianceCeiling) where

Build the practical definitional generated-policy raw-range source from a full finite-pair-trace `partialTraj` law. This packages the new definitional map-source adapter together with the regularity fields needed by the top raw-range/measurable-mean-range source layer. The trajectory law is still an explicit hypothesis.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardPartialTrajectoryKernel_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source into the practical definitional raw-range/measurable-mean-range source interface. The remaining trajectory-law input is still explicit; this wrapper only reuses the packaged source fields and adds the raw/mean regularity contracts needed by the top source layer.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi

Build the practical raw-range/measurable-mean-range source directly from a finite-pair-history comap selected-reward law. This is the comap-selected-reward entry point for the base source-conversion leaf: the selected-reward law first constructs the generated full finite-pair `partialTraj` source, then the existing source-contract constructor packages the raw/mean range regularity.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_comap_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical raw-range/measurable-mean-range source directly from a finite-pair-history comap selected-reward law whose a.e. filter is also stated at the comap-trim conditioning surface. This is the direct comap-trim companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_comap_reward_map_eq_selected_policy`. It changes only the selected-reward law entry surface: the proof first builds the generated full finite-pair `partialTraj` source through the comap-trim law constructor, then reuses the existing raw-range source-contract package.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_comap_trim_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Build the practical definitional generated-policy raw-range source with a packaged uniform variance ceiling from a full finite-pair-trace `partialTraj` law. This is the uniform-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardPartialTrajectoryKernel_map_eq`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_actionRewardPartialTrajectoryKernel_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source into the packaged uniform-variance practical source interface. This is the source-contract version of `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_actionRewardPartialTrajectoryKernel_map_eq`: the trajectory law is still supplied by `source`, while raw/mean range and uniform variance regularity remain explicit.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling

Build the packaged uniform-variance practical source directly from a finite-pair-history comap selected-reward law. This is the comap-selected-reward entry point for the source-conversion leaf: the selected-reward law first constructs the generated full finite-pair `partialTraj` source, then the existing source-contract constructor packages the raw/mean range and global variance regularity.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_comap_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the packaged uniform-variance practical source directly from a finite-pair-history comap selected-reward law whose a.e. filter is also stated at the comap-trim conditioning surface. This is the direct comap-trim companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_comap_reward_map_eq_selected_policy`. It changes only the selected-reward law entry surface: the proof first builds the generated full finite-pair `partialTraj` source through the comap-trim law constructor, then reuses the existing source-contract uniform-variance package.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_comap_trim_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Build the practical definitional generated-policy raw-range source with a packaged selected-history variance ceiling from a full finite-pair-trace `partialTraj` law. This is the history-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardPartialTrajectoryKernel_map_eq`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_actionRewardPartialTrajectoryKernel_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source into the packaged selected-history-variance practical source interface. This is the source-contract version of `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_actionRewardPartialTrajectoryKernel_map_eq`: the trajectory law is still supplied by `source`, while raw/mean range and selected-history variance regularity remain explicit.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_partialTrajectoryPairLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling

Build the packaged selected-history-variance practical source directly from a finite-pair-history comap selected-reward law. This is the comap-selected-reward entry point for the selected-history source conversion leaf: the selected-reward law first constructs the generated full finite-pair `partialTraj` source, then the existing source-contract constructor packages the raw/mean range and selected-history variance regularity.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_comap_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the packaged selected-history-variance practical source directly from a finite-pair-history comap selected-reward law whose a.e. filter is also stated at the comap-trim conditioning surface. This is the direct comap-trim companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_comap_reward_map_eq_selected_policy`. It changes only the selected-reward law entry surface: the proof first builds the generated full finite-pair `partialTraj` source through the comap-trim law constructor, then reuses the existing source-contract history-variance package.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_comap_trim_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Build the practical definitional generated-policy raw-range source from the narrower frozen-prefix extension-map `partialTraj` law. This is the current closest local surface to the final adaptive reward source: all regularity is packaged, while the remaining semantic gap is isolated to the explicit extension-map trajectory-law hypothesis.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardPartialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged uniform variance ceiling from the narrower frozen-prefix extension-map `partialTraj` law. This is the uniform-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardPartialTrajectoryKernel_extend_map_eq`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_actionRewardPartialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged selected-history variance ceiling from the narrower frozen-prefix extension-map `partialTraj` law. This is the history-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardPartialTrajectoryKernel_extend_map_eq`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_actionRewardPartialTrajectoryKernel_extend_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source from the canonical history-step next-pair law. This packages the same law shape consumed by `centeredReward_succ_condExp_eq_zero_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeBounded` as a reusable source, so downstream routes can keep the practical raw/mean regularity together with the definitional random-pair map source.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged uniform variance ceiling from the canonical history-step next-pair law. This is the uniform-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged selected-history variance ceiling from the canonical history-step next-pair law. This is the history-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_actionRewardHistoryStepKernelFamily_pair_map_eq {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Timewise measurable reward traces give raw reward a.e. measurability after casting `Rat` rewards to `Real`.

theorem rawReward_succ_aemeasurable_of_measurable_reward {Omega : Type u} [mOmega : MeasurableSpace Omega] (mu : MeasureTheory.Measure Omega) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (i : Nat) : AEMeasurable (fun omega : Omega => (((reward omega (i + 1) : Rat) : Real))) mu

Measurable finite reward history, context, state, policy action, and mean surface give selected-mean a.e. measurability after casting `Rat` to `Real`.

theorem selectedMean_succ_aemeasurable_of_measurable_mean {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] (mu : MeasureTheory.Measure Omega) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (i : Nat) : AEMeasurable (fun omega : Omega => (((mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

A pointwise range bound on the mean surface gives the generated selected-mean a.e. bound.

theorem selectedMean_succ_bound_of_mean_range_bound {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] (mu : MeasureTheory.Measure Omega) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (reward : Omega -> RewardTrace Rat) (meanLo meanHi : Nat -> Real) (hmean_bound : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (meanLo i) (meanHi i) (((mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) (ae mu)

A pointwise range bound on the raw reward trace gives the raw successor reward a.e. bound.

theorem rawReward_succ_bound_of_reward_range_bound {Omega : Type u} [mOmega : MeasurableSpace Omega] (mu : MeasureTheory.Measure Omega) (reward : Omega -> RewardTrace Rat) (rewardLo rewardHi : Nat -> Real) (hreward_bound : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (ae mu)

Raw reward range bounds plus a measurable selected-mean surface with range bounds give ambient integrability for the centered successor reward. This helper intentionally does not require any conditional reward-law source: it is pure regularity, so weaker law sources can reuse the existing integrability-based conditional mean-zero route without assuming a random-pair map law.

theorem centeredReward_succ_integrable_of_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a reward-coordinate map law plus prefix-coordinate measurability and raw reward/selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-free raw-range wrapper for the coordinate-measurable map-law consumer at an arbitrary filtration `F`: callers can provide the `RewardKernel.historyStepKernelFamily` pushforward law directly, with the finite reward prefix visible at `F i`, without separately proving centered-reward integrability.

theorem centeredReward_succ_condExp_eq_zero_of_historyStepKernelFamily_condExpKernel_map_eq_of_coordinate_measurable_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (F : MeasureTheory.Filtration Nat mOmega) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_prefix_meas : forall j : Finset.Iic i, @Measurable Omega Rat (F i) inferInstance (fun omega : Omega => reward omega j.1)) (h_kernel_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ (F i) omega) = RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate i (History.finiteRewardHistoryOfTrace (reward omega) i)) (MeasureTheory.ae (mu.trim (F.le i)))) : Filter.EventuallyEq (MeasureTheory.ae mu) (@MeasureTheory.condExp Omega Real (F i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a generated-history reward-coordinate map law plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-free raw-range wrapper for the earliest reward-coordinate map consumer: callers can provide the `RewardKernel.historyStepKernelFamily` pushforward law directly, without separately proving centered-reward integrability.

theorem centeredReward_succ_condExp_eq_zero_of_historyStepKernelFamily_condExpKernel_map_eq_historyFiltrationSucc_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_kernel_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.historyStepKernelFamily rewardKernel policy context state hcontext hstate i (History.finiteRewardHistoryOfTrace (reward omega) i)) (MeasureTheory.ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (MeasureTheory.ae mu) (@MeasureTheory.condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a direct action/reward pair map law plus prefix-coordinate measurability and raw reward/selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-free raw-range wrapper for the coordinate-measurable pair-law consumer at an arbitrary filtration `F`: callers can provide the `RewardKernel.actionRewardHistoryStepKernelFamily` pushforward law directly, without separately proving centered-reward integrability.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardHistoryStepKernelFamily_pair_map_eq_of_coordinate_measurable_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (F : MeasureTheory.Filtration Nat mOmega) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (pairContext : (n : Nat) -> ((j : Finset.Iic n) -> Prod Action Rat) -> Context) (pairState : (n : Nat) -> ((j : Finset.Iic n) -> Prod Action Rat) -> State) (hpairContext : forall n : Nat, Measurable (pairContext n)) (hpairState : forall n : Nat, Measurable (pairState n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (action : Omega -> ActionTrace Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (pairHistory : Omega -> ((j : Finset.Iic i) -> Prod Action Rat)) (h_action_next : @Measurable Omega Action mOmega inferInstance (fun omega : Omega => action omega (i + 1))) (h_prefix_meas : forall j : Finset.Iic i, @Measurable Omega Rat (F i) inferInstance (fun omega : Omega => reward omega j.1)) (h_pair_context_eq : forall omega : Omega, pairContext i (pairHistory omega) = context i (History.finiteRewardHistoryOfTrace (reward omega) i)) (h_pair_state_eq : forall omega : Omega, pairState i (pairHistory omega) = state i (History.finiteRewardHistoryOfTrace (reward omega) i)) (h_kernel_pair_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ (F i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy pairContext pairState hpairContext hpairState i (pairHistory omega)) (MeasureTheory.ae (mu.trim (F.le i)))) : Filter.EventuallyEq (MeasureTheory.ae mu) (@MeasureTheory.condExp Omega Real (F i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Generated-history-filtration specialization of the direct action/reward pair-map route with raw reward and selected-mean range regularity. This removes the separate centered-reward integrability hypothesis from the generated-history pair-law consumer. The actual `condExpKernel` next-pair law is still an explicit structural assumption.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (pairContext : (n : Nat) -> ((j : Finset.Iic n) -> Prod Action Rat) -> Context) (pairState : (n : Nat) -> ((j : Finset.Iic n) -> Prod Action Rat) -> State) (hpairContext : forall n : Nat, Measurable (pairContext n)) (hpairState : forall n : Nat, Measurable (pairState n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (pairHistory : Omega -> ((j : Finset.Iic i) -> Prod Action Rat)) (h_pair_context_eq : forall omega : Omega, pairContext i (pairHistory omega) = context i (History.finiteRewardHistoryOfTrace (reward omega) i)) (h_pair_state_eq : forall omega : Omega, pairState i (pairHistory omega) = state i (History.finiteRewardHistoryOfTrace (reward omega) i)) (h_kernel_pair_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy pairContext pairState hpairContext hpairState i (pairHistory omega)) (MeasureTheory.ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (MeasureTheory.ae mu) (@MeasureTheory.condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Concrete trace-pair specialization of the generated-history pair-map route with raw reward and selected-mean range regularity. This fixes the pair history to the actual finite prefix `fun j => (action omega j, reward omega j)` and still derives the centered reward integrability from bounded raw reward and selected mean evidence.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_projected_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hpairContext : forall n : Nat, Measurable (fun history : (j : Finset.Iic n) -> Prod Action Rat => context n (fun j : Finset.Iic n => (history j).2))) (hpairState : forall n : Nat, Measurable (fun history : (j : Finset.Iic n) -> Prod Action Rat => state n (fun j : Finset.Iic n => (history j).2))) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_kernel_pair_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (fun j : Finset.Iic n => (history j).2)) (fun n history => state n (fun j : Finset.Iic n => (history j).2)) hpairContext hpairState i (fun j : Finset.Iic i => (action omega j.1, reward omega j.1))) (MeasureTheory.ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (MeasureTheory.ae mu) (@MeasureTheory.condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Projected trace-pair route with projection measurability and raw reward/selected-mean range regularity supplied locally. This combines `History.measurable_pairHistoryRewardProjection` with the bounded-regularity wrapper, so callers only provide reward-history context/state measurability plus the concrete next-pair law.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_projected_of_context_state_measurable_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_kernel_pair_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a full finite-pair-trace `partialTraj` law plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-free raw-range wrapper for the finite-pair `partialTraj` consumer: callers no longer need to pass centered-reward integrability separately when the usual bounded reward/mean evidence is available.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_kernel_partialtraj_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a frozen-prefix extension-map `partialTraj` law plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-free raw-range wrapper for the narrower extension-map `partialTraj` consumer. It keeps the trajectory-law gap at the extension-map surface while removing the separate centered-reward integrability argument.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardPartialTrajectoryKernel_extend_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_kernel_extend_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (action omega) (reward omega) i) (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a direct canonical history-step next-pair law plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-free raw-range wrapper for the finite-pair next-pair consumer: callers can provide the `RewardKernel.actionRewardHistoryStepKernelFamily` pair law directly, without separately proving centered-reward integrability.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_kernel_pair_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Generated-action surface for the canonical history-step next-pair raw-range consumer. The underlying direct pair-law consumer already has enough information to prove conditional mean-zero; this wrapper records the common generated-action calling convention used by the adjacent reward-map and `partialTraj` routes.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionTraceSucc_actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_kernel_pair_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume the split next-pair law assumptions plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the mean-zero surface for the split-law builder: conditional a.e. action equality and the reward-coordinate selected-measure law first build the canonical history-step next-pair law, then the finite-pair raw-range consumer supplies integrability and conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_action_ae_eq_policy_reward_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_ae_eq_policy : Filter.Eventually (fun omega : Omega => Filter.EventuallyEq (MeasureTheory.ae (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega)) (fun y : Omega => action y (i + 1)) (fun _y : Omega => (policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i)))) (MeasureTheory.ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) (h_reward_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i)))) (MeasureTheory.ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (MeasureTheory.ae mu) (@MeasureTheory.condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a generated-action trace plus a policy-selected reward-coordinate law and raw reward/selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. Compared with the actual-action reward-law wrapper, this surface matches the policy-selected reward side consumed by the split-law builder directly; the generated trace supplies the conditional action a.e. equality.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionTraceSucc_reward_map_eq_selected_policy_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_reward_map_eq_policy : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i)))) (MeasureTheory.ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (MeasureTheory.ae mu) (@MeasureTheory.condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Turn raw-reward bounds plus selected-mean measurability/bounds into the raw/mean bounded source by deriving raw reward a.e. measurability from `hreward`.

def generatedActionRandomPairRawMeanBoundedSource_of_rawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi where

Turn raw-reward bounds plus a measurable selected-mean surface into the raw-bound/mean-bounded source by deriving selected-mean a.e. measurability.

def generatedActionRandomPairRawBoundMeanBoundedSource_of_rawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi where

Turn raw-reward bounds plus a measurable mean surface and deterministic mean range bounds into the measurable-mean bounded source.

def generatedActionRandomPairRawBoundMeasurableMeanBoundedSource_of_rawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi where

Turn pointwise raw-reward range bounds plus a measurable mean surface and deterministic mean range bounds into the raw-bound/measurable-mean-range source.

def generatedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource_of_rawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi where

Turn a definitional generated-action raw-range source into the existing explicit-action raw-range source by deriving the action trace and its measurability from the reward-history state.

def generatedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource_of_definitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Project a definitional raw-reward-range/measurable-mean-range bounded generated random next-pair source directly to the explicit generated random-pair map source whose action trace is `generatedActionFromRewardHistory`. This is the named map-source projection sitting below the stronger raw-range and actual-reward-map source conversions.

def generatedActionRandomPairMapSource_of_definitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Raw reward and selected-mean a.e. measurability imply centered generated reward a.e. measurability.

theorem centeredReward_succ_aemeasurable_of_generatedActionRandomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : AEMeasurable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Raw reward bounds and selected-mean bounds imply a centered generated reward bound.

theorem centeredReward_succ_bound_of_generatedActionRandomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (rewardLo i - meanHi i) (rewardHi i - meanLo i) (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) (ae mu)

Turn raw reward and selected-mean bounds into the bounded centered source consumed by the generated-policy conditional reward-law route.

def generatedActionRandomPairBoundedCenteredSource_of_rawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward (fun i => rewardLo i - meanHi i) (fun i => rewardHi i - meanLo i) where

Bounded generated centered rewards are ambient-integrable.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

A real random variable with an a.e. interval bound has every exponential tilt integrable on a finite measure space.

theorem integrable_exp_mul_of_mem_Icc {Omega : Type u} [MeasurableSpace Omega] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (X : Omega -> Real) (lo hi : Real) (hX : AEMeasurable X mu) (hbound : Filter.Eventually (fun omega : Omega => Set.Icc lo hi (X omega)) (ae mu)) (t : Real) : MeasureTheory.Integrable (fun omega : Omega => Real.exp (t * X omega)) mu

Bounded generated centered rewards have integrable exponential tilts.

theorem centeredReward_succ_integrable_exp_of_generatedActionRandomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) (i : Nat) (t : Real) : MeasureTheory.Integrable (fun omega : Omega => Real.exp (t * (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) mu

Turn a bounded centered generated source into the integrability-based centered source consumed by the existing conditional mean-zero route.

def generatedActionRandomPairCenteredSource_of_boundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) : GeneratedActionRandomPairCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward where

Project a bounded centered generated random next-pair source directly to its packaged random-pair map source. The bounded source keeps a.e. measurability and interval-bound evidence for integrability consumers. This wrapper records the weaker map-source interface under a stable name for downstream law consumers that do not need those bounds.

def generatedActionRandomPairMapSource_of_randomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a bounded centered generated random next-pair source into the weaker generated actual-action reward-coordinate source. The bounded source already contains the random-pair source and state measurability required by the reward-map conversion; the a.e. bound evidence is kept for consumers that need integrability, but is not needed by this weaker interface.

def generatedActionActualRewardMapSource_of_randomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Project a raw-reward/selected-mean bounded generated random next-pair source directly to its packaged random-pair map source. This source already contains the map source used by its history-step and actual-reward projections. The wrapper records that weaker interface under a stable name for downstream law consumers.

def generatedActionRandomPairMapSource_of_randomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a raw-reward/selected-mean bounded generated random next-pair source into the weaker generated actual-action reward-coordinate source. The raw/mean bounded source already packages the random-pair source and state measurability required by the reward-map conversion. Its raw and selected-mean regularity fields are used by integrability and centered-bound consumers, but not by this weaker source interface.

def generatedActionActualRewardMapSource_of_randomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Project a raw-reward-bound/selected-mean bounded generated random next-pair source directly to its packaged random-pair map source. This source already contains the map source used by its history-step and actual-reward projections. The wrapper records that weaker interface under a stable name for downstream law consumers.

def generatedActionRandomPairMapSource_of_randomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a raw-reward-bound/selected-mean bounded generated random next-pair source into the weaker generated actual-action reward-coordinate source. The raw-bound source already packages the random-pair source and state measurability required by the reward-map conversion. Its raw reward bound and selected-mean regularity fields remain for centered-bound and integrability consumers, but are not needed by this weaker source interface.

def generatedActionActualRewardMapSource_of_randomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Project a raw-reward-bound/measurable-selected-mean generated random next-pair source directly to its packaged random-pair map source. This source already contains the map source used by its history-step and actual-reward projections. The wrapper records that weaker interface under a stable name for downstream law consumers.

def generatedActionRandomPairMapSource_of_randomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a raw-reward-bound/measurable-selected-mean generated random next-pair source into the weaker generated actual-action reward-coordinate source. This source already packages the random-pair source and state measurability required by the reward-map conversion. The measurable-mean and bound fields remain for centered-bound and integrability consumers, but are not needed by this weaker source interface.

def generatedActionActualRewardMapSource_of_randomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Project a raw-reward-bound/measurable-mean-range bounded generated random next-pair source directly to its packaged random-pair map source. This is the source-interface counterpart of the weaker actual-reward projection below: the range-bounded source already contains the map source, and this wrapper gives downstream law consumers a stable named entry point without unpacking the structure fields.

def generatedActionRandomPairMapSource_of_randomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a raw-reward-bound/measurable-mean-range bounded generated random next-pair source into the weaker generated actual-action reward-coordinate source. This range-bounded source already packages the random-pair source and state measurability required by the reward-map conversion. The measurable-mean and range-bound fields remain for centered-bound and integrability consumers, but are not needed by this weaker source interface.

def generatedActionActualRewardMapSource_of_randomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Project a raw-reward-range/measurable-mean-range bounded generated random next-pair source directly to its packaged random-pair map source. This is the explicit-action counterpart of `generatedActionRandomPairMapSource_of_definitionalRawRangeMeasurableMeanRangeBoundedSource`: the top practical regularity source already contains the map source, and this wrapper gives downstream law consumers a stable named entry point.

def generatedActionRandomPairMapSource_of_randomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a raw-reward-range/measurable-mean-range bounded generated random next-pair source into the weaker generated actual-action reward-coordinate source. This top explicit-action source already packages the random-pair source and state measurability required by the reward-map conversion. Its deterministic raw-reward and mean range fields remain for centered-bound and integrability consumers, but are not needed by this weaker source interface.

def generatedActionActualRewardMapSource_of_randomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward

Convert a definitional raw-reward-range/measurable-mean-range bounded generated random next-pair source into the weaker definitional generated actual-action reward-coordinate source. This top definitional source already packages the definitional random-pair source. Its deterministic raw-reward and mean range fields remain for centered-bound and integrability consumers, but are not needed by this weaker source interface.

def generatedActionDefinitionalActualRewardMapSource_of_randomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward

Convert a definitional raw-reward-range/measurable-mean-range bounded generated random next-pair source into the explicit generated actual-action reward-coordinate source whose action trace is `generatedActionFromRewardHistory`. This is a convenience projection for consumers that use `GeneratedActionActualRewardMapSource` rather than the definitional source surface.

def generatedActionActualRewardMapSource_of_randomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionActualRewardMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Convert a definitional raw-reward-range/measurable-mean-range bounded generated random next-pair source into the generated finite-pair `partialTraj` source. The practical raw-range source already contains the definitional random-pair map source and context measurability. This wrapper exposes the weaker `GeneratedActionPartialTrajectoryPairLawSource` surface directly. It is only a source conversion: the packaged random next-pair law is still assumed.

def generatedActionPartialTrajectoryPairLawSource_of_randomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward

Convert a practical definitional raw-range/measurable-mean-range bounded generated random next-pair source into the generated selected-reward finite-pair-history source. This is a source-conversion theorem route for downstream selected-reward consumers: the practical source already exposes the full finite-pair `partialTraj` law, and the selected finite-pair-history source is obtained by projecting that law to the policy-selected reward coordinate. It still consumes the packaged random next-pair law rather than proving the ambient trajectory identification.

def generatedActionSelectedRewardFinitePairHistoryLawSource_of_randomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward

Project a practical uniform-variance source to the generated selected-reward finite-pair-history law source. The variance ceiling is retained by the original source and can be supplied to conditional-MGF consumers after this selected-law projection.

def generatedActionSelectedRewardFinitePairHistoryLawSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward

Project a practical selected-history variance source to the generated selected-reward finite-pair-history law source. The time-indexed variance ceilings remain source-side regularity that can be fed to the selected finite-pair-history conditional-MGF consumers.

def generatedActionSelectedRewardFinitePairHistoryLawSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward

Consume a generated-policy actual reward-coordinate law source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a generated-policy actual reward-coordinate law source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a generated-policy actual reward-coordinate law source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) (h_integrable : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume an explicit generated-action equality and actual-action reward-coordinate law plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-free raw-range wrapper for the narrow reward-coordinate route: callers can provide the generated-action identity and the one-step reward map law directly, without first packaging them as `GeneratedActionActualRewardMapSource`.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionTraceSucc_reward_map_eq_actual_action_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_reward_map_eq_actual_action : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) (action omega (i + 1))) (ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a full finite-pair `partialTraj` law plus generated-action equality and raw reward/selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the raw-range consumer for the reward-map adapter leaf: the full finite-pair trace law first projects to the actual-action reward-coordinate law, then the existing raw-range reward-coordinate route supplies integrability and conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionTraceSucc_actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_kernel_partialtraj_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a frozen-prefix extension-map `partialTraj` law plus generated-action equality and raw reward/selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the raw-range consumer for the extension-map reward-map adapter leaf: the extension-map law first projects to the actual-action reward-coordinate law, then the existing raw-range reward-coordinate route supplies integrability and conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionTraceSucc_actionRewardPartialTrajectoryKernel_extend_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_kernel_extend_map_eq : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (action omega) (reward omega) i) (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume an explicit generated-action equality and actual-action pair-product law plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is one law shape upstream from the reward-coordinate wrapper: the pair-product law is marginalized through `Prod.snd` by the existing generated action route, while the raw/mean range contract supplies integrability.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionTraceSucc_pair_map_eq_actual_action_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_pair_map_eq_actual_action : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action omega (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = MeasureTheory.Measure.map (Prod.mk (action omega (i + 1))) (RewardKernel.selectedMeasure rewardKernel (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) (action omega (i + 1)))) (ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume an explicit generated-action equality and fully random next-pair law plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the most trajectory-facing direct map-law consumer in this file: the law may keep both successor coordinates random under `condExpKernel`; the existing generated-action route freezes the action coordinate, while the raw/mean range contract supplies integrability.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionTraceSucc_random_pair_map_eq_actual_action_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (i : Nat) (h_action_generated : action = Policy.generatedActionTraceSucc policy (fun n omega => state n (History.finiteRewardHistoryOfTrace (reward omega) n)) defaultAction) (h_random_pair_map_eq_actual_action : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = MeasureTheory.Measure.map (Prod.mk (action omega (i + 1))) (RewardKernel.selectedMeasure rewardKernel (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) (action omega (i + 1)))) (ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a generated-policy actual reward-coordinate law source plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the explicit-action counterpart of the definitional raw-range wrapper: the source supplies the reward-coordinate conditional law and generated-action identity, while the raw/mean range contract supplies integrability.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionActualRewardMapSource_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionActualRewardMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a definitional generated-action actual reward-coordinate law source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional generated-action actual reward-coordinate law source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Upgrade a definitional generated-action actual reward-coordinate law source to the stronger definitional generated random next-pair source. The proof factors through the existing full finite-pair `partialTraj` consumer: the actual reward-coordinate source supplies the full trace law, and the definitional random-pair source constructor projects that law back to the next action/reward pair.

def generatedActionRandomPairDefinitionalMapSource_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward

Consume a definitional generated-action actual reward-coordinate law source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (h_integrable : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-policy random next-pair law source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a generated-policy random next-pair law source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a generated-policy random next-pair law source to obtain ordinary succ-indexed conditional mean-zero for the centered reward.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) (h_integrable : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a generated-policy random next-pair law source plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This is the source-packaged companion to the explicit random-pair map-law range wrapper: the source supplies generated-action equality and the random next-pair law, while the raw/mean range contract supplies integrability.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairMapSource_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionRandomPairMapSource mu action rewardKernel policy context state defaultAction reward haction hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume the definitional generated-action random next-pair source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairDefinitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the definitional generated-action random next-pair source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairDefinitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the definitional generated-action random next-pair source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairDefinitionalMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (law : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (h_integrable : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the definitional generated-action random next-pair source plus raw reward and selected-mean range regularity to obtain ordinary succ-indexed conditional mean-zero. This removes the explicit generated action trace and timewise action measurability inputs from the range-based random-pair source consumer.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairDefinitionalMapSource_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionRandomPairDefinitionalMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a policy-selected reward-coordinate law plus raw reward and selected-mean range regularity through the bare definitional random-pair map source. This is the source-route companion to `centeredReward_succ_condExp_eq_zero_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeBounded`: the reward law first builds `GeneratedActionRandomPairDefinitionalMapSource`, then the existing source-level raw/mean range consumer supplies ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_reward_map_eq_selected_policy_definitionalMapSource_rawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a centered generated-policy random next-pair source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a centered generated-policy random next-pair source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a centered generated-policy random next-pair source to obtain ordinary succ-indexed conditional mean-zero for the centered reward.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a centered generated-policy random next-pair source to obtain the succ-indexed conditional sub-Gaussian MGF witness for the centered reward. The source supplies the generated-action law, the canonical next-pair map law, the centered reward-kernel law, and context/state measurability. The analytic regularity contracts that remain explicit are ambient centered-reward measurability and the deterministic variance-proxy upper bound; exponential integrability is derived by the integrated target-law transfer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward) (i : Nat) (c : NNReal) (h_centered_meas : @Measurable Omega Real mOmega inferInstance (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (h_variance_le : Filter.Eventually (fun omega : Omega => varianceProxy (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) <= c) (ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc action reward haction hreward) i) ((History.historyFiltrationSucc action reward haction hreward).le i) (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) c mu

Consume a bounded centered generated-policy random next-pair source to obtain the succ-indexed conditional sub-Gaussian MGF witness for the centered reward. This is the bounded-source wrapper around the centered-source MGF consumer. It uses the bounded source only to lower into `GeneratedActionRandomPairCenteredSource`; ambient centered-reward measurability and variance-proxy domination remain explicit, while exponential integrability is derived.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) (i : Nat) (c : NNReal) (h_centered_meas : @Measurable Omega Real mOmega inferInstance (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (h_variance_le : Filter.Eventually (fun omega : Omega => varianceProxy (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) <= c) (ae (mu.trim ((History.historyFiltrationSucc action reward haction hreward).le i)))) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc action reward haction hreward) i) ((History.historyFiltrationSucc action reward haction hreward).le i) (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) c mu

Consume a definitional centered generated-policy random next-pair source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional centered generated-policy random next-pair source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional centered generated-policy random next-pair source to obtain ordinary succ-indexed conditional mean-zero for the centered reward.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional centered generated-policy random next-pair source to obtain the succ-indexed conditional sub-Gaussian MGF witness for the centered reward. This is the definitional-action wrapper around the explicit centered-source MGF consumer: the action trace is fixed to `generatedActionFromRewardHistory`, and the definitional source is lowered to the explicit centered source. The centered-reward measurability and variance ceiling remain explicit; exponential integrability is derived.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (source : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward) (i : Nat) (c : NNReal) (h_centered_meas : @Measurable Omega Real mOmega inferInstance (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (h_variance_le : Filter.Eventually (fun omega : Omega => varianceProxy (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) <= c) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a bounded centered generated-policy random next-pair source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a bounded centered generated-policy random next-pair source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a bounded centered generated-policy random next-pair source to obtain ordinary succ-indexed conditional mean-zero for the centered reward.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairBoundedCenteredSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (lo hi : Nat -> Real) (source : GeneratedActionRandomPairBoundedCenteredSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward lo hi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Raw reward and selected-mean bounded sources give ambient integrability for the generated centered successor reward.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a raw reward and selected-mean bounded generated-policy source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw reward and selected-mean bounded generated-policy source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw reward and selected-mean bounded generated-policy source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairRawMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Raw-reward bounds plus selected-mean measurability/bounds give centered successor reward a.e. measurability.

theorem centeredReward_succ_aemeasurable_of_generatedActionRandomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : AEMeasurable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Raw-reward bounds plus selected-mean bounds give a centered successor reward interval bound.

theorem centeredReward_succ_bound_of_generatedActionRandomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (rewardLo i - meanHi i) (rewardHi i - meanLo i) (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) (ae mu)

Raw-reward bounds plus selected-mean measurability/bounds give ambient integrability for the generated centered successor reward.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a raw-reward-bound and selected-mean-bounded generated-policy source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw-reward-bound and selected-mean-bounded generated-policy source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw-reward-bound and selected-mean-bounded generated-policy source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairRawBoundMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Measurable selected-mean surface plus raw-reward/mean bounds give centered successor reward a.e. measurability.

theorem centeredReward_succ_aemeasurable_of_generatedActionRandomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : AEMeasurable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Measurable selected-mean surface plus raw-reward/mean bounds give a centered successor reward interval bound.

theorem centeredReward_succ_bound_of_generatedActionRandomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (rewardLo i - meanHi i) (rewardHi i - meanLo i) (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) (ae mu)

Measurable selected-mean surface plus raw-reward/mean bounds give ambient integrability for the generated centered successor reward.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a raw-reward-bound and measurable selected-mean generated-policy source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw-reward-bound and measurable selected-mean generated-policy source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw-reward-bound and measurable selected-mean generated-policy source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairRawBoundMeasurableMeanBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Measurable mean surface plus deterministic mean range bounds give centered successor reward a.e. measurability.

theorem centeredReward_succ_aemeasurable_of_generatedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : AEMeasurable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Measurable mean surface plus deterministic mean range bounds give a centered successor reward interval bound.

theorem centeredReward_succ_bound_of_generatedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (rewardLo i - meanHi i) (rewardHi i - meanLo i) (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) (ae mu)

Measurable mean surface plus deterministic mean range bounds give ambient integrability for the generated centered successor reward.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a raw-reward-bound and deterministic mean-range generated-policy source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw-reward-bound and deterministic mean-range generated-policy source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a raw-reward-bound and deterministic mean-range generated-policy source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawBoundMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Pointwise raw-reward and mean range bounds give centered successor reward a.e. measurability.

theorem centeredReward_succ_aemeasurable_of_generatedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : AEMeasurable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Pointwise raw-reward and mean range bounds give a centered successor reward interval bound.

theorem centeredReward_succ_bound_of_generatedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (rewardLo i - meanHi i) (rewardHi i - meanLo i) (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) (ae mu)

Pointwise raw-reward and mean range bounds give ambient integrability for the generated centered successor reward.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a pointwise raw-reward and mean-range generated-policy source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (action y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardHistoryStepKernelFamily rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a pointwise raw-reward and mean-range generated-policy source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (action y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc action reward haction hreward) i) omega) = RewardKernel.actionRewardPartialTrajectoryKernel rewardKernel policy (fun n history => context n (History.pairHistoryRewardProjection history)) (fun n history => state n (History.pairHistoryRewardProjection history)) (fun n : Nat => (source.hcontext n).comp (History.measurable_pairHistoryRewardProjection (Action

Consume a pointwise raw-reward and mean-range generated-policy source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (action : Omega -> ActionTrace Action) (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (haction : forall t : Nat, Measurable (fun omega : Omega => action omega t)) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairRawRangeMeasurableMeanRangeBoundedSource mu action rewardKernel policy context state mean varianceProxy defaultAction reward haction hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc action reward haction hreward) i) mOmega _ _ _ mu (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (fun _omega : Omega => (0 : Real))

Consume a definitional generated-action raw-range source to obtain centered successor reward a.e. measurability.

theorem centeredReward_succ_aemeasurable_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : AEMeasurable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a definitional generated-action raw-range source to obtain full measurability for the generated centered successor reward. This strengthens the a.e.-measurable regularity surface when the source carries timewise reward measurability, context/state measurability, and a measurable mean surface.

theorem centeredReward_succ_measurable_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : @Measurable Omega Real mOmega inferInstance (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))

Consume a definitional generated-action raw-range source to obtain centered successor reward interval bounds.

theorem centeredReward_succ_bound_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => Set.Icc (rewardLo i - meanHi i) (rewardHi i - meanLo i) (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) (ae mu)

Turn a definitional generated-action raw-range source into the bounded centered source consumed by the generated-policy conditional reward-law route.

def generatedActionRandomPairBoundedCenteredSource_of_definitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairBoundedCenteredSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Turn a definitional generated-action raw-range source into the integrability-based centered source consumed by the generated-policy conditional reward-law route.

def generatedActionRandomPairCenteredSource_of_definitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairCenteredSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional generated-action raw-range source to obtain ambient integrability for the generated centered successor reward.

theorem centeredReward_succ_integrable_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : MeasureTheory.Integrable (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real))) mu

Consume a definitional generated-action raw-range source to obtain exponential integrability for the generated centered successor reward.

theorem centeredReward_succ_integrable_exp_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) (t : Real) : MeasureTheory.Integrable (fun omega : Omega => Real.exp (t * (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) mu

Turn a definitional generated-action raw-range source into the definitional integrability-based centered source. This keeps the generated action trace implicit through `generatedActionFromRewardHistory`, instead of first lowering to the explicit centered source over that trace.

def generatedActionRandomPairDefinitionalCenteredSource_of_definitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward where

Lower a definitional generated-action raw-range/history-variance source into the definitional centered-source interface. The history-variance wrapper carries the practical raw/mean range regularity and selected-history variance ceilings for MGF consumers. Consumers that only need the centered law and bounded-derived integrability can use this projection without unpacking the history-variance source manually.

def generatedActionRandomPairDefinitionalCenteredSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward

Lower a definitional generated-action raw-range/history-variance source into the bounded centered-source interface. This keeps the deterministic centered reward bounds available for downstream integrability and tail consumers while hiding the selected-history variance wrapper when those consumers only need the bounded-centered contract.

def generatedActionRandomPairBoundedCenteredSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairBoundedCenteredSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/history-variance source into the integrability-based centered-source interface. This is the direct projection for consumers that need the centered-source contract rather than the stronger bounded-centered or definitional interfaces.

def generatedActionRandomPairCenteredSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairCenteredSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/history-variance source into the weaker definitional actual-action reward-map source. This keeps consumers on the definitional `generatedActionFromRewardHistory` surface while hiding the selected-history variance wrapper and the stronger random-pair law package.

def generatedActionDefinitionalActualRewardMapSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward

Lower a definitional generated-action raw-range/history-variance source into the explicit generated actual-action reward-map source. This is the direct projection for consumers that only need the selected reward coordinate law over `generatedActionFromRewardHistory`, not the full random next-pair or centered-source interfaces.

def generatedActionActualRewardMapSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionActualRewardMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/history-variance source into the explicit generated random-pair map source. This exposes the full random next-pair law over `generatedActionFromRewardHistory` for downstream history-step and `partialTraj` consumers while hiding the selected-history variance wrapper.

def generatedActionRandomPairMapSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional generated-action raw-range/history-variance source to obtain the canonical history-step pair law. This first exposes the packaged generated random-pair map source, then reuses the generic source-level history-step consumer.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/uniform-variance source into the explicit generated random-pair map source. This exposes the full random next-pair law over `generatedActionFromRewardHistory` for downstream history-step and `partialTraj` consumers while hiding the uniform variance wrapper.

def generatedActionRandomPairMapSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/uniform-variance source into the generated finite-pair `partialTraj` source. The uniform-variance wrapper only adds a global variance ceiling. Consumers that need the weaker full finite-pair source can first project to the packaged raw-range source and then reuse the raw-range-to-`partialTraj` source conversion.

def generatedActionPartialTrajectoryPairLawSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward

Lower a definitional generated-action raw-range/history-variance source into the generated finite-pair `partialTraj` source. The history-variance wrapper only adds time-indexed selected-history variance ceilings. Consumers that need the weaker full finite-pair source can first project to the packaged raw-range source and then reuse the raw-range-to- `partialTraj` source conversion.

def generatedActionPartialTrajectoryPairLawSource_of_historyVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward

Consume a definitional generated-action raw-range/uniform-variance source to obtain the canonical history-step pair law. This first exposes the packaged generated random-pair map source, then reuses the generic source-level history-step consumer.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/uniform-variance source into the weaker definitional actual-action reward-map source. This keeps consumers on the definitional `generatedActionFromRewardHistory` surface while hiding the uniform variance wrapper and the stronger random-pair law package.

def generatedActionDefinitionalActualRewardMapSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward

Lower a definitional generated-action raw-range/uniform-variance source into the explicit generated actual-action reward-map source. This is the direct projection for consumers that only need the selected reward coordinate law over `generatedActionFromRewardHistory`, not the full random next-pair or centered-source interfaces.

def generatedActionActualRewardMapSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionActualRewardMapSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/uniform-variance source into the bounded centered-source interface. This keeps deterministic centered reward bounds available for downstream integrability and tail consumers while hiding the uniform variance wrapper when those consumers only need the bounded-centered contract.

def generatedActionRandomPairBoundedCenteredSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairBoundedCenteredSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/uniform-variance source into the integrability-based centered-source interface. This is the direct projection for consumers that need the centered-source contract rather than the stronger bounded-centered or definitional interfaces.

def generatedActionRandomPairCenteredSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairCenteredSource mu (generatedActionFromRewardHistory policy state defaultAction reward) rewardKernel policy context state mean varianceProxy defaultAction reward (generatedActionFromRewardHistory_measurable (policy

Lower a definitional generated-action raw-range/uniform-variance source into the definitional centered-source interface. The uniform-variance wrapper carries the practical raw/mean range regularity and a global variance ceiling for MGF consumers. Consumers that only need the centered law and bounded-derived integrability can use this projection without unpacking the uniform-variance source manually.

def generatedActionRandomPairDefinitionalCenteredSource_of_uniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) : GeneratedActionRandomPairDefinitionalCenteredSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward

Consume a definitional generated-action raw-range source to obtain the canonical history-step pair law.

theorem actionRewardHistoryStepKernelFamily_pair_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional generated-action raw-range source to obtain the full finite-pair-trace `partialTraj` law.

theorem actionRewardPartialTrajectoryKernel_map_eq_historyFiltrationSucc_finitePairHistoryOfTrace_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional generated-action raw-range source to obtain ordinary succ-indexed conditional mean-zero.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a practical definitional raw-range/measurable-mean-range generated random-pair source to obtain the succ-indexed conditional sub-Gaussian MGF witness for the centered reward. This exposes the newest definitional centered-source MGF consumer at the top-level bounded practical source surface. The range evidence is used through the existing conversion into `GeneratedActionRandomPairDefinitionalCenteredSource`; centered-reward measurability and the variance ceiling remain explicit, while the converted selected laws derive exponential integrability.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) (c : NNReal) (h_centered_meas : @Measurable Omega Real mOmega inferInstance (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (h_variance_le : Filter.Eventually (fun omega : Omega => varianceProxy (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) <= c) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical definitional raw-range source for the conditional MGF route from a supplied centered-reward measurability witness. The selected-law MGF transfer now derives exponential integrability directly.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_centered_meas {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) (c : NNReal) (h_centered_meas : @Measurable Omega Real mOmega inferInstance (fun omega : Omega => (((reward omega (i + 1) - mean (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) : Rat) : Real)))) (h_variance_le : Filter.Eventually (fun omega : Omega => varianceProxy (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) <= c) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical definitional raw-range source for the conditional MGF route while deriving centered-reward measurability from the source regularity fields; exponential integrability follows from the selected laws.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_variance_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) (c : NNReal) (h_variance_le : Filter.Eventually (fun omega : Omega => varianceProxy (context i (History.finiteRewardHistoryOfTrace (reward omega) i)) ((policy i).action (state i (History.finiteRewardHistoryOfTrace (reward omega) i))) <= c) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical definitional raw-range source for the conditional MGF route under a deterministic variance-proxy ceiling. This replaces the trimmed-a.e. selected-history variance domination hypothesis with a pointwise kernel-level ceiling on `varianceProxy`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_uniform_variance_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) (c : NNReal) (h_variance_uniform : forall context : Context, forall action : Action, varianceProxy context action <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical definitional raw-range source for the conditional MGF route under a deterministic variance-proxy ceiling on the selected finite reward histories at this time. This is weaker than a global context/action ceiling and still removes the trimmed-a.e. selected-history variance domination side condition.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_history_variance_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) (c : NNReal) (h_variance_history : forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a practical definitional raw-range source with a packaged deterministic variance-proxy ceiling for the conditional MGF route.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a practical definitional raw-range source with packaged time-indexed selected-history variance-proxy ceilings for the conditional MGF route.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a packaged selected-history variance source with any deterministic proxy that dominates the selected ceiling at the requested time. This is useful when downstream tail APIs use a coarser shared proxy than the model-side time-indexed variance schedule.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) (c : NNReal) (hceiling : varianceCeiling i <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a uniform-variance source through the weaker selected-history variance source interface. This is a convenience wrapper for downstream callers that standardize on the history-variance source API while their model supplies a global variance ceiling.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_via_historyVarianceSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a packaged uniform-variance source with any deterministic proxy that dominates the global variance ceiling. This is the uniform-source companion to the selected-history larger-proxy consumer above.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) (c : NNReal) (hceiling : varianceCeiling <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the canonical history-step next-pair law plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the history-step law-surface companion to the packaged uniform-variance source consumer above.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the canonical history-step next-pair law plus the practical uniform variance package at any deterministic proxy that dominates the global ceiling. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the full finite-pair-trace `partialTraj` law plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the full-trace law-surface companion to the packaged uniform-variance source consumer above.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source plus raw/mean range regularity and a global variance ceiling directly into the succ-indexed conditional MGF witness. This is the source-contract version of `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded`: the packaged source supplies the context/state measurability and full finite-pair partial-trajectory law.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_partialTrajectoryPairLawSource_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the full finite-pair-trace `partialTraj` law plus the practical uniform variance package at any deterministic proxy that dominates the global ceiling. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source plus the practical uniform variance package at any deterministic proxy that dominates the global ceiling. This is the source-contract version of `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le`: the packaged source supplies the context/state measurability and full finite-pair partial-trajectory law.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_partialTrajectoryPairLawSource_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (c : NNReal) (hceiling : varianceCeiling <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the full finite-pair-trace `partialTraj` law plus the practical raw/mean range regularity package and a selected-history variance ceiling to obtain the succ-indexed conditional MGF witness. This is the full-trace law-surface companion to the packaged history-variance source consumer above.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source plus raw/mean range regularity and selected-history variance ceilings directly into the succ-indexed conditional MGF witness. This is the source-contract version of `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded`: the packaged source supplies the context/state measurability and full finite-pair partial-trajectory law.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_partialTrajectoryPairLawSource_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the full finite-pair-trace `partialTraj` law plus the practical selected-history variance package at any deterministic proxy that dominates the selected ceiling at the requested time. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a generated-history `partialTraj` pair-law source plus the practical selected-history variance package at any deterministic proxy that dominates the selected ceiling at the requested time. This is the source-contract version of `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le`: the packaged source supplies the context/state measurability and full finite-pair partial-trajectory law.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_partialTrajectoryPairLawSource_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (c : NNReal) (hceiling : varianceCeiling i <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the frozen-prefix extension-map `partialTraj` law plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the extension-map law-surface companion to the packaged uniform-variance source consumer above.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_extend_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the frozen-prefix extension-map `partialTraj` law plus the practical uniform variance package at any deterministic proxy that dominates the global ceiling. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_extend_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_extend_map_eq_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the frozen-prefix extension-map `partialTraj` law plus the practical raw/mean range regularity package and a selected-history variance ceiling to obtain the succ-indexed conditional MGF witness. This is the extension-map law-surface companion to the packaged history-variance source consumer above.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_extend_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the frozen-prefix extension-map `partialTraj` law plus the practical selected-history variance package at any deterministic proxy that dominates the selected ceiling at the requested time. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_extend_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardPartialTrajectoryKernel_extend_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the canonical history-step next-pair law plus the practical raw/mean range regularity package and a selected-history variance ceiling to obtain the succ-indexed conditional MGF witness. This is the history-step law-surface companion to the packaged history-variance source consumer above.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the canonical history-step next-pair law plus the practical selected-history variance package at any deterministic proxy that dominates the selected ceiling at the requested time. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the full finite-pair-trace `partialTraj` law plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This is the full-trace companion to the frozen-prefix extension-map wrapper below.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardPartialTrajectoryKernel_map_eq_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_kernel_partialtraj_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a packaged full finite-pair-trace `partialTraj` law plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This is the source-level companion to the full-trace law-surface wrapper above: the packaged source supplies context/state measurability and the `partialTraj`/`condExpKernel` law field.

theorem centeredReward_succ_condExp_eq_zero_of_partialTrajectoryPairLawSource_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionPartialTrajectoryPairLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the generated selected-reward finite-pair-history source plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This is the direct mean-zero consumer for `GeneratedActionSelectedRewardFinitePairHistoryLawSource`: the source is first converted to `GeneratedActionPartialTrajectoryPairLawSource`, then the existing full finite-pair-trace consumer applies. The selected-reward law is still a source field, not proved here.

theorem centeredReward_succ_condExp_eq_zero_of_selectedRewardFinitePairHistoryLawSource_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the generated selected-reward finite-pair-history source plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the selected-reward source-level companion to the packaged `partialTraj` source consumer. The source is lowered through `GeneratedActionPartialTrajectoryPairLawSource`; it still consumes the selected-reward law field and does not prove ambient trajectory transport.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_selectedRewardFinitePairHistoryLawSource_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the generated selected-reward finite-pair-history source plus the practical uniform variance package at any deterministic proxy dominating the global ceiling. This is the coarser-proxy selected-source wrapper for the existing packaged `partialTraj` source MGF consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_selectedRewardFinitePairHistoryLawSource_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (c : NNReal) (hceiling : varianceCeiling <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the generated selected-reward finite-pair-history source plus the practical raw/mean range regularity package and selected-history variance ceilings to obtain the succ-indexed conditional MGF witness. This is the selected-source wrapper for the existing packaged `partialTraj` source history-variance consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_selectedRewardFinitePairHistoryLawSource_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the generated selected-reward finite-pair-history source plus the practical selected-history variance package at any deterministic proxy dominating the requested time's ceiling. This is the coarser-proxy selected-source wrapper for the existing packaged `partialTraj` source history-variance MGF consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_selectedRewardFinitePairHistoryLawSource_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionSelectedRewardFinitePairHistoryLawSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (c : NNReal) (hceiling : varianceCeiling i <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical definitional raw-range source through the generated selected-reward finite-pair-history source route to obtain ordinary succ-indexed conditional mean-zero. This records the end-to-end composition used by selected-reward theorem-card routes: the practical package is projected to `GeneratedActionSelectedRewardFinitePairHistoryLawSource`, then the selected source mean-zero consumer applies. The packaged random next-pair law is still a source field, not proved here.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_via_selectedRewardFinitePairHistoryLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical uniform-variance source through the generated selected-reward finite-pair-history source route to obtain the conditional MGF witness at the packaged global variance ceiling.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_via_selectedRewardFinitePairHistoryLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical uniform-variance source through the selected-source route at any deterministic proxy dominating the packaged global ceiling.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_via_selectedRewardFinitePairHistoryLawSource_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) (c : NNReal) (hceiling : varianceCeiling <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical selected-history variance source through the generated selected-reward finite-pair-history source route to obtain the conditional MGF witness at the requested time-indexed ceiling.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_via_selectedRewardFinitePairHistoryLawSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the practical selected-history variance source through the selected-source route at any deterministic proxy dominating the requested time-indexed ceiling.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_via_selectedRewardFinitePairHistoryLawSource_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (source : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling) (i : Nat) (c : NNReal) (hceiling : varianceCeiling i <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume a selected-reward law stated at the finite pair-prefix comap conditioning surface plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This composes the comap-law source constructor with the selected-reward source mean-zero consumer. It still consumes the selected-reward conditional law; it does not prove that law from an ambient trajectory/disintegration construction.

theorem centeredReward_succ_condExp_eq_zero_of_comap_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume a selected-reward law stated entirely at the finite pair-prefix comap conditioning surface, including the `trim` a.e. filter, plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This is the comap-trim companion to the generated-history-trim mean-zero wrapper. It only changes the input law surface; the proof still routes through `GeneratedActionSelectedRewardFinitePairHistoryLawSource` and does not prove the selected-reward law from an ambient trajectory/disintegration construction.

theorem centeredReward_succ_condExp_eq_zero_of_comap_trim_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Directly consume a selected-reward law stated at the finite pair-prefix comap conditioning surface plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the uniform-variance MGF companion to the comap mean-zero wrapper: it constructs the full generated finite-pair `partialTraj` source from the comap selected-reward law, then invokes the existing source-level conditional MGF consumer. It still consumes the selected-reward conditional law; it does not prove that law from an ambient trajectory/disintegration construction.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume a selected-reward law stated entirely at the finite pair-prefix comap conditioning surface, including the `trim` a.e. filter, plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the comap-trim companion to the uniform-variance MGF wrapper. It constructs the full generated finite-pair `partialTraj` source from the comap-trim selected-reward law, then invokes the existing source-level conditional MGF consumer. It still consumes the selected-reward conditional law; it does not prove that law from an ambient trajectory/disintegration construction.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_trim_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Directly consume a selected-reward law stated entirely at the finite pair-prefix comap conditioning surface, including the `trim` a.e. filter, plus a global variance ceiling at any deterministic coarser proxy. This is the comap-trim companion to the coarser-proxy uniform-variance MGF wrapper. It constructs the full generated finite-pair `partialTraj` source from the comap-trim selected-reward law, then invokes the existing source-level larger-proxy conditional MGF consumer. It still consumes the selected-reward conditional law and the proxy-domination proof; it does not prove either one from an ambient trajectory/disintegration construction.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_trim_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Directly consume a selected-reward law stated at the finite pair-prefix comap plus a global variance ceiling at any deterministic coarser proxy. This is the coarser-proxy companion to the comap uniform-variance wrapper. It constructs the full generated finite-pair `partialTraj` source from the comap selected-reward law, then invokes the existing source-level larger-proxy conditional MGF consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume a selected-reward law stated at the finite pair-prefix comap, raw/mean range regularity, and selected-history variance ceilings to obtain the succ-indexed conditional MGF witness. This is the history-variance companion to the comap uniform-variance wrapper: it constructs the full generated finite-pair `partialTraj` source from the comap selected-reward law, then invokes the existing source-level conditional MGF consumer. It still consumes the selected-reward conditional law; it does not prove that law from an ambient trajectory/disintegration construction.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume a selected-reward law stated entirely at the finite pair-prefix comap conditioning surface, including the `trim` a.e. filter, raw/mean range regularity, and selected-history variance ceilings to obtain the succ-indexed conditional MGF witness. This is the comap-trim companion to the history-variance MGF wrapper. It constructs the full generated finite-pair `partialTraj` source from the comap-trim selected-reward law, then invokes the existing source-level conditional MGF consumer. It still consumes the selected-reward conditional law and selected-history ceilings; it does not prove either from an ambient trajectory/disintegration construction.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_trim_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Directly consume a selected-reward law stated at the finite pair-prefix comap plus selected-history variance ceilings at any deterministic coarser proxy. This is the coarser-proxy companion to the comap history-variance wrapper. It constructs the full generated finite-pair `partialTraj` source from the comap selected-reward law, then invokes the existing source-level larger-proxy conditional MGF consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume a selected-reward law stated entirely at the finite pair-prefix comap conditioning surface, including the `trim` a.e. filter, plus selected-history variance ceilings at any deterministic coarser proxy. This is the comap-trim companion to the coarser-proxy history-variance MGF wrapper. It constructs the full generated finite-pair `partialTraj` source from the comap-trim selected-reward law, then invokes the existing source-level larger-proxy conditional MGF consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_comap_trim_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) omega) = RewardKernel.selectedMeasure rewardKernel (context i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))) ((policy i).action (state i (History.pairHistoryRewardProjection (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i))))) (ae (mu.trim (show ((inferInstance : MeasurableSpace ((j : Finset.Iic i) -> Prod Action Rat)).comap (fun y : Omega => History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward y) (reward y) i)) <= mOmega from by have hfiltration : ((History.historyFiltrationSucc (mOmega

Directly consume the frozen-prefix extension-map `partialTraj` law plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This avoids requiring callers to first build `GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource` by hand.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardPartialTrajectoryKernel_extend_map_eq_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_kernel_extend_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega ((j : Finset.Iic (i + 1)) -> Prod Action Rat) mOmega inferInstance (fun y : Omega => History.extendPairHistorySucc (History.finitePairHistoryOfTrace (generatedActionFromRewardHistory policy state defaultAction reward omega) (reward omega) i) (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the canonical history-step next-pair law plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This moves the practical generated-action interface one step before the extension-map `partialTraj` surface: callers can provide the next-pair `RewardKernel.actionRewardHistoryStepKernelFamily` law directly.

theorem centeredReward_succ_condExp_eq_zero_of_actionRewardHistoryStepKernelFamily_pair_map_eq_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_kernel_pair_map_eq : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega (Prod Action Rat) mOmega inferInstance (fun y : Omega => (generatedActionFromRewardHistory policy state defaultAction reward y (i + 1), reward y (i + 1))) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the actual-action reward-coordinate selected-measure law plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. The generated action trace supplies the action side of the next-pair split, so the remaining law input is only the reward-coordinate conditional kernel map to `RewardKernel.selectedMeasure` at the generated next action.

theorem centeredReward_succ_condExp_eq_zero_of_reward_map_eq_actual_action_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the policy-selected reward-coordinate law plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This is the definitional generated-action counterpart of the explicit policy-selected reward-coordinate wrapper: callers can state the reward law at `(policy i).action (state i history)` without first rewriting it to the generated successor action.

theorem centeredReward_succ_condExp_eq_zero_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a definitional actual-action reward-coordinate source plus the practical raw/mean range regularity package to obtain ordinary succ-indexed conditional mean-zero. This is the source-level wrapper for the direct reward-coordinate selected measure law consumer: callers provide `GeneratedActionDefinitionalActualRewardMapSource` instead of separately threading its state measurability and reward-map field.

theorem centeredReward_succ_condExp_eq_zero_of_generatedActionDefinitionalActualRewardMapSource_definitionalRawRangeMeasurableMeanRangeBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : Filter.EventuallyEq (ae mu) (@condExp Omega Real ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional raw-range/measurable-mean-range source from a packaged definitional actual-action reward-coordinate law source. This is a source-level constructor: the actual reward-coordinate source already packages the conditional reward law and state measurability, while the caller adds only the context, centered-kernel, mean-measurability, and deterministic raw/mean range regularity needed by the top raw-range layer.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi where

Build the packaged uniform-variance source from a packaged definitional actual-action reward-coordinate source. This is the uniform-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_generatedActionDefinitionalActualRewardMapSource`: the reward-coordinate source and raw/mean range regularity build the base source, while `hvariance` supplies the global deterministic variance proxy ceiling used by downstream conditional MGF consumers.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling where

Consume a packaged definitional actual-action reward-coordinate source plus uniform variance regularity through the practical uniform-variance conditional MGF route. The packaged actual source supplies the reward-coordinate law and state measurability. The caller adds raw/mean range regularity and the global variance ceiling; the proof builds the packaged uniform-variance source and reuses its source-level MGF consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionDefinitionalActualRewardMapSource_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a packaged definitional actual-action reward-coordinate source plus uniform variance regularity at a coarser deterministic proxy. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionDefinitionalActualRewardMapSource_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded`: the proof builds the same packaged uniform-variance source and then reuses the source-level larger-proxy consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionDefinitionalActualRewardMapSource_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (c : NNReal) (hceiling : varianceCeiling <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the packaged selected-history variance source from a packaged definitional actual-action reward-coordinate source. This is the history-variance companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_generatedActionDefinitionalActualRewardMapSource`: the reward-coordinate source and raw/mean range regularity build the base source, while `hvariance` supplies the time-indexed selected-history variance ceiling used by downstream conditional MGF consumers.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_generatedActionDefinitionalActualRewardMapSource {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) : GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource mu rewardKernel policy context state mean varianceProxy defaultAction reward hreward rewardLo rewardHi meanLo meanHi varianceCeiling where

Consume a packaged definitional actual-action reward-coordinate source plus selected-history variance regularity through the practical history-variance conditional MGF route. The packaged actual source supplies the reward-coordinate law and state measurability. The caller adds raw/mean range regularity and the time-indexed selected-history variance ceilings; the proof builds the packaged history-variance source and reuses its source-level MGF consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionDefinitionalActualRewardMapSource_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume a packaged definitional actual-action reward-coordinate source plus selected-history variance regularity at a coarser deterministic proxy. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionDefinitionalActualRewardMapSource_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded`: the proof builds the same packaged history-variance source and then reuses the source-level larger-proxy consumer.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_generatedActionDefinitionalActualRewardMapSource_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (source : GeneratedActionDefinitionalActualRewardMapSource mu rewardKernel policy context state defaultAction reward hreward) (i : Nat) (c : NNReal) (hceiling : varianceCeiling i <= c) : ProbabilityTheory.HasCondSubgaussianMGF ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source from the actual-action reward-coordinate selected-measure law. This is the base source-level companion to the uniform/history variance source constructors: the reward-coordinate law is first lifted to the frozen-prefix extension-map `partialTraj` law, then packaged into `GeneratedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_reward_map_eq_actual_action {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source from the policy-selected reward-coordinate selected-measure law. For `generatedActionFromRewardHistory`, the successor coordinate is definitionally the policy-selected action. This wrapper rewrites the policy-facing reward law into the actual successor-action law and reuses the base actual-action source constructor.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeBoundedSource_of_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the actual-action reward-coordinate selected-measure law plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the reward-coordinate law-surface companion to the frozen-prefix extension-map uniform-variance conditional MGF wrapper.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_actual_action_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged uniform variance ceiling from the actual-action reward-coordinate selected-measure law. This source-level wrapper preserves the reward-map law surface while exposing the reusable packaged uniform-variance source used by downstream conditional MGF consumers.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_reward_map_eq_actual_action {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the actual-action reward-coordinate selected-measure law plus the practical uniform-variance regularity package at any deterministic proxy that dominates the global variance ceiling. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_actual_action_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_actual_action_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the policy-selected reward-coordinate law plus the practical raw/mean range regularity package and a global variance ceiling to obtain the succ-indexed conditional MGF witness. This is the policy-facing counterpart of the actual-action reward-map wrapper: callers can state the reward law at `(policy i).action (state i history)` without first rewriting it to the generated successor action.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the policy-selected reward-coordinate law plus the practical uniform-variance regularity package through the bare definitional random-pair map source. The reward law first builds `GeneratedActionRandomPairDefinitionalMapSource`; that bare source is then wrapped with raw/mean range regularity and the global variance ceiling before the source-level conditional MGF consumer is applied.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalMapSource_rawRangeMeasurableMeanRangeUniformVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the policy-selected reward-coordinate law plus uniform-variance regularity through the bare definitional random-pair map source at a coarser deterministic proxy. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalMapSource_rawRangeMeasurableMeanRangeUniformVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalMapSource_rawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the policy-selected reward-coordinate law plus the practical selected-history variance regularity package through the bare definitional random-pair map source. The reward law first builds `GeneratedActionRandomPairDefinitionalMapSource`; that bare source is then wrapped with raw/mean range regularity and the time-indexed selected-history variance ceiling before the source-level conditional MGF consumer is applied.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalMapSource_rawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Consume the policy-selected reward-coordinate law plus selected-history variance regularity through the bare definitional random-pair map source at a coarser deterministic proxy. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalMapSource_rawRangeMeasurableMeanRangeHistoryVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalMapSource_rawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged uniform variance ceiling from the policy-selected reward-coordinate selected-measure law. This is the policy-facing source-level companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_reward_map_eq_actual_action`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeUniformVarianceBoundedSource_of_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the policy-selected reward-coordinate selected-measure law plus the practical uniform-variance regularity package at any deterministic proxy that dominates the global variance ceiling. This is the policy-facing coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeUniformVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall context : Context, forall action : Action, varianceProxy context action <= varianceCeiling) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the actual-action reward-coordinate selected-measure law plus the practical raw/mean range regularity package and selected-history variance ceilings to obtain the succ-indexed conditional MGF witness. This is the reward-coordinate law-surface companion to the frozen-prefix extension-map history-variance conditional MGF wrapper.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_actual_action_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged selected-history variance ceiling from the actual-action reward-coordinate selected-measure law. This source-level wrapper preserves the reward-map law surface while exposing the reusable packaged history-variance source used by downstream conditional MGF consumers.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_reward_map_eq_actual_action {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the actual-action reward-coordinate selected-measure law plus the practical selected-history variance package at any deterministic proxy that dominates the selected ceiling at the requested time. This is the coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_actual_action_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_actual_action_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_actual_action : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the policy-selected reward-coordinate law plus the practical raw/mean range regularity package and selected-history variance ceilings to obtain the succ-indexed conditional MGF witness. This is the policy-facing history-variance counterpart of the actual-action reward-map wrapper: callers can state the reward law at `(policy i).action (state i history)` without first rewriting it to the generated successor action.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Build the practical definitional generated-policy raw-range source with a packaged selected-history variance ceiling from the policy-selected reward-coordinate selected-measure law. This is the policy-facing source-level companion to `generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_reward_map_eq_actual_action`.

def generatedActionRandomPairDefinitionalRawRangeMeasurableMeanRangeHistoryVarianceBoundedSource_of_reward_map_eq_selected_policy {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Directly consume the policy-selected reward-coordinate selected-measure law plus the practical selected-history variance package at any deterministic proxy that dominates the selected ceiling at the requested time. This is the policy-facing coarser-proxy companion to `centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded`.

theorem centeredReward_succ_hasCondSubgaussianMGF_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded_of_varianceCeiling_le {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsFiniteMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Fixed-horizon Azuma-Hoeffding tail for an ambient generated reward process whose successor reward-coordinate conditional laws are the policy-selected kernel laws. The process is zero at index zero and contains the centered rewards at indices `1, ..., n - 1`. Raw reward and selected-mean range contracts supply the regularity needed by the practical one-step conditional-MGF producer, while `varianceCeiling i` bounds its selected history-dependent variance proxy. This is a fixed-horizon aggregate tail, not an arm-wise empirical-mean, anytime, or regret theorem.

theorem centeredRewardSuccProcess_sum_tail_ennreal_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsProbabilityMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Delta-calibrated two-sided confidence bound for the ambient practical selected-policy reward-law route. The zero-initialized finite sum contains centered successor rewards at indices `1, ..., n - 1`. The all-time selected reward-coordinate conditional laws and practical raw/mean/history-variance contracts construct every conditional MGF witness; the generic conditional sub-Gaussian confidence theorem then uses the radius `sqrt (2 * totalVariance * log (2 / delta))`. Positive total proxy variance is explicit because the bad event uses non-strict comparison.

theorem centeredRewardSuccProcess_sum_abs_tail_ennreal_delta_of_reward_map_eq_selected_policy_definitionalRawRangeMeasurableMeanRangeHistoryVarianceBounded {Omega : Type u} {Context : Type v} {State : Type w} {Action : Type x} [mOmega : MeasurableSpace Omega] [StandardBorelSpace Omega] [MeasurableSpace Context] [MeasurableSpace State] [MeasurableSpace Action] [MeasurableSingletonClass Action] [Countable Action] (mu : MeasureTheory.Measure Omega) [MeasureTheory.IsProbabilityMeasure mu] (rewardKernel : RewardKernel.MarkovRewardKernel (Prod Context Action) Rat) (policy : Nat -> Policy.MeasurablePolicy State Action) (context : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> Context) (state : (n : Nat) -> ((j : Finset.Iic n) -> Rat) -> State) (mean : Context -> Action -> Rat) (varianceProxy : Context -> Action -> NNReal) (defaultAction : Action) (reward : Omega -> RewardTrace Rat) (hreward : forall t : Nat, Measurable (fun omega : Omega => reward omega t)) (rewardLo rewardHi meanLo meanHi : Nat -> Real) (varianceCeiling : Nat -> NNReal) (hcontext : forall n : Nat, Measurable (context n)) (hstate : forall n : Nat, Measurable (state n)) (hmean : Measurable (fun pair : Prod Context Action => mean pair.1 pair.2)) (hkernel : RewardKernel.CenteredRewardKernelLaw rewardKernel mean varianceProxy) (hraw : forall i : Nat, forall omega : Omega, Set.Icc (rewardLo i) (rewardHi i) (((reward omega (i + 1) : Rat) : Real))) (hmean_range : forall i : Nat, forall context : Context, forall action : Action, Set.Icc (meanLo i) (meanHi i) (((mean context action : Rat) : Real))) (hvariance : forall i : Nat, forall history : ((j : Finset.Iic i) -> Rat), varianceProxy (context i history) ((policy i).action (state i history)) <= varianceCeiling i) (h_reward_map_eq_policy : forall i : Nat, Filter.Eventually (fun omega : Omega => @MeasureTheory.Measure.map Omega Rat mOmega inferInstance (fun y : Omega => reward y (i + 1)) (@ProbabilityTheory.condExpKernel Omega mOmega _ mu _ ((History.historyFiltrationSucc (generatedActionFromRewardHistory policy state defaultAction reward) reward (generatedActionFromRewardHistory_measurable (policy

Number of selections of `arm` among successor coordinates `1, ..., n-1`.

def successorArmPullCount {Action : Type x} [DecidableEq Action] (action : ActionTrace Action) (arm : Action) (n : Nat) : Nat

The successor pull count is bounded by the enclosing process horizon.

theorem successorArmPullCount_le_horizon {Action : Type x} [DecidableEq Action] (action : ActionTrace Action) (arm : Action) (n : Nat) : successorArmPullCount action arm n <= n

Real reward sum from `arm` among successor coordinates `1, ..., n-1`.