File size: 6,542 Bytes
f4b3ad1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | import OAI.NumberTheory.Ostmann.Arithmetic.ArithmeticSpectatorNode
import OAI.NumberTheory.Ostmann.Construction.TransferConjugations
import OAI.NumberTheory.Ostmann.Tree.RationalTreeLeaves
namespace OAI
/-! # From reconstructed integer histories to the spectator tree
The realization conditions record the two child products and the terminal
modulus. They allow composite inserted pivots: division by the compensation
unit gives the giant used by the rational tree. No prime law is assigned to
that composite integer.
-/
namespace Ostmann
open scoped Classical ComplexConjugate
noncomputable def spectatorHistoryLeaf {State : Type*} {q : ℕ} [Fact q.Prime]
(modulus : State → ℕ) (g : ZMod q → ℂ) (D : (ZMod q)ˣ) (σ : State) (s : ℤ) : ℂ :=
g ((s : ZMod q) / ((D : ZMod q) * (modulus σ : ZMod q)))
noncomputable def spectatorHistoryCutoff {State : Type*} {q : ℕ} [Fact q.Prime]
(sys : TransferHistorySystem State) (σ : State) (s v w : ℤ) : ℝ :=
if (historyPivot sys σ s v w : ZMod q) = 0 then 0 else 1
noncomputable def spectatorHistoryWeight {State : Type*} {q : ℕ} [Fact q.Prime]
(sys : TransferHistorySystem State) (modulus : State → ℕ)
(g : ZMod q → ℂ) (D : (ZMod q)ˣ) (n : ℕ) (σ : State) (t : FrequencyTree ℤ n) : ℂ :=
recursiveTransferWeight sys (spectatorHistoryLeaf modulus g D)
(spectatorHistoryCutoff (q := q) sys) n σ t
def SpectatorHistoryRealizes {State : Type*} {q : ℕ} [Fact q.Prime]
(sys : TransferHistorySystem State) (modulus : State → ℕ) :
{n : ℕ} → {C : (ZMod q)ˣ} → RationalTreeData (ZMod q)ˣ n C →
State → FrequencyTree ℤ n → (ZMod q)ˣ → (ZMod q)ˣ → TreeLeafTuple (ZMod q)ˣ n → Prop
| _, _, .leaf s C, σ, t, XL, XR, x =>
((frequencyRoot (A := ℤ) 0 t : ℤ) : ZMod q) = s ∧
(modulus σ : ZMod q) = (XL * XR * C * treeLeafProduct 0 x : (ZMod q)ˣ)
| n + 1, _, .node s CL CR u left right, σ, t, XL, XR, x =>
let v := frequencyRoot n t.2.1
let w := frequencyRoot n t.2.2
let P := historyPivot sys σ t.1 v w
ValidTransferNode sys σ t.1 v w P ∧
(t.1 : ZMod q) = s ∧ (v : ZMod q) = left.frequency ∧ (w : ZMod q) = right.frequency ∧
(sys.leftProduct σ : ZMod q) = (XL * CL * treeLeafProduct n x.1 : (ZMod q)ˣ) ∧
(sys.rightProduct σ : ZMod q) = (XR * CR * treeLeafProduct n x.2 : (ZMod q)ˣ) ∧
∀ h : (P : ZMod q) ≠ 0,
SpectatorHistoryRealizes sys modulus left (sys.leftState σ P) t.2.1
(Units.mk0 (P : ZMod q) h / u) XL x.1 ∧
SpectatorHistoryRealizes sys modulus right (sys.rightState σ P) t.2.2
(Units.mk0 (P : ZMod q) h / u) XR x.2
theorem spectatorHistoryWeight_eq_tree {State : Type*} {q : ℕ} [Fact q.Prime]
(sys : TransferHistorySystem State) (modulus : State → ℕ)
(g : ZMod q → ℂ) (D : (ZMod q)ˣ)
{n : ℕ} {C : (ZMod q)ˣ} (T : RationalTreeData (ZMod q)ˣ n C)
(σ : State) (t : FrequencyTree ℤ n) (XL XR : (ZMod q)ˣ)
(x : TreeLeafTuple (ZMod q)ˣ n)
(h : SpectatorHistoryRealizes sys modulus T σ t XL XR x) (b : Bool) :
(if b then conj (spectatorHistoryWeight sys modulus g D n σ t)
else spectatorHistoryWeight sys modulus g D n σ t) =
rationalTreeAmplitude g D T XL XR (transferConjugations n b) x := by
induction T generalizing σ XL XR b with
| leaf s C =>
rcases h with ⟨hs, hM⟩
have ha : ((frequencyRoot (A := ℤ) 0 t : ℤ) : ZMod q) / ((D : ZMod q) * (modulus σ : ZMod q)) =
(rationalTreeArgument s C D XL XR x : ZMod q) := by
rw [hs, hM]
simp only [rationalTreeArgument, Units.val_div_eq_div_val, Units.val_mul]
apply congrArg (fun z : ZMod q => (s : ZMod q) / z)
dsimp only [treeLeafProduct]
ring
cases b with
| false => exact congrArg g ha
| true => exact congrArg star (congrArg g ha)
| @node n s CL CR u left right ihL ihR =>
rcases h with ⟨hvalid, hs, hv, hw, hL, hR, hchild⟩
let P := historyPivot sys σ t.1 (frequencyRoot n t.2.1) (frequencyRoot n t.2.2)
let V := reconstructedEntry (s : ZMod q) left.frequency right.frequency u
((XL * CL * treeLeafProduct n x.1 : (ZMod q)ˣ) : ZMod q)
((XR * CR * treeLeafProduct n x.2 : (ZMod q)ˣ) : ZMod q)
have hs0 : (t.1 : ZMod q) ≠ 0 := by rw [hs]; exact Units.ne_zero s
have hV : V = (P : ZMod q) / u := by
dsimp only [V]
rw [← hs, ← hv, ← hw, ← hL, ← hR]
exact hvalid.spectator_composite_reconstruction u hs0
have hW := recursiveTransferWeight_node sys (spectatorHistoryLeaf modulus g D)
(spectatorHistoryCutoff (q := q) sys) n σ t P hvalid
change (if b then conj _ else _) = _
by_cases hp : (P : ZMod q) = 0
· have hV0 : V = 0 := by rw [hV, hp, zero_div]
have hweight : spectatorHistoryWeight sys modulus g D (n + 1) σ t = 0 := by
unfold spectatorHistoryWeight
rw [hW]
simp only [spectatorHistoryCutoff, show (historyPivot sys σ t.1
(frequencyRoot n t.2.1) (frequencyRoot n t.2.2) : ZMod q) = 0 from hp,
↓reduceIte, Complex.ofReal_zero, zero_mul]
simp only [hweight, map_zero, ite_self, rationalTreeAmplitude, transferConjugations]
change 0 = if hv : V = 0 then 0 else _
rw [dite_eq_left hV0]
· have hV0 : V ≠ 0 := by rw [hV]; exact div_ne_zero hp (Units.ne_zero u)
have hunit : Units.mk0 V hV0 = Units.mk0 (P : ZMod q) hp / u := by
apply Units.ext
simpa only [Units.val_mk0, Units.val_div_eq_div_val] using hV
have hweight : spectatorHistoryWeight sys modulus g D (n + 1) σ t =
spectatorHistoryWeight sys modulus g D n (sys.leftState σ P) t.2.1 *
conj (spectatorHistoryWeight sys modulus g D n (sys.rightState σ P) t.2.2) := by
unfold spectatorHistoryWeight
rw [hW]
simp only [spectatorHistoryCutoff, show (historyPivot sys σ t.1
(frequencyRoot n t.2.1) (frequencyRoot n t.2.2) : ZMod q) ≠ 0 from hp,
↓reduceIte, Complex.ofReal_one, one_mul, Complex.star_def]
have hl := ihL (sys.leftState σ P) t.2.1
(Units.mk0 (P : ZMod q) hp / u) XL x.1 (hchild hp).1 b
have hr := ihR (sys.rightState σ P) t.2.2
(Units.mk0 (P : ZMod q) hp / u) XR x.2 (hchild hp).2 (!b)
rw [hweight]
simp only [rationalTreeAmplitude, transferConjugations]
change _ = if hv : V = 0 then 0 else _
rw [dite_eq_right hV0, hunit, ← hl, ← hr]
cases b <;> simp
end Ostmann
end OAI
|