diff --git a/Complexity/Computability/Complexity/Classes/IP.lean b/Complexity/Computability/Complexity/Classes/IP.lean index d583e0f90d..6397d886b1 100644 --- a/Complexity/Computability/Complexity/Classes/IP.lean +++ b/Complexity/Computability/Complexity/Classes/IP.lean @@ -92,7 +92,7 @@ interacts with `P` starting from the prover state `s`. Private coins are fresh f noncomputable def run (program : WordOracleComp Operation α) (s : P.State) : PMF (α × P.State) := (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) P.respond) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) P.respond) program).run s /-- `Prover.run` is the run against the prover as a stateful oracle with word queries and diff --git a/Complexity/Computability/Complexity/Classes/IP/CoinFixing.lean b/Complexity/Computability/Complexity/Classes/IP/CoinFixing.lean index fcf771f04f..1bd507ef38 100644 --- a/Complexity/Computability/Complexity/Classes/IP/CoinFixing.lean +++ b/Complexity/Computability/Complexity/Classes/IP/CoinFixing.lean @@ -91,7 +91,7 @@ variable {S : Type} (oracle : Operation × List Bool → StateT S PMF (List Bool /-- The handler of the private coins and of the prover `o`. -/ local notation "handler" o => - ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) o + OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) o /-- An instruction with a fixed coin makes the requests of `coinStep`. -/ private theorem run_interpret_finiteStep_pure (t : ℕ) @@ -188,10 +188,10 @@ the programs of fixed coins. -/ theorem acceptProb_eq_sum {V : WordOracleComp Operation Bool} {t : ℕ} {x : List Bool} (hV : ∀ (S : Type) (oracle : Operation × List Bool → StateT S PMF (List Bool)) s, (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (Turing.MultiTapeTM.encBool <$> V)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (M.runOracle t x)).run s) (P : Prover Operation) : acceptProb V P = @@ -201,7 +201,7 @@ theorem acceptProb_eq_sum {V : WordOracleComp Operation Bool} {t : ℕ} {x : Lis (hV P.State P.respond P.init) rw [OracleComp.interpret_map, StateT.run_map, run_interpret_runOracle_eq_coins, _root_.PMF.monad_map_eq_map, PMF.map_comp] at h - have hl : acceptProb V P = ((OracleComp.interpret (ProbOracleComp.handler + have hl : acceptProb V P = ((OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) P.respond) V).run P.init).map ((fun z => decide (z.1 = [true])) ∘ fun p => (Turing.MultiTapeTM.encBool p.1, p.2)) true := by diff --git a/Complexity/Computability/Complexity/Classes/IP/PSPACE.lean b/Complexity/Computability/Complexity/Classes/IP/PSPACE.lean index c325dad0c0..f727b4b2a9 100644 --- a/Complexity/Computability/Complexity/Classes/IP/PSPACE.lean +++ b/Complexity/Computability/Complexity/Classes/IP/PSPACE.lean @@ -562,10 +562,10 @@ theorem mem_iff_two_pow_lt_value {V : α → WordOracleComp Unit Bool} {A : Set {M : MultiTapePTM k Bool Control Unit} {fuel : α → ℕ} (hV : ∀ a (S : Type) (oracle : Unit × List Bool → StateT S PMF (List Bool)) s, (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (encBool <$> V a)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (M.runOracle (fuel a) (enc a))).run s) (hA : IsInteractiveProof V A (2 / 3) (1 / 3)) (a : α) : a ∈ A ↔ 2 ^ fuel a < 2 * value (coinFamily M (fuel a) (enc a)) (fuel a) (fuel a) [] := by diff --git a/Complexity/Computability/Complexity/Classes/Oracle/Deterministic.lean b/Complexity/Computability/Complexity/Classes/Oracle/Deterministic.lean index 791faaed65..65a2fe0a58 100644 --- a/Complexity/Computability/Complexity/Classes/Oracle/Deterministic.lean +++ b/Complexity/Computability/Complexity/Classes/Oracle/Deterministic.lean @@ -87,7 +87,7 @@ oracle's state. -/ private theorem run_interpret_interpret_query {σ : Type} (answer : Operation × List Bool → List Bool) (program : WordQueryComp Operation β) (s : σ) : - (OracleComp.interpret (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q s => PMF.pure (answer q, s))) (OracleComp.interpret ProbOracleComp.query program)).run s = PMF.pure (OracleComp.interpret (m := Id) answer program, s) := by @@ -123,7 +123,7 @@ theorem exists_run_pure_false {program : α → WordQueryComp Operation β} (c * ((input a).length + 1) ^ d) (machine.initialConfig (input a)) have hmem' : (OracleComp.interpret (m := Id) answer (machine.run (pure false) (fun op word => OracleComp.query (op, word)) (c * ((input a).length + 1) ^ d) (input a)), - ()) ∈ ((OracleComp.interpret (ProbOracleComp.handler + ()) ∈ ((OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q s => PMF.pure (answer q, s))) (machine.runOracle (c * ((input a).length + 1) ^ d) (input a))).run ()).support := by simp only [MultiTapePTM.runOracle, MultiTapePTM.run, MultiTapePTM.runFrom, diff --git a/Complexity/Computability/Complexity/Classes/Oracle/Exponential.lean b/Complexity/Computability/Complexity/Classes/Oracle/Exponential.lean index 9c6bf05e1f..c0e00fd4d4 100644 --- a/Complexity/Computability/Complexity/Classes/Oracle/Exponential.lean +++ b/Complexity/Computability/Complexity/Classes/Oracle/Exponential.lean @@ -87,10 +87,10 @@ def IsOracleExpTimeOn {Operation α β : Type} [DecidableEq Operation] (machine : Turing.MultiTapePTM k Bool Control Operation) (c d : ℕ), ∀ a (State : Type) (oracle : Operation × List Bool → StateT State PMF (List Bool)) s, (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (output <$> program a)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracle (c * 2 ^ (d * (input a).length)) (input a))).run s namespace IsOracleExpTimeOn diff --git a/Complexity/Computability/Complexity/Classes/Oracle/Monotone.lean b/Complexity/Computability/Complexity/Classes/Oracle/Monotone.lean index 7b70a7ed7d..fb42fdd9bc 100644 --- a/Complexity/Computability/Complexity/Classes/Oracle/Monotone.lean +++ b/Complexity/Computability/Complexity/Classes/Oracle/Monotone.lean @@ -82,7 +82,7 @@ theorem ComputableInPolyTimeWithOracle.of_polyTimeReducible {A B : Set (List Boo fun a State oracle s => ?_ congr 2 rw [OracleComp.interpret_interpret, OracleComp.interpret_interpret] - have hH : (fun q : Unit × List Bool => OracleComp.interpret (ProbOracleComp.handler + have hH : (fun q : Unit × List Bool => OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (fun (q : Unit × List Bool) (_ : Unit) => (fun r => (r, ())) <$> (List.take 1 <$> ProbOracleComp.query (spec := fun _ : Unit × List Bool => List Bool) ((), g q.2)))) diff --git a/Complexity/Computability/Complexity/Classes/Oracle/PP.lean b/Complexity/Computability/Complexity/Classes/Oracle/PP.lean index 353bda9f10..4897584669 100644 --- a/Complexity/Computability/Complexity/Classes/Oracle/PP.lean +++ b/Complexity/Computability/Complexity/Classes/Oracle/PP.lean @@ -404,7 +404,7 @@ theorem PWithSharpPOracle_subset_PWithPPOracle : PWithSharpPOracle enc ⊆ PWith fun a State oracle s => ?_ congr 2 rw [OracleComp.interpret_interpret, OracleComp.interpret_interpret] - have hH : (fun q : Unit × List Bool => OracleComp.interpret (ProbOracleComp.handler + have hH : (fun q : Unit × List Bool => OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (fun (q : Unit × List Bool) (_ : Unit) => (fun reply => (reply, ())) <$> OracleComp.interpret ProbOracleComp.query (bitQuery r q))) diff --git a/Complexity/Computability/Interactive/Basic.lean b/Complexity/Computability/Interactive/Basic.lean index 5480aa8a94..3c0ac5f1f6 100644 --- a/Complexity/Computability/Interactive/Basic.lean +++ b/Complexity/Computability/Interactive/Basic.lean @@ -192,7 +192,7 @@ variable {ιP ιV : Type} {oP : OracleSpec ιP} {oV : OracleSpec ιV} /-- Lift a prover computation into the joint oracles. -/ def liftProver {α : Type} : ProbOracleComp oP α → ProbOracleComp (oP ⊕ₒ oV) α := - OracleComp.interpret (ProbOracleComp.handler + OracleComp.interpret (OracleComp.sumHandler (fun n => OracleComp.query (spec := probOracleSpec (oP ⊕ₒ oV)) (.inl n)) (fun q => ProbOracleComp.query (spec := oP ⊕ₒ oV) (.inl q))) diff --git a/Complexity/Computability/Interactive/Plain.lean b/Complexity/Computability/Interactive/Plain.lean index 1853d24207..b5957eb061 100644 --- a/Complexity/Computability/Interactive/Plain.lean +++ b/Complexity/Computability/Interactive/Plain.lean @@ -45,30 +45,30 @@ open Spec /-- The law of a program without external oracles: its private coins are fair. -/ noncomputable def plainLaw {α : Type} (p : ProbOracleComp OracleSpec.empty α) : PMF α := - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifOracle fun e => e.elim) p + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifOracle fun e => e.elim) p /-- The law of a joint program in the plain model. -/ private noncomputable def runLaw {α : Type} (p : ProbOracleComp (OracleSpec.empty ⊕ₒ OracleSpec.empty) α) : PMF α := - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifOracle + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifOracle (OracleComp.sumHandler (fun e => e.elim) fun e => e.elim)) p private theorem plain_eval {α : Type} (p : ProbOracleComp (OracleSpec.empty ⊕ₒ OracleSpec.empty) α) : World.plain.eval p = runLaw p := by have h := OracleComp.run_interpret_stateless (m := PMF) (State := Unit) - (ProbOracleComp.handler ProbComp.unifOracle + (OracleComp.sumHandler ProbComp.unifOracle (OracleComp.sumHandler (fun e => e.elim) fun e => e.elim)) p () - have hh : (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + have hh : (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) World.plain.impl) = - fun q s => (fun a => (a, s)) <$> ProbOracleComp.handler ProbComp.unifOracle + fun q s => (fun a => (a, s)) <$> OracleComp.sumHandler ProbComp.unifOracle (OracleComp.sumHandler (fun e => e.elim) fun e => e.elim) q := by funext q s rcases q with n | e | e · rfl · exact e.elim · exact e.elim - unfold World.eval ProbOracleComp.runWith + unfold World.eval ProbOracleComp.runWith OracleComp.runWith erw [hh, h] exact (PMF.map_comp _ _ _).trans (PMF.map_id _) @@ -78,7 +78,7 @@ private theorem runLaw_liftProver {α : Type} (p : ProbOracleComp OracleSpec.emp congr 1 funext q rcases q with n | e - · simp [ProbOracleComp.handler] + · simp [OracleComp.sumHandler] · exact e.elim diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/IterateWhile.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/IterateWhile.lean index 93e16b9896..af49326c3f 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/IterateWhile.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/IterateWhile.lean @@ -259,7 +259,7 @@ theorem RunsWords.iterateWhileRound {tm : MultiTapePTM k Bool State Operation} ( (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) (w' : List Bool) (s' : OracleState), (w', s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support → w'.length ≤ l) (out₀ : List Bool) : (tm.iterateWhileRound mark).RunsWords x (words vp v) out₀ (3 * vp.length + 6 * v.length + 16 + (t + l + 6)) program (fun v' => words v v') @@ -287,7 +287,7 @@ public theorem ComputesTidily.iterateWhile {tm : MultiTapePTM k Bool State Opera ∀ (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState) (w' : List Bool), (w', s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (step w)).run s).support → invariant (n + 1) w' ∧ w' ≠ []) (hlast : ∀ w, invariant r w → tm.ComputesTidily w t (pure [])) (hlength : ∀ n ≤ r, ∀ w, invariant n w → w.length ≤ L) : @@ -305,7 +305,7 @@ public theorem ComputesTidily.iterateWhile {tm : MultiTapePTM k Bool State Opera ∀ (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (st st' : OracleState) (p' : List Bool × List Bool), (p', st') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (step' p)).run st).support → inv (n + 1) p' ∧ words (k := k) p'.1 p'.2 (nextTape k) ≠ [] := by intro n hn p hp _ oracle st st' p' hp' @@ -324,7 +324,7 @@ public theorem ComputesTidily.iterateWhile {tm : MultiTapePTM k Bool State Opera (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) (w' : List Bool) (s' : OracleState), (w', s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (step p.2)).run s).support → w'.length ≤ L := fun _ oracle s w' s' hw' => hlength (n + 1) hn w' (hpreserve n hn p.2 hp.1 _ oracle s s' w' hw').1 @@ -356,7 +356,7 @@ public theorem ComputesTidily.iterateWhile {tm : MultiTapePTM k Bool State Opera (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState) (p : List Bool × List Bool), (p, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (OracleComp.iterate r step' ([], w₀) >>= last)).run s).support → p.2 = [] ∧ p.1.length ≤ L := by intro _ oracle s s' p hp diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Loop.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Loop.lean index 6649b6c25d..aff9938ccd 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Loop.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Loop.lean @@ -144,21 +144,21 @@ absorbed because the remaining loop halts within its own clock. -/ theorem run_interpret_runOracleConfigFrom_add (cfg : Config k Bool State Operation x) (fuel rest : ℕ) (s : OracleState) (hrest : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (body.runOracleConfigFrom fuel cfg)).run s).support, ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((repeatUntilBlank i body).runOracleConfigFrom rest (runConfig result.1))).run result.2).support, final.1.tapes.state = none) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((repeatUntilBlank i body).runOracleConfigFrom (fuel + rest) (runConfig cfg))).run s = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (body.runOracleConfigFrom fuel cfg)).run s).bind (fun result => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((repeatUntilBlank i body).runOracleConfigFrom rest (runConfig result.1))).run result.2) := by induction fuel generalizing cfg s with @@ -266,7 +266,7 @@ theorem RunsWords.repeatUntilBlank_round (i : Fin k) {body : MultiTapePTM k Bool (h₂ : ∀ a (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (a, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → (fromCheck i body).RunsWords x (ws₁ a) (out₀ ++ emit₁ a) t₂ (prog₂ a) (ws₂ a) (emit₂ a)) : (repeatUntilBlank i body).RunsWords x ws₀ out₀ (t₁ + t₂) @@ -291,10 +291,10 @@ theorem RunsWords.repeatUntilBlank_round (i : Fin k) {body : MultiTapePTM k Bool simp only [runConfig, hmid, f, mapState_wordsCfg, Option.elim_none] rfl have hrest : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (body.runOracleConfigFrom t₁ cfg₀)).run s).support, ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((repeatUntilBlank i body).runOracleConfigFrom t₂ (runConfig result.1))).run result.2).support, final.1.tapes.state = none := by @@ -311,7 +311,7 @@ theorem RunsWords.repeatUntilBlank_round (i : Fin k) {body : MultiTapePTM k Bool PMF (Cfg k Bool (RepeatUntilBlankState State) x × OracleState) := if h : ∃ a, p.1 = f a then ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (prog₂ (Classical.choose h))).run p.2).map (fun (b, s₂) => (wordsCfg x none (ws₂ (Classical.choose h) b) @@ -320,7 +320,7 @@ theorem RunsWords.repeatUntilBlank_round (i : Fin k) {body : MultiTapePTM k Bool have hg (a : α) (s₁ : OracleState) : g (f a, s₁) = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (prog₂ a)).run s₁).map (fun (b, s₂) => (wordsCfg x none (ws₂ a b) (out₀ ++ (emit₁ a ++ emit₂ a b)), s₂)) := by @@ -330,16 +330,16 @@ theorem RunsWords.repeatUntilBlank_round (i : Fin k) {body : MultiTapePTM k Bool simp only [hex, ↓reduceDIte, hchoose] have hcongr : ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (body.runOracleConfigFrom t₁ cfg₀)).run s).bind (fun result => PMF.map (fun (final, s') => (final.tapes, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((repeatUntilBlank i body).runOracleConfigFrom t₂ (runConfig result.1))).run result.2)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (body.runOracleConfigFrom t₁ cfg₀)).run s).bind (fun result => g (result.1.tapes, result.2)) := by apply PMF.bind_congr_on_support @@ -356,11 +356,11 @@ theorem RunsWords.repeatUntilBlank_round (i : Fin k) {body : MultiTapePTM k Bool rw [hcongr] have hmapBind : ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (body.runOracleConfigFrom t₁ cfg₀)).run s).bind (fun result => g (result.1.tapes, result.2)) = (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (body.runOracleConfigFrom t₁ cfg₀)).run s).map (fun (final, s') => (final.tapes, s'))).bind g := by rw [PMF.bind_map] @@ -396,13 +396,13 @@ theorem RunsWords.repeatUntilBlank (i : Fin k) {body : MultiTapePTM k Bool State ∀ (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (st st' : OracleState) (s' : σ), (s', st') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (step s)).run st).support → invariant (n + 1) s' ∧ ws s' i ≠ []) (hstop : ∀ s, invariant rounds s → ∀ (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (st st' : OracleState) (s' : σ), (s', st') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (last s)).run st).support → ws s' i = []) : (repeatUntilBlank i body).RunsWords x (ws s₀) out₀ ((rounds + 1) * (t + 1)) (OracleComp.iterate rounds step s₀ >>= last) ws (fun _ => []) := by diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Oracle.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Oracle.lean index fe61b5fe59..0e50f676b5 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Oracle.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Oracle.lean @@ -59,13 +59,13 @@ theorem length_output_runOracle_le (machine : MultiTapePTM k Symbol State Operat (oracle : Operation × List Symbol → StateT OracleState PMF (List Symbol)) (fuel : ℕ) (input output : List Symbol) (s s' : OracleState) (h : (output, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracle fuel input)).run s).support) : output.length ≤ fuel := by have hbound := MultiTapeMachine.length_output_runFrom_le machine (fun choices => choices <$> ProbOracleComp.sample (ProbComp.uniform Bool)) (fun op word => ProbOracleComp.query (spec := fun _ : Operation × List Symbol => List Symbol) (op, word)) - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) fuel + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) fuel (machine.initialConfig input) s s' output h simpa only [initialConfig, Cfg.init, List.length_nil, Nat.zero_add] using hbound @@ -74,13 +74,13 @@ theorem run_interpret_runOracle_ofDeterministic (machine : MultiTapeTM k Symbol (oracle : Operation × List Symbol → StateT OracleState PMF (List Symbol)) (fuel : ℕ) (input : List Symbol) (s : OracleState) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((ofDeterministic machine).runOracle fuel input)).run s = PMF.pure ((machine.runFrom (machine.initCfg input) fuel).output, s) := by apply run_interpret_ofDeterministic machine (ProbOracleComp.sample (ProbComp.uniform Bool)) (fun op word => ProbOracleComp.query (spec := fun _ : Operation × List Symbol => List Symbol) (op, word)) - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (PMF.uniformOfFintype Bool) intro state simp only [ProbOracleComp.run_interpret_sample, ProbComp.eval_uniform] @@ -156,7 +156,7 @@ theorem run_interpret_runOracle_ofClosed (machine : MultiTapePTM k Bool State) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (fuel : ℕ) (input : List Bool) (s : OracleState) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((ofClosed machine).runOracle fuel input)).run s = (ProbComp.eval (machine.runClosed fuel input)).map (·, s) := by rw [runOracle_ofClosed, ProbOracleComp.run_interpret_sample] diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryBounds.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryBounds.lean index 7c0e352266..de20ff2647 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryBounds.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryBounds.lean @@ -59,7 +59,7 @@ theorem query_bounds_runFrom (machine : MultiTapePTM k Symbol Control Operation) (fun _ : Query => List Symbol)) (output : List Symbol) (htranscript : ∀ entry ∈ transcript, size entry.1 ≤ bound) (h : (output, s', transcript') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (OracleComp.withTranscript oracle)) (machine.runFrom (ProbOracleComp.sample (ProbComp.uniform Bool)) (fun op word => ProbOracleComp.query (request op word)) fuel cfg)).run @@ -127,7 +127,7 @@ theorem query_bounds_runOracle (machine : MultiTapePTM k Symbol Control Operatio (s s' : State) (output : List Symbol) (transcript : OracleComp.Transcript (fun _ : Operation × List Symbol => List Symbol)) (h : (output, s', transcript) ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (OracleComp.withTranscript oracle)) (machine.runOracle fuel input)).run (s, [])).support) : transcript.length ≤ fuel ∧ ∀ entry ∈ transcript, entry.1.2.length ≤ fuel := by diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryTake.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryTake.lean index 625737b36b..18b7fe74ac 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryTake.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/QueryTake.lean @@ -175,7 +175,7 @@ theorem run_copyReply (x : List Bool) (pos : ℕ) (answer out : List Bool) (ch : Operation → Channel Bool) (_hch : ch op = ⟨[], answer, (pos : ℤ)⟩) (s : OracleState), (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((queryTakeCore op).runOracleConfigFrom (remLimit + 1) (config x (some .copyReply) pre.length (by subst h; simp) out ch))).run s = PMF.pure @@ -264,7 +264,7 @@ theorem run_frame (x : List Bool) ∀ (pre suf : List Bool) (h : x = pre ++ frame rem ++ suf) (out : List Bool) (ch : Operation → Channel Bool) (s : OracleState), (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((queryTakeCore op).runOracleConfigFrom (2 * rem.length + 2) (config x (some .marker) pre.length (by subst h; simp) out ch))).run s = (oracle (op, (ch op).queryBuffer ++ rem) s).map @@ -294,7 +294,7 @@ theorem run_frame (x : List Bool) rw [moveInputPos_pos_of_ne_right _ (by simp only [config]; lia)] rfl change (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((queryTakeCore op).runOracleConfigFrom (0 + 1 + 1) (config x (some .marker) pre.length hlt.le out ch))).run s = _ rw [run_interpret_runOracleConfigFrom_succ_step (queryTakeCore op) oracle (0 + 1) @@ -412,7 +412,7 @@ theorem computesTidily_queryTakePTM (op : Operation) (q : List Bool) (limit : -- Combine `run_frame` and `run_copyReply` for `queryTakeCore op` have hcore : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((queryTakeCore op).runOracleConfigFrom tCore cfg₀)).run s = (oracle (op, q) s).map (fun (answer, s') => @@ -434,7 +434,7 @@ theorem computesTidily_queryTakePTM (op : Operation) (q : List Bool) (limit : dsimp only [runOracleConfigFrom, runConfigFrom] at hcopy simpa only [List.drop_zero, Nat.cast_zero, zero_add, Function.update_idem] using hcopy have hhalt₁ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((queryTakeCore op).runOracleConfigFrom tCore cfg₀)).run s).support, result.1.tapes.state = none := by intro result hresult @@ -455,10 +455,10 @@ theorem computesTidily_queryTakePTM (op : Operation) (q : List Bool) (limit : exact (runFrom_rewindInput ⟨x.length + 1, by lia⟩ Fin.elim0 Fin.elim0 (out₀ ++ answer.take limit)).trans (Cfg.ext_zero_tapes rfl rfl rfl) have hhalt₂ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((queryTakeCore op).runOracleConfigFrom tCore cfg₀)).run s).support, ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((ofDeterministic (rewindInput Bool)).runOracleConfigFrom tRew (Sequential.start (ofDeterministic (rewindInput Bool)) result.1))).run result.2).support, final.1.tapes.state = none := by diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Replay/Deterministic.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Replay/Deterministic.lean index 6a238f4d7f..7cbf1d4927 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Replay/Deterministic.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Replay/Deterministic.lean @@ -134,7 +134,7 @@ theorem mem_support_runConfigFrom_pure {σ : Type} (machine : MultiTapePTM k Sym (cfg : Config k Symbol State Oracle input) : (OracleComp.interpret (m := Id) answer (machine.runConfigFrom (pure bit) (fun oracle word => OracleComp.query (oracle, word)) fuel cfg), s) ∈ - ((OracleComp.interpret (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + ((OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q s => PMF.pure (answer q, s))) (machine.runConfigFrom (ProbOracleComp.sample (ProbComp.uniform Bool)) (fun oracle word => ProbOracleComp.query (oracle, word)) fuel cfg)).run s).support := by diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/RunsWords.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/RunsWords.lean index a9a5a1452e..08b14456ac 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/RunsWords.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/RunsWords.lean @@ -92,7 +92,7 @@ omit [DecidableEq Operation] in theorem run_interpret_sample_uniform_bool (oracle : Operation × List Symbol → StateT OracleState PMF (List Symbol)) (s : OracleState) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (ProbOracleComp.sample (ProbComp.uniform Bool))).run s = (PMF.uniformOfFintype Bool).map (fun bit => (bit, s)) := by simp only [ProbOracleComp.run_interpret_sample, ProbComp.eval_uniform] @@ -104,14 +104,14 @@ theorem run_interpret_runOracleConfigFrom_add_of_halted (oracle : Operation × List Symbol → StateT OracleState PMF (List Symbol)) (cfg : Config k Symbol State Operation input) (fuel padding : ℕ) (s : OracleState) (hhalt : ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom fuel cfg)).run s).support, final.1.tapes.state = none) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom (fuel + padding) cfg)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom fuel cfg)).run s := MultiTapeMachine.run_interpret_runConfigFrom_add_of_halted machine _ _ _ cfg fuel padding s hhalt @@ -123,14 +123,14 @@ theorem run_interpret_runOracleConfigFrom_eq_of_halted (cfg : Config k Symbol State Operation input) {fuel larger : ℕ} (hle : fuel ≤ larger) (s : OracleState) (hhalt : ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom fuel cfg)).run s).support, final.1.tapes.state = none) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom larger cfg)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom fuel cfg)).run s := by simpa only [Nat.add_sub_of_le hle] using run_interpret_runOracleConfigFrom_add_of_halted machine oracle cfg fuel (larger - fuel) s hhalt @@ -141,7 +141,7 @@ theorem run_interpret_runOracleConfigFrom_ofDeterministic (oracle : Operation × List Symbol → StateT OracleState PMF (List Symbol)) (fuel : ℕ) (cfg : Config k Symbol State Operation input) (s : OracleState) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((ofDeterministic machine).runOracleConfigFrom fuel cfg)).run s = PMF.pure ({ cfg with tapes := machine.runFrom cfg.tapes fuel }, s) := run_interpret_runConfigFrom_ofDeterministic machine _ _ _ (PMF.uniformOfFintype Bool) @@ -154,24 +154,24 @@ theorem run_interpret_runOracleConfigFrom_seq (oracle : Operation × List Symbol → StateT OracleState PMF (List Symbol)) (cfg : Config k Symbol State₀ Operation input) (t₁ t₂ : ℕ) (s : OracleState) (h₁ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg)).run s).support, result.1.tapes.state = none) (h₂ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg)).run s).support, ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (second.runOracleConfigFrom t₂ (Sequential.start second result.1))).run result.2).support, final.1.tapes.state = none) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((first.seq second).runOracleConfigFrom (t₁ + t₂) (Sequential.left second cfg))).run s = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg)).run s).bind (fun result => ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (second.runOracleConfigFrom t₂ (Sequential.start second result.1))).run result.2).map (fun (final, s') => (Sequential.right final, s'))) := @@ -190,10 +190,10 @@ theorem run_interpret_runOracleConfigFrom_succ_step machine.tr state cfg.tapes.inputSymbol cfg.tapes.workTapeSymbols cfg.answerSymbols bit = .step action symbol move) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom (fuel + 1) cfg)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom fuel (cfg.step action symbol move))).run s := by dsimp only [runOracleConfigFrom, runConfigFrom] rw [MultiTapeMachine.runConfigFrom] @@ -213,11 +213,11 @@ theorem run_interpret_runOracleConfigFrom_succ_query machine.tr state cfg.tapes.inputSymbol cfg.tapes.workTapeSymbols cfg.answerSymbols bit = .query op next) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom (fuel + 1) cfg)).run s = (oracle (op, (cfg.channels op).queryBuffer) s).bind (fun (answer, s') => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom fuel (cfg.receive op next answer))).run s') := by dsimp only [runOracleConfigFrom, runConfigFrom] rw [MultiTapeMachine.runConfigFrom] @@ -238,11 +238,11 @@ def RunsWords (machine : MultiTapePTM k Bool State Operation) (x : List Bool) cfg.tapes = wordsCfg x (some machine.initial) ws₀ out₀ → (∀ op, (cfg.channels op).queryBuffer = []) → let run := (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg)).run s run.map (fun (final, s') => (final.tapes, s')) = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).map (fun (a, s') => (wordsCfg x none (ws₁ a) (out₀ ++ emit a), s')) ∧ ∀ final ∈ run.support, ∀ op, (final.1.channels op).queryBuffer = [] @@ -270,13 +270,13 @@ theorem halted (h : machine.RunsWords x ws₀ out₀ time program ws₁ emit) (htapes : cfg.tapes = wordsCfg x (some machine.initial) ws₀ out₀) (hbuf : ∀ op, (cfg.channels op).queryBuffer = []) : ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg)).run s).support, final.1.tapes.state = none := by intro final hfinal have hmap : (final.1.tapes, final.2) ∈ (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg)).run s).map (fun (final, s') => (final.tapes, s'))).support := (PMF.mem_support_map_iff _ _ _).mpr ⟨final, hfinal, rfl⟩ @@ -293,10 +293,10 @@ theorem mem_support (h : machine.RunsWords x ws₀ out₀ time program ws₁ emi (hbuf : ∀ op, (cfg.channels op).queryBuffer = []) {final : Config k Bool State Operation x} {s' : OracleState} (hfinal : (final, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg)).run s).support) : (∃ a, (a, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support ∧ final.tapes = wordsCfg x none (ws₁ a) (out₀ ++ emit a)) ∧ ∀ op, (final.channels op).queryBuffer = [] := by @@ -304,7 +304,7 @@ theorem mem_support (h : machine.RunsWords x ws₀ out₀ time program ws₁ emi refine ⟨?_, hclean (final, s') hfinal⟩ have hmap : (final.tapes, s') ∈ (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg)).run s).map (fun (final, s') => (final.tapes, s'))).support := (PMF.mem_support_map_iff _ _ _).mpr ⟨(final, s'), hfinal, rfl⟩ @@ -327,10 +327,10 @@ theorem congr (h : machine.RunsWords x ws₀ out₀ time program ws₁ emit) (heq : ∀ (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState), (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program').run s) : machine.RunsWords x ws₀ out₀ time program' ws₁ emit := by intro OracleState oracle s cfg htapes hbuf @@ -380,7 +380,7 @@ theorem seq_bind {first : MultiTapePTM k Bool State₀ Operation} (h₂ : ∀ a (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (a, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → second.RunsWords x (ws₁ a) (out₀ ++ emit₁ a) t₂ (prog₂ a) (ws₂ a) (emit₂ a)) : (first.seq second).RunsWords x ws₀ out₀ (t₁ + t₂) @@ -401,10 +401,10 @@ theorem seq_bind {first : MultiTapePTM k Bool State₀ Operation} exact hinj (Prod.ext hws hem) have hhalt₁ := h₁.halted oracle s cfg₀ rfl hbuf have hhalt₂ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg₀)).run s).support, ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (second.runOracleConfigFrom t₂ (Sequential.start second result.1))).run result.2).support, final.1.tapes.state = none := by rintro ⟨mid, s₁⟩ hmid @@ -422,7 +422,7 @@ theorem seq_bind {first : MultiTapePTM k Bool State₀ Operation} PMF (Cfg k Bool (State₀ ⊕ State₁) x × OracleState) := if h : ∃ a, p.1 = f a then ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (prog₂ (Classical.choose h))).run p.2).map (fun (b, s₂) => (wordsCfg x none (ws₂ (Classical.choose h) b) @@ -431,7 +431,7 @@ theorem seq_bind {first : MultiTapePTM k Bool State₀ Operation} have hg (a : α) (s₁ : OracleState) : g (wordsCfg x none (ws₁ a) (out₀ ++ emit₁ a), s₁) = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (prog₂ a)).run s₁).map (fun (b, s₂) => (wordsCfg x none (ws₂ a b) (out₀ ++ (emit₁ a ++ emit₂ a b)), s₂)) := by @@ -441,17 +441,17 @@ theorem seq_bind {first : MultiTapePTM k Bool State₀ Operation} simp only [hex, ↓reduceDIte, hchoose] have hcongr : ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg₀)).run s).bind (fun result => PMF.map (fun (final, s') => (final.tapes, s')) (PMF.map (fun (final, s') => (Sequential.right final, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (second.runOracleConfigFrom t₂ (Sequential.start second result.1))).run result.2))) = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg₀)).run s).bind (fun result => g (result.1.tapes, result.2)) := by apply PMF.bind_congr_on_support @@ -466,12 +466,12 @@ theorem seq_bind {first : MultiTapePTM k Bool State₀ Operation} PMF.map (fun p => (p.1.tapes, p.2)) (PMF.map (fun p => (Sequential.right (State₀ := State₀) p.1, p.2)) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (second.runOracleConfigFrom t₂ (Sequential.start second mid))).run s₁)) = PMF.map (fun p => (Cfg.mapState (Option.map (Sum.inr (α := State₀))) p.1, p.2)) (PMF.map (fun p => (p.1.tapes, p.2)) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (second.runOracleConfigFrom t₂ (Sequential.start second mid))).run s₁)) := by simp only [PMF.map_comp, Function.comp_def, Sequential.right] rw [hright, hsecondLaw, hmidTapes, hg a s₁, PMF.map_comp] @@ -483,11 +483,11 @@ theorem seq_bind {first : MultiTapePTM k Bool State₀ Operation} rw [hcongr] have hmapBind : ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg₀)).run s).bind (fun result => g (result.1.tapes, result.2)) = (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (first.runOracleConfigFrom t₁ cfg₀)).run s).map (fun (final, s') => (final.tapes, s'))).bind g := by rw [PMF.bind_map] @@ -533,7 +533,7 @@ theorem seq_pure_right {first : MultiTapePTM k Bool State₀ Operation} (h₂ : ∀ a (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (a, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → second.RunsWords x (ws₁ a) (out₀ ++ emit₁ a) t₂ (pure ()) (fun _ => ws₂ a) (fun _ => emit₂ a)) : @@ -567,12 +567,12 @@ theorem of_nil_output (h : machine.RunsWords x ws₀ [] time program ws₁ emit) PMF.map (fun (final, s') => (final.tapes, s')) (PMF.map (fun (a, s') => (a.prependOutput out₀, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg₀)).run s)) = PMF.map (fun (tapes, s') => (tapes.prependOutput out₀, s')) (PMF.map (fun (final, s') => (final.tapes, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg₀)).run s)) := by simp only [PMF.map_comp, Function.comp_def, Config.prependOutput] rw [hmap, hlaw, PMF.map_comp] @@ -650,12 +650,12 @@ theorem of_first_step_mapState {S : Type} {tm : MultiTapePTM k Bool S Operation} (final.1.tapes, final.2)) (PMF.map (fun (a, s') => (Config.mapState f a, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (tm.runOracleConfigFrom time cfg₀)).run s)) = PMF.map (fun (tapes, s') => (tapes.mapState (Option.map f), s')) (PMF.map (fun (final, s') => (final.tapes, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (tm.runOracleConfigFrom time cfg₀)).run s)) := by simp only [PMF.map_comp, Function.comp_def, Config.mapState] rw [hmap, hlaw, PMF.map_comp] @@ -681,14 +681,14 @@ theorem length_output_le_of_mem_support_runOracleConfigFrom {x : List Bool} (fuel : ℕ) (cfg : Config k Bool State Operation x) (s : OracleState) {final : Config k Bool State Operation x} {s' : OracleState} (hfinal : (final, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom fuel cfg)).run s).support) : final.tapes.output.length ≤ cfg.tapes.output.length + fuel := MultiTapeMachine.length_output_runConfigFrom_le machine (fun choices => choices <$> ProbOracleComp.sample (ProbComp.uniform Bool)) (fun op word => ProbOracleComp.query (spec := fun _ : Operation × List Bool => List Bool) (op, word)) - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) fuel cfg final s s' hfinal /-- Any word emitted by a `RunsWords` phase has length at most `time`. -/ @@ -700,7 +700,7 @@ theorem RunsWords.length_emit_le {machine : MultiTapePTM k Bool State Operation} (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) {a : α} {s' : OracleState} (ha : (a, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support) : (emit a).length ≤ time := by let cfg : Config k Bool State Operation x := @@ -709,7 +709,7 @@ theorem RunsWords.length_emit_le {machine : MultiTapePTM k Bool State Operation} obtain ⟨hlaw, _⟩ := h OracleState oracle s cfg rfl (fun _ => rfl) have hmem : (wordsCfg x (none : Option State) (ws₁ a) (out₀ ++ emit a), s') ∈ (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).map (fun (a, s') => (wordsCfg x (none : Option State) (ws₁ a) (out₀ ++ emit a), s'))).support := (PMF.mem_support_map_iff _ _ _).mpr ⟨(a, s'), ha, rfl⟩ @@ -737,10 +737,10 @@ theorem congr (h : machine.ComputesTidily x time program) (heq : ∀ (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState), (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program').run s) : machine.ComputesTidily x time program' := fun out₀ => (h out₀).congr heq @@ -749,10 +749,10 @@ theorem congr (h : machine.ComputesTidily x time program) theorem runOracle (h : machine.ComputesTidily x time program) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracle time x)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s := by have hlaw := ((h []) OracleState oracle s (machine.initialConfig x) (Cfg.init_eq_wordsCfg machine.initial x) (fun _ => rfl)).1 @@ -784,7 +784,7 @@ theorem length_output_le (h : machine.ComputesTidily x time program) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) {w : List Bool} {s' : OracleState} (hw : (w, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support) : w.length ≤ time := (h []).length_emit_le oracle s hw diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/SingleOracle.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/SingleOracle.lean index 13c7778a76..f7a01c6afb 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/SingleOracle.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/SingleOracle.lean @@ -100,7 +100,7 @@ theorem runOracle_singleOracle (i₀ : ι) (machine : MultiTapePTM k Symbol Stat (fuel : ℕ) (input : List Symbol) : (machine.singleOracle i₀).runOracle fuel input = OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => OracleComp.query (spec := probOracleSpec (fun _ : ι × List Symbol => List Symbol)) (Sum.inl n)) (fun q : Unit × List Symbol => diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy.lean index d787e17547..62ccc8330c 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy.lean @@ -83,13 +83,13 @@ theorem ComputesTidily.comp_of_le {tm₁ : MultiTapePTM k₁ Bool State₁ Opera (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) (w : List Bool) (s' : OracleState), (w, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → w.length ≤ l) (h₂ : ∀ w (OracleState : Type) (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (w, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → tm₂.ComputesTidily w t₂ (prog₂ w)) : (tm₂.tidyComp tm₁ mark).ComputesTidily x (t₁ + t₂ + 4 * l + 9) (prog₁ >>= prog₂) := by rw [computesTidily_iff_nil_output] @@ -127,7 +127,7 @@ theorem ComputesTidily.comp_of_le {tm₁ : MultiTapePTM k₁ Bool State₁ Opera (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (w, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → (((tm₂.extendTapes (Fin.castLEEmb (le_max_right k₁ k₂))).inputFromWord mark).seq (ofDeterministic ((clearWork Bool).extendTapes (tapeEmb A)))).RunsWords @@ -148,7 +148,7 @@ theorem ComputesTidily.comp_of_le {tm₁ : MultiTapePTM k₁ Bool State₁ Opera (oracle' : Operation × List Bool → StateT OracleState' PMF (List Bool)) (s₀ s₁ : OracleState'), (y, s₁) ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') (prog₂ w)).run s₀).support → (ofDeterministic (Oracle := Operation) ((clearWork Bool).extendTapes (tapeEmb A))).RunsWords @@ -181,7 +181,7 @@ theorem ComputesTidily.comp {tm₁ : MultiTapePTM k₁ Bool State₁ Operation} (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (w, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → tm₂.ComputesTidily w t₂ (prog₂ w)) : (tm₂.tidyComp tm₁ mark).ComputesTidily x (5 * t₁ + t₂ + 9) (prog₁ >>= prog₂) := by exact (h₁.comp_of_le mark (fun _ oracle s _ _ hw => h₁.length_output_le oracle s hw) h₂).mono @@ -206,7 +206,7 @@ theorem ComputesTidily.append {tm₁ : MultiTapePTM k₁ Bool State₁ Operation (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (w₁, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → tm₂.ComputesTidily x t₂ (prog₂ w₁)) : (appendPTM tm₁ tm₂).ComputesTidily x (t₁ + t₂) (prog₁ >>= fun w₁ => (fun w₂ => w₁ ++ w₂) <$> prog₂ w₁) := by @@ -219,7 +219,7 @@ theorem ComputesTidily.append {tm₁ : MultiTapePTM k₁ Bool State₁ Operation (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (w₁, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) prog₁).run s).support → (tm₂.extendTapes (Fin.castLEEmb (le_max_right k₁ k₂))).RunsWords x (fun _ => []) ([] ++ id w₁) t₂ (prog₂ w₁) (fun _ _ => []) id := @@ -392,7 +392,7 @@ theorem ComputesTidily.ite {tmc : MultiTapePTM k₀ Bool State₀ Operation} (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) (w' : List Bool) (s' : OracleState), (w', s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (pure w)).run s).support → w'.length ≤ w.length := by intro _ _ _ w' s' hw' simp only [OracleComp.interpret_pure, StateT.run_pure, @@ -438,7 +438,7 @@ theorem ComputesTidily.ite {tmc : MultiTapePTM k₀ Bool State₀ Operation} (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s s' : OracleState), (y, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (if w = [] then prog₂ else prog₁)).run s).support → clearLast.RunsWords x (Function.update (fun _ => []) (Fin.last K) w) ([] ++ id y) diff --git a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy/Redirect.lean b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy/Redirect.lean index b0661f0ba4..32097e7274 100644 --- a/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy/Redirect.lean +++ b/Complexity/Computability/Machines/Turing/MultiTape/Probabilistic/Tidy/Redirect.lean @@ -86,13 +86,13 @@ theorem RunsWords.extendTapes {machine : MultiTapePTM k Bool State Operation} PMF.map (fun (final, s') => (final.tapes, s')) (PMF.map (fun (a, s') => (a.embed e (fun l => tapeOfList (ws₀ l)) (fun _ => 0), s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg₀)).run s)) = PMF.map (fun (tapes, s') => (MultiTapeTM.embed e tapes (fun l => tapeOfList (ws₀ l)) (fun _ => 0), s')) (PMF.map (fun (final, s') => (final.tapes, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg₀)).run s)) := by simp only [PMF.map_comp, Function.comp_def, Config.embed] rw [hmap, hlaw, PMF.map_comp] @@ -166,7 +166,7 @@ theorem ComputesTidily.outputToWord_of_le {machine : MultiTapePTM k Bool State O (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) (w : List Bool) (s' : OracleState), (w, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support → w.length ≤ l) : ∀ out₀, machine.outputToWord.RunsWords x (fun _ => []) out₀ (time + (l + 2)) program (fun w => Function.update (fun _ => []) (Fin.last k) w) (fun _ => []) := by @@ -189,7 +189,7 @@ theorem ComputesTidily.outputToWord_of_le {machine : MultiTapePTM k Bool State O OutputToTape.config <$> machine.runOracleConfigFrom time cfg₀ := MultiTapePTM.runConfigFrom_outputToTape machine _ _ time cfg₀ have hhalt₁ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.outputToTape.runOracleConfigFrom time (OutputToTape.config cfg₀))).run s).support, result.1.tapes.state = none := by intro result hres @@ -197,10 +197,10 @@ theorem ComputesTidily.outputToWord_of_le {machine : MultiTapePTM k Bool State O obtain ⟨⟨mid, s₁⟩, hmid, rfl⟩ := (PMF.mem_support_map_iff _ _ _).mp hres exact (h []).halted oracle s cfg₀ rfl hbuf (mid, s₁) hmid have hhalt₂ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.outputToTape.runOracleConfigFrom time (OutputToTape.config cfg₀))).run s).support, ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (rew.runOracleConfigFrom (l + 2) (Sequential.start rew result.1))).run result.2).support, final.1.tapes.state = none := by @@ -225,7 +225,7 @@ theorem ComputesTidily.outputToWord_of_le {machine : MultiTapePTM k Bool State O · rw [houtRun, OracleComp.interpret_map, StateT.run_map, PMF.monad_map_eq_map, PMF.bind_map, PMF.map_bind] trans (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg₀)).run s).bind (fun a => PMF.pure @@ -253,7 +253,7 @@ theorem ComputesTidily.outputToWord_of_le {machine : MultiTapePTM k Bool State O (wordsCfg x (none : Option (State ⊕ RewindWorkState)) (Function.update (fun _ => []) (Fin.last k) p.1.output) [], p.2))) hlaw change ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfg₀)).run s).bind (PMF.pure ∘ fun a => (wordsCfg x none @@ -354,7 +354,7 @@ theorem RunsWords.inputFromWord {machine : MultiTapePTM k Bool State Operation} { tapes := inCfg mark (wordsCfg w (none : Option MarkWorkState) ws₀ out₀) x channels := cfg.channels } have hset : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (setF.runOracleConfigFrom 2 cfg₀)).run s = PMF.pure (ready, s) := by rw [run_interpret_runOracleConfigFrom_ofDeterministic] congr 1 @@ -377,7 +377,7 @@ theorem RunsWords.inputFromWord {machine : MultiTapePTM k Bool State Operation} machine.runOracleConfigFrom time cfgIn := MultiTapePTM.runConfigFrom_inputFromTape machine _ _ mark time cfgIn x 1 have hhalt₁ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.inputFromTape.runOracleConfigFrom time (InputFromTape.config mark cfgIn x 1))).run s).support, result.1.tapes.state = none := by @@ -386,11 +386,11 @@ theorem RunsWords.inputFromWord {machine : MultiTapePTM k Bool State Operation} obtain ⟨⟨mid, s₁⟩, hmid, rfl⟩ := (PMF.mem_support_map_iff _ _ _).mp hres exact h.halted oracle s cfgIn rfl hbuf (mid, s₁) hmid have hhalt₂ : ∀ result ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.inputFromTape.runOracleConfigFrom time (InputFromTape.config mark cfgIn x 1))).run s).support, ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (eraseF.runOracleConfigFrom 2 (Sequential.start eraseF result.1))).run result.2).support, final.1.tapes.state = none := by @@ -412,7 +412,7 @@ theorem RunsWords.inputFromWord {machine : MultiTapePTM k Bool State Operation} have hmidSeq := run_interpret_runOracleConfigFrom_seq machine.inputFromTape eraseF oracle (InputFromTape.config mark cfgIn x 1) time 2 s hhalt₁ hhalt₂ have hhaltMid : ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (midM.runOracleConfigFrom (time + 2) (Sequential.start midM ready))).run s).support, final.1.tapes.state = none := by intro final hfinal @@ -424,10 +424,10 @@ theorem RunsWords.inputFromWord {machine : MultiTapePTM k Bool State Operation} change PMF.map (fun (final, s') => (final.tapes, s')) ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((setF.seq midM).runOracleConfigFrom (time + 4) cfg)).run s) = _ ∧ ∀ final ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((setF.seq midM).runOracleConfigFrom (time + 4) cfg)).run s).support, _ rw [hleft₀, hsplit, run_interpret_runOracleConfigFrom_seq setF midM oracle cfg₀ 2 (time + 2) s @@ -450,7 +450,7 @@ theorem RunsWords.inputFromWord {machine : MultiTapePTM k Bool State Operation} · rw [hinRun, OracleComp.interpret_map, StateT.run_map, PMF.monad_map_eq_map, PMF.bind_map, PMF.map_bind, PMF.map_bind] trans (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfgIn)).run s).bind (fun p => PMF.pure (F p.1.tapes, p.2))) · apply PMF.bind_congr_on_support @@ -471,7 +471,7 @@ theorem RunsWords.inputFromWord {machine : MultiTapePTM k Bool State Operation} have hmapF := congrArg (PMF.map (fun (p : Cfg k Bool State w × OracleState) => (F p.1, p.2))) hlaw change ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracleConfigFrom time cfgIn)).run s).bind (PMF.pure ∘ fun p => (F p.1.tapes, p.2)) = _ rw [PMF.bind_pure_comp] @@ -504,7 +504,7 @@ theorem ComputesTidily.onWords_of_le {machine : MultiTapePTM k Bool State Operat (oracle : Operation × List Bool → StateT OracleState PMF (List Bool)) (s : OracleState) (w' : List Bool) (s' : OracleState), (w', s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support → w'.length ≤ l) : ∀ out₀, (machine.onWords mark).RunsWords x (Function.update (fun _ => []) (Fin.natAdd (k + 1) 0) w) out₀ (time + l + 6) program diff --git a/Complexity/Computability/Probabilistic/Memoize.lean b/Complexity/Computability/Probabilistic/Memoize.lean index 8529638560..894f1a0d01 100644 --- a/Complexity/Computability/Probabilistic/Memoize.lean +++ b/Complexity/Computability/Probabilistic/Memoize.lean @@ -136,7 +136,7 @@ theorem memoize_cache_size_le {α Key Value : Type} [BEq Key] (keyEncoding entry.1).length ≤ maxKey ∧ (valueEncoding entry.2).length ≤ maxValue) (result : α) (h : (result, cache') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize distribution)) program).run cache).support) : (encList (encPair keyEncoding valueEncoding) cache').length ≤ (cache.length + calls) * (4 * maxKey + 2 * maxValue + 3) := by diff --git a/Complexity/Computability/Probabilistic/Oracle.lean b/Complexity/Computability/Probabilistic/Oracle.lean index feab3a4eb2..e3eec288e4 100644 --- a/Complexity/Computability/Probabilistic/Oracle.lean +++ b/Complexity/Computability/Probabilistic/Oracle.lean @@ -67,10 +67,10 @@ def IsOraclePPTOn {Operation α β : Type} [DecidableEq Operation] (machine : Turing.MultiTapePTM k Bool Control Operation) (c d : ℕ), ∀ a (State : Type) (oracle : Operation × List Bool → StateT State PMF (List Bool)) s, (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (output <$> program a)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (machine.runOracle (c * ((input a).length + 1) ^ d) (input a))).run s namespace IsOraclePPTOn @@ -97,10 +97,10 @@ theorem congr {program program' : α → WordOracleComp Operation β} (h : IsOraclePPTOn input output program) (heq : ∀ a (State : Type) (oracle : Operation × List Bool → StateT State PMF (List Bool)) s, (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program a)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program' a)).run s) : IsOraclePPTOn input output program' := by obtain ⟨hops, k, Control, hfinite, machine, c, d, h⟩ := h refine ⟨hops, k, Control, hfinite, machine, c, d, fun a State oracle s => ?_⟩ @@ -118,13 +118,13 @@ theorem length_le {program : α → WordOracleComp Operation β} ∃ c d : ℕ, ∀ a (State : Type) (oracle : Operation × List Bool → StateT State PMF (List Bool)) s s' result, (result, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program a)).run s).support → (output result).length ≤ c * ((input a).length + 1) ^ d := by obtain ⟨_, k, Control, _, machine, c, d, h⟩ := h refine ⟨c, d, fun a State oracle s s' result hresult => ?_⟩ have hmap : (output result, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (output <$> program a)).run s).support := by rw [OracleComp.interpret_map, StateT.run_map, PMF.monad_map_eq_map] exact (PMF.mem_support_map_iff _ _ _).mpr ⟨(result, s'), hresult, rfl⟩ diff --git a/Complexity/Computability/Probabilistic/Oracle/Parameter.lean b/Complexity/Computability/Probabilistic/Oracle/Parameter.lean index b57810256b..3c53e8e334 100644 --- a/Complexity/Computability/Probabilistic/Oracle/Parameter.lean +++ b/Complexity/Computability/Probabilistic/Oracle/Parameter.lean @@ -68,10 +68,10 @@ theorem IsOraclePPT.congr (h : IsOraclePPT output program) (heq : ∀ n input (State : Type) (oracle : Operation × List Bool → StateT State PMF (List Bool)) state, (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program n input)).run state = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program' n input)).run state) : IsOraclePPT output program' := h.on.congr (fun input => heq input.1 input.2) @@ -115,7 +115,7 @@ theorem IsOraclePPT.run_interpret_preprocess {Caller State : Type} (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsPPTOn input (encPair output stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) (handler a)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (handler a)) (program (prepare a).1 (prepare a).2)).run (initial a)) := hprogram.on.run_interpret_preprocess hprepare hhandler hinitial invariant hinit hresources hpreserve @@ -146,7 +146,7 @@ theorem IsOraclePPT.run_interpret_preprocess_open {External Caller State : Type} (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsOraclePPTOn input (encPair output stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (program (prepare a).1 (prepare a).2)).run (initial a)) := hprogram.on.run_interpret_preprocess_open hprepare hhandler hinitial invariant hinit @@ -177,7 +177,7 @@ theorem IsOraclePPT.run_interpret_preprocess_open' {External Caller State : Type (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsOraclePPTOn input (encPair output stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (program (prepare a).1 (prepare a).2)).run (initial a)) := hprogram.on.run_interpret_preprocess_open' hprepare hhandler hinitial invariant hinit diff --git a/Complexity/Computability/Probabilistic/Oracle/SingleOracle.lean b/Complexity/Computability/Probabilistic/Oracle/SingleOracle.lean index 1ad8a0d827..fdcb2a489a 100644 --- a/Complexity/Computability/Probabilistic/Oracle/SingleOracle.lean +++ b/Complexity/Computability/Probabilistic/Oracle/SingleOracle.lean @@ -38,7 +38,7 @@ variable {ι α β : Type} def WordOracleComp.singleOracle (i₀ : ι) (p : WordOracleComp Unit α) : WordOracleComp ι α := OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => OracleComp.query (spec := probOracleSpec (fun _ : ι × List Bool => List Bool)) (Sum.inl n)) (fun q : Unit × List Bool => @@ -55,15 +55,15 @@ theorem WordOracleComp.run_interpret_singleOracle {State : Type} (i₀ : ι) (oracle : ι × List Bool → StateT State PMF (List Bool)) (p : WordOracleComp Unit α) (s : State) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (WordOracleComp.singleOracle i₀ p)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q : Unit × List Bool => oracle (i₀, q.2))) p).run s := by rw [WordOracleComp.singleOracle, OracleComp.interpret_interpret] congr 2 funext q - cases q <;> simp only [ProbOracleComp.handler, ProbOracleComp.query, OracleComp.interpret_query] + cases q <;> simp only [OracleComp.sumHandler, ProbOracleComp.query, OracleComp.interpret_query] /-- Routing a strict oracle-PPT single-channel program to channel `i₀ : ι` preserves `IsOraclePPTOn`. -/ diff --git a/Complexity/Computability/Probabilistic/Oracle/Substitution.lean b/Complexity/Computability/Probabilistic/Oracle/Substitution.lean index 0139a19bba..a984042875 100644 --- a/Complexity/Computability/Probabilistic/Oracle/Substitution.lean +++ b/Complexity/Computability/Probabilistic/Oracle/Substitution.lean @@ -80,7 +80,7 @@ theorem IsOraclePPTOn.run_interpret_preprocess_open (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsOraclePPTOn input (encPair output stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (program (prepare a))).run (initial a)) := by obtain ⟨resourceCoeff, resourceDegree, hbound⟩ := hresources.polyBounded_length.exists_le @@ -111,11 +111,11 @@ theorem IsOraclePPTOn.run_interpret_preprocess_open apply IsOraclePPTOn.iff_encoded.mpr refine (IsOraclePPTOn.iff_encoded.mp hrun).congr fun a External' oracle e => ?_ have hout : encPair output stateEncoding <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (program (prepare a))).run (initial a) = encPair encBits stateEncoding <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (output <$> program (prepare a))).run (initial a) := by rw [OracleComp.interpret_map, StateT.run_map, Functor.map_map] @@ -151,7 +151,7 @@ theorem IsOraclePPTOn.run_interpret_preprocess_open' (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsOraclePPTOn input (encPair output stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (program (prepare a))).run (initial a)) := hprogram.run_interpret_preprocess_open hprepare.tidy hhandler hinitial.tidy invariant hinit @@ -193,7 +193,7 @@ theorem IsOraclePPTOn.interpret_bitQueries fun a State oracle s => ?_ congr 2 rw [OracleComp.interpret_interpret, OracleComp.interpret_interpret] - have hH : (fun q : Unit × List Bool => OracleComp.interpret (ProbOracleComp.handler + have hH : (fun q : Unit × List Bool => OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (fun (q : Unit × List Bool) (_ : Unit) => (fun r => (r, ())) <$> (List.take 1 <$> ProbOracleComp.query (spec := fun _ : Unit × List Bool => List Bool) diff --git a/Complexity/Computability/Probabilistic/Oracle/Tidy.lean b/Complexity/Computability/Probabilistic/Oracle/Tidy.lean index 312d346758..99beb33ff6 100644 --- a/Complexity/Computability/Probabilistic/Oracle/Tidy.lean +++ b/Complexity/Computability/Probabilistic/Oracle/Tidy.lean @@ -99,10 +99,10 @@ theorem congr {program program' : α → WordOracleComp Operation γ} (h : IsTidyOraclePPTOn input output program) (heq : ∀ a (State : Type) (oracle : Operation × List Bool → StateT State PMF (List Bool)) s, (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program a)).run s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program' a)).run s) : IsTidyOraclePPTOn input output program' := by obtain ⟨hops, k, Control, hfinite, machine, c, d, h⟩ := h @@ -122,7 +122,7 @@ theorem length_le {program : α → WordOracleComp Operation γ} ∃ c d : ℕ, ∀ a (State : Type) (oracle : Operation × List Bool → StateT State PMF (List Bool)) s s' result, (result, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (program a)).run s).support → (output result).length ≤ c * ((input a).length + 1) ^ d := h.isOraclePPTOn.length_le diff --git a/Complexity/Computability/Probabilistic/OracleSimulation.lean b/Complexity/Computability/Probabilistic/OracleSimulation.lean index 7392720b7f..632ccefb82 100644 --- a/Complexity/Computability/Probabilistic/OracleSimulation.lean +++ b/Complexity/Computability/Probabilistic/OracleSimulation.lean @@ -69,7 +69,7 @@ theorem IsOraclePPTOn.run_interpret_preprocess {Operation α β Caller State : T (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsPPTOn input (encPair output stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) (handler a)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (handler a)) (program (prepare a))).run (initial a)) := by refine ((hprogram.run_interpret_preprocess_open (External := Empty) (handler := fun a request state => ProbOracleComp.sample (handler a request state)) diff --git a/Complexity/Computability/Probabilistic/Presample.lean b/Complexity/Computability/Probabilistic/Presample.lean index bb66f79232..adf06c063a 100644 --- a/Complexity/Computability/Probabilistic/Presample.lean +++ b/Complexity/Computability/Probabilistic/Presample.lean @@ -67,7 +67,7 @@ theorem IsOraclePPTOn.run_interpret_withSampleList invariant a result.2 ∧ result.1.length ≤ resources a request.2 ∧ (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsPPTOn input (encPair output (encPair stateEncoding (encList valueEncoding))) (fun a => - (OracleComp.interpret (ProbOracleComp.handler + (OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (OracleComp.withSampleList fallback (oracle a))) (program (prepare a))).run (initial a, values a)) := by @@ -128,7 +128,7 @@ theorem IsOraclePPT.run_interpret_withSampleList invariant a result.2 ∧ result.1.length ≤ resources a request.2 ∧ (stateEncoding result.2).length ≤ (stateEncoding state).length + resources a request.2) : IsPPTOn input (encPair output (encPair stateEncoding (encList valueEncoding))) (fun a => - (OracleComp.interpret (ProbOracleComp.handler + (OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (OracleComp.withSampleList fallback (oracle a))) (program (prepare a).1 (prepare a).2)).run (initial a, values a)) := diff --git a/Complexity/Computability/Probabilistic/QueryBounds.lean b/Complexity/Computability/Probabilistic/QueryBounds.lean index e0fe010932..1cb93ba9d2 100644 --- a/Complexity/Computability/Probabilistic/QueryBounds.lean +++ b/Complexity/Computability/Probabilistic/QueryBounds.lean @@ -54,7 +54,7 @@ theorem IsOraclePPTOn.query_bounds {Operation α β : Type} [DecidableEq Operati (s s' : State) (result : List Bool) (transcript : OracleComp.Transcript (fun _ : Operation × List Bool => List Bool)) (hmem : (result, s', transcript) ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (OracleComp.withTranscript oracle)) (output <$> program a)).run (s, [])).support) : transcript.length ≤ c * ((input a).length + 1) ^ d ∧ ∀ entry ∈ transcript, entry.1.2.length ≤ c * ((input a).length + 1) ^ d := by diff --git a/Complexity/Computability/Probabilistic/Realization/OpenOracleSimulation.lean b/Complexity/Computability/Probabilistic/Realization/OpenOracleSimulation.lean index 80396002dc..3cae17697f 100644 --- a/Complexity/Computability/Probabilistic/Realization/OpenOracleSimulation.lean +++ b/Complexity/Computability/Probabilistic/Realization/OpenOracleSimulation.lean @@ -72,7 +72,7 @@ theorem step_eq_run_interpret (machine : MultiTapePTM k Bool Control Operation) (a : α) (pair : FiniteConfig k Bool Control Operation × State) : step machine handler a pair = (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (machine.finiteStep (fun choices => choices <$> ProbOracleComp.sample (ProbComp.uniform Bool)) @@ -174,7 +174,7 @@ theorem isOraclePPTOn_run [Finite Operation] {input : α ↪ List Bool} resources ((input a).length + request.2.length)) : IsOraclePPTOn input (encPair encBits stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (handler a)) (machine.runOracle (count a) (word a))).run (initial a)) := by have hword := hword.tidy diff --git a/Complexity/Computability/Probabilistic/Realization/OracleSimulation.lean b/Complexity/Computability/Probabilistic/Realization/OracleSimulation.lean index fb597538d5..910df164f9 100644 --- a/Complexity/Computability/Probabilistic/Realization/OracleSimulation.lean +++ b/Complexity/Computability/Probabilistic/Realization/OracleSimulation.lean @@ -69,7 +69,7 @@ theorem step_eq_run_interpret (machine : MultiTapePTM k Bool Control Operation) (pair : FiniteConfig k Bool Control Operation × State) : step machine handler a pair = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (handler a)) (machine.finiteStep (fun choices => choices <$> ProbOracleComp.sample (ProbComp.uniform Bool)) @@ -143,7 +143,7 @@ theorem isPPTOn_run [Finite Operation] {input : α ↪ List Bool} resources ((input a).length + request.2.length)) : IsPPTOn input (encPair encBits stateEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (handler a)) (machine.runOracle (count a) (word a))).run (initial a)) := by refine ((OpenOracleSimulation.isOraclePPTOn_run (External := Empty) (handler := fun a request state => ProbOracleComp.sample (handler a request state)) machine diff --git a/Complexity/Crypto/Computational/CramerShoup.lean b/Complexity/Crypto/Computational/CramerShoup.lean index 30cb50f1fa..e9709d296c 100644 --- a/Complexity/Crypto/Computational/CramerShoup.lean +++ b/Complexity/Crypto/Computational/CramerShoup.lean @@ -187,7 +187,7 @@ noncomputable def cramerShoupMsgCCA2Game let pkVal := F.cramerShoupPublicKey d α σ τ σ₁ τ₁ σ₂ τ₂ let pk := F.encodeCramerShoupPublicKeyValues d pkVal let choiceOut ← ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ()) let choice := choiceOut.1 @@ -202,7 +202,7 @@ noncomputable def cramerShoupMsgCCA2Game F.encode d (csPkH₁ pkVal), F.encode d (csPkH₂ pkVal)) m ad β.val let guessOut ← ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase2Oracle hasAD H isElem d sk ct ad)) (adversary.guess n choice.2 ct)).run ()) return guessOut.1 @@ -315,7 +315,7 @@ noncomputable def cramerShoupGame1 let w := F.encode d ((α * β) • F.generator d) let pk := F.encodeCramerShoupPublicKey d u sk let choiceOut ← ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ()) let choice := choiceOut.1 @@ -326,7 +326,7 @@ noncomputable def cramerShoupGame1 let m := if bit then m₁ else m₀ let ct := F.encodeCramerShoupChallenge H d sk v w m ad let guessOut ← ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase2Oracle hasAD H isElem d sk ct ad)) (adversary.guess n choice.2 ct)).run ()) return guessOut.1 @@ -392,7 +392,7 @@ noncomputable def cramerShoupGame2 let w := F.encode d (γ • F.generator d) let pk := F.encodeCramerShoupPublicKey d u sk let choiceOut ← ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ()) let choice := choiceOut.1 @@ -403,7 +403,7 @@ noncomputable def cramerShoupGame2 let m := if bit then m₁ else m₀ let ct := F.encodeCramerShoupChallenge H d sk v w m ad let guessOut ← ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase2Oracle hasAD H isElem d sk ct ad)) (adversary.guess n choice.2 ct)).run ()) return guessOut.1 @@ -526,7 +526,7 @@ private noncomputable def cramerShoupExactCollisionGame let w := F.encode d (γ • F.generator d) let pk := F.encodeCramerShoupPublicKey d u sk let choiceOut ← ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ()) let choice := choiceOut.1 @@ -584,7 +584,7 @@ private theorem advantage_cramerShoupGame2_game3_le_exactCollision let ct := F.encodeCramerShoupChallenge H d sk v w m ad have hrun : (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase2Oracle hasAD H isElem d sk ct ad)) (adversary.guess n choiceOut.1.2 ct)).run ())).bind (fun guessOut => PMF.pure guessOut.1) = @@ -639,7 +639,7 @@ private theorem succProbability_cramerShoupExactCollisionGame_le let w := F.encode d (γ • F.generator d) let pk := F.encodeCramerShoupPublicKey d u sk (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ())).bind fun choiceOut => let choice := choiceOut.1 @@ -666,7 +666,7 @@ private theorem succProbability_cramerShoupExactCollisionGame_le let w := F.encode d (γ • F.generator d) let pk := F.encodeCramerShoupPublicKey d u sk (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ())).bind fun choiceOut => let choice := choiceOut.1 @@ -677,7 +677,7 @@ private theorem succProbability_cramerShoupExactCollisionGame_le let ad := encodeAD (d, choice.1.2) let ct := F.encodeCramerShoupChallenge H d sk v w m ad ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupCollisionPhase2Oracle hasAD H isElem d sk ct ad)) (adversary.guess n choice.2 ct)).run none) >>= fun out => let target := extractCramerShoupTuple ct ad @@ -1336,10 +1336,10 @@ private theorem eval_run_interpret_map_bind (f : α → β) (oa : WordOracleComp Unit α) (s : State) (k : β × State → PMF γ) : (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) oracle) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) oracle) (f <$> oa)).run s)).bind k = (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) oracle) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) oracle) oa).run s)).bind (fun p => k (f p.1, p.2)) := by rw [OracleComp.interpret_map, StateT.run_map] simp only [← bind_pure_comp, ProbComp.eval_bind, ProbComp.eval_pure, @@ -1361,7 +1361,7 @@ private noncomputable def cramerShoupCCA2InnerB (F.encode d pkVal.1, F.encode d pkVal.2.1, F.encode d pkVal.2.2.1, F.encode d pkVal.2.2.2) m adBits β.val (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase2Oracle hasAD H isElem d sk ct adBits)) (adversary.guess n choiceOut.1.2 ct)).run ())).bind (fun guessOut => PMF.pure guessOut.1) @@ -1374,7 +1374,7 @@ private noncomputable def cramerShoupCCA2InnerSK let sk := F.skNatOfZMod d σ τ σ₁ τ₁ σ₂ τ₂ let pk := F.encodeCramerShoupPublicKey d (F.encode d (α • F.generator d)) sk (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ())).bind fun choiceOut => if isElem (d, choiceOut.1.1.1.1) && isElem (d, choiceOut.1.1.1.2) then diff --git a/Complexity/Crypto/Computational/CramerShoup/Reductions.lean b/Complexity/Crypto/Computational/CramerShoup/Reductions.lean index 142048abf1..44b66beb3e 100644 --- a/Complexity/Crypto/Computational/CramerShoup/Reductions.lean +++ b/Complexity/Crypto/Computational/CramerShoup/Reductions.lean @@ -532,7 +532,7 @@ private theorem isPPTOn_run_cramerShoupPhase1Oracle IsPPTOn encIn (encPair (encPair (encPair (encPair encMsg encMsg) encAD) encBits) (encFinEnum Unit)) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem (d a) (sk a))) (adversary.choose (n a) (pk a))).run ()) := by have hp1 := ComputableTidilyInPolyTime.fst encIn encBits @@ -576,7 +576,7 @@ private theorem isPPTOn_run_cramerShoupPhase2Oracle (had : ComputableTidilyInPolyTime ad encIn encBits) : IsPPTOn encIn (encPair encBool (encFinEnum Unit)) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase2Oracle hasAD H isElem (d a) (sk a) (ct a) (ad a))) (adversary.guess (n a) (state a) (ct a))).run ()) := by have hp1 := ComputableTidilyInPolyTime.fst encIn encBits @@ -623,7 +623,7 @@ private theorem isPPTOn_run_cramerShoupCollisionPhase2Oracle (had : ComputableTidilyInPolyTime ad encIn encBits) : IsPPTOn encIn (encPair encBool (encOption encBits)) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupCollisionPhase2Oracle hasAD H isElem (d a) (sk a) (ct a) (ad a))) (adversary.guess (n a) (state a) (ct a))).run none) := by have hp1 := ComputableTidilyInPolyTime.fst encIn encBits @@ -695,7 +695,7 @@ noncomputable def cramerShoupMsgToDDHDistinguisher F.sampleCramerShoupSK n input.1 >>= fun sk => let pk := F.encodeCramerShoupPublicKey input.1 (csDdhU input) sk ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem input.1 sk)) (adversary.choose n pk)).run ()) >>= fun choiceOut => let choice := choiceOut.1 @@ -706,7 +706,7 @@ noncomputable def cramerShoupMsgToDDHDistinguisher let m := if bit then m₁ else m₀ let ct := F.encodeCramerShoupChallenge H input.1 sk (csDdhV input) (csDdhW input) m ad ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase2Oracle hasAD H isElem input.1 sk ct ad)) (adversary.guess n choice.2 ct)).run ()) >>= fun guessOut => pure guessOut.1 @@ -837,7 +837,7 @@ noncomputable def cramerShoupMsgToCollisionFinder let w := F.smul (d, csExpC abc, gen) let pk := F.encodeCramerShoupPublicKey d u sk ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupPhase1Oracle hasAD H isElem d sk)) (adversary.choose n pk)).run ()) >>= fun choiceOut => let choice := choiceOut.1 @@ -848,7 +848,7 @@ noncomputable def cramerShoupMsgToCollisionFinder let m := if bit then m₁ else m₀ let ct := F.encodeCramerShoupChallenge H d sk v w m ad ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (F.cramerShoupCollisionPhase2Oracle hasAD H isElem d sk ct ad)) (adversary.guess n choice.2 ct)).run none) >>= fun out => let target := extractCramerShoupTuple ct ad diff --git a/Complexity/Crypto/Computational/CramerShoup/Scheme.lean b/Complexity/Crypto/Computational/CramerShoup/Scheme.lean index 2948ed2627..497248e311 100644 --- a/Complexity/Crypto/Computational/CramerShoup/Scheme.lean +++ b/Complexity/Crypto/Computational/CramerShoup/Scheme.lean @@ -364,7 +364,7 @@ theorem ADCCA2AdversaryOf.IsPPT.query_bounds {Msg AD : Type} {encMsg : Msg ↪ L (∀ n pk (State : Type) (oracle : Unit × List Bool → StateT State PMF (List Bool)) s s' choice, (choice, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) oracle) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) oracle) (adversary.choose n pk)).run s).support → choice.2.length ≤ cs * (n + pk.length + 2) ^ ds) := by obtain ⟨c₁, d₁, hchoose⟩ := hA.choose.query_bounds @@ -473,7 +473,7 @@ noncomputable def cca2ADGameOn {Msg AD Out : Type} (adversary : ADCCA2AdversaryOf Msg AD) (bit : Bool) (n : ℕ) : ProbComp Bool := do let keys ← keyGen n let choiceOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2ADPhase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run () let choice := choiceOut.1 @@ -481,7 +481,7 @@ noncomputable def cca2ADGameOn {Msg AD Out : Type} let ct ← encrypt n keys.1 (if bit then csChoiceMsg₁ choice else csChoiceMsg₀ choice) (csChoiceAD choice) let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2ADPhase2Oracle encOut decrypt n keys.2 ct (encAD (csChoiceAD choice)))) (adversary.guess n (csChoiceState choice) ct)).run () return guessOut.1 @@ -1608,7 +1608,7 @@ def HonestPhase2QueryBound (hasAD : Bool) {Msg AD : Type} (adversary : ADCCA2AdversaryOf Msg AD) (n Q₂ : ℕ) : Prop := ∀ d ∈ (setup n).support, ∀ α β γ δ τ δ₁ δ₂ ξ : ZMod (F.order d), ∀ choiceOut ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (fun req (s : Unit) => pure (F.cramerShoupDHPhase1Reply hasAD H isElem d α δ δ₁ δ₂ req.2, s))) (adversary.choose n diff --git a/Complexity/Crypto/Computational/Encryption/Authenticated.lean b/Complexity/Crypto/Computational/Encryption/Authenticated.lean index 914e30bb9c..17374ecba5 100644 --- a/Complexity/Crypto/Computational/Encryption/Authenticated.lean +++ b/Complexity/Crypto/Computational/Encryption/Authenticated.lean @@ -260,7 +260,7 @@ noncomputable def cpaGame (E : SymmetricCipher) (adversary : OracleDistinguisher (bit : Bool) (n : ℕ) : ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.cpaEncryptionOracle n k bit)) (adversary n [])).run () return out.1 @@ -272,7 +272,7 @@ theorem isPPTOn_run_cpaEncryptionOracle (E : SymmetricCipher) {adversary : Oracl IsPPTOn (encPair encUnary encBits) (encPair encBool (encFinEnum Unit)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.cpaEncryptionOracle caller.1 caller.2 bit)) (adversary caller.1 [])).run ()) := by obtain ⟨c, d, hlen⟩ := E.encrypt_ppt.length_le let EIn := encPair (encPair encUnary encBits) @@ -395,7 +395,7 @@ noncomputable def cpaOneTimeGame (E : SymmetricCipher) (adversary : OracleDistin (bit : Bool) (n : ℕ) : ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.oneTimeCPAEncryptionOracle n k bit)) (adversary n [])).run false return out.1 @@ -407,7 +407,7 @@ theorem isPPTOn_run_oneTimeCPAEncryptionOracle (E : SymmetricCipher) IsPPTOn (encPair encUnary encBits) (encPair encBool encBool) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.oneTimeCPAEncryptionOracle caller.1 caller.2 bit)) (adversary caller.1 [])).run false) := by obtain ⟨c, d, hlen⟩ := E.encrypt_ppt.length_le @@ -529,7 +529,7 @@ noncomputable def cpaLimitToOneQuery (ctBound : ℕ → ℕ) (adversary : Oracle OracleDistinguisher := fun n _ => do let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cpaOneTimeFilterHandler n (ctBound n))) (adversary n [])).run false @@ -573,7 +573,7 @@ theorem isOraclePPT_cpaLimitToOneQuery {ctBound : ℕ → ℕ} have hrun : IsOraclePPTOn (encPair encUnary encBits) (encPair encBool encBool) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cpaOneTimeFilterHandler caller.1 (ctBound caller.1))) (adversary caller.1 [])).run false) := by @@ -587,10 +587,10 @@ theorem isOraclePPT_cpaLimitToOneQuery {ctBound : ℕ → ℕ} unfold cpaOneTimeFilterHandler at hresult dsimp only at hresult split_ifs at hresult with hlenEq - · obtain ⟨ct, hct, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawCt, _, rfl⟩ := ProbOracleComp.mem_support_map hct + · obtain ⟨ct, hct, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawCt, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hct exact ⟨trivial, (List.length_take_le _ _).trans (by lia), by simp [encBool_apply]⟩ - · cases ProbOracleComp.eq_of_mem_support_pure hresult + · cases OracleComp.eq_of_mem_supportWith_pure hresult exact ⟨trivial, by simp, by simp [encBool_apply]⟩ unfold cpaLimitToOneQuery simpa only [bind_pure_comp] using (hrun.map' (ComputableInPolyTime.fst _ _)).isOraclePPT @@ -618,7 +618,7 @@ theorem eval_cpaGame_cpaLimitToOneQuery (E : SymmetricCipher) (ctBound : ℕ → ProbComp.eval (E.oneTimeCPAEncryptionOracle n k bit request alreadyQueried)) (fun request state => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.cpaEncryptionOracle n k bit q s))) ((cpaOneTimeFilterHandler n (ctBound n) request).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -627,7 +627,7 @@ theorem eval_cpaGame_cpaLimitToOneQuery (E : SymmetricCipher) (ctBound : ℕ → change (ProbComp.eval (E.oneTimeCPAEncryptionOracle n k bit request alreadyQueried)).map (fun x => (x.1, x.2, ())) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.cpaEncryptionOracle n k bit q s))) (cpaOneTimeFilterHandler n (ctBound n) request alreadyQueried)).run ()).map (fun result => (result.1.1, result.1.2, result.2)) @@ -929,7 +929,7 @@ noncomputable def ciGame (E : SymmetricCipher) (adversary : CIAdversary) (n : ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.ciEncryptionOracle n k)) (adversary n [])).run [] return !out.2.contains out.1 && (E.decrypt n k out.1).isSome @@ -941,7 +941,7 @@ theorem isPPTOn_run_ciEncryptionOracle (E : SymmetricCipher) {adversary : CIAdve IsPPTOn (encPair encUnary encBits) (encPair encBits (encList encBits)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.ciEncryptionOracle caller.1 caller.2)) (adversary caller.1 [])).run []) := by obtain ⟨c, d, hlen⟩ := E.encrypt_ppt.length_le let EIn := encPair (encPair encUnary encBits) @@ -1101,7 +1101,7 @@ noncomputable def ciOneTimeGame (E : SymmetricCipher) (adversary : CIAdversary) ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.oneTimeCIEncryptionOracle n k)) (adversary n [])).run [] return !out.2.contains out.1 && (E.decrypt n k out.1).isSome @@ -1113,7 +1113,7 @@ theorem isPPTOn_run_oneTimeCIEncryptionOracle (E : SymmetricCipher) {adversary : IsPPTOn (encPair encUnary encBits) (encPair encBits (encList encBits)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.oneTimeCIEncryptionOracle caller.1 caller.2)) (adversary caller.1 [])).run []) := by obtain ⟨c, d, hlen⟩ := E.encrypt_ppt.length_le let EIn := encPair (encPair encUnary encBits) @@ -1262,7 +1262,7 @@ noncomputable def ciOneTimeFilterHandler (n ctBound : ℕ) (request : Unit × Li noncomputable def ciLimitToOneQuery (ctBound : ℕ → ℕ) (adversary : CIAdversary) : CIAdversary := fun n _ => do let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ciOneTimeFilterHandler n (ctBound n))) (adversary n [])).run false @@ -1306,7 +1306,7 @@ theorem isOraclePPT_ciLimitToOneQuery {ctBound : ℕ → ℕ} have hrun : IsOraclePPTOn (encPair encUnary encBits) (encPair encBits encBool) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ciOneTimeFilterHandler caller.1 (ctBound caller.1))) (adversary caller.1 [])).run false) := by @@ -1319,10 +1319,10 @@ theorem isOraclePPT_ciLimitToOneQuery {ctBound : ℕ → ℕ} intro caller request alreadyQueried _ result hresult unfold ciOneTimeFilterHandler at hresult split_ifs at hresult with hlenEq - · obtain ⟨ct, hct, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawCt, _, rfl⟩ := ProbOracleComp.mem_support_map hct + · obtain ⟨ct, hct, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawCt, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hct exact ⟨trivial, (List.length_take_le _ _).trans (by lia), by simp [encBool_apply]⟩ - · cases ProbOracleComp.eq_of_mem_support_pure hresult + · cases OracleComp.eq_of_mem_supportWith_pure hresult exact ⟨trivial, by simp, by simp [encBool_apply]⟩ unfold ciLimitToOneQuery simpa only [bind_pure_comp] using (hrun.map' (ComputableInPolyTime.fst _ _)).isOraclePPT @@ -1350,7 +1350,7 @@ theorem eval_ciGame_ciLimitToOneQuery (E : SymmetricCipher) (ctBound : ℕ → ProbComp.eval (E.oneTimeCIEncryptionOracle n k request queried)) (fun request state => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) ((ciOneTimeFilterHandler n (ctBound n) request).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -1359,7 +1359,7 @@ theorem eval_ciGame_ciLimitToOneQuery (E : SymmetricCipher) (ctBound : ℕ → change (ProbComp.eval (E.oneTimeCIEncryptionOracle n k request queried)).map (fun x => (x.1, !x.2.isEmpty, x.2)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (ciOneTimeFilterHandler n (ctBound n) request (!queried.isEmpty))).run queried).map (fun result => (result.1.1, result.1.2, result.2)) @@ -1453,7 +1453,7 @@ noncomputable def ccaGame (E : SymmetricCipher) (adversary : CCAAdversary) (bit : Bool) (n : ℕ) : ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.ccaOracle n k bit)) (adversary n [])).run [] return out.1 @@ -1465,7 +1465,7 @@ theorem isPPTOn_run_ccaOracle (E : SymmetricCipher) {adversary : CCAAdversary} IsPPTOn (encPair encUnary encBits) (encPair encBool (encList encBits)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.ccaOracle caller.1 caller.2 bit)) (adversary caller.1 [])).run []) := by obtain ⟨ce, de, hlenEnc⟩ := E.encrypt_ppt.length_le obtain ⟨cd, dd, hlenDec⟩ := E.decrypt_polyTime.tidy.polyBounded_length.exists_le @@ -1668,7 +1668,7 @@ noncomputable def ccaOneTimeGame (E : SymmetricCipher) (adversary : CCAAdversary (bit : Bool) (n : ℕ) : ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.oneTimeCCAOracle n k bit)) (adversary n [])).run [] return out.1 @@ -1680,7 +1680,7 @@ theorem isPPTOn_run_oneTimeCCAOracle (E : SymmetricCipher) {adversary : CCAAdver IsPPTOn (encPair encUnary encBits) (encPair encBool (encList encBits)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.oneTimeCCAOracle caller.1 caller.2 bit)) (adversary caller.1 [])).run []) := by obtain ⟨ce, de, hlenEnc⟩ := E.encrypt_ppt.length_le obtain ⟨cd, dd, hlenDec⟩ := E.decrypt_polyTime.tidy.polyBounded_length.exists_le @@ -1875,7 +1875,7 @@ noncomputable def ccaLimitToOneEncryptionQuery (ctBound : ℕ → ℕ) (decBound (adversary : CCAAdversary) : CCAAdversary := fun n _ => do let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaOneTimeFilterHandler n (ctBound n) decBound)) (adversary n [])).run false @@ -1956,7 +1956,7 @@ theorem isOraclePPT_ccaLimitToOneEncryptionQuery {ctBound : ℕ → ℕ} have hrun : IsOraclePPTOn (encPair encUnary encBits) (encPair encBool encBool) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaOneTimeFilterHandler caller.1 (ctBound caller.1) decBound)) (adversary caller.1 [])).run false) := by @@ -1971,14 +1971,14 @@ theorem isOraclePPT_ccaLimitToOneEncryptionQuery {ctBound : ℕ → ℕ} cases hreq : request.1 · simp only [hreq, Bool.false_eq_true, ↓reduceIte] at hresult split_ifs at hresult with hlenEq - · obtain ⟨ct, hct, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawCt, _, rfl⟩ := ProbOracleComp.mem_support_map hct + · obtain ⟨ct, hct, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawCt, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hct exact ⟨trivial, (List.length_take_le _ _).trans (by lia), by simp [encBool_apply]⟩ - · cases ProbOracleComp.eq_of_mem_support_pure hresult + · cases OracleComp.eq_of_mem_supportWith_pure hresult exact ⟨trivial, by simp, by simp [encBool_apply]⟩ · simp only [hreq, ↓reduceIte] at hresult - obtain ⟨reply, hreply, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawReply, _, rfl⟩ := ProbOracleComp.mem_support_map hreply + obtain ⟨reply, hreply, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawReply, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hreply exact ⟨trivial, (List.length_take_le _ _).trans (by lia), by simp [encBool_apply]⟩ unfold ccaLimitToOneEncryptionQuery simpa only [bind_pure_comp] using (hrun.map' (ComputableInPolyTime.fst _ _)).isOraclePPT @@ -2010,7 +2010,7 @@ theorem eval_ccaGame_ccaLimitToOneEncryptionQuery (E : SymmetricCipher) (ctBound ProbComp.eval (E.oneTimeCCAOracle n k bit request queried)) (fun request state => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaOracle n k bit q s))) ((ccaOneTimeFilterHandler n (ctBound n) decBound request).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -2019,7 +2019,7 @@ theorem eval_ccaGame_ccaLimitToOneEncryptionQuery (E : SymmetricCipher) (ctBound change (ProbComp.eval (E.oneTimeCCAOracle n k bit request queried)).map (fun x => (x.1, !x.2.isEmpty, x.2)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaOracle n k bit q s))) (ccaOneTimeFilterHandler n (ctBound n) decBound request (!queried.isEmpty))).run queried).map @@ -2129,7 +2129,7 @@ noncomputable def ccaRejectGame (E : SymmetricCipher) (adversary : CCAAdversary) (bit : Bool) (n : ℕ) : ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.ccaRejectOracle n k bit)) (adversary n [])).run [] return out.1 @@ -2154,7 +2154,7 @@ noncomputable def ccaToCPAAdversary (ctBound : ℕ → ℕ) (adversary : CCAAdve OracleDistinguisher := fun n _ => do let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaToCPAHandler n (ctBound n))) (adversary n [])).run () @@ -2201,7 +2201,7 @@ theorem isOraclePPT_ccaToCPAAdversary {ctBound : ℕ → ℕ} have hrun : IsOraclePPTOn (encPair encUnary encBits) (encPair encBool (encFinEnum Unit)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaToCPAHandler caller.1 (ctBound caller.1))) (adversary caller.1 [])).run ()) := by @@ -2216,13 +2216,13 @@ theorem isOraclePPT_ccaToCPAAdversary {ctBound : ℕ → ℕ} cases hreq : request.1 · simp only [hreq, Bool.false_eq_true, ↓reduceIte] at hresult split_ifs at hresult with hlenEq - · obtain ⟨ct, hct, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawCt, _, rfl⟩ := ProbOracleComp.mem_support_map hct + · obtain ⟨ct, hct, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawCt, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hct exact ⟨trivial, (List.length_take_le _ _).trans (by lia), by lia⟩ - · cases ProbOracleComp.eq_of_mem_support_pure hresult + · cases OracleComp.eq_of_mem_supportWith_pure hresult exact ⟨trivial, by simp, by lia⟩ · simp only [hreq, ↓reduceIte] at hresult - cases ProbOracleComp.eq_of_mem_support_pure hresult + cases OracleComp.eq_of_mem_supportWith_pure hresult exact ⟨trivial, by simp, by lia⟩ unfold ccaToCPAAdversary simpa only [bind_pure_comp] using (hrun.map' (ComputableInPolyTime.fst _ _)).isOraclePPT @@ -2250,7 +2250,7 @@ theorem eval_cpaGame_ccaToCPAAdversary (E : SymmetricCipher) (ctBound : ℕ → (fun request queried => ProbComp.eval (E.ccaRejectOracle n k bit request queried)) (fun request state => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.cpaEncryptionOracle n k bit q s))) ((ccaToCPAHandler n (ctBound n) request).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -2259,7 +2259,7 @@ theorem eval_cpaGame_ccaToCPAAdversary (E : SymmetricCipher) (ctBound : ℕ → change (ProbComp.eval (E.ccaRejectOracle n k bit request queried)).map (fun x => (x.1, (), ())) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.cpaEncryptionOracle n k bit q s))) (ccaToCPAHandler n (ctBound n) request ())).run ()).map (fun result => (result.1.1, result.1.2, result.2)) @@ -2356,7 +2356,7 @@ noncomputable def ccaToCIAtIndexAdversary (ctBound : ℕ → ℕ) (j : ℕ) (bit (adversary : CCAAdversary) : CIAdversary := fun n _ => do let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaToCIHandler n (ctBound n) bit)) (adversary n [])).run (j, (false, [])) @@ -2505,7 +2505,7 @@ theorem isOraclePPT_ccaToCIAdversary {ctBound Q : ℕ → ℕ} have hrun : IsOraclePPTOn ECaller (encPair encBool EState) (fun caller : (ℕ × List Bool) × ℕ => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaToCIHandler caller.1.1 (ctBound caller.1.1) bit)) (adversary caller.1.1 [])).run (caller.2, (false, []))) := by @@ -2520,7 +2520,7 @@ theorem isOraclePPT_ccaToCIAdversary {ctBound Q : ℕ → ℕ} CCAToCIState.capturedCt CCAToCIState.cap at hresult by_cases hcap : state.2.1 = true · simp only [hcap, ↓reduceIte] at hresult - cases ProbOracleComp.eq_of_mem_support_pure hresult + cases OracleComp.eq_of_mem_supportWith_pure hresult refine ⟨trivial, by simp, ?_⟩ simp only [EState, length_encPair, encUnary_apply, List.length_replicate, encBool_apply, List.length_singleton, encBits_apply] @@ -2530,7 +2530,7 @@ theorem isOraclePPT_ccaToCIAdversary {ctBound Q : ℕ → ℕ} · simp only [hzero, ↓reduceIte] at hresult cases hreq : request.1 <;> simp only [hreq, Bool.false_eq_true, ↓reduceIte] at hresult <;> - cases ProbOracleComp.eq_of_mem_support_pure hresult <;> + cases OracleComp.eq_of_mem_supportWith_pure hresult <;> refine ⟨trivial, by simp, ?_⟩ <;> simp only [EState, length_encPair, encUnary_apply, List.length_replicate, encBool_apply, List.length_singleton, encBits_apply, List.length_nil] <;> @@ -2541,20 +2541,20 @@ theorem isOraclePPT_ccaToCIAdversary {ctBound Q : ℕ → ℕ} by_cases hlenEq : ((unframe request.2).length == caller.1.1 && (dropFrame request.2).length == caller.1.1) = true · simp only [hlenEq, ↓reduceIte] at hresult - obtain ⟨ct, hct, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawCt, _, rfl⟩ := ProbOracleComp.mem_support_map hct + obtain ⟨ct, hct, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawCt, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hct refine ⟨trivial, (List.length_take_le _ _).trans (by lia), ?_⟩ simp only [EState, length_encPair, encUnary_apply, List.length_replicate, encBool_apply, List.length_singleton, encBits_apply, List.length_nil] lia · simp only [hlenEq, Bool.false_eq_true, ↓reduceIte] at hresult - cases ProbOracleComp.eq_of_mem_support_pure hresult + cases OracleComp.eq_of_mem_supportWith_pure hresult refine ⟨trivial, by simp, ?_⟩ simp only [EState, length_encPair, encUnary_apply, List.length_replicate, encBool_apply, List.length_singleton, encBits_apply, List.length_nil] lia · simp only [hreq, ↓reduceIte] at hresult - cases ProbOracleComp.eq_of_mem_support_pure hresult + cases OracleComp.eq_of_mem_supportWith_pure hresult refine ⟨trivial, by simp, ?_⟩ simp only [EState, length_encPair, encUnary_apply, List.length_replicate, encBool_apply, List.length_singleton, encBits_apply, List.length_nil] @@ -2643,11 +2643,11 @@ private noncomputable def ccaRejectWithBadOracle (E : SymmetricCipher) (n : ℕ) private theorem run_ccaWithBadOracle_map_fst (E : SymmetricCipher) (n : ℕ) (k : List Bool) (bit : Bool) (program : WordOracleComp Bool Bool) (queried : List (List Bool)) (bad : Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaWithBadOracle n k bit q s))) program).run (queried, bad)).map (fun (a, s) => (a, s.1)) = (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaOracle n k bit q s))) program).run queried := by refine ProbOracleComp.run_interpret_map_state @@ -2667,11 +2667,11 @@ private theorem run_ccaWithBadOracle_map_fst (E : SymmetricCipher) (n : ℕ) (k private theorem run_ccaRejectWithBadOracle_map_fst (E : SymmetricCipher) (n : ℕ) (k : List Bool) (bit : Bool) (program : WordOracleComp Bool Bool) (queried : List (List Bool)) (bad : Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) program).run (queried, bad)).map (fun (a, s) => (a, s.1)) = (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectOracle n k bit q s))) program).run queried := by refine ProbOracleComp.run_interpret_map_state @@ -2691,16 +2691,16 @@ private theorem run_ccaRejectWithBadOracle_map_fst (E : SymmetricCipher) (n : private theorem identicalUntilBad_ccaRejectWithBad_ccaWithBad (E : SymmetricCipher) (n : ℕ) (k : List Bool) (bit : Bool) : OracleComp.IdenticalUntilBad - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaWithBadOracle n k bit q s))) (fun s => s.2 = true) where agree q s hs a s' hs' := by cases q with | inl m => rfl | inr request => - simp only [ProbOracleComp.handler] + simp only [OracleComp.sumHandler] cases hreq : request.1 · simp only [ccaRejectWithBadOracle, ccaWithBadOracle, hreq, Bool.false_eq_true, ↓reduceIte] · simp only [ccaRejectWithBadOracle, ccaWithBadOracle, hreq, ↓reduceIte] @@ -2719,7 +2719,7 @@ private theorem identicalUntilBad_ccaRejectWithBad_ccaWithBad (E : SymmetricCiph obtain ⟨_, _, rfl⟩ := (PMF.mem_support_map_iff _ _ _).mp hx exact hs | inr request => - simp only [ProbOracleComp.handler, ccaRejectWithBadOracle] at hx + simp only [OracleComp.sumHandler, ccaRejectWithBadOracle] at hx cases hreq : request.1 · simp only [hreq, Bool.false_eq_true, ↓reduceIte] at hx by_cases hlenEq : ((unframe request.2).length == n && @@ -2744,7 +2744,7 @@ private theorem identicalUntilBad_ccaRejectWithBad_ccaWithBad (E : SymmetricCiph obtain ⟨_, _, rfl⟩ := (PMF.mem_support_map_iff _ _ _).mp hx exact hs | inr request => - simp only [ProbOracleComp.handler, ccaWithBadOracle] at hx + simp only [OracleComp.sumHandler, ccaWithBadOracle] at hx cases hreq : request.1 · simp only [hreq, Bool.false_eq_true, ↓reduceIte] at hx by_cases hlenEq : ((unframe request.2).length == n && @@ -2796,7 +2796,7 @@ private theorem ciCombined_captured_bind_eq_one {α : Type} (E : SymmetricCipher (ct : List Bool) (queried : List (List Bool)) (hwin : (!queried.contains ct && (E.decrypt n k ct).isSome) = true) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaToCICombinedOracle n k bit q s))) program).run ((rem, (true, ct)), queried)).bind (fun x => PMF.pure (!x.2.2.contains x.2.1.2.2 && (E.decrypt n k x.2.1.2.2).isSome)) true = @@ -2887,12 +2887,12 @@ private theorem bad_ccaRejectWithBad_le_sum_ciCombined {α : Type} (E : Symmetri (k : List Bool) (bit : Bool) {program : WordOracleComp Bool α} {Q : ℕ} (hq : program.IsQueryBounded Q) (queried : List (List Bool)) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) program).run (queried, false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑ j ∈ Finset.range (Q + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaToCICombinedOracle n k bit q s))) program).run ((j, (false, [])), queried)).bind (fun x => PMF.pure (!x.2.2.contains x.2.1.2.2 && (E.decrypt n k x.2.1.2.2).isSome)) @@ -2905,18 +2905,18 @@ private theorem bad_ccaRejectWithBad_le_sum_ciCombined {α : Type} (E : Symmetri cases q with | inl m => simp only [Sum.elim_inl, Nat.add_zero, OracleComp.run_interpret_bind, - OracleComp.run_interpret_query, ProbOracleComp.handler, StateT.lift, + OracleComp.run_interpret_query, OracleComp.sumHandler, StateT.lift, Probability.PMF.monad_bind_eq_bind, Probability.PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind, PMF.toOuterMeasure_bind_apply, PMF.bind_apply] calc ∑' a : Fin (m + 1), ProbComp.unifOracle m a * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) (cont a)).run (queried, false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑' a : Fin (m + 1), ProbComp.unifOracle m a * ∑ j ∈ Finset.range (Q + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaToCICombinedOracle n k bit q s))) (cont a)).run ((j, (false, [])), queried)).bind (fun x => @@ -2930,7 +2930,7 @@ private theorem bad_ccaRejectWithBad_le_sum_ciCombined {α : Type} (E : Symmetri simp only [← PMF.bind_apply] | inr request => simp only [Sum.elim_inr, OracleComp.run_interpret_bind, OracleComp.run_interpret_query, - ProbOracleComp.handler] + OracleComp.sumHandler] rw [Finset.sum_range_succ'] simp only [eval_ccaRejectWithBadOracle_false, eval_ccaToCICombinedOracle_succ_false, eval_ccaToCICombinedOracle_zero_false] @@ -2946,14 +2946,14 @@ private theorem bad_ccaRejectWithBad_le_sum_ciCombined {α : Type} (E : Symmetri ProbComp.eval (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2)) ct * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) (cont ct)).run (ct :: queried, false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑ j ∈ Finset.range (Q + 1), (ProbComp.eval (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2))).bind (fun ct => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaToCICombinedOracle n k bit q s))) (cont ct)).run ((j, (false, [])), ct :: queried)).bind (fun x => @@ -2964,7 +2964,7 @@ private theorem bad_ccaRejectWithBad_le_sum_ciCombined {α : Type} (E : Symmetri ProbComp.eval (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2)) ct * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) (cont ct)).run (ct :: queried, false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑' ct : List Bool, @@ -2972,7 +2972,7 @@ private theorem bad_ccaRejectWithBad_le_sum_ciCombined {α : Type} (E : Symmetri (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2)) ct * ∑ j ∈ Finset.range (Q + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaToCICombinedOracle n k bit q s))) (cont ct)).run ((j, (false, [])), ct :: queried)).bind (fun x => @@ -3020,12 +3020,12 @@ private theorem eval_ciGame_ccaToCIAtIndexAdversary_key (E : SymmetricCipher) (c ∀ msg, msg.length = n → ∀ ct ∈ (ProbComp.eval (E.encrypt n k msg)).support, ct.length ≤ ctBound n) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (ccaToCIAtIndexAdversary ctBound j bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaToCICombinedOracle n k bit q s))) (adversary n [])).run ((j, (false, [])), [])).bind (fun x => PMF.pure (!x.2.2.contains x.2.1.2.2 && (E.decrypt n k x.2.1.2.2).isSome)) := by @@ -3041,9 +3041,9 @@ private theorem eval_ciGame_ccaToCIAtIndexAdversary_key (E : SymmetricCipher) (c cases q with | inl m => rfl | inr request => - simp only [ProbOracleComp.handler] + simp only [OracleComp.sumHandler] change ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (ccaToCIHandler n (ctBound n) bit request state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2)) = @@ -3099,22 +3099,22 @@ private theorem advantage_ccaGame_ccaRejectGame_le_sum (E : SymmetricCipher) (ct (ProbComp.eval (E.ciGame (ccaToCIAtIndexAdversary ctBound j bit adversary) n)) : ℝ) := by have hccaEq (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaOracle n k bit q s))) (adversary n [])).run []).bind (fun out => PMF.pure out.1) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) := by rw [← run_ccaWithBadOracle_map_fst E n k bit (adversary n []) [] false, PMF.bind_map, Function.comp_def] have hrejEq (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectOracle n k bit q s))) (adversary n [])).run []).bind (fun out => PMF.pure out.1) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) := by rw [← run_ccaRejectWithBadOracle_map_fst E n k bit (adversary n []) [] false, @@ -3126,7 +3126,7 @@ private theorem advantage_ccaGame_ccaRejectGame_le_sum (E : SymmetricCipher) (ct have hsum_eq : pSum = ∑' k : List Bool, ProbComp.eval (E.keyGen n) k * ∑ j ∈ Finset.range (Q n + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (ccaToCIAtIndexAdversary ctBound j bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) true := by @@ -3140,7 +3140,7 @@ private theorem advantage_ccaGame_ccaRejectGame_le_sum (E : SymmetricCipher) (ct rw [Finset.mul_sum] have hCCA_eq : pCCA = ∑' k : List Bool, ProbComp.eval (E.keyGen n) k * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) true := by simp only [pCCA, ccaGame, ProbComp.eval_bind, ProbComp.eval_pure, @@ -3148,7 +3148,7 @@ private theorem advantage_ccaGame_ccaRejectGame_le_sum (E : SymmetricCipher) (ct exact PMF.bind_apply _ _ _ have hRej_eq : pRej = ∑' k : List Bool, ProbComp.eval (E.keyGen n) k * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ccaRejectWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) true := by simp only [pRej, ccaRejectGame, ProbComp.eval_bind, ProbComp.eval_pure, @@ -3204,7 +3204,7 @@ theorem eval_ciGame_ccaToCIAdversary (E : SymmetricCipher) (ctBound Q : ℕ → ProbOracleComp.eval_run_interpret] have hsample (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (do let j ← ProbOracleComp.sample (ProbComp.sampleDyadicIndex (Q n)) @@ -3212,7 +3212,7 @@ theorem eval_ciGame_ccaToCIAdversary (E : SymmetricCipher) (ctBound Q : ℕ → (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) = (PMF.uniformOfFintype (Fin (dyadicSize (Q n)))).bind (fun i => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (ccaToCIAtIndexAdversary ctBound i.val bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome))) := by @@ -3318,7 +3318,7 @@ theorem eval_ciGame_ccaToCIHiddenBitAdversary (E : SymmetricCipher) (ctBound Q : ProbOracleComp.eval_run_interpret] have hsample (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (do let bits ← ProbOracleComp.sample (BitString.sampleList 1) @@ -3329,7 +3329,7 @@ theorem eval_ciGame_ccaToCIHiddenBitAdversary (E : SymmetricCipher) (ctBound Q : (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) = (PMF.uniformOfFintype Bool).bind (fun bit => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.ciEncryptionOracle n k q s))) (ccaToCIAdversary ctBound Q bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome))) := by @@ -3468,19 +3468,19 @@ theorem isQueryBounded_ccaToCPAAdversary_of_isEncryptionQueryBounded unfold ccaToCPAAdversary have hrun : ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaToCPAHandler n (ctBound n))) (adversary n [])).run ()).IsQueryBounded Qe := by refine OracleComp.IsCostBounded.run_interpret (fun q s => ?_) hq () cases q with | inl m => - simp only [ProbOracleComp.handler, Sum.elim_inl] + simp only [OracleComp.sumHandler, Sum.elim_inl] change ((·, s) <$> ProbOracleComp.sample (ProbComp.unifFin m)).IsQueryBounded 0 simp only [OracleComp.isCostBounded_map_iff] exact ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m) | inr request => - simp only [ProbOracleComp.handler, Sum.elim_inr] + simp only [OracleComp.sumHandler, Sum.elim_inr] exact isQueryBounded_ccaToCPAHandler n (ctBound n) request s simpa only [bind_pure_comp, OracleComp.isCostBounded_map_iff] using hrun @@ -3531,19 +3531,19 @@ theorem isQueryBounded_ccaToCIAtIndexAdversary_of_isEncryptionQueryBounded unfold ccaToCIAtIndexAdversary have hrun : ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (ccaToCIHandler n (ctBound n) bit)) (adversary n [])).run (j, (false, []))).IsQueryBounded Qe := by refine OracleComp.IsCostBounded.run_interpret (fun q state => ?_) hq (j, (false, [])) cases q with | inl m => - simp only [ProbOracleComp.handler, Sum.elim_inl] + simp only [OracleComp.sumHandler, Sum.elim_inl] change ((·, state) <$> ProbOracleComp.sample (ProbComp.unifFin m)).IsQueryBounded 0 simp only [OracleComp.isCostBounded_map_iff] exact ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m) | inr request => - simp only [ProbOracleComp.handler, Sum.elim_inr] + simp only [OracleComp.sumHandler, Sum.elim_inr] exact isQueryBounded_ccaToCIHandler n (ctBound n) bit request state simpa only [bind_pure_comp, OracleComp.isCostBounded_map_iff] using hrun @@ -3636,7 +3636,7 @@ noncomputable def ccaOneTimeRejectGame (E : SymmetricCipher) (adversary : CCAAdv (bit : Bool) (n : ℕ) : ProbComp Bool := do let k ← E.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (E.oneTimeCCARejectOracle n k bit)) (adversary n [])).run [] return out.1 @@ -3663,7 +3663,7 @@ theorem eval_cpaOneTimeGame_ccaToCPAAdversary (E : SymmetricCipher) (ctBound : (fun request queried => ProbComp.eval (E.oneTimeCCARejectOracle n k bit request queried)) (fun request state => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCPAEncryptionOracle n k bit q s))) ((ccaToCPAHandler n (ctBound n) request).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -3672,7 +3672,7 @@ theorem eval_cpaOneTimeGame_ccaToCPAAdversary (E : SymmetricCipher) (ctBound : change (ProbComp.eval (E.oneTimeCCARejectOracle n k bit request queried)).map (fun x => (x.1, (), !x.2.isEmpty)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCPAEncryptionOracle n k bit q s))) (ccaToCPAHandler n (ctBound n) request ())).run (!queried.isEmpty)).map (fun result => (result.1.1, result.1.2, result.2)) @@ -3757,11 +3757,11 @@ private noncomputable def oneTimeCCARejectWithBadOracle (E : SymmetricCipher) (n private theorem run_oneTimeCCAWithBadOracle_map_fst (E : SymmetricCipher) (n : ℕ) (k : List Bool) (bit : Bool) (program : WordOracleComp Bool Bool) (queried : List (List Bool)) (bad : Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAWithBadOracle n k bit q s))) program).run (queried, bad)).map (fun (a, s) => (a, s.1)) = (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAOracle n k bit q s))) program).run queried := by refine ProbOracleComp.run_interpret_map_state @@ -3782,11 +3782,11 @@ private theorem run_oneTimeCCARejectWithBadOracle_map_fst (E : SymmetricCipher) (k : List Bool) (bit : Bool) (program : WordOracleComp Bool Bool) (queried : List (List Bool)) (bad : Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) program).run (queried, bad)).map (fun (a, s) => (a, s.1)) = (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectOracle n k bit q s))) program).run queried := by refine ProbOracleComp.run_interpret_map_state @@ -3807,16 +3807,16 @@ private theorem run_oneTimeCCARejectWithBadOracle_map_fst (E : SymmetricCipher) private theorem identicalUntilBad_oneTimeCCARejectWithBad_oneTimeCCAWithBad (E : SymmetricCipher) (n : ℕ) (k : List Bool) (bit : Bool) : OracleComp.IdenticalUntilBad - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAWithBadOracle n k bit q s))) (fun s => s.2 = true) where agree q s hs a s' hs' := by cases q with | inl m => rfl | inr request => - simp only [ProbOracleComp.handler] + simp only [OracleComp.sumHandler] cases hreq : request.1 · simp only [oneTimeCCARejectWithBadOracle, oneTimeCCAWithBadOracle, hreq, Bool.false_eq_true, ↓reduceIte] @@ -3836,7 +3836,7 @@ private theorem identicalUntilBad_oneTimeCCARejectWithBad_oneTimeCCAWithBad obtain ⟨_, _, rfl⟩ := (PMF.mem_support_map_iff _ _ _).mp hx exact hs | inr request => - simp only [ProbOracleComp.handler, oneTimeCCARejectWithBadOracle] at hx + simp only [OracleComp.sumHandler, oneTimeCCARejectWithBadOracle] at hx cases hreq : request.1 · simp only [hreq, Bool.false_eq_true, ↓reduceIte] at hx by_cases hlenEq : (s.1.isEmpty && ((unframe request.2).length == n) && @@ -3861,7 +3861,7 @@ private theorem identicalUntilBad_oneTimeCCARejectWithBad_oneTimeCCAWithBad obtain ⟨_, _, rfl⟩ := (PMF.mem_support_map_iff _ _ _).mp hx exact hs | inr request => - simp only [ProbOracleComp.handler, oneTimeCCAWithBadOracle] at hx + simp only [OracleComp.sumHandler, oneTimeCCAWithBadOracle] at hx cases hreq : request.1 · simp only [hreq, Bool.false_eq_true, ↓reduceIte] at hx by_cases hlenEq : (s.1.isEmpty && ((unframe request.2).length == n) && @@ -3909,7 +3909,7 @@ private theorem oneTimeCICombined_captured_bind_eq_one {α : Type} (E : Symmetri (ct : List Bool) (queried : List (List Bool)) (hwin : (!queried.contains ct && (E.decrypt n k ct).isSome) = true) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAToCICombinedOracle n k bit q s))) program).run ((rem, (true, ct)), queried)).bind (fun x => PMF.pure (!x.2.2.contains x.2.1.2.2 && (E.decrypt n k x.2.1.2.2).isSome)) true = @@ -3990,12 +3990,12 @@ private theorem bad_oneTimeCCARejectWithBad_le_sum_oneTimeCICombined {α : Type} {program : WordOracleComp Bool α} {Q : ℕ} (hq : program.IsQueryBounded Q) (queried : List (List Bool)) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) program).run (queried, false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑ j ∈ Finset.range (Q + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAToCICombinedOracle n k bit q s))) program).run ((j, (false, [])), queried)).bind (fun x => PMF.pure (!x.2.2.contains x.2.1.2.2 && (E.decrypt n k x.2.1.2.2).isSome)) @@ -4008,18 +4008,18 @@ private theorem bad_oneTimeCCARejectWithBad_le_sum_oneTimeCICombined {α : Type} cases q with | inl m => simp only [Sum.elim_inl, Nat.add_zero, OracleComp.run_interpret_bind, - OracleComp.run_interpret_query, ProbOracleComp.handler, StateT.lift, + OracleComp.run_interpret_query, OracleComp.sumHandler, StateT.lift, Probability.PMF.monad_bind_eq_bind, Probability.PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind, PMF.toOuterMeasure_bind_apply, PMF.bind_apply] calc ∑' a : Fin (m + 1), ProbComp.unifOracle m a * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) (cont a)).run (queried, false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑' a : Fin (m + 1), ProbComp.unifOracle m a * ∑ j ∈ Finset.range (Q + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAToCICombinedOracle n k bit q s))) (cont a)).run ((j, (false, [])), queried)).bind (fun x => @@ -4033,7 +4033,7 @@ private theorem bad_oneTimeCCARejectWithBad_le_sum_oneTimeCICombined {α : Type} simp only [← PMF.bind_apply] | inr request => simp only [Sum.elim_inr, OracleComp.run_interpret_bind, OracleComp.run_interpret_query, - ProbOracleComp.handler] + OracleComp.sumHandler] rw [Finset.sum_range_succ'] simp only [eval_oneTimeCCARejectWithBadOracle_false, eval_oneTimeCCAToCICombinedOracle_succ_false, @@ -4049,14 +4049,14 @@ private theorem bad_oneTimeCCARejectWithBad_le_sum_oneTimeCICombined {α : Type} ProbComp.eval (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2)) ct * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) (cont ct)).run ([ct], false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑ j ∈ Finset.range (Q + 1), (ProbComp.eval (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2))).bind (fun ct => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAToCICombinedOracle n k bit q s))) (cont ct)).run ((j, (false, [])), [ct])).bind (fun x => @@ -4067,7 +4067,7 @@ private theorem bad_oneTimeCCARejectWithBad_le_sum_oneTimeCICombined {α : Type} ProbComp.eval (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2)) ct * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) (cont ct)).run ([ct], false)).toOuterMeasure {x | x.2.2 = true} ≤ ∑' ct : List Bool, @@ -4075,7 +4075,7 @@ private theorem bad_oneTimeCCARejectWithBad_le_sum_oneTimeCICombined {α : Type} (E.encrypt n k (if bit then dropFrame request.2 else unframe request.2)) ct * ∑ j ∈ Finset.range (Q + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAToCICombinedOracle n k bit q s))) (cont ct)).run ((j, (false, [])), [ct])).bind (fun x => @@ -4119,12 +4119,12 @@ private theorem eval_ciOneTimeGame_ccaToCIAtIndexAdversary_key (E : SymmetricCip ∀ msg, msg.length = n → ∀ ct ∈ (ProbComp.eval (E.encrypt n k msg)).support, ct.length ≤ ctBound n) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCIEncryptionOracle n k q s))) (ccaToCIAtIndexAdversary ctBound j bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAToCICombinedOracle n k bit q s))) (adversary n [])).run ((j, (false, [])), [])).bind (fun x => PMF.pure (!x.2.2.contains x.2.1.2.2 && (E.decrypt n k x.2.1.2.2).isSome)) := by @@ -4140,9 +4140,9 @@ private theorem eval_ciOneTimeGame_ccaToCIAtIndexAdversary_key (E : SymmetricCip cases q with | inl m => rfl | inr request => - simp only [ProbOracleComp.handler] + simp only [OracleComp.sumHandler] change ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCIEncryptionOracle n k q s))) (ccaToCIHandler n (ctBound n) bit request state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2)) = @@ -4216,22 +4216,22 @@ private theorem advantage_ccaOneTimeGame_ccaOneTimeRejectGame_le_sum (E : Symmet ℝ) := by have hccaEq (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAOracle n k bit q s))) (adversary n [])).run []).bind (fun out => PMF.pure out.1) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) := by rw [← run_oneTimeCCAWithBadOracle_map_fst E n k bit (adversary n []) [] false, PMF.bind_map, Function.comp_def] have hrejEq (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectOracle n k bit q s))) (adversary n [])).run []).bind (fun out => PMF.pure out.1) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) := by rw [← run_oneTimeCCARejectWithBadOracle_map_fst E n k bit (adversary n []) [] false, @@ -4243,7 +4243,7 @@ private theorem advantage_ccaOneTimeGame_ccaOneTimeRejectGame_le_sum (E : Symmet have hsum_eq : pSum = ∑' k : List Bool, ProbComp.eval (E.keyGen n) k * ∑ j ∈ Finset.range (Q n + 1), ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCIEncryptionOracle n k q s))) (ccaToCIAtIndexAdversary ctBound j bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) true := by @@ -4257,7 +4257,7 @@ private theorem advantage_ccaOneTimeGame_ccaOneTimeRejectGame_le_sum (E : Symmet rw [Finset.mul_sum] have hCCA_eq : pCCA = ∑' k : List Bool, ProbComp.eval (E.keyGen n) k * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCAWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) true := by simp only [pCCA, ccaOneTimeGame, ProbComp.eval_bind, ProbComp.eval_pure, @@ -4265,7 +4265,7 @@ private theorem advantage_ccaOneTimeGame_ccaOneTimeRejectGame_le_sum (E : Symmet exact PMF.bind_apply _ _ _ have hRej_eq : pRej = ∑' k : List Bool, ProbComp.eval (E.keyGen n) k * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCCARejectWithBadOracle n k bit q s))) (adversary n [])).run ([], false)).bind (fun out => PMF.pure out.1) true := by simp only [pRej, ccaOneTimeRejectGame, ProbComp.eval_bind, ProbComp.eval_pure, @@ -4324,7 +4324,7 @@ theorem eval_ciOneTimeGame_ccaToCIAdversary (E : SymmetricCipher) (ctBound Q : ProbOracleComp.eval_run_interpret] have hsample (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCIEncryptionOracle n k q s))) (do let j ← ProbOracleComp.sample (ProbComp.sampleDyadicIndex (Q n)) @@ -4332,7 +4332,7 @@ theorem eval_ciOneTimeGame_ccaToCIAdversary (E : SymmetricCipher) (ctBound Q : (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) = (PMF.uniformOfFintype (Fin (dyadicSize (Q n)))).bind (fun i => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCIEncryptionOracle n k q s))) (ccaToCIAtIndexAdversary ctBound i.val bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome))) := by @@ -4438,7 +4438,7 @@ theorem eval_ciOneTimeGame_ccaToCIHiddenBitAdversary (E : SymmetricCipher) (ctBo ProbOracleComp.eval_run_interpret] have hsample (k : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCIEncryptionOracle n k q s))) (do let bits ← ProbOracleComp.sample (BitString.sampleList 1) @@ -4449,7 +4449,7 @@ theorem eval_ciOneTimeGame_ccaToCIHiddenBitAdversary (E : SymmetricCipher) (ctBo (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome)) = (PMF.uniformOfFintype Bool).bind (fun bit => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCIEncryptionOracle n k q s))) (ccaToCIAdversary ctBound Q bit adversary n [])).run []).bind (fun out => PMF.pure (!out.2.contains out.1 && (E.decrypt n k out.1).isSome))) := by diff --git a/Complexity/Crypto/Computational/Encryption/CCA.lean b/Complexity/Crypto/Computational/Encryption/CCA.lean index 969e25cddf..b941cf2ade 100644 --- a/Complexity/Crypto/Computational/Encryption/CCA.lean +++ b/Complexity/Crypto/Computational/Encryption/CCA.lean @@ -300,7 +300,7 @@ theorem CCA2AdversaryOf.IsPPT.query_bounds {Msg : Type} {encMsg : Msg ↪ List B (∀ n pk (State : Type) (oracle : Unit × List Bool → StateT State PMF (List Bool)) s s' choice, (choice, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) oracle) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) oracle) (adversary.choose n pk)).run s).support → choice.2.length ≤ cs * (n + pk.length + 2) ^ ds) := by obtain ⟨c₁, d₁, hchoose⟩ := hA.choose.query_bounds @@ -382,14 +382,14 @@ noncomputable def cca2GameOn {Msg Out : Type} (adversary : CCA2AdversaryOf Msg) (bit : Bool) (n : ℕ) : ProbComp Bool := do let keys ← keyGen n let choiceOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run () let choice := choiceOut.1 if valid n keys.1 (ChoiceOut.msg₀ choice) (ChoiceOut.msg₁ choice) then let ct ← encrypt n keys.1 (if bit then ChoiceOut.msg₁ choice else ChoiceOut.msg₀ choice) let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt n keys.2 ct)) (adversary.guess n (ChoiceOut.state choice) ct)).run () return guessOut.1 @@ -455,7 +455,7 @@ theorem isPPTOn_run_cca2Phase1Oracle {Msg Out : Type} {encMsg : Msg ↪ List Boo (encPair (encPair (encPair encMsg encMsg) encBits) (encFinEnum Unit)) (fun ⟨n, pk, sk⟩ => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n sk)) (adversary.choose n pk)).run ()) := by let ECaller := encPair encUnary (encPair encBits encBits) @@ -513,7 +513,7 @@ theorem isPPTOn_run_cca2Phase2Oracle {Msg Out : Type} {encMsg : Msg ↪ List Boo (encPair encBool (encFinEnum Unit)) (fun ⟨n, sk, state, ct⟩ => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt n sk ct)) (adversary.guess n state ct)).run ()) := by let ECaller := encPair encUnary (encPair encBits (encPair encBits encBits)) @@ -601,7 +601,7 @@ theorem isPPTOn_cca2GameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} {encOut have hphase1 : IsPPTOn E1 EChoice (fun p : ℕ × (List Bool × List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt p.1 p.2.2)) (adversary.choose p.1 p.2.1)).run ()) := isPPTOn_run_cca2Phase1Oracle hdecrypt hA @@ -652,7 +652,7 @@ theorem isPPTOn_cca2GameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} {encOut have hphase2 : IsPPTOn E3 (encPair encBool (encFinEnum Unit)) (fun p : ((ℕ × (List Bool × List Bool)) × (((Msg × Msg) × List Bool) × Unit)) × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt p.1.1.1 p.1.1.2.2 p.2)) (adversary.guess p.1.1.1 p.1.2.1.2 p.2)).run ()) := (isPPTOn_run_cca2Phase2Oracle hdecrypt hA).preprocess hphase2Arg @@ -660,7 +660,7 @@ theorem isPPTOn_cca2GameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} {encOut (fun p : ((ℕ × (List Bool × List Bool)) × (((Msg × Msg) × List Bool) × Unit)) × List Bool => do let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt p.1.1.1 p.1.1.2.2 p.2)) (adversary.guess p.1.1.1 p.1.2.1.2 p.2)).run () return guessOut.1) := @@ -670,7 +670,7 @@ theorem isPPTOn_cca2GameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} {encOut if valid p.1.1 p.1.2.1 p.2.1.1.1 p.2.1.1.2 then do let ct ← encrypt p.1.1 p.1.2.1 (if bit then p.2.1.1.2 else p.2.1.1.1) let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt p.1.1 p.1.2.2 ct)) (adversary.guess p.1.1 p.2.1.2 ct)).run () return guessOut.1 @@ -973,7 +973,7 @@ theorem MultiCCA2AdversaryOf.IsPPT.query_bounds {Msg : Type} {encMsg : Msg ↪ L (∀ n pk (State : Type) (oracle : Unit × List Bool → StateT State PMF (List Bool)) s s' choice, (choice, s') ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) oracle) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) oracle) (adversary.choose n pk)).run s).support → choice.1.length ≤ cs * (n + pk.length + 2) ^ ds ∧ choice.2.length ≤ cs * (n + pk.length + 2) ^ ds) := by @@ -1064,14 +1064,14 @@ noncomputable def cca2MultiGameOn {Msg Out : Type} (adversary : MultiCCA2AdversaryOf Msg) (bit : Bool) (n : ℕ) : ProbComp Bool := do let keys ← keyGen n let choiceOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run () let choice := choiceOut.1 if choice.1.all (fun p => valid n keys.1 p.1 p.2) then let cts ← choice.1.mapM (fun p => encrypt n keys.1 (if bit then p.2 else p.1)) let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt n keys.2 cts)) (adversary.guess n choice.2 cts)).run () return guessOut.1 @@ -1141,7 +1141,7 @@ theorem isPPTOn_run_cca2MultiPhase1Oracle {Msg Out : Type} {encMsg : Msg ↪ Lis (encPair (encPair (encList (encPair encMsg encMsg)) encBits) (encFinEnum Unit)) (fun caller : ℕ × List Bool × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt caller.1 caller.2.2)) (adversary.choose caller.1 caller.2.1)).run ()) := by let ECaller := encPair encUnary (encPair encBits encBits) @@ -1199,7 +1199,7 @@ theorem isPPTOn_run_cca2MultiPhase2Oracle {Msg Out : Type} {encMsg : Msg ↪ Lis (encPair encBool (encFinEnum Unit)) (fun caller : ℕ × List Bool × List Bool × List (List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt caller.1 caller.2.1 caller.2.2.2)) (adversary.guess caller.1 caller.2.2.1 caller.2.2.2)).run ()) := by let ECaller := encPair encUnary (encPair encBits (encPair encBits (encList encBits))) @@ -1292,7 +1292,7 @@ theorem isPPTOn_cca2MultiGameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} have hphase1 : IsPPTOn E1 EChoice (fun p : ℕ × (List Bool × List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt p.1 p.2.2)) (adversary.choose p.1 p.2.1)).run ()) := isPPTOn_run_cca2MultiPhase1Oracle hdecrypt hA @@ -1373,7 +1373,7 @@ theorem isPPTOn_cca2MultiGameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} ((ℕ × (List Bool × List Bool)) × ((List (Msg × Msg) × List Bool) × Unit)) × List (List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt p.1.1.1 p.1.1.2.2 p.2)) (adversary.guess p.1.1.1 p.1.2.1.2 p.2)).run ()) := (isPPTOn_run_cca2MultiPhase2Oracle hdecrypt hA).preprocess hphase2Arg @@ -1382,7 +1382,7 @@ theorem isPPTOn_cca2MultiGameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} ((ℕ × (List Bool × List Bool)) × ((List (Msg × Msg) × List Bool) × Unit)) × List (List Bool) => do let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt p.1.1.1 p.1.1.2.2 p.2)) (adversary.guess p.1.1.1 p.1.2.1.2 p.2)).run () return guessOut.1) := @@ -1393,7 +1393,7 @@ theorem isPPTOn_cca2MultiGameOn {Msg Out : Type} {encMsg : Msg ↪ List Bool} let cts ← p.2.1.1.mapM (fun pair => encrypt p.1.1 p.1.2.1 (if bit then pair.2 else pair.1)) let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt p.1.1 p.1.2.2 cts)) (adversary.guess p.1.1 p.2.1.2 cts)).run () return guessOut.1 @@ -1759,15 +1759,15 @@ theorem eval_run_multiPhase2FilterHandler {Out : Type} (hdecBound : ∀ req, (encOption encOut (decrypt n sk req)).length ≤ decBound req) (prog : WordOracleComp Unit Bool) : ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt n sk ct)) (Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (multiPhase2FilterHandler decBound cts)) prog).run ())).run ()) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt n sk cts)) prog).run ()) := by rw [OracleComp.interpret_map, StateT.run_map, ProbComp.eval_map, @@ -1777,7 +1777,7 @@ theorem eval_run_multiPhase2FilterHandler {Out : Type} (oracle := fun q s => ProbComp.eval (cca2MultiPhase2Oracle encOut decrypt n sk cts q s)) (oracle' := fun q (state : Unit × Unit) => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (cca2Phase2Oracle encOut decrypt n sk ct q s))) ((multiPhase2FilterHandler decBound cts q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -1787,7 +1787,7 @@ theorem eval_run_multiPhase2FilterHandler {Out : Type} change (ProbComp.eval (cca2MultiPhase2Oracle encOut decrypt n sk cts ((), req) ())).map (fun x => (x.1, (), ())) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (cca2Phase2Oracle encOut decrypt n sk ct q s))) (multiPhase2FilterHandler decBound cts ((), req) ())).run ()).map (fun result => (result.1.1, result.1.2, result.2)) @@ -1822,7 +1822,7 @@ noncomputable def cca2MultiHybridCont {Msg Out : Type} let ctsBack ← (choice.1.drop split).mapM (fun p => encrypt n keys.1 p.1) let cts := ctsFront ++ ctsBack let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt n keys.2 cts)) (adversary.guess n choice.2 cts)).run () return guessOut.1 @@ -1840,7 +1840,7 @@ noncomputable def cca2MultiHybridGameOn {Msg Out : Type} (adversary : MultiCCA2AdversaryOf Msg) (split n : ℕ) : ProbComp Bool := do let keys ← keyGen n let choiceOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run () let choice := choiceOut.1 @@ -1873,7 +1873,7 @@ theorem eval_cca2MultiHybridGameOn_of_le {Msg Out : Type} (adversary : MultiCCA2AdversaryOf Msg) (split n : ℕ) (hbound : ∀ keys ∈ (ProbComp.eval (keyGen n)).support, ∀ choiceOut ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run ())).support, choiceOut.1.1.length ≤ split) : @@ -1911,7 +1911,7 @@ noncomputable def cca2MultiToSingleAt {Msg : Type} [Inhabited Msg] if decoded.1 then let cts := decoded.2.2.1 ++ ct :: decoded.2.2.2 Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (multiPhase2FilterHandler (decBound n) cts)) (adversary.guess n decoded.2.1 cts)).run () @@ -2265,7 +2265,7 @@ theorem isOraclePPTOn_cca2MultiToSingleAt_guess {Msg : Type} [Inhabited Msg] have hrun : IsOraclePPTOn (Operation := Unit) EGuess (encPair encBool EState) (fun p : ℕ × List Bool × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (multiPhase2FilterHandler (decBound p.1) ((multiCCA2StateDecoder.decode p.2.1).2.2.1 ++ @@ -2285,15 +2285,15 @@ theorem isOraclePPTOn_cca2MultiToSingleAt_guess {Msg : Type} [Inhabited Msg] intro caller request state _ result hresult unfold multiPhase2FilterHandler at hresult split_ifs at hresult with hmem - · cases ProbOracleComp.eq_of_mem_support_pure hresult + · cases OracleComp.eq_of_mem_supportWith_pure hresult exact ⟨trivial, Nat.zero_le _, Nat.le_add_right _ _⟩ - · obtain ⟨reply, hreply, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawReply, _, rfl⟩ := ProbOracleComp.mem_support_map hreply + · obtain ⟨reply, hreply, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawReply, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hreply exact ⟨trivial, List.length_take_le _ _, Nat.le_add_right _ _⟩ have hyes : IsOraclePPTOn (Operation := Unit) EGuess encBool (fun p : ℕ × List Bool × List Bool => Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (multiPhase2FilterHandler (decBound p.1) ((multiCCA2StateDecoder.decode p.2.1).2.2.1 ++ @@ -2385,7 +2385,7 @@ theorem isQueryBounded_cca2MultiToSingleAt {Msg : Type} [Inhabited Msg] (hQ.2 n (multiCCA2StateDecoder.decode state).2.1 _) () cases q with | inl m => - simpa [ProbOracleComp.handler, StateT.lift] using + simpa [OracleComp.sumHandler, StateT.lift] using (OracleComp.isCostBounded_map_iff (·, s) (ProbOracleComp.sample (ProbComp.unifFin m)) 0).mpr (ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m)) | inr req => @@ -2431,14 +2431,14 @@ theorem eval_cca2GameOn_cca2MultiToSingle {Msg Out : Type} [Inhabited Msg] ProbOracleComp.eval_run_interpret] have hsample (keys : List Bool × List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (cca2Phase1Oracle encOut decrypt n keys.2 q s))) (do let split ← ProbOracleComp.sample (ProbComp.sampleDyadicIndex (Q n)) (cca2MultiToSingleAt valid encrypt decBound adversary split).choose n keys.1)).run ()) = (PMF.uniformOfFintype (Fin (dyadicSize (Q n)))).bind (fun i => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (cca2Phase1Oracle encOut decrypt n keys.2 q s))) ((cca2MultiToSingleAt valid encrypt decBound adversary i.val).choose n keys.1)).run ())) := by @@ -2472,7 +2472,7 @@ private theorem eval_cca2MultiToSingleAt_cont {Msg Out : Type} [Inhabited Msg] (choiceOut : (List (Msg × Msg) × List Bool) × Unit) (hdecBound : ∀ req, (encOption encOut (decrypt n keys.2 req)).length ≤ decBound n req) : (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (if decide (split < choiceOut.1.1.length) && choiceOut.1.1.all (fun p => valid n keys.1 p.1 p.2) then do @@ -2490,7 +2490,7 @@ private theorem eval_cca2MultiToSingleAt_cont {Msg Out : Type} [Inhabited Msg] ProbComp.eval (if valid n keys.1 choice.1.1 choice.1.2 then do let ct ← encrypt n keys.1 (if bit then choice.1.2 else choice.1.1) let guessOut ← (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt n keys.2 ct)) ((cca2MultiToSingleAt valid encrypt decBound adversary split).guess n choice.2 ct)).run () @@ -2522,12 +2522,12 @@ private theorem eval_cca2MultiToSingleAt_cont {Msg Out : Type} [Inhabited Msg] PMF.pure_bind, hvalid_target, ↓reduceIte] have hguess (ctsFront ctsBack : List (List Bool)) (ct : List Bool) : ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase2Oracle encOut decrypt n keys.2 ct)) ((cca2MultiToSingleAt valid encrypt decBound adversary split).guess n (encMultiCCA2State (true, choiceOut.1.2, ctsFront, ctsBack)) ct)).run ()) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2MultiPhase2Oracle encOut decrypt n keys.2 (ctsFront ++ ct :: ctsBack))) (adversary.guess n choiceOut.1.2 (ctsFront ++ ct :: ctsBack))).run ()) := by unfold cca2MultiToSingleAt @@ -2601,7 +2601,7 @@ theorem cca2MultiHybridGameOn_step_gap {Msg Out : Type} [Inhabited Msg] (cca2MultiToSingleAt valid encrypt decBound adversary split) bit n) = (ProbComp.eval (keyGen n)).bind fun keys => (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run ())).bind fun choiceOut => if decide (split < choiceOut.1.1.length) && @@ -2681,7 +2681,7 @@ theorem cca2MultiGameOn_gap {Msg Out : Type} [Inhabited Msg] ∀ req, (encOption encOut (decrypt n keys.2 req)).length ≤ decBound n req) (hQ : ∀ keys ∈ (ProbComp.eval (keyGen n)).support, ∀ choiceOut ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run ())).support, choiceOut.1.1.length ≤ Q n) : @@ -2742,7 +2742,7 @@ theorem advantage_cca2MultiGameOn {Msg Out : Type} [Inhabited Msg] ∀ req, (encOption encOut (decrypt n keys.2 req)).length ≤ decBound n req) (hQ : ∀ keys ∈ (ProbComp.eval (keyGen n)).support, ∀ choiceOut ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run ())).support, choiceOut.1.1.length ≤ Q n) : @@ -2808,7 +2808,7 @@ theorem INDCCA2On.indcca2MultiOn {Msg Out : Type} [Inhabited Msg] (hkeys : keys ∈ (ProbComp.eval (keyGen n)).support) (choiceOut : (List (Msg × Msg) × List Bool) × Unit) (hchoice : choiceOut ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (cca2Phase1Oracle encOut decrypt n keys.2)) (adversary.choose n keys.1)).run ())).support) : choiceOut.1.1.length ≤ Q n := by diff --git a/Complexity/Crypto/Computational/Encryption/EncryptThenMAC.lean b/Complexity/Crypto/Computational/Encryption/EncryptThenMAC.lean index dc0b185de0..acc36c2f30 100644 --- a/Complexity/Crypto/Computational/Encryption/EncryptThenMAC.lean +++ b/Complexity/Crypto/Computational/Encryption/EncryptThenMAC.lean @@ -322,7 +322,7 @@ noncomputable def etmToMACForger (E : SymmetricCipher) (M : MACScheme) (tagBound else (if M.msgLen n == 0 then [false] else [], [])) <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToMACHandler E n (tagBound n) ke)) (adversary n [])).run () @@ -427,7 +427,7 @@ theorem isOraclePPT_etmToMACForger (E : SymmetricCipher) (M : MACScheme) {tagBou have hrun : IsOraclePPTOn (Operation := Unit) ECaller (encPair encBits (encFinEnum Unit)) (fun caller : (ℕ × List Bool) × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToMACHandler E caller.1.1 (tagBound caller.1.1) caller.2)) (adversary caller.1.1 [])).run ()) := by @@ -454,14 +454,14 @@ theorem isOraclePPT_etmToMACForger (E : SymmetricCipher) (M : MACScheme) {tagBou have hcBound : c.length ≤ ce * (2 * caller.1.1 + 2 * caller.2.length + request.2.length + 3) ^ de := hcLen.trans (Nat.mul_le_mul_left ce (Nat.pow_le_pow_left (by lia) de)) - obtain ⟨tag, htag, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawTag, _, rfl⟩ := ProbOracleComp.mem_support_map htag + obtain ⟨tag, htag, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawTag, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp htag have htagTake : (List.take (tagBound caller.1.1) rawTag).length ≤ tagBound caller.1.1 := List.length_take_le _ _ refine ⟨trivial, ?_, by lia⟩ simp only [length_encPair, encBits_apply] lia - · have hresEq := ProbOracleComp.eq_of_mem_support_pure hresult + · have hresEq := OracleComp.eq_of_mem_supportWith_pure hresult subst hresEq exact ⟨trivial, by simp, by lia⟩ have hdecArg : ComputableTidilyInPolyTime @@ -537,7 +537,7 @@ theorem isOraclePPT_etmToMACForger (E : SymmetricCipher) (M : MACScheme) {tagBou else (if M.msgLen caller.1.1 == 0 then [false] else [], [])) <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToMACHandler E caller.1.1 (tagBound caller.1.1) caller.2)) (adversary caller.1.1 [])).run ()) := @@ -614,7 +614,7 @@ theorem eval_sufCmaGame_etmToMACForger (E : SymmetricCipher) (M : MACScheme) ProbComp.eval_bind, ProbComp.eval_pure, ProbOracleComp.eval_run_interpret] have hinner (km : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (M.signingPairOracle km q s))) (do let ke ← ProbOracleComp.sample (E.keyGen n) @@ -625,7 +625,7 @@ theorem eval_sufCmaGame_etmToMACForger (E : SymmetricCipher) (M : MACScheme) else (if M.msgLen n == 0 then [false] else [], [])) <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToMACHandler E n (tagBound n) ke)) (adversary n [])).run ())).run []).bind @@ -634,10 +634,10 @@ theorem eval_sufCmaGame_etmToMACForger (E : SymmetricCipher) (M : MACScheme) M.verify km out.1.1 out.1.2)) = (ProbComp.eval (E.keyGen n)).bind (fun ke => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (M.signingPairOracle km q s))) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToMACHandler E n (tagBound n) ke)) (adversary n [])).run ())).run []).bind @@ -674,7 +674,7 @@ theorem eval_sufCmaGame_etmToMACForger (E : SymmetricCipher) (M : MACScheme) have hsim := ProbOracleComp.run_interpret_map_state (oracle := fun q (state : Unit × List (List Bool × List Bool)) => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (M.signingPairOracle km q s))) (etmToMACHandler E n (tagBound n) ke q state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -760,12 +760,12 @@ theorem isQueryBounded_etmToMACForger (E : SymmetricCipher) (M : MACScheme) refine OracleComp.IsCostBounded.run_interpret (fun q s => ?_) hq () cases q with | inl m => - simp only [ProbOracleComp.handler, Sum.elim_inl] + simp only [OracleComp.sumHandler, Sum.elim_inl] change ((·, s) <$> ProbOracleComp.sample (ProbComp.unifFin m)).IsQueryBounded 0 simp only [OracleComp.isCostBounded_map_iff] exact ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m) | inr request => - simp only [ProbOracleComp.handler, Sum.elim_inr] + simp only [OracleComp.sumHandler, Sum.elim_inr] exact isQueryBounded_etmToMACHandler E n (tagBound n) ke request s /-- Open stateful handler that simulates the `oneTimeCIEncryptionOracle` of `encryptThenMAC E M` @@ -802,7 +802,7 @@ noncomputable def etmToOneTimeMACForger (E : SymmetricCipher) (M : MACScheme) (t else (if M.msgLen n == 0 then [false] else [], [])) <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeMACHandler E n (tagBound n) ke)) (adversary n [])).run false @@ -908,7 +908,7 @@ theorem isOraclePPT_etmToOneTimeMACForger (E : SymmetricCipher) (M : MACScheme) have hrun : IsOraclePPTOn (Operation := Unit) ECaller (encPair encBits encBool) (fun caller : (ℕ × List Bool) × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeMACHandler E caller.1.1 (tagBound caller.1.1) caller.2)) (adversary caller.1.1 [])).run false) := by @@ -935,14 +935,14 @@ theorem isOraclePPT_etmToOneTimeMACForger (E : SymmetricCipher) (M : MACScheme) have hcBound : c.length ≤ ce * (2 * caller.1.1 + 2 * caller.2.length + request.2.length + 3) ^ de := hcLen.trans (Nat.mul_le_mul_left ce (Nat.pow_le_pow_left (by lia) de)) - obtain ⟨tag, htag, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawTag, _, rfl⟩ := ProbOracleComp.mem_support_map htag + obtain ⟨tag, htag, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawTag, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp htag have htagTake : (List.take (tagBound caller.1.1) rawTag).length ≤ tagBound caller.1.1 := List.length_take_le _ _ refine ⟨trivial, ?_, by simp [encBool_apply]⟩ simp only [length_encPair, encBits_apply] lia - · have hresEq := ProbOracleComp.eq_of_mem_support_pure hresult + · have hresEq := OracleComp.eq_of_mem_supportWith_pure hresult subst hresEq exact ⟨trivial, by simp, by simp [encBool_apply]⟩ have hdecArg : ComputableTidilyInPolyTime @@ -1018,7 +1018,7 @@ theorem isOraclePPT_etmToOneTimeMACForger (E : SymmetricCipher) (M : MACScheme) else (if M.msgLen caller.1.1 == 0 then [false] else [], [])) <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeMACHandler E caller.1.1 (tagBound caller.1.1) caller.2)) (adversary caller.1.1 [])).run false) := @@ -1051,12 +1051,12 @@ theorem isQueryBounded_etmToOneTimeMACForger (E : SymmetricCipher) (M : MACSchem refine OracleComp.IsCostBounded.run_interpret (fun q s => ?_) hq false cases q with | inl m => - simp only [ProbOracleComp.handler, Sum.elim_inl] + simp only [OracleComp.sumHandler, Sum.elim_inl] change ((·, s) <$> ProbOracleComp.sample (ProbComp.unifFin m)).IsQueryBounded 0 simp only [OracleComp.isCostBounded_map_iff] exact ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m) | inr request => - simp only [ProbOracleComp.handler, Sum.elim_inr] + simp only [OracleComp.sumHandler, Sum.elim_inr] exact isQueryBounded_etmToOneTimeMACHandler E n (tagBound n) ke request s private noncomputable def etmOneTimeMACIntermediateOracle (E : SymmetricCipher) (M : MACScheme) @@ -1088,7 +1088,7 @@ theorem eval_sufOneTimeGame_etmToOneTimeMACForger (E : SymmetricCipher) (M : MAC ProbComp.eval_bind, ProbComp.eval_pure, ProbOracleComp.eval_run_interpret] have hinner (km : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (M.oneTimeSigningPairOracle km q s))) (do let ke ← ProbOracleComp.sample (E.keyGen n) @@ -1099,7 +1099,7 @@ theorem eval_sufOneTimeGame_etmToOneTimeMACForger (E : SymmetricCipher) (M : MAC else (if M.msgLen n == 0 then [false] else [], [])) <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeMACHandler E n (tagBound n) ke)) (adversary n [])).run false)).run []).bind @@ -1108,10 +1108,10 @@ theorem eval_sufOneTimeGame_etmToOneTimeMACForger (E : SymmetricCipher) (M : MAC M.verify km out.1.1 out.1.2)) = (ProbComp.eval (E.keyGen n)).bind (fun ke => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (M.oneTimeSigningPairOracle km q s))) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeMACHandler E n (tagBound n) ke)) (adversary n [])).run false)).run []).bind @@ -1149,7 +1149,7 @@ theorem eval_sufOneTimeGame_etmToOneTimeMACForger (E : SymmetricCipher) (M : MAC (oracle := etmOneTimeMACIntermediateOracle E M n ke km) (oracle' := fun q (state : Bool × List (List Bool × List Bool)) => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (M.oneTimeSigningPairOracle km q s))) ((etmToOneTimeMACHandler E n (tagBound n) ke q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -1160,7 +1160,7 @@ theorem eval_sufOneTimeGame_etmToOneTimeMACForger (E : SymmetricCipher) (M : MAC change (etmOneTimeMACIntermediateOracle E M n ke km ((), msg) queriedPairs).map (fun x => (x.1, !x.2.isEmpty, x.2)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (M.oneTimeSigningPairOracle km q s))) (etmToOneTimeMACHandler E n (tagBound n) ke ((), msg) (!queriedPairs.isEmpty))).run queriedPairs).map @@ -1259,7 +1259,7 @@ noncomputable def etmToCPAAdversary (M : MACScheme) (adversary : OracleDistingui fun n _ => do let km ← ProbOracleComp.sample (M.keyGen n) Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToCPAHandler M n km)) (adversary n [])).run () @@ -1361,7 +1361,7 @@ theorem isOraclePPT_etmToCPAAdversary (M : MACScheme) {adversary : OracleDisting have hrun : IsOraclePPTOn (Operation := Unit) ECaller (encPair encBool (encFinEnum Unit)) (fun caller : (ℕ × List Bool) × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToCPAHandler M caller.1.1 caller.2)) (adversary caller.1.1 [])).run ()) := by @@ -1381,11 +1381,11 @@ theorem isOraclePPT_etmToCPAAdversary (M : MACScheme) {adversary : OracleDisting dsimp only at hresult split_ifs at hresult with hlenEq · obtain ⟨c, hc, hresult⟩ := OracleComp.mem_supportWith_bind_iff.mp hresult - obtain ⟨rawCt, _, rfl⟩ := ProbOracleComp.mem_support_map hc + obtain ⟨rawCt, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hc have hcTake : (List.take (M.msgLen caller.1.1) rawCt).length ≤ M.msgLen caller.1.1 := List.length_take_le _ _ - obtain ⟨tag, htag, rfl⟩ := ProbOracleComp.mem_support_map hresult - rw [ProbOracleComp.support_sample] at htag + obtain ⟨tag, htag, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + simp only [ProbOracleComp.support_sample] at htag have htagLen := hlenSign (caller.2, List.take (M.msgLen caller.1.1) rawCt) tag htag simp only [length_encPair, encBits_apply] at htagLen have htagBound : tag.length ≤ cs * (2 * caller.2.length + M.msgLen caller.1.1 + 2) ^ ds := @@ -1393,13 +1393,13 @@ theorem isOraclePPT_etmToCPAAdversary (M : MACScheme) {adversary : OracleDisting refine ⟨trivial, ?_, by lia⟩ simp only [length_encPair, encBits_apply] lia - · have hresEq := ProbOracleComp.eq_of_mem_support_pure hresult + · have hresEq := OracleComp.eq_of_mem_supportWith_pure hresult subst hresEq exact ⟨trivial, by simp, by lia⟩ have hrunMap : IsOraclePPTOn (Operation := Unit) ECaller encBool (fun caller : (ℕ × List Bool) × List Bool => Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToCPAHandler M caller.1.1 caller.2)) (adversary caller.1.1 [])).run ()) := @@ -1437,7 +1437,7 @@ theorem eval_cpaGame_etmToCPAAdversary (E : SymmetricCipher) (M : MACScheme) have hsim := ProbOracleComp.run_interpret_map_state (oracle := fun q (state : Unit × Unit) => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.cpaEncryptionOracle n ke bit q s))) (etmToCPAHandler M n km q state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -1531,12 +1531,12 @@ theorem isQueryBounded_etmToCPAAdversary (M : MACScheme) (adversary : OracleDist refine OracleComp.IsCostBounded.run_interpret (fun q s => ?_) hq () cases q with | inl m => - simp only [ProbOracleComp.handler, Sum.elim_inl] + simp only [OracleComp.sumHandler, Sum.elim_inl] change ((·, s) <$> ProbOracleComp.sample (ProbComp.unifFin m)).IsQueryBounded 0 simp only [OracleComp.isCostBounded_map_iff] exact ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m) | inr request => - simp only [ProbOracleComp.handler, Sum.elim_inr] + simp only [OracleComp.sumHandler, Sum.elim_inr] exact isQueryBounded_etmToCPAHandler M n km request s /-- Open stateful handler that simulates the `oneTimeCPAEncryptionOracle` of `encryptThenMAC E M` @@ -1568,7 +1568,7 @@ noncomputable def etmToOneTimeCPAAdversary (M : MACScheme) (adversary : OracleDi fun n _ => do let km ← ProbOracleComp.sample (M.keyGen n) Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeCPAHandler M n km)) (adversary n [])).run false @@ -1671,7 +1671,7 @@ theorem isOraclePPT_etmToOneTimeCPAAdversary (M : MACScheme) {adversary : Oracle have hrun : IsOraclePPTOn (Operation := Unit) ECaller (encPair encBool encBool) (fun caller : (ℕ × List Bool) × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeCPAHandler M caller.1.1 caller.2)) (adversary caller.1.1 [])).run false) := by @@ -1691,11 +1691,11 @@ theorem isOraclePPT_etmToOneTimeCPAAdversary (M : MACScheme) {adversary : Oracle dsimp only at hresult split_ifs at hresult with hlenEq · obtain ⟨c, hc, hresult⟩ := OracleComp.mem_supportWith_bind_iff.mp hresult - obtain ⟨rawCt, _, rfl⟩ := ProbOracleComp.mem_support_map hc + obtain ⟨rawCt, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hc have hcTake : (List.take (M.msgLen caller.1.1) rawCt).length ≤ M.msgLen caller.1.1 := List.length_take_le _ _ - obtain ⟨tag, htag, rfl⟩ := ProbOracleComp.mem_support_map hresult - rw [ProbOracleComp.support_sample] at htag + obtain ⟨tag, htag, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + simp only [ProbOracleComp.support_sample] at htag have htagLen := hlenSign (caller.2, List.take (M.msgLen caller.1.1) rawCt) tag htag simp only [length_encPair, encBits_apply] at htagLen have htagBound : tag.length ≤ cs * (2 * caller.2.length + M.msgLen caller.1.1 + 2) ^ ds := @@ -1703,13 +1703,13 @@ theorem isOraclePPT_etmToOneTimeCPAAdversary (M : MACScheme) {adversary : Oracle refine ⟨trivial, ?_, by simp [encBool_apply]⟩ simp only [length_encPair, encBits_apply] lia - · have hresEq := ProbOracleComp.eq_of_mem_support_pure hresult + · have hresEq := OracleComp.eq_of_mem_supportWith_pure hresult subst hresEq exact ⟨trivial, by simp, by simp [encBool_apply]⟩ have hrunMap : IsOraclePPTOn (Operation := Unit) ECaller encBool (fun caller : (ℕ × List Bool) × List Bool => Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (etmToOneTimeCPAHandler M caller.1.1 caller.2)) (adversary caller.1.1 [])).run false) := @@ -1754,12 +1754,12 @@ theorem isQueryBounded_etmToOneTimeCPAAdversary (M : MACScheme) (adversary : Ora refine OracleComp.IsCostBounded.run_interpret (fun q s => ?_) hq false cases q with | inl m => - simp only [ProbOracleComp.handler, Sum.elim_inl] + simp only [OracleComp.sumHandler, Sum.elim_inl] change ((·, s) <$> ProbOracleComp.sample (ProbComp.unifFin m)).IsQueryBounded 0 simp only [OracleComp.isCostBounded_map_iff] exact ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m) | inr request => - simp only [ProbOracleComp.handler, Sum.elim_inr] + simp only [OracleComp.sumHandler, Sum.elim_inr] exact isQueryBounded_etmToOneTimeCPAHandler M n km request s /-- Running `etmToOneTimeCPAAdversary M adversary` in `E.cpaOneTimeGame` at challenge bit `bit` @@ -1795,7 +1795,7 @@ theorem eval_cpaOneTimeGame_etmToOneTimeCPAAdversary (E : SymmetricCipher) (M : (encPair encBits encBits (ke, km)) bit q alreadyQueried)) (oracle' := fun q (state : Bool × Bool) => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCPAEncryptionOracle n ke bit q s))) ((etmToOneTimeCPAHandler M n km q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -1806,7 +1806,7 @@ theorem eval_cpaOneTimeGame_etmToOneTimeCPAAdversary (E : SymmetricCipher) (M : (encPair encBits encBits (ke, km)) bit ((), payload) alreadyQueried)).map (fun x => (x.1, x.2, x.2)) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun q s => ProbComp.eval (E.oneTimeCPAEncryptionOracle n ke bit q s))) (etmToOneTimeCPAHandler M n km ((), payload) alreadyQueried)).run alreadyQueried).map (fun result => (result.1.1, result.1.2, result.2)) @@ -2202,7 +2202,7 @@ noncomputable def cpaToPrfDistinguisher (adversary : OracleDistinguisher) (bit : fun n _ => Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cpaToPrfHandler n bit)) (adversary n [])).run () @@ -2283,7 +2283,7 @@ theorem isOraclePPT_cpaToPrfDistinguisher {adversary : OracleDistinguisher} have hrun : IsOraclePPTOn (Operation := Unit) ECaller (encPair encBool (encFinEnum Unit)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cpaToPrfHandler caller.1 bit)) (adversary caller.1 [])).run ()) := by @@ -2306,13 +2306,13 @@ theorem isOraclePPT_cpaToPrfDistinguisher {adversary : OracleDistinguisher} (ProbOracleComp.sample (BitString.sampleList caller.1)) at hr rw [ProbOracleComp.support_sample, BitString.eval_sampleList] at hr have hrLen : r.length = caller.1 := BitString.length_of_mem_support_uniformList hr - obtain ⟨pad, hpad, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawPad, _, rfl⟩ := ProbOracleComp.mem_support_map hpad + obtain ⟨pad, hpad, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawPad, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hpad have hpadTake : (List.take caller.1 rawPad).length ≤ caller.1 := List.length_take_le _ _ simp only [List.length_append, List.length_zipWith, hrLen] exact ⟨trivial, by lia, Nat.le_add_right _ _⟩ · simp only [hlenEq, Bool.false_eq_true, ↓reduceIte] at hresult - have hresEq := ProbOracleComp.eq_of_mem_support_pure hresult + have hresEq := OracleComp.eq_of_mem_supportWith_pure hresult subst hresEq exact ⟨trivial, by simp, Nat.le_add_right _ _⟩ unfold cpaToPrfDistinguisher @@ -2336,7 +2336,7 @@ theorem eval_prfRealGame_cpaToPrfDistinguisher (family : List Bool → List Bool have hread := ProbOracleComp.run_interpret_readOnly (fun req (_ : Unit) => PMF.pure (prfOracle family n k req.2)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cpaToPrfHandler n bit)) (adversary n [])).run ()) () @@ -2350,7 +2350,7 @@ theorem eval_prfRealGame_cpaToPrfDistinguisher (family : List Bool → List Bool have hsim := ProbOracleComp.run_interpret_map_state (oracle := fun q (state : Unit × Unit) => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun req (s : Unit) => (PMF.pure (prfOracle family n k req.2)).map (·, s))) (cpaToPrfHandler n bit q state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -2439,7 +2439,7 @@ private theorem eval_prfIdealGame_cpaToPrfDistinguisher (adversary : OracleDisti (bit : Bool) (n : ℕ) : ProbComp.eval (prfIdealGame (cpaToPrfDistinguisher adversary bit) n) = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherFaithfulWithBadOracle n bit)) (adversary n [])).run ([], false)).map Prod.fst := by rw [prfIdealGame_eq_cached, ProbComp.eval_map, ProbOracleComp.eval_run_interpret] @@ -2449,7 +2449,7 @@ private theorem eval_prfIdealGame_cpaToPrfDistinguisher (adversary : OracleDisti have hsim := ProbOracleComp.run_interpret_map_state (oracle := fun q (state : Unit × List (List Bool × List Bool)) => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun req s => ProbComp.eval (cachedRandomFunctionOracle n req.2 s))) (cpaToPrfHandler n bit q state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -2496,11 +2496,11 @@ private theorem eval_prfIdealGame_cpaToPrfDistinguisher (adversary : OracleDisti private theorem run_prfCipherForgetfulWithBadOracle_map_fst (adversary : OracleDistinguisher) (bit : Bool) (n : ℕ) (cache : List (List Bool × List Bool)) (bad : Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit)) (adversary n [])).run (cache, bad)).map Prod.fst = ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherOTPOracle n)) (adversary n [])).run ()).map Prod.fst := by have hsim := ProbOracleComp.run_interpret_map_state @@ -2534,9 +2534,9 @@ private theorem run_prfCipherForgetfulWithBadOracle_map_fst (adversary : OracleD private theorem identicalUntilBad_prfCipherFaithful_forgetful (n : ℕ) (bit : Bool) : OracleComp.IdenticalUntilBad - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherFaithfulWithBadOracle n bit)) - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit)) (fun s => s.2 = true) where agree q s hs a s' hs' := by @@ -2548,7 +2548,7 @@ private theorem identicalUntilBad_prfCipherFaithful_forgetful (n : ℕ) (bit : B have hbad : bad = false := Bool.eq_false_iff.mpr hs have hbad' : bad' = false := Bool.eq_false_iff.mpr hs' subst hbad hbad' - simp only [ProbOracleComp.handler, prfCipherFaithfulWithBadOracle, + simp only [OracleComp.sumHandler, prfCipherFaithfulWithBadOracle, prfCipherForgetfulWithBadOracle, Bool.false_or] by_cases hlenEq : ((unframe request.2).length == n && (dropFrame request.2).length == n) = true @@ -2579,7 +2579,7 @@ private theorem identicalUntilBad_prfCipherFaithful_forgetful (n : ℕ) (bit : B rcases s with ⟨cache, bad⟩ simp only at hs subst hs - simp only [ProbOracleComp.handler, prfCipherFaithfulWithBadOracle, Bool.true_or] at hx + simp only [OracleComp.sumHandler, prfCipherFaithfulWithBadOracle, Bool.true_or] at hx by_cases hlenEq : ((unframe request.2).length == n && (dropFrame request.2).length == n) = true · simp only [hlenEq, ↓reduceIte] at hx @@ -2599,7 +2599,7 @@ private theorem identicalUntilBad_prfCipherFaithful_forgetful (n : ℕ) (bit : B rcases s with ⟨cache, bad⟩ simp only at hs subst hs - simp only [ProbOracleComp.handler, prfCipherForgetfulWithBadOracle, Bool.true_or] at hx + simp only [OracleComp.sumHandler, prfCipherForgetfulWithBadOracle, Bool.true_or] at hx by_cases hlenEq : ((unframe request.2).length == n && (dropFrame request.2).length == n) = true · simp only [hlenEq, ↓reduceIte] at hx @@ -2673,7 +2673,7 @@ private theorem bad_prfCipherForgetfulWithBadOracle_le {α : Type} (n : ℕ) (bi {program : WordOracleComp Unit α} {Q : ℕ} (hq : program.IsQueryBounded Q) (cache : List (List Bool × List Bool)) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit)) program).run (cache, false)).toOuterMeasure {x | x.2.2 = true} ≤ (Q : ℝ≥0∞) * ((cache.length + Q : ℕ) : ℝ≥0∞) * ((1 : ℝ≥0∞) / 2 ^ n) := by @@ -2688,16 +2688,16 @@ private theorem bad_prfCipherForgetfulWithBadOracle_le {α : Type} (n : ℕ) (bi | inl m => simp only [Sum.elim_inl, Nat.add_zero] set B : ℝ≥0∞ := (Q : ℝ≥0∞) * ((cache.length + Q : ℕ) : ℝ≥0∞) * ((1 : ℝ≥0∞) / 2 ^ n) - calc ∑' y, ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + calc ∑' y, OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit) (Sum.inl m) (cache, false) y * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit)) (cont y.1)).run y.2).toOuterMeasure {x | x.2.2 = true} - ≤ ∑' y, ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + ≤ ∑' y, OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit) (Sum.inl m) (cache, false) y * B := by refine tsum_le_tsum fun y => ?_ - by_cases hy : y ∈ (ProbOracleComp.handler + by_cases hy : y ∈ (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit) (Sum.inl m) (cache, false)).support · change y ∈ ((ProbComp.unifOracle m).map (·, (cache, false))).support at hy @@ -2714,7 +2714,7 @@ private theorem bad_prfCipherForgetfulWithBadOracle_le {α : Type} (n : ℕ) (bi have hterm (y : List Bool × (List (List Bool × List Bool) × Bool)) : prfCipherForgetfulWithBadOracle n bit request (cache, false) y * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit)) (cont y.1)).run y.2).toOuterMeasure {x | x.2.2 = true} ≤ prfCipherForgetfulWithBadOracle n bit request (cache, false) y * @@ -2742,7 +2742,7 @@ private theorem bad_prfCipherForgetfulWithBadOracle_le {α : Type} (n : ℕ) (bi · rw [(PMF.apply_eq_zero_iff _ _).mpr hmem, zero_mul, zero_mul] calc ∑' y, prfCipherForgetfulWithBadOracle n bit request (cache, false) y * ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit)) (cont y.1)).run y.2).toOuterMeasure {x | x.2.2 = true} ≤ ∑' y, prfCipherForgetfulWithBadOracle n bit request (cache, false) y * @@ -2784,7 +2784,7 @@ private theorem advantage_prfIdealGame_prfCipherOTPOracle_le (adversary : Oracle (Game.advantage (ProbComp.eval (prfIdealGame (cpaToPrfDistinguisher adversary bit) n)) (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherOTPOracle n)) (adversary n [])).run ()).map Prod.fst) : ℝ) ≤ (Q : ℝ) ^ 2 / (2 : ℝ) ^ n := by @@ -2794,11 +2794,11 @@ private theorem advantage_prfIdealGame_prfCipherOTPOracle_le (adversary : Oracle have hadv := hiub.advantage_le (adversary n []) ([], false) (fun out => PMF.pure out.1) change (Game.advantage (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherFaithfulWithBadOracle n bit)) (adversary n [])).run ([], false)).map Prod.fst) (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherForgetfulWithBadOracle n bit)) (adversary n [])).run ([], false)).map Prod.fst) : ℝ) ≤ _ at hadv rw [hiub.bad_eq] at hadv @@ -2844,7 +2844,7 @@ theorem advantage_cpaGame_prfCipher_le (family : List Bool → List Bool → Lis let pReal1 := ProbComp.eval (prfRealGame family (cpaToPrfDistinguisher adversary true) n) let pIdeal1 := ProbComp.eval (prfIdealGame (cpaToPrfDistinguisher adversary true) n) let pOTP := ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (prfCipherOTPOracle n)) (adversary n [])).run ()).map Prod.fst change (Game.advantage pReal0 pReal1 : ℝ) ≤ diff --git a/Complexity/Crypto/Computational/GGM/Expansion.lean b/Complexity/Crypto/Computational/GGM/Expansion.lean index 4fede9c544..babcb91a8c 100644 --- a/Complexity/Crypto/Computational/GGM/Expansion.lean +++ b/Complexity/Crypto/Computational/GGM/Expansion.lean @@ -67,7 +67,7 @@ def expansionGame (generator : List Bool → List Bool) (sample : ProbComp (List Bool)) (adversary : OracleDistinguisher) (n depth : ℕ) : ProbComp Bool := Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request => expansionOracle generator sample n depth request.2)) (adversary n [])).run [] @@ -151,7 +151,7 @@ theorem isPPTOn_expansionGame {Caller : Type} {input : Caller ↪ List Bool} have hdepth := hdepth.tidy have hrun : IsPPTOn input (encPair encBool cacheEncoding) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request => expansionOracle generator (sample a) (width a) (depth a) request.2)) (adversary (width a) [])).run []) := by apply hadversary.run_interpret_preprocess (operationEncoding := encFinEnum Unit) @@ -242,10 +242,10 @@ theorem expansionGame_generated (generator : List Bool → List Bool) private theorem prefix_eager (n depth width : ℕ) (hdepth : depth ≤ n) (respond : List Bool → List Bool → List Bool) (program : WordOracleComp Unit Bool) : (PMF.uniformOfFintype (BitString depth → BitString width)).bind (fun table => - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifOracle (fun request => + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifOracle (fun request => PMF.pure (if request.2.length = n then respond request.2 (List.ofFn (table (BitString.ofList depth (request.2.take depth)))) else []))) program) = - ((OracleComp.interpret (ProbOracleComp.handler + ((OracleComp.interpret (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun request cache => if request.2.length = n then (memoize (fun _ : List Bool => BitString.uniformList width) @@ -260,10 +260,10 @@ private theorem prefix_eager (n depth width : ℕ) (hdepth : depth ≤ n) (⟨List.ofFn, List.ofFn_injective⟩ : BitString depth ↪ List Bool) List.ofFn (fun _ => PMF.uniformOfFintype (BitString width)) (fun _ => BitString.uniformList width) (fun _ => rfl) (OracleComp.interpret - (ProbOracleComp.handler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) (fun request : Unit × List Bool => adapter request.2)) program) have hstep (query : List Bool) : OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun key => memoize (fun _ : List Bool => BitString.uniformList width) (List.ofFn key))) (adapter query) = fun cache => if query.length = n then (memoize (fun _ : List Bool => BitString.uniformList width) (query.take depth) cache).map @@ -279,12 +279,12 @@ private theorem prefix_eager (n depth width : ℕ) (hdepth : depth ≤ n) rfl have heval (table : BitString depth → BitString width) (query : List Bool) : OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle (fun key => PMF.pure (List.ofFn (table key)))) + (OracleComp.sumHandler ProbComp.unifOracle (fun key => PMF.pure (List.ofFn (table key)))) (adapter query) = PMF.pure (if query.length = n then respond query (List.ofFn (table (BitString.ofList depth (query.take depth)))) else []) := by by_cases hquery : query.length = n <;> simp [adapter, hquery, PMF.pure_map] simpa only [PMF.pi_uniformOfFintype, OracleComp.interpret_interpret, - ProbOracleComp.interpret_handler, ProbOracleComp.interpret_sample, ProbComp.unifFin, + OracleComp.interpret_sumHandler, ProbOracleComp.interpret_sample, ProbComp.unifFin, OracleComp.interpret_query, Function.Embedding.coeFn_mk, hstep, heval, PMF.monad_bind_eq_bind] using h @@ -338,12 +338,12 @@ theorem expansionGame_uniform (generator : List Bool → List Bool) (adversary : ProbComp.eval (expansionGame generator (BitString.sampleList (2 * n)) adversary n depth) = ProbComp.eval (hybridGame generator adversary n (depth + 1)) := by let earlier := fun table : BitString depth → BitString (2 * n) => - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifOracle (fun request => + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifOracle (fun request => PMF.pure (if request.2.length = n then eval generator (selectChild n (List.ofFn (table (BitString.ofList depth (request.2.take depth)))) (request.2[depth]?.getD false)) (request.2.drop (depth + 1)) else []))) (adversary n []) let later := fun table : BitString (depth + 1) → BitString n => - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifOracle (fun request => + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifOracle (fun request => PMF.pure (if request.2.length = n then eval generator (List.ofFn (table (BitString.ofList (depth + 1) (request.2.take (depth + 1))))) (request.2.drop (depth + 1)) else []))) (adversary n []) diff --git a/Complexity/Crypto/Computational/GGM/Hybrid.lean b/Complexity/Crypto/Computational/GGM/Hybrid.lean index 73dcbf8854..c9d04dcfcc 100644 --- a/Complexity/Crypto/Computational/GGM/Hybrid.lean +++ b/Complexity/Crypto/Computational/GGM/Hybrid.lean @@ -73,7 +73,7 @@ noncomputable def frontierOracle (generator : List Bool → List Bool) (n depth noncomputable def hybridGame (generator : List Bool → List Bool) (adversary : OracleDistinguisher) (n depth : ℕ) : ProbComp Bool := Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request => frontierOracle generator n depth request.2)) (adversary n [])).run [] /-- At level zero, all valid queries share one root label. Sampling that label on demand agrees @@ -182,7 +182,7 @@ theorem isPPTOn_hybridGame {generator : List Bool → List Bool} have hgenerator := hgenerator.tidy have hrun : IsPPTOn (encPair encUnary encUnary) (encPair encBool cacheEncoding) (fun pair : ℕ × ℕ => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request => frontierOracle generator pair.1 pair.2 request.2)) (adversary pair.1 [])).run []) := by apply hadversary.run_interpret_preprocess (operationEncoding := encFinEnum Unit) diff --git a/Complexity/Crypto/Computational/GGM/Reduction.lean b/Complexity/Crypto/Computational/GGM/Reduction.lean index 134b72c398..9aba902342 100644 --- a/Complexity/Crypto/Computational/GGM/Reduction.lean +++ b/Complexity/Crypto/Computational/GGM/Reduction.lean @@ -53,7 +53,7 @@ Truncation and the empty fallback make the test total on every challenge list. - def sampleGame (generator : List Bool → List Bool) (adversary : OracleDistinguisher) (n depth : ℕ) (values : List (List Bool)) : ProbComp Bool := Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (OracleComp.withSampleList [] (fun expansion request => expansionOracle generator (pure expansion) n depth request.2))) (adversary n [])).run ([], values) @@ -102,7 +102,7 @@ theorem isPPTOn_sampleGame {Caller : Type} {input : Caller ↪ List Bool} have hrun : IsPPTOn input (encPair encBool (encPair cacheEncoding (encList encBits))) (fun a => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (OracleComp.withSampleList [] (fun expansion request => expansionOracle generator (pure expansion) (width a) (depth a) request.2))) (adversary (width a) [])).run ([], values a)) := by diff --git a/Complexity/Crypto/Computational/GMW/Protocol.lean b/Complexity/Crypto/Computational/GMW/Protocol.lean index 9530cbcbfb..8a9099724c 100644 --- a/Complexity/Crypto/Computational/GMW/Protocol.lean +++ b/Complexity/Crypto/Computational/GMW/Protocol.lean @@ -597,7 +597,7 @@ def twoRoundStep (reply1 reply2 : List Bool → List Bool) (q : List Bool) /-- Run a `WordOracleComp Unit` program against `twoRoundStep` inside `ProbComp`. -/ def runTwoRound {α : Type} (reply1 reply2 : List Bool → List Bool) (prog : WordOracleComp Unit α) (s : ℕ × List Bool) : ProbComp (α × (ℕ × List Bool)) := - (OracleComp.interpret (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (fun q state => pure (twoRoundStep reply1 reply2 q.2 state))) prog).run s @[simp] theorem runTwoRound_pure {α : Type} (reply1 reply2 : List Bool → List Bool) @@ -632,7 +632,7 @@ theorem eval_runTwoRound {α : Type} (reply1 reply2 : List Bool → List Bool) ProbComp.eval (runTwoRound reply1 reply2 prog s) = ProbOracleComp.runWith (fun q state => PMF.pure (twoRoundStep reply1 reply2 q.2 state)) prog s := by - simpa [runTwoRound, ProbOracleComp.runWith] using + simpa [runTwoRound, ProbOracleComp.runWith, OracleComp.runWith] using ProbOracleComp.eval_run_interpret (fun q state => pure (twoRoundStep reply1 reply2 q.2 state)) prog s @@ -694,7 +694,7 @@ theorem run_gmwProver_fst {α : Type} (generator : List Bool → List Bool) (s m simp [P, gmwProver, relate, oracle', PMF.bind_map, Function.comp_def]) prog P.init have hmap := congrArg (PMF.map Prod.fst) hsim have hlhs : (((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) P.respond) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) P.respond) prog).run P.init).bind (fun (a, s') => (relate s').map (a, ·))).map Prod.fst = (P.run prog P.init).map Prod.fst := by simp only [Prover.run, PMF.map_bind, PMF.map_comp, Function.comp_def] diff --git a/Complexity/Crypto/Computational/GMW/Simulator.lean b/Complexity/Crypto/Computational/GMW/Simulator.lean index c365b4c3d6..4b8a0221ed 100644 --- a/Complexity/Crypto/Computational/GMW/Simulator.lean +++ b/Complexity/Crypto/Computational/GMW/Simulator.lean @@ -90,7 +90,7 @@ private theorem runTwoRound_query_inl {α β : Type} (reply1 reply2 : List Bool f <$> runTwoRound reply1 reply2 (OracleComp.query (Sum.inl n) >>= k) s = (ProbComp.unifFin n >>= fun u => f <$> runTwoRound reply1 reply2 (k u) s) := by simp only [runTwoRound, OracleComp.interpret_bind, OracleComp.interpret_query, - ProbOracleComp.handler, StateT.run_bind, StateT.run_lift, bind_assoc, pure_bind, map_bind] + OracleComp.sumHandler, StateT.run_bind, StateT.run_lift, bind_assoc, pure_bind, map_bind] private theorem runTwoRound_query_inr {α β : Type} (reply1 reply2 : List Bool → List Bool) (q : Unit × List Bool) (k : List Bool → WordOracleComp Unit α) (s : ℕ × List Bool) @@ -99,7 +99,7 @@ private theorem runTwoRound_query_inr {α β : Type} (reply1 reply2 : List Bool let step := twoRoundStep reply1 reply2 q.2 s f <$> runTwoRound reply1 reply2 (k step.1) step.2 := by simp only [runTwoRound, OracleComp.interpret_bind, OracleComp.interpret_query, - ProbOracleComp.handler, StateT.run_bind] + OracleComp.sumHandler, StateT.run_bind] rfl private theorem length_snd_mem_support_runTwoRound {α : Type} (r1 r2 : List Bool → List Bool) diff --git a/Complexity/Crypto/Computational/IndexedSignature.lean b/Complexity/Crypto/Computational/IndexedSignature.lean index 6e079b1753..c53cfaf388 100644 --- a/Complexity/Crypto/Computational/IndexedSignature.lean +++ b/Complexity/Crypto/Computational/IndexedSignature.lean @@ -140,7 +140,7 @@ def indexedEufCmaGame (S : IndexedSignatureScheme) (adversary : IndexedForger) ( ProbComp Bool := do let keys ← S.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.indexedSigningOracle n keys.2)) (adversary n keys.1)).run [] return !out.2.contains (out.1.1, out.1.2.1) && S.verify keys.1 out.1.1 out.1.2.1 out.1.2.2 @@ -154,7 +154,7 @@ theorem isPPTOn_run_indexedSigningOracle (S : IndexedSignatureScheme) {adversary (encPair (encPair encUnary (encPair encBits encBits)) (encList (encPair encUnary encBits))) (fun caller : ℕ × (List Bool × List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.indexedSigningOracle caller.1 caller.2.2)) (adversary caller.1 caller.2.1)).run []) := by obtain ⟨c, d, hlen⟩ := S.sign_ppt.length_le diff --git a/Complexity/Crypto/Computational/IndexedSignature/Counter.lean b/Complexity/Crypto/Computational/IndexedSignature/Counter.lean index 9088156c1f..0de3689f54 100644 --- a/Complexity/Crypto/Computational/IndexedSignature/Counter.lean +++ b/Complexity/Crypto/Computational/IndexedSignature/Counter.lean @@ -109,7 +109,7 @@ that was never signed, of any length. -/ def counterEufCmaGame (adversary : Forger) (n : ℕ) : ProbComp Bool := do let keys ← S.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.counterSigningOracle n keys.2)) (adversary n keys.1)).run (0, []) return !out.2.2.contains out.1.1 && S.counterVerify keys.1 out.1.1 out.1.2 @@ -149,7 +149,7 @@ theorem isPPTOn_run_counterSigningOracle {adversary : Forger} (encPair (encPair encBits encBits) (encPair encUnary (encList encBits))) (fun caller : ℕ × (List Bool × List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.counterSigningOracle caller.1 caller.2.2)) (adversary caller.1 caller.2.1)).run (0, [])) := by obtain ⟨c, d, hlen⟩ := S.sign_ppt.length_le @@ -278,7 +278,7 @@ variable (S) in and forward its forgery `(msg, encPair encUnary encBits (u, σ))` as `(u, msg, σ)`. -/ def counterForger (bound : ℕ → ℕ → ℕ) (adversary : Forger) : IndexedForger := fun n pk => do let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (S.counterHandler n bound)) (adversary n pk)).run 0 return ((requestDecoder.decode out.1.2).1, out.1.1, (requestDecoder.decode out.1.2).2) @@ -291,7 +291,7 @@ private noncomputable def jointOracle (n : ℕ) (sk : List Bool) (bound : ℕ (q : Unit × List Bool) (state : ℕ × List (ℕ × List Bool)) : PMF (List Bool × ℕ × List (ℕ × List Bool)) := ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.indexedSigningOracle n sk q s))) ((S.counterHandler n bound q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2)) @@ -329,11 +329,11 @@ private theorem map_run_jointOracle {n : ℕ} {sk : List Bool} {bound : ℕ → σ.length ≤ bound n msg.length) {α : Type} (program : WordOracleComp Unit α) : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (jointOracle S n sk bound)) program).run (0, [])).map (fun r => (r.1, r.2.1, r.2.2.map Prod.snd)) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.counterSigningOracle n sk)) program).run (0, [])) := by rw [ProbOracleComp.eval_run_interpret] refine ProbOracleComp.run_interpret_map_state_of_invariant _ _ @@ -376,7 +376,7 @@ private theorem eval_indexedEufCmaGame_counterForger (bound : ℕ → ℕ → ProbComp.eval (S.indexedEufCmaGame (S.counterForger bound adversary) n) = (ProbComp.eval (S.keyGen n)).bind fun keys => ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (jointOracle S n keys.2 bound)) (adversary n keys.1)).run (0, [])).map (indexedWin S keys.1) := by simp only [indexedEufCmaGame, counterForger, ProbComp.eval_bind, ProbComp.eval_pure, @@ -394,7 +394,7 @@ private theorem eval_counterEufCmaGame_eq {bound : ℕ → ℕ → ℕ} {n : ℕ ProbComp.eval (S.counterEufCmaGame adversary n) = (ProbComp.eval (S.keyGen n)).bind fun keys => ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (jointOracle S n keys.2 bound)) (adversary n keys.1)).run (0, [])).map (fun r => !(r.2.2.map Prod.snd).contains r.1.1 && S.counterVerify keys.1 r.1.1 r.1.2) := by @@ -474,12 +474,12 @@ private theorem counterHandler_bound {bound : ℕ → ℕ → ℕ} (c : ℕ × L (encUnary j).length + (bound c.1 request.2.length + 2 * S.capacity c.1 + 1) := by unfold counterHandler at hresult split_ifs at hresult with hj - · obtain ⟨sig, hsig, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨raw, -, rfl⟩ := ProbOracleComp.mem_support_map hsig + · obtain ⟨sig, hsig, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨raw, -, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hsig have htake := List.length_take_le (bound c.1 request.2.length) raw simp only [length_encPair, encUnary_apply, encBits_apply, List.length_replicate] omega - · have h := ProbOracleComp.eq_of_mem_support_pure hresult + · have h := OracleComp.eq_of_mem_supportWith_pure hresult subst h simp only [List.length_nil, encUnary_apply, List.length_replicate] omega @@ -506,7 +506,7 @@ theorem isOraclePPT_counterForger {bound : ℕ → ℕ → ℕ} (encPair (encPair encBits encBits) encUnary) (fun c : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (S.counterHandler c.1 bound)) (adversary c.1 c.2)).run 0) := hadversary.run_interpret_preprocess_open' (prepare := fun c => c) diff --git a/Complexity/Crypto/Computational/MAC.lean b/Complexity/Crypto/Computational/MAC.lean index e51e6fdcc7..1a23ed4094 100644 --- a/Complexity/Crypto/Computational/MAC.lean +++ b/Complexity/Crypto/Computational/MAC.lean @@ -317,7 +317,7 @@ noncomputable def eufCmaGame (M : MACScheme) (adversary : Forger) (n : ℕ) : ProbComp Bool := do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingOracle sk)) (adversary n [])).run [] let (msg, tag) := out.1 return (msg.length == M.msgLen n) && !out.2.contains msg && @@ -342,7 +342,7 @@ theorem isPPTOn_eufCmaGame (M : MACScheme) {adversary : Forger} (encPair (encPair encBits encBits) (encList encBits)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingOracle caller.2)) (adversary caller.1 [])).run []) := by apply hadversary.run_interpret_preprocess (prepare := fun caller : ℕ × List Bool => (caller.1, ([] : List Bool))) @@ -422,7 +422,7 @@ noncomputable def eufOneTimeGame (M : MACScheme) (adversary : Forger) (n : ℕ) ProbComp Bool := do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningOracle sk)) (adversary n [])).run [] let (msg, tag) := out.1 return (msg.length == M.msgLen n) && !out.2.contains msg && @@ -437,7 +437,7 @@ theorem isPPTOn_run_oneTimeSigningOracle (M : MACScheme) {adversary : Forger} (encPair (encPair encBits encBits) (encList encBits)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningOracle caller.2)) (adversary caller.1 [])).run []) := by obtain ⟨c, d, hlen⟩ := M.sign_ppt.length_le have hhandler : IsPPTOn @@ -524,15 +524,15 @@ private theorem run_limitToOneQuery_eq_oneTimeSigningOracle (M : MACScheme) tag.length ≤ bound n msg.length) (prog : WordOracleComp Unit (List Bool × List Bool)) : ProbComp.eval (Prod.map Prod.fst id <$> ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingOracle sk)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (SignatureScheme.oneTimeFilterHandler bound (n, []))) prog).run false)).run [])) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningOracle sk)) prog).run []) := by rw [ProbComp.eval_map, ProbOracleComp.eval_run_interpret, ProbOracleComp.eval_run_interpret, ProbOracleComp.run_interpret_run_interpret, PMF.map_comp] @@ -541,7 +541,7 @@ private theorem run_limitToOneQuery_eq_oneTimeSigningOracle (M : MACScheme) (oracle := fun q s => ProbComp.eval (M.oneTimeSigningOracle sk q s)) (oracle' := fun q (state : Bool × List (List Bool)) => ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (M.signingOracle sk q s))) ((SignatureScheme.oneTimeFilterHandler bound (n, []) q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -601,14 +601,14 @@ theorem EUFCMA.oneTimeEUFCMA {M : MACScheme} (h : M.EUFCMA) : M.OneTimeEUFCMA := have hrun := run_limitToOneQuery_eq_oneTimeSigningOracle M bound n sk htagBound (adversary n []) have hmap : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingOracle sk)) (SignatureScheme.limitToOneQuery bound adversary n [])).run []) = Prod.map Prod.fst id <$> ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingOracle sk)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (SignatureScheme.oneTimeFilterHandler bound (n, []))) (adversary n [])).run false)).run []) := by @@ -640,7 +640,7 @@ noncomputable def sufCmaGame (M : MACScheme) (adversary : Forger) (n : ℕ) : ProbComp Bool := do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) (adversary n [])).run [] let (msg, tag) := out.1 return (msg.length == M.msgLen n) && !out.2.contains out.1 && @@ -655,7 +655,7 @@ theorem isPPTOn_run_signingPairOracle (M : MACScheme) {adversary : Forger} (encPair (encPair encBits encBits) (encList (encPair encBits encBits))) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle caller.2)) (adversary caller.1 [])).run []) := by obtain ⟨c, d, hlen⟩ := M.sign_ppt.length_le have hhandler : IsPPTOn @@ -788,10 +788,10 @@ messages. -/ theorem eval_run_signingOracle_eq_map_fst_signingPairOracle (M : MACScheme) (sk : List Bool) (prog : WordOracleComp Unit (List Bool × List Bool)) : ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingOracle sk)) prog).run []) = (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) prog).run [])).map (fun (a, s') => (a, s'.map Prod.fst)) := by rw [ProbOracleComp.eval_run_interpret, ProbOracleComp.eval_run_interpret] @@ -812,7 +812,7 @@ theorem eval_eufCmaGame_eq_signingPairOracle (M : MACScheme) ProbComp.eval (do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) (adversary n [])).run [] let (msg, tag) := out.1 return (msg.length == M.msgLen n) && !(out.2.map Prod.fst).contains msg && @@ -876,7 +876,7 @@ private theorem mem_support_signingPairOracle (M : MACScheme) (sk : List Bool) (prog : WordOracleComp Unit (List Bool × List Bool)) (result : List Bool × List Bool) (queriedPairs : List (List Bool × List Bool)) (hmem : (result, queriedPairs) ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) prog).run [])).support) : ∀ pair ∈ queriedPairs, pair.2 ∈ (ProbComp.eval (M.sign sk pair.1)).support := by rw [ProbOracleComp.eval_run_interpret] at hmem @@ -978,7 +978,7 @@ noncomputable def sufOneTimeGame (M : MACScheme) (adversary : Forger) (n : ℕ) ProbComp Bool := do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningPairOracle sk)) (adversary n [])).run [] let (msg, tag) := out.1 return (msg.length == M.msgLen n) && !out.2.contains out.1 && @@ -993,7 +993,7 @@ theorem isPPTOn_run_oneTimeSigningPairOracle (M : MACScheme) {adversary : Forger (encPair (encPair encBits encBits) (encList (encPair encBits encBits))) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningPairOracle caller.2)) (adversary caller.1 [])).run []) := by obtain ⟨c, d, hlen⟩ := M.sign_ppt.length_le have hhandler : IsPPTOn @@ -1134,15 +1134,15 @@ private theorem run_limitToOneQuery_eq_oneTimeSigningPairOracle (M : MACScheme) tag.length ≤ bound n msg.length) (prog : WordOracleComp Unit (List Bool × List Bool)) : ProbComp.eval (Prod.map Prod.fst id <$> ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (SignatureScheme.oneTimeFilterHandler bound (n, []))) prog).run false)).run [])) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningPairOracle sk)) prog).run []) := by rw [ProbComp.eval_map, ProbOracleComp.eval_run_interpret, ProbOracleComp.eval_run_interpret, ProbOracleComp.run_interpret_run_interpret, PMF.map_comp] @@ -1150,7 +1150,7 @@ private theorem run_limitToOneQuery_eq_oneTimeSigningPairOracle (M : MACScheme) (oracle := fun q s => ProbComp.eval (M.oneTimeSigningPairOracle sk q s)) (oracle' := fun q (state : Bool × List (List Bool × List Bool)) => ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (M.signingPairOracle sk q s))) ((SignatureScheme.oneTimeFilterHandler bound (n, []) q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -1211,14 +1211,14 @@ theorem SUFCMA.oneTimeSUFCMA {M : MACScheme} (h : M.SUFCMA) : M.OneTimeSUFCMA := have hrun := run_limitToOneQuery_eq_oneTimeSigningPairOracle M bound n sk htagBound (adversary n []) have hmap : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) (SignatureScheme.limitToOneQuery bound adversary n [])).run []) = Prod.map Prod.fst id <$> ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (SignatureScheme.oneTimeFilterHandler bound (n, []))) (adversary n [])).run false)).run []) := by @@ -1236,10 +1236,10 @@ messages. -/ theorem eval_run_oneTimeSigningOracle_eq_map_fst_oneTimeSigningPairOracle (M : MACScheme) (sk : List Bool) (prog : WordOracleComp Unit (List Bool × List Bool)) : ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningOracle sk)) prog).run []) = (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningPairOracle sk)) prog).run [])).map (fun (a, s') => (a, s'.map Prod.fst)) := by rw [ProbOracleComp.eval_run_interpret, ProbOracleComp.eval_run_interpret] @@ -1262,7 +1262,7 @@ theorem eval_eufOneTimeGame_eq_oneTimeSigningPairOracle (M : MACScheme) ProbComp.eval (do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningPairOracle sk)) (adversary n [])).run [] let (msg, tag) := out.1 return (msg.length == M.msgLen n) && !(out.2.map Prod.fst).contains msg && @@ -1309,7 +1309,7 @@ private theorem mem_support_oneTimeSigningPairOracle (M : MACScheme) (sk : List (prog : WordOracleComp Unit (List Bool × List Bool)) (result : List Bool × List Bool) (queriedPairs : List (List Bool × List Bool)) (hmem : (result, queriedPairs) ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.oneTimeSigningPairOracle sk)) prog).run [])).support) : ∀ pair ∈ queriedPairs, pair.2 ∈ (ProbComp.eval (M.sign sk pair.1)).support := by rw [ProbOracleComp.eval_run_interpret] at hmem @@ -1626,7 +1626,7 @@ the PRF security game [Boneh and Shoup, Section 6.3, Theorem 6.2][BonehShoup2023 def macToPrfDistinguisher (adversary : Forger) : OracleDistinguisher := fun n _ => do let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (macLogHandler n)) (adversary n [])).run [] @@ -1659,7 +1659,7 @@ theorem isOraclePPT_macToPrfDistinguisher {adversary : Forger} (encPair (encPair encBits encBits) (encList encBits)) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (macLogHandler caller.1)) (adversary caller.1 [])).run []) := by @@ -1671,8 +1671,8 @@ theorem isOraclePPT_macToPrfDistinguisher {adversary : Forger} (fun _ _ => True) (fun _ => trivial) (by polytime) intro caller request queried _ result hresult unfold macLogHandler at hresult - obtain ⟨tag, htag, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawTag, _, rfl⟩ := ProbOracleComp.mem_support_map htag + obtain ⟨tag, htag, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawTag, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp htag refine ⟨trivial, ?_, ?_⟩ · exact (List.length_take_le _ _).trans (by lia) · simp only [encList_cons, List.length_append, length_frame, encBits_apply] @@ -1708,20 +1708,20 @@ private theorem run_macLogHandler_eq_signingOracle (n : ℕ) (sk : List Bool) (hsk : sk.length = n) (prog : WordOracleComp Unit (List Bool × List Bool)) : ProbComp.eval (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (prfOracle family n sk request.2))) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (macLogHandler n)) prog).run [])) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) ((prfMAC family hpoly).signingOracle sk)) prog).run []) := by have hread := ProbOracleComp.run_interpret_readOnly (fun request (_ : Unit) => PMF.pure (prfOracle family n sk request.2)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (macLogHandler n)) prog).run []) () @@ -1734,7 +1734,7 @@ private theorem run_macLogHandler_eq_signingOracle have hsim := ProbOracleComp.run_interpret_map_state (oracle := fun q (state : List (List Bool) × Unit) => ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun request (u : Unit) => (PMF.pure (prfOracle family n sk request.2)).map (·, u))) ((macLogHandler n q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -1744,7 +1744,7 @@ private theorem run_macLogHandler_eq_signingOracle intro ⟨⟨⟩, msg⟩ ⟨queried, ⟨⟩⟩ change PMF.map (fun (a, s') => (a, s'.1)) (((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun request (u : Unit) => (PMF.pure (prfOracle family n sk request.2)).map (·, u))) (macLogHandler n ((), msg) queried)).run ()).map (fun result => (result.1.1, result.1.2, result.2))) = @@ -1828,26 +1828,26 @@ theorem succProbability_prfIdealGame_macToPrfDistinguisher_le (adversary : Forge PMF (List Bool) := fun q state => ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun request => lazyRandomFunctionOracle n request.2)) ((macLogHandler n q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2)) let phase1 := ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) combinedOracle) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) combinedOracle) (adversary n [])).run ([], fun _ => none)) let phase2 : ((List Bool × List Bool) × List (List Bool) × RandomOracle.Cache (fun _ : BitString n => BitString n)) → PMF Bool := fun ⟨out, queried, cache⟩ => if (out.1.length == n) && !queried.contains out.1 then ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun request => lazyRandomFunctionOracle n request.2)) ((· == out.2) <$> (List.take n <$> ProbOracleComp.query ((), out.1)))).run cache).map Prod.fst else PMF.pure false have hgame : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun request => lazyRandomFunctionOracle n request.2)) (macToPrfDistinguisher adversary n [])).run (fun _ => none)).map Prod.fst = phase1.bind phase2 := by @@ -2304,7 +2304,7 @@ noncomputable def sufCmaGame (M : NonceMACScheme) (adversary : NonceMACForger) ( ProbComp Bool := do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) (adversary n [])).run [] let ((msg, nonce), tag) := out.1 return (msg.length == M.msgLen n) && (nonce.length == M.nonceLen n) && @@ -2318,7 +2318,7 @@ noncomputable def eufCmaGame (M : NonceMACScheme) (adversary : NonceMACForger) ( ProbComp Bool := do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) (adversary n [])).run [] let ((msg, nonce), tag) := out.1 return (msg.length == M.msgLen n) && (nonce.length == M.nonceLen n) && @@ -2336,7 +2336,7 @@ theorem isPPTOn_run_signingPairOracle (M : NonceMACScheme) {adversary : NonceMAC (encList (encPair (encPair encBits encBits) encBits))) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle caller.2)) (adversary caller.1 [])).run []) := by obtain ⟨c, d, hlen⟩ := M.sign_ppt.length_le have hhandler : IsPPTOn @@ -2558,7 +2558,7 @@ private theorem mem_support_signingPairOracle (M : NonceMACScheme) (sk : List Bo (result : (List Bool × List Bool) × List Bool) (queriedTriples : List ((List Bool × List Bool) × List Bool)) (hmem : (result, queriedTriples) ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) prog).run [])).support) : ∀ triple ∈ queriedTriples, triple.2 ∈ (ProbComp.eval (M.sign sk triple.1.1 triple.1.2)).support := by @@ -2593,7 +2593,7 @@ theorem eval_sufCmaGame_eq_freshPair_of_unique_tag (M : NonceMACScheme) ProbComp.eval (do let sk ← M.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (M.signingPairOracle sk)) (adversary n [])).run [] let (pair, tag) := out.1 let (msg, nonce) := pair diff --git a/Complexity/Crypto/Computational/MerkleSignature/Security.lean b/Complexity/Crypto/Computational/MerkleSignature/Security.lean index 3e4dae0a3b..5c1f715987 100644 --- a/Complexity/Crypto/Computational/MerkleSignature/Security.lean +++ b/Complexity/Crypto/Computational/MerkleSignature/Security.lean @@ -121,7 +121,7 @@ noncomputable def collisionFinder (adversary : IndexedForger) : CollisionFinder := fun n k => do let keys ← OracleComp.replicate (2 ^ depth n) (S.keyGen n) let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbComp.unifFin j)) + (OracleComp.sumHandler (fun j => StateT.lift (ProbComp.unifFin j)) ((scheme S H depth hH hlen hcap).indexedSigningOracle n (secretKey k keys))) (adversary n (publicKey H k keys))).run [] return collisionOf H k keys out @@ -163,7 +163,7 @@ noncomputable def oneTimeForgerAt (bound : ℕ → ℕ) (adversary : IndexedForg Forger := fun n vk => do let setup ← ProbOracleComp.sample (plantKeys S depth n i vk) let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin j))) + (OracleComp.sumHandler (fun j => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin j))) (plantedHandler S H depth n setup.1 setup.2 i (bound n))) (adversary n (publicKey H setup.1 setup.2))).run [] return (H setup.1 out.1.2.1, (signatureDecoder.decode out.1.2.2).2.1) @@ -196,15 +196,15 @@ private theorem eval_run_plantedHandler σ.length ≤ b) {α : Type} (program : WordOracleComp Unit α) : (OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbComp.unifOracle j)) + (OracleComp.sumHandler (fun j => StateT.lift (ProbComp.unifOracle j)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle x.2 q s))) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun j => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin j))) (plantedHandler S H depth n k (front ++ (x.1, []) :: back) front.length b)) program).run [])).run [] = (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbComp.unifFin j)) + (OracleComp.sumHandler (fun j => StateT.lift (ProbComp.unifFin j)) ((scheme S H depth hH hlen hcap).indexedSigningOracle n (secretKey k (front ++ x :: back)))) program).run [])).map (fun r => (r, otsLogOf H front.length k r.2)) := by @@ -215,7 +215,7 @@ private theorem eval_run_plantedHandler (secretKey k (front ++ x :: back)) q signed)) (oracle' := fun (q : Unit × List Bool) (state : List (ℕ × List Bool) × List (List Bool)) => ((OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbComp.unifOracle j)) + (OracleComp.sumHandler (fun j => StateT.lift (ProbComp.unifOracle j)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle x.2 q s))) ((plantedHandler S H depth n k (front ++ (x.1, []) :: back) front.length b q).run state.1)).run state.2).map @@ -229,7 +229,7 @@ private theorem eval_run_plantedHandler (pure a : StateT σ PMF β) state = PMF.pure (a, state) := fun _ _ => rfl have hsampleApply : ∀ {β : Type} (p : ProbComp β) (state : List (List Bool)), (OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbComp.unifOracle j)) + (OracleComp.sumHandler (fun j => StateT.lift (ProbComp.unifOracle j)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle x.2 q s))) (ProbOracleComp.sample p)) state = (ProbComp.eval p).map (·, state) := fun p state => ProbOracleComp.run_interpret_sample _ p state @@ -284,7 +284,7 @@ private noncomputable def realRun (adversary : IndexedForger) (n : ℕ) (k : List Bool) (keys : List (List Bool × List Bool)) : PMF ((ℕ × List Bool × List Bool) × List (ℕ × List Bool)) := ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbComp.unifFin j)) + (OracleComp.sumHandler (fun j => StateT.lift (ProbComp.unifFin j)) ((scheme S H depth hH hlen hcap).indexedSigningOracle n (secretKey k keys))) (adversary n (publicKey H k keys))).run []) @@ -653,7 +653,7 @@ theorem isPPT_collisionFinder {adversary : IndexedForger} (encPair (encPair encUnary (encPair encBits encBits)) (encList (encPair encUnary encBits))) (fun q : (ℕ × List Bool) × List (List Bool × List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun j => StateT.lift (ProbComp.unifFin j)) + (OracleComp.sumHandler (fun j => StateT.lift (ProbComp.unifFin j)) ((scheme S H depth hH hlen hcap).indexedSigningOracle q.1.1 (secretKey q.1.2 q.2))) (adversary q.1.1 (publicKey H q.1.2 q.2))).run []) := hrun₀.preprocess (prepare := fun q : (ℕ × List Bool) × List (List Bool × List Bool) => @@ -901,8 +901,8 @@ private theorem plantedHandler_bound (hlen : ∀ k m, (H k m).length = k.length) unfold plantedHandler at hres dsimp only at hres split_ifs at hres with hguard hi - · obtain ⟨ots, hots, rfl⟩ := ProbOracleComp.mem_support_map hres - obtain ⟨raw, -, rfl⟩ := ProbOracleComp.mem_support_map hots + · obtain ⟨ots, hots, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hres + obtain ⟨raw, -, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hots have htake := List.length_take_le (bound n) raw have hvk := (hkeyLen i).1 have hp := hpath i @@ -912,10 +912,9 @@ private theorem plantedHandler_bound (hlen : ∀ k m, (H k m).length = k.length) · simp only [hdecode, encList_cons, encPair_apply, encUnary_apply, encBits_apply, List.length_append, length_frame, List.length_replicate] omega - · obtain ⟨sig, hsig, rfl⟩ := ProbOracleComp.mem_support_map hres - rw [ProbOracleComp.support_sample] at hsig - simp only [signWith, ProbComp.eval_bind, ProbComp.eval_pure, PMF.mem_support_bind_iff, - PMF.mem_support_pure_iff] at hsig + · obtain ⟨sig, hsig, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hres + simp only [ProbOracleComp.support_sample, signWith, ProbComp.eval_bind, ProbComp.eval_pure, + PMF.mem_support_bind_iff, PMF.mem_support_pure_iff] at hsig obtain ⟨ots, hots, rfl⟩ := hsig have hotsLen := hsignLen (_, _) ots hots simp only [encBits_apply, encPair_apply, List.length_append, length_frame, hlen] at hotsLen @@ -932,7 +931,7 @@ private theorem plantedHandler_bound (hlen : ∀ k m, (H k m).length = k.length) · simp only [hdecode, encList_cons, encPair_apply, encUnary_apply, encBits_apply, List.length_append, length_frame, List.length_replicate] omega - · have h := ProbOracleComp.eq_of_mem_support_pure hres + · have h := OracleComp.eq_of_mem_supportWith_pure hres subst h exact ⟨by simp, Nat.le_add_right _ _⟩ @@ -975,7 +974,7 @@ theorem isOraclePPT_oneTimeForger {bound : ℕ → ℕ} (encPair (encPair encUnary (encPair encBits encBits)) (encList (encPair encUnary encBits))) (fun c : ((ℕ × List Bool) × ℕ) × (List Bool × List (List Bool × List Bool)) => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun j => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin j))) (plantedHandler S H depth c.1.1.1 c.2.1 c.2.2 c.1.2 (bound c.1.1.1))) (adversary c.1.1.1 (publicKey H c.2.1 c.2.2))).run []) := @@ -1017,7 +1016,7 @@ theorem isOraclePPT_oneTimeForger {bound : ℕ → ℕ} (second := fun (c : (ℕ × List Bool) × ℕ) (setup : List Bool × List (List Bool × List Bool)) => do let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun j => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin j))) (plantedHandler S H depth c.1.1 setup.1 setup.2 c.2 (bound c.1.1))) (adversary c.1.1 (publicKey H setup.1 setup.2))).run [] diff --git a/Complexity/Crypto/Computational/NaorReingold/PRF.lean b/Complexity/Crypto/Computational/NaorReingold/PRF.lean index fd3bf4138b..ad5a0478b5 100644 --- a/Complexity/Crypto/Computational/NaorReingold/PRF.lean +++ b/Complexity/Crypto/Computational/NaorReingold/PRF.lean @@ -346,7 +346,7 @@ private theorem advantage_evalNaorReingoldTape_uniform_le (inLen outLen : ℕ (expWidth n + (inLen n * expWidth n + outLen n * (2 * bound (desc n) + 1)))).bind fun tape => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then F.evalNaorReingoldTape inLen outLen desc bound expWidth n tape request.2 else [])) @@ -364,7 +364,7 @@ private theorem advantage_evalNaorReingoldTape_uniform_le (inLen outLen : ℕ fun p => (Cslib.BitString.uniformList H).bind fun seed => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then F.linearHashKDF (fun _ => ℓ) bound ((d, seed), F.encode d (F.naorReingoldEval d p.1 p.2 @@ -377,7 +377,7 @@ private theorem advantage_evalNaorReingoldTape_uniform_le (inLen outLen : ℕ have hlhs : ((Cslib.BitString.uniformList (E + (m * E + H))).bind fun tape => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then F.evalNaorReingoldTape inLen outLen desc bound expWidth n tape request.2 else [])) @@ -387,7 +387,7 @@ private theorem advantage_evalNaorReingoldTape_uniform_le (inLen outLen : ℕ (fun law : PMF (ℕ × List ℕ × List Bool) => law.bind fun parsed => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then F.naorReingoldHashedWordEval ℓ bound d parsed.2.2 parsed.1 parsed.2.1 request.2 else [])) @@ -403,7 +403,7 @@ private theorem advantage_evalNaorReingoldTape_uniform_le (inLen outLen : ℕ cases q with | inl r => rfl | inr request => - dsimp only [ProbOracleComp.handler] + dsimp only [OracleComp.sumHandler] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte, naorReingoldHashedWordEval] have hxs : List.ofFn (BitString.ofList m request.2) = request.2 := @@ -423,7 +423,7 @@ private theorem advantage_evalNaorReingoldTape_uniform_le (inLen outLen : ℕ change ((Cslib.BitString.uniformList H).bind fun seed => ν.bind fun α₀ => (PMF.uniformOfFintype (Fin m → ZMod (F.order d))).bind fun α => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then F.linearHashKDF (fun _ => ℓ) bound ((d, seed), F.encode d (F.naorReingoldEval d α₀ α (BitString.ofList m request.2))) @@ -471,7 +471,7 @@ private theorem naorReingoldHashedIdealGame_pure_const (inLen outLen : ℕ → (fun k _ => adversary k []) n = (PMF.uniformOfFintype (BitString (inLen n) → BitString (outLen n))).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then List.ofFn (f (BitString.ofList (inLen n) request.2)) else [])) @@ -542,7 +542,7 @@ private noncomputable def prfTapeDistinguisher (F : PrimeOrderGroupFamily) (adversary : OracleDistinguisher) : Distinguisher := fun n tape => Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) fun request _ => pure (if request.2.length = n then F.evalNaorReingoldTape id id desc bound expWidth n tape request.2 @@ -632,7 +632,7 @@ private theorem eval_prfTapeDistinguisher (F : PrimeOrderGroupFamily) (adversary : OracleDistinguisher) (n : ℕ) (tape : List Bool) : ProbComp.eval (prfTapeDistinguisher F desc bound expWidth adversary n tape) = OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = n then F.evalNaorReingoldTape id id desc bound expWidth n tape request.2 else [])) @@ -640,12 +640,12 @@ private theorem eval_prfTapeDistinguisher (F : PrimeOrderGroupFamily) simp only [prfTapeDistinguisher, ProbComp.eval_map, ProbOracleComp.eval_run_interpret, ProbComp.eval_pure] have hH : - ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) (fun (request : Unit × List Bool) (_ : Unit) => PMF.pure (if request.2.length = n then F.evalNaorReingoldTape id id desc bound expWidth n tape request.2 else [], ())) = - fun q => StateT.lift (ProbOracleComp.handler ProbComp.unifOracle + fun q => StateT.lift (OracleComp.sumHandler ProbComp.unifOracle (fun request => PMF.pure (if request.2.length = n then F.evalNaorReingoldTape id id desc bound expWidth n tape request.2 else [])) q) := by @@ -654,7 +654,7 @@ private theorem eval_prfTapeDistinguisher (F : PrimeOrderGroupFamily) | inl r => rfl | inr request => funext u - simp [ProbOracleComp.handler, StateT.lift, PMF.monad_pure_eq_pure] + simp [OracleComp.sumHandler, StateT.lift, PMF.monad_pure_eq_pure] rw [hH, OracleComp.run_interpret_lift, ← PMF.monad_map_eq_map, Functor.map_map] exact id_map _ @@ -734,7 +734,7 @@ theorem DDH.pseudorandomFunction_naorReingoldSeeded {F : PrimeOrderGroupFamily} cases q with | inl r => rfl | inr request => - dsimp only [ProbOracleComp.handler, prfOracle] + dsimp only [OracleComp.sumHandler, prfOracle] by_cases hq : request.2.length = n · simp only [hq, ↓reduceIte, naorReingoldSeededPRF_eq_evalTape, hklen] · simp [hq] @@ -742,7 +742,7 @@ theorem DDH.pseudorandomFunction_naorReingoldSeeded {F : PrimeOrderGroupFamily} distinguishingGame (BitString.uniformList (targetLen n)) (D_tape n) = (BitString.uniformList need).bind fun tape => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = n then F.evalNaorReingoldTape id id desc bound expWidth n tape request.2 else [])) @@ -754,7 +754,7 @@ theorem DDH.pseudorandomFunction_naorReingoldSeeded {F : PrimeOrderGroupFamily} cases q with | inl r => rfl | inr request => - dsimp only [ProbOracleComp.handler] + dsimp only [OracleComp.sumHandler] rw [evalNaorReingoldTape_take F id id desc bound expWidth (limit := need) le_rfl] have hideal_eq : ProbComp.eval (prfIdealGame adversary n) = @@ -1019,11 +1019,11 @@ theorem DDH.exists_pseudorandomGenerator {F : PrimeOrderGroupFamily} {desc : ℕ refine negligible_of_le (hexp_neg.add hnr_neg) fun n => ?_ have hinterp (oracle : List Bool → List Bool) : OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => PMF.pure (oracle request.2)) + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (oracle request.2)) (adv n []) = ProbComp.eval (D n ((queries n).map fun word => (oracle word).headD false)) := by change OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => pure (oracle request.2)) + (OracleComp.sumHandler ProbComp.unifOracle fun request => pure (oracle request.2)) (KabanetsCai.queryTable (queries n) >>= fun word => ProbOracleComp.sample (D n word)) = _ rw [OracleComp.interpret_bind, KabanetsCai.interpret_queryTable ProbComp.unifOracle oracle (queries n), @@ -1034,7 +1034,7 @@ theorem DDH.exists_pseudorandomGenerator {F : PrimeOrderGroupFamily} {desc : ℕ (BitString.uniformList (expWidth n + (inBits n * expWidth n + 1 * (2 * bound (desc n) + 1)))).bind fun tape => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inBits n then F.evalNaorReingoldTape inBits (fun _ => 1) desc bound expWidth n tape request.2 else [])) diff --git a/Complexity/Crypto/Computational/NaorReingold/Security.lean b/Complexity/Crypto/Computational/NaorReingold/Security.lean index 19c11bef21..418c072b7b 100644 --- a/Complexity/Crypto/Computational/NaorReingold/Security.lean +++ b/Complexity/Crypto/Computational/NaorReingold/Security.lean @@ -169,7 +169,7 @@ theorem isPPTOn_sampleNaorReingoldExp {α : Type} {input : α ↪ List Bool} private noncomputable def naorReingoldWordRun (F : PrimeOrderGroupFamily) (d : F.Desc) {m : ℕ} (prog : WordOracleComp Unit Bool) (fn : BitString m → F.Carrier d) : PMF Bool := OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (F.naorReingoldWordOracle d fn request.2)) prog @@ -182,7 +182,7 @@ Theorem 4.1). -/ let α₀ ← PMF.uniformOfFintype (ZMod (F.order d)) let α ← PMF.uniformOfFintype (Fin (inLen n) → ZMod (F.order d)) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (F.naorReingoldWordOracle d (F.naorReingoldEval d α₀ α) request.2)) (adversary n (F.encDesc d)) @@ -195,7 +195,7 @@ Theorem 4.1). -/ let α₀ ← F.sampleNaorReingoldExp n d let αs ← OracleComp.replicate (inLen n) (F.sampleNaorReingoldExp n d) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin fun request => + (OracleComp.sumHandler ProbComp.unifFin fun request => pure (if request.2.length = inLen n then F.naorReingoldWordEval d α₀ αs request.2 else [])) (adversary n (F.encDesc d))) @@ -207,7 +207,7 @@ Theorem 4.1). -/ let d ← setup n let B ← PMF.uniformOfFintype (BitString (inLen n) → ZMod (F.order d)) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (F.naorReingoldWordOracle d (fun x => B x • F.generator d) request.2)) (adversary n (F.encDesc d)) @@ -451,7 +451,7 @@ private noncomputable def naorReingoldDescToDDHDistinguisher (F : PrimeOrderGrou if k < m then do let αs ← OracleComp.replicate (m - (k + 1)) (F.sampleNaorReingoldExp n input.1) Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) (fun request => F.naorReingoldFrontierOracle n m k input.1 input.2.1 input.2.2.1 input.2.2.2 αs request.2)) (adv n input.1)).run [] @@ -469,7 +469,7 @@ noncomputable def naorReingoldToDDHDistinguisher (inLen : ℕ → ℕ) if k < m then do let αs ← OracleComp.replicate (m - (k + 1)) (F.sampleNaorReingoldExp n input.1) Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) (fun request => F.naorReingoldFrontierOracle n m k input.1 input.2.1 input.2.2.1 input.2.2.2 αs request.2)) (adversary n (F.encDesc input.1))).run [] @@ -733,7 +733,7 @@ private theorem isPPTOn_naorReingoldDescToDDHDistinguisher (F : PrimeOrderGroupF (by fun_prop) (by fun_prop) (by fun_prop) (by fun_prop) (by fun_prop) (by fun_prop) have hrun : IsPPTOn (ddhCallerEncoding F) (encPair encBool naorReingoldCacheEncoding) (fun caller : DDHCaller F => (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) (fun request => F.naorReingoldFrontierOracle caller.1.1.1 (inLen caller.1.1.1) caller.1.2 caller.1.1.2.1 caller.1.1.2.2.1 caller.1.1.2.2.2.1 caller.1.1.2.2.2.2 caller.2 request.2)) @@ -801,7 +801,7 @@ private theorem isPPTOn_naorReingoldDescToDDHDistinguisher (F : PrimeOrderGroupF exact ⟨hcache, by simp, by lia⟩ have hrun_fst : IsPPTOn (ddhCallerEncoding F) encBool (fun caller : DDHCaller F => Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) (fun request => F.naorReingoldFrontierOracle caller.1.1.1 (inLen caller.1.1.1) caller.1.2 caller.1.1.2.1 caller.1.1.2.2.1 caller.1.1.2.2.2.1 caller.1.1.2.2.2.2 caller.2 request.2)) @@ -826,7 +826,7 @@ private theorem isPPTOn_naorReingoldDescToDDHDistinguisher (F : PrimeOrderGroupF let αs ← OracleComp.replicate (inLen p.1.1 - (p.2 + 1)) (F.sampleNaorReingoldExp p.1.1 p.1.2.1) Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) (fun request => F.naorReingoldFrontierOracle p.1.1 (inLen p.1.1) p.2 p.1.2.1 p.1.2.2.1 p.1.2.2.2.1 p.1.2.2.2.2 αs request.2)) (adv p.1.1 p.1.2.1)).run []) := @@ -854,7 +854,7 @@ private theorem isPPTOn_naorReingoldDescToDDHDistinguisher (F : PrimeOrderGroupF let αs ← OracleComp.replicate (inLen p.1.1 - (p.2 + 1)) (F.sampleNaorReingoldExp p.1.1 p.1.2.1) Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) (fun request => F.naorReingoldFrontierOracle p.1.1 (inLen p.1.1) p.2 p.1.2.1 p.1.2.2.1 p.1.2.2.2.1 p.1.2.2.2.2 αs request.2)) (adv p.1.1 p.1.2.1)).run [] @@ -953,7 +953,7 @@ private noncomputable def frontierLevelWithExpLaw (F : PrimeOrderGroupFamily) (d let pairLaw := (PMF.iid expLaw 2).map fun p => F.ddhFixedUWordRerandomize d u v w (p 0).val (p 1).val ((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) fun request cache => if request.2.length = m then do let (vw, cache') ← memoize (fun _ : List Bool => pairLaw) (request.2.take k) cache @@ -967,7 +967,7 @@ private theorem eval_frontierLevel_eq_withExpLaw (F : PrimeOrderGroupFamily) (n ProbComp.eval (do let αs ← OracleComp.replicate (m - (k + 1)) (F.sampleNaorReingoldExp n d) Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifFin r)) (fun request => F.naorReingoldFrontierOracle n m k d u v w αs request.2)) prog).run []) = frontierLevelWithExpLaw F d m k prog u v w @@ -983,7 +983,7 @@ private theorem eval_frontierLevel_eq_withExpLaw (F : PrimeOrderGroupFamily) (n | inl r => rfl | inr request => funext cache - dsimp only [ProbOracleComp.handler, naorReingoldFrontierOracle] + dsimp only [OracleComp.sumHandler, naorReingoldFrontierOracle] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte, ProbComp.eval_bind, ProbComp.eval_pure, ProbComp.eval_memoize, eval_sampleNaorReingoldPair_eq_iid F n d u v w] @@ -1036,7 +1036,7 @@ private theorem dist_frontierLevelWithExpLaw_le (F : PrimeOrderGroupFamily) (d : let values := List.ofFn fun i => F.ddhFixedUWordRerandomize d u v w (st.2 i 0).val (st.2 i 1).val (((OracleComp.interpret - (ProbOracleComp.handler (fun t => StateT.lift (ProbComp.unifOracle t)) + (OracleComp.sumHandler (fun t => StateT.lift (ProbComp.unifOracle t)) (OracleComp.withSampleList ([], []) (frontierStep F d m k αs))) prog).run ([], values)).map fun res => res.1) have hlaw (μ : PMF (ZMod (F.order d))) : @@ -1051,7 +1051,7 @@ private theorem dist_frontierLevelWithExpLaw_le (F : PrimeOrderGroupFamily) (d : have hpre := congrArg (PMF.map Prod.fst) (hQ.run_interpret_presample pairLaw ([], []) (frontierStep F d m k αs) []) trans (((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) fun request cache => pairLaw.bind fun fresh => frontierStep F d m k αs fresh request cache) prog).run []).map Prod.fst) · refine congrArg (PMF.map Prod.fst) @@ -1211,7 +1211,7 @@ private theorem frontierLevelWithExpLaw_uniform_eq_multi (F : PrimeOrderGroupFam fun _ => (F.ddhFixedURerandomizeLaw d u₀ v₀ w₀).map valMap let prefixProg : ProbOracleComp (fun _ : BitString k => List Bool × List Bool) Bool := OracleComp.interpret - (ProbOracleComp.handler (fun r => ProbOracleComp.sample (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => ProbOracleComp.sample (ProbComp.unifFin r)) fun request => if request.2.length = m then (fun vw : List Bool × List Bool => @@ -1231,7 +1231,7 @@ private theorem frontierLevelWithExpLaw_uniform_eq_multi (F : PrimeOrderGroupFam (fun i => if h : k + 1 ≤ i.val then suffix ⟨i.val - (k + 1), by omega⟩ else 1))) = ((F.multiDDHRerandomizeLaw d (BitString k) u₀ v₀ w₀).bind fun T => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle + (OracleComp.sumHandler ProbComp.unifOracle (fun key => PMF.pure (valMap (T key)))) prefixProg) := by congr 1; funext T @@ -1240,9 +1240,9 @@ private theorem frontierLevelWithExpLaw_uniform_eq_multi (F : PrimeOrderGroupFam congr 1; funext q cases q with | inl r => - simp [ProbOracleComp.handler, ProbOracleComp.sample, ProbComp.unifFin] + simp [OracleComp.sumHandler, ProbOracleComp.sample, ProbComp.unifFin] | inr request => - dsimp only [ProbOracleComp.handler, Function.comp_apply] + dsimp only [OracleComp.sumHandler, Function.comp_apply] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte, OracleComp.interpret_map, ProbOracleComp.interpret_query, PMF.monad_map_eq_map, PMF.pure_map, naorReingoldWordOracle, valMap] @@ -1251,11 +1251,11 @@ private theorem frontierLevelWithExpLaw_uniform_eq_multi (F : PrimeOrderGroupFam · simp [hq, naorReingoldWordOracle, PMF.monad_pure_eq_pure] have hrhs : ((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) (fun key => memoize sample' (keyMap key))) prefixProg).run []).map Prod.fst = ((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) fun request cache => if request.2.length = m then do let (vw, cache') ← memoize sample' (request.2.take k) cache @@ -1273,10 +1273,10 @@ private theorem frontierLevelWithExpLaw_uniform_eq_multi (F : PrimeOrderGroupFam cases q with | inl r => funext cache - simp [ProbOracleComp.handler, ProbOracleComp.sample, ProbComp.unifFin, StateT.lift] + simp [OracleComp.sumHandler, ProbOracleComp.sample, ProbComp.unifFin, StateT.lift] | inr request => funext cache - dsimp only [ProbOracleComp.handler, Function.comp_apply] + dsimp only [OracleComp.sumHandler, Function.comp_apply] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte, OracleComp.interpret_map, ProbOracleComp.interpret_query, keyMap, Function.Embedding.coeFn_mk, @@ -1761,7 +1761,7 @@ theorem advantage_naorReingoldProbRealGame_wordRealGame_le (setup : ℕ → PMF refine Game.advantage_bind_le_nnreal (setup n) _ _ fun d => ?_ let detRun : (ZMod (F.order d) × (Fin m → ZMod (F.order d))) → PMF Bool := fun p => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (F.naorReingoldWordOracle d (F.naorReingoldEval d p.1 p.2) request.2)) (adversary n (F.encDesc d)) have hprob : @@ -1769,7 +1769,7 @@ theorem advantage_naorReingoldProbRealGame_wordRealGame_le (setup : ℕ → PMF let α₀ ← F.sampleNaorReingoldExp n d let αs ← OracleComp.replicate m (F.sampleNaorReingoldExp n d) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin fun request => + (OracleComp.sumHandler ProbComp.unifFin fun request => pure (if request.2.length = m then F.naorReingoldWordEval d α₀ αs request.2 else [])) (adversary n (F.encDesc d))) = @@ -1786,7 +1786,7 @@ theorem advantage_naorReingoldProbRealGame_wordRealGame_le (setup : ℕ → PMF cases q with | inl r => rfl | inr request => - dsimp only [ProbOracleComp.handler] + dsimp only [OracleComp.sumHandler] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte, naorReingoldWordOracle] have hxs : List.ofFn (BitString.ofList m request.2) = request.2 := @@ -2055,7 +2055,7 @@ theorem computableInPolyTime_naorReingoldHashedWordEval {bound : F.Desc → ℕ} let α₀ ← PMF.uniformOfFintype (ZMod (F.order ds.1)) let α ← PMF.uniformOfFintype (Fin (inLen n) → ZMod (F.order ds.1)) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then F.linearHashKDF (fun _ => outLen n) bound (ds, F.encode ds.1 (F.naorReingoldEval ds.1 α₀ α @@ -2073,7 +2073,7 @@ exponents via `sampleNaorReingoldExp` (original). -/ let α₀ ← F.sampleNaorReingoldExp n ds.1 let αs ← OracleComp.replicate (inLen n) (F.sampleNaorReingoldExp n ds.1) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin fun request => + (OracleComp.sumHandler ProbComp.unifFin fun request => pure (if request.2.length = inLen n then F.naorReingoldHashedWordEval (outLen n) bound ds.1 ds.2 α₀ αs request.2 else [])) @@ -2090,7 +2090,7 @@ Theorem 4.3 and Remark 4.2). -/ let ds ← F.seededSetup setup (F.linearHashSeedLen outLen bound) n let f ← PMF.uniformOfFintype (BitString (inLen n) → BitString (outLen n)) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then List.ofFn (f (BitString.ofList (inLen n) request.2)) else [])) @@ -2106,7 +2106,7 @@ and hash each queried group element `B x • g` with `linearHashKDF` (paraphrase let ds ← F.seededSetup setup (F.linearHashSeedLen outLen bound) n let B ← PMF.uniformOfFintype (BitString (inLen n) → ZMod (F.order ds.1)) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then F.linearHashKDF (fun _ => outLen n) bound (ds, F.encode ds.1 (B (BitString.ofList (inLen n) request.2) • F.generator ds.1)) @@ -2118,14 +2118,14 @@ private theorem run_eager_bitStringTable_eq_presample {m ℓ Q : ℕ} (outLaw : PMF (BitString ℓ)) : ((PMF.pi (fun _ : BitString m => outLaw)).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then List.ofFn (f (BitString.ofList m request.2)) else [])) prog) = (PMF.pi (fun _ : Fin Q => outLaw)).bind fun tbl => (((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) (OracleComp.withSampleList [] (fun (fresh : List Bool) (request : Unit × List Bool) (cache : List (List Bool × List Bool)) => @@ -2140,7 +2140,7 @@ private theorem run_eager_bitStringTable_eq_presample {m ℓ Q : ℕ} let sample' : List Bool → PMF (List Bool) := fun _ => outLaw.map valMap let innerProg : ProbOracleComp (fun _ : BitString m => List Bool) Bool := OracleComp.interpret - (ProbOracleComp.handler (fun r => ProbOracleComp.sample (ProbComp.unifFin r)) + (OracleComp.sumHandler (fun r => ProbOracleComp.sample (ProbComp.unifFin r)) fun request => if request.2.length = m then ProbOracleComp.query (BitString.ofList m request.2) @@ -2152,32 +2152,32 @@ private theorem run_eager_bitStringTable_eq_presample {m ℓ Q : ℕ} have hlhs : ((PMF.pi (fun _ : BitString m => outLaw)).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then List.ofFn (f (BitString.ofList m request.2)) else [])) prog) = ((PMF.pi (fun _ : BitString m => outLaw)).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun key => PMF.pure (valMap (f key))) + (OracleComp.sumHandler ProbComp.unifOracle fun key => PMF.pure (valMap (f key))) innerProg) := by congr 1; funext f dsimp only [innerProg] rw [OracleComp.interpret_interpret] congr 1; funext q cases q with - | inl r => simp [ProbOracleComp.handler, ProbOracleComp.sample, ProbComp.unifFin] + | inl r => simp [OracleComp.sumHandler, ProbOracleComp.sample, ProbComp.unifFin] | inr request => - dsimp only [ProbOracleComp.handler, Function.comp_apply] + dsimp only [OracleComp.sumHandler, Function.comp_apply] by_cases hq : request.2.length = m <;> simp [hq, ProbOracleComp.interpret_query, valMap, PMF.monad_pure_eq_pure] have hrhs : ((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) (fun key => memoize sample' (keyMap key))) innerProg).run []).map Prod.fst = ((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) fun (request : Unit × List Bool) (cache : List (List Bool × List Bool)) => (outLaw.map valMap).bind fun fresh => if request.2.length = m then @@ -2196,10 +2196,10 @@ private theorem run_eager_bitStringTable_eq_presample {m ℓ Q : ℕ} cases q with | inl r => funext cache - simp [ProbOracleComp.handler, ProbOracleComp.sample, ProbComp.unifFin, StateT.lift] + simp [OracleComp.sumHandler, ProbOracleComp.sample, ProbComp.unifFin, StateT.lift] | inr request => funext cache - dsimp only [ProbOracleComp.handler, Function.comp_apply] + dsimp only [OracleComp.sumHandler, Function.comp_apply] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte, ProbOracleComp.interpret_query, keyMap, Function.Embedding.coeFn_mk, BitString.ofFn_ofList hq, memoize, sample'] @@ -2234,7 +2234,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami ((Cslib.BitString.uniformList (F.linearHashSeedLen outLen bound n d)).bind fun seed => (PMF.uniformOfFintype (BitString (inLen n) → ZMod (F.order d))).bind fun B => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then F.linearHashKDF (fun _ => outLen n) bound ((d, seed), F.encode d @@ -2244,7 +2244,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami ((Cslib.BitString.uniformList (F.linearHashSeedLen outLen bound n d)).bind fun seed => (PMF.uniformOfFintype (BitString (inLen n) → BitString (outLen n))).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then List.ofFn (f (BitString.ofList (inLen n) request.2)) else [])) @@ -2259,7 +2259,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami Cslib.BitString.LinearHash.hash (Cslib.BitString.blocksEquiv (m := ℓ) (k := W) seed) let detKernel : BitString (ℓ * W) × (Fin Q → BitString ℓ) → PMF Bool := fun pair => (((OracleComp.interpret - (ProbOracleComp.handler (fun r => StateT.lift (ProbComp.unifOracle r)) + (OracleComp.sumHandler (fun r => StateT.lift (ProbComp.unifOracle r)) (OracleComp.withSampleList [] (fun (fresh : List Bool) (request : Unit × List Bool) (cache : List (List Bool × List Bool)) => @@ -2274,7 +2274,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami ((Cslib.BitString.uniformList (F.linearHashSeedLen outLen bound n d)).bind fun seed => (PMF.uniformOfFintype (BitString m → ZMod (F.order d))).bind fun B => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then F.linearHashKDF (fun _ => ℓ) bound ((d, seed), F.encode d (B (BitString.ofList m request.2) • F.generator d)) @@ -2288,7 +2288,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami have htable : ((PMF.uniformOfFintype (BitString m → ZMod (F.order d))).bind fun B => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then F.linearHashKDF (fun _ => ℓ) bound ((d, List.ofFn seed), @@ -2297,7 +2297,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami (adversary n (F.withSeed.encDesc (d, List.ofFn seed)))) = ((PMF.pi (fun _ : BitString m => source.map (hashSeed seed))).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then List.ofFn (f (BitString.ofList m request.2)) else [])) @@ -2317,7 +2317,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami cases q with | inl r => rfl | inr request => - dsimp only [ProbOracleComp.handler] + dsimp only [OracleComp.sumHandler] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte] have hpad := F.ofFn_paddedGeneratorMultiple hbound (B (BitString.ofList m request.2)) @@ -2336,7 +2336,7 @@ private theorem advantage_naorReingoldHashedIdeal_at_le (F : PrimeOrderGroupFami ((Cslib.BitString.uniformList (F.linearHashSeedLen outLen bound n d)).bind fun seed => (PMF.uniformOfFintype (BitString m → BitString ℓ)).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then List.ofFn (f (BitString.ofList m request.2)) else [])) @@ -2427,7 +2427,7 @@ private noncomputable def hashedAdvGroup (F : PrimeOrderGroupFamily) (inLen outL (bound : F.Desc → ℕ) (adversary : OracleDistinguisher) (n : ℕ) (ds : F.withSeed.Desc) : WordOracleComp Unit Bool := Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun r => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin r))) fun (request : Unit × List Bool) (_ : Unit) => if request.2.length = inLen n then @@ -2570,7 +2570,7 @@ private theorem naorReingoldWordRun_hashedAdvGroup (F : PrimeOrderGroupFamily) (fn : BitString (inLen n) → F.Carrier ds.1) : naorReingoldWordRun F.withSeed ds (hashedAdvGroup F inLen outLen bound adversary n ds) fn = OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then F.linearHashKDF (fun _ => outLen n) bound (ds, F.encode ds.1 (fn (BitString.ofList (inLen n) request.2))) @@ -2579,7 +2579,7 @@ private theorem naorReingoldWordRun_hashedAdvGroup (F : PrimeOrderGroupFamily) dsimp only [naorReingoldWordRun, hashedAdvGroup] rw [OracleComp.interpret_map, PMF.monad_map_eq_map] have hH : - (ProbOracleComp.handler + (OracleComp.sumHandler (fun r => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin r))) fun (request : Unit × List Bool) (_ : Unit) => if request.2.length = inLen n then @@ -2604,16 +2604,16 @@ private theorem naorReingoldWordRun_hashedAdvGroup (F : PrimeOrderGroupFamily) | inr request => funext u by_cases hq : request.2.length = inLen n <;> - simp [ProbOracleComp.handler, hq, StateT.lift, Functor.map_map] + simp [OracleComp.sumHandler, hq, StateT.lift, Functor.map_map] rw [hH, OracleComp.run_interpret_lift, OracleComp.interpret_map, PMF.monad_map_eq_map, PMF.map_comp, show Prod.fst ∘ (fun a : Bool => (a, ())) = id from rfl, PMF.map_id, OracleComp.interpret_interpret] congr 1; funext q cases q with | inl r => - simp [ProbOracleComp.handler, ProbOracleComp.sample, ProbComp.unifFin] + simp [OracleComp.sumHandler, ProbOracleComp.sample, ProbComp.unifFin] | inr request => - dsimp only [ProbOracleComp.handler, Function.comp_apply] + dsimp only [OracleComp.sumHandler, Function.comp_apply] by_cases hq : request.2.length = inLen n · simp only [hq, ↓reduceIte, OracleComp.interpret_map, ProbOracleComp.interpret_query, PMF.monad_map_eq_map, PMF.pure_map, naorReingoldWordOracle, @@ -2785,7 +2785,7 @@ theorem DDH.negligible_naorReingoldHashedProbGame {F : PrimeOrderGroupFamily} let d := ds.1 let detRun : (ZMod (F.order d) × (Fin m → ZMod (F.order d))) → PMF Bool := fun p => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = m then F.linearHashKDF (fun _ => outLen n) bound (ds, F.encode d (F.naorReingoldEval d p.1 p.2 (BitString.ofList m request.2))) @@ -2796,7 +2796,7 @@ theorem DDH.negligible_naorReingoldHashedProbGame {F : PrimeOrderGroupFamily} let α₀ ← F.sampleNaorReingoldExp n d let αs ← OracleComp.replicate m (F.sampleNaorReingoldExp n d) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin fun request => + (OracleComp.sumHandler ProbComp.unifFin fun request => pure (if request.2.length = m then F.naorReingoldHashedWordEval (outLen n) bound d ds.2 α₀ αs request.2 else [])) @@ -2814,7 +2814,7 @@ theorem DDH.negligible_naorReingoldHashedProbGame {F : PrimeOrderGroupFamily} cases q with | inl r => rfl | inr request => - dsimp only [ProbOracleComp.handler] + dsimp only [OracleComp.sumHandler] by_cases hq : request.2.length = m · simp only [hq, ↓reduceIte, naorReingoldHashedWordEval] have hxs : List.ofFn (BitString.ofList m request.2) = request.2 := @@ -3011,7 +3011,7 @@ theorem DDH.negligible_naorReingoldHashedGame_const {F : PrimeOrderGroupFamily} (Cslib.BitString.uniformList (F.linearHashSeedLen (fun _ => c) bound n d)).bind fun seed => (PMF.uniformOfFintype (BitString (inLen n) → ZMod (F.order d))).bind fun B => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then F.linearHashKDF (fun _ => c) bound ((d, seed), F.encode d @@ -3022,7 +3022,7 @@ theorem DDH.negligible_naorReingoldHashedGame_const {F : PrimeOrderGroupFamily} (Cslib.BitString.uniformList (F.linearHashSeedLen (fun _ => c) bound n d)).bind fun seed => (PMF.uniformOfFintype (BitString (inLen n) → BitString c)).bind fun f => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle fun request => + (OracleComp.sumHandler ProbComp.unifOracle fun request => PMF.pure (if request.2.length = inLen n then List.ofFn (f (BitString.ofList (inLen n) request.2)) else [])) diff --git a/Complexity/Crypto/Computational/OneWay/MCSP.lean b/Complexity/Crypto/Computational/OneWay/MCSP.lean index 2a3d0937e7..9e3e4a268a 100644 --- a/Complexity/Crypto/Computational/OneWay/MCSP.lean +++ b/Complexity/Crypto/Computational/OneWay/MCSP.lean @@ -215,7 +215,7 @@ theorem tableInstance_map_tableQueries (oracle : List Bool → List Bool) (n m : /-- Against a deterministic oracle, the distinguisher runs the decider on the truth table of the oracle's restriction. -/ theorem interpret_mcspDistinguisher (d : ℕ) (oracle : List Bool → List Bool) (n : ℕ) : - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifFin + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifFin fun request => pure (oracle request.2)) (mcspDistinguisher p V d n []) = mcspRun p V ⟨tableArity d n, MCSP.truthTable (tableArity d n) (restriction oracle n (tableArity d n)), 2 ^ tableArity d n / (5 * tableArity d n)⟩ := by diff --git a/Complexity/Crypto/Computational/OneWayToSignature.lean b/Complexity/Crypto/Computational/OneWayToSignature.lean index a3cc11acb0..a711b71689 100644 --- a/Complexity/Crypto/Computational/OneWayToSignature.lean +++ b/Complexity/Crypto/Computational/OneWayToSignature.lean @@ -581,7 +581,7 @@ noncomputable def lamportInverter (f : List Bool → List Bool) if j < 2 * n then do let keys ← lamportSimKeys f n j y let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) ((lamportScheme f hf).oneTimeSigningOracle keys.2)) (adversary n keys.1)).run [] return (frames out.1.2).getD (j / 2) [] else @@ -602,7 +602,7 @@ theorem isPPT_lamportInverter {f : List Bool → List Bool} encBits (fun r : ((ℕ × List Bool) × ℕ) × (List Bool × List Bool) => do let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) ((lamportScheme f (.of_tidy hf)).oneTimeSigningOracle r.2.2)) (adversary r.1.1.1 r.2.1)).run [] return (frames out.1.2).getD (r.1.2 / 2) []) := by @@ -645,7 +645,7 @@ theorem isPPT_lamportInverter {f : List Bool → List Bool} if q.2 < 2 * q.1.1 then do let keys ← lamportSimKeys f q.1.1 q.2 q.1.2 let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) ((lamportScheme f (.of_tidy hf)).oneTimeSigningOracle keys.2)) (adversary q.1.1 keys.1)).run [] return (frames out.1.2).getD (q.2 / 2) [] @@ -691,7 +691,7 @@ theorem OneWay.oneTimeEUFCMA_lamport {f : List Bool → List Bool} (hf : OneWay encList encBits (w.take j ++ [] :: w.drop (j + 1)) let runWith (pk sk : List Bool) : PMF ((List Bool × List Bool) × List (List Bool)) := ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.oneTimeSigningOracle sk)) (adversary n pk)).run []) let win (w : List (List Bool)) (out : (List Bool × List Bool) × List (List Bool)) : Bool := (out.1.1.length == n) && !out.2.contains out.1.1 && @@ -703,7 +703,7 @@ theorem OneWay.oneTimeEUFCMA_lamport {f : List Bool → List Bool} (hf : OneWay if j < 2 * n then do let keys ← lamportSimKeys f n j y let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.oneTimeSigningOracle keys.2)) (adversary n keys.1)).run [] return (frames out.1.2).getD (j / 2) [] else diff --git a/Complexity/Crypto/Computational/PseudorandomFunction.lean b/Complexity/Crypto/Computational/PseudorandomFunction.lean index c84665c102..23987227f1 100644 --- a/Complexity/Crypto/Computational/PseudorandomFunction.lean +++ b/Complexity/Crypto/Computational/PseudorandomFunction.lean @@ -76,7 +76,7 @@ def randomFunctionQuery (n : ℕ) (query : List Bool) : theorem interpret_randomFunctionQuery {m : Type → Type*} [Monad m] [LawfulMonad m] (random : (n : ℕ) → m (Fin (n + 1))) (n : ℕ) (table : BitString n → BitString n) (query : List Bool) : - OracleComp.interpret (ProbOracleComp.handler random (fun bits => pure (table bits))) + OracleComp.interpret (OracleComp.sumHandler random (fun bits => pure (table bits))) (randomFunctionQuery n query) = pure (randomFunctionOracle n table query) := by by_cases h : query.length = n <;> simp [randomFunctionQuery, randomFunctionOracle, h] @@ -85,7 +85,7 @@ open Classical in noncomputable def lazyRandomFunctionOracle (n : ℕ) (query : List Bool) : StateT (RandomOracle.Cache (fun _ : BitString n => BitString n)) PMF (List Bool) := OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (RandomOracle.answer (fun _ => PMF.uniformOfFintype (BitString n)))) (randomFunctionQuery n query) @@ -94,14 +94,14 @@ noncomputable def prfRealGame (family : List Bool → List Bool → List Bool) (adversary : OracleDistinguisher) (n : ℕ) : ProbComp Bool := do let key ← BitString.sampleList n OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (prfOracle family n key request.2))) (adversary n []) /-- Sample one whole random function, independently of the adversary's private samples. -/ noncomputable def prfIdealGame (adversary : OracleDistinguisher) (n : ℕ) : ProbComp Bool := do let table ← ProbComp.uniform (BitString n → BitString n) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (randomFunctionOracle n table request.2))) (adversary n []) /-- The ideal game admits consistent lazy answers to adaptive queries, with private randomness @@ -109,22 +109,22 @@ independent of the table and the same rejection convention for malformed inputs. theorem prfIdealGame_eq_lazy (adversary : OracleDistinguisher) (n : ℕ) : ProbComp.eval (prfIdealGame adversary n) = ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun request => lazyRandomFunctionOracle n request.2)) (adversary n [])).run (fun _ => none)).map Prod.fst := by classical let adapted := OracleComp.interpret - (ProbOracleComp.handler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) (fun request : Unit × List Bool => randomFunctionQuery n request.2)) (adversary n []) have h := RandomOracle.uniform_interpret_prob_eq_lazy adapted have heager (table : BitString n → BitString n) (query : List Bool) : OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle (fun bits => PMF.pure (table bits))) + (OracleComp.sumHandler ProbComp.unifOracle (fun bits => PMF.pure (table bits))) (randomFunctionQuery n query) = PMF.pure (randomFunctionOracle n table query) := interpret_randomFunctionQuery ProbComp.unifOracle n table query simpa only [adapted, prfIdealGame, ProbComp.eval_bind, ProbComp.eval_uniform, ProbOracleComp.eval_interpret, ProbComp.eval_pure, OracleComp.interpret_interpret, - ProbOracleComp.interpret_handler, ProbOracleComp.interpret_sample, ProbComp.unifFin, + OracleComp.interpret_sumHandler, ProbOracleComp.interpret_sample, ProbComp.unifFin, OracleComp.interpret_query, heager, lazyRandomFunctionOracle, PMF.monad_bind_eq_bind] using h /-- A keyed family evaluated in plain polynomial time, secure against every uniform adaptive diff --git a/Complexity/Crypto/Computational/PseudorandomFunction/Coins.lean b/Complexity/Crypto/Computational/PseudorandomFunction/Coins.lean index 4f9b3823e5..f031b0d3ba 100644 --- a/Complexity/Crypto/Computational/PseudorandomFunction/Coins.lean +++ b/Complexity/Crypto/Computational/PseudorandomFunction/Coins.lean @@ -144,7 +144,7 @@ def randomCoinOracle (N : ℕ) (table : BitString N → BitString N) (request : noncomputable def coinRealGame (adversary : OracleDistinguisher) (N : ℕ) : ProbComp Bool := do let key ← BitString.sampleList N OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (coinOracle family key request.2))) (adversary N []) /-- The ideal coin game: a uniform random function on `N` bits answers every request at its @@ -152,7 +152,7 @@ padding, cut to the requested count. -/ noncomputable def coinIdealGame (adversary : OracleDistinguisher) (N : ℕ) : ProbComp Bool := do let table ← ProbComp.uniform (BitString N → BitString N) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (randomCoinOracle N table request.2))) (adversary N []) /-! ### The reduction to the PRF games -/ @@ -165,19 +165,19 @@ def coinQuery (N : ℕ) (request : Unit × List Bool) : WordOracleComp Unit (Lis /-- The PRF distinguisher built from a coin adversary: run it, answering through `coinQuery`. -/ def coinDistinguisher (adversary : OracleDistinguisher) : OracleDistinguisher := fun N aux => OracleComp.interpret - (ProbOracleComp.handler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) (coinQuery N)) + (OracleComp.sumHandler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) (coinQuery N)) (adversary N aux) /-- Interpreting the forwarded program against a stateless word oracle is interpreting the original program against that oracle composed with `coinQuery`. -/ private theorem interpret_coinDistinguisher (oracle : Unit × List Bool → ProbComp (List Bool)) (adversary : OracleDistinguisher) (N : ℕ) (aux : List Bool) : - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifFin oracle) + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifFin oracle) (coinDistinguisher adversary N aux) = - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifFin (fun request => + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifFin (fun request => List.take (coinRequestDecoder.decode request.2).2 <$> oracle ((), padRequest N (coinRequestDecoder.decode request.2).1))) (adversary N aux) := by - simp only [coinDistinguisher, OracleComp.interpret_interpret, ProbOracleComp.interpret_handler, + simp only [coinDistinguisher, OracleComp.interpret_interpret, OracleComp.interpret_sumHandler, ProbOracleComp.interpret_sample, coinQuery, OracleComp.interpret_map, ProbOracleComp.interpret_query] congr 1 @@ -191,7 +191,7 @@ theorem eval_coinRealGame (adversary : OracleDistinguisher) (N : ℕ) : have hlen := BitString.length_of_mem_support_uniformList hkey rw [interpret_coinDistinguisher] refine congrArg (fun h => ProbComp.eval (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin h) (adversary N []))) (funext fun request => ?_) + (OracleComp.sumHandler ProbComp.unifFin h) (adversary N []))) (funext fun request => ?_) simp only [map_pure, coinOracle, prfCoins, prfOracle, length_padRequest, hlen, ite_true] /-- The ideal coin game is the ideal PRF game of the forwarded adversary. -/ @@ -202,7 +202,7 @@ theorem eval_coinIdealGame (adversary : OracleDistinguisher) (N : ℕ) : refine PMF.bind_congr_on_support _ _ _ fun table _ => ?_ rw [interpret_coinDistinguisher] refine congrArg (fun h => ProbComp.eval (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin h) (adversary N []))) (funext fun request => ?_) + (OracleComp.sumHandler ProbComp.unifFin h) (adversary N []))) (funext fun request => ?_) simp only [map_pure, randomCoinOracle] /-- `coinQuery` as a handler with trivial state, for the open substitution rule. -/ @@ -244,10 +244,10 @@ theorem isOraclePPT_coinDistinguisher {adversary : OracleDistinguisher} (fun _ => trivial) (by polytime) ?_ · refine (hrun.map' (ComputableInPolyTime.fst encBool (encFinEnum Unit))).congr fun c External oracle e => ?_ - have hlift : ProbOracleComp.handler + have hlift : OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (fun q => coinHandler c.1 q) = - fun q => StateT.lift (σ := Unit) (ProbOracleComp.handler + fun q => StateT.lift (σ := Unit) (OracleComp.sumHandler (fun n => ProbOracleComp.sample (ProbComp.unifFin n)) (coinQuery c.1) q) := by funext q cases q with @@ -256,7 +256,7 @@ theorem isOraclePPT_coinDistinguisher {adversary : OracleDistinguisher} funext u exact map_eq_pure_bind _ _ have h : Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (fun q => coinHandler c.1 q)) (adversary c.1 c.2)).run () = coinDistinguisher adversary c.1 c.2 := by @@ -264,8 +264,8 @@ theorem isOraclePPT_coinDistinguisher {adversary : OracleDistinguisher} exact id_map _ rw [h] · intro c request u _ result hresult - obtain ⟨reply, hreply, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨raw, -, rfl⟩ := ProbOracleComp.mem_support_map hreply + obtain ⟨reply, hreply, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨raw, -, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hreply refine ⟨trivial, (List.length_take_le _ _).trans ?_, le_add_right le_rfl⟩ exact length_dropFrame_le request.2 diff --git a/Complexity/Crypto/Computational/PseudorandomFunction/RandomOracle.lean b/Complexity/Crypto/Computational/PseudorandomFunction/RandomOracle.lean index 51361417f0..49847f8910 100644 --- a/Complexity/Crypto/Computational/PseudorandomFunction/RandomOracle.lean +++ b/Complexity/Crypto/Computational/PseudorandomFunction/RandomOracle.lean @@ -74,7 +74,7 @@ consistency and independent private randomness under arbitrary adaptive interact theorem prfIdealGame_eq_cached (adversary : OracleDistinguisher) (n : ℕ) : ProbComp.eval (prfIdealGame adversary n) = ProbComp.eval (Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request => cachedRandomFunctionOracle n request.2)) (adversary n [])).run []) := by let adapter := fun query : List Bool => if query.length = n then (ProbOracleComp.query (BitString.ofList n query) : @@ -84,10 +84,10 @@ theorem prfIdealGame_eq_cached (adversary : OracleDistinguisher) (n : ℕ) : (⟨List.ofFn, List.ofFn_injective⟩ : BitString n ↪ List Bool) List.ofFn (fun _ => PMF.uniformOfFintype (BitString n)) (fun _ => BitString.uniformList n) (fun _ => rfl) (OracleComp.interpret - (ProbOracleComp.handler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => ProbOracleComp.sample (ProbComp.unifFin k)) (fun request : Unit × List Bool => adapter request.2)) (adversary n [])) have hstep (query : List Bool) : OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun key => memoize (fun _ => BitString.uniformList n) (List.ofFn key))) (adapter query) = fun cache => ProbComp.eval (cachedRandomFunctionOracle n query cache) := by @@ -99,13 +99,13 @@ theorem prfIdealGame_eq_cached (adversary : OracleDistinguisher) (n : ℕ) : OracleComp.interpret_pure, ProbComp.eval_pure] rfl have heager (table : BitString n → BitString n) (query : List Bool) : OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle (fun key => PMF.pure (List.ofFn (table key)))) + (OracleComp.sumHandler ProbComp.unifOracle (fun key => PMF.pure (List.ofFn (table key)))) (adapter query) = PMF.pure (randomFunctionOracle n table query) := by by_cases hquery : query.length = n <;> simp [adapter, randomFunctionOracle, hquery] rw [ProbComp.eval_map, ProbOracleComp.eval_run_interpret] simpa only [prfIdealGame, ProbComp.eval_bind, ProbComp.eval_uniform, ProbOracleComp.eval_interpret, ProbComp.eval_pure, PMF.pi_uniformOfFintype, - OracleComp.interpret_interpret, ProbOracleComp.interpret_handler, + OracleComp.interpret_interpret, OracleComp.interpret_sumHandler, ProbOracleComp.interpret_sample, ProbComp.unifFin, OracleComp.interpret_query, Function.Embedding.coeFn_mk, hstep, heager, PMF.monad_bind_eq_bind] using h @@ -118,7 +118,7 @@ theorem isPPT_prfIdealGame {adversary : OracleDistinguisher} have hrun : IsPPTOn (encPair encUnary encBits) (encPair encBool (encList (encPair encBits encBits))) (fun pair : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request => cachedRandomFunctionOracle pair.1 request.2)) (adversary pair.1 [])).run []) := by apply hadversary.run_interpret_preprocess (operationEncoding := encFinEnum Unit) diff --git a/Complexity/Crypto/Computational/PseudorandomFunction/TruthTable.lean b/Complexity/Crypto/Computational/PseudorandomFunction/TruthTable.lean index 0393b9f4c6..f73c366355 100644 --- a/Complexity/Crypto/Computational/PseudorandomFunction/TruthTable.lean +++ b/Complexity/Crypto/Computational/PseudorandomFunction/TruthTable.lean @@ -109,11 +109,11 @@ theorem isOraclePPTOn_queryTable : IsOraclePPTOn (encList encBits) encBits query cases words with | nil => simp only [queryTableStep, List.isEmpty_nil, ite_true] at hnext - rw [ProbOracleComp.eq_of_mem_support_pure hnext] + rw [OracleComp.eq_of_mem_supportWith_pure hnext] simp | cons word words => simp only [queryTableStep, List.isEmpty_cons, Bool.false_eq_true, ite_false] at hnext - obtain ⟨reply, -, rfl⟩ := ProbOracleComp.mem_support_map hnext + obtain ⟨reply, -, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hnext simp only [length_encPair, encBits_apply, List.length_append, List.length_singleton, List.tail_cons, length_encList, List.map_cons, List.sum_cons] omega @@ -122,10 +122,10 @@ theorem isOraclePPTOn_queryTable : IsOraclePPTOn (encList encBits) encBits query theorem interpret_queryTable {m : Type → Type*} [Monad m] [LawfulMonad m] (random : (n : ℕ) → m (Fin (n + 1))) (oracle : List Bool → List Bool) (words : List (List Bool)) : - OracleComp.interpret (ProbOracleComp.handler random fun request => pure (oracle request.2)) + OracleComp.interpret (OracleComp.sumHandler random fun request => pure (oracle request.2)) (queryTable words) = pure (words.map fun word => (oracle word).headD false) := by have key : ∀ (words : List (List Bool)) (acc : List Bool), - OracleComp.interpret (ProbOracleComp.handler random fun request => pure (oracle request.2)) + OracleComp.interpret (OracleComp.sumHandler random fun request => pure (oracle request.2)) (OracleComp.iterate words.length queryTableStep (words, acc)) = pure ([], acc ++ words.map fun word => (oracle word).headD false) := by intro words @@ -135,7 +135,7 @@ theorem interpret_queryTable {m : Type → Type*} [Monad m] [LawfulMonad m] intro acc rw [List.length_cons, OracleComp.iterate_succ_bind, OracleComp.interpret_bind] have hstep : OracleComp.interpret - (ProbOracleComp.handler random fun request => pure (oracle request.2)) + (OracleComp.sumHandler random fun request => pure (oracle request.2)) (queryTableStep (word :: words, acc)) = pure (words, acc ++ [(oracle word).headD false]) := by simp only [queryTableStep, List.isEmpty_cons, Bool.false_eq_true, ite_false, diff --git a/Complexity/Crypto/Computational/Signature.lean b/Complexity/Crypto/Computational/Signature.lean index 204b91866f..9a46e6a270 100644 --- a/Complexity/Crypto/Computational/Signature.lean +++ b/Complexity/Crypto/Computational/Signature.lean @@ -171,7 +171,7 @@ def eufCmaGame (S : SignatureScheme) (adversary : Forger) (n : ℕ) : ProbComp Bool := do let keys ← S.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.signingOracle keys.2)) (adversary n keys.1)).run [] return (out.1.1.length == n) && !out.2.contains out.1.1 && S.verify keys.1 out.1.1 out.1.2 @@ -196,7 +196,7 @@ theorem isPPTOn_eufCmaGame (S : SignatureScheme) {adversary : Forger} (encPair (encPair encBits encBits) (encList encBits)) (fun caller : ℕ × (List Bool × List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.signingOracle caller.2.2)) (adversary caller.1 caller.2.1)).run []) := by apply hadversary.run_interpret_preprocess (prepare := fun caller : ℕ × (List Bool × List Bool) => (caller.1, caller.2.1)) @@ -273,7 +273,7 @@ def eufOneTimeGame (S : SignatureScheme) (adversary : Forger) (n : ℕ) : ProbComp Bool := do let keys ← S.keyGen n let out ← (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.oneTimeSigningOracle keys.2)) (adversary n keys.1)).run [] return (out.1.1.length == n) && !out.2.contains out.1.1 && S.verify keys.1 out.1.1 out.1.2 @@ -287,7 +287,7 @@ theorem isPPTOn_run_oneTimeSigningOracle (S : SignatureScheme) {adversary : Forg (encPair (encPair encBits encBits) (encList encBits)) (fun caller : ℕ × (List Bool × List Bool) => (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.oneTimeSigningOracle caller.2.2)) (adversary caller.1 caller.2.1)).run []) := by obtain ⟨c, d, hlen⟩ := S.sign_ppt.length_le have hhandler : IsPPTOn @@ -375,7 +375,7 @@ message. -/ theorem length_le_one_of_mem_support_run_oneTimeSigningOracle (S : SignatureScheme) {α : Type} (sk : List Bool) (prog : WordOracleComp Unit α) {result : α} {queried : List (List Bool)} (h : (result, queried) ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle sk q s))) prog).run []).support) : queried.length ≤ 1 := by refine ProbOracleComp.run_interpret_invariant @@ -398,7 +398,7 @@ private theorem run_oneTimeSigningOracle_apply_eq_zero_of_not_agree (S : Signatu {s queried' : List (List Bool)} (hs : ¬ ∀ r ∈ s, agree r) (hq' : ∀ r ∈ queried', agree r) (a : α) : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle sk q s))) prog).run s) (a, queried') = 0 := by rw [PMF.apply_eq_zero_iff] @@ -427,10 +427,10 @@ theorem run_oneTimeSigningOracle_apply_eq_of_agree (S : SignatureScheme) {α : T (prog : WordOracleComp Unit α) (s : List (List Bool)) (a : α) (queried' : List (List Bool)) (hq' : ∀ r ∈ queried', agree r) : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle sk₁ q s))) prog).run s) (a, queried') = ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle sk₂ q s))) prog).run s) (a, queried') := by induction prog using PFunctor.FreeM.induction generalizing s with @@ -464,13 +464,13 @@ theorem run_oneTimeSigningOracle_apply_eq_of_agree (S : SignatureScheme) {α : T PMF.bind_apply] have h1 (sig : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle sk₁ q s))) (cont sig)).run [msg]) (a, queried') = 0 := run_oneTimeSigningOracle_apply_eq_zero_of_not_agree S sk₁ (cont sig) hnot hq' a have h2 (sig : List Bool) : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.oneTimeSigningOracle sk₂ q s))) (cont sig)).run [msg]) (a, queried') = 0 := run_oneTimeSigningOracle_apply_eq_zero_of_not_agree S sk₂ (cont sig) hnot hq' a @@ -495,7 +495,7 @@ def oneTimeFilterHandler (bound : ℕ → ℕ → ℕ) (caller : ℕ × List Boo def limitToOneQuery (bound : ℕ → ℕ → ℕ) (adversary : Forger) : Forger := fun n pk => Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (oneTimeFilterHandler bound (n, pk))) (adversary n pk)).run false @@ -547,7 +547,7 @@ theorem isOraclePPT_limitToOneQuery {bound : ℕ → ℕ → ℕ} (encPair (encPair encBits encBits) encBool) (fun caller : ℕ × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (oneTimeFilterHandler bound caller)) (adversary caller.1 caller.2)).run false) := by @@ -568,11 +568,11 @@ theorem isOraclePPT_limitToOneQuery {bound : ℕ → ℕ → ℕ} intro caller request state _ result hresult unfold oneTimeFilterHandler at hresult split_ifs at hresult with hstate - · have heq := ProbOracleComp.eq_of_mem_support_pure hresult + · have heq := OracleComp.eq_of_mem_supportWith_pure hresult subst heq simp [encBool_apply] - · obtain ⟨sig, hsig, rfl⟩ := ProbOracleComp.mem_support_map hresult - obtain ⟨rawSig, _, rfl⟩ := ProbOracleComp.mem_support_map hsig + · obtain ⟨sig, hsig, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult + obtain ⟨rawSig, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hsig refine ⟨trivial, ?_, ?_⟩ · exact (List.length_take_le _ _).trans (by lia) · simp [encBool_apply] @@ -585,15 +585,15 @@ private theorem run_limitToOneQuery_eq_oneTimeSigningOracle (S : SignatureScheme sig.length ≤ bound n msg.length) (prog : WordOracleComp Unit (List Bool × List Bool)) : ProbComp.eval (Prod.map Prod.fst id <$> ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.signingOracle sk)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (oneTimeFilterHandler bound (n, pk))) prog).run false)).run [])) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.oneTimeSigningOracle sk)) prog).run []) := by rw [ProbComp.eval_map, ProbOracleComp.eval_run_interpret, ProbOracleComp.eval_run_interpret, ProbOracleComp.run_interpret_run_interpret, PMF.map_comp] @@ -602,7 +602,7 @@ private theorem run_limitToOneQuery_eq_oneTimeSigningOracle (S : SignatureScheme (oracle := fun q s => ProbComp.eval (S.oneTimeSigningOracle sk q s)) (oracle' := fun q (state : Bool × List (List Bool)) => ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q s => ProbComp.eval (S.signingOracle sk q s))) ((oneTimeFilterHandler bound (n, pk) q).run state.1)).run state.2).map (fun result => (result.1.1, result.1.2, result.2))) @@ -662,14 +662,14 @@ theorem EUFCMA.oneTimeEUFCMA {S : SignatureScheme} (h : S.EUFCMA) : S.OneTimeEUF have hrun := run_limitToOneQuery_eq_oneTimeSigningOracle S bound n keys.1 keys.2 hsigBound (adversary n keys.1) have hmap : ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.signingOracle keys.2)) (limitToOneQuery bound adversary n keys.1)).run []) = Prod.map Prod.fst id <$> ((OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (S.signingOracle keys.2)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) (oneTimeFilterHandler bound (n, keys.1))) (adversary n keys.1)).run false)).run []) := by diff --git a/Complexity/Crypto/Game/UntilBad.lean b/Complexity/Crypto/Game/UntilBad.lean index f80d1e46db..935d7daf50 100644 --- a/Complexity/Crypto/Game/UntilBad.lean +++ b/Complexity/Crypto/Game/UntilBad.lean @@ -93,7 +93,7 @@ open scoped ENNReal NNReal noncomputable def runStatelessOracle {α : Type} (o : List Bool → List Bool) (prog : WordOracleComp Unit α) (next : α → Game) : Game := (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (fun req (s : Unit) => pure (o req.2, s))) prog).run ())).bind (fun out => next out.1) @@ -111,7 +111,7 @@ theorem runStatelessOracle_query_inl {α : Type} (o : List Bool → List Bool) runStatelessOracle o (OracleComp.query (Sum.inl m) >>= k) next = (PMF.uniformOfFintype (Fin (m + 1))).bind (fun x => runStatelessOracle o (k x) next) := by - simp [runStatelessOracle, ProbOracleComp.handler, StateT.run_bind, + simp [runStatelessOracle, OracleComp.sumHandler, StateT.run_bind, ProbComp.eval_bind, PMF.bind_bind] theorem runStatelessOracle_query_inr {α : Type} (o : List Bool → List Bool) @@ -122,7 +122,7 @@ theorem runStatelessOracle_query_inr {α : Type} (o : List Bool → List Bool) runStatelessOracle o (OracleComp.query (Sum.inr req) >>= k) next = runStatelessOracle o (k (o req.2)) next := by rw [runStatelessOracle, OracleComp.interpret_bind, OracleComp.interpret_query, - ProbOracleComp.handler, StateT.run_bind] + OracleComp.sumHandler, StateT.run_bind] rfl /-- **Stateless oracle until-bad bound**: if `prog` makes at most `Q` oracle queries, `o₁ τ req` @@ -239,7 +239,7 @@ theorem advantage_runStatelessOracle_le_of_support {α : Type} (o : List Bool → List Bool) (prog : WordOracleComp Unit α) (next₁ next₂ : α → Game) {ε : ℝ≥0} (h : ∀ out ∈ (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (fun req (s : Unit) => pure (o req.2, s))) prog).run ())).support, Game.advantage (next₁ out.1) (next₂ out.1) ≤ ε) : Game.advantage (runStatelessOracle o prog next₁) (runStatelessOracle o prog next₂) ≤ ε := @@ -282,7 +282,7 @@ noncomputable def runFinderOracle {α : Type} (o₂ : List Bool → List Bool) (prog : WordOracleComp Unit α) (s : Option (List Bool)) (isGood : List Bool → Bool) : Game := (ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifFin m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifFin m)) (finderPhase2Oracle o₂ isBad extract)) prog).run s)).bind (fun out => PMF.pure (out.2.elim false isGood)) @@ -302,7 +302,7 @@ theorem runFinderOracle_query_inl {α : Type} (o₂ : List Bool → List Bool) runFinderOracle o₂ isBad extract (OracleComp.query (Sum.inl m) >>= k) s isGood = (PMF.uniformOfFintype (Fin (m + 1))).bind (fun x => runFinderOracle o₂ isBad extract (k x) s isGood) := by - simp [runFinderOracle, ProbOracleComp.handler, StateT.run_bind, + simp [runFinderOracle, OracleComp.sumHandler, StateT.run_bind, ProbComp.eval_bind, PMF.bind_bind] theorem runFinderOracle_query_inr {α : Type} (o₂ : List Bool → List Bool) @@ -315,7 +315,7 @@ theorem runFinderOracle_query_inr {α : Type} (o₂ : List Bool → List Bool) runFinderOracle o₂ isBad extract (k (o₂ req.2)) (if isBad req.2 then some (extract req.2) else s) isGood := by rw [runFinderOracle, OracleComp.interpret_bind, OracleComp.interpret_query, - ProbOracleComp.handler, StateT.run_bind] + OracleComp.sumHandler_inr, StateT.run_bind] rfl /-- Once `s` satisfies `s.elim false isGood = true`, `runFinderOracle` succeeds with diff --git a/Complexity/Crypto/Protocols/MAC/CarterWegman.lean b/Complexity/Crypto/Protocols/MAC/CarterWegman.lean index 42a50c10db..393aa63f1d 100644 --- a/Complexity/Crypto/Protocols/MAC/CarterWegman.lean +++ b/Complexity/Crypto/Protocols/MAC/CarterWegman.lean @@ -1629,7 +1629,7 @@ def prfMultiPadDistinguisher (Q : ℕ → ℕ) (nonce : ℕ → ℕ → List Boo private theorem interpret_iterate_prfPadCollectStep (n : ℕ) (nonce : ℕ → ℕ → List Bool) (f : List Bool → List Bool) (q : ℕ) (init : List (List Bool)) : OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => pure (f request.2))) + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (f request.2))) (OracleComp.iterate q (prfPadCollectStep n nonce) init) = pure (init ++ (List.range q).map (fun i => (f (nonce n (init.length + i))).take n)) := by induction q generalizing init with @@ -1830,8 +1830,8 @@ theorem isOraclePPT_prfMultiPadDistinguisher (by polytime) (by polytime) hstep hpoly ?_ intro p pads next hnext unfold prfPadCollectStep at hnext - obtain ⟨reply, hreply, rfl⟩ := ProbOracleComp.mem_support_map hnext - obtain ⟨rawReply, _, rfl⟩ := ProbOracleComp.mem_support_map hreply + obtain ⟨reply, hreply, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hnext + obtain ⟨rawReply, _, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hreply have hlen : (rawReply.take p.1).length ≤ p.1 := List.length_take_le _ _ simp only [encList_append, encList_cons, encList_nil, List.append_nil, List.length_append, length_frame, encBits_apply] @@ -2230,43 +2230,43 @@ theorem probOracleComp_uniform_bind_run_interpret_nonceFnHandler {α β : Type} (hpost : ∀ a tr' padFn, ¬ (tr'.map (fun ((_, x), _) => x)).Nodup → post a tr' padFn = c) : ((PMF.uniformOfFintype (N → Y)).bind fun table => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler hash k (reconstructPadFn hash k tr table))) prog).run tr).bind fun res => post res.1 res.2 (reconstructPadFn hash k tr table)) = (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) nonceSimHandler) prog).run tr).bind fun res => (PMF.uniformOfFintype (N → Y)).bind fun table => post res.1 res.2 (reconstructPadFn hash k res.2 table)) := by have happ_fn (padFn : N → Y) : - ∀ q tr₁ res, res ∈ (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + ∀ q tr₁ res, res ∈ (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler hash k padFn) q tr₁).support → ∃ s, res.2 = tr₁ ++ s := by intro q tr₁ res hres cases q with | inl m => - simp only [ProbOracleComp.handler, StateT.lift, PMF.monad_bind_eq_bind, + simp only [OracleComp.sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.support_pure, Set.mem_singleton_iff] at hres rcases hres with ⟨i, -, hres⟩ exact ⟨[], by simp [congrArg Prod.snd hres]⟩ | inr q => - simp only [ProbOracleComp.handler, nonceFnHandler, PMF.support_pure, + simp only [OracleComp.sumHandler, nonceFnHandler, PMF.support_pure, Set.mem_singleton_iff] at hres exact ⟨[(q, _)], congrArg Prod.snd hres⟩ have happ_sim : - ∀ q tr₁ res, res ∈ (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + ∀ q tr₁ res, res ∈ (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceSimHandler (M := M) (N := N) (Y := Y)) q tr₁).support → ∃ s, res.2 = tr₁ ++ s := by intro q tr₁ res hres cases q with | inl m => - simp only [ProbOracleComp.handler, StateT.lift, PMF.monad_bind_eq_bind, + simp only [OracleComp.sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.support_pure, Set.mem_singleton_iff] at hres rcases hres with ⟨i, -, hres⟩ exact ⟨[], by simp [congrArg Prod.snd hres]⟩ | inr q => - simp only [ProbOracleComp.handler, nonceSimHandler, PMF.monad_bind_eq_bind, + simp only [OracleComp.sumHandler, nonceSimHandler, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.support_pure, Set.mem_singleton_iff] at hres rcases hres with ⟨t, -, hres⟩ @@ -2284,21 +2284,21 @@ theorem probOracleComp_uniform_bind_run_interpret_nonceFnHandler {α β : Type} · cases q with | inl m => simp only [OracleComp.run_interpret_bind, OracleComp.run_interpret_query, - ProbOracleComp.handler, StateT.lift, PMF.monad_bind_eq_bind, + OracleComp.sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] rw [PMF.bind_comm (PMF.uniformOfFintype (N → Y)) (ProbComp.unifOracle m)] congr 1; funext i exact ih i tr | inr q => simp only [OracleComp.run_interpret_bind, OracleComp.run_interpret_query, - ProbOracleComp.handler, nonceFnHandler, nonceSimHandler, PMF.monad_bind_eq_bind, + OracleComp.sumHandler, nonceFnHandler, nonceSimHandler, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] by_cases hx : q.2 ∈ tr.map (fun e => e.1.2) · have hnot (t : Y) : ¬ ((tr ++ [(q, t)]).map (fun e => e.1.2)).Nodup := not_nodup_map_append_of_mem q.1 t hx have hlhs (table : N → Y) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler hash k (reconstructPadFn hash k tr table))) (cont (sign hash k (reconstructPadFn hash k tr table q.2) q.1))).run (tr ++ [(q, sign hash k (reconstructPadFn hash k tr table q.2) q.1)])).bind @@ -2307,7 +2307,7 @@ theorem probOracleComp_uniform_bind_run_interpret_nonceFnHandler {α β : Type} (fun a tr' h => hpost a tr' _ h) have hrhs (t : Y) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) nonceSimHandler) (cont t)).run (tr ++ [(q, t)])).bind (fun res => (PMF.uniformOfFintype (N → Y)).bind fun table => post res.1 res.2 (reconstructPadFn hash k res.2 table)) = c := @@ -2316,14 +2316,14 @@ theorem probOracleComp_uniform_bind_run_interpret_nonceFnHandler {α β : Type} · rw [uniform_reconstructPadFn_step hash k q.1 hx (fun t tr' fn => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler hash k fn)) (cont t)).run tr').bind fun res => post res.1 res.2 fn)] congr 1; funext t exact ih t (tr ++ [(q, t)]) · have hlhs (table : N → Y) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler hash k (reconstructPadFn hash k tr table))) (OracleComp.query q >>= cont)).run tr).bind (fun res => post res.1 res.2 (reconstructPadFn hash k tr table)) = c := @@ -2331,7 +2331,7 @@ theorem probOracleComp_uniform_bind_run_interpret_nonceFnHandler {α β : Type} (fun a tr' h => hpost a tr' _ h) have hrhs : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) nonceSimHandler) (OracleComp.query q >>= cont)).run tr).bind (fun res => (PMF.uniformOfFintype (N → Y)).bind fun table => post res.1 res.2 (reconstructPadFn hash k res.2 table)) = c := @@ -2760,29 +2760,29 @@ private theorem interpret_deterministic_run_interpret {State α : Type} (handler : Unit × List Bool → StateT State (WordOracleComp Unit) (List Bool)) (prog : WordOracleComp Unit α) (s : State) : OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => pure (g request.2))) + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (g request.2))) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin k))) handler) prog).run s) = (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request state => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun req => pure (g req.2))) + (OracleComp.sumHandler ProbComp.unifFin (fun req => pure (g req.2))) (handler request state))) prog).run s := by have hf : IsMonadHom (WordOracleComp Unit) ProbComp (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun request => pure (g request.2)))) := + (OracleComp.sumHandler ProbComp.unifFin (fun request => pure (g request.2)))) := PFunctor.FreeM.isMonadHom_liftM _ rw [OracleComp.map_run_interpret hf] congr 2 funext q state cases q with - | inl k => simp [ProbOracleComp.handler, StateT.lift, ProbComp.unifFin] + | inl k => simp [OracleComp.sumHandler, StateT.lift, ProbComp.unifFin] | inr request => rfl @[simp] @@ -3000,7 +3000,7 @@ def prfNonceToPrfDistinguisher (msgLen : ℕ → ℕ) (seed : ℕ → ProbComp ( let k ← ProbOracleComp.sample (seed n) let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cwNonceLogHandler msgLen hash n k)) (adversary n [])).run [] @@ -3085,7 +3085,7 @@ theorem isOraclePPT_prfNonceToPrfDistinguisher (encList (encPair (encPair encBits encBits) encBits))) (fun caller : (ℕ × List Bool) × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cwNonceLogHandler msgLen hash caller.1.1 caller.2)) (adversary caller.1.1 [])).run []) := by @@ -3099,14 +3099,14 @@ theorem isOraclePPT_prfNonceToPrfDistinguisher dsimp only [cwNonceLogHandler] at hresult have hsplit := length_unframe_add_dropFrame_le request.2 split at hresult - · obtain ⟨pad, -, rfl⟩ := ProbOracleComp.mem_support_map hresult + · obtain ⟨pad, -, rfl⟩ := OracleComp.mem_supportWith_map_iff.mp hresult refine ⟨trivial, ?_, ?_⟩ · rw [BitString.length_listXor] lia · simp only [encList_cons, encPair_apply, encBits_apply, List.length_append, length_frame, BitString.length_listXor] lia - · have hres := ProbOracleComp.eq_of_mem_support_pure hresult + · have hres := OracleComp.eq_of_mem_supportWith_pure hresult subst hres refine ⟨trivial, ?_, ?_⟩ · simp @@ -3183,7 +3183,7 @@ theorem eval_prfRealGame_prfNonceToPrfDistinguisher have hhandler : (fun request state => OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun req => + (OracleComp.sumHandler ProbComp.unifFin (fun req => pure (prfOracle family n prfKey req.2))) (cwNonceLogHandler msgLen hash n k request state)) = M.signingPairOracle (encPair encBits encBits (k, prfKey)) := by @@ -3297,22 +3297,22 @@ private theorem eval_cwNonceLogHandler_randomFunctionOracle_le (tr : List ((BitString (msgLen n) × BitString n) × BitString n)) (hsub : tr.map ofBitTriple <+ init.reverse) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun request state => ProbComp.eval (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin (fun req => + (OracleComp.sumHandler ProbComp.unifFin (fun req => pure (randomFunctionOracle n table req.2))) (cwNonceLogHandler msgLen hash n k request state)))) prog).run init).bind (fun out => PMF.pure (cwNonceIdealCheck msgLen hash n k table out)) true ≤ ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (adaptNonceStep msgLen n)) prog).run init)).run tr).bind @@ -3339,18 +3339,18 @@ private theorem eval_cwNonceLogHandler_randomFunctionOracle_le (Fin (m + 1) × List ((List Bool × List Bool) × List Bool))) = (OracleComp.query (Sum.inl m) >>= fun i => pure (i, init)) := by simp [StateT.lift, ProbOracleComp.sample, ProbComp.unifFin] - rw [ProbOracleComp.handler, ProbOracleComp.handler, hsample, + rw [OracleComp.sumHandler, OracleComp.sumHandler, hsample, OracleComp.run_interpret_bind, OracleComp.run_interpret_query] - simp only [ProbOracleComp.handler, StateT.lift, OracleComp.run_interpret_pure, + simp only [OracleComp.sumHandler, StateT.lift, OracleComp.run_interpret_pure, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] refine bind_apply_mono_on_support (ProbComp.unifOracle m) true fun i _ => ?_ exact ih i init tr hsub | inr request => - dsimp only [ProbOracleComp.handler, cwNonceLogHandler, adaptNonceStep] + dsimp only [OracleComp.sumHandler, cwNonceLogHandler, adaptNonceStep] let msg := unframe request.2 let nonce := dropFrame request.2 change (((OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin fun req => + (OracleComp.sumHandler ProbComp.unifFin fun req => pure (randomFunctionOracle n table req.2)) (if (msg.length == msgLen n && nonce.length == n) = true then (fun pad => @@ -3360,16 +3360,16 @@ private theorem eval_cwNonceLogHandler_randomFunctionOracle_le else pure ([], ((msg, nonce), []) :: init))).eval.bind fun x => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) fun request state => (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin fun req => + (OracleComp.sumHandler ProbComp.unifFin fun req => pure (randomFunctionOracle n table req.2)) (cwNonceLogHandler msgLen hash n k request state)).eval) (cont x.1)).run x.2)).bind fun out => PMF.pure (cwNonceIdealCheck msgLen hash n k table out)) true ≤ (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) @@ -3380,12 +3380,12 @@ private theorem eval_cwNonceLogHandler_randomFunctionOracle_le else pure ([], ((msg, nonce), []) :: init))).run tr >>= fun x => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (adaptNonceStep msgLen n)) (cont x.1.1)).run x.1.2)).run x.2).bind @@ -3399,7 +3399,7 @@ private theorem eval_cwNonceLogHandler_randomFunctionOracle_le rw [OracleComp.run_interpret_map] have hq_rhs : (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) @@ -3463,7 +3463,7 @@ theorem eval_prfIdealGame_prfNonceToPrfDistinguisher_le let adaptProg : ProbOracleComp (fun _ : BitString (msgLen n) × BitString n => BitString n) (((List Bool × List Bool) × List Bool) × List ((List Bool × List Bool) × List Bool)) := (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (adaptNonceStep msgLen n)) (adversary n [])).run [] @@ -3472,7 +3472,7 @@ theorem eval_prfIdealGame_prfNonceToPrfDistinguisher_le ((ProbComp.eval (seed n)).bind fun k => (PMF.uniformOfFintype (BitString n → BitString n)).bind fun table => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler hashBit k table)) adaptProg).run []).bind fun res => PMF.pure @@ -3493,13 +3493,13 @@ theorem eval_prfIdealGame_prfNonceToPrfDistinguisher_le have hsim (k : List Bool) : ((PMF.uniformOfFintype (BitString n → BitString n)).bind fun table => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (nonceFnHandler hashBit k table)) adaptProg).run []).bind fun res => PMF.pure (checkNonceSUF hashBit k table res.2 (toBitTriple (msgLen n) n res.1.1))) = (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) nonceSimHandler) adaptProg).run []).bind fun res => (PMF.uniformOfFintype (BitString n → BitString n)).bind fun table => PMF.pure (checkNonceSUF hashBit k (reconstructPadFn hashBit k res.2 table) @@ -4288,49 +4288,49 @@ theorem probOracleComp_uniform_bind_run_interpret_randomNonceFnHandler {α β : (hpost : ∀ a tr' padFn, ¬ (tr'.map (fun ((_, x), _) => x)).Nodup → post a tr' padFn = c) : ((PMF.uniformOfFintype (N → Y)).bind fun table => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k (reconstructPadFn hash k tr table))) prog).run tr).bind fun res => post res.1 res.2 (reconstructPadFn hash k tr table)) = (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) prog).run tr).bind fun res => (PMF.uniformOfFintype (N → Y)).bind fun table => post res.1 res.2 (reconstructPadFn hash k res.2 table)) := by have happ_fn (padFn : N → Y) : ∀ q tr₁ res, - res ∈ (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + res ∈ (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k padFn) q tr₁).support → ∃ s, res.2 = tr₁ ++ s := by intro q tr₁ res hres cases q with | inl num => - simp only [ProbOracleComp.handler, StateT.lift, PMF.monad_bind_eq_bind, + simp only [OracleComp.sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.support_pure, Set.mem_singleton_iff] at hres rcases hres with ⟨i, -, hres⟩ exact ⟨[], by simp [congrArg Prod.snd hres]⟩ | inr m => - simp only [ProbOracleComp.handler, randomNonceFnHandler, PMF.monad_bind_eq_bind, + simp only [OracleComp.sumHandler, randomNonceFnHandler, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.support_pure, Set.mem_singleton_iff] at hres rcases hres with ⟨x, -, hres⟩ exact ⟨[((m, x), _)], congrArg Prod.snd hres⟩ have happ_sim : ∀ q tr₁ res, - res ∈ (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + res ∈ (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceSimHandler (M := M) (N := N) (Y := Y)) q tr₁).support → ∃ s, res.2 = tr₁ ++ s := by intro q tr₁ res hres cases q with | inl num => - simp only [ProbOracleComp.handler, StateT.lift, PMF.monad_bind_eq_bind, + simp only [OracleComp.sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.support_pure, Set.mem_singleton_iff] at hres rcases hres with ⟨i, -, hres⟩ exact ⟨[], by simp [congrArg Prod.snd hres]⟩ | inr m => - simp only [ProbOracleComp.handler, randomNonceSimHandler, PMF.monad_bind_eq_bind, + simp only [OracleComp.sumHandler, randomNonceSimHandler, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.support_pure, Set.mem_singleton_iff] at hres rcases hres with ⟨x, -, t, -, hres⟩ @@ -4347,7 +4347,7 @@ theorem probOracleComp_uniform_bind_run_interpret_randomNonceFnHandler {α β : cases q with | inl num => simp only [OracleComp.run_interpret_bind, OracleComp.run_interpret_query, - ProbOracleComp.handler, StateT.lift, PMF.monad_bind_eq_bind, + OracleComp.sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] rw [PMF.bind_comm (PMF.uniformOfFintype (N → Y)) (ProbComp.unifOracle num)] congr 1; funext i @@ -4355,7 +4355,7 @@ theorem probOracleComp_uniform_bind_run_interpret_randomNonceFnHandler {α β : | inr m => by_cases hnodup : (tr.map (fun e => e.1.2)).Nodup · simp only [OracleComp.run_interpret_bind, OracleComp.run_interpret_query, - ProbOracleComp.handler, randomNonceFnHandler, randomNonceSimHandler, + OracleComp.sumHandler, randomNonceFnHandler, randomNonceSimHandler, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] rw [PMF.bind_comm (PMF.uniformOfFintype (N → Y)) (PMF.uniformOfFintype N)] congr 1; funext x @@ -4364,7 +4364,7 @@ theorem probOracleComp_uniform_bind_run_interpret_randomNonceFnHandler {α β : not_nodup_map_append_of_mem m t hx have hlhs (table : N → Y) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k (reconstructPadFn hash k tr table))) (cont (x, sign hash k (reconstructPadFn hash k tr table x) m))).run (tr ++ [((m, x), sign hash k (reconstructPadFn hash k tr table x) m)])).bind @@ -4373,7 +4373,7 @@ theorem probOracleComp_uniform_bind_run_interpret_randomNonceFnHandler {α β : (fun a tr' h => hpost a tr' _ h) have hrhs (t : Y) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) (cont (x, t))).run (tr ++ [((m, x), t)])).bind (fun res => (PMF.uniformOfFintype (N → Y)).bind fun table => @@ -4383,14 +4383,14 @@ theorem probOracleComp_uniform_bind_run_interpret_randomNonceFnHandler {α β : · rw [uniform_reconstructPadFn_step hash k m hx (fun t tr' fn => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k fn)) (cont (x, t))).run tr').bind fun res => post res.1 res.2 fn)] congr 1; funext t exact ih (x, t) (tr ++ [((m, x), t)]) · have hlhs (table : N → Y) : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k (reconstructPadFn hash k tr table))) (OracleComp.query (Sum.inr m) >>= cont)).run tr).bind (fun res => post res.1 res.2 (reconstructPadFn hash k tr table)) = c := @@ -4398,7 +4398,7 @@ theorem probOracleComp_uniform_bind_run_interpret_randomNonceFnHandler {α β : (fun a tr' h => hpost a tr' _ h) have hrhs : ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) (OracleComp.query (Sum.inr m) >>= cont)).run tr).bind (fun res => (PMF.uniformOfFintype (N → Y)).bind fun table => post res.1 res.2 (reconstructPadFn hash k res.2 table)) = c := @@ -4415,7 +4415,7 @@ theorem probOracleComp_randomNonceSimHandler_not_nodup_le {α : Type} {prog : ProbOracleComp (fun _ : M => N × Y) α} {Q : ℕ} (hprog : prog.IsQueryBounded Q) (tr : List ((M × N) × Y)) : (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) prog).run tr).bind fun res => PMF.pure (!decide (res.2.map (fun ((_, x), _) => x)).Nodup)) true ≤ if (tr.map (fun ((_, x), _) => x)).Nodup then @@ -4430,29 +4430,29 @@ theorem probOracleComp_randomNonceSimHandler_not_nodup_le {α : Type} | inl num => simp only [Sum.elim_inl, Nat.add_zero] change (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) (OracleComp.query (Sum.inl num) >>= cont)).run tr).bind fun res => PMF.pure (!decide (res.2.map (fun e => e.1.2)).Nodup)) true ≤ _ simp only [OracleComp.run_interpret_bind, OracleComp.run_interpret_query, - ProbOracleComp.handler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, + OracleComp.sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] rw [PMF.bind_apply] exact tsum_mul_le_of_forall_le (ProbComp.unifOracle num) fun i => ih i tr | inr m => simp only [Sum.elim_inr] change (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) (OracleComp.query (Sum.inr m) >>= cont)).run tr).bind fun res => PMF.pure (!decide (res.2.map (fun e => e.1.2)).Nodup)) true ≤ _ by_cases hnodup : (tr.map (fun e => e.1.2)).Nodup · simp only [hnodup, ↓reduceIte, OracleComp.run_interpret_bind, - OracleComp.run_interpret_query, ProbOracleComp.handler, randomNonceSimHandler, + OracleComp.run_interpret_query, OracleComp.sumHandler, randomNonceSimHandler, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] let B : ℝ≥0∞ := ((∑ i ∈ Finset.range Q, (tr.length + 1 + i) : ℕ) : ℝ≥0∞) / Fintype.card N have hxt (x : N) (t : Y) : (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) (cont (x, t))).run (tr ++ [((m, x), t)])).bind fun res => PMF.pure (!decide (res.2.map (fun e => e.1.2)).Nodup)) true ≤ @@ -4474,7 +4474,7 @@ theorem probOracleComp_randomNonceSimHandler_not_nodup_le {α : Type} have hx_bound (x : N) : ((PMF.uniformOfFintype Y).bind fun t => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) (cont (x, t))).run (tr ++ [((m, x), t)])).bind fun res => PMF.pure (!decide (res.2.map (fun e => e.1.2)).Nodup)) true ≤ @@ -4509,7 +4509,7 @@ theorem probOracleComp_randomNonceSimHandler_not_nodup_le {α : Type} calc ∑' x, PMF.uniformOfFintype N x * ((PMF.uniformOfFintype Y).bind fun t => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) (cont (x, t))).run (tr ++ [((m, x), t)])).bind fun res => PMF.pure (!decide (res.2.map (fun e => e.1.2)).Nodup)) true @@ -4543,7 +4543,7 @@ theorem seed_uniform_probOracleComp_checkRandomNonceSUF_le {α : Type} (seed.bind fun k => (PMF.uniformOfFintype (N → Y)).bind fun rf => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k rf)) prog).run []).bind fun res => PMF.pure (checkRandomNonceSUF hash k rf res.2 (out res.1))) true ≤ @@ -4552,14 +4552,14 @@ theorem seed_uniform_probOracleComp_checkRandomNonceSUF_le {α : Type} (seed.bind fun k => (PMF.uniformOfFintype (N → Y)).bind fun rf => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k rf)) prog).run []).bind fun res => PMF.pure (checkRandomNonceSUF hash k rf res.2 (out res.1))) true ≤ (seed.bind fun k => (PMF.uniformOfFintype (N → Y)).bind fun rf => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k rf)) prog).run []).bind fun res => @@ -4568,7 +4568,7 @@ theorem seed_uniform_probOracleComp_checkRandomNonceSUF_le {α : Type} refine bind_apply_mono_on_support (PMF.uniformOfFintype (N → Y)) true fun rf _ => ?_ refine bind_apply_mono_on_support ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k rf)) prog).run []) true fun res _ => ?_ by_cases h : checkRandomNonceSUF hash k rf res.2 (out res.1) = true @@ -4578,12 +4578,12 @@ theorem seed_uniform_probOracleComp_checkRandomNonceSUF_le {α : Type} have hsim (k : K) : ((PMF.uniformOfFintype (N → Y)).bind fun rf => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hash k rf)) prog).run []).bind fun res => PMF.pure (checkRandomNonceOrCollision hash k rf res.2 (out res.1))) = (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) prog).run []).bind fun res => (PMF.uniformOfFintype (N → Y)).bind fun table => PMF.pure @@ -4597,7 +4597,7 @@ theorem seed_uniform_probOracleComp_checkRandomNonceSUF_le {α : Type} simp only [hsim] let simPMF := (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) randomNonceSimHandler) prog).run [] rw [PMF.bind_comm seed simPMF] have hpoint (res : α × List ((M × N) × Y)) : @@ -4813,7 +4813,7 @@ noncomputable def prfRandomNonceToPrfDistinguisher (msgLen : ℕ → ℕ) let k ← ProbOracleComp.sample (seed n) let out ← (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cwRandomNonceLogHandler msgLen hash n k)) (adversary n [])).run [] @@ -5042,7 +5042,7 @@ theorem isOraclePPT_prfRandomNonceToPrfDistinguisher (encPair (encPair encBits encBits) (encList (encPair encBits encBits))) (fun caller : (ℕ × List Bool) × List Bool => (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (cwRandomNonceLogHandler msgLen hash caller.1.1 caller.2)) (adversary caller.1.1 [])).run []) := by @@ -5128,7 +5128,7 @@ theorem eval_prfRealGame_prfRandomNonceToPrfDistinguisher (fun request state => ProbComp.eval (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin + (OracleComp.sumHandler ProbComp.unifFin (fun req => pure (prfOracle family n prfKey req.2))) (cwRandomNonceLogHandler msgLen hash n k request state))) = (fun request state => @@ -5188,18 +5188,18 @@ private theorem isQueryBounded_adaptRandomNonceStep (msgLen : ℕ → ℕ) (n : {α : Type} {prog : WordOracleComp Unit α} {Q : ℕ} (hprog : prog.IsQueryBounded Q) (init : List (List Bool × List Bool)) : ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (adaptRandomNonceStep msgLen n)) prog).run init).IsQueryBounded Q := by refine OracleComp.IsCostBounded.run_interpret (fun q s => ?_) hprog init cases q with | inl m => - simp only [ProbOracleComp.handler, StateT.run_lift, Sum.elim_inl] + simp only [OracleComp.sumHandler, StateT.run_lift, Sum.elim_inl] simpa using (ProbOracleComp.IsQueryBounded.sample (ProbComp.unifFin m)).bind fun a => .pure (a, s) 0 | inr req => - dsimp only [ProbOracleComp.handler, StateT.run, adaptRandomNonceStep, Sum.elim_inr] + dsimp only [OracleComp.sumHandler, StateT.run, adaptRandomNonceStep, Sum.elim_inr] split_ifs · rw [OracleComp.isCostBounded_map_iff] exact ProbOracleComp.IsQueryBounded.query (BitString.ofList (msgLen n) req.2) @@ -5266,22 +5266,22 @@ private theorem eval_cwRandomNonceLogHandler_randomFunctionOracle_le (tr : List ((BitString (msgLen n) × BitString n) × BitString n)) (hsub : tr.map ofRandomBitTriple <+ init.reverse) : (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun request state => ProbComp.eval (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin + (OracleComp.sumHandler ProbComp.unifFin (fun req => pure (randomFunctionOracle n table req.2))) (cwRandomNonceLogHandler msgLen hash n k request state)))) prog).run init).bind fun out => PMF.pure (cwRandomNonceIdealCheck msgLen hash n k table out)) true ≤ (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (adaptRandomNonceStep msgLen n)) prog).run init)).run tr).bind fun res => @@ -5308,17 +5308,17 @@ private theorem eval_cwRandomNonceLogHandler_randomFunctionOracle_le (Fin (num + 1) × List (List Bool × List Bool))) = (OracleComp.query (Sum.inl num) >>= fun i => pure (i, init)) := by simp [StateT.lift, ProbOracleComp.sample, ProbComp.unifFin] - rw [ProbOracleComp.handler, ProbOracleComp.handler, hsample, + rw [OracleComp.sumHandler, OracleComp.sumHandler, hsample, OracleComp.run_interpret_bind, OracleComp.run_interpret_query] - simp only [ProbOracleComp.handler, StateT.lift, OracleComp.run_interpret_pure, + simp only [OracleComp.sumHandler, StateT.lift, OracleComp.run_interpret_pure, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind] refine bind_apply_mono_on_support (ProbComp.unifOracle num) true fun i _ => ?_ exact ih i init tr hsub | inr req => - dsimp only [ProbOracleComp.handler, cwRandomNonceLogHandler, adaptRandomNonceStep] + dsimp only [OracleComp.sumHandler, cwRandomNonceLogHandler, adaptRandomNonceStep] let msg := req.2 change (((OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin + (OracleComp.sumHandler ProbComp.unifFin (fun r => pure (randomFunctionOracle n table r.2))) (if (msg.length == msgLen n) = true then do let nonce ← ProbOracleComp.sample (BitString.sampleList n) @@ -5330,17 +5330,17 @@ private theorem eval_cwRandomNonceLogHandler_randomFunctionOracle_le else pure ([], (msg, []) :: init))).eval >>= fun x => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (fun request state => ProbComp.eval (OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifFin + (OracleComp.sumHandler ProbComp.unifFin (fun req => pure (randomFunctionOracle n table req.2))) (cwRandomNonceLogHandler msgLen hash n k request state)))) (cont x.1)).run x.2)).bind fun out => PMF.pure (cwRandomNonceIdealCheck msgLen hash n k table out)) true ≤ (((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) @@ -5352,12 +5352,12 @@ private theorem eval_cwRandomNonceLogHandler_randomFunctionOracle_le else pure ([], (msg, []) :: init))).run tr >>= fun x => (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) ((OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (adaptRandomNonceStep msgLen n)) (cont x.1.1)).run x.1.2)).run x.2).bind @@ -5371,7 +5371,7 @@ private theorem eval_cwRandomNonceLogHandler_randomFunctionOracle_le rw [OracleComp.run_interpret_map] have hq_rhs : (OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler (fun k (m : BitString (msgLen n)) => BitString.ofList n (hash n k (List.ofFn m))) k table)) @@ -5440,7 +5440,7 @@ theorem eval_prfIdealGame_prfRandomNonceToPrfDistinguisher_le let adaptProg : ProbOracleComp (fun _ : BitString (msgLen n) => BitString n × BitString n) ((List Bool × List Bool) × List (List Bool × List Bool)) := (OracleComp.interpret - (ProbOracleComp.handler + (OracleComp.sumHandler (fun m => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin m))) (adaptRandomNonceStep msgLen n)) (adversary n [])).run [] @@ -5450,7 +5450,7 @@ theorem eval_prfIdealGame_prfRandomNonceToPrfDistinguisher_le ((ProbComp.eval (seed n)).bind fun k => (PMF.uniformOfFintype (BitString n → BitString n)).bind fun table => ((OracleComp.interpret - (ProbOracleComp.handler (fun m => StateT.lift (ProbComp.unifOracle m)) + (OracleComp.sumHandler (fun m => StateT.lift (ProbComp.unifOracle m)) (randomNonceFnHandler hashBit k table)) adaptProg).run []).bind fun res => PMF.pure diff --git a/Complexity/Crypto/Protocols/MPC/Basic.lean b/Complexity/Crypto/Protocols/MPC/Basic.lean index 6534498450..606a0e0263 100644 --- a/Complexity/Crypto/Protocols/MPC/Basic.lean +++ b/Complexity/Crypto/Protocols/MPC/Basic.lean @@ -117,7 +117,7 @@ noncomputable def MultiOracleWorld.handler {spec : MultiOracleSpec} (W : MultiOracleWorld spec) : (q : ℕ ⊕ (Σ op : spec.Op, (s : Fin (spec.arity op)) → spec.Query op s)) → PMF (probOracleSpec spec.toOracleSpec q) := - ProbOracleComp.handler (spec := spec.toOracleSpec) ProbComp.unifOracle + OracleComp.sumHandler (spec₂ := spec.toOracleSpec) ProbComp.unifOracle (fun q => ProbComp.eval (W q.1 q.2)) /-- The empty multi-party oracle specification (plain point-to-point channel model). -/ @@ -367,7 +367,7 @@ noncomputable def Steps.evalWith {m : ℕ} {spec : MultiOracleSpec} {State Out : (next.evalWith W (fun i => (st i, Round.deliverOracle parties ans i))).map (fun r_tail i => (Round.deliverOracle parties ans i, r_tail i)) := by simp [Steps.evalWith, Steps.run, MultiOracleWorld.handler, ProbOracleComp.query, - ProbOracleComp.handler, bind_pure_comp] + OracleComp.sumHandler, bind_pure_comp] /-- Evaluate `proto.run x` against `W : MultiOracleWorld spec` via `OracleComp.evalWith`. -/ noncomputable def Protocol.evalWith {m : ℕ} {spec : MultiOracleSpec} {sc : Schedule m spec} @@ -485,8 +485,7 @@ theorem Protocol.evalWith_eq {m : ℕ} {spec : MultiOracleSpec} {sc : Schedule m let views : (i : Fin m) → PartyView In Coins sc i := fun i => ⟨x i, r i, recv i⟩ (views, fun i => proto.outputOfView i (views i)) := by simp [Protocol.evalWith, Protocol.run, Steps.evalWith, MultiOracleWorld.handler, - ProbOracleComp.handler_eq_sumHandler, ProbOracleComp.sample_eq_liftLeft, - ProbComp.eval_eq_evalWith, bind_pure_comp] + ProbOracleComp.sample_eq_liftLeft, ProbComp.eval_eq_evalWith, bind_pure_comp] /-- Every supported outcome of `proto.evalWith W x` has outputs equal to `proto.outputOfView` of its views. -/ diff --git a/Complexity/Languages/Probabilistic/Forking.lean b/Complexity/Languages/Probabilistic/Forking.lean index 354b3dfc10..299eafda3d 100644 --- a/Complexity/Languages/Probabilistic/Forking.lean +++ b/Complexity/Languages/Probabilistic/Forking.lean @@ -189,7 +189,7 @@ theorem runWithAnswers_run_interpret_invariant {ι σ β : Type} {spec : ι → private theorem eval_run_withSampleList (default : H) (program : OracleComp (fun _ : Query => H) α) (answers : List H) : ProbComp.eval ((fun (result, next, _) => (result, next)) <$> - (interpret (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (withSampleList default fun v _ s => (pure (v, s) : ProbComp (H × Unit)))) (interpret (fun q => ProbOracleComp.query (spec := fun _ : Query => H) q) program)).run ((), answers)) = @@ -203,7 +203,7 @@ private theorem eval_run_withSampleList (default : H) /-- Answering lifted queries uniformly as they come is answering them uniformly. -/ private theorem eval_run_uniform [Fintype H] [Nonempty H] (program : OracleComp (fun _ : Query => H) α) : - ProbComp.eval ((interpret (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + ProbComp.eval ((interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (fun _ s => do let value ← ProbComp.uniform H (pure (value, s) : ProbComp (H × Unit)))) @@ -268,7 +268,7 @@ list. -/ private theorem eval_run_withSampleList_count (default : H) (program : OracleComp (fun _ : Query => H) α) (count : ℕ) (answers : List H) : ProbComp.eval ((fun (result, next, _) => (result, next)) <$> - (interpret (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (withSampleList default fun v _ n => (pure (v, n + 1) : ProbComp (H × ℕ)))) (interpret (fun q => ProbOracleComp.query (spec := fun _ : Query => H) q) program)).run (count, answers)) = @@ -287,7 +287,7 @@ private theorem eval_run_withSampleList_count (default : H) /-- Answering lifted queries uniformly as they come, counting them, is `countingUniform`. -/ private theorem eval_run_counting [Fintype H] [Nonempty H] (program : OracleComp (fun _ : Query => H) α) (count : ℕ) : - ProbComp.eval ((interpret (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + ProbComp.eval ((interpret (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (fun _ n => do let value ← ProbComp.uniform H (pure (value, n + 1) : ProbComp (H × ℕ)))) diff --git a/Complexity/Languages/Probabilistic/Oracle.lean b/Complexity/Languages/Probabilistic/Oracle.lean index 71e2d34a3b..f0ff953b8c 100644 --- a/Complexity/Languages/Probabilistic/Oracle.lean +++ b/Complexity/Languages/Probabilistic/Oracle.lean @@ -27,11 +27,13 @@ is not automatically a strict PPT operation. requests and the external queries of `spec`. * `Cslib.ProbOracleComp`: the sum of the uniform sampling and external oracle interfaces. * `Cslib.ProbOracleComp.sample`, `.query`: closed sampling and typed external calls. -* `Cslib.ProbOracleComp.handler`: the sum handler of sampling and external queries. The sampling and external interfaces form the sum `unifSpec ⊕ₒ spec` of `Complexity/Languages/Probabilistic/Sum.lean`: `sample` is its left embedding -(`sample_eq_liftLeft`) and `handler` its sum handler (`handler_eq_sumHandler`). +(`sample_eq_liftLeft`), and a handler is the sum handler `OracleComp.sumHandler random oracle`, +which answers private sampling requests with `random` and external queries with `oracle`. In +particular, memoizing `oracle` does not memoize `random`. The rules of `OracleComp.sumHandler` +apply directly. ## Main results @@ -87,46 +89,22 @@ theorem isMonadHom_sample : IsMonadHom ProbComp (ProbOracleComp spec) (sample (s /-- Make one external call, whose reply may determine later sampling or queries. -/ def query (q : Query) : ProbOracleComp spec (spec q) := OracleComp.query (Sum.inr q) -/-- Combine the two handlers. In particular, memoizing `oracle` does not memoize `random`. -This is the sum handler of `unifSpec ⊕ₒ spec` (`handler_eq_sumHandler`), with its own case -equations. -/ -def handler {m : Type → Type v} (random : (n : ℕ) → m (Fin (n + 1))) - (oracle : (q : Query) → m (spec q)) : - (q : ℕ ⊕ Query) → m (probOracleSpec spec q) - | .inl n => random n - | .inr q => oracle q - -/-- The combined handler is the sum handler of the sampling and external interfaces. -/ -theorem handler_eq_sumHandler {m : Type → Type v} (random : (n : ℕ) → m (Fin (n + 1))) - (oracle : (q : Query) → m (spec q)) : - handler random oracle = OracleComp.sumHandler random oracle := by - funext q - cases q <;> rfl - -/-- Interpretation distributes over the sampling and external components of a program handler. -/ -theorem interpret_handler {Query' : Type} {spec' : Query' → Type} - {m : Type → Type v} [Monad m] (target : (q : Query') → m (spec' q)) - (random : (k : ℕ) → OracleComp spec' (Fin (k + 1))) - (oracle : (q : Query) → OracleComp spec' (spec q)) : - (fun q => OracleComp.interpret target (handler random oracle q)) = - handler (fun k => OracleComp.interpret target (random k)) - (fun q => OracleComp.interpret target (oracle q)) := by - simp only [handler_eq_sumHandler, OracleComp.interpret_sumHandler] +open OracleComp (sumHandler) variable {m : Type → Type v} [Monad m] [LawfulMonad m] /-- The combined handler answers a single external query through its external component. -/ @[simp] theorem interpret_query (random : (n : ℕ) → m (Fin (n + 1))) (oracle : (q : Query) → m (spec q)) (q : Query) : - OracleComp.interpret (handler random oracle) (query q) = oracle q := + OracleComp.interpret (sumHandler random oracle) (query q) = oracle q := OracleComp.interpret_query _ _ /-- Embedded closed programs use only the sampling component of the combined handler. -/ @[simp] theorem interpret_sample (random : (n : ℕ) → m (Fin (n + 1))) (oracle : (q : Query) → m (spec q)) (program : ProbComp α) : - OracleComp.interpret (handler random oracle) (sample program) = + OracleComp.interpret (sumHandler random oracle) (sample program) = OracleComp.interpret random program := by - rw [handler_eq_sumHandler, sample_eq_liftLeft, OracleComp.interpret_sumHandler_liftLeft] + rw [sample_eq_liftLeft, OracleComp.interpret_sumHandler_liftLeft] /-- Sampling preserves ordinary functional sequencing before any interpretation. -/ @[simp] theorem sample_bind (program : ProbComp α) (next : α → ProbComp β) : @@ -145,7 +123,7 @@ variable {m : Type → Type v} [Monad m] [LawfulMonad m] theorem run_interpret_sample (oracle : (q : Query) → StateT State PMF (spec q)) (program : ProbComp α) (s : State) : (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (sample program)).run s = + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (sample program)).run s = (ProbComp.eval program).map (·, s) := by rw [interpret_sample] exact OracleComp.run_interpret_lift ProbComp.unifOracle program s @@ -155,7 +133,7 @@ draw as a fresh sample, leaving its own state unchanged. -/ theorem run_interpret_lift_sample {Query' : Type} {spec' : Query' → Type} (oracle : (q : Query) → StateT State (ProbOracleComp spec') (spec q)) (program : ProbComp α) (s : State) : - (OracleComp.interpret (handler (fun n => StateT.lift (sample (ProbComp.unifFin n))) oracle) + (OracleComp.interpret (sumHandler (fun n => StateT.lift (sample (ProbComp.unifFin n))) oracle) (sample program)).run s = (·, s) <$> sample program := by rw [interpret_sample, OracleComp.run_interpret_lift] rfl @@ -166,23 +144,23 @@ theorem sample_run_interpret {Query' : Type} {spec' : Query' → Type} (oracle : (q : Query) → StateT State ProbComp (spec q)) (program : ProbOracleComp spec α) (s : State) : sample (spec := spec') ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifFin n)) oracle) program).run s) = - (OracleComp.interpret (handler (fun n => StateT.lift (sample (ProbComp.unifFin n))) + (sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) oracle) program).run s) = + (OracleComp.interpret (sumHandler (fun n => StateT.lift (sample (ProbComp.unifFin n))) (fun q state => sample (oracle q state))) program).run s := by rw [OracleComp.map_run_interpret (isMonadHom_sample (spec := spec'))] congr 2 funext q state cases q with - | inl n => simp [handler, StateT.lift] + | inl n => simp [StateT.lift] | inr q => rfl /-- Closed handlers have the same probability law when interpreted before or after evaluation. -/ theorem eval_interpret (oracle : (q : Query) → ProbComp (spec q)) (program : ProbOracleComp spec α) : - ProbComp.eval (OracleComp.interpret (handler ProbComp.unifFin oracle) program) = - OracleComp.interpret (handler ProbComp.unifOracle (fun q => ProbComp.eval (oracle q))) + ProbComp.eval (OracleComp.interpret (sumHandler ProbComp.unifFin oracle) program) = + OracleComp.interpret (sumHandler ProbComp.unifOracle (fun q => ProbComp.eval (oracle q))) program := by - simp only [ProbComp.eval, OracleComp.interpret_interpret, interpret_handler, + simp only [ProbComp.eval, OracleComp.interpret_interpret, OracleComp.interpret_sumHandler, ProbComp.unifFin, OracleComp.interpret_query] /-- Evaluating closed stateful handlers commutes with interpreting the whole oracle program. @@ -190,14 +168,14 @@ Private sampling stays independent, and the final state is retained beside the r theorem eval_run_interpret (oracle : (q : Query) → StateT State ProbComp (spec q)) (program : ProbOracleComp spec α) (s : State) : ProbComp.eval ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifFin n)) oracle) program).run s) = - (OracleComp.interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) oracle) program).run s) = + (OracleComp.interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q state => ProbComp.eval (oracle q state))) program).run s := by rw [OracleComp.map_run_interpret ProbComp.isMonadHom_eval] apply congrArg (fun oracle => (OracleComp.interpret (m := StateT State PMF) oracle program).run s) funext q state cases q with - | inl n => simp [handler, StateT.lift, ProbComp.unifOracle, PMF.map, Function.comp_def] + | inl n => simp [StateT.lift, ProbComp.unifOracle, PMF.map, Function.comp_def] | inr q => rfl end ProbOracleComp diff --git a/Complexity/Languages/Probabilistic/Oracle/Interaction.lean b/Complexity/Languages/Probabilistic/Oracle/Interaction.lean index d822a739c0..96c799aff0 100644 --- a/Complexity/Languages/Probabilistic/Oracle/Interaction.lean +++ b/Complexity/Languages/Probabilistic/Oracle/Interaction.lean @@ -21,11 +21,11 @@ and the final oracle state, with fresh fair samples for the private coins, and A prover of an interactive proof is such an oracle; `Cslib.Complexity.Prover.run` is the case of word queries and replies (`Cslib.Complexity.Prover.run_eq_runWith`). -`runWith` is the instance of the generic `OracleComp.runWith` whose handler draws private samples -freshly and answers external calls by `oracle`; that handler is the sum of the lifted uniform -handler and `oracle` (`runWith_eq_runWith_sumHandler`). Against a memoryless oracle it is -`OracleComp.evalWith` of the sum of the uniform handler and the oracle, with the state unchanged -(`runWith_lift`). Its structural rules are those of `OracleComp.runWith`. +`runWith` is the instance of the generic `OracleComp.runWith` whose handler is the sum +`OracleComp.sumHandler` of fresh uniform draws for private samples, which keep the state, and +`oracle` for external calls. Against a memoryless oracle it is `OracleComp.evalWith` of the sum of +the uniform handler and the oracle, with the state unchanged (`runWith_lift`). Its structural +rules are those of `OracleComp.runWith`. ## Main definitions @@ -34,8 +34,8 @@ handler and `oracle` (`runWith_eq_runWith_sumHandler`). Against a memoryless ora ## Main results -* `Cslib.ProbOracleComp.runWith_eq_runWith_sumHandler`, `Cslib.ProbOracleComp.runWith_lift`, - `Cslib.ProbOracleComp.acceptProbWith_lift`: the instances of the generic semantics. +* `Cslib.ProbOracleComp.runWith_lift`, `Cslib.ProbOracleComp.acceptProbWith_lift`: against a + memoryless oracle, the instances of `OracleComp.evalWith`. * `Cslib.ProbOracleComp.runWith_pure`, `Cslib.ProbOracleComp.runWith_bind`, `Cslib.ProbOracleComp.runWith_map`, `Cslib.ProbOracleComp.runWith_query`, `Cslib.ProbOracleComp.runWith_sample`: structural rules for `runWith`. @@ -56,24 +56,16 @@ variable {Query : Type} {spec : Query → Type} {State α β : Type} (oracle : (q : Query) → StateT State PMF (spec q)) /-- The joint law of the result of `program` and the final state of the oracle answering its -external calls, starting from the state `s`. Private samples are fresh. -/ +external calls, starting from the state `s`. Private samples are fresh. This is the generic +stateful run `OracleComp.runWith` of the sum handler. -/ noncomputable def runWith (program : ProbOracleComp spec α) (s : State) : PMF (α × State) := - (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s + OracleComp.runWith + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program s /-- The probability that `program` returns `true` against the oracle from the state `s`. -/ noncomputable def acceptProbWith (program : ProbOracleComp spec Bool) (s : State) : ℝ≥0∞ := (runWith oracle program s).map Prod.fst true -/-- The run is the generic stateful run whose handler answers private samples by fresh uniform -draws, keeping the state, and external calls by `oracle`. -/ -theorem runWith_eq_runWith_sumHandler (program : ProbOracleComp spec α) (s : State) : - runWith oracle program s = - OracleComp.runWith (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) - oracle) program s := by - rw [runWith, handler_eq_sumHandler] - rfl - /-- Against a memoryless oracle, the run is `OracleComp.evalWith` of the uniform handler on the sampling side and the oracle on the other, with the state unchanged. -/ theorem runWith_lift (h : (q : Query) → PMF (spec q)) (program : ProbOracleComp spec α) @@ -85,7 +77,7 @@ theorem runWith_lift (h : (q : Query) → PMF (spec q)) (program : ProbOracleCom fun q => StateT.lift (OracleComp.sumHandler ProbComp.unifOracle h q) := by funext q cases q <;> rfl - rw [runWith_eq_runWith_sumHandler, hlift, OracleComp.runWith_lift] + rw [runWith, hlift, OracleComp.runWith_lift] /-- Against a memoryless oracle, the acceptance probability is the probability of `true` under `OracleComp.evalWith` of the uniform handler and the oracle. -/ diff --git a/Complexity/Languages/Probabilistic/Oracle/QueryCount.lean b/Complexity/Languages/Probabilistic/Oracle/QueryCount.lean index 7e1e719ba1..67abf975bf 100644 --- a/Complexity/Languages/Probabilistic/Oracle/QueryCount.lean +++ b/Complexity/Languages/Probabilistic/Oracle/QueryCount.lean @@ -139,7 +139,7 @@ theorem transcript_cost_le {cost : Query → ℕ} {program : ProbOracleComp spec (oracle : (q : Query) → StateT State PMF (spec q)) {s s' : State} {result : α} {transcript : Transcript spec} (hmem : (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).support) : (transcript.map fun entry => cost entry.1).sum ≤ n := by induction h generalizing s s' result transcript with @@ -154,14 +154,14 @@ theorem transcript_cost_le {cost : Query → ℕ} {program : ProbOracleComp spec obtain ⟨⟨a, middle, seen⟩, hfirst, hrest⟩ := hmem cases q with | inl k => - simp only [handler, StateT.run_lift, Probability.PMF.monad_bind_eq_bind, + simp only [sumHandler, StateT.run_lift, Probability.PMF.monad_bind_eq_bind, Probability.PMF.monad_pure_eq_pure, PMF.mem_support_bind_iff, PMF.mem_support_pure_iff] at hfirst obtain ⟨_, -, heq⟩ := hfirst cases heq simpa using ih a hrest | inr q => - simp only [handler, StateT.run, withTranscript, PMF.mem_support_map_iff] at hfirst + simp only [sumHandler, StateT.run, withTranscript, PMF.mem_support_map_iff] at hfirst obtain ⟨⟨answer, next⟩, -, heq⟩ := hfirst cases heq rw [run_interpret_withTranscript_append, PMF.mem_support_map_iff] at hrest @@ -180,7 +180,7 @@ theorem isCostBounded_of_transcript_cost_le [hne : ∀ q, Nonempty (spec q)] {co (h : ∀ (State : Type) (oracle : (q : Query) → StateT State PMF (spec q)) (s s' : State) (result : α) (transcript : Transcript spec), (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).support → (transcript.map fun entry => cost entry.1).sum ≤ n) : IsCostBounded (Sum.elim (fun _ => 0) cost) program n := by @@ -190,11 +190,11 @@ theorem isCostBounded_of_transcript_cost_le [hne : ∀ q, Nonempty (spec q)] {co | liftBind q cont ih => have hrun (State : Type) (oracle : (q : Query) → StateT State PMF (spec q)) (s : State) : ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) (PFunctor.FreeM.liftBind q cont)).run (s, [])) = - ((handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle) q).run + ((sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle) q).run (s, [])).bind fun first => (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) (cont first.1)).run first.2 := rfl cases q with | inl k => @@ -204,14 +204,14 @@ theorem isCostBounded_of_transcript_cost_le [hne : ∀ q, Nonempty (spec q)] {co transcript ?_ rw [hrun, PMF.mem_support_bind_iff] refine ⟨(a, s, []), ?_, hmem⟩ - simp [handler, ProbComp.unifOracle] + simp [sumHandler, ProbComp.unifOracle] | inr q => -- Every supported run of a continuation, with the first call answered as chosen, is part -- of a supported run of the whole program. have key (a : spec q) (State : Type) (oracle : (q : Query) → StateT State PMF (spec q)) (s s' : State) (result : α) (transcript : Transcript spec) (hmem : (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) (cont a)).run (s, [])).support) : (transcript.map fun entry => cost entry.1).sum + cost q ≤ n := by let first (q' : Query) : spec q' := @@ -237,7 +237,7 @@ theorem isCostBounded_of_transcript_cost_le [hne : ∀ q, Nonempty (spec q)] {co let default (q' : Query) : StateT Unit PMF (spec q') := fun _ => PMF.pure (Classical.choice (hne q'), ()) obtain ⟨⟨result, s', transcript⟩, hmem⟩ := PMF.support_nonempty ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript default)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript default)) (cont (Classical.choice (hne q)))).run ((), [])) have hle : cost q ≤ n := by have := key _ Unit _ () s' result transcript hmem @@ -256,7 +256,7 @@ theorem isCostBounded_iff_transcript_cost_le [∀ q, Nonempty (spec q)] {cost : ∀ (State : Type) (oracle : (q : Query) → StateT State PMF (spec q)) (s s' : State) (result : α) (transcript : Transcript spec), (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).support → (transcript.map fun entry => cost entry.1).sum ≤ n := ⟨fun h _ oracle _ _ _ _ hmem => transcript_cost_le h oracle hmem, @@ -268,7 +268,7 @@ theorem IsQueryBounded.length_transcript_le {program : ProbOracleComp spec α} { (oracle : (q : Query) → StateT State PMF (spec q)) {s s' : State} {result : α} {transcript : Transcript spec} (hmem : (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).support) : transcript.length ≤ n := by simpa using transcript_cost_le h oracle hmem @@ -280,7 +280,7 @@ theorem QueriesSatisfy.forall_mem_transcript {p : Query → Prop} (oracle : (q : Query) → StateT State PMF (spec q)) {s s' : State} {result : α} {transcript : Transcript spec} (hmem : (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).support) : ∀ entry ∈ transcript, p entry.1 := by classical @@ -301,7 +301,7 @@ theorem isQueryBounded_of_length_transcript_le [∀ q, Nonempty (spec q)] (h : ∀ (State : Type) (oracle : (q : Query) → StateT State PMF (spec q)) (s s' : State) (result : α) (transcript : Transcript spec), (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).support → transcript.length ≤ n) : program.IsQueryBounded n := @@ -315,7 +315,7 @@ theorem queriesSatisfy_of_forall_mem_transcript [∀ q, Nonempty (spec q)] {p : (h : ∀ (State : Type) (oracle : (q : Query) → StateT State PMF (spec q)) (s s' : State) (result : α) (transcript : Transcript spec), (result, s', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).support → ∀ entry ∈ transcript, p entry.1) : program.QueriesSatisfy p := by diff --git a/Complexity/Languages/Probabilistic/Oracle/Simulation.lean b/Complexity/Languages/Probabilistic/Oracle/Simulation.lean index 9f06db8086..eb30f2a1d1 100644 --- a/Complexity/Languages/Probabilistic/Oracle/Simulation.lean +++ b/Complexity/Languages/Probabilistic/Oracle/Simulation.lean @@ -40,6 +40,7 @@ Adapts the cslib `crypto` branch's state simulation API at namespace Cslib.ProbOracleComp open Probability +open OracleComp (sumHandler) variable {Query α State State' : Type} {spec : Query → Type} @@ -47,18 +48,19 @@ variable {Query α State State' : Type} {spec : Query → Type} theorem run_interpret_readOnly (oracle : (q : Query) → State → PMF (spec q)) (program : ProbOracleComp spec α) (s : State) : (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q state => (oracle q state).map (·, state))) program).run s = (OracleComp.interpret - (handler ProbComp.unifOracle (fun q => oracle q s)) program).map (·, s) := by - have hhandler : handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (sumHandler ProbComp.unifOracle (fun q => oracle q s)) program).map (·, s) := by + have hhandler : sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q state => (oracle q state).map (·, state)) = - fun q state => (handler ProbComp.unifOracle (fun q => oracle q state) q).map (·, state) := by + fun q state => + (sumHandler ProbComp.unifOracle (fun q => oracle q state) q).map (·, state) := by funext q state cases q <;> rfl rw [hhandler] exact OracleComp.run_interpret_readOnly - (fun q state => handler ProbComp.unifOracle (fun q => oracle q state) q) program s + (fun q state => sumHandler ProbComp.unifOracle (fun q => oracle q state) q) program s /-- An external oracle's invariant is unaffected by the client's private sampling. -/ theorem run_interpret_invariant (oracle : (q : Query) → StateT State PMF (spec q)) @@ -66,7 +68,7 @@ theorem run_interpret_invariant (oracle : (q : Query) → StateT State PMF (spec (step : ∀ q s, invariant s → ∀ a s', (a, s') ∈ (oracle q s).support → invariant s') (program : ProbOracleComp spec α) (s : State) (hs : invariant s) (result : α) (s' : State) (h : (result, s') ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support) : + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support) : invariant s' := by apply OracleComp.run_interpret_invariant _ invariant ?_ program s hs result s' h intro q state hstate value next hnext @@ -83,10 +85,11 @@ theorem run_interpret_simulation (oracle : (q : Query) → StateT State PMF (spe (step : ∀ q s, (oracle q s).bind (fun (a, s') => (relate s').map (a, ·)) = (relate s).bind (oracle' q)) (program : ProbOracleComp spec α) (s : State) : ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).bind + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).bind (fun (a, s') => (relate s').map (a, ·)) = (relate s).bind (fun state => (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run state) := by + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run + state) := by apply OracleComp.run_interpret_simulation intro q state cases q with @@ -108,10 +111,10 @@ theorem run_interpret_map_state_of_invariant (oracle q s).map (fun (a, s') => (a, represent s')) = oracle' q (represent s)) (program : ProbOracleComp spec α) (s : State) (hs : invariant s) : ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).map + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).map (fun (a, s') => (a, represent s')) = (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run (represent s) := by apply OracleComp.run_interpret_map_state_of_invariant _ _ represent invariant ?_ ?_ program s hs · intro q state hstate value next hnext @@ -136,10 +139,10 @@ theorem run_interpret_map_state (oracle : (q : Query) → StateT State PMF (spec (step : ∀ q s, (oracle q s).map (fun (a, s') => (a, represent s')) = oracle' q (represent s)) (program : ProbOracleComp spec α) (s : State) : ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).map + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).map (fun (a, s') => (a, represent s')) = (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run (represent s) := by exact run_interpret_map_state_of_invariant oracle oracle' represent (fun _ => True) (by simp) (fun q state _ => step q state) program s trivial @@ -153,21 +156,21 @@ theorem run_interpret_map_response_state {spec' : Query → Type} (step : ∀ q s, (oracle q s).map (fun (a, s') => (response q a, represent s')) = oracle' q (represent s)) (program : ProbOracleComp spec' α) (s : State) : ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) - (OracleComp.interpret (handler (fun n => sample (ProbComp.unifFin n)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.interpret (sumHandler (fun n => sample (ProbComp.unifFin n)) (fun q => response q <$> query q)) program)).run s).map (fun (a, s') => (a, represent s')) = (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle') program).run (represent s) := by let response' : (q : ℕ ⊕ Query) → probOracleSpec spec q → probOracleSpec spec' q | .inl _ => id | .inr q => response q have hadapter : (fun q => response' q <$> OracleComp.query q) = - handler (fun n => sample (ProbComp.unifFin n)) (fun q => response q <$> query q) := by + sumHandler (fun n => sample (ProbComp.unifFin n)) (fun q => response q <$> query q) := by funext q cases q with - | inl n => simp [response', handler, sample, ProbComp.unifFin] + | inl n => simp [response', sumHandler, sample, ProbComp.unifFin] | inr q => rfl rw [← hadapter] apply OracleComp.run_interpret_map_response_state @@ -187,12 +190,12 @@ theorem run_interpret_run_interpret {Query' : Type} {spec' : Query' → Type} (inner : (q : Query) → StateT Hidden (ProbOracleComp spec') (spec q)) (oracle : (q : Query') → StateT External PMF (spec' q)) (program : ProbOracleComp spec α) (hidden : Hidden) (external : External) : - (OracleComp.interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) - ((OracleComp.interpret (handler (fun n => StateT.lift (sample (ProbComp.unifFin n))) inner) + (OracleComp.interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + ((OracleComp.interpret (sumHandler (fun n => StateT.lift (sample (ProbComp.unifFin n))) inner) program).run hidden)).run external = - ((OracleComp.interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) + ((OracleComp.interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun q state => ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((inner q).run state.1)).run state.2).map (fun ⟨⟨a, b⟩, c⟩ => (a, b, c)))) program).run (hidden, external)).map @@ -207,7 +210,7 @@ theorem run_interpret_run_interpret {Query' : Type} {spec' : Query' → Type} simp only [StateT.run_lift, OracleComp.interpret_bind, OracleComp.interpret_pure, StateT.run_bind, StateT.run_pure, interpret_sample, ProbComp.unifFin, OracleComp.interpret_query] - simp [handler, StateT.lift, PMF.map, Function.comp_def] + simp [sumHandler, StateT.lift, PMF.map, Function.comp_def] | inr q => rfl end Cslib.ProbOracleComp diff --git a/Complexity/Languages/Probabilistic/Oracle/Support.lean b/Complexity/Languages/Probabilistic/Oracle/Support.lean index 862f6af57e..f8c0ad7421 100644 --- a/Complexity/Languages/Probabilistic/Oracle/Support.lean +++ b/Complexity/Languages/Probabilistic/Oracle/Support.lean @@ -51,16 +51,6 @@ open OracleComp variable {Query α β : Type} {spec : Query → Type} -/-- A returned value is the only possible result. -/ -theorem eq_of_mem_support_pure {a result : α} - (h : result ∈ support (pure a : ProbOracleComp spec α)) : result = a := - eq_of_mem_supportWith_pure h - -/-- A possible mapped result is the image of a possible result. -/ -theorem mem_support_map {program : ProbOracleComp spec α} {f : α → β} {result : β} - (h : result ∈ support (f <$> program)) : ∃ a ∈ support program, f a = result := - mem_supportWith_map_iff.mp h - /-- An external query may return any of its possible replies. -/ @[simp] theorem supportWith_query (possible : (q : ℕ ⊕ Query) → Set (probOracleSpec spec q)) (q : Query) : supportWith possible (query (spec := spec) q) = possible (.inr q) := @@ -75,7 +65,7 @@ theorem mem_support_map {program : ProbOracleComp spec α} {f : α → β} {resu theorem mem_support_of_mem {program : ProbOracleComp spec α} {State : Type} (oracle : (q : Query) → StateT State PMF (spec q)) {s s' : State} {result : α} (h : (result, s') ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support) : + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support) : result ∈ support program := mem_supportWith_of_mem_support_runWith _ (fun _ _ _ _ _ => Set.mem_univ _) h @@ -86,7 +76,7 @@ theorem mem_support_iff_exists [hne : ∀ q, Nonempty (spec q)] {program : ProbO result ∈ support program ↔ ∃ (State : Type) (oracle : (q : Query) → StateT State PMF (spec q)) (s s' : State), (result, s') ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s).support := by classical refine ⟨fun h => ?_, fun ⟨State, oracle, s, s', h⟩ => mem_support_of_mem oracle h⟩ @@ -99,18 +89,18 @@ theorem mem_support_iff_exists [hne : ∀ q, Nonempty (spec q)] {program : ProbO obtain ⟨a, -, ha⟩ := Set.mem_iUnion₂.mp h obtain ⟨State, oracle, s, s', hrun⟩ := ih a ha have hrun' {S : Type} (oracle : (q : Query) → StateT S PMF (spec q)) (state : S) : - (OracleComp.interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (PFunctor.FreeM.liftBind q cont)).run state = - ((handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle q).run state).bind + ((sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle q).run state).bind fun first => (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (cont first.1)).run + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) (cont first.1)).run first.2 := rfl cases q with | inl n => refine ⟨State, oracle, s, s', ?_⟩ rw [hrun', PMF.mem_support_bind_iff] refine ⟨(a, s), ?_, hrun⟩ - simp [handler, ProbComp.unifOracle] + simp [sumHandler, ProbComp.unifOracle] | inr q => let first (q' : Query) : spec q' := if hq : q' = q then hq ▸ a else Classical.choice (hne q') diff --git a/Complexity/Languages/Probabilistic/Oracle/Transcript.lean b/Complexity/Languages/Probabilistic/Oracle/Transcript.lean index 3880fdbb77..f3e808eb9c 100644 --- a/Complexity/Languages/Probabilistic/Oracle/Transcript.lean +++ b/Complexity/Languages/Probabilistic/Oracle/Transcript.lean @@ -16,7 +16,7 @@ import Complexity.Languages.Probabilistic.Oracle.Simulation # Transcripts of randomized programs The typed transcript of a program with private coins records only its external requests: private -samples use the other component of `ProbOracleComp.handler` and do not enter the log. Forgetting +samples use the other component of `OracleComp.sumHandler` and do not enter the log. Forgetting the log recovers the original execution, and an existing log is an untouched suffix of the new one. ## Main results @@ -41,9 +41,9 @@ variable {Query α State : Type} {Response : Query → Type} /-- Forgetting the external log preserves the joint result and complete oracle state. -/ theorem run_interpret_withTranscript (oracle : (q : Query) → StateT State PMF (Response q)) (program : ProbOracleComp Response α) (s : State) (transcript : Transcript Response) : - ((interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + ((interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, transcript)).map (fun (result, state) => (result, state.1)) = - (interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s := by apply ProbOracleComp.run_interpret_map_state (withTranscript oracle) oracle Prod.fst intro q state @@ -55,10 +55,10 @@ change either part of the log. -/ theorem run_interpret_withTranscript_append (oracle : (q : Query) → StateT State PMF (Response q)) (program : ProbOracleComp Response α) (s : State) (transcript : Transcript Response) : - (interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, transcript) = ((interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (withTranscript oracle)) program).run (s, [])).map (fun (result, state, fresh) => (result, state, fresh ++ transcript)) := by symm diff --git a/Complexity/Languages/Probabilistic/Presample.lean b/Complexity/Languages/Probabilistic/Presample.lean index 4dbde95e12..7a9e1c212f 100644 --- a/Complexity/Languages/Probabilistic/Presample.lean +++ b/Complexity/Languages/Probabilistic/Presample.lean @@ -75,10 +75,10 @@ theorem IsQueryBounded.run_interpret_presample {program : ProbOracleComp spec α (h : program.IsQueryBounded n) (source : PMF Value) (fallback : Value) (oracle : Value → (q : Query) → StateT State PMF (spec q)) (s : State) : ((PMF.iid source n).map List.ofFn).bind (fun values => - ((interpret (handler (fun k => StateT.lift (ProbComp.unifOracle k)) + ((interpret (sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (withSampleList fallback oracle)) program).run (s, values)).map fun (result, next, _) => (result, next)) = - (interpret (handler (fun k => StateT.lift (ProbComp.unifOracle k)) + (interpret (sumHandler (fun k => StateT.lift (ProbComp.unifOracle k)) (fun q state => source.bind fun value => oracle value q state)) program).run s := by induction h generalizing s with | pure a n => @@ -86,13 +86,13 @@ theorem IsQueryBounded.run_interpret_presample {program : ProbOracleComp spec α | liftBind q cont n _ ih => cases q with | inl k => - simp only [Sum.elim_inl, Nat.add_zero, run_interpret_bind, run_interpret_query, handler, + simp only [Sum.elim_inl, Nat.add_zero, run_interpret_bind, run_interpret_query, sumHandler, StateT.lift, PMF.monad_bind_eq_bind, PMF.monad_pure_eq_pure, PMF.bind_bind, PMF.pure_bind, PMF.map_bind] rw [PMF.bind_comm] exact congrArg ((ProbComp.unifOracle k).bind ·) (funext fun a => ih a s) | inr q => - simp only [Sum.elim_inr, run_interpret_bind, run_interpret_query, handler, PMF.iid, + simp only [Sum.elim_inr, run_interpret_bind, run_interpret_query, sumHandler, PMF.iid, withSampleList, PMF.monad_bind_eq_bind, PMF.monad_map_eq_map, PMF.map_bind, PMF.bind_bind, PMF.bind_map, PMF.map_comp, Function.comp_def, List.ofFn_succ, Fin.cons_zero, Fin.cons_succ, List.headD_cons, List.tail_cons] @@ -111,9 +111,9 @@ theorem IsQueryBounded.eval_presample {program : ProbOracleComp spec α} {count ProbComp.eval (do let values ← replicate count source (fun (result, next, _) => (result, next)) <$> (interpret - (handler (fun n => StateT.lift (ProbComp.unifFin n)) + (sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (withSampleList fallback oracle)) program).run (s, values)) = - ProbComp.eval ((interpret (handler (fun n => StateT.lift (ProbComp.unifFin n)) + ProbComp.eval ((interpret (sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (fun q s => do let value ← source oracle value q s)) program).run s) := by diff --git a/Complexity/Languages/Probabilistic/RandomOracle/Probabilistic.lean b/Complexity/Languages/Probabilistic/RandomOracle/Probabilistic.lean index 81b52d85df..90d88c7ea3 100644 --- a/Complexity/Languages/Probabilistic/RandomOracle/Probabilistic.lean +++ b/Complexity/Languages/Probabilistic/RandomOracle/Probabilistic.lean @@ -43,6 +43,7 @@ to the disjoint-sum interface of `ProbOracleComp`, reusing the general state sim namespace Cslib.RandomOracle open Probability ProbOracleComp +open OracleComp (sumHandler) section List @@ -54,7 +55,7 @@ private theorem run_interpret_memoize_transcript_prob (distribution : Query → (program : ProbOracleComp (fun _ : Query => Value) α) (cache cache' : List (Query × Value)) (result : α) (transcript : OracleComp.Transcript (fun _ : Query => Value)) (h : (result, cache', transcript) ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (OracleComp.withTranscript (memoize distribution))) program).run (cache, [])).support) : cache'.length ≤ cache.length + transcript.length ∧ ∀ entry ∈ cache', entry ∈ cache ∨ @@ -78,7 +79,7 @@ theorem memoize_cache_bounds_prob (distribution : Query → PMF Value) (hcalls : program.IsQueryBounded calls) (hsize : program.QueriesSatisfy (size · ≤ maxSize)) (cache cache' : List (Query × Value)) (result : α) (h : (result, cache') ∈ ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize distribution)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize distribution)) program).run cache).support) : cache'.length ≤ cache.length + calls ∧ ∀ entry ∈ cache', entry ∈ cache ∨ @@ -102,10 +103,10 @@ theorem run_interpret_memoize_prob [LawfulBEq Query] [DecidableEq Query] (distribution : Query → PMF Value) (program : ProbOracleComp (fun _ : Query => Value) α) (cache : List (Query × Value)) : ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize distribution)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize distribution)) program).run cache).map (fun (result, cache') => (result, ofList cache')) = (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer distribution)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer distribution)) program).run (ofList cache) := by apply ProbOracleComp.run_interpret_map_state intro q current @@ -118,10 +119,10 @@ theorem eval_run_interpret_memoize_prob [LawfulBEq Query] [DecidableEq Query] (compute : Query → ProbComp Value) (program : ProbOracleComp (fun _ : Query => Value) α) (cache : List (Query × Value)) : (ProbComp.eval ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifFin n)) (memoize compute)) program).run + (sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (memoize compute)) program).run cache)).map (fun (result, cache') => (result, ofList cache')) = (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer (fun q => ProbComp.eval (compute q)))) program).run (ofList cache) := by rw [ProbOracleComp.eval_run_interpret] simpa only [ProbComp.eval_memoize] using @@ -139,13 +140,14 @@ theorem run_interpret_answer_complete_prob [DecidableEq Query] (program : ProbOracleComp Response α) (cache : Cache Response) : (do let (result, cache') ← (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer distribution)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer distribution)) program).run cache (complete distribution cache').map (result, ·)) = (do let table ← complete distribution cache (OracleComp.interpret - (handler ProbComp.unifOracle (fun q => PMF.pure (table q))) program).map (·, table)) := by + (sumHandler ProbComp.unifOracle (fun q => PMF.pure (table q))) program).map + (·, table)) := by simp only [PMF.monad_bind_eq_bind] have h := ProbOracleComp.run_interpret_simulation (answer distribution) (fun q table => (PMF.pure (table q)).map (·, table)) (complete distribution) @@ -163,9 +165,9 @@ theorem interpret_prob_eq_lazy [DecidableEq Query] (do let table ← PMF.pi distribution OracleComp.interpret - (handler ProbComp.unifOracle (fun q => PMF.pure (table q))) program) = + (sumHandler ProbComp.unifOracle (fun q => PMF.pure (table q))) program) = ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer distribution)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer distribution)) program).run (fun _ => none)).map Prod.fst := pi_bind_eq_map_fst_of_complete_eq distribution (run_interpret_answer_complete_prob distribution program (fun _ => none)) @@ -177,9 +179,9 @@ theorem uniform_interpret_prob_eq_lazy [DecidableEq Query] [∀ q, Fintype (Resp (do let table ← PMF.uniformOfFintype ((q : Query) → Response q) OracleComp.interpret - (handler ProbComp.unifOracle (fun q => PMF.pure (table q))) program) = + (sumHandler ProbComp.unifOracle (fun q => PMF.pure (table q))) program) = ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (answer (fun q => PMF.uniformOfFintype (Response q)))) program).run (fun _ => none)).map Prod.fst := by simpa only [PMF.pi_uniformOfFintype] using @@ -190,9 +192,9 @@ theorem interpret_prob_eq_memoize {Value : Type} [Finite Value] [BEq Query] [Law (distribution : Query → PMF Value) (program : ProbOracleComp (fun _ : Query => Value) α) : (do let table ← PMF.pi distribution - OracleComp.interpret (handler ProbComp.unifOracle (fun q => PMF.pure (table q))) program) = + OracleComp.interpret (sumHandler ProbComp.unifOracle (fun q => PMF.pure (table q))) program) = ((OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize distribution)) + (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize distribution)) program).run []).map Prod.fst := by classical rw [interpret_prob_eq_lazy] @@ -210,8 +212,8 @@ theorem interpret_prob_eq_memoize_map {Value Key' Value' : Type} [Finite Value] (do let table ← PMF.pi distribution OracleComp.interpret - (handler ProbComp.unifOracle (fun key => PMF.pure (valueMap (table key)))) program) = - ((OracleComp.interpret (handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (sumHandler ProbComp.unifOracle (fun key => PMF.pure (valueMap (table key)))) program) = + ((OracleComp.interpret (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (fun key => memoize sample' (keyMap key))) program).run []).map Prod.fst := by let represent := fun cache : List (Query × Value) => cache.map (fun entry => (keyMap entry.1, valueMap entry.2)) @@ -223,10 +225,10 @@ theorem interpret_prob_eq_memoize_map {Value Key' Value' : Type} [Finite Value] have houtput := congrArg (PMF.map Prod.fst) hrun simp only [PMF.map_comp, Function.comp_def, represent, List.map_nil] at houtput rw [← houtput] - simpa only [OracleComp.interpret_interpret, interpret_handler, interpret_sample, + simpa only [OracleComp.interpret_interpret, OracleComp.interpret_sumHandler, interpret_sample, ProbComp.unifFin, OracleComp.interpret_query, OracleComp.interpret_map, interpret_query, PMF.monad_map_eq_map, PMF.pure_map] using interpret_prob_eq_memoize distribution - (OracleComp.interpret (handler (fun n => sample (ProbComp.unifFin n)) + (OracleComp.interpret (sumHandler (fun n => sample (ProbComp.unifFin n)) (fun key => valueMap <$> ProbOracleComp.query key)) program) /-- Executable closed samplers with a list cache implement the eager independent-table experiment, @@ -235,10 +237,10 @@ theorem eval_run_interpret_memoize_prob_eq_eager {Key Value Result : Type} [Fintype Key] [Finite Value] [BEq Key] [LawfulBEq Key] (compute : Key → ProbComp Value) (program : ProbOracleComp (fun _ : Key => Value) Result) : ProbComp.eval (Prod.fst <$> (OracleComp.interpret - (handler (fun n => StateT.lift (ProbComp.unifFin n)) (memoize compute)) program).run []) = + (sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (memoize compute)) program).run []) = (do let table ← PMF.pi (fun q => ProbComp.eval (compute q)) - OracleComp.interpret (handler ProbComp.unifOracle (fun q => PMF.pure (table q))) + OracleComp.interpret (sumHandler ProbComp.unifOracle (fun q => PMF.pure (table q))) program) := by rw [interpret_prob_eq_memoize] simp only [ProbComp.eval_map, ProbOracleComp.eval_run_interpret, ProbComp.eval_memoize] diff --git a/ComplexityTests/OneWayMetacomplexity.lean b/ComplexityTests/OneWayMetacomplexity.lean index 16baa20a1d..b9e381f687 100644 --- a/ComplexityTests/OneWayMetacomplexity.lean +++ b/ComplexityTests/OneWayMetacomplexity.lean @@ -72,7 +72,7 @@ example : {b : Bool | b = true} ∈ BPP encBool := -- Against a deterministic oracle, `queryTable` collects the first reply bits, `false` for an -- empty reply. -example : OracleComp.interpret (ProbOracleComp.handler ProbComp.unifFin +example : OracleComp.interpret (OracleComp.sumHandler ProbComp.unifFin fun request => pure (List.reverse request.2)) (KabanetsCai.queryTable [[true, false], [], [false, true]]) = pure [false, false, true] := by rw [KabanetsCai.interpret_queryTable] diff --git a/ComplexityTests/OracleComposition.lean b/ComplexityTests/OracleComposition.lean index ffd690b5fb..c8cc77a6d1 100644 --- a/ComplexityTests/OracleComposition.lean +++ b/ComplexityTests/OracleComposition.lean @@ -46,7 +46,7 @@ private theorem run_counting (reply : ℕ → List Bool) (request : Bool × List -- The unselected branch makes no call: the counter records exactly one external request. example (word : List Bool) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (counting fun _ => [false, true])) (adaptive word)).run 0 = PMF.pure ([], 1) := by simp [adaptive, run_counting] @@ -54,7 +54,7 @@ example (word : List Bool) : -- reply is truncated to the input length. example : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (counting fun calls => List.replicate (calls + 5) true)) (adaptive [false, false, false])).run 0 = PMF.pure ([true, true, true], 2) := by simp [adaptive, run_counting] diff --git a/ComplexityTests/OracleComposition/Substitution.lean b/ComplexityTests/OracleComposition/Substitution.lean index 0fb25a6a36..6d55e8f441 100644 --- a/ComplexityTests/OracleComposition/Substitution.lean +++ b/ComplexityTests/OracleComposition/Substitution.lean @@ -54,7 +54,7 @@ private theorem cached_isOraclePPTOn : IsOraclePPTOn private noncomputable def twoLevel (n : ℕ) : WordOracleComp Unit (List Bool × List (List Bool × List Bool)) := (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (cached n)) (client n)).run [] -- The two-level client is strict oracle PPT, returning its result and the final cache. The local @@ -87,7 +87,7 @@ private theorem run_firstOnes (request : Unit × List Bool) (calls : ℕ) : -- third result is the cached first reply rather than a fresh one. example : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) firstOnes) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) firstOnes) (twoLevel 3)).run 0 = PMF.pure (([false, false, false, true, true, true], [([true, true, true], [false, false, false]), ([], [true, true, true])]), 2) := by @@ -120,7 +120,7 @@ private theorem run_copyReply (n : ℕ) (request : Unit × List Bool) (state : L -- though the client keeps one bit; such a handler has no strict oracle PPT certificate. example : ¬ IsOraclePPTOn encUnary (encPair encBits encBits) (fun n => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (copyReply n)) (requestHead n)).run []) := by intro h obtain ⟨c, d, hbound⟩ := h.length_le @@ -165,13 +165,13 @@ example : IsOraclePPTOn encUnary encBits repeatHead := by -- additive allowance bounds its state growth. example : ¬ IsOraclePPTOn encUnary (encPair encBits encBits) (fun n => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (double n)) (repeatHead n)).run [true]) := by intro h obtain ⟨c, d, hbound⟩ := h.length_le obtain ⟨n, hn⟩ := not_two_pow_le c d have hiterate (m : ℕ) (word : List Bool) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) + (OracleComp.sumHandler (fun n => StateT.lift (ProbOracleComp.sample (ProbComp.unifFin n))) (double n)) (OracleComp.iterate m (fun _ => List.take 1 <$> ProbOracleComp.query ((), [])) word)).run [true] = pure (if m = 0 then word else [], List.replicate (2 ^ m) true) := by diff --git a/ComplexityTests/OracleCompositionPlain.lean b/ComplexityTests/OracleCompositionPlain.lean index 2d280940ea..98f390102f 100644 --- a/ComplexityTests/OracleCompositionPlain.lean +++ b/ComplexityTests/OracleCompositionPlain.lean @@ -36,12 +36,12 @@ private theorem run_constant (k : ℕ) (request : Unit × List Bool) (calls : -- The zero branch makes no call; a nonzero input truncates a longer reply and makes one call. example : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) (constant 5)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (constant 5)) (askUnlessZero 0)).run 0 = PMF.pure ([], 0) := by simp [askUnlessZero] example : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) (constant 5)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (constant 5)) (askUnlessZero 2)).run 0 = PMF.pure ([true, true], 1) := by simp [askUnlessZero, run_constant] diff --git a/ComplexityTests/OraclePPT.lean b/ComplexityTests/OraclePPT.lean index 04cdc720e8..87a8e8cde0 100644 --- a/ComplexityTests/OraclePPT.lean +++ b/ComplexityTests/OraclePPT.lean @@ -40,7 +40,7 @@ example (State : Type) (oracle : Bool → StateT State PMF Bool) (s s' : State) (result : Bool × Bool × Bool) (transcript : OracleComp.Transcript (fun _ : Bool => Bool)) (h : (result, s', transcript) ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (OracleComp.withTranscript oracle)) randomized).run (s, [])).support) : (transcript.map fun _ => 1).sum ≤ 2 := ProbOracleComp.isCostBounded_iff_transcript_cost_le.mp randomized_queryBounds @@ -84,7 +84,7 @@ private noncomputable def flipOracle (_ : Bool) : StateT Bool PMF Bool := -- in reverse chronological order, and both state transitions are retained jointly. private theorem run_duplicatedRequests : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (OracleComp.withTranscript flipOracle)) duplicatedRequests).run (false, []) = PMF.pure ((false, true), false, ([⟨false, true⟩, ⟨false, false⟩] : OracleComp.Transcript (fun _ : Bool => Bool))) := by @@ -105,20 +105,20 @@ example : ¬duplicatedRequests.IsQueryBounded 1 := by -- experiments on `randomized`. example : ProbComp.eval (Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (memoize (fun _ : Bool => ProbComp.uniform Bool))) randomized).run []) = ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (Cslib.RandomOracle.answer (fun _ => PMF.uniformOfFintype Bool))) randomized).run (fun _ => none)).map Prod.fst := by have heager : ProbComp.eval (Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (memoize (fun _ : Bool => ProbComp.uniform Bool))) randomized).run []) = (do let table ← PMF.pi (fun _ : Bool => PMF.uniformOfFintype Bool) OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle (fun q => PMF.pure (table q))) + (OracleComp.sumHandler ProbComp.unifOracle (fun q => PMF.pure (table q))) randomized) := by simpa only [ProbComp.eval_uniform] using Cslib.RandomOracle.eval_run_interpret_memoize_prob_eq_eager @@ -129,7 +129,7 @@ example : -- only with respect to this storage bound, not the separate machine time certificate. example (result : Bool × Bool × Bool) (cache : List (Bool × Bool)) (h : (result, cache) ∈ ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (memoize (fun _ : Bool => PMF.uniformOfFintype Bool))) randomized).run []).support) : (encList (encPair encBool encBool) cache).length ≤ 18 := by exact memoize_cache_size_le encBool encBool _ randomized 2 1 1 randomized_queryBounds @@ -146,7 +146,7 @@ example : (true, [(false, true), (false, false)]) ∈ -- Two equal sampling requests draw independently, even in the presence of an external oracle. example (State : Type) (oracle : Bool → StateT State PMF Bool) (s : State) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) ((do let first ← ProbOracleComp.sample (ProbComp.uniform Bool) let second ← ProbOracleComp.sample (ProbComp.uniform Bool) @@ -196,7 +196,7 @@ private noncomputable def respond (caller : List Bool) (_ : Unit × List Bool) -- Reply size is unbounded in the caller, and the local invariant survives every sampled bit. example : IsPPTOn encBits (encPair encBits encBits) (fun word => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) (respond word)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (respond word)) (requestHead word)).run word) := by apply requestHead_isOraclePPTOn.run_interpret_preprocess (operationEncoding := encFinEnum Unit) (resources := fun caller _ => caller.length + 1) @@ -214,7 +214,7 @@ example : IsPPTOn encBits (encPair encBits encBits) (fun word => -- The same bit appears in the output and the returned state; no marginalization is hidden. example (word : List Bool) : ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) (respond word)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (respond word)) (requestHead word)).run word) = (PMF.uniformOfFintype Bool).map (fun bit => ([bit], bit :: word)) := by rw [ProbOracleComp.eval_run_interpret] @@ -226,7 +226,7 @@ example (word : List Bool) : -- The API accepts a different caller encoding and preprocessing without any machine annotation. example : IsPPTOn (encList encBool) (encPair encBits encBits) (fun word => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) (respond word)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (respond word)) (requestHead word.reverse)).run word) := by apply requestHead_isOraclePPTOn.run_interpret_preprocess (operationEncoding := encFinEnum Unit) (resources := fun caller _ => caller.length + 1) @@ -263,7 +263,7 @@ example {β : Type} {output : β ↪ List Bool} {program : List Bool → WordOra (hprogram : IsOraclePPTOn encBits output program) : IsPPTOn encBits (encPair output (encList (encPair encBits encBits))) (fun word => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (fun request => memoize (fun _ => BitString.sampleList word.length) request.2)) (program word)).run []) := by apply hprogram.run_interpret_preprocess (operationEncoding := encFinEnum Unit) @@ -284,7 +284,7 @@ example {β : Type} {output : β ↪ List Bool} {program : List Bool → WordOra -- The trace contains one external request despite private draws and an unbounded reply. example (n : ℕ) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) (OracleComp.withTranscript (fun _ : Unit × List Bool => fun state : ℕ => PMF.pure (List.replicate n true, state + 1)))) (requestHead [])).run (7, []) = @@ -310,7 +310,7 @@ example : ¬ IsOraclePPTOn encBits encBits example : IsPPTOn (encPair encBits (encList encBits)) (encPair encBits (encPair encBits (encList encBits))) (fun pair => (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (OracleComp.withSampleList [] (fun value _ state => pure (value.take pair.1.length, value.take pair.1.length ++ state)))) (requestHead pair.1)).run (pair.1, pair.2)) := by diff --git a/ComplexityTests/OracleRepresentation.lean b/ComplexityTests/OracleRepresentation.lean index 8565d47b78..4261884933 100644 --- a/ComplexityTests/OracleRepresentation.lean +++ b/ComplexityTests/OracleRepresentation.lean @@ -54,13 +54,13 @@ private noncomputable def randomized : ProbOracleComp (fun _ : Bool => Bool) -- Private sampling is forwarded identically even though external replies change type. example : ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) source) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) source) (OracleComp.interpret - (ProbOracleComp.handler (fun n => ProbOracleComp.sample (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => ProbOracleComp.sample (ProbComp.unifFin n)) (fun q => Prod.fst <$> ProbOracleComp.query q)) randomized)).run (false, true)).map (fun (result, state) => (result, state.1)) = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) target) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) target) randomized).run false := ProbOracleComp.run_interpret_map_response_state (fun _ => Prod.fst) source target Prod.fst step randomized (false, true) diff --git a/ComplexityTests/OracleSemantics.lean b/ComplexityTests/OracleSemantics.lean index 46522c4723..f6e040e7f4 100644 --- a/ComplexityTests/OracleSemantics.lean +++ b/ComplexityTests/OracleSemantics.lean @@ -77,11 +77,11 @@ example : true ∈ support coinThenQuery := by ProbComp.eval_uniform] exact ⟨true, by simp [PMF.mem_support_iff], true, by simp [ProbOracleComp.query], rfl⟩ --- Its run is the generic run of the sum handler. +-- Its run is, by definition, the generic run of the sum handler. example (oracle : (q : Unit) → StateT ℕ PMF Bool) (s : ℕ) : ProbOracleComp.runWith oracle coinThenQuery s = runWith (sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) coinThenQuery s := - ProbOracleComp.runWith_eq_runWith_sumHandler oracle coinThenQuery s + rfl -- Against a reply that is always `false`, it never accepts. example (s : ℕ) : diff --git a/ComplexityTests/OracleSpecSum.lean b/ComplexityTests/OracleSpecSum.lean index aa40f46887..822a5f56de 100644 --- a/ComplexityTests/OracleSpecSum.lean +++ b/ComplexityTests/OracleSpecSum.lean @@ -34,13 +34,7 @@ example : (OracleComp.liftLeft left) = some false := by simp [left] --- The combined handler of a program with private coins is the sum handler, and sampling is the --- left embedding. -example (spec : Bool → Type) (random : (n : ℕ) → Option (Fin (n + 1))) - (oracle : (q : Bool) → Option (spec q)) : - ProbOracleComp.handler random oracle = OracleComp.sumHandler random oracle := - ProbOracleComp.handler_eq_sumHandler random oracle - +-- Sampling in a program with private coins is the left embedding. example (program : ProbComp Bool) : ProbOracleComp.sample (spec := fun _ : Bool => Bool) program = OracleComp.liftLeft program := ProbOracleComp.sample_eq_liftLeft program diff --git a/ComplexityTests/Presample.lean b/ComplexityTests/Presample.lean index 362c1bed0c..12fe9a3a99 100644 --- a/ComplexityTests/Presample.lean +++ b/ComplexityTests/Presample.lean @@ -64,7 +64,7 @@ example : OracleComp.withSampleList false respond true ([], [true, false]) = -- Private draws leave both state components unchanged; the saved values belong only to queries. example (state values : List Bool) : (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (OracleComp.withSampleList false respond)) (ProbOracleComp.sample (ProbComp.uniform Bool))).run (state, values) = (fun bit => (bit, state, values)) <$> ProbComp.uniform Bool := by @@ -95,10 +95,10 @@ example (state : List Bool) : ProbComp.eval (do let values ← OracleComp.replicate 2 (ProbComp.uniform Bool) (fun (result, next, _) => (result, next)) <$> (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (OracleComp.withSampleList false respond)) adaptive).run (state, values)) = ProbComp.eval ((OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifFin n)) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifFin n)) (fun query state => ProbComp.uniform Bool >>= fun value => respond value query state)) adaptive).run state) := adaptive_queryBounds.eval_presample (ProbComp.uniform Bool) false respond state diff --git a/ComplexityTests/PseudorandomFunction.lean b/ComplexityTests/PseudorandomFunction.lean index 4512d8304f..1da6d70c09 100644 --- a/ComplexityTests/PseudorandomFunction.lean +++ b/ComplexityTests/PseudorandomFunction.lean @@ -36,7 +36,7 @@ private noncomputable def repeatQuery (n : ℕ) (_ : List Bool) : WordOracleComp example (n : ℕ) : ProbComp.eval (prfIdealGame repeatQuery n) = PMF.uniformOfFintype Bool ∧ ProbComp.eval (Prod.fst <$> (OracleComp.interpret - (ProbOracleComp.handler (fun k => StateT.lift (ProbComp.unifFin k)) + (OracleComp.sumHandler (fun k => StateT.lift (ProbComp.unifFin k)) (fun request => cachedRandomFunctionOracle n request.2)) (repeatQuery n [])).run []) = PMF.uniformOfFintype Bool := by have h : ProbComp.eval (prfIdealGame repeatQuery n) = PMF.uniformOfFintype Bool := by diff --git a/ComplexityTests/UnboundedSimulators.lean b/ComplexityTests/UnboundedSimulators.lean index c24b1ba130..6882c15b79 100644 --- a/ComplexityTests/UnboundedSimulators.lean +++ b/ComplexityTests/UnboundedSimulators.lean @@ -68,7 +68,7 @@ theorem closeTo_refl {α : Type} (μ : PMF α) : CloseTo μ μ 0 := fun _ => by /-- A prover-side program without oracles, as a closed probabilistic program. -/ noncomputable def closeProgram {α : Type} (p : ProbOracleComp OracleSpec.empty α) : ProbComp α := - OracleComp.interpret (ProbOracleComp.handler ProbComp.unifFin fun e => e.elim) p + OracleComp.interpret (OracleComp.sumHandler ProbComp.unifFin fun e => e.elim) p theorem eval_closeProgram {α : Type} (p : ProbOracleComp OracleSpec.empty α) : ProbComp.eval (closeProgram p) = plainLaw p := by diff --git a/abstracts/ComplexityAbstracts/CryptographyAbstract.lean b/abstracts/ComplexityAbstracts/CryptographyAbstract.lean index 55285f4638..887551dbcc 100644 --- a/abstracts/ComplexityAbstracts/CryptographyAbstract.lean +++ b/abstracts/ComplexityAbstracts/CryptographyAbstract.lean @@ -25,7 +25,7 @@ finite-control machines with strict polynomial bounds and independent fair coins conventions, `Randomized.StrictPPT`, `Randomized.Negligible` and `Randomized.Indistinguishable`, are the shared foundations displayed in the appendix. The definitions and theorem statements below specify the claim; Lean checks their proofs through -`CryptographyBridge`. Besides the shared foundations, the audit allows only the following eight +`CryptographyBridge`. Besides the shared foundations, the audit allows only the following nine foundational program, interpretation and machine modules across the implementation boundary, without importing a security definition: * under `Computability.Machines.Turing.MultiTape`: `Machine` (machines whose oracle channels @@ -34,8 +34,8 @@ without importing a security definition: `Probabilistic.Oracle` (fair-coin runs with external oracle calls); * under `Languages.Probabilistic`: `Basic` (terminating programs with typed calls, whose only randomness is uniform choice from a finite range), `Oracle` (private coins beside external - calls), `Sum` (sums of oracle interfaces) and `Oracle.Interaction` (runs against a stateful - randomized oracle). + calls), `Sum` (sums of oracle interfaces), `Semantics` (the generic run of a program against a + stateful randomized oracle) and `Oracle.Interaction` (its instance with private coins). ## References @@ -203,6 +203,7 @@ info: abstract audit passed for `ComplexityTests.Abstracts.CryptographyAbstract` Complexity.Languages.Probabilistic.Basic, Complexity.Languages.Probabilistic.Oracle, Complexity.Languages.Probabilistic.Sum, + Complexity.Languages.Probabilistic.Semantics, Complexity.Languages.Probabilistic.Oracle.Interaction, Complexity.Computability.Machines.Turing.MultiTape.Machine, Complexity.Computability.Machines.Turing.MultiTape.Machine.Program, diff --git a/abstracts/ComplexityAbstracts/CryptographyBridge.lean b/abstracts/ComplexityAbstracts/CryptographyBridge.lean index b7e9931eb8..e4ca6136f9 100644 --- a/abstracts/ComplexityAbstracts/CryptographyBridge.lean +++ b/abstracts/ComplexityAbstracts/CryptographyBridge.lean @@ -169,7 +169,7 @@ theorem execute_eq {State β : Type} (program : OracleProgram β) (oracle : Unit × List Bool → StateT State PMF (List Bool)) (s : State) : execute program oracle s = (OracleComp.interpret - (ProbOracleComp.handler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) + (OracleComp.sumHandler (fun n => StateT.lift (ProbComp.unifOracle n)) oracle) program).run s := rfl def OraclePPT (program : ℕ → List Bool → OracleProgram Bool) : Prop := @@ -202,16 +202,17 @@ noncomputable def evaluateOracle {β : Type} (program : OracleProgram β) theorem evaluateOracle_eq {β : Type} (program : OracleProgram β) (oracle : List Bool → List Bool) : evaluateOracle program oracle = OracleComp.interpret - (ProbOracleComp.handler ProbComp.unifOracle (fun request => PMF.pure (oracle request.2))) + (OracleComp.sumHandler ProbComp.unifOracle (fun request => PMF.pure (oracle request.2))) program := by - have hlift : ProbOracleComp.handler (fun n => StateT.lift (σ := Unit) (ProbComp.unifOracle n)) + have hlift : OracleComp.sumHandler (fun n => StateT.lift (σ := Unit) (ProbComp.unifOracle n)) (fun request : Unit × List Bool => StateT.lift (PMF.pure (oracle request.2))) = (fun q => StateT.lift - (ProbOracleComp.handler ProbComp.unifOracle (fun request => PMF.pure (oracle request.2)) + (OracleComp.sumHandler ProbComp.unifOracle (fun request => PMF.pure (oracle request.2)) q)) := by funext q cases q <;> rfl - simp only [evaluateOracle, ProbOracleComp.runWith, hlift, OracleComp.run_interpret_lift] + simp only [evaluateOracle, ProbOracleComp.runWith, OracleComp.runWith, hlift, + OracleComp.run_interpret_lift] simp only [PMF.monad_map_eq_map, PMF.map_comp] exact PMF.map_id _ diff --git a/abstracts/ComplexityAbstracts/ShamirAbstract.lean b/abstracts/ComplexityAbstracts/ShamirAbstract.lean index 53f2caf7d2..259c61d157 100644 --- a/abstracts/ComplexityAbstracts/ShamirAbstract.lean +++ b/abstracts/ComplexityAbstracts/ShamirAbstract.lean @@ -24,7 +24,7 @@ bounds and correctness apply to encoded instances. The explicit foundational mod distinguishes finite-uniform requests in program syntax from their efficient fair-coin realization. The definitions and theorem statement below specify the claim. Lean checks the bridge, and the -audit permits only the following eight foundational program and machine modules, with no +audit permits only the following nine foundational program and machine modules, with no complexity-class or headline-result allowance: * under `Computability.Machines.Turing.MultiTape`: `Machine` (machines whose oracle channels have a write-only query buffer and a read-only reply tape), `Machine.Program` (a clocked run as @@ -32,8 +32,8 @@ complexity-class or headline-result allowance: `Probabilistic.Oracle` (fair-coin runs with external oracle calls); * under `Languages.Probabilistic`: `Basic` (terminating programs with typed calls, whose only randomness is uniform choice from a finite range), `Oracle` (private coins beside external - calls), `Sum` (sums of oracle interfaces) and `Oracle.Interaction` (runs against a stateful - randomized oracle). + calls), `Sum` (sums of oracle interfaces), `Semantics` (the generic run of a program against a + stateful randomized oracle) and `Oracle.Interaction` (its instance with private coins). ## References @@ -127,6 +127,7 @@ info: abstract audit passed for `ComplexityTests.Abstracts.ShamirAbstract`: Complexity.Languages.Probabilistic.Basic, Complexity.Languages.Probabilistic.Oracle, Complexity.Languages.Probabilistic.Sum, + Complexity.Languages.Probabilistic.Semantics, Complexity.Languages.Probabilistic.Oracle.Interaction ] diff --git a/abstracts/ComplexityAbstracts/TodaAbstract.lean b/abstracts/ComplexityAbstracts/TodaAbstract.lean index d57d93675e..5c434524a3 100644 --- a/abstracts/ComplexityAbstracts/TodaAbstract.lean +++ b/abstracts/ComplexityAbstracts/TodaAbstract.lean @@ -28,7 +28,7 @@ is deterministic. Its resource bound is expressed by exact realization on a cloc machine; the same interaction interface also supports randomized programs. The definitions and theorem statement below specify the claim. Lean checks the bridge, and -besides the shared foundations the audit permits only the following eight foundational program and +besides the shared foundations the audit permits only the following nine foundational program and machine modules, with no complexity-class or Toda-theorem allowance: * under `Computability.Machines.Turing.MultiTape`: `Machine` (machines whose oracle channels have a write-only query buffer and a read-only reply tape), `Machine.Program` (a clocked run as @@ -36,8 +36,8 @@ machine modules, with no complexity-class or Toda-theorem allowance: `Probabilistic.Oracle` (fair-coin runs with external oracle calls); * under `Languages.Probabilistic`: `Basic` (terminating programs with typed calls, whose only randomness is uniform choice from a finite range), `Oracle` (private coins beside external - calls), `Sum` (sums of oracle interfaces) and `Oracle.Interaction` (runs against a stateful - randomized oracle). + calls), `Sum` (sums of oracle interfaces), `Semantics` (the generic run of a program against a + stateful randomized oracle) and `Oracle.Interaction` (its instance with private coins). ## References @@ -169,6 +169,7 @@ info: abstract audit passed for `ComplexityTests.Abstracts.TodaAbstract`: Complexity.Languages.Probabilistic.Basic, Complexity.Languages.Probabilistic.Oracle, Complexity.Languages.Probabilistic.Sum, + Complexity.Languages.Probabilistic.Semantics, Complexity.Languages.Probabilistic.Oracle.Interaction ]