| import OAI.Dynamics.ConditionalShuffle.CycleIterate |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped Classical |
| namespace Thorp.Conditional.Hybrid |
| open OverlayEnergy Revealed.Instrument |
|
|
| lemma raw_append (d n m : ℕ) (v : RawState (d+1)) |
| (s : Fin n → Bool) (r : Fin m → Bool) (a : History (d+1) n) (b : History (d+1) m) : |
| raw d v (n+m) (Fin.append s r) (Fin.append a b) = raw d (raw d v n s a) m r b := by |
| induction m with |
| | zero => |
| have hr : Fin.append s r = s := by funext i; exact Fin.append_left s r i |
| have hb : Fin.append a b = a := by funext i; exact Fin.append_left a b i |
| rw [hr, hb]; rfl |
| | succ m ih => |
| obtain ⟨⟨q,r⟩,rfl⟩ := (Fin.snocEquiv (fun _ : Fin (m+1) => Bool)).surjective r |
| obtain ⟨⟨c,b⟩,rfl⟩ := (Fin.snocEquiv (fun _ : Fin (m+1) => Coins (d+1))).surjective b |
| erw [Fin.append_snoc, Fin.append_snoc, raw_snoc, raw_snoc, ih] |
|
|
| lemma raw_public (d : ℕ) (v : RawState (d+1)) (t : ℕ) (ω : History (d+1) t) : |
| raw d v t (fun _ => false) ω = rawPermute v (run (d+1) t ω) := by |
| induction t with |
| | zero => rfl |
| | succ t ih => |
| change rawPermute (raw d v t (fun _ => false) (Fin.init ω)) (step (d+1) (ω (Fin.last t))) = _ |
| rw [ih, run_succ] |
| rfl |
|
|
| lemma raw_private (d : ℕ) (v : RawState (d+1)) (t : ℕ) (ω : History (d+1) t) : |
| raw d v t (fun _ => true) ω = rawIterate d v t ω := by |
| induction t with |
| | zero => rfl |
| | succ t ih => |
| change rawNext d (raw d v t (fun _ => true) (Fin.init ω)) (ω (Fin.last t)) = _ |
| rw [ih]; rfl |
|
|
| def periodLength (g : ℕ) := (9*(g+3)+200*(g+3))+(g+3) |
|
|
| lemma periodLength_eq (g : ℕ) : periodLength g = 210*(g+3) := by unfold periodLength; omega |
|
|
| def cycleSchedule (g : ℕ) : Fin (periodLength g) → Bool := |
| Fin.append (Fin.append (fun _ : Fin (9*(g+3)) => false) |
| (fun _ : Fin (200*(g+3)) => false)) (fun _ : Fin (g+3) => true) |
|
|
| def tripleHistory (Ω : Type) (a b c : ℕ) : |
| (((Fin a → Ω) × (Fin b → Ω)) × (Fin c → Ω)) ≃ (Fin ((a+b)+c) → Ω) := |
| (Equiv.prodCongr (Fin.appendEquiv a b) (Equiv.refl _)).trans (Fin.appendEquiv (a+b) c) |
|
|
| lemma tripleHistory_apply (Ω : Type) (a b c : ℕ) (ω) : |
| tripleHistory Ω a b c ω = Fin.append (Fin.append ω.1.1 ω.1.2) ω.2 := rfl |
|
|
| def cycleHistory (g : ℕ) : CycleCoins g ≃ (Fin (periodLength g) → Bits g) := |
| tripleHistory (Bits g) (9*(g+3)) (200*(g+3)) (g+3) |
|
|
| lemma cycleHistory_apply (g : ℕ) (ω : CycleCoins g) : |
| cycleHistory g ω = Fin.append (Fin.append ω.1.1 ω.1.2) ω.2 := |
| tripleHistory_apply (Bits g) _ _ _ ω |
|
|
| lemma raw_cycle (g : ℕ) (v : RawState (g+3)) (ω : CycleCoins g) : |
| raw (g+2) v (periodLength g) (cycleSchedule g) (cycleHistory g ω) = cycle g v ω := by |
| rw [cycleHistory_apply] |
| unfold cycleSchedule |
| erw [raw_append, raw_append, raw_public, raw_public, raw_private] |
| rfl |
|
|
| def repeatedSchedule (g n : ℕ) : Fin (periodLength g*n) → Bool := |
| chunks Bool (periodLength g) n (fun _ => cycleSchedule g) |
|
|
| def repeatedHistory (g n : ℕ) : (Fin n → CycleCoins g) ≃ (Fin (periodLength g*n) → Bits g) := |
| (Equiv.piCongrRight (fun _ : Fin n => cycleHistory g)).trans (chunks (Bits g) (periodLength g) n) |
|
|
| lemma repeatedHistory_apply (g n : ℕ) (ω : Fin n → CycleCoins g) : |
| repeatedHistory g n ω = chunks (Bits g) (periodLength g) n (fun i => cycleHistory g (ω i)) := by |
| rfl |
|
|
| lemma raw_cycles (g : ℕ) (v : RawState (g+3)) (n : ℕ) (ω : Fin n → CycleCoins g) : |
| raw (g+2) v (periodLength g*n) (repeatedSchedule g n) (repeatedHistory g n ω) = cycles g v n ω := by |
| induction n with |
| | zero => rfl |
| | succ n ih => |
| obtain ⟨⟨c,ω⟩,rfl⟩ := (Fin.snocEquiv (fun _ : Fin (n+1) => CycleCoins g)).surjective ω |
| have hs : (fun _ : Fin (n+1) => cycleSchedule g) = |
| Fin.snoc (fun _ : Fin n => cycleSchedule g) (cycleSchedule g) := by |
| funext i; refine Fin.lastCases ?_ (fun j => ?_) i <;> simp |
| have hh : (fun i : Fin (n+1) => cycleHistory g ((Fin.snoc ω c : Fin (n+1) → CycleCoins g) i)) = |
| Fin.snoc (fun i : Fin n => cycleHistory g (ω i)) (cycleHistory g c) := by |
| funext i; refine Fin.lastCases ?_ (fun j => ?_) i <;> simp |
| rw [repeatedHistory_apply, repeatedSchedule] |
| rw [hs] |
| change raw (g+2) v _ _ (chunks (Bits g) _ _ |
| (fun i => cycleHistory g ((Fin.snoc ω c : Fin (n+1) → CycleCoins g) i))) = _ |
| rw [hh, chunks_snoc, chunks_snoc] |
| erw [raw_append] |
| change raw (g+2) (raw (g+2) v _ (repeatedSchedule g n) (repeatedHistory g n ω)) |
| _ (cycleSchedule g) (cycleHistory g c) = _ |
| rw [ih, raw_cycle] |
| simp only [cycles, Fin.snocEquiv, Equiv.coe_fn_mk, Fin.init_snoc, Fin.snoc_last] |
|
|
| lemma repeated_energy (g : ℕ) (v : RawState (g+3)) |
| (hw : ∀ x, v.free x = false → v.weight x = 0) (hz : ∑ x, v.weight x = 0) |
| (hf : Fintype.card (Position (g+3)) ≤ 64 * freeCount v.free) |
| (hk : freeCount v.free ≤ 2^g) |
| (hs : 256*(g+4) ≤ Fintype.card (Position (g+3))) (n : ℕ) : |
| energy (g+2) v (periodLength g*n) (repeatedSchedule g n) ≤ rawEnergy v * OverlayEnergy.coefficient g^n := by |
| have hh := mean_equiv (repeatedHistory g n) |
| (fun ω : History (g+3) (periodLength g*n) => |
| rawEnergy (raw (g+2) v (periodLength g*n) (repeatedSchedule g n) ω)) |
| change mean (fun ω : Fin n → CycleCoins g => |
| rawEnergy (raw (g+2) v _ (repeatedSchedule g n) (repeatedHistory g n ω))) = _ at hh |
| simp only [raw_cycles] at hh |
| change mean (fun ω : History (g+3) (periodLength g*n) => _) ≤ _ |
| have hi := cycles_expected_energy g v hw hz hf hk hs n |
| exact (mean_fintype_irrel _ _ _).le.trans (hh.symm.le.trans hi) |
|
|
| lemma repeated_point_energy (g : ℕ) (B : Position (g+3) → Bool) (tag) (ht : B tag = true) |
| (hf : Fintype.card (Position (g+3)) ≤ 64*freeCount B) (hk : freeCount B ≤ 2^g) |
| (hs : 256*(g+4) ≤ Fintype.card (Position (g+3))) (n : ℕ) : |
| energy (g+2) (initialState (g+3) B tag ht).raw (periodLength g*n) (repeatedSchedule g n) ≤ |
| OverlayEnergy.coefficient g^n := by |
| have hh := repeated_energy g (initialState (g+3) B tag ht).raw |
| (initialState (g+3) B tag ht).supported (initialState (g+3) B tag ht).mass_zero hf hk hs n |
| exact hh.trans (mul_le_of_le_one_left (pow_nonneg (coefficient_nonneg g) n) |
| (initialState (g+3) B tag ht).energy_le_one) |
|
|
| end Thorp.Conditional.Hybrid |
|
|
| end |
|
|
| end OAI |
|
|
