import Determinize.Finite.Reward.Normalizeimport Determinize.Proof.FiniteModel.Equalityimport Determinize.Proof.FiniteModel.Progressnamespace Determinize.Proof.RewardModelopen Determinize.Finite Determinize.Finite.Rewardprivate def additive : Frame → Bool | .right .add (.number _) => true | _ => falseprivate theorem splitStack_cons (frame : Frame) (stack : List Frame) : splitStack (frame :: stack) = if (splitStack stack).1 = [] ∧ additive frame then ([], (match frame with | .right .add (.number c) => c | _ => 0) :: (splitStack stack).2) else (frame :: (splitStack stack).1, (splitStack stack).2) := by cases h : splitStack stack with | mk inner offsets => cases inner <;> cases frame <;> simp only [splitStack, h, additive, Bool.false_eq_true, and_false, ↓reduceIte, true_and, reduceCtorEq, and_self, false_and] case nil.right op value => cases op <;> cases value <;> simptheorem splitStack_reconstruct (stack : List Frame) : (splitStack stack).1 ++ ((splitStack stack).2.map fun c ↦ Frame.right .add (.number c)) = stack := by induction stack with | nil => rfl | cons frame stack ih => rw [splitStack_cons] split_ifs with h · rcases h with ⟨empty, add⟩ cases frame <;> simp only [additive, Bool.false_eq_true] at add case right op value => cases op <;> cases value <;> simp only [Bool.false_eq_true] at add simp_all · simpa using congrArg (List.cons frame) ihprivate theorem splitStack_inner (stack : List Frame) : splitStack (splitStack stack).1 = ((splitStack stack).1, []) := by induction stack with | nil => rfl | cons frame stack ih => rw [splitStack_cons] split_ifs with h · rfl · change splitStack (frame :: (splitStack stack).1) = _ rw [splitStack_cons, ih] rw [ite_eq_right h]private theorem splitStack_append (inner : List Frame) (offsets : List Rat) (clean : splitStack inner = (inner, [])) : splitStack (inner ++ offsets.map (fun c ↦ Frame.right .add (.number c))) = (inner, offsets) := by induction inner with | nil => induction offsets with | nil => rfl | cons c cs ih => simp only [List.nil_append] at ih ⊢ simp [splitStack, ih] | cons frame inner ih => rw [splitStack_cons] at clean split_ifs at clean with h · simp at clean · have eqs := Prod.mk.inj clean have hi : (splitStack inner).1 = inner := List.cons.inj eqs.1 |>.2 have hc : splitStack inner = (inner, []) := Prod.ext hi eqs.2 have blocked : ¬ (inner = [] ∧ additive frame) := by simpa [hi] using h rw [List.cons_append, splitStack_cons, ih hc] simp [blocked]theorem normalizeStack_idempotent (stack : List Frame) : normalizeStack (normalizeStack stack).2 = (0, (normalizeStack stack).2) := by have clean := splitStack_inner stack by_cases empty : (splitStack stack).2.isEmpty = true · simp [normalizeStack, empty, clean] · have hg := splitStack_append (splitStack stack).1 [0] clean simp only [List.map_cons, List.map_nil] at hg simp [normalizeStack, empty, Reward.guard, hg]theorem normalize_idempotent (state : State) : Reward.normalize (Reward.normalize state).2 = (0, (Reward.normalize state).2) := by cases state with | eval expression environment stack => simp only [Reward.normalize, normalizeStack_idempotent] | deliver value stack => simp only [Reward.normalize, normalizeStack_idempotent] | rejected => rflend Determinize.Proof.RewardModel