Source lean/Determinize/Finite/Reward/Export.lean
import Determinize.Finite.Exportimport Determinize.Proof.RewardModel.Soundnessimport Determinize.Finite.Reward.Solveimport Determinize.Proof.RewardModel.Momentsimport Determinize.Proof.FiniteModel.Evidenceimport Determinize.Proof.RewardModel.Sparsenamespace Determinize.Finite.Rewardopen Spec.FiniteModelprivate def rational (q : Rat) : String :=  if q.den == 1 then toString q.num else s!"{q.num}/{q.den}"private def leanRat (q : Rat) : String := s!"(({q.num} : Rat) / {q.den})"def candidateText (candidate : Candidate) : String :=  let (data, shared) := (Finite.Shared.rewardCandidate candidate).run {}  "import Determinize.Finite.Reward.Graph\n\n" ++  "open Determinize.Finite Determinize.Spec.Paper Determinize.Spec.FiniteModel\n\n" ++  "set_option maxRecDepth 100000\nset_option maxHeartbeats 0\nset_option Elab.async false\n\n" ++  shared.text datadef replayCertificateText (source : Spec.Paper.Core) (subject : Subject) (candidate : Candidate) :    String :=  (candidateText candidate).replace "import Determinize.Finite.Reward.Graph"    ("import Determinize.Proof.RewardModel.Soundness\n" ++      "import Determinize.Proof.FiniteModel.Evidence") ++  s!"\ndef checkedSource : Expr Rat := {Frontend.leanExpression source}\n" ++  s!"def checkedSubject : Subject := {reprStr subject}\n" ++  "\nabbrev rowClaim (i : Fin candidate.states.size) := candidate.StateReplayValid i\n" ++  Finite.proofTable "row" "rowClaim" "candidate.states.size" "allRows" candidate.states.size ++  "\ntheorem machineReplay : candidate.ReplayValid checkedSource checkedSubject :=\n" ++  "  candidate.replay_of_states checkedSource checkedSubject (by decide +kernel) allRows\n" ++  "\nabbrev model := candidate.toModel machineReplay\n" ++  "\ntheorem modelMatches : model.Matches (checkedSubject.program checkedSource) :=\n" ++  "  Determinize.Proof.RewardModel.replay_matches candidate machineReplay\n" ++  "\n#print axioms machineReplay\n#print axioms modelMatches\n"def controlCandidate (candidate : Candidate) : Finite.Candidate :=  {initial := candidate.initial, states := candidate.states, rows := candidate.rows.map fun row ↦    {kind := row.kind, edges := Id.run do      let mut edges : Array Finite.Edge := #[]      for e in row.edges do        if let some j := edges.findIdx? (fun existing ↦ existing.target == e.target) then          edges := edges.modify j            (fun existing ↦ {existing with probability := existing.probability + e.probability})        else edges := edges.push ⟨e.target, e.probability⟩      return edges}}def writeStorm (outputPath : System.FilePath) (candidate : Candidate) : IO Unit := do  let files ← IO.ofExcept (Finite.render (controlCandidate candidate) false)  let mut edgeText := "additive-rewards 1\n"  for (row, i) in candidate.rows.toList.zipIdx do    for edge in row.edges do      edgeText := edgeText ++        s!"{i} {edge.target} {rational edge.probability} {rational edge.reward}\n"  if let some parent := outputPath.parent then IO.FS.createDirAll parent  for (suffix, content) in [(".tra", files.transitions),      (".lab", files.labels), (".positive.state.rew", files.positiveRewards),      (".negative.state.rew", files.negativeRewards), (".additive.edges", edgeText)] do    IO.FS.writeFile (outputPath.toString ++ suffix) contentdef write (outputPath : System.FilePath) (source : Spec.Paper.Core) (subject : Subject)    (candidate : Candidate) (_valid : candidate.ReplayValid source subject) : IO Unit := do  writeStorm outputPath candidate  IO.FS.writeFile (outputPath.toString ++ ".candidate.lean") (candidateText candidate)  IO.FS.writeFile (outputPath.toString ++ ".replay.lean")    (replayCertificateText source subject candidate)def resultCertificateText (source : Spec.Paper.Core) (subject : Subject) (candidate : Candidate)    (model : Spec.RewardModel.Model) (solution : Solution model) : String :=  let vector (name : String) (values : Fin model.size → Rat) :=    s!"\ndef {name} : Vector Rat model.size := ⟨#[{String.intercalate ",      " ((List.ofFn values).map leanRat)}], by rfl⟩\n"  let dead := String.intercalate ", " ((List.ofFn solution.boundary.dead).map toString)  let ranks := String.intercalate ", " ((List.ofFn solution.paths.rank).map toString)  let next := String.intercalate ", "      ((List.ofFn solution.paths.next).map fun j ↦ s!"⟨{j.val}, by decide +kernel⟩")  (replayCertificateText source subject candidate).replace    "import Determinize.Proof.RewardModel.Soundness"    ("import Determinize.Proof.RewardModel.Soundness\n" ++      "import Determinize.Proof.RewardModel.Sparse") ++  vector "massValues" solution.mass ++ vector "firstValues" solution.first ++  vector "secondValues" solution.second ++ vector "rejectionValues" solution.rejection ++  s!"\ndef deadStates : Vector Bool model.size := ⟨#[{dead}], by rfl⟩\n" ++  s!"def ranks : Vector Nat model.size := ⟨#[{ranks}], by rfl⟩\n" ++  s!"def nextStates : Vector (Fin model.size) model.size := ⟨#[{next}], by rfl⟩\n" ++  "\ndef certificate : Determinize.Proof.RewardModel.Certificate model.size :=\n" ++  "  Determinize.Proof.RewardModel.Certificate.ofVectors\n" ++  "    deadStates ranks nextStates massValues firstValues secondValues rejectionValues\n" ++  "\nabbrev resultClaim (i : Fin model.size) := certificate.StateValid model i\n" ++  Finite.proofTable "result" "resultClaim" "model.size" "allResults" model.size ++  "\ndef solution := certificate.solution model allResults\n" ++  "\nabbrev statistics := solution.statistics\n" ++  "\ntheorem checkedResult : Determinize.Spec.RewardModel.ResultMatches model\n" ++  "    (checkedSubject.program checkedSource) statistics :=\n" ++  "  Determinize.Proof.RewardModel.solution_result model _ modelMatches solution\n" ++  "\ntheorem integrability : MeasureTheory.Integrable (fun x : ℝ => x)\n" ++  "    (bigStepMeasure (checkedSubject.program checkedSource)) ∧\n" ++  "    MeasureTheory.Integrable (fun x : ℝ => x^2) (bigStepMeasure (checkedSubject.program \      checkedSource)) := by\n" ++  "  simpa only [modelMatches.2] using Determinize.Proof.RewardModel.integrable_outputMeasure \      model\n" ++  "\ntheorem outputStatistics : statistics.Matches (bigStepMeasure (checkedSubject.program \      checkedSource)) := by\n" ++  "  simpa only [modelMatches.2] using Determinize.Proof.RewardModel.solution_statistics model \      solution\n" ++  "\ntheorem conditionalVariance (positive : 0 < statistics.returnMass) :\n" ++  "    ProbabilityTheory.variance id ((bigStepMeasure (checkedSubject.program checkedSource) \      Set.univ)⁻¹ •\n" ++  "      bigStepMeasure (checkedSubject.program checkedSource)) =\n" ++  "      ((statistics.secondMoment / statistics.returnMass - (statistics.firstMoment / \      statistics.returnMass)^2 : Rat) : ℝ) := by\n" ++  "  simpa only [modelMatches.2] using Determinize.Proof.RewardModel.solution_conditional_variance \      model solution positive\n" ++  "\ntheorem terminationProbabilities : (⟨solution.mass model.initial, solution.rejection \      model.initial,\n" ++  "    1-solution.mass model.initial-solution.rejection model.initial⟩ : \      TerminationStatistics).Matches model.control :=\n" ++  "  Determinize.Proof.RewardModel.solution_termination model solution\n" ++  "\n#print axioms checkedResult\n#print axioms integrability\n#print axioms outputStatistics\n" ++  "#print axioms conditionalVariance\n#print axioms terminationProbabilities\n" ++  Finite.printedText solution.statisticsdef writeResult (outputPath : System.FilePath) (source : Spec.Paper.Core) (subject : Subject)    (candidate : Candidate) (valid : candidate.ReplayValid source subject)    (limits : SolveLimits := {}) : IO Rat := do  let model := candidate.toModel valid  let solution ← IO.ofExcept (solve model limits)  let statistics := solution.statistics  let optional := fun value : Option Rat ↦ match value with    | none => Lean.Json.null | some q => Lean.toJson (rational q)  let metadata := Lean.Json.mkObj [    ("answer", Lean.toJson (rational statistics.firstMoment)),    ("return_mass", Lean.toJson (rational statistics.returnMass)),    ("kernel_checked", Lean.toJson false),    ("certificate_status", Lean.toJson "generated"),    ("termination_statistics_scope", Lean.toJson "graph"),    ("rejection_probability", Lean.toJson (rational (solution.rejection model.initial))),    ("divergence_probability",      Lean.toJson (rational (1 - statistics.returnMass - solution.rejection model.initial))),    ("second_moment", Lean.toJson (rational statistics.secondMoment)),    ("conditional_mean", optional statistics.conditionalMean),    ("conditional_variance", optional statistics.conditionalVariance),    ("subject", Lean.toJson (if subject == .source then "source" else "determinized")),    ("mode", Lean.toJson "additive"), ("states", Lean.toJson model.size),    ("rank_bound", Lean.toJson ((List.ofFn solution.paths.rank).foldl max 0))]  write outputPath source subject candidate valid  IO.FS.writeFile (outputPath.toString ++ ".result.lean")    (resultCertificateText source subject candidate model solution)  IO.FS.writeFile (outputPath.toString ++ ".result.json") (metadata.pretty ++ "\n")  return statistics.firstMomentend Determinize.Finite.Reward