import Determinize.Frontend.Syntaxnamespace Determinize.Frontendopen Spec.Paperdef prettyAffinity : Affinity → String | .E => "E" | .G => "G"def prettyType : Ty → String | .unit => "unit" | .bool => "bool" | .float m => s!"float[{prettyAffinity m}]" | .prod a b => s!"({prettyType a} * {prettyType b})" | .sum a b => s!"({prettyType a} + {prettyType b})" | .list a => s!"[{prettyType a}]" | .arr a b => s!"({prettyType a} -> {prettyType b})"private partial def decimalPlaces (denominator : Nat) : Option Nat := if denominator == 1 then some 0 else let factor := denominator.gcd 10 if factor ≤ 1 then none else (· + 1) <$> decimalPlaces (denominator / factor)private def literal (q : Rat) : String := if q.den == 1 then toString q.num else match decimalPlaces q.den with | none => s!"({q.num} / {q.den})" | some places => let scale := 10 ^ places let numerator := q.num.natAbs * (scale / q.den) let fraction := toString (numerator % scale) let padding := String.ofList (List.replicate (places - fraction.length) '0') s!"{if q.num < 0 then "-" else ""}{numerator / scale}.{padding}{fraction}"def leanAction : DistributionAction → String | .sample affinity => s!"(.sample .{prettyAffinity affinity})" | .mean => ".mean"/-- How `pretty` writes the site of a primitive: `head name site` is the head of theapplication, such as `uniform[E]`. -/class PrettySite (Site : Type) where head (name : String) : Site → Stringinstance : PrettySite DistributionAction where head name := fun | .sample affinity => s!"{name}[{prettyAffinity affinity}]" | .mean => "mean_" ++ nameinstance : PrettySite Affinity where head name affinity := s!"{name}[{prettyAffinity affinity}]"/-- A placeholder prints as an omitted affinity. -/instance : PrettySite (Option Affinity) where head name := fun | some affinity => s!"{name}[{prettyAffinity affinity}]" | none => nameprivate def primitive {Site : Type} [PrettySite Site] (name : String) (site : Site) (args : List String) : String := s!"{PrettySite.head name site}({String.intercalate ", " args})"private def render {Site : Type} [PrettySite Site] (env : List String) (depth : Nat) : Expr Rat Site → String | .bvar i => (env[i]?).getD s!"unbound_{i}" | .reject => "observe(false)" | .unit => "()" | .bool b => toString b | .real q => literal q | .lam b => let x := s!"x{depth}"; s!"(fun {x} => {render (x :: env) (depth + 1) b})" | .fix b => let f := s!"f{depth}"; let x := s!"x{depth}"; s!"(rec {f} {x} => {render (x :: f :: env) (depth + 1) b})" | .app a b => s!"({render env depth a} {render env depth b})" | .pair a b => s!"({render env depth a}, {render env depth b})" | .fst a => s!"(fst {render env depth a})" | .snd a => s!"(snd {render env depth a})" | .inl a => s!"(inl {render env depth a})" | .inr a => s!"(inr {render env depth a})" | .matchSum e a b => let x := s!"x{depth}"; s!"(match {render env depth e} with inl {x} => {render (x :: env) (depth + 1) a} \ | inr {x} => {render (x :: env) (depth + 1) b})" | .nil => "[]" | .cons h t => s!"({render env depth h} :: {render env depth t})" | .matchList e n c => let x := s!"x{depth}"; let xs := s!"xs{depth}"; s!"(match {render env depth e} with [] => {render env depth n} | {x} :: {xs} => \ {render (x :: xs :: env) (depth + 1) c})" | .ite c .unit .reject => s!"observe({render env depth c})" | .ite c a b => s!"(if {render env depth c} then {render env depth a} else {render env depth b})" | .letE a b => let x := s!"x{depth}"; s!"(let {x} = {render env depth a} in {render (x :: env) (depth + 1) b})" | .neg a => s!"(-{render env depth a})" | .add a b => s!"({render env depth a} + {render env depth b})" | .mul a b => s!"({render env depth a} * {render env depth b})" | .div a b => s!"({render env depth a} / {render env depth b})" | .lt a b => s!"({render env depth a} < {render env depth b})" | .uniform k a b => primitive "uniform" k [render env depth a, render env depth b] | .gaussian k a b => primitive "gauss" k [render env depth a, render env depth b] | .poisson k a => primitive "poisson" k [render env depth a] | .discrete k p => primitive "discrete_list" k [render env depth p] | .bernoulli k a => primitive "bernoulli" k [render env depth a] | .exponential k a => primitive "exponential" k [render env depth a] | .beta k a b => primitive "beta" k [render env depth a, render env depth b] | .gamma k a b => primitive "gamma" k [render env depth a, render env depth b]/-- Surface syntax, which the parser reads back as the same program unless the program has a meansite: the parser knows no `mean_<dist>` names. -/def pretty {Site : Type} [PrettySite Site] (e : Expr Rat Site) : String := render [] 0 e/-- Constructor syntax for independent kernel checking; every rational is parenthesized. -/def leanExpression : Core → String | .bvar index => s!"(.bvar {index})" | .reject => "(.reject)" | .unit => s!"(.unit)" | .bool value => s!"(.bool {value})" | .real value => s!"(.real (({value.num} : Rat) / {value.den}))" | .lam body => s!"(.lam {leanExpression body})" | .fix body => s!"(.fix {leanExpression body})" | .app fn arg => s!"(.app {leanExpression fn} {leanExpression arg})" | .pair left right => s!"(.pair {leanExpression left} {leanExpression right})" | .fst pairValue => s!"(.fst {leanExpression pairValue})" | .snd pairValue => s!"(.snd {leanExpression pairValue})" | .inl value => s!"(.inl {leanExpression value})" | .inr value => s!"(.inr {leanExpression value})" | .matchSum scrutinee left right => s!"(.matchSum {leanExpression scrutinee} {leanExpression left} {leanExpression right})" | .nil => s!"(.nil)" | .cons head tail => s!"(.cons {leanExpression head} {leanExpression tail})" | .matchList scrutinee nilCase consCase => s!"(.matchList {leanExpression scrutinee} {leanExpression nilCase} {leanExpression consCase})" | .ite condition thenBranch elseBranch => s!"(.ite {leanExpression condition} {leanExpression thenBranch} {leanExpression elseBranch})" | .letE value body => s!"(.letE {leanExpression value} {leanExpression body})" | .neg body => s!"(.neg {leanExpression body})" | .add left right => s!"(.add {leanExpression left} {leanExpression right})" | .mul left right => s!"(.mul {leanExpression left} {leanExpression right})" | .div left right => s!"(.div {leanExpression left} {leanExpression right})" | .lt left right => s!"(.lt {leanExpression left} {leanExpression right})" | .uniform action lower upper => s!"(.uniform {leanAction action} {leanExpression lower} {leanExpression upper})" | .gaussian action mean variance => s!"(.gaussian {leanAction action} {leanExpression mean} {leanExpression variance})" | .poisson action rate => s!"(.poisson {leanAction action} {leanExpression rate})" | .discrete action p => s!"(.discrete {leanAction action} {leanExpression p})" | .bernoulli action probability => s!"(.bernoulli {leanAction action} {leanExpression probability})" | .exponential action rate => s!"(.exponential {leanAction action} {leanExpression rate})" | .beta action alpha betaArg => s!"(.beta {leanAction action} {leanExpression alpha} {leanExpression betaArg})" | .gamma action shape rate => s!"(.gamma {leanAction action} {leanExpression shape} {leanExpression rate})"end Determinize.Frontend