Documentation

CsdLean4.RecordLayer.EchoRadar

Round-trip radar from the sender's records #

Category: 7-SigmaLayer (the record layer). BACKLOG #200 (out of #39; the author's third operational-geometry brief, §1's proof target).

#197 read a radar coordinate off one clock at A and a detection at B: a one-way flight. Here both radar timestamps are readings of A's clock, taken at A's two records — the emission arc and the return arc of the one register at A that the carrier itself writes (#199). The arena is #199's echo arena with #185's record clock alongside; the ideal readings are (0, 2τ_hop), the round trip, whose radar separation is τ_hop (radarSep_roundTrip). Every contribution to the error is derived for the witness; the two input bounds are labelled.

Honest scope #

References: specs/BACKLOG.md #200, #199, #197, #187, #185, #39; RecordLayer/EchoArena.lean, RecordLayer/RadarDetector.lean (transferError, abs_detunedHopTime_sub_hopTime_le), CV/RadarCoordinates.lean (RadarReadings, ofDuration, radarSep_roundTrip, abs_radarTime_sub_le), RecordLayer/RecordClock.lean (tickReading, abs_tickReading_sub_lt, tickCount_mono), RecordLayer/CoupledReception.lean (the clocked-arena pattern).

Both transfers #

theorem CSD.RecordLayer.abs_detunedRoundTrip_sub_roundTrip_le {J ħ : ℝ} (hJ : 0 < J) (hħ : 0 < ħ) (Δ : ℝ) :

★ Outward transfer and return transfer: the detuned round trip πħ/Ω is within 2 transferError of 2τ_hop.

The echo arena with the record clock #

@[reducible, inline]

The echo arena with the record clock of #185.

Equations
Instances For

    The joint two-time propagator: the echo dynamics and the clock.

    Equations
    Instances For
      theorem CSD.RecordLayer.echoClockedEvolve_comp {K : ℕ} (J ħ : ℝ) (A B : PointerCoupling) (T : ℝ) (s t u : SigmaLayer.OnticTime) :
      echoClockedEvolve J ħ A B T t u ∘ echoClockedEvolve J ħ A B T s t = echoClockedEvolve J ħ A B T s u

      The two-time law on the clocked echo arena.

      noncomputable def CSD.RecordLayer.echoClockReading {K : ℕ} (x : EchoClockedArena K) :

      The arena clock's reading.

      Equations
      Instances For

        A's two writes on the clocked arena #

        noncomputable def CSD.RecordLayer.clockedEmissionRecord {K : ℕ} {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) {c : ClockArena K} (hc : c ∈ ClockReady K) (T : ℝ) :

        ★★ The emission record on the clocked arena (#191): A's first arc, the clock ready alongside.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For
          noncomputable def CSD.RecordLayer.clockedReturnRecord {K : ℕ} {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) {c : ClockArena K} (hc : c ∈ ClockReady K) (T : ℝ) :

          ★★ The return record on the clocked arena (#191): A's second arc.

          Equations
          • One or more equations did not get rendered due to their size.
          Instances For
            theorem CSD.RecordLayer.emissionEvent_region {K : ℕ} {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) {c : ClockArena K} (hc : c ∈ ClockReady K) (T : ℝ) :
            ((clockedEmissionRecord A B hJ hħ hqA hqB hr hslow hc T).toRecordEvent echoClockReading).region = {0}
            theorem CSD.RecordLayer.emissionEvent_time {K : ℕ} {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) {c : ClockArena K} (hc : c ∈ ClockReady K) (T : ℝ) :
            ((clockedEmissionRecord A B hJ hħ hqA hqB hr hslow hc T).toRecordEvent echoClockReading).time = tickCount (clockEvolve T 0 (emitEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB)) c)

            The emission event's period is the clock's tick count at the completion of the emission write.

            theorem CSD.RecordLayer.returnEvent_region {K : ℕ} {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) {c : ClockArena K} (hc : c ∈ ClockReady K) (T : ℝ) :
            ((clockedReturnRecord A B hJ hħ hqA hqB hr hslow hc T).toRecordEvent echoClockReading).region = {0}
            theorem CSD.RecordLayer.returnEvent_time {K : ℕ} {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) {c : ClockArena K} (hc : c ∈ ClockReady K) (T : ℝ) :
            ((clockedReturnRecord A B hJ hħ hqA hqB hr hslow hc T).toRecordEvent echoClockReading).time = tickCount (clockEvolve T 0 (returnEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB)) c)

            The return event's period is the clock's tick count at the completion of the return write.

            theorem CSD.RecordLayer.emitEnd_nonneg {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) :
            0 ≤ emitEnd r l ω
            theorem CSD.RecordLayer.returnEnd_nonneg {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) :
            0 ≤ returnEnd r l ω
            theorem CSD.RecordLayer.emitEnd_le_returnEnd {r l ω : ℝ} (hr : 0 < r) (hl0 : 0 ≤ l) (hl : l ≤ 1) (hω : 0 < ω) (hslow : 3 * (r * l) ≤ ω) :
            emitEnd r l ω ≤ returnEnd r l ω

            The emission write completes before the return write.

            theorem CSD.RecordLayer.emission_causalPrecedes_return {K : ℕ} {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) (hK : 0 < K) {c : ClockArena K} (hc : c ∈ ClockReady K) {T : ℝ} (hT : 0 < T) :

            ★ The emission precedes the return on the hop graph: same site, the later clock label.

            The readings, the budget and the bound #

            noncomputable def CSD.RecordLayer.echoReturnDelay (A B : PointerCoupling) (J ħ : ℝ) (qA qB : LF4.KTorus) :

            The detector response of the return write: its completion minus the detuned round trip.

            Equations
            • One or more equations did not get rendered due to their size.
            Instances For
              theorem CSD.RecordLayer.echoReturnDelay_eq (A B : PointerCoupling) (J ħ : ℝ) (qA qB : LF4.KTorus) :
              echoReturnDelay A B J ħ qA qB = (2 / 3 + senderRate A ħ qA * echoLoss A B J qA qB / (4 * echoRate A B J ħ qA qB)) / (senderRate A ħ qA * (1 - echoLoss A B J qA qB / 2)) - Real.pi * ħ / CV.rabiFreq J (echoDetuning A B qA qB)

              The return delay, explicit in the preparation: (2/3 + r_A λ/(4ω))/(r_A (1 − λ/2)) − πħ/Ω'.

              noncomputable def CSD.RecordLayer.echoRadarBudget (A B : PointerCoupling) (J ħ : ℝ) (qA qB : LF4.KTorus) (T : ℝ) :

              The error budget of the round trip: clock resolution T, the retention window, the emission write's response emitEnd, the return write's response |echoReturnDelay|, and the two transfers 2 transferError.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For
                noncomputable def CSD.RecordLayer.echoReadings {K : ℕ} (hK : 0 < K) {T : ℝ} (hT : 0 < T) {c : ClockArena K} (hc : c ∈ ClockReady K) {t₁ t₂ : ℝ} (h₁₂ : t₁ ≤ t₂) :

                The measured readings: A's clock at the time t₁ of the emission reading and at the time t₂ of the return reading.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For
                  theorem CSD.RecordLayer.echoReadings_emit {K : ℕ} (hK : 0 < K) {T : ℝ} (hT : 0 < T) {c : ClockArena K} (hc : c ∈ ClockReady K) {t₁ t₂ : ℝ} (h₁₂ : t₁ ≤ t₂) :
                  (echoReadings hK hT hc h₁₂).emit = tickReading T (clockEvolve T 0 t₁ c)
                  theorem CSD.RecordLayer.echoReadings_ret {K : ℕ} (hK : 0 < K) {T : ℝ} (hT : 0 < T) {c : ClockArena K} (hc : c ∈ ClockReady K) {t₁ t₂ : ℝ} (h₁₂ : t₁ ≤ t₂) :
                  (echoReadings hK hT hc h₁₂).ret = tickReading T (clockEvolve T 0 t₂ c)
                  theorem CSD.RecordLayer.echoReadings_eq_labels {K : ℕ} {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) (hK : 0 < K) {T : ℝ} (hT : 0 < T) {c : ClockArena K} (hc : c ∈ ClockReady K) :
                  (echoReadings hK hT hc ⋯).emit = ↑((clockedEmissionRecord A B hJ hħ hqA hqB hr hslow hc T).toRecordEvent echoClockReading).time * T ∧ (echoReadings hK hT hc ⋯).ret = ↑((clockedReturnRecord A B hJ hħ hqA hqB hr hslow hc T).toRecordEvent echoClockReading).time * T

                  ★★ Taken at the completions of the two writes, the radar timestamps are T times the clock labels of A's two record events.

                  noncomputable def CSD.RecordLayer.idealEchoReadings {J ħ : ℝ} (hJ : 0 < J) (hħ : 0 < ħ) :

                  The ideal round-trip readings: emission at 0, return at 2τ_hop.

                  Equations
                  Instances For
                    theorem CSD.RecordLayer.idealEchoReadings_emit {J ħ : ℝ} (hJ : 0 < J) (hħ : 0 < ħ) :
                    theorem CSD.RecordLayer.idealEchoReadings_ret {J ħ : ℝ} (hJ : 0 < J) (hħ : 0 < ħ) :
                    theorem CSD.RecordLayer.idealEchoReadings_radarSep {J ħ : ℝ} (hJ : 0 < J) (hħ : 0 < ħ) :

                    The ideal radar separation of the round trip is the hop time.

                    theorem CSD.RecordLayer.echoRadarBudget_nonneg {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hr : 0 < senderRate A ħ qA) (hslow : 3 * (senderRate A ħ qA * echoLoss A B J qA qB) ≤ echoRate A B J ħ qA qB) {T : ℝ} (hT : 0 < T) :
                    0 ≤ echoRadarBudget A B J ħ qA qB T
                    theorem CSD.RecordLayer.abs_echoReadings_emit_sub_le {K : ℕ} {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hr : 0 < senderRate A ħ qA) (hK : 0 < K) {T : ℝ} (hT : 0 < T) {c : ClockArena K} (hc : c ∈ ClockReady K) {t₁ t₂ : ℝ} (h₁₂ : t₁ ≤ t₂) (ht₁K : t₁ ≤ ↑K * T) (hemit : emitEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) ≤ t₁ ∧ 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)) :
                    |(echoReadings hK hT hc h₁₂).emit - 0| ≤ echoRadarBudget A B J ħ qA qB T

                    ★★ The emission reading is within the budget of 0. Clock resolution (derived), the emission write's completion (derived), the retention window (input: the reading is taken while the emission record displays).

                    theorem CSD.RecordLayer.abs_echoReadings_ret_sub_le {K : ℕ} {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hr : 0 < senderRate A ħ qA) (hK : 0 < K) {T : ℝ} (hT : 0 < T) {c : ClockArena K} (hc : c ∈ ClockReady K) {t₁ t₂ : ℝ} (h₁₂ : t₁ ≤ t₂) (ht₂K : t₂ ≤ ↑K * T) (hret : returnEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) ≤ t₂ ∧ 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)) :
                    |(echoReadings hK hT hc h₁₂).ret - CV.roundTrip J ħ| ≤ echoRadarBudget A B J ħ qA qB T

                    ★★ The return reading is within the budget of 2τ_hop. Clock resolution (derived), the retention window (input: the reading is taken while the return record displays), the return write's response (derived), the two transfers (derived).

                    theorem CSD.RecordLayer.radar_from_sender_records {K : ℕ} {J ħ : ℝ} (A B : PointerCoupling) {qA qB : LF4.KTorus} (hJ : 0 < J) (hħ : 0 < ħ) (hqA : qA ∈ readyArc 2) (hr : 0 < senderRate A ħ qA) (hslow : 3 * (senderRate A ħ qA * echoLoss A B J qA qB) ≤ echoRate A B J ħ qA qB) (hK : 0 < K) {T : ℝ} (hT : 0 < T) {c : ClockArena K} (hc : c ∈ ClockReady K) {t₁ t₂ : ℝ} (ht₁K : t₁ ≤ ↑K * T) (ht₂K : t₂ ≤ ↑K * T) (hemit : emitEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) ≤ t₁ ∧ 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)) (hret : returnEnd (senderRate A ħ qA) (echoLoss A B J qA qB) (echoRate A B J ħ qA qB) ≤ t₂ ∧ 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)) {c₀ : ℝ} (hc₀ : 0 ≤ c₀) :
                    ∃ (h₁₂ : t₁ ≤ t₂), senderRead (echoFlow J ħ A B t₁ (CV.msgPoint 1, qA, qB)) = 1 ∧ senderRead (echoFlow J ħ A B t₂ (CV.msgPoint 1, qA, qB)) = 2 ∧ (idealEchoReadings hJ hħ).radarSep = CV.hopTime J ħ ∧ |(echoReadings hK hT hc h₁₂).radarTime - (idealEchoReadings hJ hħ).radarTime| ≤ echoRadarBudget A B J ħ qA qB T ∧ |(echoReadings hK hT hc h₁₂).radarSep - (idealEchoReadings hJ hħ).radarSep| ≤ echoRadarBudget A B J ħ qA qB T ∧ |(echoReadings hK hT hc h₁₂).radarDist c₀ - (idealEchoReadings hJ hħ).radarDist c₀| ≤ c₀ * echoRadarBudget A B J ħ qA qB T

                    ★★★ Round-trip radar from the sender's records. Both timestamps are readings of A's clock, taken while A's emission record (value 1) and A's return record (value 2) display; against the ideal round-trip readings (0, 2τ_hop) — whose radar separation is τ_hop — the measured radar time, separation and distance are within the budget `T + senderWindow + emitEnd + |echoReturnDelay|

                    • 2 transferError(timesc₀` for the distance). A radar separation read entirely at one station.