Documentation

CsdLean4.RecordLayer.EchoArena

The autonomous echo arena: emission, reception and return as activated writes #

Category: 7-SigmaLayer (the record layer). BACKLOG #199 (out of #39; the author's third operational-geometry brief, #198–#205).

The activated write of #194 has one pointer, at the receiver. The echo puts a pointer at each station:

EchoArena = FieldArena 2 2 × (T² × T²), x = (p, (q_A, q_B)),

pointer A coupled to the occupancy of A, pointer B to the occupancy of B, each detuning the carrier by its own back-reaction (#198: H = J X + Δ_A n_A + Δ_B n_B). The dynamics is the one the time-independent joint Hamiltonian

𝓗 = ⟨p, J X p⟩ + g_A n_A(p) f_A(θ₂ᴬ) + g_B n_B(p) f_B(θ₂ᴮ)

prescribes: at fixed conserved angles the ray evolves by the two-site detuned exchange, pointer A turns at the rate −(2g_A/ħ) f_A'(θ₂ᴬ) · n_A(p) and pointer B at −(2g_B/ħ) f_B'(θ₂ᴮ) · n_B(p). Each pointer moves only while the carrier is at its station. For message 1 the carrier leaves A, arrives at B, and comes back to A on its own at the detuned round trip (twoDetuned_return), so pointer A is driven twice — once as the carrier leaves (the emission), once as it returns — and pointer B once (the reception). Read in thirds of a turn, pointer A's first arc is the emission record and its second arc the return record: two displacement arcs of one register at A, written by the carrier itself.

What is and is not claimed #

References: specs/BACKLOG.md #199, #198, #200, #194, #191, #39; CV/TwoSiteDetuned.lean, RecordLayer/ActivatedWrite.lean (detuningAt, rateAt, pointerDrift, displayArc, writeStart, writeEnd, retention), RecordLayer/RecordOccurrence.lean.

The arena and the couplings #

@[reducible, inline]

The arena of the echo: the two-site exchange and one pointer torus per station.

Equations
Instances For

    The product instance, which instance search does not find at this depth.

    The product instance, which instance search does not find at this depth.

    A pointer coupling: a periodic C¹ potential f and a strength g.

    • f : ℝ → ℝ

      The potential on the conserved angle.

    • g : ℝ

      The coupling strength.

    • periodic : Function.Periodic self.f 1

      The potential is 1-periodic.

    • smooth : ContDiff ℝ 1 self.f

      The potential is C¹.

    Instances For

      A generic Liouville step: translating one circle coordinate #

      Translating one circle coordinate by a measurable function of the other coordinates preserves the product measure. The fibre map over x is swap ∘ (skew product of id with a translation) ∘ swap, and the whole map is the skew product of id with those fibres.

      The dynamics #

      noncomputable def CSD.RecordLayer.echoDetA (A : PointerCoupling) (x : EchoArena) :

      The detuning at A: g_A f_A(θ₂ᴬ).

      Equations
      Instances For
        noncomputable def CSD.RecordLayer.echoDetB (B : PointerCoupling) (x : EchoArena) :

        The detuning at B: g_B f_B(θ₂ᴮ).

        Equations
        Instances For
          noncomputable def CSD.RecordLayer.echoAmountA (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :

          The lifted displacement of pointer A after time t: r_A ∫₀ᵗ n_A(p(s)) ds.

          Equations
          Instances For
            noncomputable def CSD.RecordLayer.echoAmountB (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :

            The lifted displacement of pointer B after time t: r_B ∫₀ᵗ n_B(p(s)) ds.

            Equations
            Instances For
              noncomputable def CSD.RecordLayer.echoFlow (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) :

              ★ The echo flow: at fixed conserved angles the ray evolves by the two-site detuned exchange, and each pointer is translated by its lifted displacement.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                theorem CSD.RecordLayer.echoFlow_fst (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                (echoFlow J ħ A B t x).1 = (CV.twoDetunedFlow J ħ (echoDetA A x) (echoDetB B x)).arenaFlow t x.1
                theorem CSD.RecordLayer.echoFlow_pointerA (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                (echoFlow J ħ A B t x).2.1 = pshift (echoAmountA J ħ A B t x) x.2.1
                theorem CSD.RecordLayer.echoFlow_pointerB (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                (echoFlow J ħ A B t x).2.2 = pshift (echoAmountB J ħ A B t x) x.2.2
                theorem CSD.RecordLayer.echoFlow_angles (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                (echoFlow J ħ A B t x).2.1.2 = x.2.1.2 ∧ (echoFlow J ħ A B t x).2.2.2 = x.2.2.2

                Both conserved angles are conserved.

                theorem CSD.RecordLayer.echoDetA_echoFlow (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                echoDetA A (echoFlow J ħ A B t x) = echoDetA A x
                theorem CSD.RecordLayer.echoDetB_echoFlow (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                echoDetB B (echoFlow J ħ A B t x) = echoDetB B x
                theorem CSD.RecordLayer.echoAmountA_add (J ħ : ℝ) (A B : PointerCoupling) (s t : ℝ) (x : EchoArena) :
                echoAmountA J ħ A B (s + t) x = echoAmountA J ħ A B s x + echoAmountA J ħ A B t (echoFlow J ħ A B s x)
                theorem CSD.RecordLayer.echoAmountB_add (J ħ : ℝ) (A B : PointerCoupling) (s t : ℝ) (x : EchoArena) :
                echoAmountB J ħ A B (s + t) x = echoAmountB J ħ A B s x + echoAmountB J ħ A B t (echoFlow J ħ A B s x)
                theorem CSD.RecordLayer.echoFlow_add (J ħ : ℝ) (A B : PointerCoupling) (s t : ℝ) :
                echoFlow J ħ A B (s + t) = echoFlow J ħ A B t ∘ echoFlow J ħ A B s

                ★★ The group law: the echo flow is a one-parameter group, by the group laws of both accumulated occupancies along the two-site flow.

                The two-time propagator: autonomous, so only the elapsed time enters.

                Equations
                Instances For
                  theorem CSD.RecordLayer.echoEvolve_comp (J ħ : ℝ) (A B : PointerCoupling) (s t u : SigmaLayer.OnticTime) :
                  echoEvolve J ħ A B t u ∘ echoEvolve J ħ A B s t = echoEvolve J ħ A B s u

                  The two-time law.

                  theorem CSD.RecordLayer.echoEvolve_shift (J ħ : ℝ) (A B : PointerCoupling) (s t a : SigmaLayer.OnticTime) :
                  echoEvolve J ħ A B (s + a) (t + a) = echoEvolve J ħ A B s t

                  ★ Autonomy: no test of t_Σ appears.

                  Continuity and Liouville #

                  The three steps of the echo flow #

                  noncomputable def CSD.RecordLayer.echoRayStep (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :

                  The ray step: the unitary kick at fixed angles, the pointers untouched.

                  Equations
                  Instances For
                    noncomputable def CSD.RecordLayer.echoShiftA (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :

                    The translation of pointer A.

                    Equations
                    Instances For
                      noncomputable def CSD.RecordLayer.echoShiftB (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :

                      The translation of pointer B.

                      Equations
                      Instances For
                        theorem CSD.RecordLayer.echoShiftA_fst (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        (echoShiftA J ħ A B t x).1 = x.1
                        theorem CSD.RecordLayer.echoShiftB_fst (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        (echoShiftB J ħ A B t x).1 = x.1
                        theorem CSD.RecordLayer.echoShiftA_pointerB (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        (echoShiftA J ħ A B t x).2.2 = x.2.2
                        theorem CSD.RecordLayer.echoShiftB_pointerA (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        (echoShiftB J ħ A B t x).2.1 = x.2.1
                        theorem CSD.RecordLayer.echoDetA_echoShiftA (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        echoDetA A (echoShiftA J ħ A B t x) = echoDetA A x
                        theorem CSD.RecordLayer.echoDetB_echoShiftA (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        echoDetB B (echoShiftA J ħ A B t x) = echoDetB B x
                        theorem CSD.RecordLayer.echoDetA_echoShiftB (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        echoDetA A (echoShiftB J ħ A B t x) = echoDetA A x
                        theorem CSD.RecordLayer.echoDetB_echoShiftB (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        echoDetB B (echoShiftB J ħ A B t x) = echoDetB B x
                        theorem CSD.RecordLayer.echoAmountB_echoShiftA (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                        echoAmountB J ħ A B t (echoShiftA J ħ A B t x) = echoAmountB J ħ A B t x

                        Pointer B's amount is read from coordinates the translation of A does not touch.

                        theorem CSD.RecordLayer.echoFlow_eq_comp (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) :
                        echoFlow J ħ A B t = echoRayStep J ħ A B t ∘ echoShiftB J ħ A B t ∘ echoShiftA J ħ A B t

                        The echo flow is the ray step after the two translations.

                        The ray step preserves the measure: a skew product over the angles of the unitary kick.

                        ★★ Liouville: the echo flow preserves Fubini–Study × Haar⁴ — the ray step after the two pointer translations, each measure-preserving.

                        Energy and the equations of motion #

                        noncomputable def CSD.RecordLayer.echoEnergy (J : ℝ) (A B : PointerCoupling) (x : EchoArena) :

                        The joint energy J⟨X⟩ + g_A f_A(θ₂ᴬ) n_A + g_B f_B(θ₂ᴮ) n_B.

                        Equations
                        • One or more equations did not get rendered due to their size.
                        Instances For
                          theorem CSD.RecordLayer.echoEnergy_echoFlow (J ħ : ℝ) (A B : PointerCoupling) (t : ℝ) (x : EchoArena) :
                          echoEnergy J A B (echoFlow J ħ A B t x) = echoEnergy J A B x

                          ★★ Energy conservation: the joint energy is constant along the echo flow.

                          theorem CSD.RecordLayer.hasDerivAt_echoAmountA (J ħ : ℝ) (A B : PointerCoupling) (x : EchoArena) (t : ℝ) :
                          HasDerivAt (fun (t : ℝ) => echoAmountA J ħ A B t x) (rateAt A.g ħ ⋯ x.2.1.2 * CV.arenaObs CV.occA (echoFlow J ħ A B t x).1) t

                          ★★ Pointer A's equation of motion: it turns at the rate −(2g_A/ħ) f_A'(θ₂ᴬ) · n_A(p(t)) — only while the carrier is at A.

                          theorem CSD.RecordLayer.hasDerivAt_echoAmountB (J ħ : ℝ) (A B : PointerCoupling) (x : EchoArena) (t : ℝ) :
                          HasDerivAt (fun (t : ℝ) => echoAmountB J ħ A B t x) (rateAt B.g ħ ⋯ x.2.2.2 * CV.arenaObs CV.occB (echoFlow J ħ A B t x).1) t

                          ★★ Pointer B's equation of motion: it turns at the rate −(2g_B/ħ) f_B'(θ₂ᴮ) · n_B(p(t)) — only while the carrier is at B.

                          The two messages #

                          noncomputable def CSD.RecordLayer.echoDetuning (A B : PointerCoupling) (qA qB : LF4.KTorus) :

                          The detuning difference Δ_B − Δ_A seen by the carrier for pointers prepared at q_A, q_B.

                          Equations
                          Instances For
                            noncomputable def CSD.RecordLayer.echoLoss (A B : PointerCoupling) (J : ℝ) (qA qB : LF4.KTorus) :

                            The transfer factor λ = (J/Ω')².

                            Equations
                            Instances For
                              noncomputable def CSD.RecordLayer.echoRate (A B : PointerCoupling) (J ħ : ℝ) (qA qB : LF4.KTorus) :

                              The Rabi rate ω = Ω'/ħ of the echo.

                              Equations
                              Instances For
                                noncomputable def CSD.RecordLayer.senderRate (A : PointerCoupling) (ħ : ℝ) (qA : LF4.KTorus) :

                                Pointer A's rate r_A = −(2g_A/ħ) f_A'(θ₂ᴬ).

                                Equations
                                Instances For
                                  noncomputable def CSD.RecordLayer.receiverDrift (A B : PointerCoupling) (J ħ : ℝ) (qA qB : LF4.KTorus) :

                                  Pointer B's mean rate over a Rabi cycle, κ_B = r_B λ.

                                  Equations
                                  Instances For
                                    theorem CSD.RecordLayer.echoLoss_pos {J : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (qA qB : LF4.KTorus) :
                                    0 < echoLoss A B J qA qB
                                    theorem CSD.RecordLayer.echoLoss_le_one {J : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (qA qB : LF4.KTorus) :
                                    echoLoss A B J qA qB ≤ 1
                                    theorem CSD.RecordLayer.echoRate_pos {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) :
                                    0 < echoRate A B J ħ qA qB
                                    theorem CSD.RecordLayer.echoFlow_msgPoint_zero {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (qA qB : LF4.KTorus) (t : ℝ) :
                                    echoFlow J ħ A B t (CV.msgPoint 0, qA, qB) = (CV.msgPoint 0, qA, qB)

                                    Message 0 fixes the whole arena point: the vacuum never moves and neither pointer turns.

                                    noncomputable def CSD.RecordLayer.senderDrift (r l ω t : ℝ) :

                                    The sender's displacement for message 1: r (t − λ (ωt − sin ωt cos ωt)/(2ω)).

                                    Equations
                                    Instances For
                                      theorem CSD.RecordLayer.senderDrift_eq (r l ω t : ℝ) :
                                      senderDrift r l ω t = r * t - pointerDrift (r * l) ω t
                                      theorem CSD.RecordLayer.echoAmountA_msgPoint_one {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) (t : ℝ) :
                                      echoAmountA J ħ A B t (CV.msgPoint 1, qA, qB) = senderDrift (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) t

                                      ★★★ Pointer A's displacement for message 1, in closed form.

                                      theorem CSD.RecordLayer.echoAmountB_msgPoint_one {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) (t : ℝ) :
                                      echoAmountB J ħ A B t (CV.msgPoint 1, qA, qB) = pointerDrift (receiverDrift A B J ħ qA qB) (echoRate A B J ħ qA qB) t

                                      ★★★ Pointer B's displacement for message 1, in closed form: #194's drift with κ_B = r_B λ.

                                      theorem CSD.RecordLayer.echoFlow_msgPoint_one_pointerA {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) (t : ℝ) :
                                      (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)).2.1 = pshift (senderDrift (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) t) qA
                                      theorem CSD.RecordLayer.echoFlow_msgPoint_one_pointerB {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) (t : ℝ) :
                                      (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)).2.2 = pshift (pointerDrift (receiverDrift A B J ħ qA qB) (echoRate A B J ħ qA qB) t) qB
                                      theorem CSD.RecordLayer.echo_return_ray {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) :
                                      (echoFlow J ħ A B (CV.detunedRoundTrip J ħ (echoDetuning A B qA qB)) (CV.msgPoint 1, qA, qB)).1 = CV.msgPoint 1

                                      ★ The carrier is back at A at the detuned round trip, as a ray.

                                      The plateaus #

                                      theorem CSD.RecordLayer.senderDrift_hopTime {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (r : ℝ) (qA qB : LF4.KTorus) :
                                      senderDrift r (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) (CV.detunedHopTime J ħ (echoDetuning A B qA qB)) = r * CV.detunedHopTime J ħ (echoDetuning A B qA qB) * (1 - echoLoss A B J qA qB / 2)

                                      At the detuned hop time pointer A has turned by r_A τ (1 − λ/2).

                                      theorem CSD.RecordLayer.sender_rate_hopTime {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) :
                                      HasDerivAt (fun (t : ℝ) => echoAmountA J ħ A B t (CV.msgPoint 1, qA, qB)) (senderRate A ħ qA * (1 - echoLoss A B J qA qB)) (CV.detunedHopTime J ħ (echoDetuning A B qA qB))

                                      The sender's plateau: at the detuned hop time pointer A moves at the rate r_A (1 − λ) — the loss alone; at zero detuning it is stationary while the carrier is at B.

                                      theorem CSD.RecordLayer.receiver_rate_roundTrip {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) :
                                      HasDerivAt (fun (t : ℝ) => echoAmountB J ħ A B t (CV.msgPoint 1, qA, qB)) 0 (CV.detunedRoundTrip J ħ (echoDetuning A B qA qB))

                                      The receiver's plateau: at the detuned round trip pointer B is stationary — the carrier is back at A.

                                      Bounds on the sender's drift #

                                      theorem CSD.RecordLayer.senderDrift_nonneg {r l ω : ℝ} (hr : 0 ≤ r) (hl0 : 0 ≤ l) (hl1 : l ≤ 1) (hω : 0 < ω) {t : ℝ} (ht : 0 ≤ t) :
                                      0 ≤ senderDrift r l ω t
                                      theorem CSD.RecordLayer.senderDrift_le {r l ω : ℝ} (hr : 0 ≤ r) (hl0 : 0 ≤ l) (hω : 0 < ω) {t : ℝ} (ht : 0 ≤ t) :
                                      senderDrift r l ω t ≤ r * t
                                      theorem CSD.RecordLayer.senderDrift_lower {r l ω : ℝ} (hr : 0 ≤ r) (hl0 : 0 ≤ l) (hω : 0 < ω) (t : ℝ) :
                                      r * (t * (1 - l / 2) - l / (4 * ω)) ≤ senderDrift r l ω t

                                      The band about the mean growth: r (t (1 − λ/2) − λ/(4ω)) ≤ D_A(t).

                                      theorem CSD.RecordLayer.senderDrift_upper {r l ω : ℝ} (hr : 0 ≤ r) (hl0 : 0 ≤ l) (hω : 0 < ω) (t : ℝ) :
                                      senderDrift r l ω t ≤ r * (t * (1 - l / 2) + l / (4 * ω))

                                      The band about the mean growth: D_A(t) ≤ r (t (1 − λ/2) + λ/(4ω)).

                                      The sender's write intervals #

                                      noncomputable def CSD.RecordLayer.meanRate (r l : ℝ) :

                                      The sender's mean rate r (1 − λ/2).

                                      Equations
                                      Instances For
                                        noncomputable def CSD.RecordLayer.band (r l ω : ℝ) :

                                        The half-width r λ/(4ω) of the band about the mean growth.

                                        Equations
                                        Instances For
                                          noncomputable def CSD.RecordLayer.emitStart (r : ℝ) :

                                          The emission write begins: 1/(6 r).

                                          Equations
                                          Instances For
                                            noncomputable def CSD.RecordLayer.emitEnd (r l ω : ℝ) :

                                            The emission write ends: the mean growth reaches 1/3 plus the band.

                                            Equations
                                            Instances For
                                              noncomputable def CSD.RecordLayer.returnStart (r : ℝ) :

                                              The return write begins: 1/(2 r).

                                              Equations
                                              Instances For
                                                noncomputable def CSD.RecordLayer.returnEnd (r l ω : ℝ) :

                                                The return write ends: the mean growth reaches 2/3 plus the band.

                                                Equations
                                                Instances For
                                                  noncomputable def CSD.RecordLayer.senderWindow (r l ω : ℝ) :

                                                  The sender's retention window: (1/6 − 2 band)/meanRate.

                                                  Equations
                                                  Instances For
                                                    theorem CSD.RecordLayer.meanRate_pos {r l : ℝ} (hr : 0 < r) (hl : l ≤ 1) :
                                                    0 < meanRate r l
                                                    theorem CSD.RecordLayer.meanRate_le {r l : ℝ} (hr : 0 ≤ r) (hl : 0 ≤ l) :
                                                    theorem CSD.RecordLayer.band_nonneg {r l ω : ℝ} (hr : 0 ≤ r) (hl : 0 ≤ l) (hω : 0 < ω) :
                                                    0 ≤ band r l ω
                                                    theorem CSD.RecordLayer.band_le {r l ω : ℝ} (hω : 0 < ω) (hslow : 3 * (r * l) ≤ ω) :
                                                    band r l ω ≤ 1 / 12

                                                    The slowness condition 3 r λ ≤ ω is exactly band ≤ 1/12.

                                                    theorem CSD.RecordLayer.meanRate_mul_emitEnd {r l ω : ℝ} (hr : 0 < r) (hl : l ≤ 1) :
                                                    meanRate r l * emitEnd r l ω = 1 / 3 + band r l ω
                                                    theorem CSD.RecordLayer.meanRate_mul_returnEnd {r l ω : ℝ} (hr : 0 < r) (hl : l ≤ 1) :
                                                    meanRate r l * returnEnd r l ω = 2 / 3 + band r l ω
                                                    theorem CSD.RecordLayer.meanRate_mul_senderWindow {r l ω : ℝ} (hr : 0 < r) (hl : l ≤ 1) :
                                                    meanRate r l * senderWindow r l ω = 1 / 6 - 2 * band r l ω
                                                    theorem CSD.RecordLayer.senderWindow_nonneg {r l ω : ℝ} (hr : 0 < r) (hl : l ≤ 1) (hω : 0 < ω) (hslow : 3 * (r * l) ≤ ω) :
                                                    0 ≤ senderWindow r l ω
                                                    theorem CSD.RecordLayer.emitStart_le_emitEnd {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) :
                                                    theorem CSD.RecordLayer.returnStart_le_returnEnd {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) :
                                                    theorem CSD.RecordLayer.emitEnd_add_window_lt_returnEnd {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) (hslow : 3 * (r * l) ≤ ω) :
                                                    emitEnd r l ω + senderWindow r l ω < returnEnd r l ω

                                                    The emission record is written before the return record.

                                                    theorem CSD.RecordLayer.senderDrift_mem_emit {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) {t : ℝ} (ht₁ : emitEnd r l ω ≤ t) (ht₂ : t ≤ emitEnd r l ω + senderWindow r l ω) :
                                                    1 / 3 ≤ senderDrift r l ω t ∧ senderDrift r l ω t ≤ 1 / 2

                                                    Through the emission window the sender's displacement lies in [1/3, 1/2].

                                                    theorem CSD.RecordLayer.senderDrift_mem_return {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) {t : ℝ} (ht₁ : returnEnd r l ω ≤ t) (ht₂ : t ≤ returnEnd r l ω + senderWindow r l ω) :
                                                    2 / 3 ≤ senderDrift r l ω t ∧ senderDrift r l ω t ≤ 5 / 6

                                                    Through the return window the sender's displacement lies in [2/3, 5/6].

                                                    The readouts #

                                                    noncomputable def CSD.RecordLayer.thirds (r : ℝ) :
                                                    Fin 3

                                                    A real number read in thirds: 0 on (−∞, 1/3], 1 on (1/3, 2/3], 2 above.

                                                    Equations
                                                    Instances For
                                                      theorem CSD.RecordLayer.thirds_eq_zero {r : ℝ} (h : r ≤ 1 / 3) :
                                                      thirds r = 0
                                                      theorem CSD.RecordLayer.thirds_eq_one {r : ℝ} (h1 : 1 / 3 < r) (h2 : r ≤ 2 / 3) :
                                                      thirds r = 1
                                                      theorem CSD.RecordLayer.thirds_eq_two {r : ℝ} (h : 2 / 3 < r) :
                                                      thirds r = 2
                                                      noncomputable def CSD.RecordLayer.senderRead (x : EchoArena) :
                                                      Fin 3

                                                      Pointer A read in thirds: 0 ready, 1 emitted, 2 returned.

                                                      Equations
                                                      Instances For

                                                        Pointer B read on #194's display arc.

                                                        Equations
                                                        Instances For

                                                          Reading the pointers after a shift from the ready arc #

                                                          theorem CSD.RecordLayer.rep_pshift_of_ready {q : LF4.KTorus} (hq : q ∈ readyArc 2) {D : ℝ} (h0 : 0 ≤ D) (h1 : D ≤ 5 / 6) :
                                                          rep (pshift D q).1 = rep q.1 + D

                                                          A shift by D ∈ [0, 5/6] of a ready pointer keeps its representative at rep q + D.

                                                          theorem CSD.RecordLayer.thirds_pshift_ready_zero {q : LF4.KTorus} (hq : q ∈ readyArc 2) {D : ℝ} (h0 : 0 ≤ D) (h1 : D ≤ 1 / 6) :
                                                          thirds (rep (pshift D q).1) = 0
                                                          theorem CSD.RecordLayer.thirds_pshift_ready_one {q : LF4.KTorus} (hq : q ∈ readyArc 2) {D : ℝ} (h0 : 1 / 3 ≤ D) (h1 : D ≤ 1 / 2) :
                                                          thirds (rep (pshift D q).1) = 1
                                                          theorem CSD.RecordLayer.thirds_pshift_ready_two {q : LF4.KTorus} (hq : q ∈ readyArc 2) {D : ℝ} (h0 : 2 / 3 ≤ D) (h1 : D ≤ 5 / 6) :
                                                          thirds (rep (pshift D q).1) = 2
                                                          theorem CSD.RecordLayer.thirds_pshift_ready_ne_two {q : LF4.KTorus} (hq : q ∈ readyArc 2) {D : ℝ} (h0 : 0 ≤ D) (h1 : D ≤ 1 / 2) :
                                                          thirds (rep (pshift D q).1) ≠ 2
                                                          theorem CSD.RecordLayer.pshift_pointerDrift_notMem_displayArc {q : LF4.KTorus} (hq : q ∈ readyArc 2) {κ ω : ℝ} (hκ : 0 < κ) (hω : 0 < ω) {t : ℝ} (ht0 : 0 ≤ t) (ht : t < writeStart κ) :

                                                          #194's display-arc test, for a bare pointer: before the write interval the drifted pointer is not displayed.

                                                          theorem CSD.RecordLayer.pshift_pointerDrift_mem_displayArc {q : LF4.KTorus} (hq : q ∈ readyArc 2) {κ ω : ℝ} (hκ : 0 < κ) (hω : 0 < ω) {t : ℝ} (ht₁ : writeEnd κ ω ≤ t) (ht₂ : t ≤ writeEnd κ ω + retention κ ω) :

                                                          #194's display-arc test, for a bare pointer: through the window the drifted pointer is displayed.

                                                          The three writes #

                                                          theorem CSD.RecordLayer.sender_before_emit {J ħ : ℝ} (A B : PointerCoupling) {qA : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (qB : LF4.KTorus) {t : ℝ} (ht0 : 0 ≤ t) (ht : t < emitStart (senderRate A ħ qA)) :
                                                          senderRead (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)) = 0

                                                          ★★ Before the emission write pointer A reads 0.

                                                          theorem CSD.RecordLayer.sender_emitted {J ħ : ℝ} (A B : PointerCoupling) {qA : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (qB : LF4.KTorus) {t : ℝ} (ht₁ : emitEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) ≤ t) (ht₂ : t ≤ emitEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) + senderWindow (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB)) :
                                                          senderRead (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)) = 1

                                                          ★★ Through the emission window pointer A reads 1.

                                                          theorem CSD.RecordLayer.sender_before_return {J ħ : ℝ} (A B : PointerCoupling) {qA : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (qB : LF4.KTorus) {t : ℝ} (ht0 : 0 ≤ t) (ht : t < returnStart (senderRate A ħ qA)) :
                                                          senderRead (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)) ≠ 2

                                                          ★★ Before the return write pointer A does not read 2.

                                                          theorem CSD.RecordLayer.sender_returned {J ħ : ℝ} (A B : PointerCoupling) {qA : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (qB : LF4.KTorus) {t : ℝ} (ht₁ : returnEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) ≤ t) (ht₂ : t ≤ returnEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) + senderWindow (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB)) :
                                                          senderRead (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)) = 2

                                                          ★★ Through the return window pointer A reads 2.

                                                          theorem CSD.RecordLayer.receiver_before {J ħ : ℝ} (A B : PointerCoupling) {qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (qA : LF4.KTorus) (hqB : qB ∈ readyArc 2) (hκ : 0 < receiverDrift A B J ħ qA qB) {t : ℝ} (ht0 : 0 ≤ t) (ht : t < writeStart (receiverDrift A B J ħ qA qB)) :

                                                          ★★ Before the reception write pointer B is not displayed.

                                                          theorem CSD.RecordLayer.receiver_received {J ħ : ℝ} (A B : PointerCoupling) {qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (qA : LF4.KTorus) (hqB : qB ∈ readyArc 2) (hκ : 0 < receiverDrift A B J ħ qA qB) {t : ℝ} (ht₁ : writeEnd (receiverDrift A B J ħ qA qB) (echoRate A B J ħ qA qB) ≤ t) (ht₂ : t ≤ writeEnd (receiverDrift A B J ħ qA qB) (echoRate A B J ħ qA qB) + retention (receiverDrift A B J ħ qA qB) (echoRate A B J ħ qA qB)) :

                                                          ★★ Through the reception window pointer B is displayed.

                                                          noncomputable def CSD.RecordLayer.emissionRecord {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hqB : qB ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (hslow : 3 * (senderRate A ħ qA * echoLoss A B J qA qB) ≤ echoRate A B J ħ qA qB) :

                                                          ★★★ The emission record: pointer A's first arc, written by the carrier as it leaves — an ActualOccurrence at site {A} from the start 0, value 1, write interval [1/(6 r_A), emitEnd], window senderWindow.

                                                          Equations
                                                          • One or more equations did not get rendered due to their size.
                                                          Instances For
                                                            noncomputable def CSD.RecordLayer.receptionRecord {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hqB : qB ∈ readyArc 2) (hκ : 0 < receiverDrift A B J ħ qA qB) (hslow : 3 * receiverDrift A B J ħ qA qB ≤ 2 * echoRate A B J ħ qA qB) :

                                                            ★★★ The reception record: pointer B's arc, #194's write on the echo arena — an ActualOccurrence at site {B}, value true, write interval [1/(6κ_B), 2/(3κ_B) + 1/(2ω)], window 2/(3κ_B) − 1/ω.

                                                            Equations
                                                            • One or more equations did not get rendered due to their size.
                                                            Instances For
                                                              noncomputable def CSD.RecordLayer.returnRecord {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hqB : qB ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (hslow : 3 * (senderRate A ħ qA * echoLoss A B J qA qB) ≤ echoRate A B J ħ qA qB) :

                                                              ★★★ The return record: pointer A's second arc, written by the carrier as it comes back — an ActualOccurrence at site {A}, value 2, write interval [1/(2 r_A), returnEnd], window senderWindow. The final reading comes from a register locally accessible at A.

                                                              Equations
                                                              • One or more equations did not get rendered due to their size.
                                                              Instances For
                                                                theorem CSD.RecordLayer.emission_return_disjoint {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hqB : qB ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (hslow : 3 * (senderRate A ħ qA * echoLoss A B J qA qB) ≤ echoRate A B J ħ qA qB) :
                                                                (emissionRecord A B hJ hħ hqA hqB hr hslow).value ≠ (returnRecord A B hJ hħ hqA hqB hr hslow).value ∧ (emissionRecord A B hJ hħ hqA hqB hr hslow).writeEnd + (emissionRecord A B hJ hħ hqA hqB hr hslow).window < (returnRecord A B hJ hħ hqA hqB hr hslow).writeEnd ∧ ∀ (t : ℝ), (emissionRecord A B hJ hħ hqA hqB hr hslow).writeEnd ≤ t → t ≤ (emissionRecord A B hJ hħ hqA hqB hr hslow).writeEnd + (emissionRecord A B hJ hħ hqA hqB hr hslow).window → (returnRecord A B hJ hħ hqA hqB hr hslow).history t ≠ (returnRecord A B hJ hħ hqA hqB hr hslow).value

                                                                ★★ The return arc is disjoint from the emission arc, and the return record is written after the emission record: the two values differ, the emission window ends before the return write ends, and through the emission window the register does not read 2.

                                                                theorem CSD.RecordLayer.sender_returns {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) (hr : 0 < senderRate A ħ qA) (hslow : 3 * (senderRate A ħ qA * echoLoss A B J qA qB) ≤ echoRate A B J ħ qA qB) :
                                                                ∃ (t : ℝ), returnEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) + senderWindow (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) < t ∧ (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)).2.1 = qA

                                                                ★★ The sender's retention is finite: after the return window there is a time at which pointer A is back exactly where message 0 left it — the carrier keeps shuttling and the pointer completes a turn.

                                                                theorem CSD.RecordLayer.receiver_returns {J ħ : ℝ} (A B : PointerCoupling) (hJ : 0 < J) (hħ : 0 < ħ) (qA qB : LF4.KTorus) (hκ : 0 < receiverDrift A B J ħ qA qB) :
                                                                ∃ (t : ℝ), writeEnd (receiverDrift A B J ħ qA qB) (echoRate A B J ħ qA qB) + retention (receiverDrift A B J ħ qA qB) (echoRate A B J ħ qA qB) < t ∧ (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)).2.2 = qB

                                                                ★★ The receiver's retention is finite (#194's message_one_returns on the echo arena).

                                                                The package #

                                                                theorem CSD.RecordLayer.autonomous_echo {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hqB : qB ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (hκ : 0 < receiverDrift A B J ħ qA qB) (hslowA : 3 * (senderRate A ħ qA * echoLoss A B J qA qB) ≤ echoRate A B J ħ qA qB) (hslowB : 3 * receiverDrift A B J ħ qA qB ≤ 2 * echoRate A B J ħ qA qB) :
                                                                (∀ (s t u : SigmaLayer.OnticTime), echoEvolve J ħ A B t u ∘ echoEvolve J ħ A B s t = echoEvolve J ħ A B s u) ∧ (∀ (s t a : SigmaLayer.OnticTime), echoEvolve J ħ A B (s + a) (t + a) = echoEvolve J ħ A B s t) ∧ (∀ (s t : SigmaLayer.OnticTime) (p₀ : CV.FieldArena 2 2), MeasureTheory.MeasurePreserving (echoEvolve J ħ A B s t) ((Matrix.UnitaryGroup.fsMeasure p₀).prod MeasureTheory.volume) ((Matrix.UnitaryGroup.fsMeasure p₀).prod MeasureTheory.volume)) ∧ (∀ (t : ℝ) (x : EchoArena), echoEnergy J A B (echoFlow J ħ A B t x) = echoEnergy J A B x) ∧ (∀ (t : ℝ) (x : EchoArena), (echoFlow J ħ A B t x).2.1.2 = x.2.1.2 ∧ (echoFlow J ħ A B t x).2.2.2 = x.2.2.2) ∧ (∀ (x : EchoArena) (t : ℝ), HasDerivAt (fun (t : ℝ) => echoAmountA J ħ A B t x) (rateAt A.g ħ ⋯ x.2.1.2 * CV.arenaObs CV.occA (echoFlow J ħ A B t x).1) t) ∧ (∀ (x : EchoArena) (t : ℝ), HasDerivAt (fun (t : ℝ) => echoAmountB J ħ A B t x) (rateAt B.g ħ ⋯ x.2.2.2 * CV.arenaObs CV.occB (echoFlow J ħ A B t x).1) t) ∧ (∀ (t : ℝ), echoFlow J ħ A B t (CV.msgPoint 0, qA, qB) = (CV.msgPoint 0, qA, qB)) ∧ (echoFlow J ħ A B (CV.detunedRoundTrip J ħ (echoDetuning A B qA qB)) (CV.msgPoint 1, qA, qB)).1 = CV.msgPoint 1 ∧ (emissionRecord A B hJ hħ hqA hqB hr hslowA).site = {0} ∧ (receptionRecord A B hJ hħ hqA hqB hκ hslowB).site = {1} ∧ (returnRecord A B hJ hħ hqA hqB hr hslowA).site = {0} ∧ (emissionRecord A B hJ hħ hqA hqB hr hslowA).prep = (CV.msgPoint 1, qA, qB) ∧ (receptionRecord A B hJ hħ hqA hqB hκ hslowB).prep = (CV.msgPoint 1, qA, qB) ∧ (returnRecord A B hJ hħ hqA hqB hr hslowA).prep = (CV.msgPoint 1, qA, qB) ∧ (emissionRecord A B hJ hħ hqA hqB hr hslowA).value ≠ (returnRecord A B hJ hħ hqA hqB hr hslowA).value ∧ (emissionRecord A B hJ hħ hqA hqB hr hslowA).writeEnd + (emissionRecord A B hJ hħ hqA hqB hr hslowA).window < (returnRecord A B hJ hħ hqA hqB hr hslowA).writeEnd ∧ (∃ (t : ℝ), (returnRecord A B hJ hħ hqA hqB hr hslowA).writeEnd + (returnRecord A B hJ hħ hqA hqB hr hslowA).window < t ∧ (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)).2.1 = qA) ∧ ∃ (t : ℝ), (receptionRecord A B hJ hħ hqA hqB hκ hslowB).writeEnd + (receptionRecord A B hJ hħ hqA hqB hκ hslowB).window < t ∧ (echoFlow J ħ A B t (CV.msgPoint 1, qA, qB)).2.2 = qB

                                                                ★★★ The autonomous echo. On FieldArena 2 2 × (T² × T²) with the dynamics of the joint Hamiltonian ⟨p, J X p⟩ + g_A n_A f_A(θ₂ᴬ) + g_B n_B f_B(θ₂ᴮ): the two-time law holds and the propagator is autonomous; Liouville measure is preserved; the joint energy and both θ₂ are conserved; each pointer turns at its own rate times the occupancy of its own station; message 0 fixes the whole arena point; for message 1 the carrier is back at A at the detuned round trip; the emission, the reception and the return are three ActualOccurrences on the one arena at sites {A}, {B}, {A} from the one preparation; the return arc is disjoint from the emission arc and written after it; and all three retentions are finite.